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