author | chegar |
Thu, 17 Oct 2019 20:54:25 +0100 | |
branch | datagramsocketimpl-branch |
changeset 58679 | 9c3209ff7550 |
parent 58678 | 9cf78a70fa4f |
parent 55653 | 3243c42d737d |
permissions | -rw-r--r-- |
1 | 1 |
/* |
55490
3f3dc00a69a5
8191278: MappedByteBuffer bulk access memory failures are not handled gracefully
jcm
parents:
54654
diff
changeset
|
2 |
* Copyright (c) 1999, 2019, Oracle and/or its affiliates. All rights reserved. |
1 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
7 |
* published by the Free Software Foundation. |
|
8 |
* |
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
13 |
* accompanied this code). |
|
14 |
* |
|
15 |
* You should have received a copy of the GNU General Public License version |
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5403
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5403
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5403
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
// no precompiled headers |
47765
b7c7428eaab9
8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents:
47216
diff
changeset
|
26 |
#include "jvm.h" |
14626
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
13963
diff
changeset
|
27 |
#include "asm/macroAssembler.hpp" |
7397 | 28 |
#include "classfile/classLoader.hpp" |
29 |
#include "classfile/systemDictionary.hpp" |
|
30 |
#include "classfile/vmSymbols.hpp" |
|
34667 | 31 |
#include "code/codeCache.hpp" |
7397 | 32 |
#include "code/icBuffer.hpp" |
33 |
#include "code/vtableStubs.hpp" |
|
34 |
#include "interpreter/interpreter.hpp" |
|
49615
1b1de4b263c8
8200232: Build failures after JDK-8200106 (Move NoSafepointVerifier out from gcLocker.hpp)
shade
parents:
49449
diff
changeset
|
35 |
#include "logging/log.hpp" |
7397 | 36 |
#include "memory/allocation.inline.hpp" |
37 |
#include "os_share_linux.hpp" |
|
38 |
#include "prims/jniFastGetField.hpp" |
|
39 |
#include "prims/jvm_misc.hpp" |
|
40 |
#include "runtime/arguments.hpp" |
|
41 |
#include "runtime/extendedPC.hpp" |
|
42 |
#include "runtime/frame.inline.hpp" |
|
49449
ef5d5d343e2a
8199263: Split interfaceSupport.hpp to not require including .inline.hpp files
coleenp
parents:
49407
diff
changeset
|
43 |
#include "runtime/interfaceSupport.inline.hpp" |
7397 | 44 |
#include "runtime/java.hpp" |
45 |
#include "runtime/javaCalls.hpp" |
|
46 |
#include "runtime/mutexLocker.hpp" |
|
47 |
#include "runtime/osThread.hpp" |
|
48 |
#include "runtime/sharedRuntime.hpp" |
|
49 |
#include "runtime/stubRoutines.hpp" |
|
14583
d70ee55535f4
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
13963
diff
changeset
|
50 |
#include "runtime/thread.inline.hpp" |
7397 | 51 |
#include "runtime/timer.hpp" |
22542
62913331d480
8032827: NMT: missing virtual memory tagging in os::workaround_expand_exec_shield_cs_limit()
zgu
parents:
22234
diff
changeset
|
52 |
#include "services/memTracker.hpp" |
46625 | 53 |
#include "utilities/align.hpp" |
49653
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49615
diff
changeset
|
54 |
#include "utilities/debug.hpp" |
7397 | 55 |
#include "utilities/events.hpp" |
56 |
#include "utilities/vmError.hpp" |
|
1 | 57 |
|
58 |
// put OS-includes here |
|
59 |
# include <sys/types.h> |
|
60 |
# include <sys/mman.h> |
|
61 |
# include <pthread.h> |
|
62 |
# include <signal.h> |
|
63 |
# include <errno.h> |
|
64 |
# include <dlfcn.h> |
|
65 |
# include <stdlib.h> |
|
66 |
# include <stdio.h> |
|
67 |
# include <unistd.h> |
|
68 |
# include <sys/resource.h> |
|
69 |
# include <pthread.h> |
|
70 |
# include <sys/stat.h> |
|
71 |
# include <sys/time.h> |
|
72 |
# include <sys/utsname.h> |
|
73 |
# include <sys/socket.h> |
|
74 |
# include <sys/wait.h> |
|
75 |
# include <pwd.h> |
|
76 |
# include <poll.h> |
|
77 |
# include <ucontext.h> |
|
46452 | 78 |
#ifndef AMD64 |
1 | 79 |
# include <fpu_control.h> |
46452 | 80 |
#endif |
1 | 81 |
|
82 |
#ifdef AMD64 |
|
83 |
#define REG_SP REG_RSP |
|
84 |
#define REG_PC REG_RIP |
|
85 |
#define REG_FP REG_RBP |
|
86 |
#define SPELL_REG_SP "rsp" |
|
87 |
#define SPELL_REG_FP "rbp" |
|
88 |
#else |
|
89 |
#define REG_SP REG_UESP |
|
90 |
#define REG_PC REG_EIP |
|
91 |
#define REG_FP REG_EBP |
|
92 |
#define SPELL_REG_SP "esp" |
|
93 |
#define SPELL_REG_FP "ebp" |
|
94 |
#endif // AMD64 |
|
95 |
||
96 |
address os::current_stack_pointer() { |
|
223
5c3b023117d9
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
1
diff
changeset
|
97 |
#ifdef SPARC_WORKS |
51050
96ea37459ca7
8207011: Remove uses of the register storage class specifier
mikael
parents:
50734
diff
changeset
|
98 |
void *esp; |
50734 | 99 |
__asm__("mov %%" SPELL_REG_SP ", %0":"=r"(esp)); |
223
5c3b023117d9
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
1
diff
changeset
|
100 |
return (address) ((char*)esp + sizeof(long)*2); |
17880 | 101 |
#elif defined(__clang__) |
51050
96ea37459ca7
8207011: Remove uses of the register storage class specifier
mikael
parents:
50734
diff
changeset
|
102 |
void* esp; |
50734 | 103 |
__asm__ __volatile__ ("mov %%" SPELL_REG_SP ", %0":"=r"(esp):); |
17880 | 104 |
return (address) esp; |
223
5c3b023117d9
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
1
diff
changeset
|
105 |
#else |
1 | 106 |
register void *esp __asm__ (SPELL_REG_SP); |
107 |
return (address) esp; |
|
223
5c3b023117d9
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
1
diff
changeset
|
108 |
#endif |
1 | 109 |
} |
110 |
||
111 |
char* os::non_memory_address_word() { |
|
112 |
// Must never look like an address returned by reserve_memory, |
|
113 |
// even in its subfields (as defined by the CPU immediate fields, |
|
114 |
// if the CPU splits constants across multiple instructions). |
|
115 |
||
116 |
return (char*) -1; |
|
117 |
} |
|
118 |
||
35077
8b86440d3bf1
8145114: const-correctness for ucontext_t* reading functions
stuefe
parents:
35071
diff
changeset
|
119 |
address os::Linux::ucontext_get_pc(const ucontext_t * uc) { |
1 | 120 |
return (address)uc->uc_mcontext.gregs[REG_PC]; |
121 |
} |
|
122 |
||
29573
2d800e5d575f
8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents:
27685
diff
changeset
|
123 |
void os::Linux::ucontext_set_pc(ucontext_t * uc, address pc) { |
2d800e5d575f
8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents:
27685
diff
changeset
|
124 |
uc->uc_mcontext.gregs[REG_PC] = (intptr_t)pc; |
2d800e5d575f
8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents:
27685
diff
changeset
|
125 |
} |
2d800e5d575f
8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents:
27685
diff
changeset
|
126 |
|
35077
8b86440d3bf1
8145114: const-correctness for ucontext_t* reading functions
stuefe
parents:
35071
diff
changeset
|
127 |
intptr_t* os::Linux::ucontext_get_sp(const ucontext_t * uc) { |
1 | 128 |
return (intptr_t*)uc->uc_mcontext.gregs[REG_SP]; |
129 |
} |
|
130 |
||
35077
8b86440d3bf1
8145114: const-correctness for ucontext_t* reading functions
stuefe
parents:
35071
diff
changeset
|
131 |
intptr_t* os::Linux::ucontext_get_fp(const ucontext_t * uc) { |
1 | 132 |
return (intptr_t*)uc->uc_mcontext.gregs[REG_FP]; |
133 |
} |
|
134 |
||
135 |
// For Forte Analyzer AsyncGetCallTrace profiling support - thread |
|
136 |
// is currently interrupted by SIGPROF. |
|
137 |
// os::Solaris::fetch_frame_from_ucontext() tries to skip nested signal |
|
138 |
// frames. Currently we don't do that on Linux, so it's the same as |
|
139 |
// os::fetch_frame_from_context(). |
|
35071
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
140 |
// This method is also used for stack overflow signal handling. |
1 | 141 |
ExtendedPC os::Linux::fetch_frame_from_ucontext(Thread* thread, |
35077
8b86440d3bf1
8145114: const-correctness for ucontext_t* reading functions
stuefe
parents:
35071
diff
changeset
|
142 |
const ucontext_t* uc, intptr_t** ret_sp, intptr_t** ret_fp) { |
1 | 143 |
|
144 |
assert(thread != NULL, "just checking"); |
|
145 |
assert(ret_sp != NULL, "just checking"); |
|
146 |
assert(ret_fp != NULL, "just checking"); |
|
147 |
||
148 |
return os::fetch_frame_from_context(uc, ret_sp, ret_fp); |
|
149 |
} |
|
150 |
||
35077
8b86440d3bf1
8145114: const-correctness for ucontext_t* reading functions
stuefe
parents:
35071
diff
changeset
|
151 |
ExtendedPC os::fetch_frame_from_context(const void* ucVoid, |
1 | 152 |
intptr_t** ret_sp, intptr_t** ret_fp) { |
153 |
||
154 |
ExtendedPC epc; |
|
35077
8b86440d3bf1
8145114: const-correctness for ucontext_t* reading functions
stuefe
parents:
35071
diff
changeset
|
155 |
const ucontext_t* uc = (const ucontext_t*)ucVoid; |
1 | 156 |
|
157 |
if (uc != NULL) { |
|
158 |
epc = ExtendedPC(os::Linux::ucontext_get_pc(uc)); |
|
159 |
if (ret_sp) *ret_sp = os::Linux::ucontext_get_sp(uc); |
|
160 |
if (ret_fp) *ret_fp = os::Linux::ucontext_get_fp(uc); |
|
161 |
} else { |
|
162 |
// construct empty ExtendedPC for return value checking |
|
163 |
epc = ExtendedPC(NULL); |
|
164 |
if (ret_sp) *ret_sp = (intptr_t *)NULL; |
|
165 |
if (ret_fp) *ret_fp = (intptr_t *)NULL; |
|
166 |
} |
|
167 |
||
168 |
return epc; |
|
169 |
} |
|
170 |
||
35077
8b86440d3bf1
8145114: const-correctness for ucontext_t* reading functions
stuefe
parents:
35071
diff
changeset
|
171 |
frame os::fetch_frame_from_context(const void* ucVoid) { |
1 | 172 |
intptr_t* sp; |
173 |
intptr_t* fp; |
|
174 |
ExtendedPC epc = fetch_frame_from_context(ucVoid, &sp, &fp); |
|
175 |
return frame(sp, fp, epc.pc()); |
|
176 |
} |
|
177 |
||
35071
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
178 |
frame os::fetch_frame_from_ucontext(Thread* thread, void* ucVoid) { |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
179 |
intptr_t* sp; |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
180 |
intptr_t* fp; |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
181 |
ExtendedPC epc = os::Linux::fetch_frame_from_ucontext(thread, (ucontext_t*)ucVoid, &sp, &fp); |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
182 |
return frame(sp, fp, epc.pc()); |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
183 |
} |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
184 |
|
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
185 |
bool os::Linux::get_frame_at_stack_banging_point(JavaThread* thread, ucontext_t* uc, frame* fr) { |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
186 |
address pc = (address) os::Linux::ucontext_get_pc(uc); |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
187 |
if (Interpreter::contains(pc)) { |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
188 |
// interpreter performs stack banging after the fixed frame header has |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
189 |
// been generated while the compilers perform it before. To maintain |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
190 |
// semantic consistency between interpreted and compiled frames, the |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
191 |
// method returns the Java sender of the current frame. |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
192 |
*fr = os::fetch_frame_from_ucontext(thread, uc); |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
193 |
if (!fr->is_first_java_frame()) { |
41314
f815c3be1f2e
8146546: assert(fr->safe_for_sender(thread)) failed: Safety check
fparain
parents:
41070
diff
changeset
|
194 |
// get_frame_at_stack_banging_point() is only called when we |
f815c3be1f2e
8146546: assert(fr->safe_for_sender(thread)) failed: Safety check
fparain
parents:
41070
diff
changeset
|
195 |
// have well defined stacks so java_sender() calls do not need |
f815c3be1f2e
8146546: assert(fr->safe_for_sender(thread)) failed: Safety check
fparain
parents:
41070
diff
changeset
|
196 |
// to assert safe_for_sender() first. |
35071
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
197 |
*fr = fr->java_sender(); |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
198 |
} |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
199 |
} else { |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
200 |
// more complex code with compiled code |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
201 |
assert(!Interpreter::contains(pc), "Interpreted methods should have been handled above"); |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
202 |
CodeBlob* cb = CodeCache::find_blob(pc); |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
203 |
if (cb == NULL || !cb->is_nmethod() || cb->is_frame_complete_at(pc)) { |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
204 |
// Not sure where the pc points to, fallback to default |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
205 |
// stack overflow handling |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
206 |
return false; |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
207 |
} else { |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
208 |
// in compiled code, the stack banging is performed just after the return pc |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
209 |
// has been pushed on the stack |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
210 |
intptr_t* fp = os::Linux::ucontext_get_fp(uc); |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
211 |
intptr_t* sp = os::Linux::ucontext_get_sp(uc); |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
212 |
*fr = frame(sp + 1, fp, (address)*sp); |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
213 |
if (!fr->is_java_frame()) { |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
214 |
assert(!fr->is_first_frame(), "Safety check"); |
41314
f815c3be1f2e
8146546: assert(fr->safe_for_sender(thread)) failed: Safety check
fparain
parents:
41070
diff
changeset
|
215 |
// See java_sender() comment above. |
35071
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
216 |
*fr = fr->java_sender(); |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
217 |
} |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
218 |
} |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
219 |
} |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
220 |
assert(fr->is_java_frame(), "Safety check"); |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
221 |
return true; |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
222 |
} |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
223 |
|
1 | 224 |
// By default, gcc always save frame pointer (%ebp/%rbp) on stack. It may get |
225 |
// turned off by -fomit-frame-pointer, |
|
226 |
frame os::get_sender_for_C_frame(frame* fr) { |
|
227 |
return frame(fr->sender_sp(), fr->link(), fr->sender_pc()); |
|
228 |
} |
|
229 |
||
230 |
intptr_t* _get_previous_fp() { |
|
223
5c3b023117d9
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
1
diff
changeset
|
231 |
#ifdef SPARC_WORKS |
51050
96ea37459ca7
8207011: Remove uses of the register storage class specifier
mikael
parents:
50734
diff
changeset
|
232 |
intptr_t **ebp; |
50734 | 233 |
__asm__("mov %%" SPELL_REG_FP ", %0":"=r"(ebp)); |
17880 | 234 |
#elif defined(__clang__) |
235 |
intptr_t **ebp; |
|
50734 | 236 |
__asm__ __volatile__ ("mov %%" SPELL_REG_FP ", %0":"=r"(ebp):); |
223
5c3b023117d9
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
1
diff
changeset
|
237 |
#else |
1 | 238 |
register intptr_t **ebp __asm__ (SPELL_REG_FP); |
223
5c3b023117d9
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
1
diff
changeset
|
239 |
#endif |
40384
43db0d4b6e14
8133740: NMT for Linux/x86/x64 and bsd/x64 slowdebug builds includes NativeCallStack::NativeCallStack() frame in backtrace
cjplummer
parents:
40010
diff
changeset
|
240 |
// ebp is for this frame (_get_previous_fp). We want the ebp for the |
43db0d4b6e14
8133740: NMT for Linux/x86/x64 and bsd/x64 slowdebug builds includes NativeCallStack::NativeCallStack() frame in backtrace
cjplummer
parents:
40010
diff
changeset
|
241 |
// caller of os::current_frame*(), so go up two frames. However, for |
43db0d4b6e14
8133740: NMT for Linux/x86/x64 and bsd/x64 slowdebug builds includes NativeCallStack::NativeCallStack() frame in backtrace
cjplummer
parents:
40010
diff
changeset
|
242 |
// optimized builds, _get_previous_fp() will be inlined, so only go |
43db0d4b6e14
8133740: NMT for Linux/x86/x64 and bsd/x64 slowdebug builds includes NativeCallStack::NativeCallStack() frame in backtrace
cjplummer
parents:
40010
diff
changeset
|
243 |
// up 1 frame in that case. |
43db0d4b6e14
8133740: NMT for Linux/x86/x64 and bsd/x64 slowdebug builds includes NativeCallStack::NativeCallStack() frame in backtrace
cjplummer
parents:
40010
diff
changeset
|
244 |
#ifdef _NMT_NOINLINE_ |
43db0d4b6e14
8133740: NMT for Linux/x86/x64 and bsd/x64 slowdebug builds includes NativeCallStack::NativeCallStack() frame in backtrace
cjplummer
parents:
40010
diff
changeset
|
245 |
return **(intptr_t***)ebp; |
43db0d4b6e14
8133740: NMT for Linux/x86/x64 and bsd/x64 slowdebug builds includes NativeCallStack::NativeCallStack() frame in backtrace
cjplummer
parents:
40010
diff
changeset
|
246 |
#else |
43db0d4b6e14
8133740: NMT for Linux/x86/x64 and bsd/x64 slowdebug builds includes NativeCallStack::NativeCallStack() frame in backtrace
cjplummer
parents:
40010
diff
changeset
|
247 |
return *ebp; |
43db0d4b6e14
8133740: NMT for Linux/x86/x64 and bsd/x64 slowdebug builds includes NativeCallStack::NativeCallStack() frame in backtrace
cjplummer
parents:
40010
diff
changeset
|
248 |
#endif |
1 | 249 |
} |
250 |
||
251 |
||
252 |
frame os::current_frame() { |
|
253 |
intptr_t* fp = _get_previous_fp(); |
|
254 |
frame myframe((intptr_t*)os::current_stack_pointer(), |
|
255 |
(intptr_t*)fp, |
|
256 |
CAST_FROM_FN_PTR(address, os::current_frame)); |
|
257 |
if (os::is_first_C_frame(&myframe)) { |
|
258 |
// stack is not walkable |
|
15468
4a274f843f41
8006508: Wrong frame constructor is called in os_linux_x86.cpp
dholmes
parents:
14633
diff
changeset
|
259 |
return frame(); |
1 | 260 |
} else { |
261 |
return os::get_sender_for_C_frame(&myframe); |
|
262 |
} |
|
263 |
} |
|
264 |
||
265 |
// Utility functions |
|
266 |
||
267 |
// From IA32 System Programming Guide |
|
268 |
enum { |
|
269 |
trap_page_fault = 0xE |
|
270 |
}; |
|
271 |
||
8106 | 272 |
extern "C" JNIEXPORT int |
1 | 273 |
JVM_handle_linux_signal(int sig, |
274 |
siginfo_t* info, |
|
275 |
void* ucVoid, |
|
276 |
int abort_if_unrecognized) { |
|
277 |
ucontext_t* uc = (ucontext_t*) ucVoid; |
|
278 |
||
34633
2a6c7c7b30a7
8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents:
33148
diff
changeset
|
279 |
Thread* t = Thread::current_or_null_safe(); |
1 | 280 |
|
18943 | 281 |
// Must do this before SignalHandlerMark, if crash protection installed we will longjmp away |
282 |
// (no destructors can be run) |
|
46644
a5813fb66270
8183925: Decouple crash protection from watcher thread
rehn
parents:
46625
diff
changeset
|
283 |
os::ThreadCrashProtection::check_crash_protection(sig, t); |
18943 | 284 |
|
1 | 285 |
SignalHandlerMark shm(t); |
286 |
||
287 |
// Note: it's not uncommon that JNI code uses signal/sigset to install |
|
288 |
// then restore certain signal handler (e.g. to temporarily block SIGPIPE, |
|
289 |
// or have a SIGILL handler when detecting CPU type). When that happens, |
|
290 |
// JVM_handle_linux_signal() might be invoked with junk info/ucVoid. To |
|
291 |
// avoid unnecessary crash when libjsig is not preloaded, try handle signals |
|
292 |
// that do not require siginfo/ucontext first. |
|
293 |
||
294 |
if (sig == SIGPIPE || sig == SIGXFSZ) { |
|
295 |
// allow chained handler to go first |
|
296 |
if (os::Linux::chained_handler(sig, info, ucVoid)) { |
|
297 |
return true; |
|
298 |
} else { |
|
37430
fd743dadef12
8151939: VM_Version_init() print buffer is too small
coleenp
parents:
35201
diff
changeset
|
299 |
// Ignoring SIGPIPE/SIGXFSZ - see bugs 4229104 or 6499219 |
1 | 300 |
return true; |
301 |
} |
|
302 |
} |
|
303 |
||
49653
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49615
diff
changeset
|
304 |
#ifdef CAN_SHOW_REGISTERS_ON_ASSERT |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49615
diff
changeset
|
305 |
if ((sig == SIGSEGV || sig == SIGBUS) && info != NULL && info->si_addr == g_assert_poison) { |
55653
3243c42d737d
8227275: Within native OOM error handling, assertions may hang the process
stuefe
parents:
55490
diff
changeset
|
306 |
if (handle_assert_poison_fault(ucVoid, info->si_addr)) { |
3243c42d737d
8227275: Within native OOM error handling, assertions may hang the process
stuefe
parents:
55490
diff
changeset
|
307 |
return 1; |
3243c42d737d
8227275: Within native OOM error handling, assertions may hang the process
stuefe
parents:
55490
diff
changeset
|
308 |
} |
49653
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49615
diff
changeset
|
309 |
} |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49615
diff
changeset
|
310 |
#endif |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49615
diff
changeset
|
311 |
|
1 | 312 |
JavaThread* thread = NULL; |
313 |
VMThread* vmthread = NULL; |
|
314 |
if (os::Linux::signal_handlers_are_installed) { |
|
315 |
if (t != NULL ){ |
|
316 |
if(t->is_Java_thread()) { |
|
317 |
thread = (JavaThread*)t; |
|
318 |
} |
|
319 |
else if(t->is_VM_thread()){ |
|
320 |
vmthread = (VMThread *)t; |
|
321 |
} |
|
322 |
} |
|
323 |
} |
|
324 |
/* |
|
325 |
NOTE: does not seem to work on linux. |
|
326 |
if (info == NULL || info->si_code <= 0 || info->si_code == SI_NOINFO) { |
|
327 |
// can't decode this kind of signal |
|
328 |
info = NULL; |
|
329 |
} else { |
|
330 |
assert(sig == info->si_signo, "bad siginfo"); |
|
331 |
} |
|
332 |
*/ |
|
333 |
// decide if this trap can be handled by a stub |
|
334 |
address stub = NULL; |
|
335 |
||
336 |
address pc = NULL; |
|
337 |
||
338 |
//%note os_trap_1 |
|
339 |
if (info != NULL && uc != NULL && thread != NULL) { |
|
340 |
pc = (address) os::Linux::ucontext_get_pc(uc); |
|
341 |
||
18740 | 342 |
if (StubRoutines::is_safefetch_fault(pc)) { |
29573
2d800e5d575f
8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents:
27685
diff
changeset
|
343 |
os::Linux::ucontext_set_pc(uc, StubRoutines::continuation_for_safefetch_fault(pc)); |
18740 | 344 |
return 1; |
1 | 345 |
} |
346 |
||
18434 | 347 |
#ifndef AMD64 |
348 |
// Halt if SI_KERNEL before more crashes get misdiagnosed as Java bugs |
|
349 |
// This can happen in any running code (currently more frequently in |
|
350 |
// interpreter code but has been seen in compiled code) |
|
351 |
if (sig == SIGSEGV && info->si_addr == 0 && info->si_code == SI_KERNEL) { |
|
352 |
fatal("An irrecoverable SI_KERNEL SIGSEGV has occurred due " |
|
353 |
"to unstable signal handling in this distribution."); |
|
354 |
} |
|
355 |
#endif // AMD64 |
|
356 |
||
1 | 357 |
// Handle ALL stack overflow variations here |
358 |
if (sig == SIGSEGV) { |
|
359 |
address addr = (address) info->si_addr; |
|
360 |
||
361 |
// check if fault address is within thread stack |
|
35201
996db89f378e
8139864: Improve handling of stack protection zones.
goetz
parents:
35077
diff
changeset
|
362 |
if (thread->on_local_stack(addr)) { |
1 | 363 |
// stack overflow |
35201
996db89f378e
8139864: Improve handling of stack protection zones.
goetz
parents:
35077
diff
changeset
|
364 |
if (thread->in_stack_yellow_reserved_zone(addr)) { |
1 | 365 |
if (thread->thread_state() == _thread_in_Java) { |
35071
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
366 |
if (thread->in_stack_reserved_zone(addr)) { |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
367 |
frame fr; |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
368 |
if (os::Linux::get_frame_at_stack_banging_point(thread, uc, &fr)) { |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
369 |
assert(fr.is_java_frame(), "Must be a Java frame"); |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
370 |
frame activation = |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
371 |
SharedRuntime::look_for_reserved_stack_annotated_method(thread, fr); |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
372 |
if (activation.sp() != NULL) { |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
373 |
thread->disable_stack_reserved_zone(); |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
374 |
if (activation.is_interpreted_frame()) { |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
375 |
thread->set_reserved_stack_activation((address)( |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
376 |
activation.fp() + frame::interpreter_frame_initial_sp_offset)); |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
377 |
} else { |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
378 |
thread->set_reserved_stack_activation((address)activation.unextended_sp()); |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
379 |
} |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
380 |
return 1; |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
381 |
} |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
382 |
} |
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34667
diff
changeset
|
383 |
} |
1 | 384 |
// Throw a stack overflow exception. Guard pages will be reenabled |
385 |
// while unwinding the stack. |
|
35201
996db89f378e
8139864: Improve handling of stack protection zones.
goetz
parents:
35077
diff
changeset
|
386 |
thread->disable_stack_yellow_reserved_zone(); |
1 | 387 |
stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW); |
388 |
} else { |
|
389 |
// Thread was in the vm or native code. Return and try to finish. |
|
35201
996db89f378e
8139864: Improve handling of stack protection zones.
goetz
parents:
35077
diff
changeset
|
390 |
thread->disable_stack_yellow_reserved_zone(); |
1 | 391 |
return 1; |
392 |
} |
|
393 |
} else if (thread->in_stack_red_zone(addr)) { |
|
394 |
// Fatal red zone violation. Disable the guard pages and fall through |
|
395 |
// to handle_unexpected_exception way down below. |
|
396 |
thread->disable_stack_red_zone(); |
|
397 |
tty->print_raw_cr("An irrecoverable stack overflow has occurred."); |
|
15926
8e87d545195f
7107135: Stack guard pages are no more protected after loading a shared library with executable stack
iklam
parents:
15468
diff
changeset
|
398 |
|
8e87d545195f
7107135: Stack guard pages are no more protected after loading a shared library with executable stack
iklam
parents:
15468
diff
changeset
|
399 |
// This is a likely cause, but hard to verify. Let's just print |
8e87d545195f
7107135: Stack guard pages are no more protected after loading a shared library with executable stack
iklam
parents:
15468
diff
changeset
|
400 |
// it as a hint. |
8e87d545195f
7107135: Stack guard pages are no more protected after loading a shared library with executable stack
iklam
parents:
15468
diff
changeset
|
401 |
tty->print_raw_cr("Please check if any of your loaded .so files has " |
8e87d545195f
7107135: Stack guard pages are no more protected after loading a shared library with executable stack
iklam
parents:
15468
diff
changeset
|
402 |
"enabled executable stack (see man page execstack(8))"); |
1 | 403 |
} else { |
404 |
// Accessing stack address below sp may cause SEGV if current |
|
405 |
// thread has MAP_GROWSDOWN stack. This should only happen when |
|
406 |
// current thread was created by user code with MAP_GROWSDOWN flag |
|
407 |
// and then attached to VM. See notes in os_linux.cpp. |
|
408 |
if (thread->osthread()->expanding_stack() == 0) { |
|
409 |
thread->osthread()->set_expanding_stack(); |
|
410 |
if (os::Linux::manually_expand_stack(thread, addr)) { |
|
411 |
thread->osthread()->clear_expanding_stack(); |
|
412 |
return 1; |
|
413 |
} |
|
414 |
thread->osthread()->clear_expanding_stack(); |
|
415 |
} else { |
|
416 |
fatal("recursive segv. expanding stack."); |
|
417 |
} |
|
418 |
} |
|
419 |
} |
|
420 |
} |
|
421 |
||
23487
0f7e268cd9e3
8037226: compiler/7196199/Test7196199.java fails on 32-bit linux with MaxVectorSize > 16
kvn
parents:
22542
diff
changeset
|
422 |
if ((sig == SIGSEGV) && VM_Version::is_cpuinfo_segv_addr(pc)) { |
0f7e268cd9e3
8037226: compiler/7196199/Test7196199.java fails on 32-bit linux with MaxVectorSize > 16
kvn
parents:
22542
diff
changeset
|
423 |
// Verify that OS save/restore AVX registers. |
0f7e268cd9e3
8037226: compiler/7196199/Test7196199.java fails on 32-bit linux with MaxVectorSize > 16
kvn
parents:
22542
diff
changeset
|
424 |
stub = VM_Version::cpuinfo_cont_addr(); |
0f7e268cd9e3
8037226: compiler/7196199/Test7196199.java fails on 32-bit linux with MaxVectorSize > 16
kvn
parents:
22542
diff
changeset
|
425 |
} |
0f7e268cd9e3
8037226: compiler/7196199/Test7196199.java fails on 32-bit linux with MaxVectorSize > 16
kvn
parents:
22542
diff
changeset
|
426 |
|
1 | 427 |
if (thread->thread_state() == _thread_in_Java) { |
428 |
// Java thread running in Java code => find exception handler if any |
|
429 |
// a fault inside compiled code, the interpreter, or a stub |
|
430 |
||
431 |
if (sig == SIGSEGV && os::is_poll_address((address)info->si_addr)) { |
|
432 |
stub = SharedRuntime::get_poll_stub(pc); |
|
433 |
} else if (sig == SIGBUS /* && info->si_code == BUS_OBJERR */) { |
|
434 |
// BugId 4454115: A read from a MappedByteBuffer can fault |
|
435 |
// here if the underlying file has been truncated. |
|
436 |
// Do not crash the VM in such a case. |
|
437 |
CodeBlob* cb = CodeCache::find_blob_unsafe(pc); |
|
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37430
diff
changeset
|
438 |
CompiledMethod* nm = (cb != NULL) ? cb->as_compiled_method_or_null() : NULL; |
55490
3f3dc00a69a5
8191278: MappedByteBuffer bulk access memory failures are not handled gracefully
jcm
parents:
54654
diff
changeset
|
439 |
bool is_unsafe_arraycopy = thread->doing_unsafe_access() && UnsafeCopyMemory::contains_pc(pc); |
3f3dc00a69a5
8191278: MappedByteBuffer bulk access memory failures are not handled gracefully
jcm
parents:
54654
diff
changeset
|
440 |
if ((nm != NULL && nm->has_unsafe_access()) || is_unsafe_arraycopy) { |
38209
b2a58604e046
8156088: Reintegrate 8153892: Handle unsafe access error directly in signal handler instead of going through a stub
mikael
parents:
38190
diff
changeset
|
441 |
address next_pc = Assembler::locate_next_instruction(pc); |
55490
3f3dc00a69a5
8191278: MappedByteBuffer bulk access memory failures are not handled gracefully
jcm
parents:
54654
diff
changeset
|
442 |
if (is_unsafe_arraycopy) { |
3f3dc00a69a5
8191278: MappedByteBuffer bulk access memory failures are not handled gracefully
jcm
parents:
54654
diff
changeset
|
443 |
next_pc = UnsafeCopyMemory::page_error_continue_pc(pc); |
3f3dc00a69a5
8191278: MappedByteBuffer bulk access memory failures are not handled gracefully
jcm
parents:
54654
diff
changeset
|
444 |
} |
38209
b2a58604e046
8156088: Reintegrate 8153892: Handle unsafe access error directly in signal handler instead of going through a stub
mikael
parents:
38190
diff
changeset
|
445 |
stub = SharedRuntime::handle_unsafe_access(thread, next_pc); |
1 | 446 |
} |
447 |
} |
|
448 |
else |
|
449 |
||
450 |
#ifdef AMD64 |
|
451 |
if (sig == SIGFPE && |
|
452 |
(info->si_code == FPE_INTDIV || info->si_code == FPE_FLTDIV)) { |
|
453 |
stub = |
|
454 |
SharedRuntime:: |
|
455 |
continuation_for_implicit_exception(thread, |
|
456 |
pc, |
|
457 |
SharedRuntime:: |
|
458 |
IMPLICIT_DIVIDE_BY_ZERO); |
|
459 |
#else |
|
460 |
if (sig == SIGFPE /* && info->si_code == FPE_INTDIV */) { |
|
461 |
// HACK: si_code does not work on linux 2.2.12-20!!! |
|
462 |
int op = pc[0]; |
|
463 |
if (op == 0xDB) { |
|
464 |
// FIST |
|
465 |
// TODO: The encoding of D2I in i486.ad can cause an exception |
|
466 |
// prior to the fist instruction if there was an invalid operation |
|
467 |
// pending. We want to dismiss that exception. From the win_32 |
|
468 |
// side it also seems that if it really was the fist causing |
|
469 |
// the exception that we do the d2i by hand with different |
|
470 |
// rounding. Seems kind of weird. |
|
471 |
// NOTE: that we take the exception at the NEXT floating point instruction. |
|
472 |
assert(pc[0] == 0xDB, "not a FIST opcode"); |
|
473 |
assert(pc[1] == 0x14, "not a FIST opcode"); |
|
474 |
assert(pc[2] == 0x24, "not a FIST opcode"); |
|
475 |
return true; |
|
476 |
} else if (op == 0xF7) { |
|
477 |
// IDIV |
|
478 |
stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO); |
|
479 |
} else { |
|
480 |
// TODO: handle more cases if we are using other x86 instructions |
|
481 |
// that can generate SIGFPE signal on linux. |
|
482 |
tty->print_cr("unknown opcode 0x%X with SIGFPE.", op); |
|
483 |
fatal("please update this code."); |
|
484 |
} |
|
485 |
#endif // AMD64 |
|
486 |
} else if (sig == SIGSEGV && |
|
52462
4ad404da0088
8213199: GC abstraction for Assembler::needs_explicit_null_check()
rkennke
parents:
52460
diff
changeset
|
487 |
MacroAssembler::uses_implicit_null_check(info->si_addr)) { |
1 | 488 |
// Determination of interpreter/vtable stub/compiled code null exception |
489 |
stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL); |
|
490 |
} |
|
55490
3f3dc00a69a5
8191278: MappedByteBuffer bulk access memory failures are not handled gracefully
jcm
parents:
54654
diff
changeset
|
491 |
} else if ((thread->thread_state() == _thread_in_vm || |
3f3dc00a69a5
8191278: MappedByteBuffer bulk access memory failures are not handled gracefully
jcm
parents:
54654
diff
changeset
|
492 |
thread->thread_state() == _thread_in_native) && |
3f3dc00a69a5
8191278: MappedByteBuffer bulk access memory failures are not handled gracefully
jcm
parents:
54654
diff
changeset
|
493 |
(sig == SIGBUS && /* info->si_code == BUS_OBJERR && */ |
3f3dc00a69a5
8191278: MappedByteBuffer bulk access memory failures are not handled gracefully
jcm
parents:
54654
diff
changeset
|
494 |
thread->doing_unsafe_access())) { |
38209
b2a58604e046
8156088: Reintegrate 8153892: Handle unsafe access error directly in signal handler instead of going through a stub
mikael
parents:
38190
diff
changeset
|
495 |
address next_pc = Assembler::locate_next_instruction(pc); |
55490
3f3dc00a69a5
8191278: MappedByteBuffer bulk access memory failures are not handled gracefully
jcm
parents:
54654
diff
changeset
|
496 |
if (UnsafeCopyMemory::contains_pc(pc)) { |
3f3dc00a69a5
8191278: MappedByteBuffer bulk access memory failures are not handled gracefully
jcm
parents:
54654
diff
changeset
|
497 |
next_pc = UnsafeCopyMemory::page_error_continue_pc(pc); |
3f3dc00a69a5
8191278: MappedByteBuffer bulk access memory failures are not handled gracefully
jcm
parents:
54654
diff
changeset
|
498 |
} |
38209
b2a58604e046
8156088: Reintegrate 8153892: Handle unsafe access error directly in signal handler instead of going through a stub
mikael
parents:
38190
diff
changeset
|
499 |
stub = SharedRuntime::handle_unsafe_access(thread, next_pc); |
1 | 500 |
} |
501 |
||
502 |
// jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in |
|
503 |
// and the heap gets shrunk before the field access. |
|
504 |
if ((sig == SIGSEGV) || (sig == SIGBUS)) { |
|
505 |
address addr = JNI_FastGetField::find_slowcase_pc(pc); |
|
506 |
if (addr != (address)-1) { |
|
507 |
stub = addr; |
|
508 |
} |
|
509 |
} |
|
510 |
} |
|
511 |
||
512 |
#ifndef AMD64 |
|
513 |
// Execution protection violation |
|
514 |
// |
|
515 |
// This should be kept as the last step in the triage. We don't |
|
516 |
// have a dedicated trap number for a no-execute fault, so be |
|
517 |
// conservative and allow other handlers the first shot. |
|
518 |
// |
|
519 |
// Note: We don't test that info->si_code == SEGV_ACCERR here. |
|
520 |
// this si_code is so generic that it is almost meaningless; and |
|
521 |
// the si_code for this condition may change in the future. |
|
522 |
// Furthermore, a false-positive should be harmless. |
|
523 |
if (UnguardOnExecutionViolation > 0 && |
|
524 |
(sig == SIGSEGV || sig == SIGBUS) && |
|
525 |
uc->uc_mcontext.gregs[REG_TRAPNO] == trap_page_fault) { |
|
526 |
int page_size = os::vm_page_size(); |
|
527 |
address addr = (address) info->si_addr; |
|
528 |
address pc = os::Linux::ucontext_get_pc(uc); |
|
529 |
// Make sure the pc and the faulting address are sane. |
|
530 |
// |
|
531 |
// If an instruction spans a page boundary, and the page containing |
|
532 |
// the beginning of the instruction is executable but the following |
|
533 |
// page is not, the pc and the faulting address might be slightly |
|
534 |
// different - we still want to unguard the 2nd page in this case. |
|
535 |
// |
|
536 |
// 15 bytes seems to be a (very) safe value for max instruction size. |
|
537 |
bool pc_is_near_addr = |
|
538 |
(pointer_delta((void*) addr, (void*) pc, sizeof(char)) < 15); |
|
539 |
bool instr_spans_page_boundary = |
|
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
540 |
(align_down((intptr_t) pc ^ (intptr_t) addr, |
1 | 541 |
(intptr_t) page_size) > 0); |
542 |
||
543 |
if (pc == addr || (pc_is_near_addr && instr_spans_page_boundary)) { |
|
544 |
static volatile address last_addr = |
|
545 |
(address) os::non_memory_address_word(); |
|
546 |
||
547 |
// In conservative mode, don't unguard unless the address is in the VM |
|
548 |
if (addr != last_addr && |
|
549 |
(UnguardOnExecutionViolation > 1 || os::address_is_in_vm(addr))) { |
|
550 |
||
1664
fc9ed50498fb
6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents:
670
diff
changeset
|
551 |
// Set memory to RWX and retry |
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
552 |
address page_start = align_down(addr, page_size); |
1664
fc9ed50498fb
6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents:
670
diff
changeset
|
553 |
bool res = os::protect_memory((char*) page_start, page_size, |
fc9ed50498fb
6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents:
670
diff
changeset
|
554 |
os::MEM_PROT_RWX); |
1 | 555 |
|
37430
fd743dadef12
8151939: VM_Version_init() print buffer is too small
coleenp
parents:
35201
diff
changeset
|
556 |
log_debug(os)("Execution protection violation " |
fd743dadef12
8151939: VM_Version_init() print buffer is too small
coleenp
parents:
35201
diff
changeset
|
557 |
"at " INTPTR_FORMAT |
fd743dadef12
8151939: VM_Version_init() print buffer is too small
coleenp
parents:
35201
diff
changeset
|
558 |
", unguarding " INTPTR_FORMAT ": %s, errno=%d", p2i(addr), |
fd743dadef12
8151939: VM_Version_init() print buffer is too small
coleenp
parents:
35201
diff
changeset
|
559 |
p2i(page_start), (res ? "success" : "failed"), errno); |
1 | 560 |
stub = pc; |
561 |
||
562 |
// Set last_addr so if we fault again at the same address, we don't end |
|
563 |
// up in an endless loop. |
|
564 |
// |
|
565 |
// There are two potential complications here. Two threads trapping at |
|
566 |
// the same address at the same time could cause one of the threads to |
|
567 |
// think it already unguarded, and abort the VM. Likely very rare. |
|
568 |
// |
|
569 |
// The other race involves two threads alternately trapping at |
|
570 |
// different addresses and failing to unguard the page, resulting in |
|
571 |
// an endless loop. This condition is probably even more unlikely than |
|
572 |
// the first. |
|
573 |
// |
|
574 |
// Although both cases could be avoided by using locks or thread local |
|
575 |
// last_addr, these solutions are unnecessary complication: this |
|
576 |
// handler is a best-effort safety net, not a complete solution. It is |
|
577 |
// disabled by default and should only be used as a workaround in case |
|
578 |
// we missed any no-execute-unsafe VM code. |
|
579 |
||
580 |
last_addr = addr; |
|
581 |
} |
|
582 |
} |
|
583 |
} |
|
584 |
#endif // !AMD64 |
|
585 |
||
586 |
if (stub != NULL) { |
|
587 |
// save all thread context in case we need to restore it |
|
588 |
if (thread != NULL) thread->set_saved_exception_pc(pc); |
|
589 |
||
29573
2d800e5d575f
8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents:
27685
diff
changeset
|
590 |
os::Linux::ucontext_set_pc(uc, stub); |
1 | 591 |
return true; |
592 |
} |
|
593 |
||
594 |
// signal-chaining |
|
595 |
if (os::Linux::chained_handler(sig, info, ucVoid)) { |
|
596 |
return true; |
|
597 |
} |
|
598 |
||
599 |
if (!abort_if_unrecognized) { |
|
600 |
// caller wants another chance, so give it to him |
|
601 |
return false; |
|
602 |
} |
|
603 |
||
604 |
if (pc == NULL && uc != NULL) { |
|
605 |
pc = os::Linux::ucontext_get_pc(uc); |
|
606 |
} |
|
607 |
||
608 |
// unmask current signal |
|
609 |
sigset_t newset; |
|
610 |
sigemptyset(&newset); |
|
611 |
sigaddset(&newset, sig); |
|
612 |
sigprocmask(SIG_UNBLOCK, &newset, NULL); |
|
613 |
||
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
32080
diff
changeset
|
614 |
VMError::report_and_die(t, sig, pc, info, ucVoid); |
1 | 615 |
|
616 |
ShouldNotReachHere(); |
|
27677 | 617 |
return true; // Mute compiler |
1 | 618 |
} |
619 |
||
620 |
void os::Linux::init_thread_fpu_state(void) { |
|
621 |
#ifndef AMD64 |
|
622 |
// set fpu to 53 bit precision |
|
623 |
set_fpu_control_word(0x27f); |
|
624 |
#endif // !AMD64 |
|
625 |
} |
|
626 |
||
627 |
int os::Linux::get_fpu_control_word(void) { |
|
628 |
#ifdef AMD64 |
|
629 |
return 0; |
|
630 |
#else |
|
631 |
int fpu_control; |
|
632 |
_FPU_GETCW(fpu_control); |
|
633 |
return fpu_control & 0xffff; |
|
634 |
#endif // AMD64 |
|
635 |
} |
|
636 |
||
637 |
void os::Linux::set_fpu_control_word(int fpu_control) { |
|
638 |
#ifndef AMD64 |
|
639 |
_FPU_SETCW(fpu_control); |
|
640 |
#endif // !AMD64 |
|
641 |
} |
|
642 |
||
643 |
// Check that the linux kernel version is 2.4 or higher since earlier |
|
644 |
// versions do not support SSE without patches. |
|
645 |
bool os::supports_sse() { |
|
646 |
#ifdef AMD64 |
|
647 |
return true; |
|
648 |
#else |
|
649 |
struct utsname uts; |
|
650 |
if( uname(&uts) != 0 ) return false; // uname fails? |
|
651 |
char *minor_string; |
|
652 |
int major = strtol(uts.release,&minor_string,10); |
|
653 |
int minor = strtol(minor_string+1,NULL,10); |
|
654 |
bool result = (major > 2 || (major==2 && minor >= 4)); |
|
37430
fd743dadef12
8151939: VM_Version_init() print buffer is too small
coleenp
parents:
35201
diff
changeset
|
655 |
log_info(os)("OS version is %d.%d, which %s support SSE/SSE2", |
1 | 656 |
major,minor, result ? "DOES" : "does NOT"); |
657 |
return result; |
|
658 |
#endif // AMD64 |
|
659 |
} |
|
660 |
||
661 |
bool os::is_allocatable(size_t bytes) { |
|
662 |
#ifdef AMD64 |
|
663 |
// unused on amd64? |
|
664 |
return true; |
|
665 |
#else |
|
666 |
||
667 |
if (bytes < 2 * G) { |
|
668 |
return true; |
|
669 |
} |
|
670 |
||
671 |
char* addr = reserve_memory(bytes, NULL); |
|
672 |
||
673 |
if (addr != NULL) { |
|
674 |
release_memory(addr, bytes); |
|
675 |
} |
|
676 |
||
677 |
return addr != NULL; |
|
678 |
#endif // AMD64 |
|
679 |
} |
|
680 |
||
681 |
//////////////////////////////////////////////////////////////////////////////// |
|
682 |
// thread stack |
|
683 |
||
42906
1a8db9cf1407
8170655: [posix] Fix minimum stack size computations
goetz
parents:
42905
diff
changeset
|
684 |
// Minimum usable stack sizes required to get to user code. Space for |
1a8db9cf1407
8170655: [posix] Fix minimum stack size computations
goetz
parents:
42905
diff
changeset
|
685 |
// HotSpot guard pages is added later. |
1a8db9cf1407
8170655: [posix] Fix minimum stack size computations
goetz
parents:
42905
diff
changeset
|
686 |
size_t os::Posix::_compiler_thread_min_stack_allowed = 48 * K; |
1a8db9cf1407
8170655: [posix] Fix minimum stack size computations
goetz
parents:
42905
diff
changeset
|
687 |
size_t os::Posix::_java_thread_min_stack_allowed = 40 * K; |
1a8db9cf1407
8170655: [posix] Fix minimum stack size computations
goetz
parents:
42905
diff
changeset
|
688 |
#ifdef _LP64 |
41070
496463b4e206
8140520: segfault on solaris-amd64 with "-XX:VMThreadStackSize=1" option
rdurbin
parents:
40384
diff
changeset
|
689 |
size_t os::Posix::_vm_internal_thread_min_stack_allowed = 64 * K; |
1 | 690 |
#else |
41070
496463b4e206
8140520: segfault on solaris-amd64 with "-XX:VMThreadStackSize=1" option
rdurbin
parents:
40384
diff
changeset
|
691 |
size_t os::Posix::_vm_internal_thread_min_stack_allowed = (48 DEBUG_ONLY(+ 4)) * K; |
42906
1a8db9cf1407
8170655: [posix] Fix minimum stack size computations
goetz
parents:
42905
diff
changeset
|
692 |
#endif // _LP64 |
1 | 693 |
|
694 |
// return default stack size for thr_type |
|
41070
496463b4e206
8140520: segfault on solaris-amd64 with "-XX:VMThreadStackSize=1" option
rdurbin
parents:
40384
diff
changeset
|
695 |
size_t os::Posix::default_stack_size(os::ThreadType thr_type) { |
1 | 696 |
// default stack size (compiler thread needs larger stack) |
697 |
#ifdef AMD64 |
|
698 |
size_t s = (thr_type == os::compiler_thread ? 4 * M : 1 * M); |
|
699 |
#else |
|
700 |
size_t s = (thr_type == os::compiler_thread ? 2 * M : 512 * K); |
|
701 |
#endif // AMD64 |
|
702 |
return s; |
|
703 |
} |
|
704 |
||
705 |
///////////////////////////////////////////////////////////////////////////// |
|
706 |
// helper functions for fatal error handler |
|
707 |
||
35077
8b86440d3bf1
8145114: const-correctness for ucontext_t* reading functions
stuefe
parents:
35071
diff
changeset
|
708 |
void os::print_context(outputStream *st, const void *context) { |
1 | 709 |
if (context == NULL) return; |
710 |
||
35077
8b86440d3bf1
8145114: const-correctness for ucontext_t* reading functions
stuefe
parents:
35071
diff
changeset
|
711 |
const ucontext_t *uc = (const ucontext_t*)context; |
1 | 712 |
st->print_cr("Registers:"); |
713 |
#ifdef AMD64 |
|
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
714 |
st->print( "RAX=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_RAX]); |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
715 |
st->print(", RBX=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_RBX]); |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
716 |
st->print(", RCX=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_RCX]); |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
717 |
st->print(", RDX=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_RDX]); |
1 | 718 |
st->cr(); |
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
719 |
st->print( "RSP=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_RSP]); |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
720 |
st->print(", RBP=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_RBP]); |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
721 |
st->print(", RSI=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_RSI]); |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
722 |
st->print(", RDI=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_RDI]); |
1 | 723 |
st->cr(); |
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
724 |
st->print( "R8 =" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_R8]); |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
725 |
st->print(", R9 =" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_R9]); |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
726 |
st->print(", R10=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_R10]); |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
727 |
st->print(", R11=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_R11]); |
1 | 728 |
st->cr(); |
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
729 |
st->print( "R12=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_R12]); |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
730 |
st->print(", R13=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_R13]); |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
731 |
st->print(", R14=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_R14]); |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
732 |
st->print(", R15=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_R15]); |
1 | 733 |
st->cr(); |
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
734 |
st->print( "RIP=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_RIP]); |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
735 |
st->print(", EFLAGS=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_EFL]); |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
736 |
st->print(", CSGSFS=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_CSGSFS]); |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
737 |
st->print(", ERR=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_ERR]); |
1 | 738 |
st->cr(); |
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
739 |
st->print(" TRAPNO=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_TRAPNO]); |
1 | 740 |
#else |
741 |
st->print( "EAX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EAX]); |
|
742 |
st->print(", EBX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EBX]); |
|
743 |
st->print(", ECX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_ECX]); |
|
744 |
st->print(", EDX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EDX]); |
|
745 |
st->cr(); |
|
746 |
st->print( "ESP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_UESP]); |
|
747 |
st->print(", EBP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EBP]); |
|
748 |
st->print(", ESI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_ESI]); |
|
749 |
st->print(", EDI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EDI]); |
|
750 |
st->cr(); |
|
751 |
st->print( "EIP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EIP]); |
|
7108 | 752 |
st->print(", EFLAGS=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EFL]); |
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
753 |
st->print(", CR2=" PTR64_FORMAT, (uint64_t)uc->uc_mcontext.cr2); |
1 | 754 |
#endif // AMD64 |
755 |
st->cr(); |
|
756 |
st->cr(); |
|
757 |
||
758 |
intptr_t *sp = (intptr_t *)os::Linux::ucontext_get_sp(uc); |
|
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
759 |
st->print_cr("Top of Stack: (sp=" PTR_FORMAT ")", p2i(sp)); |
38658
34f9c45625d8
8140594: Various minor code improvements (compiler)
goetz
parents:
38190
diff
changeset
|
760 |
print_hex_dump(st, (address)sp, (address)(sp + 8), sizeof(intptr_t)); |
1 | 761 |
st->cr(); |
762 |
||
763 |
// Note: it may be unsafe to inspect memory near pc. For example, pc may |
|
764 |
// point to garbage if entry point in an nmethod is corrupted. Leave |
|
765 |
// this at the end, and hope for the best. |
|
766 |
address pc = os::Linux::ucontext_get_pc(uc); |
|
53605
853c68ff2ed7
8217879: hs_err should print more instructions in hex dump
shade
parents:
52462
diff
changeset
|
767 |
print_instructions(st, pc, sizeof(char)); |
853c68ff2ed7
8217879: hs_err should print more instructions in hex dump
shade
parents:
52462
diff
changeset
|
768 |
st->cr(); |
7108 | 769 |
} |
770 |
||
35077
8b86440d3bf1
8145114: const-correctness for ucontext_t* reading functions
stuefe
parents:
35071
diff
changeset
|
771 |
void os::print_register_info(outputStream *st, const void *context) { |
7108 | 772 |
if (context == NULL) return; |
773 |
||
35077
8b86440d3bf1
8145114: const-correctness for ucontext_t* reading functions
stuefe
parents:
35071
diff
changeset
|
774 |
const ucontext_t *uc = (const ucontext_t*)context; |
7108 | 775 |
|
776 |
st->print_cr("Register to memory mapping:"); |
|
777 |
st->cr(); |
|
778 |
||
779 |
// this is horrendously verbose but the layout of the registers in the |
|
780 |
// context does not match how we defined our abstract Register set, so |
|
781 |
// we can't just iterate through the gregs area |
|
782 |
||
783 |
// this is only for the "general purpose" registers |
|
784 |
||
785 |
#ifdef AMD64 |
|
786 |
st->print("RAX="); print_location(st, uc->uc_mcontext.gregs[REG_RAX]); |
|
787 |
st->print("RBX="); print_location(st, uc->uc_mcontext.gregs[REG_RBX]); |
|
788 |
st->print("RCX="); print_location(st, uc->uc_mcontext.gregs[REG_RCX]); |
|
789 |
st->print("RDX="); print_location(st, uc->uc_mcontext.gregs[REG_RDX]); |
|
790 |
st->print("RSP="); print_location(st, uc->uc_mcontext.gregs[REG_RSP]); |
|
791 |
st->print("RBP="); print_location(st, uc->uc_mcontext.gregs[REG_RBP]); |
|
792 |
st->print("RSI="); print_location(st, uc->uc_mcontext.gregs[REG_RSI]); |
|
793 |
st->print("RDI="); print_location(st, uc->uc_mcontext.gregs[REG_RDI]); |
|
794 |
st->print("R8 ="); print_location(st, uc->uc_mcontext.gregs[REG_R8]); |
|
795 |
st->print("R9 ="); print_location(st, uc->uc_mcontext.gregs[REG_R9]); |
|
796 |
st->print("R10="); print_location(st, uc->uc_mcontext.gregs[REG_R10]); |
|
797 |
st->print("R11="); print_location(st, uc->uc_mcontext.gregs[REG_R11]); |
|
798 |
st->print("R12="); print_location(st, uc->uc_mcontext.gregs[REG_R12]); |
|
799 |
st->print("R13="); print_location(st, uc->uc_mcontext.gregs[REG_R13]); |
|
800 |
st->print("R14="); print_location(st, uc->uc_mcontext.gregs[REG_R14]); |
|
801 |
st->print("R15="); print_location(st, uc->uc_mcontext.gregs[REG_R15]); |
|
802 |
#else |
|
803 |
st->print("EAX="); print_location(st, uc->uc_mcontext.gregs[REG_EAX]); |
|
804 |
st->print("EBX="); print_location(st, uc->uc_mcontext.gregs[REG_EBX]); |
|
805 |
st->print("ECX="); print_location(st, uc->uc_mcontext.gregs[REG_ECX]); |
|
806 |
st->print("EDX="); print_location(st, uc->uc_mcontext.gregs[REG_EDX]); |
|
807 |
st->print("ESP="); print_location(st, uc->uc_mcontext.gregs[REG_ESP]); |
|
808 |
st->print("EBP="); print_location(st, uc->uc_mcontext.gregs[REG_EBP]); |
|
809 |
st->print("ESI="); print_location(st, uc->uc_mcontext.gregs[REG_ESI]); |
|
810 |
st->print("EDI="); print_location(st, uc->uc_mcontext.gregs[REG_EDI]); |
|
811 |
#endif // AMD64 |
|
812 |
||
813 |
st->cr(); |
|
1 | 814 |
} |
815 |
||
816 |
void os::setup_fpu() { |
|
817 |
#ifndef AMD64 |
|
818 |
address fpu_cntrl = StubRoutines::addr_fpu_cntrl_wrd_std(); |
|
819 |
__asm__ volatile ( "fldcw (%0)" : |
|
820 |
: "r" (fpu_cntrl) : "memory"); |
|
821 |
#endif // !AMD64 |
|
822 |
} |
|
11961
0abd4cd26e5a
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
8921
diff
changeset
|
823 |
|
0abd4cd26e5a
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
8921
diff
changeset
|
824 |
#ifndef PRODUCT |
0abd4cd26e5a
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
8921
diff
changeset
|
825 |
void os::verify_stack_alignment() { |
0abd4cd26e5a
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
8921
diff
changeset
|
826 |
#ifdef AMD64 |
0abd4cd26e5a
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
8921
diff
changeset
|
827 |
assert(((intptr_t)os::current_stack_pointer() & (StackAlignmentInBytes-1)) == 0, "incorrect stack alignment"); |
0abd4cd26e5a
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
8921
diff
changeset
|
828 |
#endif |
0abd4cd26e5a
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
8921
diff
changeset
|
829 |
} |
0abd4cd26e5a
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
8921
diff
changeset
|
830 |
#endif |
20279
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
831 |
|
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
832 |
|
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
833 |
/* |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
834 |
* IA32 only: execute code at a high address in case buggy NX emulation is present. I.e. avoid CS limit |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
835 |
* updates (JDK-8023956). |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
836 |
*/ |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
837 |
void os::workaround_expand_exec_shield_cs_limit() { |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
838 |
#if defined(IA32) |
54654
7acebe4d65e2
8221639: [i386] expand_exec_shield_cs_limit workaround is undefined code after JDK-8199717
sgehwolf
parents:
53605
diff
changeset
|
839 |
assert(Linux::initial_thread_stack_bottom() != NULL, "sanity"); |
20279
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
840 |
size_t page_size = os::vm_page_size(); |
49407
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
841 |
|
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
842 |
/* |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
843 |
* JDK-8197429 |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
844 |
* |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
845 |
* Expand the stack mapping to the end of the initial stack before |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
846 |
* attempting to install the codebuf. This is needed because newer |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
847 |
* Linux kernels impose a distance of a megabyte between stack |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
848 |
* memory and other memory regions. If we try to install the |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
849 |
* codebuf before expanding the stack the installation will appear |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
850 |
* to succeed but we'll get a segfault later if we expand the stack |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
851 |
* in Java code. |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
852 |
* |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
853 |
*/ |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
854 |
if (os::is_primordial_thread()) { |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
855 |
address limit = Linux::initial_thread_stack_bottom(); |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
856 |
if (! DisablePrimordialThreadGuardPages) { |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
857 |
limit += JavaThread::stack_red_zone_size() + |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
858 |
JavaThread::stack_yellow_zone_size(); |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
859 |
} |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
860 |
os::Linux::expand_stack_to(limit); |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
861 |
} |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
862 |
|
20279
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
863 |
/* |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
864 |
* Take the highest VA the OS will give us and exec |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
865 |
* |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
866 |
* Although using -(pagesz) as mmap hint works on newer kernel as you would |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
867 |
* think, older variants affected by this work-around don't (search forward only). |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
868 |
* |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
869 |
* On the affected distributions, we understand the memory layout to be: |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
870 |
* |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
871 |
* TASK_LIMIT= 3G, main stack base close to TASK_LIMT. |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
872 |
* |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
873 |
* A few pages south main stack will do it. |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
874 |
* |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
875 |
* If we are embedded in an app other than launcher (initial != main stack), |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
876 |
* we don't have much control or understanding of the address space, just let it slide. |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
877 |
*/ |
35201
996db89f378e
8139864: Improve handling of stack protection zones.
goetz
parents:
35077
diff
changeset
|
878 |
char* hint = (char*)(Linux::initial_thread_stack_bottom() - |
996db89f378e
8139864: Improve handling of stack protection zones.
goetz
parents:
35077
diff
changeset
|
879 |
(JavaThread::stack_guard_zone_size() + page_size)); |
27476
6ac67737d359
8058715: stability issues when being launched as an embedded JVM via JNI
dbuck
parents:
26576
diff
changeset
|
880 |
char* codebuf = os::attempt_reserve_memory_at(page_size, hint); |
49407
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
881 |
|
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
882 |
if (codebuf == NULL) { |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
883 |
// JDK-8197429: There may be a stack gap of one megabyte between |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
884 |
// the limit of the stack and the nearest memory region: this is a |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
885 |
// Linux kernel workaround for CVE-2017-1000364. If we failed to |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
886 |
// map our codebuf, try again at an address one megabyte lower. |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
887 |
hint -= 1 * M; |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
888 |
codebuf = os::attempt_reserve_memory_at(page_size, hint); |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
889 |
} |
7fa5375fa6fd
8197429: Increased stack guard causes segfaults on x86-32
aph
parents:
47765
diff
changeset
|
890 |
|
35201
996db89f378e
8139864: Improve handling of stack protection zones.
goetz
parents:
35077
diff
changeset
|
891 |
if ((codebuf == NULL) || (!os::commit_memory(codebuf, page_size, true))) { |
20279
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
892 |
return; // No matter, we tried, best effort. |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
893 |
} |
22542
62913331d480
8032827: NMT: missing virtual memory tagging in os::workaround_expand_exec_shield_cs_limit()
zgu
parents:
22234
diff
changeset
|
894 |
|
62913331d480
8032827: NMT: missing virtual memory tagging in os::workaround_expand_exec_shield_cs_limit()
zgu
parents:
22234
diff
changeset
|
895 |
MemTracker::record_virtual_memory_type((address)codebuf, mtInternal); |
62913331d480
8032827: NMT: missing virtual memory tagging in os::workaround_expand_exec_shield_cs_limit()
zgu
parents:
22234
diff
changeset
|
896 |
|
37430
fd743dadef12
8151939: VM_Version_init() print buffer is too small
coleenp
parents:
35201
diff
changeset
|
897 |
log_info(os)("[CS limit NX emulation work-around, exec code at: %p]", codebuf); |
20279
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
898 |
|
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
899 |
// Some code to exec: the 'ret' instruction |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
900 |
codebuf[0] = 0xC3; |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
901 |
|
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
902 |
// Call the code in the codebuf |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
903 |
__asm__ volatile("call *%0" : : "r"(codebuf)); |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
904 |
|
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
905 |
// keep the page mapped so CS limit isn't reduced. |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
906 |
#endif |
7ffa08fef52a
8023956: Provide a work-around to broken Linux 32 bit "Exec Shield" using CS for NX emulation (crashing with SI_KERNEL)
dsimms
parents:
18945
diff
changeset
|
907 |
} |
26576
a9429d24d429
8050147: StoreLoad barrier interferes with stack usages
shade
parents:
24424
diff
changeset
|
908 |
|
a9429d24d429
8050147: StoreLoad barrier interferes with stack usages
shade
parents:
24424
diff
changeset
|
909 |
int os::extra_bang_size_in_bytes() { |
a9429d24d429
8050147: StoreLoad barrier interferes with stack usages
shade
parents:
24424
diff
changeset
|
910 |
// JDK-8050147 requires the full cache line bang for x86. |
a9429d24d429
8050147: StoreLoad barrier interferes with stack usages
shade
parents:
24424
diff
changeset
|
911 |
return VM_Version::L1_line_size(); |
a9429d24d429
8050147: StoreLoad barrier interferes with stack usages
shade
parents:
24424
diff
changeset
|
912 |
} |