sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 1 | |
| 2 | /*--------------------------------------------------------------------*/ |
njn | ed6b824 | 2005-06-01 00:03:17 +0000 | [diff] [blame] | 3 | /*--- Implementation of POSIX signals. m_signals.c ---*/ |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 4 | /*--------------------------------------------------------------------*/ |
njn | ed6b824 | 2005-06-01 00:03:17 +0000 | [diff] [blame] | 5 | |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 6 | /* |
njn | b9c427c | 2004-12-01 14:14:42 +0000 | [diff] [blame] | 7 | This file is part of Valgrind, a dynamic binary instrumentation |
| 8 | framework. |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 9 | |
njn | 5361242 | 2005-03-12 16:22:54 +0000 | [diff] [blame] | 10 | Copyright (C) 2000-2005 Julian Seward |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 11 | jseward@acm.org |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 12 | |
| 13 | This program is free software; you can redistribute it and/or |
| 14 | modify it under the terms of the GNU General Public License as |
| 15 | published by the Free Software Foundation; either version 2 of the |
| 16 | License, or (at your option) any later version. |
| 17 | |
| 18 | This program is distributed in the hope that it will be useful, but |
| 19 | WITHOUT ANY WARRANTY; without even the implied warranty of |
| 20 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 21 | General Public License for more details. |
| 22 | |
| 23 | You should have received a copy of the GNU General Public License |
| 24 | along with this program; if not, write to the Free Software |
| 25 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA |
| 26 | 02111-1307, USA. |
| 27 | |
njn25 | e49d8e7 | 2002-09-23 09:36:25 +0000 | [diff] [blame] | 28 | The GNU General Public License is contained in the file COPYING. |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 29 | */ |
| 30 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 31 | /* |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 32 | Signal handling. |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 33 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 34 | There are 4 distinct classes of signal: |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 35 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 36 | 1. Synchronous, instruction-generated (SIGILL, FPE, BUS, SEGV and |
| 37 | TRAP): these are signals as a result of an instruction fault. If |
| 38 | we get one while running client code, then we just do the |
| 39 | appropriate thing. If it happens while running Valgrind code, then |
| 40 | it indicates a Valgrind bug. Note that we "manually" implement |
| 41 | automatic stack growth, such that if a fault happens near the |
| 42 | client process stack, it is extended in the same way the kernel |
| 43 | would, and the fault is never reported to the client program. |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 44 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 45 | 2. Asynchronous varients of the above signals: If the kernel tries |
| 46 | to deliver a sync signal while it is blocked, it just kills the |
| 47 | process. Therefore, we can't block those signals if we want to be |
| 48 | able to report on bugs in Valgrind. This means that we're also |
| 49 | open to receiving those signals from other processes, sent with |
| 50 | kill. We could get away with just dropping them, since they aren't |
| 51 | really signals that processes send to each other. |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 52 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 53 | 3. Synchronous, general signals. If a thread/process sends itself |
| 54 | a signal with kill, its expected to be synchronous: ie, the signal |
| 55 | will have been delivered by the time the syscall finishes. |
| 56 | |
| 57 | 4. Asyncronous, general signals. All other signals, sent by |
| 58 | another process with kill. These are generally blocked, except for |
| 59 | two special cases: we poll for them each time we're about to run a |
| 60 | thread for a time quanta, and while running blocking syscalls. |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 61 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 62 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 63 | In addition, we define two signals for internal use: SIGVGCHLD and |
| 64 | SIGVGKILL. SIGVGCHLD is used to indicate thread death to any |
| 65 | reaping thread (the master thread). It is always blocked and never |
| 66 | delivered as a signal; it is always polled with sigtimedwait. |
| 67 | |
| 68 | SIGVGKILL is used to terminate threads. When one thread wants |
| 69 | another to exit, it will set its exitreason and send it SIGVGKILL |
| 70 | if it appears to be blocked in a syscall. |
| 71 | |
| 72 | |
| 73 | We use a kernel thread for each application thread. When the |
| 74 | thread allows itself to be open to signals, it sets the thread |
| 75 | signal mask to what the client application set it to. This means |
| 76 | that we get the kernel to do all signal routing: under Valgrind, |
| 77 | signals get delivered in the same way as in the non-Valgrind case |
| 78 | (the exception being for the sync signal set, since they're almost |
| 79 | always unblocked). |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 80 | */ |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 81 | |
njn | c7561b9 | 2005-06-19 01:24:32 +0000 | [diff] [blame] | 82 | #include "pub_core_basics.h" |
| 83 | #include "pub_core_threadstate.h" |
njn | 899ce73 | 2005-06-21 00:28:11 +0000 | [diff] [blame] | 84 | #include "pub_core_debuginfo.h" // Needed for pub_core_aspacemgr :( |
njn | 2521d32 | 2005-05-08 14:45:13 +0000 | [diff] [blame] | 85 | #include "pub_core_aspacemgr.h" |
njn | 634a652 | 2005-07-02 01:59:28 +0000 | [diff] [blame] | 86 | #include "pub_core_debugger.h" // For VG_(start_debugger) |
njn | d2b1711 | 2005-04-19 04:10:25 +0000 | [diff] [blame] | 87 | #include "pub_core_errormgr.h" |
njn | 97405b2 | 2005-06-02 03:39:33 +0000 | [diff] [blame] | 88 | #include "pub_core_libcbase.h" |
njn | 132bfcc | 2005-06-04 19:16:06 +0000 | [diff] [blame] | 89 | #include "pub_core_libcassert.h" |
njn | e9befc6 | 2005-06-11 15:51:30 +0000 | [diff] [blame] | 90 | #include "pub_core_libcmman.h" |
njn | 36a20fa | 2005-06-03 03:08:39 +0000 | [diff] [blame] | 91 | #include "pub_core_libcprint.h" |
njn | f39e9a3 | 2005-06-12 02:43:17 +0000 | [diff] [blame] | 92 | #include "pub_core_libcproc.h" |
njn | de62cbf | 2005-06-10 22:08:14 +0000 | [diff] [blame] | 93 | #include "pub_core_libcsignal.h" |
njn | f536bbb | 2005-06-13 04:21:38 +0000 | [diff] [blame] | 94 | #include "pub_core_machine.h" |
njn | af1d7df | 2005-06-11 01:31:52 +0000 | [diff] [blame] | 95 | #include "pub_core_mallocfree.h" |
njn | 2024234 | 2005-05-16 23:31:24 +0000 | [diff] [blame] | 96 | #include "pub_core_options.h" |
njn | c7561b9 | 2005-06-19 01:24:32 +0000 | [diff] [blame] | 97 | #include "pub_core_scheduler.h" |
njn | 0c24647 | 2005-05-31 01:00:08 +0000 | [diff] [blame] | 98 | #include "pub_core_signals.h" |
njn | 24a6efb | 2005-06-20 03:36:51 +0000 | [diff] [blame] | 99 | #include "pub_core_sigframe.h" // For VG_(sigframe_create)() |
njn | 945ed2e | 2005-06-24 03:28:30 +0000 | [diff] [blame] | 100 | #include "pub_core_stacks.h" // For VG_(change_stack)() |
njn | 24a6efb | 2005-06-20 03:36:51 +0000 | [diff] [blame] | 101 | #include "pub_core_stacktrace.h" // For VG_(get_and_pp_StackTrace)() |
njn | 9abd608 | 2005-06-17 21:31:45 +0000 | [diff] [blame] | 102 | #include "pub_core_syscall.h" |
njn | c1b0181 | 2005-06-17 22:19:06 +0000 | [diff] [blame] | 103 | #include "pub_core_syswrap.h" |
njn | 43b9a8a | 2005-05-10 04:37:01 +0000 | [diff] [blame] | 104 | #include "pub_core_tooliface.h" |
njn | 9abd608 | 2005-06-17 21:31:45 +0000 | [diff] [blame] | 105 | #include "vki_unistd.h" |
sewardj | 985fabb | 2005-04-24 14:18:14 +0000 | [diff] [blame] | 106 | |
njn | d2b1711 | 2005-04-19 04:10:25 +0000 | [diff] [blame] | 107 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 108 | /* Define to give more sanity checking for signals. */ |
| 109 | #define DEBUG_SIGNALS |
| 110 | |
| 111 | |
| 112 | /* --------------------------------------------------------------------- |
| 113 | Forwards decls. |
| 114 | ------------------------------------------------------------------ */ |
| 115 | |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 116 | static void sync_signalhandler ( Int sigNo, vki_siginfo_t *info, struct vki_ucontext * ); |
| 117 | static void async_signalhandler ( Int sigNo, vki_siginfo_t *info, struct vki_ucontext * ); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 118 | static void sigvgkill_handler ( Int sigNo, vki_siginfo_t *info, struct vki_ucontext * ); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 119 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 120 | static const Char *signame(Int sigNo); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 121 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 122 | /* Maximum usable signal. */ |
| 123 | Int VG_(max_signal) = _VKI_NSIG; |
nethercote | 759dda3 | 2004-08-07 18:16:56 +0000 | [diff] [blame] | 124 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 125 | #define N_QUEUED_SIGNALS 8 |
nethercote | 759dda3 | 2004-08-07 18:16:56 +0000 | [diff] [blame] | 126 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 127 | typedef struct SigQueue { |
| 128 | Int next; |
| 129 | vki_siginfo_t sigs[N_QUEUED_SIGNALS]; |
| 130 | } SigQueue; |
nethercote | 759dda3 | 2004-08-07 18:16:56 +0000 | [diff] [blame] | 131 | |
njn | 605f488 | 2005-05-29 17:50:40 +0000 | [diff] [blame] | 132 | #if defined(VGP_x86_linux) |
njn | af839f5 | 2005-06-23 03:27:57 +0000 | [diff] [blame] | 133 | # define VG_UCONTEXT_INSTR_PTR(uc) ((uc)->uc_mcontext.eip) |
| 134 | # define VG_UCONTEXT_STACK_PTR(uc) ((uc)->uc_mcontext.esp) |
| 135 | # define VG_UCONTEXT_FRAME_PTR(uc) ((uc)->uc_mcontext.ebp) |
| 136 | # define VG_UCONTEXT_SYSCALL_NUM(uc) ((uc)->uc_mcontext.eax) |
sewardj | acaec5f | 2005-08-19 16:02:59 +0000 | [diff] [blame] | 137 | # define VG_UCONTEXT_SYSCALL_SYSRES(uc) \ |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 138 | /* Convert the value in uc_mcontext.eax into a SysRes. */ \ |
cerion | 85665ca | 2005-06-20 15:51:07 +0000 | [diff] [blame] | 139 | VG_(mk_SysRes_x86_linux)( (uc)->uc_mcontext.eax ) |
sewardj | acaec5f | 2005-08-19 16:02:59 +0000 | [diff] [blame] | 140 | # define VG_UCONTEXT_LINK_REG(uc) 0 /* Dude, where's my LR? */ |
sewardj | e7aa4ae | 2005-06-09 12:43:42 +0000 | [diff] [blame] | 141 | |
njn | 605f488 | 2005-05-29 17:50:40 +0000 | [diff] [blame] | 142 | #elif defined(VGP_amd64_linux) |
njn | af839f5 | 2005-06-23 03:27:57 +0000 | [diff] [blame] | 143 | # define VG_UCONTEXT_INSTR_PTR(uc) ((uc)->uc_mcontext.rip) |
| 144 | # define VG_UCONTEXT_STACK_PTR(uc) ((uc)->uc_mcontext.rsp) |
| 145 | # define VG_UCONTEXT_FRAME_PTR(uc) ((uc)->uc_mcontext.rbp) |
| 146 | # define VG_UCONTEXT_SYSCALL_NUM(uc) ((uc)->uc_mcontext.rax) |
sewardj | acaec5f | 2005-08-19 16:02:59 +0000 | [diff] [blame] | 147 | # define VG_UCONTEXT_SYSCALL_SYSRES(uc) \ |
sewardj | e7aa4ae | 2005-06-09 12:43:42 +0000 | [diff] [blame] | 148 | /* Convert the value in uc_mcontext.rax into a SysRes. */ \ |
cerion | 85665ca | 2005-06-20 15:51:07 +0000 | [diff] [blame] | 149 | VG_(mk_SysRes_amd64_linux)( (uc)->uc_mcontext.rax ) |
sewardj | acaec5f | 2005-08-19 16:02:59 +0000 | [diff] [blame] | 150 | # define VG_UCONTEXT_LINK_REG(uc) 0 /* No LR on amd64 either */ |
sewardj | e7aa4ae | 2005-06-09 12:43:42 +0000 | [diff] [blame] | 151 | |
cerion | 85665ca | 2005-06-20 15:51:07 +0000 | [diff] [blame] | 152 | #elif defined(VGP_ppc32_linux) |
njn | af839f5 | 2005-06-23 03:27:57 +0000 | [diff] [blame] | 153 | # define VG_UCONTEXT_INSTR_PTR(uc) ((uc)->uc_mcontext.mc_gregs[VKI_PT_NIP]) |
| 154 | # define VG_UCONTEXT_STACK_PTR(uc) ((uc)->uc_mcontext.mc_gregs[1]) |
| 155 | # define VG_UCONTEXT_FRAME_PTR(uc) ((uc)->uc_mcontext.mc_gregs[1]) |
| 156 | # define VG_UCONTEXT_SYSCALL_NUM(uc) ((uc)->uc_mcontext.mc_gregs[0]) |
sewardj | acaec5f | 2005-08-19 16:02:59 +0000 | [diff] [blame] | 157 | # define VG_UCONTEXT_SYSCALL_SYSRES(uc) \ |
cerion | 85665ca | 2005-06-20 15:51:07 +0000 | [diff] [blame] | 158 | /* Convert the values in uc_mcontext r3,cr into a SysRes. */ \ |
| 159 | VG_(mk_SysRes_ppc32_linux)( (uc)->uc_mcontext.mc_gregs[3], \ |
| 160 | (uc)->uc_mcontext.mc_gregs[VKI_PT_CCR] ) |
sewardj | acaec5f | 2005-08-19 16:02:59 +0000 | [diff] [blame] | 161 | # define VG_UCONTEXT_LINK_REG(uc) ((uc)->uc_mcontext.mc_gregs[VKI_PT_LNK]) |
cerion | 85665ca | 2005-06-20 15:51:07 +0000 | [diff] [blame] | 162 | |
njn | 605f488 | 2005-05-29 17:50:40 +0000 | [diff] [blame] | 163 | #else |
| 164 | # error Unknown platform |
| 165 | #endif |
| 166 | |
nethercote | 759dda3 | 2004-08-07 18:16:56 +0000 | [diff] [blame] | 167 | /* --------------------------------------------------------------------- |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 168 | HIGH LEVEL STUFF TO DO WITH SIGNALS: POLICY (MOSTLY) |
| 169 | ------------------------------------------------------------------ */ |
| 170 | |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 171 | /* --------------------------------------------------------------------- |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 172 | Signal state for this process. |
| 173 | ------------------------------------------------------------------ */ |
| 174 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 175 | |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 176 | /* Base-ment of these arrays[_VKI_NSIG]. |
sewardj | b48e500 | 2002-05-13 00:16:03 +0000 | [diff] [blame] | 177 | |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 178 | Valid signal numbers are 1 .. _VKI_NSIG inclusive. |
sewardj | b48e500 | 2002-05-13 00:16:03 +0000 | [diff] [blame] | 179 | Rather than subtracting 1 for indexing these arrays, which |
| 180 | is tedious and error-prone, they are simply dimensioned 1 larger, |
| 181 | and entry [0] is not used. |
| 182 | */ |
| 183 | |
sewardj | b48e500 | 2002-05-13 00:16:03 +0000 | [diff] [blame] | 184 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 185 | /* ----------------------------------------------------- |
| 186 | Static client signal state (SCSS). This is the state |
| 187 | that the client thinks it has the kernel in. |
| 188 | SCSS records verbatim the client's settings. These |
| 189 | are mashed around only when SKSS is calculated from it. |
| 190 | -------------------------------------------------- */ |
sewardj | b48e500 | 2002-05-13 00:16:03 +0000 | [diff] [blame] | 191 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 192 | typedef |
| 193 | struct { |
| 194 | void* scss_handler; /* VKI_SIG_DFL or VKI_SIG_IGN or ptr to |
| 195 | client's handler */ |
| 196 | UInt scss_flags; |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 197 | vki_sigset_t scss_mask; |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 198 | void* scss_restorer; /* where sigreturn goes */ |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 199 | } |
| 200 | SCSS_Per_Signal; |
sewardj | b48e500 | 2002-05-13 00:16:03 +0000 | [diff] [blame] | 201 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 202 | typedef |
| 203 | struct { |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 204 | /* per-signal info */ |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 205 | SCSS_Per_Signal scss_per_sig[1+_VKI_NSIG]; |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 206 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 207 | /* Additional elements to SCSS not stored here: |
| 208 | - for each thread, the thread's blocking mask |
| 209 | - for each thread in WaitSIG, the set of waited-on sigs |
| 210 | */ |
| 211 | } |
| 212 | SCSS; |
sewardj | b48e500 | 2002-05-13 00:16:03 +0000 | [diff] [blame] | 213 | |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 214 | static SCSS scss; |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 215 | |
| 216 | |
| 217 | /* ----------------------------------------------------- |
| 218 | Static kernel signal state (SKSS). This is the state |
| 219 | that we have the kernel in. It is computed from SCSS. |
| 220 | -------------------------------------------------- */ |
| 221 | |
| 222 | /* Let's do: |
| 223 | sigprocmask assigns to all thread masks |
| 224 | so that at least everything is always consistent |
| 225 | Flags: |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 226 | SA_SIGINFO -- we always set it, and honour it for the client |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 227 | SA_NOCLDSTOP -- passed to kernel |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 228 | SA_ONESHOT or SA_RESETHAND -- pass through |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 229 | SA_RESTART -- we observe this but set our handlers to always restart |
| 230 | SA_NOMASK or SA_NODEFER -- we observe this, but our handlers block everything |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 231 | SA_ONSTACK -- pass through |
| 232 | SA_NOCLDWAIT -- pass through |
sewardj | b48e500 | 2002-05-13 00:16:03 +0000 | [diff] [blame] | 233 | */ |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 234 | |
sewardj | 77e466c | 2002-04-14 02:29:29 +0000 | [diff] [blame] | 235 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 236 | typedef |
| 237 | struct { |
| 238 | void* skss_handler; /* VKI_SIG_DFL or VKI_SIG_IGN |
| 239 | or ptr to our handler */ |
| 240 | UInt skss_flags; |
| 241 | /* There is no skss_mask, since we know that we will always ask |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 242 | for all signals to be blocked in our sighandlers. */ |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 243 | /* Also there is no skss_restorer. */ |
| 244 | } |
| 245 | SKSS_Per_Signal; |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 246 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 247 | typedef |
| 248 | struct { |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 249 | SKSS_Per_Signal skss_per_sig[1+_VKI_NSIG]; |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 250 | } |
| 251 | SKSS; |
| 252 | |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 253 | static SKSS skss; |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 254 | |
njn | 07ef6c0 | 2005-05-18 19:43:09 +0000 | [diff] [blame] | 255 | static Bool is_sig_ign(Int sigNo) |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 256 | { |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 257 | vg_assert(sigNo >= 1 && sigNo <= _VKI_NSIG); |
sewardj | 2e93c50 | 2002-04-12 11:12:52 +0000 | [diff] [blame] | 258 | |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 259 | return scss.scss_per_sig[sigNo].scss_handler == VKI_SIG_IGN; |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 260 | } |
sewardj | b48e500 | 2002-05-13 00:16:03 +0000 | [diff] [blame] | 261 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 262 | /* --------------------------------------------------------------------- |
| 263 | Compute the SKSS required by the current SCSS. |
| 264 | ------------------------------------------------------------------ */ |
| 265 | |
sewardj | 4f29ddf | 2002-05-03 22:29:04 +0000 | [diff] [blame] | 266 | static |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 267 | void pp_SKSS ( void ) |
| 268 | { |
| 269 | Int sig; |
| 270 | VG_(printf)("\n\nSKSS:\n"); |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 271 | for (sig = 1; sig <= _VKI_NSIG; sig++) { |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 272 | VG_(printf)("sig %d: handler 0x%x, flags 0x%x\n", sig, |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 273 | skss.skss_per_sig[sig].skss_handler, |
| 274 | skss.skss_per_sig[sig].skss_flags ); |
sewardj | 77e466c | 2002-04-14 02:29:29 +0000 | [diff] [blame] | 275 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 276 | } |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 277 | } |
| 278 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 279 | /* This is the core, clever bit. Computation is as follows: |
| 280 | |
| 281 | For each signal |
| 282 | handler = if client has a handler, then our handler |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 283 | else if client is DFL, then our handler as well |
| 284 | else (client must be IGN) |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 285 | then hander is IGN |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 286 | */ |
| 287 | static |
| 288 | void calculate_SKSS_from_SCSS ( SKSS* dst ) |
| 289 | { |
| 290 | Int sig; |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 291 | UInt scss_flags; |
| 292 | UInt skss_flags; |
| 293 | |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 294 | for (sig = 1; sig <= _VKI_NSIG; sig++) { |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 295 | void *skss_handler; |
| 296 | void *scss_handler; |
| 297 | |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 298 | scss_handler = scss.scss_per_sig[sig].scss_handler; |
| 299 | scss_flags = scss.scss_per_sig[sig].scss_flags; |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 300 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 301 | switch(sig) { |
| 302 | case VKI_SIGSEGV: |
| 303 | case VKI_SIGBUS: |
| 304 | case VKI_SIGFPE: |
| 305 | case VKI_SIGILL: |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 306 | case VKI_SIGTRAP: |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 307 | /* For these, we always want to catch them and report, even |
| 308 | if the client code doesn't. */ |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 309 | skss_handler = sync_signalhandler; |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 310 | break; |
| 311 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 312 | case VKI_SIGCONT: |
| 313 | /* Let the kernel handle SIGCONT unless the client is actually |
| 314 | catching it. */ |
njn | a530fc6 | 2005-03-13 04:46:36 +0000 | [diff] [blame] | 315 | case VKI_SIGCHLD: |
| 316 | case VKI_SIGWINCH: |
| 317 | case VKI_SIGURG: |
| 318 | /* For signals which are have a default action of Ignore, |
| 319 | only set a handler if the client has set a signal handler. |
| 320 | Otherwise the kernel will interrupt a syscall which |
| 321 | wouldn't have otherwise been interrupted. */ |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 322 | if (scss.scss_per_sig[sig].scss_handler == VKI_SIG_DFL) |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 323 | skss_handler = VKI_SIG_DFL; |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 324 | else if (scss.scss_per_sig[sig].scss_handler == VKI_SIG_IGN) |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 325 | skss_handler = VKI_SIG_IGN; |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 326 | else |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 327 | skss_handler = async_signalhandler; |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 328 | break; |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 329 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 330 | default: |
njn | a530fc6 | 2005-03-13 04:46:36 +0000 | [diff] [blame] | 331 | // VKI_SIGVG* are runtime variables, so we can't make them |
| 332 | // cases in the switch, so we handle them in the 'default' case. |
njn | 351d006 | 2005-06-21 22:23:59 +0000 | [diff] [blame] | 333 | if (sig == VG_SIGVGKILL) |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 334 | skss_handler = sigvgkill_handler; |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 335 | else { |
| 336 | if (scss_handler == VKI_SIG_IGN) |
| 337 | skss_handler = VKI_SIG_IGN; |
| 338 | else |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 339 | skss_handler = async_signalhandler; |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 340 | } |
| 341 | break; |
| 342 | } |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 343 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 344 | /* Flags */ |
| 345 | |
| 346 | skss_flags = 0; |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 347 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 348 | /* SA_NOCLDSTOP, SA_NOCLDWAIT: pass to kernel */ |
| 349 | skss_flags |= scss_flags & (VKI_SA_NOCLDSTOP | VKI_SA_NOCLDWAIT); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 350 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 351 | /* SA_ONESHOT: ignore client setting */ |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 352 | |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 353 | /* SA_RESTART: ignore client setting and always set it for us. |
| 354 | Though we never rely on the kernel to restart a |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 355 | syscall, we observe whether it wanted to restart the syscall |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 356 | or not, which is needed by |
| 357 | VG_(fixup_guest_state_after_syscall_interrupted) */ |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 358 | skss_flags |= VKI_SA_RESTART; |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 359 | |
| 360 | /* SA_NOMASK: ignore it */ |
| 361 | |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 362 | /* SA_ONSTACK: client setting is irrelevant here */ |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 363 | /* We don't set a signal stack, so ignore */ |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 364 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 365 | /* always ask for SA_SIGINFO */ |
| 366 | skss_flags |= VKI_SA_SIGINFO; |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 367 | |
fitzhardinge | 4f10ada | 2004-06-03 10:00:42 +0000 | [diff] [blame] | 368 | /* use our own restorer */ |
| 369 | skss_flags |= VKI_SA_RESTORER; |
| 370 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 371 | /* Create SKSS entry for this signal. */ |
sewardj | 6a3c26e | 2002-05-23 17:09:43 +0000 | [diff] [blame] | 372 | if (sig != VKI_SIGKILL && sig != VKI_SIGSTOP) |
| 373 | dst->skss_per_sig[sig].skss_handler = skss_handler; |
| 374 | else |
| 375 | dst->skss_per_sig[sig].skss_handler = VKI_SIG_DFL; |
| 376 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 377 | dst->skss_per_sig[sig].skss_flags = skss_flags; |
| 378 | } |
| 379 | |
| 380 | /* Sanity checks. */ |
nethercote | 5fd72bb | 2004-11-04 19:28:38 +0000 | [diff] [blame] | 381 | vg_assert(dst->skss_per_sig[VKI_SIGKILL].skss_handler == VKI_SIG_DFL); |
| 382 | vg_assert(dst->skss_per_sig[VKI_SIGSTOP].skss_handler == VKI_SIG_DFL); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 383 | |
| 384 | if (0) |
| 385 | pp_SKSS(); |
| 386 | } |
| 387 | |
| 388 | |
| 389 | /* --------------------------------------------------------------------- |
| 390 | After a possible SCSS change, update SKSS and the kernel itself. |
| 391 | ------------------------------------------------------------------ */ |
| 392 | |
njn | 9abd608 | 2005-06-17 21:31:45 +0000 | [diff] [blame] | 393 | // We need two levels of macro-expansion here to convert __NR_rt_sigreturn |
| 394 | // to a number before converting it to a string... sigh. |
tom | 3a08815 | 2005-06-22 12:11:42 +0000 | [diff] [blame] | 395 | static void my_sigreturn(void); |
njn | 9abd608 | 2005-06-17 21:31:45 +0000 | [diff] [blame] | 396 | |
| 397 | #if defined(VGP_x86_linux) |
| 398 | # define _MYSIG(name) \ |
| 399 | "my_sigreturn:\n" \ |
| 400 | " movl $" #name ", %eax\n" \ |
| 401 | " int $0x80\n" |
| 402 | #elif defined(VGP_amd64_linux) |
| 403 | # define _MYSIG(name) \ |
| 404 | "my_sigreturn:\n" \ |
| 405 | " movq $" #name ", %rax\n" \ |
| 406 | " syscall\n" |
cerion | 85665ca | 2005-06-20 15:51:07 +0000 | [diff] [blame] | 407 | #elif defined(VGP_ppc32_linux) |
| 408 | # define _MYSIG(name) \ |
| 409 | "my_sigreturn:\n" \ |
| 410 | " li 0, " #name "\n" \ |
| 411 | " sc\n" |
njn | 9abd608 | 2005-06-17 21:31:45 +0000 | [diff] [blame] | 412 | #else |
| 413 | # error Unknown platform |
| 414 | #endif |
| 415 | |
| 416 | #define MYSIG(name) _MYSIG(name) |
| 417 | asm( |
| 418 | MYSIG(__NR_rt_sigreturn) |
| 419 | ); |
| 420 | |
| 421 | |
nethercote | 9dd1151 | 2004-08-04 15:31:30 +0000 | [diff] [blame] | 422 | static void handle_SCSS_change ( Bool force_update ) |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 423 | { |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 424 | Int res, sig; |
| 425 | SKSS skss_old; |
| 426 | struct vki_sigaction ksa, ksa_old; |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 427 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 428 | /* Remember old SKSS and calculate new one. */ |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 429 | skss_old = skss; |
| 430 | calculate_SKSS_from_SCSS ( &skss ); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 431 | |
| 432 | /* Compare the new SKSS entries vs the old ones, and update kernel |
| 433 | where they differ. */ |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 434 | for (sig = 1; sig <= VG_(max_signal); sig++) { |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 435 | |
| 436 | /* Trying to do anything with SIGKILL is pointless; just ignore |
| 437 | it. */ |
| 438 | if (sig == VKI_SIGKILL || sig == VKI_SIGSTOP) |
| 439 | continue; |
| 440 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 441 | if (!force_update) { |
| 442 | if ((skss_old.skss_per_sig[sig].skss_handler |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 443 | == skss.skss_per_sig[sig].skss_handler) |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 444 | && (skss_old.skss_per_sig[sig].skss_flags |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 445 | == skss.skss_per_sig[sig].skss_flags)) |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 446 | /* no difference */ |
| 447 | continue; |
| 448 | } |
| 449 | |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 450 | ksa.ksa_handler = skss.skss_per_sig[sig].skss_handler; |
| 451 | ksa.sa_flags = skss.skss_per_sig[sig].skss_flags; |
sewardj | ce2a615 | 2005-07-08 18:25:13 +0000 | [diff] [blame] | 452 | # if !defined(VGP_ppc32_linux) |
njn | 9abd608 | 2005-06-17 21:31:45 +0000 | [diff] [blame] | 453 | ksa.sa_restorer = my_sigreturn; |
sewardj | ce2a615 | 2005-07-08 18:25:13 +0000 | [diff] [blame] | 454 | # endif |
sewardj | 162bebd | 2005-07-09 10:43:45 +0000 | [diff] [blame] | 455 | /* Re above ifdef (also the assertion below), PaulM says: |
| 456 | The sa_restorer field is not used at all on ppc. Glibc |
| 457 | converts the sigaction you give it into a kernel sigaction, |
| 458 | but it doesn't put anything in the sa_restorer field. |
| 459 | */ |
fitzhardinge | 4f10ada | 2004-06-03 10:00:42 +0000 | [diff] [blame] | 460 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 461 | /* block all signals in handler */ |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 462 | VG_(sigfillset)( &ksa.sa_mask ); |
| 463 | VG_(sigdelset)( &ksa.sa_mask, VKI_SIGKILL ); |
| 464 | VG_(sigdelset)( &ksa.sa_mask, VKI_SIGSTOP ); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 465 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 466 | if (VG_(clo_trace_signals) && VG_(clo_verbosity) > 2) |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 467 | VG_(message)(Vg_DebugMsg, |
| 468 | "setting ksig %d to: hdlr 0x%x, flags 0x%x, " |
| 469 | "mask(63..0) 0x%x 0x%x", |
| 470 | sig, ksa.ksa_handler, |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 471 | ksa.sa_flags, |
| 472 | ksa.sa_mask.sig[1], |
| 473 | ksa.sa_mask.sig[0] |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 474 | ); |
| 475 | |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 476 | res = VG_(sigaction)( sig, &ksa, &ksa_old ); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 477 | vg_assert(res == 0); |
| 478 | |
| 479 | /* Since we got the old sigaction more or less for free, might |
| 480 | as well extract the maximum sanity-check value from it. */ |
| 481 | if (!force_update) { |
| 482 | vg_assert(ksa_old.ksa_handler |
| 483 | == skss_old.skss_per_sig[sig].skss_handler); |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 484 | vg_assert(ksa_old.sa_flags |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 485 | == skss_old.skss_per_sig[sig].skss_flags); |
sewardj | ce2a615 | 2005-07-08 18:25:13 +0000 | [diff] [blame] | 486 | # if !defined(VGP_ppc32_linux) |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 487 | vg_assert(ksa_old.sa_restorer |
njn | 9abd608 | 2005-06-17 21:31:45 +0000 | [diff] [blame] | 488 | == my_sigreturn); |
sewardj | ce2a615 | 2005-07-08 18:25:13 +0000 | [diff] [blame] | 489 | # endif |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 490 | VG_(sigaddset)( &ksa_old.sa_mask, VKI_SIGKILL ); |
| 491 | VG_(sigaddset)( &ksa_old.sa_mask, VKI_SIGSTOP ); |
| 492 | vg_assert(VG_(isfullsigset)( &ksa_old.sa_mask )); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 493 | } |
| 494 | } |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 495 | } |
| 496 | |
| 497 | |
| 498 | /* --------------------------------------------------------------------- |
| 499 | Update/query SCSS in accordance with client requests. |
| 500 | ------------------------------------------------------------------ */ |
| 501 | |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 502 | /* Logic for this alt-stack stuff copied directly from do_sigaltstack |
| 503 | in kernel/signal.[ch] */ |
| 504 | |
| 505 | /* True if we are on the alternate signal stack. */ |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 506 | static Bool on_sig_stack ( ThreadId tid, Addr m_SP ) |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 507 | { |
fitzhardinge | 98c4dc0 | 2004-03-16 08:27:29 +0000 | [diff] [blame] | 508 | ThreadState *tst = VG_(get_ThreadState)(tid); |
| 509 | |
nethercote | 511e406 | 2004-09-11 13:34:08 +0000 | [diff] [blame] | 510 | return (m_SP - (Addr)tst->altstack.ss_sp < tst->altstack.ss_size); |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 511 | } |
| 512 | |
nethercote | 511e406 | 2004-09-11 13:34:08 +0000 | [diff] [blame] | 513 | static Int sas_ss_flags ( ThreadId tid, Addr m_SP ) |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 514 | { |
fitzhardinge | 98c4dc0 | 2004-03-16 08:27:29 +0000 | [diff] [blame] | 515 | ThreadState *tst = VG_(get_ThreadState)(tid); |
| 516 | |
| 517 | return (tst->altstack.ss_size == 0 |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 518 | ? VKI_SS_DISABLE |
nethercote | 511e406 | 2004-09-11 13:34:08 +0000 | [diff] [blame] | 519 | : on_sig_stack(tid, m_SP) ? VKI_SS_ONSTACK : 0); |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 520 | } |
| 521 | |
| 522 | |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 523 | SysRes VG_(do_sys_sigaltstack) ( ThreadId tid, vki_stack_t* ss, vki_stack_t* oss ) |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 524 | { |
njn | 502badb | 2005-05-08 02:04:49 +0000 | [diff] [blame] | 525 | Addr m_SP; |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 526 | |
| 527 | vg_assert(VG_(is_valid_tid)(tid)); |
njn | f536bbb | 2005-06-13 04:21:38 +0000 | [diff] [blame] | 528 | m_SP = VG_(get_SP)(tid); |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 529 | |
| 530 | if (VG_(clo_trace_signals)) |
| 531 | VG_(message)(Vg_DebugExtraMsg, |
nethercote | 04d3a80 | 2004-11-16 18:26:11 +0000 | [diff] [blame] | 532 | "sys_sigaltstack: tid %d, " |
nethercote | 511e406 | 2004-09-11 13:34:08 +0000 | [diff] [blame] | 533 | "ss %p, oss %p (current SP %p)", |
| 534 | tid, (void*)ss, (void*)oss, (void*)m_SP ); |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 535 | |
| 536 | if (oss != NULL) { |
fitzhardinge | 98c4dc0 | 2004-03-16 08:27:29 +0000 | [diff] [blame] | 537 | oss->ss_sp = VG_(threads)[tid].altstack.ss_sp; |
| 538 | oss->ss_size = VG_(threads)[tid].altstack.ss_size; |
nethercote | 511e406 | 2004-09-11 13:34:08 +0000 | [diff] [blame] | 539 | oss->ss_flags = VG_(threads)[tid].altstack.ss_flags | sas_ss_flags(tid, m_SP); |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 540 | } |
| 541 | |
| 542 | if (ss != NULL) { |
njn | f536bbb | 2005-06-13 04:21:38 +0000 | [diff] [blame] | 543 | if (on_sig_stack(tid, VG_(get_SP)(tid))) { |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 544 | return VG_(mk_SysRes_Error)( VKI_EPERM ); |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 545 | } |
| 546 | if (ss->ss_flags != VKI_SS_DISABLE |
| 547 | && ss->ss_flags != VKI_SS_ONSTACK |
| 548 | && ss->ss_flags != 0) { |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 549 | return VG_(mk_SysRes_Error)( VKI_EINVAL ); |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 550 | } |
| 551 | if (ss->ss_flags == VKI_SS_DISABLE) { |
fitzhardinge | 98c4dc0 | 2004-03-16 08:27:29 +0000 | [diff] [blame] | 552 | VG_(threads)[tid].altstack.ss_flags = VKI_SS_DISABLE; |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 553 | } else { |
| 554 | if (ss->ss_size < VKI_MINSIGSTKSZ) { |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 555 | return VG_(mk_SysRes_Error)( VKI_ENOMEM ); |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 556 | } |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 557 | |
nethercote | 20283c6 | 2004-11-04 19:43:22 +0000 | [diff] [blame] | 558 | VG_(threads)[tid].altstack.ss_sp = ss->ss_sp; |
| 559 | VG_(threads)[tid].altstack.ss_size = ss->ss_size; |
fitzhardinge | 98c4dc0 | 2004-03-16 08:27:29 +0000 | [diff] [blame] | 560 | VG_(threads)[tid].altstack.ss_flags = 0; |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 561 | } |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 562 | } |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 563 | return VG_(mk_SysRes_Success)( 0 ); |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 564 | } |
| 565 | |
| 566 | |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 567 | SysRes VG_(do_sys_sigaction) ( Int signo, |
| 568 | const struct vki_sigaction *new_act, |
| 569 | struct vki_sigaction *old_act ) |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 570 | { |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 571 | if (VG_(clo_trace_signals)) |
| 572 | VG_(message)(Vg_DebugExtraMsg, |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 573 | "sys_sigaction: sigNo %d, " |
nethercote | 93246cf | 2004-11-04 18:56:47 +0000 | [diff] [blame] | 574 | "new %p, old %p, new flags 0x%llx", |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 575 | signo, (UWord)new_act, (UWord)old_act, |
nethercote | 93246cf | 2004-11-04 18:56:47 +0000 | [diff] [blame] | 576 | (ULong)(new_act ? new_act->sa_flags : 0) ); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 577 | |
| 578 | /* Rule out various error conditions. The aim is to ensure that if |
| 579 | when the call is passed to the kernel it will definitely |
| 580 | succeed. */ |
| 581 | |
| 582 | /* Reject out-of-range signal numbers. */ |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 583 | if (signo < 1 || signo > VG_(max_signal)) goto bad_signo; |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 584 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 585 | /* don't let them use our signals */ |
njn | 351d006 | 2005-06-21 22:23:59 +0000 | [diff] [blame] | 586 | if ( (signo > VG_SIGVGRTUSERMAX) |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 587 | && new_act |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 588 | && !(new_act->ksa_handler == VKI_SIG_DFL |
| 589 | || new_act->ksa_handler == VKI_SIG_IGN) ) |
nethercote | 9c42a0f | 2003-11-17 10:37:19 +0000 | [diff] [blame] | 590 | goto bad_signo_reserved; |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 591 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 592 | /* Reject attempts to set a handler (or set ignore) for SIGKILL. */ |
| 593 | if ( (signo == VKI_SIGKILL || signo == VKI_SIGSTOP) |
| 594 | && new_act |
| 595 | && new_act->ksa_handler != VKI_SIG_DFL) |
| 596 | goto bad_sigkill_or_sigstop; |
| 597 | |
| 598 | /* If the client supplied non-NULL old_act, copy the relevant SCSS |
| 599 | entry into it. */ |
| 600 | if (old_act) { |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 601 | old_act->ksa_handler = scss.scss_per_sig[signo].scss_handler; |
| 602 | old_act->sa_flags = scss.scss_per_sig[signo].scss_flags; |
| 603 | old_act->sa_mask = scss.scss_per_sig[signo].scss_mask; |
| 604 | old_act->sa_restorer = scss.scss_per_sig[signo].scss_restorer; |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 605 | } |
| 606 | |
| 607 | /* And now copy new SCSS entry from new_act. */ |
| 608 | if (new_act) { |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 609 | scss.scss_per_sig[signo].scss_handler = new_act->ksa_handler; |
| 610 | scss.scss_per_sig[signo].scss_flags = new_act->sa_flags; |
| 611 | scss.scss_per_sig[signo].scss_mask = new_act->sa_mask; |
| 612 | scss.scss_per_sig[signo].scss_restorer = new_act->sa_restorer; |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 613 | |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 614 | VG_(sigdelset)(&scss.scss_per_sig[signo].scss_mask, VKI_SIGKILL); |
| 615 | VG_(sigdelset)(&scss.scss_per_sig[signo].scss_mask, VKI_SIGSTOP); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 616 | } |
| 617 | |
| 618 | /* All happy bunnies ... */ |
| 619 | if (new_act) { |
nethercote | 9dd1151 | 2004-08-04 15:31:30 +0000 | [diff] [blame] | 620 | handle_SCSS_change( False /* lazy update */ ); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 621 | } |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 622 | return VG_(mk_SysRes_Success)( 0 ); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 623 | |
| 624 | bad_signo: |
njn | 0087c50 | 2005-07-01 04:15:36 +0000 | [diff] [blame] | 625 | if (VG_(showing_core_errors)()) { |
njn25 | e49d8e7 | 2002-09-23 09:36:25 +0000 | [diff] [blame] | 626 | VG_(message)(Vg_UserMsg, |
nethercote | 9c42a0f | 2003-11-17 10:37:19 +0000 | [diff] [blame] | 627 | "Warning: bad signal number %d in sigaction()", |
njn25 | e49d8e7 | 2002-09-23 09:36:25 +0000 | [diff] [blame] | 628 | signo); |
sewardj | 9a3d8bd | 2005-05-23 14:47:52 +0000 | [diff] [blame] | 629 | } |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 630 | return VG_(mk_SysRes_Error)( VKI_EINVAL ); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 631 | |
nethercote | 9c42a0f | 2003-11-17 10:37:19 +0000 | [diff] [blame] | 632 | bad_signo_reserved: |
njn | 0087c50 | 2005-07-01 04:15:36 +0000 | [diff] [blame] | 633 | if (VG_(showing_core_errors)()) { |
nethercote | 9c42a0f | 2003-11-17 10:37:19 +0000 | [diff] [blame] | 634 | VG_(message)(Vg_UserMsg, |
| 635 | "Warning: ignored attempt to set %s handler in sigaction();", |
| 636 | signame(signo)); |
| 637 | VG_(message)(Vg_UserMsg, |
| 638 | " the %s signal is used internally by Valgrind", |
| 639 | signame(signo)); |
fitzhardinge | bf45987 | 2003-11-18 16:55:33 +0000 | [diff] [blame] | 640 | } |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 641 | return VG_(mk_SysRes_Error)( VKI_EINVAL ); |
nethercote | 9c42a0f | 2003-11-17 10:37:19 +0000 | [diff] [blame] | 642 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 643 | bad_sigkill_or_sigstop: |
njn | 0087c50 | 2005-07-01 04:15:36 +0000 | [diff] [blame] | 644 | if (VG_(showing_core_errors)()) { |
njn25 | e49d8e7 | 2002-09-23 09:36:25 +0000 | [diff] [blame] | 645 | VG_(message)(Vg_UserMsg, |
nethercote | 9c42a0f | 2003-11-17 10:37:19 +0000 | [diff] [blame] | 646 | "Warning: ignored attempt to set %s handler in sigaction();", |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 647 | signame(signo)); |
nethercote | 9c42a0f | 2003-11-17 10:37:19 +0000 | [diff] [blame] | 648 | VG_(message)(Vg_UserMsg, |
| 649 | " the %s signal is uncatchable", |
| 650 | signame(signo)); |
sewardj | 9a3d8bd | 2005-05-23 14:47:52 +0000 | [diff] [blame] | 651 | } |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 652 | return VG_(mk_SysRes_Error)( VKI_EINVAL ); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 653 | } |
| 654 | |
| 655 | |
| 656 | static |
| 657 | void do_sigprocmask_bitops ( Int vki_how, |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 658 | vki_sigset_t* orig_set, |
| 659 | vki_sigset_t* modifier ) |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 660 | { |
| 661 | switch (vki_how) { |
| 662 | case VKI_SIG_BLOCK: |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 663 | VG_(sigaddset_from_set)( orig_set, modifier ); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 664 | break; |
| 665 | case VKI_SIG_UNBLOCK: |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 666 | VG_(sigdelset_from_set)( orig_set, modifier ); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 667 | break; |
| 668 | case VKI_SIG_SETMASK: |
| 669 | *orig_set = *modifier; |
| 670 | break; |
| 671 | default: |
njn | e427a66 | 2002-10-02 11:08:25 +0000 | [diff] [blame] | 672 | VG_(core_panic)("do_sigprocmask_bitops"); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 673 | break; |
| 674 | } |
| 675 | } |
| 676 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 677 | /* |
| 678 | This updates the thread's signal mask. There's no such thing as a |
| 679 | process-wide signal mask. |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 680 | |
| 681 | Note that the thread signal masks are an implicit part of SCSS, |
| 682 | which is why this routine is allowed to mess with them. |
| 683 | */ |
| 684 | static |
| 685 | void do_setmask ( ThreadId tid, |
| 686 | Int how, |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 687 | vki_sigset_t* newset, |
| 688 | vki_sigset_t* oldset ) |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 689 | { |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 690 | if (VG_(clo_trace_signals)) |
sewardj | a464e5c | 2002-05-23 17:34:49 +0000 | [diff] [blame] | 691 | VG_(message)(Vg_DebugExtraMsg, |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 692 | "do_setmask: tid = %d how = %d (%s), set = %p %08x%08x", |
| 693 | tid, how, |
| 694 | how==VKI_SIG_BLOCK ? "SIG_BLOCK" : ( |
| 695 | how==VKI_SIG_UNBLOCK ? "SIG_UNBLOCK" : ( |
| 696 | how==VKI_SIG_SETMASK ? "SIG_SETMASK" : "???")), |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 697 | newset, newset ? newset->sig[1] : 0, newset ? newset->sig[0] : 0 |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 698 | ); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 699 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 700 | /* Just do this thread. */ |
| 701 | vg_assert(VG_(is_valid_tid)(tid)); |
| 702 | if (oldset) { |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 703 | *oldset = VG_(threads)[tid].sig_mask; |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 704 | if (VG_(clo_trace_signals)) |
| 705 | VG_(message)(Vg_DebugExtraMsg, |
| 706 | "\toldset=%p %08x%08x", |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 707 | oldset, oldset->sig[1], oldset->sig[0]); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 708 | } |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 709 | if (newset) { |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 710 | do_sigprocmask_bitops (how, &VG_(threads)[tid].sig_mask, newset ); |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 711 | VG_(sigdelset)(&VG_(threads)[tid].sig_mask, VKI_SIGKILL); |
| 712 | VG_(sigdelset)(&VG_(threads)[tid].sig_mask, VKI_SIGSTOP); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 713 | VG_(threads)[tid].tmp_sig_mask = VG_(threads)[tid].sig_mask; |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 714 | } |
| 715 | } |
| 716 | |
| 717 | |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 718 | SysRes VG_(do_sys_sigprocmask) ( ThreadId tid, |
| 719 | Int how, |
| 720 | vki_sigset_t* set, |
| 721 | vki_sigset_t* oldset ) |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 722 | { |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 723 | switch(how) { |
| 724 | case VKI_SIG_BLOCK: |
| 725 | case VKI_SIG_UNBLOCK: |
| 726 | case VKI_SIG_SETMASK: |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 727 | vg_assert(VG_(is_valid_tid)(tid)); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 728 | do_setmask ( tid, how, set, oldset ); |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 729 | return VG_(mk_SysRes_Success)( 0 ); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 730 | |
| 731 | default: |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 732 | VG_(message)(Vg_DebugMsg, |
njn | 02bc4b8 | 2005-05-15 17:28:26 +0000 | [diff] [blame] | 733 | "sigprocmask: unknown 'how' field %d", how); |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 734 | return VG_(mk_SysRes_Error)( VKI_EINVAL ); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 735 | } |
| 736 | } |
| 737 | |
| 738 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 739 | /* --------------------------------------------------------------------- |
| 740 | LOW LEVEL STUFF TO DO WITH SIGNALS: IMPLEMENTATION |
| 741 | ------------------------------------------------------------------ */ |
sewardj | 77e466c | 2002-04-14 02:29:29 +0000 | [diff] [blame] | 742 | |
sewardj | 2e93c50 | 2002-04-12 11:12:52 +0000 | [diff] [blame] | 743 | /* --------------------------------------------------------------------- |
| 744 | Handy utilities to block/restore all host signals. |
| 745 | ------------------------------------------------------------------ */ |
| 746 | |
| 747 | /* Block all host signals, dumping the old mask in *saved_mask. */ |
njn | 444eba1 | 2005-05-12 03:47:31 +0000 | [diff] [blame] | 748 | static void block_all_host_signals ( /* OUT */ vki_sigset_t* saved_mask ) |
sewardj | 2e93c50 | 2002-04-12 11:12:52 +0000 | [diff] [blame] | 749 | { |
| 750 | Int ret; |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 751 | vki_sigset_t block_procmask; |
| 752 | VG_(sigfillset)(&block_procmask); |
| 753 | ret = VG_(sigprocmask) |
sewardj | 2e93c50 | 2002-04-12 11:12:52 +0000 | [diff] [blame] | 754 | (VKI_SIG_SETMASK, &block_procmask, saved_mask); |
| 755 | vg_assert(ret == 0); |
| 756 | } |
| 757 | |
| 758 | /* Restore the blocking mask using the supplied saved one. */ |
njn | 444eba1 | 2005-05-12 03:47:31 +0000 | [diff] [blame] | 759 | static void restore_all_host_signals ( /* IN */ vki_sigset_t* saved_mask ) |
sewardj | 2e93c50 | 2002-04-12 11:12:52 +0000 | [diff] [blame] | 760 | { |
| 761 | Int ret; |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 762 | ret = VG_(sigprocmask)(VKI_SIG_SETMASK, saved_mask, NULL); |
sewardj | 2e93c50 | 2002-04-12 11:12:52 +0000 | [diff] [blame] | 763 | vg_assert(ret == 0); |
| 764 | } |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 765 | |
njn | 444eba1 | 2005-05-12 03:47:31 +0000 | [diff] [blame] | 766 | void VG_(clear_out_queued_signals)( ThreadId tid, vki_sigset_t* saved_mask ) |
| 767 | { |
| 768 | block_all_host_signals(saved_mask); |
| 769 | if (VG_(threads)[tid].sig_queue != NULL) { |
| 770 | VG_(arena_free)(VG_AR_CORE, VG_(threads)[tid].sig_queue); |
| 771 | VG_(threads)[tid].sig_queue = NULL; |
| 772 | } |
| 773 | restore_all_host_signals(saved_mask); |
| 774 | } |
| 775 | |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 776 | /* --------------------------------------------------------------------- |
| 777 | The signal simulation proper. A simplified version of what the |
| 778 | Linux kernel does. |
| 779 | ------------------------------------------------------------------ */ |
| 780 | |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 781 | /* Set up a stack frame (VgSigContext) for the client's signal |
nethercote | fedd810 | 2004-09-13 15:19:34 +0000 | [diff] [blame] | 782 | handler. */ |
sewardj | 2c5ffbe | 2005-03-12 13:32:06 +0000 | [diff] [blame] | 783 | static |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 784 | void push_signal_frame ( ThreadId tid, const vki_siginfo_t *siginfo ) |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 785 | { |
nethercote | 6eec460 | 2004-09-13 14:15:36 +0000 | [diff] [blame] | 786 | Addr esp_top_of_frame; |
sewardj | 2e93c50 | 2002-04-12 11:12:52 +0000 | [diff] [blame] | 787 | ThreadState* tst; |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 788 | Int sigNo = siginfo->si_signo; |
sewardj | 2e93c50 | 2002-04-12 11:12:52 +0000 | [diff] [blame] | 789 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 790 | vg_assert(sigNo >= 1 && sigNo <= VG_(max_signal)); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 791 | vg_assert(VG_(is_valid_tid)(tid)); |
| 792 | tst = & VG_(threads)[tid]; |
sewardj | 2e93c50 | 2002-04-12 11:12:52 +0000 | [diff] [blame] | 793 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 794 | if (VG_(clo_trace_signals)) |
| 795 | VG_(message)(Vg_DebugMsg, |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 796 | "push_signal_frame (thread %d): signal %d", tid, sigNo); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 797 | |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 798 | if (/* this signal asked to run on an alt stack */ |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 799 | (scss.scss_per_sig[sigNo].scss_flags & VKI_SA_ONSTACK ) |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 800 | && /* there is a defined and enabled alt stack, which we're not |
| 801 | already using. Logic from get_sigframe in |
| 802 | arch/i386/kernel/signal.c. */ |
njn | f536bbb | 2005-06-13 04:21:38 +0000 | [diff] [blame] | 803 | sas_ss_flags(tid, VG_(get_SP)(tid)) == 0 |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 804 | ) { |
| 805 | esp_top_of_frame |
fitzhardinge | 98c4dc0 | 2004-03-16 08:27:29 +0000 | [diff] [blame] | 806 | = (Addr)(tst->altstack.ss_sp) + tst->altstack.ss_size; |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 807 | if (VG_(clo_trace_signals)) |
| 808 | VG_(message)(Vg_DebugMsg, |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 809 | "delivering signal %d (%s) to thread %d: on ALT STACK (%p-%p; %d bytes)", |
| 810 | sigNo, signame(sigNo), tid, |
| 811 | tst->altstack.ss_sp, |
| 812 | tst->altstack.ss_sp + tst->altstack.ss_size, |
| 813 | tst->altstack.ss_size ); |
njn | fdc28af | 2003-02-24 10:36:48 +0000 | [diff] [blame] | 814 | |
nethercote | 7cc9c23 | 2004-01-21 15:08:04 +0000 | [diff] [blame] | 815 | /* Signal delivery to tools */ |
fitzhardinge | 98c4dc0 | 2004-03-16 08:27:29 +0000 | [diff] [blame] | 816 | VG_TRACK( pre_deliver_signal, tid, sigNo, /*alt_stack*/True ); |
njn | fdc28af | 2003-02-24 10:36:48 +0000 | [diff] [blame] | 817 | |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 818 | } else { |
njn | af839f5 | 2005-06-23 03:27:57 +0000 | [diff] [blame] | 819 | esp_top_of_frame = VG_(get_SP)(tid) - VG_STACK_REDZONE_SZB; |
njn | fdc28af | 2003-02-24 10:36:48 +0000 | [diff] [blame] | 820 | |
nethercote | 7cc9c23 | 2004-01-21 15:08:04 +0000 | [diff] [blame] | 821 | /* Signal delivery to tools */ |
fitzhardinge | 98c4dc0 | 2004-03-16 08:27:29 +0000 | [diff] [blame] | 822 | VG_TRACK( pre_deliver_signal, tid, sigNo, /*alt_stack*/False ); |
sewardj | 2342c97 | 2002-05-22 23:34:20 +0000 | [diff] [blame] | 823 | } |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 824 | |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 825 | vg_assert(scss.scss_per_sig[sigNo].scss_handler != VKI_SIG_IGN); |
| 826 | vg_assert(scss.scss_per_sig[sigNo].scss_handler != VKI_SIG_DFL); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 827 | |
| 828 | /* This may fail if the client stack is busted; if that happens, |
| 829 | the whole process will exit rather than simply calling the |
| 830 | signal handler. */ |
sewardj | 985fabb | 2005-04-24 14:18:14 +0000 | [diff] [blame] | 831 | VG_(sigframe_create) (tid, esp_top_of_frame, siginfo, |
| 832 | scss.scss_per_sig[sigNo].scss_handler, |
| 833 | scss.scss_per_sig[sigNo].scss_flags, |
| 834 | &tst->sig_mask, |
| 835 | scss.scss_per_sig[sigNo].scss_restorer); |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 836 | } |
| 837 | |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 838 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 839 | static const Char *signame(Int sigNo) |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 840 | { |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 841 | static Char buf[10]; |
sewardj | b48e500 | 2002-05-13 00:16:03 +0000 | [diff] [blame] | 842 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 843 | switch(sigNo) { |
| 844 | #define S(x) case VKI_##x: return #x |
| 845 | S(SIGHUP); |
| 846 | S(SIGINT); |
| 847 | S(SIGQUIT); |
| 848 | S(SIGILL); |
| 849 | S(SIGTRAP); |
| 850 | S(SIGABRT); |
| 851 | S(SIGBUS); |
| 852 | S(SIGFPE); |
| 853 | S(SIGKILL); |
| 854 | S(SIGUSR1); |
| 855 | S(SIGUSR2); |
| 856 | S(SIGSEGV); |
| 857 | S(SIGPIPE); |
| 858 | S(SIGALRM); |
| 859 | S(SIGTERM); |
| 860 | S(SIGSTKFLT); |
| 861 | S(SIGCHLD); |
| 862 | S(SIGCONT); |
| 863 | S(SIGSTOP); |
| 864 | S(SIGTSTP); |
| 865 | S(SIGTTIN); |
| 866 | S(SIGTTOU); |
| 867 | S(SIGURG); |
| 868 | S(SIGXCPU); |
| 869 | S(SIGXFSZ); |
| 870 | S(SIGVTALRM); |
| 871 | S(SIGPROF); |
| 872 | S(SIGWINCH); |
| 873 | S(SIGIO); |
| 874 | S(SIGPWR); |
| 875 | S(SIGUNUSED); |
| 876 | #undef S |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 877 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 878 | case VKI_SIGRTMIN ... VKI_SIGRTMAX: |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 879 | VG_(sprintf)(buf, "SIGRT%d", sigNo-VKI_SIGRTMIN); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 880 | return buf; |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 881 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 882 | default: |
| 883 | VG_(sprintf)(buf, "SIG%d", sigNo); |
| 884 | return buf; |
| 885 | } |
| 886 | } |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 887 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 888 | /* Hit ourselves with a signal using the default handler */ |
| 889 | void VG_(kill_self)(Int sigNo) |
| 890 | { |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 891 | vki_sigset_t mask, origmask; |
| 892 | struct vki_sigaction sa, origsa; |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 893 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 894 | sa.ksa_handler = VKI_SIG_DFL; |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 895 | sa.sa_flags = 0; |
| 896 | sa.sa_restorer = 0; |
| 897 | VG_(sigemptyset)(&sa.sa_mask); |
sewardj | 2e93c50 | 2002-04-12 11:12:52 +0000 | [diff] [blame] | 898 | |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 899 | VG_(sigaction)(sigNo, &sa, &origsa); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 900 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 901 | VG_(sigemptyset)(&mask); |
| 902 | VG_(sigaddset)(&mask, sigNo); |
| 903 | VG_(sigprocmask)(VKI_SIG_UNBLOCK, &mask, &origmask); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 904 | |
tom | b9b10c7 | 2005-07-20 16:05:28 +0000 | [diff] [blame] | 905 | VG_(kill)(VG_(getpid)(), sigNo); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 906 | |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 907 | VG_(sigaction)(sigNo, &origsa, NULL); |
| 908 | VG_(sigprocmask)(VKI_SIG_SETMASK, &origmask, NULL); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 909 | } |
| 910 | |
njn | 277a6d6 | 2004-11-26 14:07:24 +0000 | [diff] [blame] | 911 | // Core dumping is disabled until someone can work out how to abstract out |
| 912 | // the arch-specific and word-size-specific parts neatly. |
njn | bde3027 | 2004-11-29 15:45:31 +0000 | [diff] [blame] | 913 | // |
| 914 | // Note that the code below is not 64-bit clean! |
| 915 | // |
njn | 277a6d6 | 2004-11-26 14:07:24 +0000 | [diff] [blame] | 916 | #if 0 |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 917 | /* |
| 918 | Dump core |
| 919 | |
| 920 | Generate a standard ELF core file corresponding to the client state |
| 921 | at the time of a crash. |
| 922 | */ |
| 923 | #include <elf.h> |
| 924 | #ifndef NT_PRXFPREG |
| 925 | #define NT_PRXFPREG 0x46e62b7f /* copied from gdb5.1/include/elf/common.h */ |
| 926 | #endif /* NT_PRXFPREG */ |
| 927 | |
| 928 | /* If true, then this Segment may be mentioned in the core */ |
| 929 | static Bool may_dump(const Segment *seg) |
| 930 | { |
njn | 0ae787c | 2005-06-28 22:14:53 +0000 | [diff] [blame] | 931 | return (seg->flags & SF_VALGRIND) == 0 && VG_(is_client_addr)(seg->addr); |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 932 | } |
| 933 | |
| 934 | /* If true, then this Segment's contents will be in the core */ |
| 935 | static Bool should_dump(const Segment *seg) |
| 936 | { |
| 937 | return may_dump(seg); // && (seg->prot & VKI_PROT_WRITE); |
| 938 | } |
| 939 | |
| 940 | static void fill_ehdr(Elf32_Ehdr *ehdr, Int num_phdrs) |
| 941 | { |
njn | e1d981a | 2005-03-11 04:47:23 +0000 | [diff] [blame] | 942 | VG_(memset)(ehdr, 0, sizeof(*ehdr)); |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 943 | |
| 944 | VG_(memcpy)(ehdr->e_ident, ELFMAG, SELFMAG); |
njn | af839f5 | 2005-06-23 03:27:57 +0000 | [diff] [blame] | 945 | ehdr->e_ident[EI_CLASS] = VG_ELF_CLASS; |
| 946 | ehdr->e_ident[EI_DATA] = VG_ELF_ENDIANNESS; |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 947 | ehdr->e_ident[EI_VERSION] = EV_CURRENT; |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 948 | |
| 949 | ehdr->e_type = ET_CORE; |
njn | af839f5 | 2005-06-23 03:27:57 +0000 | [diff] [blame] | 950 | ehdr->e_machine = VG_ELF_MACHINE; |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 951 | ehdr->e_version = EV_CURRENT; |
| 952 | ehdr->e_entry = 0; |
| 953 | ehdr->e_phoff = sizeof(Elf32_Ehdr); |
| 954 | ehdr->e_shoff = 0; |
| 955 | ehdr->e_flags = 0; |
| 956 | ehdr->e_ehsize = sizeof(Elf32_Ehdr); |
| 957 | ehdr->e_phentsize = sizeof(Elf32_Phdr); |
| 958 | ehdr->e_phnum = num_phdrs; |
| 959 | ehdr->e_shentsize = 0; |
| 960 | ehdr->e_shnum = 0; |
| 961 | ehdr->e_shstrndx = 0; |
| 962 | |
| 963 | } |
| 964 | |
| 965 | static void fill_phdr(Elf32_Phdr *phdr, const Segment *seg, UInt off, Bool write) |
| 966 | { |
| 967 | write = write && should_dump(seg); |
| 968 | |
| 969 | VG_(memset)(phdr, 0, sizeof(*phdr)); |
| 970 | |
| 971 | phdr->p_type = PT_LOAD; |
| 972 | phdr->p_offset = off; |
| 973 | phdr->p_vaddr = seg->addr; |
| 974 | phdr->p_paddr = 0; |
| 975 | phdr->p_filesz = write ? seg->len : 0; |
| 976 | phdr->p_memsz = seg->len; |
| 977 | phdr->p_flags = 0; |
| 978 | |
| 979 | if (seg->prot & VKI_PROT_READ) |
| 980 | phdr->p_flags |= PF_R; |
| 981 | if (seg->prot & VKI_PROT_WRITE) |
| 982 | phdr->p_flags |= PF_W; |
| 983 | if (seg->prot & VKI_PROT_EXEC) |
| 984 | phdr->p_flags |= PF_X; |
| 985 | |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 986 | phdr->p_align = VKI_PAGE_SIZE; |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 987 | } |
| 988 | |
| 989 | struct note { |
| 990 | struct note *next; |
| 991 | Elf32_Nhdr note; |
| 992 | Char name[0]; |
| 993 | }; |
| 994 | |
| 995 | static UInt note_size(const struct note *n) |
| 996 | { |
njn | 13bfd85 | 2005-06-02 03:52:53 +0000 | [diff] [blame] | 997 | return sizeof(Elf32_Nhdr) + VG_ROUNDUP(VG_(strlen)(n->name)+1, 4) + VG_ROUNDUP(n->note.n_descsz, 4); |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 998 | } |
| 999 | |
| 1000 | static void add_note(struct note **list, const Char *name, UInt type, const void *data, UInt datasz) |
| 1001 | { |
| 1002 | Int namelen = VG_(strlen)(name)+1; |
| 1003 | Int notelen = sizeof(struct note) + |
njn | 13bfd85 | 2005-06-02 03:52:53 +0000 | [diff] [blame] | 1004 | VG_ROUNDUP(namelen, 4) + |
| 1005 | VG_ROUNDUP(datasz, 4); |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1006 | struct note *n = VG_(arena_malloc)(VG_AR_CORE, notelen); |
| 1007 | |
| 1008 | VG_(memset)(n, 0, notelen); |
| 1009 | |
| 1010 | n->next = *list; |
| 1011 | *list = n; |
| 1012 | |
| 1013 | n->note.n_type = type; |
| 1014 | n->note.n_namesz = namelen; |
| 1015 | n->note.n_descsz = datasz; |
| 1016 | |
| 1017 | VG_(memcpy)(n->name, name, namelen); |
njn | 13bfd85 | 2005-06-02 03:52:53 +0000 | [diff] [blame] | 1018 | VG_(memcpy)(n->name+VG_ROUNDUP(namelen,4), data, datasz); |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1019 | } |
| 1020 | |
| 1021 | static void write_note(Int fd, const struct note *n) |
| 1022 | { |
| 1023 | VG_(write)(fd, &n->note, note_size(n)); |
| 1024 | } |
| 1025 | |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 1026 | static void fill_prpsinfo(const ThreadState *tst, struct vki_elf_prpsinfo *prpsinfo) |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1027 | { |
njn | f845f8f | 2005-06-23 02:26:47 +0000 | [diff] [blame] | 1028 | static Char name[VKI_PATH_MAX]; |
| 1029 | Bool res; |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1030 | |
| 1031 | VG_(memset)(prpsinfo, 0, sizeof(*prpsinfo)); |
| 1032 | |
| 1033 | switch(tst->status) { |
| 1034 | case VgTs_Runnable: |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1035 | case VgTs_Yielding: |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1036 | prpsinfo->pr_sname = 'R'; |
| 1037 | break; |
| 1038 | |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1039 | case VgTs_WaitSys: |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1040 | prpsinfo->pr_sname = 'S'; |
| 1041 | break; |
| 1042 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1043 | case VgTs_Zombie: |
| 1044 | prpsinfo->pr_sname = 'Z'; |
| 1045 | break; |
| 1046 | |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1047 | case VgTs_Empty: |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1048 | case VgTs_Init: |
| 1049 | prpsinfo->pr_sname = '?'; |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1050 | break; |
| 1051 | } |
| 1052 | |
| 1053 | prpsinfo->pr_uid = 0; |
| 1054 | prpsinfo->pr_gid = 0; |
| 1055 | |
njn | f845f8f | 2005-06-23 02:26:47 +0000 | [diff] [blame] | 1056 | if (VG_(resolve_filename)(VG_(clexecfd), name, VKI_PATH_MAX)) { |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1057 | Char *n = name+VG_(strlen)(name)-1; |
| 1058 | |
njn | f845f8f | 2005-06-23 02:26:47 +0000 | [diff] [blame] | 1059 | while (n > name && *n != '/') |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1060 | n--; |
| 1061 | if (n != name) |
| 1062 | n++; |
| 1063 | |
| 1064 | VG_(strncpy)(prpsinfo->pr_fname, n, sizeof(prpsinfo->pr_fname)); |
| 1065 | } |
| 1066 | } |
| 1067 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1068 | static void fill_prstatus(const ThreadState *tst, |
| 1069 | struct vki_elf_prstatus *prs, |
| 1070 | const vki_siginfo_t *si) |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1071 | { |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 1072 | struct vki_user_regs_struct *regs; |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1073 | |
| 1074 | VG_(memset)(prs, 0, sizeof(*prs)); |
| 1075 | |
| 1076 | prs->pr_info.si_signo = si->si_signo; |
| 1077 | prs->pr_info.si_code = si->si_code; |
| 1078 | prs->pr_info.si_errno = 0; |
| 1079 | |
| 1080 | prs->pr_cursig = si->si_signo; |
| 1081 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1082 | prs->pr_pid = tst->os_state.lwpid; |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1083 | prs->pr_ppid = 0; |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1084 | prs->pr_pgrp = VG_(getpgrp)(); |
| 1085 | prs->pr_sid = VG_(getpgrp)(); |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1086 | |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 1087 | regs = (struct vki_user_regs_struct *)prs->pr_reg; |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1088 | |
| 1089 | vg_assert(sizeof(*regs) == sizeof(prs->pr_reg)); |
| 1090 | |
njn | af839f5 | 2005-06-23 03:27:57 +0000 | [diff] [blame] | 1091 | VG_(fill_elfregs_from_tst)(regs, &tst->arch); |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1092 | } |
| 1093 | |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 1094 | static void fill_fpu(const ThreadState *tst, vki_elf_fpregset_t *fpu) |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1095 | { |
njn | af839f5 | 2005-06-23 03:27:57 +0000 | [diff] [blame] | 1096 | VG_(fill_elffpregs_from_tst)(fpu, &tst->arch); |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1097 | } |
| 1098 | |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 1099 | static void fill_xfpu(const ThreadState *tst, vki_elf_fpxregset_t *xfpu) |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1100 | { |
njn | af839f5 | 2005-06-23 03:27:57 +0000 | [diff] [blame] | 1101 | VG_(fill_elffpxregs_from_tst)(xfpu, &tst->arch); |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1102 | } |
| 1103 | |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 1104 | static void make_coredump(ThreadId tid, const vki_siginfo_t *si, UInt max_size) |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1105 | { |
| 1106 | Char buf[1000]; |
| 1107 | Char *basename = "vgcore"; |
| 1108 | Char *coreext = ""; |
| 1109 | Int seq = 0; |
| 1110 | Int core_fd; |
| 1111 | Segment *seg; |
| 1112 | Elf32_Ehdr ehdr; |
| 1113 | Elf32_Phdr *phdrs; |
| 1114 | Int num_phdrs; |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1115 | Int i, idx; |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1116 | UInt off; |
| 1117 | struct note *notelist, *note; |
| 1118 | UInt notesz; |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 1119 | struct vki_elf_prpsinfo prpsinfo; |
| 1120 | struct vki_elf_prstatus prstatus; |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1121 | |
nethercote | f854867 | 2004-06-21 12:42:35 +0000 | [diff] [blame] | 1122 | if (VG_(clo_log_name) != NULL) { |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1123 | coreext = ".core"; |
nethercote | f854867 | 2004-06-21 12:42:35 +0000 | [diff] [blame] | 1124 | basename = VG_(clo_log_name); |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1125 | } |
| 1126 | |
| 1127 | for(;;) { |
| 1128 | if (seq == 0) |
| 1129 | VG_(sprintf)(buf, "%s%s.pid%d", |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1130 | basename, coreext, VG_(getpid)()); |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1131 | else |
| 1132 | VG_(sprintf)(buf, "%s%s.pid%d.%d", |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1133 | basename, coreext, VG_(getpid)(), seq); |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1134 | seq++; |
| 1135 | |
| 1136 | core_fd = VG_(open)(buf, |
| 1137 | VKI_O_CREAT|VKI_O_WRONLY|VKI_O_EXCL|VKI_O_TRUNC, |
| 1138 | VKI_S_IRUSR|VKI_S_IWUSR); |
| 1139 | if (core_fd >= 0) |
| 1140 | break; |
| 1141 | |
| 1142 | if (core_fd != -VKI_EEXIST) |
| 1143 | return; /* can't create file */ |
| 1144 | } |
| 1145 | |
| 1146 | /* First, count how many memory segments to dump */ |
| 1147 | num_phdrs = 1; /* start with notes */ |
| 1148 | for(seg = VG_(first_segment)(); |
| 1149 | seg != NULL; |
| 1150 | seg = VG_(next_segment)(seg)) { |
| 1151 | if (!may_dump(seg)) |
| 1152 | continue; |
| 1153 | |
| 1154 | num_phdrs++; |
| 1155 | } |
| 1156 | |
| 1157 | fill_ehdr(&ehdr, num_phdrs); |
| 1158 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1159 | notelist = NULL; |
| 1160 | |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1161 | /* Second, work out their layout */ |
| 1162 | phdrs = VG_(arena_malloc)(VG_AR_CORE, sizeof(*phdrs) * num_phdrs); |
| 1163 | |
| 1164 | for(i = 1; i < VG_N_THREADS; i++) { |
sewardj | 51ac087 | 2004-12-21 01:20:49 +0000 | [diff] [blame] | 1165 | vki_elf_fpregset_t fpu; |
| 1166 | vki_elf_fpxregset_t xfpu; |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1167 | |
| 1168 | if (VG_(threads)[i].status == VgTs_Empty) |
| 1169 | continue; |
| 1170 | |
sewardj | 51ac087 | 2004-12-21 01:20:49 +0000 | [diff] [blame] | 1171 | fill_xfpu(&VG_(threads)[i], &xfpu); |
| 1172 | add_note(¬elist, "LINUX", NT_PRXFPREG, &xfpu, sizeof(xfpu)); |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1173 | |
| 1174 | fill_fpu(&VG_(threads)[i], &fpu); |
| 1175 | add_note(¬elist, "CORE", NT_FPREGSET, &fpu, sizeof(fpu)); |
| 1176 | |
| 1177 | fill_prstatus(&VG_(threads)[i], &prstatus, si); |
| 1178 | add_note(¬elist, "CORE", NT_PRSTATUS, &prstatus, sizeof(prstatus)); |
| 1179 | } |
| 1180 | |
| 1181 | fill_prpsinfo(&VG_(threads)[tid], &prpsinfo); |
| 1182 | add_note(¬elist, "CORE", NT_PRPSINFO, &prpsinfo, sizeof(prpsinfo)); |
| 1183 | |
| 1184 | for(note = notelist, notesz = 0; note != NULL; note = note->next) |
| 1185 | notesz += note_size(note); |
| 1186 | |
| 1187 | off = sizeof(ehdr) + sizeof(*phdrs) * num_phdrs; |
| 1188 | |
| 1189 | phdrs[0].p_type = PT_NOTE; |
| 1190 | phdrs[0].p_offset = off; |
| 1191 | phdrs[0].p_vaddr = 0; |
| 1192 | phdrs[0].p_paddr = 0; |
| 1193 | phdrs[0].p_filesz = notesz; |
| 1194 | phdrs[0].p_memsz = 0; |
| 1195 | phdrs[0].p_flags = 0; |
| 1196 | phdrs[0].p_align = 0; |
| 1197 | |
| 1198 | off += notesz; |
| 1199 | |
njn | 13bfd85 | 2005-06-02 03:52:53 +0000 | [diff] [blame] | 1200 | off = VG_PGROUNDUP(off); |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1201 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1202 | for(seg = VG_(first_segment)(), idx = 1; |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1203 | seg != NULL; |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1204 | seg = VG_(next_segment)(seg)) { |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1205 | if (!may_dump(seg)) |
| 1206 | continue; |
| 1207 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1208 | fill_phdr(&phdrs[idx], seg, off, (seg->len + off) < max_size); |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1209 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1210 | off += phdrs[idx].p_filesz; |
| 1211 | |
| 1212 | idx++; |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1213 | } |
| 1214 | |
| 1215 | /* write everything out */ |
| 1216 | VG_(write)(core_fd, &ehdr, sizeof(ehdr)); |
| 1217 | VG_(write)(core_fd, phdrs, sizeof(*phdrs) * num_phdrs); |
| 1218 | |
| 1219 | for(note = notelist; note != NULL; note = note->next) |
| 1220 | write_note(core_fd, note); |
| 1221 | |
| 1222 | VG_(lseek)(core_fd, phdrs[1].p_offset, VKI_SEEK_SET); |
| 1223 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1224 | for(seg = VG_(first_segment)(), idx = 1; |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1225 | seg != NULL; |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1226 | seg = VG_(next_segment)(seg)) { |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1227 | if (!should_dump(seg)) |
| 1228 | continue; |
| 1229 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1230 | if (phdrs[idx].p_filesz > 0) { |
| 1231 | Int ret; |
| 1232 | |
| 1233 | vg_assert(VG_(lseek)(core_fd, phdrs[idx].p_offset, VKI_SEEK_SET) == phdrs[idx].p_offset); |
| 1234 | vg_assert(seg->len >= phdrs[idx].p_filesz); |
| 1235 | |
| 1236 | ret = VG_(write)(core_fd, (void *)seg->addr, phdrs[idx].p_filesz); |
| 1237 | } |
| 1238 | idx++; |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1239 | } |
| 1240 | |
| 1241 | VG_(close)(core_fd); |
| 1242 | } |
njn | 277a6d6 | 2004-11-26 14:07:24 +0000 | [diff] [blame] | 1243 | #endif |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1244 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1245 | /* |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1246 | Perform the default action of a signal. If the signal is fatal, it |
| 1247 | marks all threads as needing to exit, but it doesn't actually kill |
| 1248 | the process or thread. |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1249 | |
| 1250 | If we're not being quiet, then print out some more detail about |
| 1251 | fatal signals (esp. core dumping signals). |
| 1252 | */ |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 1253 | static void default_action(const vki_siginfo_t *info, ThreadId tid) |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1254 | { |
| 1255 | Int sigNo = info->si_signo; |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1256 | Bool terminate = False; /* kills process */ |
| 1257 | Bool core = False; /* kills process w/ core */ |
| 1258 | struct vki_rlimit corelim; |
| 1259 | Bool could_core; |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1260 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1261 | vg_assert(VG_(is_running_thread)(tid)); |
| 1262 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1263 | switch(sigNo) { |
| 1264 | case VKI_SIGQUIT: /* core */ |
| 1265 | case VKI_SIGILL: /* core */ |
| 1266 | case VKI_SIGABRT: /* core */ |
| 1267 | case VKI_SIGFPE: /* core */ |
| 1268 | case VKI_SIGSEGV: /* core */ |
| 1269 | case VKI_SIGBUS: /* core */ |
| 1270 | case VKI_SIGTRAP: /* core */ |
| 1271 | case VKI_SIGXCPU: /* core */ |
| 1272 | case VKI_SIGXFSZ: /* core */ |
| 1273 | terminate = True; |
| 1274 | core = True; |
| 1275 | break; |
| 1276 | |
| 1277 | case VKI_SIGHUP: /* term */ |
| 1278 | case VKI_SIGINT: /* term */ |
| 1279 | case VKI_SIGKILL: /* term - we won't see this */ |
| 1280 | case VKI_SIGPIPE: /* term */ |
| 1281 | case VKI_SIGALRM: /* term */ |
| 1282 | case VKI_SIGTERM: /* term */ |
| 1283 | case VKI_SIGUSR1: /* term */ |
| 1284 | case VKI_SIGUSR2: /* term */ |
| 1285 | case VKI_SIGIO: /* term */ |
| 1286 | case VKI_SIGPWR: /* term */ |
| 1287 | case VKI_SIGSYS: /* term */ |
| 1288 | case VKI_SIGPROF: /* term */ |
| 1289 | case VKI_SIGVTALRM: /* term */ |
| 1290 | case VKI_SIGRTMIN ... VKI_SIGRTMAX: /* term */ |
| 1291 | terminate = True; |
| 1292 | break; |
| 1293 | } |
| 1294 | |
| 1295 | vg_assert(!core || (core && terminate)); |
| 1296 | |
fitzhardinge | 98abfc7 | 2003-12-16 02:05:15 +0000 | [diff] [blame] | 1297 | if (VG_(clo_trace_signals)) |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1298 | VG_(message)(Vg_DebugMsg, "delivering %d (code %d) to default handler; action: %s%s", |
| 1299 | sigNo, info->si_code, terminate ? "terminate" : "ignore", core ? "+core" : ""); |
fitzhardinge | 98abfc7 | 2003-12-16 02:05:15 +0000 | [diff] [blame] | 1300 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1301 | if (!terminate) |
| 1302 | return; /* nothing to do */ |
fitzhardinge | 4a4d108 | 2004-03-15 23:46:54 +0000 | [diff] [blame] | 1303 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1304 | could_core = core; |
| 1305 | |
| 1306 | if (core) { |
| 1307 | /* If they set the core-size limit to zero, don't generate a |
| 1308 | core file */ |
fitzhardinge | 61a5341 | 2004-03-15 23:44:11 +0000 | [diff] [blame] | 1309 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1310 | VG_(getrlimit)(VKI_RLIMIT_CORE, &corelim); |
fitzhardinge | 61a5341 | 2004-03-15 23:44:11 +0000 | [diff] [blame] | 1311 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1312 | if (corelim.rlim_cur == 0) |
| 1313 | core = False; |
| 1314 | } |
fitzhardinge | 61a5341 | 2004-03-15 23:44:11 +0000 | [diff] [blame] | 1315 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1316 | if (VG_(clo_verbosity) > 1 || (could_core && info->si_code > VKI_SI_USER)) { |
| 1317 | VG_(message)(Vg_UserMsg, ""); |
| 1318 | VG_(message)(Vg_UserMsg, "Process terminating with default action of signal %d (%s)%s", |
| 1319 | sigNo, signame(sigNo), core ? ": dumping core" : ""); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1320 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1321 | /* Be helpful - decode some more details about this fault */ |
| 1322 | if (info->si_code > VKI_SI_USER) { |
| 1323 | const Char *event = NULL; |
| 1324 | Bool haveaddr = True; |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1325 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1326 | switch(sigNo) { |
| 1327 | case VKI_SIGSEGV: |
| 1328 | switch(info->si_code) { |
| 1329 | case 1: event = "Access not within mapped region"; break; |
| 1330 | case 2: event = "Bad permissions for mapped region"; break; |
| 1331 | case 128: |
| 1332 | /* General Protection Fault: The CPU/kernel |
| 1333 | isn't telling us anything useful, but this |
| 1334 | is commonly the result of exceeding a |
| 1335 | segment limit, such as the one imposed by |
| 1336 | --pointercheck=yes. */ |
| 1337 | if (VG_(clo_pointercheck)) |
| 1338 | event = "GPF (Pointer out of bounds?)"; |
| 1339 | else |
| 1340 | event = "General Protection Fault"; |
| 1341 | haveaddr = False; |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1342 | break; |
| 1343 | } |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1344 | break; |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1345 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1346 | case VKI_SIGILL: |
| 1347 | switch(info->si_code) { |
| 1348 | case 1: event = "Illegal opcode"; break; |
| 1349 | case 2: event = "Illegal operand"; break; |
| 1350 | case 3: event = "Illegal addressing mode"; break; |
| 1351 | case 4: event = "Illegal trap"; break; |
| 1352 | case 5: event = "Privileged opcode"; break; |
| 1353 | case 6: event = "Privileged register"; break; |
| 1354 | case 7: event = "Coprocessor error"; break; |
| 1355 | case 8: event = "Internal stack error"; break; |
| 1356 | } |
| 1357 | break; |
| 1358 | |
| 1359 | case VKI_SIGFPE: |
| 1360 | switch (info->si_code) { |
| 1361 | case 1: event = "Integer divide by zero"; break; |
| 1362 | case 2: event = "Integer overflow"; break; |
| 1363 | case 3: event = "FP divide by zero"; break; |
| 1364 | case 4: event = "FP overflow"; break; |
| 1365 | case 5: event = "FP underflow"; break; |
| 1366 | case 6: event = "FP inexact"; break; |
| 1367 | case 7: event = "FP invalid operation"; break; |
| 1368 | case 8: event = "FP subscript out of range"; break; |
| 1369 | } |
| 1370 | break; |
| 1371 | |
| 1372 | case VKI_SIGBUS: |
| 1373 | switch (info->si_code) { |
| 1374 | case 1: event = "Invalid address alignment"; break; |
| 1375 | case 2: event = "Non-existent physical address"; break; |
| 1376 | case 3: event = "Hardware error"; break; |
| 1377 | } |
| 1378 | break; |
| 1379 | } |
| 1380 | |
| 1381 | if (event != NULL) { |
| 1382 | if (haveaddr) |
nethercote | 3b390c7 | 2003-11-13 17:53:43 +0000 | [diff] [blame] | 1383 | VG_(message)(Vg_UserMsg, " %s at address %p", |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1384 | event, info->_sifields._sigfault._addr); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1385 | else |
| 1386 | VG_(message)(Vg_UserMsg, " %s", event); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1387 | } |
| 1388 | } |
fitzhardinge | 126c64f | 2003-12-08 21:58:37 +0000 | [diff] [blame] | 1389 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1390 | if (tid != VG_INVALID_THREADID) { |
njn | d01fef7 | 2005-03-25 23:35:48 +0000 | [diff] [blame] | 1391 | VG_(get_and_pp_StackTrace)(tid, VG_(clo_backtrace_size)); |
fitzhardinge | 126c64f | 2003-12-08 21:58:37 +0000 | [diff] [blame] | 1392 | } |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1393 | } |
| 1394 | |
| 1395 | if (VG_(is_action_requested)( "Attach to debugger", & VG_(clo_db_attach) )) { |
| 1396 | VG_(start_debugger)( tid ); |
| 1397 | } |
fitzhardinge | 126c64f | 2003-12-08 21:58:37 +0000 | [diff] [blame] | 1398 | |
njn | 277a6d6 | 2004-11-26 14:07:24 +0000 | [diff] [blame] | 1399 | // See comment above about this temporary disabling of core dumps. |
| 1400 | #if 0 |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1401 | if (core) { |
| 1402 | const static struct vki_rlimit zero = { 0, 0 }; |
fitzhardinge | 4a4d108 | 2004-03-15 23:46:54 +0000 | [diff] [blame] | 1403 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1404 | make_coredump(tid, info, corelim.rlim_cur); |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1405 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1406 | /* Make sure we don't get a confusing kernel-generated |
| 1407 | coredump when we finally exit */ |
| 1408 | VG_(setrlimit)(VKI_RLIMIT_CORE, &zero); |
| 1409 | } |
njn | 277a6d6 | 2004-11-26 14:07:24 +0000 | [diff] [blame] | 1410 | #endif |
fitzhardinge | d65dcad | 2004-03-13 02:06:58 +0000 | [diff] [blame] | 1411 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1412 | /* stash fatal signal in main thread */ |
sewardj | 1d88711 | 2005-05-30 21:44:08 +0000 | [diff] [blame] | 1413 | // what's this for? |
| 1414 | //VG_(threads)[VG_(master_tid)].os_state.fatalsig = sigNo; |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 1415 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1416 | /* everyone dies */ |
| 1417 | VG_(nuke_all_threads_except)(tid, VgSrc_FatalSig); |
| 1418 | VG_(threads)[tid].exitreason = VgSrc_FatalSig; |
| 1419 | VG_(threads)[tid].os_state.fatalsig = sigNo; |
sewardj | b48e500 | 2002-05-13 00:16:03 +0000 | [diff] [blame] | 1420 | } |
| 1421 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1422 | /* |
| 1423 | This does the business of delivering a signal to a thread. It may |
| 1424 | be called from either a real signal handler, or from normal code to |
| 1425 | cause the thread to enter the signal handler. |
sewardj | 5e2f001 | 2004-12-13 14:10:34 +0000 | [diff] [blame] | 1426 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1427 | This updates the thread state, but it does not set it to be |
| 1428 | Runnable. |
| 1429 | */ |
njn | 9ec0f3e | 2005-03-13 06:00:47 +0000 | [diff] [blame] | 1430 | static void deliver_signal ( ThreadId tid, const vki_siginfo_t *info ) |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 1431 | { |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1432 | Int sigNo = info->si_signo; |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 1433 | SCSS_Per_Signal *handler = &scss.scss_per_sig[sigNo]; |
fitzhardinge | 98abfc7 | 2003-12-16 02:05:15 +0000 | [diff] [blame] | 1434 | void *handler_fn; |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1435 | ThreadState *tst = VG_(get_ThreadState)(tid); |
| 1436 | |
| 1437 | if (VG_(clo_trace_signals)) |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1438 | VG_(message)(Vg_DebugMsg,"delivering signal %d (%s):%d to thread %d", |
| 1439 | sigNo, signame(sigNo), info->si_code, tid ); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1440 | |
njn | 351d006 | 2005-06-21 22:23:59 +0000 | [diff] [blame] | 1441 | if (sigNo == VG_SIGVGKILL) { |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1442 | /* If this is a SIGVGKILL, we're expecting it to interrupt any |
| 1443 | blocked syscall. It doesn't matter whether the VCPU state is |
| 1444 | set to restart or not, because we don't expect it will |
| 1445 | execute any more client instructions. */ |
| 1446 | vg_assert(VG_(is_exiting)(tid)); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1447 | return; |
| 1448 | } |
| 1449 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1450 | /* If the client specifies SIG_IGN, treat it as SIG_DFL. |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1451 | |
njn | 9ec0f3e | 2005-03-13 06:00:47 +0000 | [diff] [blame] | 1452 | If deliver_signal() is being called on a thread, we want |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1453 | the signal to get through no matter what; if they're ignoring |
| 1454 | it, then we do this override (this is so we can send it SIGSEGV, |
| 1455 | etc). */ |
fitzhardinge | 98abfc7 | 2003-12-16 02:05:15 +0000 | [diff] [blame] | 1456 | handler_fn = handler->scss_handler; |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1457 | if (handler_fn == VKI_SIG_IGN) |
fitzhardinge | 98abfc7 | 2003-12-16 02:05:15 +0000 | [diff] [blame] | 1458 | handler_fn = VKI_SIG_DFL; |
| 1459 | |
| 1460 | vg_assert(handler_fn != VKI_SIG_IGN); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1461 | |
fitzhardinge | 98abfc7 | 2003-12-16 02:05:15 +0000 | [diff] [blame] | 1462 | if (handler_fn == VKI_SIG_DFL) { |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 1463 | default_action(info, tid); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1464 | } else { |
| 1465 | /* Create a signal delivery frame, and set the client's %ESP and |
| 1466 | %EIP so that when execution continues, we will enter the |
| 1467 | signal handler with the frame on top of the client's stack, |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1468 | as it expects. |
| 1469 | |
| 1470 | Signal delivery can fail if the client stack is too small or |
| 1471 | missing, and we can't push the frame. If that happens, |
| 1472 | push_signal_frame will cause the whole process to exit when |
| 1473 | we next hit the scheduler. |
| 1474 | */ |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1475 | vg_assert(VG_(is_valid_tid)(tid)); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1476 | |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 1477 | push_signal_frame ( tid, info ); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1478 | |
| 1479 | if (handler->scss_flags & VKI_SA_ONESHOT) { |
| 1480 | /* Do the ONESHOT thing. */ |
| 1481 | handler->scss_handler = VKI_SIG_DFL; |
| 1482 | |
nethercote | 9dd1151 | 2004-08-04 15:31:30 +0000 | [diff] [blame] | 1483 | handle_SCSS_change( False /* lazy update */ ); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1484 | } |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1485 | |
| 1486 | /* At this point: |
| 1487 | tst->sig_mask is the current signal mask |
| 1488 | tst->tmp_sig_mask is the same as sig_mask, unless we're in sigsuspend |
| 1489 | handler->scss_mask is the mask set by the handler |
| 1490 | |
| 1491 | Handler gets a mask of tmp_sig_mask|handler_mask|signo |
| 1492 | */ |
| 1493 | tst->sig_mask = tst->tmp_sig_mask; |
| 1494 | if (!(handler->scss_flags & VKI_SA_NOMASK)) { |
| 1495 | VG_(sigaddset_from_set)(&tst->sig_mask, &handler->scss_mask); |
| 1496 | VG_(sigaddset)(&tst->sig_mask, sigNo); |
| 1497 | |
| 1498 | tst->tmp_sig_mask = tst->sig_mask; |
| 1499 | } |
| 1500 | } |
| 1501 | |
| 1502 | /* Thread state is ready to go - just add Runnable */ |
| 1503 | } |
| 1504 | |
njn | 06244e7 | 2005-06-21 22:27:19 +0000 | [diff] [blame] | 1505 | static void resume_scheduler(ThreadId tid) |
| 1506 | { |
| 1507 | ThreadState *tst = VG_(get_ThreadState)(tid); |
| 1508 | |
| 1509 | vg_assert(tst->os_state.lwpid == VG_(gettid)()); |
| 1510 | |
| 1511 | if (tst->sched_jmpbuf_valid) { |
| 1512 | /* Can't continue; must longjmp back to the scheduler and thus |
| 1513 | enter the sighandler immediately. */ |
| 1514 | longjmp(tst->sched_jmpbuf, True); |
| 1515 | } |
| 1516 | } |
| 1517 | |
njn | 9ec0f3e | 2005-03-13 06:00:47 +0000 | [diff] [blame] | 1518 | static void synth_fault_common(ThreadId tid, Addr addr, Int si_code) |
| 1519 | { |
| 1520 | vki_siginfo_t info; |
| 1521 | |
| 1522 | vg_assert(VG_(threads)[tid].status == VgTs_Runnable); |
| 1523 | |
| 1524 | info.si_signo = VKI_SIGSEGV; |
| 1525 | info.si_code = si_code; |
| 1526 | info._sifields._sigfault._addr = (void*)addr; |
| 1527 | |
| 1528 | /* If they're trying to block the signal, force it to be delivered */ |
| 1529 | if (VG_(sigismember)(&VG_(threads)[tid].sig_mask, VKI_SIGSEGV)) |
| 1530 | VG_(set_default_handler)(VKI_SIGSEGV); |
| 1531 | |
| 1532 | deliver_signal(tid, &info); |
| 1533 | } |
| 1534 | |
| 1535 | // Synthesize a fault where the address is OK, but the page |
| 1536 | // permissions are bad. |
| 1537 | void VG_(synth_fault_perms)(ThreadId tid, Addr addr) |
| 1538 | { |
| 1539 | synth_fault_common(tid, addr, 2); |
| 1540 | } |
| 1541 | |
| 1542 | // Synthesize a fault where the address there's nothing mapped at the address. |
| 1543 | void VG_(synth_fault_mapping)(ThreadId tid, Addr addr) |
| 1544 | { |
| 1545 | synth_fault_common(tid, addr, 1); |
| 1546 | } |
| 1547 | |
| 1548 | // Synthesize a misc memory fault. |
| 1549 | void VG_(synth_fault)(ThreadId tid) |
| 1550 | { |
| 1551 | synth_fault_common(tid, 0, 0x80); |
| 1552 | } |
| 1553 | |
| 1554 | // Synthesise a SIGILL. |
| 1555 | void VG_(synth_sigill)(ThreadId tid, Addr addr) |
| 1556 | { |
| 1557 | vki_siginfo_t info; |
| 1558 | |
| 1559 | vg_assert(VG_(threads)[tid].status == VgTs_Runnable); |
| 1560 | |
| 1561 | info.si_signo = VKI_SIGILL; |
| 1562 | info.si_code = 1; /* jrs: no idea what this should be */ |
| 1563 | info._sifields._sigfault._addr = (void*)addr; |
| 1564 | |
njn | 06244e7 | 2005-06-21 22:27:19 +0000 | [diff] [blame] | 1565 | resume_scheduler(tid); |
njn | 9ec0f3e | 2005-03-13 06:00:47 +0000 | [diff] [blame] | 1566 | deliver_signal(tid, &info); |
| 1567 | } |
| 1568 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1569 | /* Make a signal pending for a thread, for later delivery. |
| 1570 | VG_(poll_signals) will arrange for it to be delivered at the right |
| 1571 | time. |
| 1572 | |
| 1573 | tid==0 means add it to the process-wide queue, and not sent it to a |
| 1574 | specific thread. |
| 1575 | */ |
sewardj | 2c5ffbe | 2005-03-12 13:32:06 +0000 | [diff] [blame] | 1576 | static |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1577 | void queue_signal(ThreadId tid, const vki_siginfo_t *si) |
| 1578 | { |
| 1579 | ThreadState *tst; |
| 1580 | SigQueue *sq; |
| 1581 | vki_sigset_t savedmask; |
| 1582 | |
| 1583 | tst = VG_(get_ThreadState)(tid); |
| 1584 | |
| 1585 | /* Protect the signal queue against async deliveries */ |
njn | 444eba1 | 2005-05-12 03:47:31 +0000 | [diff] [blame] | 1586 | block_all_host_signals(&savedmask); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1587 | |
| 1588 | if (tst->sig_queue == NULL) { |
| 1589 | tst->sig_queue = VG_(arena_malloc)(VG_AR_CORE, sizeof(*tst->sig_queue)); |
| 1590 | VG_(memset)(tst->sig_queue, 0, sizeof(*tst->sig_queue)); |
| 1591 | } |
| 1592 | sq = tst->sig_queue; |
| 1593 | |
| 1594 | if (VG_(clo_trace_signals)) |
| 1595 | VG_(message)(Vg_DebugMsg, "Queueing signal %d (idx %d) to thread %d", |
| 1596 | si->si_signo, sq->next, tid); |
| 1597 | |
| 1598 | /* Add signal to the queue. If the queue gets overrun, then old |
| 1599 | queued signals may get lost. |
| 1600 | |
| 1601 | XXX We should also keep a sigset of pending signals, so that at |
| 1602 | least a non-siginfo signal gets deliviered. |
| 1603 | */ |
| 1604 | if (sq->sigs[sq->next].si_signo != 0) |
| 1605 | VG_(message)(Vg_UserMsg, "Signal %d being dropped from thread %d's queue", |
| 1606 | sq->sigs[sq->next].si_signo, tid); |
| 1607 | |
| 1608 | sq->sigs[sq->next] = *si; |
| 1609 | sq->next = (sq->next+1) % N_QUEUED_SIGNALS; |
| 1610 | |
njn | 444eba1 | 2005-05-12 03:47:31 +0000 | [diff] [blame] | 1611 | restore_all_host_signals(&savedmask); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1612 | } |
| 1613 | |
| 1614 | /* |
| 1615 | Returns the next queued signal for thread tid which is in "set". |
| 1616 | tid==0 means process-wide signal. Set si_signo to 0 when the |
| 1617 | signal has been delivered. |
| 1618 | |
| 1619 | Must be called with all signals blocked, to protect against async |
| 1620 | deliveries. |
| 1621 | */ |
| 1622 | static vki_siginfo_t *next_queued(ThreadId tid, const vki_sigset_t *set) |
| 1623 | { |
| 1624 | ThreadState *tst = VG_(get_ThreadState)(tid); |
| 1625 | SigQueue *sq; |
| 1626 | Int idx; |
| 1627 | vki_siginfo_t *ret = NULL; |
| 1628 | |
| 1629 | sq = tst->sig_queue; |
| 1630 | if (sq == NULL) |
| 1631 | goto out; |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1632 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1633 | idx = sq->next; |
| 1634 | do { |
| 1635 | if (0) |
| 1636 | VG_(printf)("idx=%d si_signo=%d inset=%d\n", idx, |
| 1637 | sq->sigs[idx].si_signo, VG_(sigismember)(set, sq->sigs[idx].si_signo)); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1638 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1639 | if (sq->sigs[idx].si_signo != 0 && VG_(sigismember)(set, sq->sigs[idx].si_signo)) { |
| 1640 | if (VG_(clo_trace_signals)) |
| 1641 | VG_(message)(Vg_DebugMsg, "Returning queued signal %d (idx %d) for thread %d", |
| 1642 | sq->sigs[idx].si_signo, idx, tid); |
| 1643 | ret = &sq->sigs[idx]; |
| 1644 | goto out; |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1645 | } |
| 1646 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1647 | idx = (idx + 1) % N_QUEUED_SIGNALS; |
| 1648 | } while(idx != sq->next); |
| 1649 | out: |
| 1650 | return ret; |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1651 | } |
| 1652 | |
| 1653 | /* |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1654 | Receive an async signal from the kernel. |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1655 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1656 | This should only happen when the thread is blocked in a syscall, |
| 1657 | since that's the only time this set of signals is unblocked. |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1658 | */ |
| 1659 | static |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 1660 | void async_signalhandler ( Int sigNo, vki_siginfo_t *info, struct vki_ucontext *uc ) |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1661 | { |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1662 | ThreadId tid = VG_(get_lwp_tid)(VG_(gettid)()); |
| 1663 | ThreadState *tst = VG_(get_ThreadState)(tid); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1664 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1665 | vg_assert(tst->status == VgTs_WaitSys); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1666 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1667 | /* The thread isn't currently running, make it so before going on */ |
| 1668 | VG_(set_running)(tid); |
| 1669 | |
| 1670 | if (VG_(clo_trace_signals)) |
| 1671 | VG_(message)(Vg_DebugMsg, "Async handler got signal %d for tid %d info %d", |
| 1672 | sigNo, tid, info->si_code); |
| 1673 | |
| 1674 | /* Update thread state properly */ |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 1675 | VG_(fixup_guest_state_after_syscall_interrupted)( |
| 1676 | tid, |
njn | af839f5 | 2005-06-23 03:27:57 +0000 | [diff] [blame] | 1677 | VG_UCONTEXT_INSTR_PTR(uc), |
| 1678 | VG_UCONTEXT_SYSCALL_NUM(uc), |
| 1679 | VG_UCONTEXT_SYSCALL_SYSRES(uc), |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 1680 | !!(scss.scss_per_sig[sigNo].scss_flags & VKI_SA_RESTART) |
| 1681 | ); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1682 | |
| 1683 | /* Set up the thread's state to deliver a signal */ |
njn | 07ef6c0 | 2005-05-18 19:43:09 +0000 | [diff] [blame] | 1684 | if (!is_sig_ign(info->si_signo)) |
njn | 9ec0f3e | 2005-03-13 06:00:47 +0000 | [diff] [blame] | 1685 | deliver_signal(tid, info); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1686 | |
| 1687 | /* longjmp back to the thread's main loop to start executing the |
| 1688 | handler. */ |
njn | 06244e7 | 2005-06-21 22:27:19 +0000 | [diff] [blame] | 1689 | resume_scheduler(tid); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1690 | |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 1691 | VG_(core_panic)("async_signalhandler: got unexpected signal while outside of scheduler"); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1692 | } |
| 1693 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1694 | /* Extend the stack to cover addr. maxsize is the limit the stack can grow to. |
| 1695 | |
| 1696 | Returns True on success, False on failure. |
| 1697 | |
| 1698 | Succeeds without doing anything if addr is already within a segment. |
| 1699 | |
| 1700 | Failure could be caused by: |
| 1701 | - addr not below a growable segment |
| 1702 | - new stack size would exceed maxsize |
| 1703 | - mmap failed for some other reason |
| 1704 | */ |
| 1705 | Bool VG_(extend_stack)(Addr addr, UInt maxsize) |
| 1706 | { |
| 1707 | Segment *seg; |
| 1708 | Addr base; |
| 1709 | UInt newsize; |
| 1710 | |
| 1711 | /* Find the next Segment above addr */ |
| 1712 | seg = VG_(find_segment)(addr); |
| 1713 | if (seg) |
| 1714 | return True; |
| 1715 | |
| 1716 | /* now we know addr is definitely unmapped */ |
| 1717 | seg = VG_(find_segment_above_unmapped)(addr); |
| 1718 | |
| 1719 | /* If there isn't one, or it isn't growable, fail */ |
| 1720 | if (seg == NULL || |
| 1721 | !(seg->flags & SF_GROWDOWN) || |
| 1722 | VG_(seg_contains)(seg, addr, sizeof(void *))) |
| 1723 | return False; |
| 1724 | |
| 1725 | vg_assert(seg->addr > addr); |
| 1726 | |
| 1727 | /* Create the mapping */ |
njn | 13bfd85 | 2005-06-02 03:52:53 +0000 | [diff] [blame] | 1728 | base = VG_PGROUNDDN(addr); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1729 | newsize = seg->addr - base; |
| 1730 | |
| 1731 | if (seg->len + newsize >= maxsize) |
| 1732 | return False; |
| 1733 | |
sewardj | 50b8f77 | 2005-08-02 13:35:21 +0000 | [diff] [blame] | 1734 | /* Nasty Hack. The new segment will have SF_MMAP set because |
| 1735 | that's what VG_(mmap) does. But the existing stack segment |
| 1736 | won't necessarily have it set, because the initial segment list |
| 1737 | entry for the main thread's stack doesn't have it set. That |
| 1738 | means that the segment list preener won't merge the segments |
| 1739 | together (because they have different flags). That means the |
| 1740 | segment list will in fact list two adjacent segments for the |
| 1741 | main stack, which is wrong. This means that the tests which |
| 1742 | check if a translation is from a stack-like area and therefore |
| 1743 | in need of a self-check will not work right. Sigh. |
| 1744 | |
| 1745 | So .. in lieu of fixing this properly (viz, rationalising all |
| 1746 | the SF_ flags), just mark the original stack segment as having |
| 1747 | SF_MMAP. Then the preener will merge it into the new area. |
| 1748 | This is a hack. */ |
| 1749 | seg->flags |= SF_MMAP; |
| 1750 | /* end of Nasty Hack */ |
| 1751 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1752 | if (VG_(mmap)((Char *)base, newsize, |
| 1753 | seg->prot, |
| 1754 | VKI_MAP_PRIVATE | VKI_MAP_FIXED | VKI_MAP_ANONYMOUS | VKI_MAP_CLIENT, |
| 1755 | seg->flags, |
| 1756 | -1, 0) == (void *)-1) |
| 1757 | return False; |
| 1758 | |
rjwalsh | 0140af5 | 2005-06-04 20:42:33 +0000 | [diff] [blame] | 1759 | /* When we change the main stack, we have to let the stack handling |
| 1760 | code know about it. */ |
njn | 945ed2e | 2005-06-24 03:28:30 +0000 | [diff] [blame] | 1761 | VG_(change_stack)(VG_(clstk_id), base, VG_(clstk_end)); |
rjwalsh | 0140af5 | 2005-06-04 20:42:33 +0000 | [diff] [blame] | 1762 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1763 | if (0) |
| 1764 | VG_(printf)("extended stack: %p %d\n", |
| 1765 | base, newsize); |
| 1766 | |
| 1767 | if (VG_(clo_sanity_level) > 2) |
| 1768 | VG_(sanity_check_general)(False); |
| 1769 | |
| 1770 | return True; |
| 1771 | } |
| 1772 | |
| 1773 | static void (*fault_catcher)(Int sig, Addr addr); |
| 1774 | |
| 1775 | void VG_(set_fault_catcher)(void (*catcher)(Int, Addr)) |
| 1776 | { |
njn | 50ae1a7 | 2005-04-08 23:28:23 +0000 | [diff] [blame] | 1777 | vg_assert2(NULL == catcher || NULL == fault_catcher, |
| 1778 | "Fault catcher is already registered"); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1779 | |
| 1780 | fault_catcher = catcher; |
| 1781 | } |
| 1782 | |
| 1783 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1784 | /* |
sewardj | 2a99cf6 | 2004-11-24 10:44:19 +0000 | [diff] [blame] | 1785 | Receive a sync signal from the host. |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1786 | */ |
| 1787 | static |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 1788 | void sync_signalhandler ( Int sigNo, vki_siginfo_t *info, struct vki_ucontext *uc ) |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1789 | { |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1790 | ThreadId tid = VG_(get_lwp_tid)(VG_(gettid)()); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1791 | |
| 1792 | vg_assert(info != NULL); |
| 1793 | vg_assert(info->si_signo == sigNo); |
| 1794 | vg_assert(sigNo == VKI_SIGSEGV || |
| 1795 | sigNo == VKI_SIGBUS || |
| 1796 | sigNo == VKI_SIGFPE || |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1797 | sigNo == VKI_SIGILL || |
| 1798 | sigNo == VKI_SIGTRAP); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1799 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1800 | if (info->si_code <= VKI_SI_USER) { |
| 1801 | /* If some user-process sent us one of these signals (ie, |
| 1802 | they're not the result of a faulting instruction), then treat |
| 1803 | it as an async signal. This is tricky because we could get |
| 1804 | this almost anywhere: |
| 1805 | - while generated client code |
| 1806 | Action: queue signal and return |
| 1807 | - while running Valgrind code |
| 1808 | Action: queue signal and return |
| 1809 | - while blocked in a syscall |
| 1810 | Action: make thread runnable, queue signal, resume scheduler |
| 1811 | */ |
| 1812 | if (VG_(threads)[tid].status == VgTs_WaitSys) { |
| 1813 | /* Since this signal interrupted a syscall, it means the |
| 1814 | client's signal mask was applied, so we can't get here |
| 1815 | unless the client wants this signal right now. This means |
| 1816 | we can simply use the async_signalhandler. */ |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 1817 | async_signalhandler(sigNo, info, uc); |
| 1818 | VG_(core_panic)("async_signalhandler returned!?\n"); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1819 | } |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1820 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1821 | if (info->_sifields._kill._pid == 0) { |
| 1822 | /* There's a per-user limit of pending siginfo signals. If |
| 1823 | you exceed this, by having more than that number of |
| 1824 | pending signals with siginfo, then new signals are |
| 1825 | delivered without siginfo. This condition can be caused |
| 1826 | by any unrelated program you're running at the same time |
| 1827 | as Valgrind, if it has a large number of pending siginfo |
| 1828 | signals which it isn't taking delivery of. |
| 1829 | |
| 1830 | Since we depend on siginfo to work out why we were sent a |
| 1831 | signal and what we should do about it, we really can't |
| 1832 | continue unless we get it. */ |
| 1833 | VG_(message)(Vg_UserMsg, "Signal %d (%s) appears to have lost its siginfo; I can't go on.", |
| 1834 | sigNo, signame(sigNo)); |
| 1835 | VG_(message)(Vg_UserMsg, " This may be because one of your programs has consumed your"); |
| 1836 | VG_(message)(Vg_UserMsg, " ration of siginfo structures."); |
njn | 504b72b | 2005-08-16 01:39:34 +0000 | [diff] [blame] | 1837 | VG_(printf)( |
| 1838 | " For more information, see:\n" |
| 1839 | " http://kerneltrap.org/mailarchive/1/message/25599/thread\n" |
| 1840 | " Basically, some program on your system is building up a large queue of\n" |
| 1841 | " pending signals, and this causes the siginfo data for other signals to\n" |
| 1842 | " be dropped because it's exceeding a system limit. However, Valgrind\n" |
| 1843 | " absolutely needs siginfo for SIGSEGV. A workaround is to track down the\n" |
| 1844 | " offending program and avoid running it while using Valgrind, but there\n" |
| 1845 | " is no easy way to do this. Apparently the problem was fixed in kernel\n" |
| 1846 | " 2.6.12.\n"); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1847 | |
| 1848 | /* It's a fatal signal, so we force the default handler. */ |
| 1849 | VG_(set_default_handler)(sigNo); |
njn | 9ec0f3e | 2005-03-13 06:00:47 +0000 | [diff] [blame] | 1850 | deliver_signal(tid, info); |
njn | 06244e7 | 2005-06-21 22:27:19 +0000 | [diff] [blame] | 1851 | resume_scheduler(tid); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1852 | VG_(exit)(99); /* If we can't resume, then just exit */ |
| 1853 | } |
| 1854 | |
| 1855 | if (VG_(clo_trace_signals)) |
| 1856 | VG_(message)(Vg_DebugMsg, "Routing user-sent sync signal %d via queue", |
| 1857 | sigNo); |
| 1858 | |
| 1859 | /* Since every thread has these signals unblocked, we can't rely |
| 1860 | on the kernel to route them properly, so we need to queue |
| 1861 | them manually. */ |
| 1862 | if (info->si_code == VKI_SI_TKILL) |
| 1863 | queue_signal(tid, info); /* directed to us specifically */ |
| 1864 | else |
| 1865 | queue_signal(0, info); /* shared pending */ |
| 1866 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1867 | return; |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1868 | } |
| 1869 | |
| 1870 | if (VG_(clo_trace_signals)) { |
| 1871 | VG_(message)(Vg_DebugMsg, "signal %d arrived ... si_code=%d, EIP=%p, eip=%p", |
njn | f536bbb | 2005-06-13 04:21:38 +0000 | [diff] [blame] | 1872 | sigNo, info->si_code, VG_(get_IP)(tid), |
njn | af839f5 | 2005-06-23 03:27:57 +0000 | [diff] [blame] | 1873 | VG_UCONTEXT_INSTR_PTR(uc) ); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1874 | } |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1875 | vg_assert(sigNo >= 1 && sigNo <= VG_(max_signal)); |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 1876 | |
fitzhardinge | 98abfc7 | 2003-12-16 02:05:15 +0000 | [diff] [blame] | 1877 | /* Special fault-handling case. We can now get signals which can |
| 1878 | act upon and immediately restart the faulting instruction. |
| 1879 | */ |
| 1880 | if (info->si_signo == VKI_SIGSEGV) { |
fitzhardinge | 98abfc7 | 2003-12-16 02:05:15 +0000 | [diff] [blame] | 1881 | Addr fault = (Addr)info->_sifields._sigfault._addr; |
njn | f536bbb | 2005-06-13 04:21:38 +0000 | [diff] [blame] | 1882 | Addr esp = VG_(get_SP)(tid); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1883 | Segment* seg; |
fitzhardinge | 98abfc7 | 2003-12-16 02:05:15 +0000 | [diff] [blame] | 1884 | |
| 1885 | seg = VG_(find_segment)(fault); |
sewardj | 548be6d | 2005-02-16 01:31:37 +0000 | [diff] [blame] | 1886 | if (seg == NULL) |
| 1887 | seg = VG_(find_segment_above_unmapped)(fault); |
| 1888 | |
fitzhardinge | 98abfc7 | 2003-12-16 02:05:15 +0000 | [diff] [blame] | 1889 | if (VG_(clo_trace_signals)) { |
| 1890 | if (seg == NULL) |
| 1891 | VG_(message)(Vg_DebugMsg, |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1892 | "SIGSEGV: si_code=%d faultaddr=%p tid=%d ESP=%p seg=NULL shad=%p-%p", |
fitzhardinge | 98abfc7 | 2003-12-16 02:05:15 +0000 | [diff] [blame] | 1893 | info->si_code, fault, tid, esp, |
| 1894 | VG_(shadow_base), VG_(shadow_end)); |
| 1895 | else |
| 1896 | VG_(message)(Vg_DebugMsg, |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1897 | "SIGSEGV: si_code=%d faultaddr=%p tid=%d ESP=%p seg=%p-%p fl=%x shad=%p-%p", |
fitzhardinge | 98abfc7 | 2003-12-16 02:05:15 +0000 | [diff] [blame] | 1898 | info->si_code, fault, tid, esp, seg->addr, seg->addr+seg->len, seg->flags, |
| 1899 | VG_(shadow_base), VG_(shadow_end)); |
| 1900 | } |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1901 | if (info->si_code == 1 /* SEGV_MAPERR */ |
njn | af839f5 | 2005-06-23 03:27:57 +0000 | [diff] [blame] | 1902 | && fault >= (esp - VG_STACK_REDZONE_SZB) |
njn | cafca7b | 2005-03-13 04:39:28 +0000 | [diff] [blame] | 1903 | && fault < VG_(client_end)) { |
fitzhardinge | 98abfc7 | 2003-12-16 02:05:15 +0000 | [diff] [blame] | 1904 | /* If the fault address is above esp but below the current known |
| 1905 | stack segment base, and it was a fault because there was |
| 1906 | nothing mapped there (as opposed to a permissions fault), |
| 1907 | then extend the stack segment. |
| 1908 | */ |
njn | af839f5 | 2005-06-23 03:27:57 +0000 | [diff] [blame] | 1909 | Addr base = VG_PGROUNDDN(esp - VG_STACK_REDZONE_SZB); |
njn | 50ba34e | 2005-04-04 02:41:42 +0000 | [diff] [blame] | 1910 | if (VG_(extend_stack)(base, VG_(threads)[tid].client_stack_szB)) { |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1911 | if (VG_(clo_trace_signals)) |
| 1912 | VG_(message)(Vg_DebugMsg, |
njn | 13bfd85 | 2005-06-02 03:52:53 +0000 | [diff] [blame] | 1913 | " -> extended stack base to %p", VG_PGROUNDDN(fault)); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1914 | return; // extension succeeded, restart instruction |
| 1915 | } else |
| 1916 | VG_(message)(Vg_UserMsg, "Stack overflow in thread %d: can't grow stack to %p", |
| 1917 | tid, fault); |
fitzhardinge | 98abfc7 | 2003-12-16 02:05:15 +0000 | [diff] [blame] | 1918 | } |
njn | b69f7c1 | 2005-06-24 22:17:38 +0000 | [diff] [blame] | 1919 | /* Fall into normal signal handling for all other cases */ |
fitzhardinge | 98abfc7 | 2003-12-16 02:05:15 +0000 | [diff] [blame] | 1920 | } |
| 1921 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1922 | /* OK, this is a signal we really have to deal with. If it came |
| 1923 | from the client's code, then we can jump back into the scheduler |
| 1924 | and have it delivered. Otherwise it's a Valgrind bug. */ |
| 1925 | { |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1926 | ThreadState *tst = VG_(get_ThreadState)(VG_(get_lwp_tid)(VG_(gettid)())); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1927 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1928 | if (VG_(sigismember)(&tst->sig_mask, sigNo)) { |
| 1929 | /* signal is blocked, but they're not allowed to block faults */ |
| 1930 | VG_(set_default_handler)(sigNo); |
| 1931 | } |
| 1932 | |
| 1933 | if (!VG_(my_fault)) { |
| 1934 | /* Can't continue; must longjmp back to the scheduler and thus |
| 1935 | enter the sighandler immediately. */ |
njn | 9ec0f3e | 2005-03-13 06:00:47 +0000 | [diff] [blame] | 1936 | deliver_signal(tid, info); |
njn | 06244e7 | 2005-06-21 22:27:19 +0000 | [diff] [blame] | 1937 | resume_scheduler(tid); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1938 | } |
| 1939 | |
| 1940 | /* Check to see if someone is interested in faults. */ |
| 1941 | if (fault_catcher) { |
| 1942 | (*fault_catcher)(sigNo, (Addr)info->_sifields._sigfault._addr); |
| 1943 | |
| 1944 | /* If the catcher returns, then it didn't handle the fault, |
| 1945 | so carry on panicing. */ |
| 1946 | } |
| 1947 | |
| 1948 | /* If resume_scheduler returns or its our fault, it means we |
| 1949 | don't have longjmp set up, implying that we weren't running |
| 1950 | client code, and therefore it was actually generated by |
| 1951 | Valgrind internally. |
| 1952 | */ |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1953 | VG_(message)(Vg_DebugMsg, |
| 1954 | "INTERNAL ERROR: Valgrind received a signal %d (%s) - exiting", |
| 1955 | sigNo, signame(sigNo)); |
fitzhardinge | 98abfc7 | 2003-12-16 02:05:15 +0000 | [diff] [blame] | 1956 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1957 | VG_(message)(Vg_DebugMsg, |
njn | d0073f4 | 2005-05-14 17:00:25 +0000 | [diff] [blame] | 1958 | "si_code=%x; Faulting address: %p; sp: %p", |
| 1959 | info->si_code, info->_sifields._sigfault._addr, |
njn | af839f5 | 2005-06-23 03:27:57 +0000 | [diff] [blame] | 1960 | VG_UCONTEXT_STACK_PTR(uc)); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1961 | |
| 1962 | if (0) |
| 1963 | VG_(kill_self)(sigNo); /* generate a core dump */ |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1964 | |
sewardj | 1d88711 | 2005-05-30 21:44:08 +0000 | [diff] [blame] | 1965 | //if (tid == 0) /* could happen after everyone has exited */ |
| 1966 | // tid = VG_(master_tid); |
| 1967 | vg_assert(tid != 0); |
| 1968 | |
njn | db13c4f | 2005-06-01 00:00:46 +0000 | [diff] [blame] | 1969 | VG_(core_panic_at)("Killed by fatal signal", |
njn | af839f5 | 2005-06-23 03:27:57 +0000 | [diff] [blame] | 1970 | VG_UCONTEXT_INSTR_PTR(uc), |
| 1971 | VG_UCONTEXT_STACK_PTR(uc), |
sewardj | acaec5f | 2005-08-19 16:02:59 +0000 | [diff] [blame] | 1972 | VG_UCONTEXT_FRAME_PTR(uc), |
| 1973 | VG_UCONTEXT_LINK_REG(uc)); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1974 | } |
| 1975 | } |
| 1976 | |
| 1977 | |
| 1978 | /* |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1979 | Kill this thread. Makes it leave any syscall it might be currently |
| 1980 | blocked in, and return to the scheduler. This doesn't mark the thread |
| 1981 | as exiting; that's the caller's job. |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1982 | */ |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1983 | static void sigvgkill_handler(int signo, vki_siginfo_t *si, struct vki_ucontext *uc) |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1984 | { |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1985 | ThreadId tid = VG_(get_lwp_tid)(VG_(gettid)()); |
| 1986 | |
| 1987 | if (VG_(clo_trace_signals)) |
| 1988 | VG_(message)(Vg_DebugMsg, "sigvgkill for lwp %d tid %d", VG_(gettid)(), tid); |
| 1989 | |
njn | 351d006 | 2005-06-21 22:23:59 +0000 | [diff] [blame] | 1990 | vg_assert(signo == VG_SIGVGKILL); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1991 | vg_assert(si->si_signo == signo); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1992 | vg_assert(VG_(threads)[tid].status == VgTs_WaitSys); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 1993 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1994 | VG_(set_running)(tid); |
| 1995 | VG_(post_syscall)(tid); |
| 1996 | |
njn | 06244e7 | 2005-06-21 22:27:19 +0000 | [diff] [blame] | 1997 | resume_scheduler(tid); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 1998 | |
| 1999 | VG_(core_panic)("sigvgkill_handler couldn't return to the scheduler\n"); |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 2000 | } |
| 2001 | |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 2002 | static __attribute((unused)) |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 2003 | void pp_ksigaction ( struct vki_sigaction* sa ) |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 2004 | { |
| 2005 | Int i; |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 2006 | VG_(printf)("pp_ksigaction: handler %p, flags 0x%x, restorer %p\n", |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 2007 | sa->ksa_handler, (UInt)sa->sa_flags, sa->sa_restorer); |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 2008 | VG_(printf)("pp_ksigaction: { "); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 2009 | for (i = 1; i <= VG_(max_signal); i++) |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 2010 | if (VG_(sigismember(&(sa->sa_mask),i))) |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 2011 | VG_(printf)("%d ", i); |
| 2012 | VG_(printf)("}\n"); |
| 2013 | } |
| 2014 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 2015 | /* |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 2016 | Force signal handler to default |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 2017 | */ |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 2018 | void VG_(set_default_handler)(Int signo) |
| 2019 | { |
| 2020 | struct vki_sigaction sa; |
| 2021 | |
| 2022 | sa.ksa_handler = VKI_SIG_DFL; |
| 2023 | sa.sa_flags = 0; |
| 2024 | sa.sa_restorer = 0; |
| 2025 | VG_(sigemptyset)(&sa.sa_mask); |
| 2026 | |
| 2027 | VG_(do_sys_sigaction)(signo, &sa, NULL); |
| 2028 | } |
| 2029 | |
| 2030 | /* |
| 2031 | Poll for pending signals, and set the next one up for delivery. |
| 2032 | */ |
| 2033 | void VG_(poll_signals)(ThreadId tid) |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 2034 | { |
| 2035 | static const struct vki_timespec zero = { 0, 0 }; |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 2036 | vki_siginfo_t si, *sip; |
| 2037 | vki_sigset_t pollset; |
| 2038 | ThreadState *tst = VG_(get_ThreadState)(tid); |
| 2039 | Int i; |
| 2040 | vki_sigset_t saved_mask; |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 2041 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 2042 | /* look for all the signals this thread isn't blocking */ |
| 2043 | for(i = 0; i < _VKI_NSIG_WORDS; i++) |
| 2044 | pollset.sig[i] = ~tst->sig_mask.sig[i]; |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 2045 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 2046 | //VG_(printf)("tid %d pollset=%08x%08x\n", tid, pollset.sig[1], pollset.sig[0]); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 2047 | |
njn | 444eba1 | 2005-05-12 03:47:31 +0000 | [diff] [blame] | 2048 | block_all_host_signals(&saved_mask); // protect signal queue |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 2049 | |
| 2050 | /* First look for any queued pending signals */ |
| 2051 | sip = next_queued(tid, &pollset); /* this thread */ |
| 2052 | |
| 2053 | if (sip == NULL) |
| 2054 | sip = next_queued(0, &pollset); /* process-wide */ |
| 2055 | |
| 2056 | /* If there was nothing queued, ask the kernel for a pending signal */ |
| 2057 | if (sip == NULL && VG_(sigtimedwait)(&pollset, &si, &zero) > 0) { |
| 2058 | if (VG_(clo_trace_signals)) |
sewardj | a8d8e23 | 2005-06-07 20:04:56 +0000 | [diff] [blame] | 2059 | VG_(message)(Vg_DebugMsg, "poll_signals: got signal %d " |
| 2060 | "for thread %d", si.si_signo, tid); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 2061 | sip = &si; |
thughes | 8abf392 | 2004-10-16 10:59:49 +0000 | [diff] [blame] | 2062 | } |
fitzhardinge | e1c06d8 | 2003-10-30 07:21:44 +0000 | [diff] [blame] | 2063 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 2064 | if (sip != NULL) { |
| 2065 | /* OK, something to do; deliver it */ |
| 2066 | if (VG_(clo_trace_signals)) |
| 2067 | VG_(message)(Vg_DebugMsg, "Polling found signal %d for tid %d", |
| 2068 | sip->si_signo, tid); |
njn | 07ef6c0 | 2005-05-18 19:43:09 +0000 | [diff] [blame] | 2069 | if (!is_sig_ign(sip->si_signo)) |
njn | 9ec0f3e | 2005-03-13 06:00:47 +0000 | [diff] [blame] | 2070 | deliver_signal(tid, sip); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 2071 | else if (VG_(clo_trace_signals)) |
| 2072 | VG_(message)(Vg_DebugMsg, " signal %d ignored", sip->si_signo); |
| 2073 | |
| 2074 | sip->si_signo = 0; /* remove from signal queue, if that's |
| 2075 | where it came from */ |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 2076 | } |
| 2077 | |
njn | 444eba1 | 2005-05-12 03:47:31 +0000 | [diff] [blame] | 2078 | restore_all_host_signals(&saved_mask); |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 2079 | } |
| 2080 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 2081 | /* At startup, copy the process' real signal state to the SCSS. |
| 2082 | Whilst doing this, block all real signals. Then calculate SKSS and |
| 2083 | set the kernel to that. Also initialise DCSS. |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 2084 | */ |
| 2085 | void VG_(sigstartup_actions) ( void ) |
| 2086 | { |
| 2087 | Int i, ret; |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 2088 | vki_sigset_t saved_procmask; |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 2089 | struct vki_sigaction sa; |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 2090 | |
sewardj | 2e93c50 | 2002-04-12 11:12:52 +0000 | [diff] [blame] | 2091 | /* VG_(printf)("SIGSTARTUP\n"); */ |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 2092 | /* Block all signals. saved_procmask remembers the previous mask, |
| 2093 | which the first thread inherits. |
| 2094 | */ |
njn | 444eba1 | 2005-05-12 03:47:31 +0000 | [diff] [blame] | 2095 | block_all_host_signals( &saved_procmask ); |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 2096 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 2097 | /* Copy per-signal settings to SCSS. */ |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 2098 | for (i = 1; i <= _VKI_NSIG; i++) { |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 2099 | /* Get the old host action */ |
nethercote | 73b526f | 2004-10-31 18:48:21 +0000 | [diff] [blame] | 2100 | ret = VG_(sigaction)(i, NULL, &sa); |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 2101 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 2102 | if (ret != 0) |
| 2103 | break; |
| 2104 | |
| 2105 | /* Try setting it back to see if this signal is really |
| 2106 | available */ |
| 2107 | if (i >= VKI_SIGRTMIN) { |
| 2108 | struct vki_sigaction tsa; |
| 2109 | |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 2110 | tsa.ksa_handler = (void *)sync_signalhandler; |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 2111 | tsa.sa_flags = VKI_SA_SIGINFO; |
| 2112 | tsa.sa_restorer = 0; |
| 2113 | VG_(sigfillset)(&tsa.sa_mask); |
| 2114 | |
| 2115 | /* try setting it to some arbitrary handler */ |
| 2116 | if (VG_(sigaction)(i, &tsa, NULL) != 0) { |
| 2117 | /* failed - not really usable */ |
| 2118 | break; |
| 2119 | } |
| 2120 | |
| 2121 | ret = VG_(sigaction)(i, &sa, NULL); |
| 2122 | vg_assert(ret == 0); |
| 2123 | } |
| 2124 | |
| 2125 | VG_(max_signal) = i; |
| 2126 | |
| 2127 | if (VG_(clo_trace_signals) && VG_(clo_verbosity) > 2) |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 2128 | VG_(printf)("snaffling handler 0x%x for signal %d\n", |
| 2129 | (Addr)(sa.ksa_handler), i ); |
| 2130 | |
njn | 695c16e | 2005-03-27 03:40:28 +0000 | [diff] [blame] | 2131 | scss.scss_per_sig[i].scss_handler = sa.ksa_handler; |
| 2132 | scss.scss_per_sig[i].scss_flags = sa.sa_flags; |
| 2133 | scss.scss_per_sig[i].scss_mask = sa.sa_mask; |
| 2134 | scss.scss_per_sig[i].scss_restorer = sa.sa_restorer; |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 2135 | } |
| 2136 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 2137 | if (VG_(clo_trace_signals)) |
| 2138 | VG_(message)(Vg_DebugMsg, "Max kernel-supported signal is %d", VG_(max_signal)); |
| 2139 | |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 2140 | /* Our private internal signals are treated as ignored */ |
njn | 351d006 | 2005-06-21 22:23:59 +0000 | [diff] [blame] | 2141 | scss.scss_per_sig[VG_SIGVGKILL].scss_handler = VKI_SIG_IGN; |
| 2142 | scss.scss_per_sig[VG_SIGVGKILL].scss_flags = VKI_SA_SIGINFO; |
| 2143 | VG_(sigfillset)(&scss.scss_per_sig[VG_SIGVGKILL].scss_mask); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 2144 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 2145 | /* Copy the process' signal mask into the root thread. */ |
sewardj | 1d88711 | 2005-05-30 21:44:08 +0000 | [diff] [blame] | 2146 | vg_assert(VG_(threads)[1].status == VgTs_Init); |
| 2147 | for (i = 2; i < VG_N_THREADS; i++) |
| 2148 | vg_assert(VG_(threads)[i].status == VgTs_Empty); |
| 2149 | |
| 2150 | VG_(threads)[1].sig_mask = saved_procmask; |
| 2151 | VG_(threads)[1].tmp_sig_mask = saved_procmask; |
sewardj | 7a61d91 | 2002-04-25 01:27:35 +0000 | [diff] [blame] | 2152 | |
sewardj | 018f762 | 2002-05-15 21:13:39 +0000 | [diff] [blame] | 2153 | /* Calculate SKSS and apply it. This also sets the initial kernel |
| 2154 | mask we need to run with. */ |
nethercote | 9dd1151 | 2004-08-04 15:31:30 +0000 | [diff] [blame] | 2155 | handle_SCSS_change( True /* forced update */ ); |
jsgf | 855d93d | 2003-10-13 22:26:55 +0000 | [diff] [blame] | 2156 | |
sewardj | b5f6f51 | 2005-03-10 23:59:00 +0000 | [diff] [blame] | 2157 | /* Leave with all signals still blocked; the thread scheduler loop |
| 2158 | will set the appropriate mask at the appropriate time. */ |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 2159 | } |
| 2160 | |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 2161 | /*--------------------------------------------------------------------*/ |
njn | ed6b824 | 2005-06-01 00:03:17 +0000 | [diff] [blame] | 2162 | /*--- end ---*/ |
sewardj | de4a1d0 | 2002-03-22 01:27:54 +0000 | [diff] [blame] | 2163 | /*--------------------------------------------------------------------*/ |