1 2 /*--------------------------------------------------------------------*/ 3 /*--- Signal-related libc stuff. m_libcsignal.c ---*/ 4 /*--------------------------------------------------------------------*/ 5 6 /* 7 This file is part of Valgrind, a dynamic binary instrumentation 8 framework. 9 10 Copyright (C) 2000-2011 Julian Seward 11 jseward (at) acm.org 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 28 The GNU General Public License is contained in the file COPYING. 29 */ 30 31 #include "pub_core_basics.h" 32 #include "pub_core_debuglog.h" 33 #include "pub_core_vki.h" 34 #include "pub_core_vkiscnums.h" 35 #include "pub_core_libcbase.h" 36 #include "pub_core_libcassert.h" 37 #include "pub_core_syscall.h" 38 #include "pub_core_libcsignal.h" /* self */ 39 40 /* IMPORTANT: on Darwin it is essential to use the _nocancel versions 41 of syscalls rather than the vanilla version, if a _nocancel version 42 is available. See docs/internals/Darwin-notes.txt for the reason 43 why. */ 44 45 /* sigemptyset, sigfullset, sigaddset and sigdelset return 0 on 46 success and -1 on error. */ 47 /* In the sigset routines below, be aware that _VKI_NSIG_BPW can be 48 either 32 or 64, and hence the sig[] words can either be 32- or 49 64-bits. And which they are it doesn't necessarily follow from the 50 host word size. */ 51 52 Int VG_(sigfillset)( vki_sigset_t* set ) 53 { 54 Int i; 55 if (set == NULL) 56 return -1; 57 for (i = 0; i < _VKI_NSIG_WORDS; i++) 58 set->sig[i] = ~0; 59 return 0; 60 } 61 62 Int VG_(sigemptyset)( vki_sigset_t* set ) 63 { 64 Int i; 65 if (set == NULL) 66 return -1; 67 for (i = 0; i < _VKI_NSIG_WORDS; i++) 68 set->sig[i] = 0; 69 return 0; 70 } 71 72 Bool VG_(isemptysigset)( const vki_sigset_t* set ) 73 { 74 Int i; 75 vg_assert(set != NULL); 76 for (i = 0; i < _VKI_NSIG_WORDS; i++) 77 if (set->sig[i] != 0) return False; 78 return True; 79 } 80 81 Bool VG_(isfullsigset)( const vki_sigset_t* set ) 82 { 83 Int i; 84 vg_assert(set != NULL); 85 for (i = 0; i < _VKI_NSIG_WORDS; i++) 86 if (set->sig[i] != ~0) return False; 87 return True; 88 } 89 90 Bool VG_(iseqsigset)( const vki_sigset_t* set1, const vki_sigset_t* set2 ) 91 { 92 Int i; 93 vg_assert(set1 != NULL && set2 != NULL); 94 for (i = 0; i < _VKI_NSIG_WORDS; i++) 95 if (set1->sig[i] != set2->sig[i]) return False; 96 return True; 97 } 98 99 100 Int VG_(sigaddset)( vki_sigset_t* set, Int signum ) 101 { 102 if (set == NULL) 103 return -1; 104 if (signum < 1 || signum > _VKI_NSIG) 105 return -1; 106 signum--; 107 set->sig[signum / _VKI_NSIG_BPW] |= (1ULL << (signum % _VKI_NSIG_BPW)); 108 return 0; 109 } 110 111 Int VG_(sigdelset)( vki_sigset_t* set, Int signum ) 112 { 113 if (set == NULL) 114 return -1; 115 if (signum < 1 || signum > _VKI_NSIG) 116 return -1; 117 signum--; 118 set->sig[signum / _VKI_NSIG_BPW] &= ~(1ULL << (signum % _VKI_NSIG_BPW)); 119 return 0; 120 } 121 122 Int VG_(sigismember) ( const vki_sigset_t* set, Int signum ) 123 { 124 if (set == NULL) 125 return 0; 126 if (signum < 1 || signum > _VKI_NSIG) 127 return 0; 128 signum--; 129 if (1 & ((set->sig[signum / _VKI_NSIG_BPW]) >> (signum % _VKI_NSIG_BPW))) 130 return 1; 131 else 132 return 0; 133 } 134 135 /* Add all signals in src to dst. */ 136 void VG_(sigaddset_from_set)( vki_sigset_t* dst, vki_sigset_t* src ) 137 { 138 Int i; 139 vg_assert(dst != NULL && src != NULL); 140 for (i = 0; i < _VKI_NSIG_WORDS; i++) 141 dst->sig[i] |= src->sig[i]; 142 } 143 144 /* Remove all signals in src from dst. */ 145 void VG_(sigdelset_from_set)( vki_sigset_t* dst, vki_sigset_t* src ) 146 { 147 Int i; 148 vg_assert(dst != NULL && src != NULL); 149 for (i = 0; i < _VKI_NSIG_WORDS; i++) 150 dst->sig[i] &= ~(src->sig[i]); 151 } 152 153 /* dst = dst `intersect` src. */ 154 void VG_(sigintersectset)( vki_sigset_t* dst, vki_sigset_t* src ) 155 { 156 Int i; 157 vg_assert(dst != NULL && src != NULL); 158 for (i = 0; i < _VKI_NSIG_WORDS; i++) 159 dst->sig[i] &= src->sig[i]; 160 } 161 162 /* dst = ~src */ 163 void VG_(sigcomplementset)( vki_sigset_t* dst, vki_sigset_t* src ) 164 { 165 Int i; 166 vg_assert(dst != NULL && src != NULL); 167 for (i = 0; i < _VKI_NSIG_WORDS; i++) 168 dst->sig[i] = ~ src->sig[i]; 169 } 170 171 172 /* The functions sigaction, sigprocmask, sigpending and sigsuspend 173 return 0 on success and -1 on error. 174 */ 175 Int VG_(sigprocmask)( Int how, const vki_sigset_t* set, vki_sigset_t* oldset) 176 { 177 # if defined(VGO_linux) 178 # if defined(__NR_rt_sigprocmask) 179 SysRes res = VG_(do_syscall4)(__NR_rt_sigprocmask, 180 how, (UWord)set, (UWord)oldset, 181 _VKI_NSIG_WORDS * sizeof(UWord)); 182 # else 183 SysRes res = VG_(do_syscall3)(__NR_sigprocmask, 184 how, (UWord)set, (UWord)oldset); 185 # endif 186 187 # elif defined(VGO_darwin) 188 /* On Darwin, __NR_sigprocmask appears to affect the entire 189 process, not just this thread. Hence need to use 190 __NR___pthread_sigmask instead. */ 191 SysRes res = VG_(do_syscall3)(__NR___pthread_sigmask, 192 how, (UWord)set, (UWord)oldset); 193 # else 194 # error "Unknown OS" 195 # endif 196 return sr_isError(res) ? -1 : 0; 197 } 198 199 200 #if defined(VGO_darwin) 201 /* A helper function for sigaction on Darwin. */ 202 static 203 void darwin_signal_demux(void* a1, UWord a2, UWord a3, void* a4, void* a5) { 204 VG_(debugLog)(2, "libcsignal", 205 "PRE demux sig, a2 = %lu, signo = %lu\n", a2, a3); 206 if (a2 == 1) 207 ((void(*)(int))a1) (a3); 208 else 209 ((void(*)(int,void*,void*))a1) (a3,a4,a5); 210 VG_(debugLog)(2, "libcsignal", 211 "POST demux sig, a2 = %lu, signo = %lu\n", a2, a3); 212 VG_(do_syscall2)(__NR_sigreturn, (UWord)a5, 0x1E); 213 /* NOTREACHED */ 214 __asm__ __volatile__("ud2"); 215 } 216 #endif 217 218 Int VG_(sigaction) ( Int signum, 219 const vki_sigaction_toK_t* act, 220 vki_sigaction_fromK_t* oldact) 221 { 222 # if defined(VGO_linux) 223 /* Normal case: vki_sigaction_toK_t and vki_sigaction_fromK_t are 224 identical types. */ 225 SysRes res = VG_(do_syscall4)(__NR_rt_sigaction, 226 signum, (UWord)act, (UWord)oldact, 227 _VKI_NSIG_WORDS * sizeof(UWord)); 228 return sr_isError(res) ? -1 : 0; 229 230 # elif defined(VGO_darwin) 231 /* If we're passing a new action to the kernel, make a copy of the 232 new action, install our own sa_tramp field in it, and ignore 233 whatever we were provided with. This is OK because all the 234 sigaction requests come from m_signals, and are not directly 235 what the client program requested, so there is no chance that we 236 will inadvertantly ignore the sa_tramp field requested by the 237 client. (In fact m_signals does ignore it when building signal 238 frames for the client, but that's a completely different 239 matter). 240 241 If we're receiving an old action from the kernel, be very 242 paranoid and make sure the kernel doesn't trash bits of memory 243 that we don't expect it to. */ 244 SysRes res; 245 246 vki_sigaction_toK_t actCopy; 247 struct { 248 ULong before[2]; 249 vki_sigaction_fromK_t oa; 250 ULong after[2]; 251 } 252 oldactCopy; 253 254 vki_sigaction_toK_t* real_act; 255 vki_sigaction_fromK_t* real_oldact; 256 257 real_act = act ? &actCopy : NULL; 258 real_oldact = oldact ? &oldactCopy.oa : NULL; 259 VG_(memset)(&oldactCopy, 0x55, sizeof(oldactCopy)); 260 if (real_act) { 261 *real_act = *act; 262 real_act->sa_tramp = (void*)&darwin_signal_demux; 263 } 264 res = VG_(do_syscall3)(__NR_sigaction, 265 signum, (UWord)real_act, (UWord)real_oldact); 266 if (real_oldact) { 267 vg_assert(oldactCopy.before[0] == 0x5555555555555555ULL); 268 vg_assert(oldactCopy.before[1] == 0x5555555555555555ULL); 269 vg_assert(oldactCopy.after[0] == 0x5555555555555555ULL); 270 vg_assert(oldactCopy.after[1] == 0x5555555555555555ULL); 271 *oldact = *real_oldact; 272 } 273 return sr_isError(res) ? -1 : 0; 274 275 # else 276 # error "Unsupported OS" 277 # endif 278 } 279 280 281 /* See explanation in pub_core_libcsignal.h. */ 282 void 283 VG_(convert_sigaction_fromK_to_toK)( vki_sigaction_fromK_t* fromK, 284 /*OUT*/vki_sigaction_toK_t* toK ) 285 { 286 # if defined(VGO_linux) 287 *toK = *fromK; 288 # elif defined(VGO_darwin) 289 toK->ksa_handler = fromK->ksa_handler; 290 toK->sa_tramp = NULL; /* the cause of all the difficulty */ 291 toK->sa_mask = fromK->sa_mask; 292 toK->sa_flags = fromK->sa_flags; 293 # else 294 # error "Unsupported OS" 295 # endif 296 } 297 298 299 Int VG_(kill)( Int pid, Int signo ) 300 { 301 # if defined(VGO_linux) 302 SysRes res = VG_(do_syscall2)(__NR_kill, pid, signo); 303 # elif defined(VGO_darwin) 304 SysRes res = VG_(do_syscall3)(__NR_kill, 305 pid, signo, 1/*posix-compliant*/); 306 # else 307 # error "Unsupported OS" 308 # endif 309 return sr_isError(res) ? -1 : 0; 310 } 311 312 Int VG_(tkill)( Int lwpid, Int signo ) 313 { 314 # if defined(__NR_tkill) 315 SysRes res = VG_(mk_SysRes_Error)(VKI_ENOSYS); 316 res = VG_(do_syscall2)(__NR_tkill, lwpid, signo); 317 if (sr_isError(res) && sr_Err(res) == VKI_ENOSYS) 318 res = VG_(do_syscall2)(__NR_kill, lwpid, signo); 319 return sr_isError(res) ? -1 : 0; 320 321 # elif defined(VGO_darwin) 322 // Note that the __pthread_kill syscall takes a Mach thread, not a pthread. 323 SysRes res; 324 res = VG_(do_syscall2)(__NR___pthread_kill, lwpid, signo); 325 return sr_isError(res) ? -1 : 0; 326 327 # else 328 # error "Unsupported plat" 329 # endif 330 } 331 332 /* ---------------------- sigtimedwait_zero ----------------------- */ 333 334 /* A cut-down version of POSIX sigtimedwait: poll for pending signals 335 mentioned in the sigset_t, and if any are present, select one 336 arbitrarily, return its number (which must be > 0), and put 337 auxiliary info about it in the siginfo_t, and make it 338 not-pending-any-more. If none are pending, return zero. The _zero 339 refers to the fact that there is zero timeout, so if no signals are 340 pending it returns immediately. Perhaps a better name would be 341 'sigpoll'. Returns -1 on error, 0 if no signals pending, and n > 0 342 if signal n was selected. 343 344 The Linux implementation is trivial: do the corresponding syscall. 345 346 The Darwin implementation is horrible and probably broken in a dozen 347 obscure ways. I suspect it's only thread-safe because V forces 348 single-threadedness. */ 349 350 /* ---------- sigtimedwait_zero: Linux ----------- */ 351 352 #if defined(VGO_linux) 353 Int VG_(sigtimedwait_zero)( const vki_sigset_t *set, 354 vki_siginfo_t *info ) 355 { 356 static const struct vki_timespec zero = { 0, 0 }; 357 SysRes res = VG_(do_syscall4)(__NR_rt_sigtimedwait, (UWord)set, (UWord)info, 358 (UWord)&zero, sizeof(*set)); 359 return sr_isError(res) ? -1 : sr_Res(res); 360 } 361 362 /* ---------- sigtimedwait_zero: Darwin ----------- */ 363 364 #elif defined(VGO_darwin) 365 366 //static void show_set ( HChar* str, const vki_sigset_t* set ) { 367 // Int i; 368 // VG_(printf)("%s { ", str); 369 // for (i = 1; i <= _VKI_NSIG; i++) { 370 // if (VG_(sigismember)(set, i)) 371 // VG_(printf)("%u ", i); 372 // } 373 // VG_(printf)("}\n"); 374 //} 375 376 /* The general idea is: 377 - use sigpending to find out which signals are pending 378 - choose one 379 - temporarily set its handler to sigtimedwait_zero_handler 380 - use sigsuspend atomically unblock it and wait for the signal. 381 Upon return, sigsuspend restores the signal mask to what it 382 was to start with. 383 - Restore the handler for the signal to whatever it was before. 384 */ 385 386 /* A signal handler which does nothing (it doesn't need to). It does 387 however check that it's not handing a sync signal for which 388 returning is meaningless. */ 389 static void sigtimedwait_zero_handler ( Int sig ) 390 { 391 /* XXX this is wrong -- get rid of these. We could 392 get _any_ signal here */ 393 vg_assert(sig != VKI_SIGILL); 394 vg_assert(sig != VKI_SIGSEGV); 395 vg_assert(sig != VKI_SIGBUS); 396 vg_assert(sig != VKI_SIGTRAP); 397 /* do nothing */ 398 } 399 400 Int VG_(sigtimedwait_zero)( const vki_sigset_t *set, 401 vki_siginfo_t *info ) 402 { 403 const Bool debug = False; 404 Int i, ir; 405 SysRes sr; 406 vki_sigset_t pending, blocked, allbutone; 407 vki_sigaction_toK_t sa, saved_sa2; 408 vki_sigaction_fromK_t saved_sa; 409 410 //show_set("STWZ: looking for", set); 411 412 /* Find out what's pending: Darwin sigpending */ 413 sr = VG_(do_syscall1)(__NR_sigpending, (UWord)&pending); 414 vg_assert(!sr_isError(sr)); 415 416 /* don't try for signals not in 'set' */ 417 /* pending = pending `intersect` set */ 418 VG_(sigintersectset)(&pending, (vki_sigset_t*)set); 419 420 /* don't try for signals not blocked at the moment */ 421 ir = VG_(sigprocmask)(VKI_SIG_SETMASK, NULL, &blocked); 422 vg_assert(ir == 0); 423 424 /* pending = pending `intersect` blocked */ 425 VG_(sigintersectset)(&pending, &blocked); 426 427 /* decide which signal we're going to snarf */ 428 for (i = 1; i < _VKI_NSIG; i++) 429 if (VG_(sigismember)(&pending,i)) 430 break; 431 432 if (i == _VKI_NSIG) 433 return 0; 434 435 if (debug) 436 VG_(debugLog)(0, "libcsignal", 437 "sigtimedwait_zero: snarfing signal %d\n", i ); 438 439 /* fetch signal i. 440 pre: i is blocked and pending 441 pre: we are the only thread running 442 */ 443 /* Set up alternative signal handler */ 444 VG_(sigfillset)(&sa.sa_mask); 445 sa.ksa_handler = &sigtimedwait_zero_handler; 446 sa.sa_flags = 0; 447 ir = VG_(sigaction)(i, &sa, &saved_sa); 448 vg_assert(ir == 0); 449 450 /* Switch signal masks and wait for the signal. This should happen 451 immediately, since we've already established it is pending and 452 blocked. */ 453 VG_(sigfillset)(&allbutone); 454 VG_(sigdelset)(&allbutone, i); 455 /* Note: pass the sig mask by value here, not reference (!) */ 456 vg_assert(_VKI_NSIG_WORDS == 1); 457 sr = VG_(do_syscall3)(__NR_sigsuspend_nocancel, 458 (UWord)allbutone.sig[0], 0,0); 459 if (debug) 460 VG_(debugLog)(0, "libcsignal", 461 "sigtimedwait_zero: sigsuspend got " 462 "res: %s %#lx\n", 463 sr_isError(sr) ? "FAIL" : "SUCCESS", 464 sr_isError(sr) ? sr_Err(sr) : sr_Res(sr)); 465 vg_assert(sr_isError(sr)); 466 vg_assert(sr_Err(sr) == VKI_EINTR); 467 468 /* Restore signal's handler to whatever it was before */ 469 VG_(convert_sigaction_fromK_to_toK)( &saved_sa, &saved_sa2 ); 470 ir = VG_(sigaction)(i, &saved_sa2, NULL); 471 vg_assert(ir == 0); 472 473 /* This is bogus - we could get more info from the sighandler. */ 474 VG_(memset)( info, 0, sizeof(*info) ); 475 info->si_signo = i; 476 477 return i; 478 } 479 480 #else 481 # error "Unknown OS" 482 #endif 483 484 /*--------------------------------------------------------------------*/ 485 /*--- end ---*/ 486 /*--------------------------------------------------------------------*/ 487
