4429 //
4430 extern "C" JNIEXPORT int JVM_handle_linux_signal(int signo,
4431 siginfo_t* siginfo,
4432 void* ucontext,
4433 int abort_if_unrecognized);
4434
4435 static void signalHandler(int sig, siginfo_t* info, void* uc) {
4436 assert(info != NULL && uc != NULL, "it must be old kernel");
4437 int orig_errno = errno; // Preserve errno value over signal handler.
4438 JVM_handle_linux_signal(sig, info, uc, true);
4439 errno = orig_errno;
4440 }
4441
4442
4443 // This boolean allows users to forward their own non-matching signals
4444 // to JVM_handle_linux_signal, harmlessly.
4445 bool os::Linux::signal_handlers_are_installed = false;
4446
4447 // For signal-chaining
4448 struct sigaction sigact[NSIG];
4449 uint64_t sigs = 0;
4450 #if (64 < NSIG-1)
4451 #error "Not all signals can be encoded in sigs. Adapt its type!"
4452 #endif
4453 bool os::Linux::libjsig_is_loaded = false;
4454 typedef struct sigaction *(*get_signal_t)(int);
4455 get_signal_t os::Linux::get_signal_action = NULL;
4456
4457 struct sigaction* os::Linux::get_chained_signal_action(int sig) {
4458 struct sigaction *actp = NULL;
4459
4460 if (libjsig_is_loaded) {
4461 // Retrieve the old signal handler from libjsig
4462 actp = (*get_signal_action)(sig);
4463 }
4464 if (actp == NULL) {
4465 // Retrieve the preinstalled signal handler from jvm
4466 actp = get_preinstalled_handler(sig);
4467 }
4468
4469 return actp;
4470 }
4471
4472 static bool call_chained_handler(struct sigaction *actp, int sig,
4511 // restore the signal mask
4512 pthread_sigmask(SIG_SETMASK, &oset, NULL);
4513 }
4514 // Tell jvm's signal handler the signal is taken care of.
4515 return true;
4516 }
4517
4518 bool os::Linux::chained_handler(int sig, siginfo_t* siginfo, void* context) {
4519 bool chained = false;
4520 // signal-chaining
4521 if (UseSignalChaining) {
4522 struct sigaction *actp = get_chained_signal_action(sig);
4523 if (actp != NULL) {
4524 chained = call_chained_handler(actp, sig, siginfo, context);
4525 }
4526 }
4527 return chained;
4528 }
4529
4530 struct sigaction* os::Linux::get_preinstalled_handler(int sig) {
4531 if ((((uint64_t)1 << (sig-1)) & sigs) != 0) {
4532 return &sigact[sig];
4533 }
4534 return NULL;
4535 }
4536
4537 void os::Linux::save_preinstalled_handler(int sig, struct sigaction& oldAct) {
4538 assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
4539 sigact[sig] = oldAct;
4540 sigs |= (uint64_t)1 << (sig-1);
4541 }
4542
4543 // for diagnostic
4544 int sigflags[NSIG];
4545
4546 int os::Linux::get_our_sigflags(int sig) {
4547 assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
4548 return sigflags[sig];
4549 }
4550
4551 void os::Linux::set_our_sigflags(int sig, int flags) {
4552 assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
4553 if (sig > 0 && sig < NSIG) {
4554 sigflags[sig] = flags;
4555 }
4556 }
4557
4558 void os::Linux::set_signal_handler(int sig, bool set_installed) {
4559 // Check for overwrite.
4560 struct sigaction oldAct;
4611
4612 // signal-chaining
4613 typedef void (*signal_setting_t)();
4614 signal_setting_t begin_signal_setting = NULL;
4615 signal_setting_t end_signal_setting = NULL;
4616 begin_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
4617 dlsym(RTLD_DEFAULT, "JVM_begin_signal_setting"));
4618 if (begin_signal_setting != NULL) {
4619 end_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
4620 dlsym(RTLD_DEFAULT, "JVM_end_signal_setting"));
4621 get_signal_action = CAST_TO_FN_PTR(get_signal_t,
4622 dlsym(RTLD_DEFAULT, "JVM_get_signal_action"));
4623 libjsig_is_loaded = true;
4624 assert(UseSignalChaining, "should enable signal-chaining");
4625 }
4626 if (libjsig_is_loaded) {
4627 // Tell libjsig jvm is setting signal handlers
4628 (*begin_signal_setting)();
4629 }
4630
4631 set_signal_handler(SIGSEGV, true);
4632 set_signal_handler(SIGPIPE, true);
4633 set_signal_handler(SIGBUS, true);
4634 set_signal_handler(SIGILL, true);
4635 set_signal_handler(SIGFPE, true);
4636 #if defined(PPC64)
4637 set_signal_handler(SIGTRAP, true);
4638 #endif
4639 set_signal_handler(SIGXFSZ, true);
4640
4641 if (libjsig_is_loaded) {
4642 // Tell libjsig jvm finishes setting signal handlers
4643 (*end_signal_setting)();
4644 }
4645
4646 // We don't activate signal checker if libjsig is in place, we trust ourselves
4647 // and if UserSignalHandler is installed all bets are off.
4648 // Log that signal checking is off only if -verbose:jni is specified.
4649 if (CheckJNICalls) {
4650 if (libjsig_is_loaded) {
|
4429 //
4430 extern "C" JNIEXPORT int JVM_handle_linux_signal(int signo,
4431 siginfo_t* siginfo,
4432 void* ucontext,
4433 int abort_if_unrecognized);
4434
4435 static void signalHandler(int sig, siginfo_t* info, void* uc) {
4436 assert(info != NULL && uc != NULL, "it must be old kernel");
4437 int orig_errno = errno; // Preserve errno value over signal handler.
4438 JVM_handle_linux_signal(sig, info, uc, true);
4439 errno = orig_errno;
4440 }
4441
4442
4443 // This boolean allows users to forward their own non-matching signals
4444 // to JVM_handle_linux_signal, harmlessly.
4445 bool os::Linux::signal_handlers_are_installed = false;
4446
4447 // For signal-chaining
4448 struct sigaction sigact[NSIG];
4449 sigset_t sigs;
4450 bool os::Linux::libjsig_is_loaded = false;
4451 typedef struct sigaction *(*get_signal_t)(int);
4452 get_signal_t os::Linux::get_signal_action = NULL;
4453
4454 struct sigaction* os::Linux::get_chained_signal_action(int sig) {
4455 struct sigaction *actp = NULL;
4456
4457 if (libjsig_is_loaded) {
4458 // Retrieve the old signal handler from libjsig
4459 actp = (*get_signal_action)(sig);
4460 }
4461 if (actp == NULL) {
4462 // Retrieve the preinstalled signal handler from jvm
4463 actp = get_preinstalled_handler(sig);
4464 }
4465
4466 return actp;
4467 }
4468
4469 static bool call_chained_handler(struct sigaction *actp, int sig,
4508 // restore the signal mask
4509 pthread_sigmask(SIG_SETMASK, &oset, NULL);
4510 }
4511 // Tell jvm's signal handler the signal is taken care of.
4512 return true;
4513 }
4514
4515 bool os::Linux::chained_handler(int sig, siginfo_t* siginfo, void* context) {
4516 bool chained = false;
4517 // signal-chaining
4518 if (UseSignalChaining) {
4519 struct sigaction *actp = get_chained_signal_action(sig);
4520 if (actp != NULL) {
4521 chained = call_chained_handler(actp, sig, siginfo, context);
4522 }
4523 }
4524 return chained;
4525 }
4526
4527 struct sigaction* os::Linux::get_preinstalled_handler(int sig) {
4528 if (sigismember(&sigs, sig)) {
4529 return &sigact[sig];
4530 }
4531 return NULL;
4532 }
4533
4534 void os::Linux::save_preinstalled_handler(int sig, struct sigaction& oldAct) {
4535 assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
4536 sigact[sig] = oldAct;
4537 sigaddset(&sigs, sig);
4538 }
4539
4540 // for diagnostic
4541 int sigflags[NSIG];
4542
4543 int os::Linux::get_our_sigflags(int sig) {
4544 assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
4545 return sigflags[sig];
4546 }
4547
4548 void os::Linux::set_our_sigflags(int sig, int flags) {
4549 assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
4550 if (sig > 0 && sig < NSIG) {
4551 sigflags[sig] = flags;
4552 }
4553 }
4554
4555 void os::Linux::set_signal_handler(int sig, bool set_installed) {
4556 // Check for overwrite.
4557 struct sigaction oldAct;
4608
4609 // signal-chaining
4610 typedef void (*signal_setting_t)();
4611 signal_setting_t begin_signal_setting = NULL;
4612 signal_setting_t end_signal_setting = NULL;
4613 begin_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
4614 dlsym(RTLD_DEFAULT, "JVM_begin_signal_setting"));
4615 if (begin_signal_setting != NULL) {
4616 end_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
4617 dlsym(RTLD_DEFAULT, "JVM_end_signal_setting"));
4618 get_signal_action = CAST_TO_FN_PTR(get_signal_t,
4619 dlsym(RTLD_DEFAULT, "JVM_get_signal_action"));
4620 libjsig_is_loaded = true;
4621 assert(UseSignalChaining, "should enable signal-chaining");
4622 }
4623 if (libjsig_is_loaded) {
4624 // Tell libjsig jvm is setting signal handlers
4625 (*begin_signal_setting)();
4626 }
4627
4628 ::sigemptyset(&sigs);
4629 set_signal_handler(SIGSEGV, true);
4630 set_signal_handler(SIGPIPE, true);
4631 set_signal_handler(SIGBUS, true);
4632 set_signal_handler(SIGILL, true);
4633 set_signal_handler(SIGFPE, true);
4634 #if defined(PPC64)
4635 set_signal_handler(SIGTRAP, true);
4636 #endif
4637 set_signal_handler(SIGXFSZ, true);
4638
4639 if (libjsig_is_loaded) {
4640 // Tell libjsig jvm finishes setting signal handlers
4641 (*end_signal_setting)();
4642 }
4643
4644 // We don't activate signal checker if libjsig is in place, we trust ourselves
4645 // and if UserSignalHandler is installed all bets are off.
4646 // Log that signal checking is off only if -verbose:jni is specified.
4647 if (CheckJNICalls) {
4648 if (libjsig_is_loaded) {
|