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