2979
2980 // Renamed from 'signalHandler' to avoid collision with other shared libs.
2981 static void javaSignalHandler(int sig, siginfo_t* info, void* uc) {
2982 assert(info != NULL && uc != NULL, "it must be old kernel");
2983
2984 // Never leave program error signals blocked;
2985 // on all our platforms they would bring down the process immediately when
2986 // getting raised while being blocked.
2987 unblock_program_error_signals();
2988
2989 int orig_errno = errno; // Preserve errno value over signal handler.
2990 JVM_handle_aix_signal(sig, info, uc, true);
2991 errno = orig_errno;
2992 }
2993
2994 // This boolean allows users to forward their own non-matching signals
2995 // to JVM_handle_aix_signal, harmlessly.
2996 bool os::Aix::signal_handlers_are_installed = false;
2997
2998 // For signal-chaining
2999 struct sigaction sigact[NSIG];
3000 sigset_t sigs;
3001 bool os::Aix::libjsig_is_loaded = false;
3002 typedef struct sigaction *(*get_signal_t)(int);
3003 get_signal_t os::Aix::get_signal_action = NULL;
3004
3005 struct sigaction* os::Aix::get_chained_signal_action(int sig) {
3006 struct sigaction *actp = NULL;
3007
3008 if (libjsig_is_loaded) {
3009 // Retrieve the old signal handler from libjsig
3010 actp = (*get_signal_action)(sig);
3011 }
3012 if (actp == NULL) {
3013 // Retrieve the preinstalled signal handler from jvm
3014 actp = get_preinstalled_handler(sig);
3015 }
3016
3017 return actp;
3018 }
3019
3020 static bool call_chained_handler(struct sigaction *actp, int sig,
3021 siginfo_t *siginfo, void *context) {
3022 // Call the old signal handler
3023 if (actp->sa_handler == SIG_DFL) {
3024 // It's more reasonable to let jvm treat it as an unexpected exception
3025 // instead of taking the default action.
3026 return false;
3027 } else if (actp->sa_handler != SIG_IGN) {
3028 if ((actp->sa_flags & SA_NODEFER) == 0) {
3029 // automaticlly block the signal
3030 sigaddset(&(actp->sa_mask), sig);
3031 }
3032
3033 sa_handler_t hand = NULL;
3034 sa_sigaction_t sa = NULL;
3057
3058 // restore the signal mask
3059 pthread_sigmask(SIG_SETMASK, &oset, 0);
3060 }
3061 // Tell jvm's signal handler the signal is taken care of.
3062 return true;
3063 }
3064
3065 bool os::Aix::chained_handler(int sig, siginfo_t* siginfo, void* context) {
3066 bool chained = false;
3067 // signal-chaining
3068 if (UseSignalChaining) {
3069 struct sigaction *actp = get_chained_signal_action(sig);
3070 if (actp != NULL) {
3071 chained = call_chained_handler(actp, sig, siginfo, context);
3072 }
3073 }
3074 return chained;
3075 }
3076
3077 struct sigaction* os::Aix::get_preinstalled_handler(int sig) {
3078 if (sigismember(&sigs, sig)) {
3079 return &sigact[sig];
3080 }
3081 return NULL;
3082 }
3083
3084 void os::Aix::save_preinstalled_handler(int sig, struct sigaction& oldAct) {
3085 assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
3086 sigact[sig] = oldAct;
3087 sigaddset(&sigs, sig);
3088 }
3089
3090 // for diagnostic
3091 int sigflags[NSIG];
3092
3093 int os::Aix::get_our_sigflags(int sig) {
3094 assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
3095 return sigflags[sig];
3096 }
3097
3098 void os::Aix::set_our_sigflags(int sig, int flags) {
3099 assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
3100 if (sig > 0 && sig < NSIG) {
3101 sigflags[sig] = flags;
3102 }
3103 }
3104
3105 void os::Aix::set_signal_handler(int sig, bool set_installed) {
3106 // Check for overwrite.
3107 struct sigaction oldAct;
3108 sigaction(sig, (struct sigaction*)NULL, &oldAct);
3109
3110 void* oldhand = oldAct.sa_sigaction
3111 ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction)
3112 : CAST_FROM_FN_PTR(void*, oldAct.sa_handler);
3113 if (oldhand != CAST_FROM_FN_PTR(void*, SIG_DFL) &&
3114 oldhand != CAST_FROM_FN_PTR(void*, SIG_IGN) &&
3115 oldhand != CAST_FROM_FN_PTR(void*, (sa_sigaction_t)javaSignalHandler)) {
3116 if (AllowUserSignalHandlers || !set_installed) {
3117 // Do not overwrite; user takes responsibility to forward to us.
3118 return;
3119 } else if (UseSignalChaining) {
3120 // save the old handler in jvm
3121 save_preinstalled_handler(sig, oldAct);
3122 // libjsig also interposes the sigaction() call below and saves the
3123 // old sigaction on it own.
3124 } else {
3125 fatal("Encountered unexpected pre-existing sigaction handler "
3126 "%#lx for signal %d.", (long)oldhand, sig);
3127 }
3128 }
3129
3130 struct sigaction sigAct;
3131 sigfillset(&(sigAct.sa_mask));
3132 if (!set_installed) {
3133 sigAct.sa_handler = SIG_DFL;
3134 sigAct.sa_flags = SA_RESTART;
3135 } else {
3136 sigAct.sa_sigaction = javaSignalHandler;
3137 sigAct.sa_flags = SA_SIGINFO|SA_RESTART;
3138 }
3139 // Save flags, which are set by ours
3140 assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
3141 sigflags[sig] = sigAct.sa_flags;
3157
3158 // signal-chaining
3159 typedef void (*signal_setting_t)();
3160 signal_setting_t begin_signal_setting = NULL;
3161 signal_setting_t end_signal_setting = NULL;
3162 begin_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
3163 dlsym(RTLD_DEFAULT, "JVM_begin_signal_setting"));
3164 if (begin_signal_setting != NULL) {
3165 end_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
3166 dlsym(RTLD_DEFAULT, "JVM_end_signal_setting"));
3167 get_signal_action = CAST_TO_FN_PTR(get_signal_t,
3168 dlsym(RTLD_DEFAULT, "JVM_get_signal_action"));
3169 libjsig_is_loaded = true;
3170 assert(UseSignalChaining, "should enable signal-chaining");
3171 }
3172 if (libjsig_is_loaded) {
3173 // Tell libjsig jvm is setting signal handlers.
3174 (*begin_signal_setting)();
3175 }
3176
3177 ::sigemptyset(&sigs);
3178 set_signal_handler(SIGSEGV, true);
3179 set_signal_handler(SIGPIPE, true);
3180 set_signal_handler(SIGBUS, true);
3181 set_signal_handler(SIGILL, true);
3182 set_signal_handler(SIGFPE, true);
3183 set_signal_handler(SIGTRAP, true);
3184 set_signal_handler(SIGXFSZ, true);
3185
3186 if (libjsig_is_loaded) {
3187 // Tell libjsig jvm finishes setting signal handlers.
3188 (*end_signal_setting)();
3189 }
3190
3191 // We don't activate signal checker if libjsig is in place, we trust ourselves
3192 // and if UserSignalHandler is installed all bets are off.
3193 // Log that signal checking is off only if -verbose:jni is specified.
3194 if (CheckJNICalls) {
3195 if (libjsig_is_loaded) {
3196 tty->print_cr("Info: libjsig is activated, all active signal checking is disabled");
3197 check_signals = false;
|
2979
2980 // Renamed from 'signalHandler' to avoid collision with other shared libs.
2981 static void javaSignalHandler(int sig, siginfo_t* info, void* uc) {
2982 assert(info != NULL && uc != NULL, "it must be old kernel");
2983
2984 // Never leave program error signals blocked;
2985 // on all our platforms they would bring down the process immediately when
2986 // getting raised while being blocked.
2987 unblock_program_error_signals();
2988
2989 int orig_errno = errno; // Preserve errno value over signal handler.
2990 JVM_handle_aix_signal(sig, info, uc, true);
2991 errno = orig_errno;
2992 }
2993
2994 // This boolean allows users to forward their own non-matching signals
2995 // to JVM_handle_aix_signal, harmlessly.
2996 bool os::Aix::signal_handlers_are_installed = false;
2997
2998 // For signal-chaining
2999 bool os::Aix::libjsig_is_loaded = false;
3000 typedef struct sigaction *(*get_signal_t)(int);
3001 get_signal_t os::Aix::get_signal_action = NULL;
3002
3003 struct sigaction* os::Aix::get_chained_signal_action(int sig) {
3004 struct sigaction *actp = NULL;
3005
3006 if (libjsig_is_loaded) {
3007 // Retrieve the old signal handler from libjsig
3008 actp = (*get_signal_action)(sig);
3009 }
3010 if (actp == NULL) {
3011 // Retrieve the preinstalled signal handler from jvm
3012 actp = os::Posix::get_preinstalled_handler(sig);
3013 }
3014
3015 return actp;
3016 }
3017
3018 static bool call_chained_handler(struct sigaction *actp, int sig,
3019 siginfo_t *siginfo, void *context) {
3020 // Call the old signal handler
3021 if (actp->sa_handler == SIG_DFL) {
3022 // It's more reasonable to let jvm treat it as an unexpected exception
3023 // instead of taking the default action.
3024 return false;
3025 } else if (actp->sa_handler != SIG_IGN) {
3026 if ((actp->sa_flags & SA_NODEFER) == 0) {
3027 // automaticlly block the signal
3028 sigaddset(&(actp->sa_mask), sig);
3029 }
3030
3031 sa_handler_t hand = NULL;
3032 sa_sigaction_t sa = NULL;
3055
3056 // restore the signal mask
3057 pthread_sigmask(SIG_SETMASK, &oset, 0);
3058 }
3059 // Tell jvm's signal handler the signal is taken care of.
3060 return true;
3061 }
3062
3063 bool os::Aix::chained_handler(int sig, siginfo_t* siginfo, void* context) {
3064 bool chained = false;
3065 // signal-chaining
3066 if (UseSignalChaining) {
3067 struct sigaction *actp = get_chained_signal_action(sig);
3068 if (actp != NULL) {
3069 chained = call_chained_handler(actp, sig, siginfo, context);
3070 }
3071 }
3072 return chained;
3073 }
3074
3075 // for diagnostic
3076 int sigflags[NSIG];
3077
3078 int os::Aix::get_our_sigflags(int sig) {
3079 assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
3080 return sigflags[sig];
3081 }
3082
3083 void os::Aix::set_our_sigflags(int sig, int flags) {
3084 assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
3085 if (sig > 0 && sig < NSIG) {
3086 sigflags[sig] = flags;
3087 }
3088 }
3089
3090 void os::Aix::set_signal_handler(int sig, bool set_installed) {
3091 // Check for overwrite.
3092 struct sigaction oldAct;
3093 sigaction(sig, (struct sigaction*)NULL, &oldAct);
3094
3095 void* oldhand = oldAct.sa_sigaction
3096 ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction)
3097 : CAST_FROM_FN_PTR(void*, oldAct.sa_handler);
3098 if (oldhand != CAST_FROM_FN_PTR(void*, SIG_DFL) &&
3099 oldhand != CAST_FROM_FN_PTR(void*, SIG_IGN) &&
3100 oldhand != CAST_FROM_FN_PTR(void*, (sa_sigaction_t)javaSignalHandler)) {
3101 if (AllowUserSignalHandlers || !set_installed) {
3102 // Do not overwrite; user takes responsibility to forward to us.
3103 return;
3104 } else if (UseSignalChaining) {
3105 // save the old handler in jvm
3106 os::Posix::save_preinstalled_handler(sig, oldAct);
3107 // libjsig also interposes the sigaction() call below and saves the
3108 // old sigaction on it own.
3109 } else {
3110 fatal("Encountered unexpected pre-existing sigaction handler "
3111 "%#lx for signal %d.", (long)oldhand, sig);
3112 }
3113 }
3114
3115 struct sigaction sigAct;
3116 sigfillset(&(sigAct.sa_mask));
3117 if (!set_installed) {
3118 sigAct.sa_handler = SIG_DFL;
3119 sigAct.sa_flags = SA_RESTART;
3120 } else {
3121 sigAct.sa_sigaction = javaSignalHandler;
3122 sigAct.sa_flags = SA_SIGINFO|SA_RESTART;
3123 }
3124 // Save flags, which are set by ours
3125 assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
3126 sigflags[sig] = sigAct.sa_flags;
3142
3143 // signal-chaining
3144 typedef void (*signal_setting_t)();
3145 signal_setting_t begin_signal_setting = NULL;
3146 signal_setting_t end_signal_setting = NULL;
3147 begin_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
3148 dlsym(RTLD_DEFAULT, "JVM_begin_signal_setting"));
3149 if (begin_signal_setting != NULL) {
3150 end_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
3151 dlsym(RTLD_DEFAULT, "JVM_end_signal_setting"));
3152 get_signal_action = CAST_TO_FN_PTR(get_signal_t,
3153 dlsym(RTLD_DEFAULT, "JVM_get_signal_action"));
3154 libjsig_is_loaded = true;
3155 assert(UseSignalChaining, "should enable signal-chaining");
3156 }
3157 if (libjsig_is_loaded) {
3158 // Tell libjsig jvm is setting signal handlers.
3159 (*begin_signal_setting)();
3160 }
3161
3162 os::Posix::init_sigs();
3163 set_signal_handler(SIGSEGV, true);
3164 set_signal_handler(SIGPIPE, true);
3165 set_signal_handler(SIGBUS, true);
3166 set_signal_handler(SIGILL, true);
3167 set_signal_handler(SIGFPE, true);
3168 set_signal_handler(SIGTRAP, true);
3169 set_signal_handler(SIGXFSZ, true);
3170
3171 if (libjsig_is_loaded) {
3172 // Tell libjsig jvm finishes setting signal handlers.
3173 (*end_signal_setting)();
3174 }
3175
3176 // We don't activate signal checker if libjsig is in place, we trust ourselves
3177 // and if UserSignalHandler is installed all bets are off.
3178 // Log that signal checking is off only if -verbose:jni is specified.
3179 if (CheckJNICalls) {
3180 if (libjsig_is_loaded) {
3181 tty->print_cr("Info: libjsig is activated, all active signal checking is disabled");
3182 check_signals = false;
|