lib/libkse/thread/thr_sig.c

   1 /*
   2  * Copyright (c) 1995-1998 John Birrell <jb@cimlogic.com.au>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the author nor the names of any co-contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * $FreeBSD$
  30  */
  31
  32 #include "namespace.h"
  33 #include <sys/param.h>
  34 #include <sys/types.h>
  35 #include <sys/signalvar.h>
  36 #include <signal.h>
  37 #include <errno.h>
  38 #include <fcntl.h>
  39 #include <unistd.h>
  40 #include <string.h>
  41 #include <pthread.h>
  42 #include "un-namespace.h"
  43 #include "thr_private.h"
  44
  45 /* Prototypes: */
  46 static inline void build_siginfo(siginfo_t *info, int signo);
  47 #ifndef SYSTEM_SCOPE_ONLY
  48 static struct pthread *thr_sig_find(struct kse *curkse, int sig,
  49                     siginfo_t *info);
  50 #endif
  51 static inline void thr_sigframe_restore(struct pthread *thread,
  52         struct pthread_sigframe *psf);
  53 static inline void thr_sigframe_save(struct pthread *thread,
  54         struct pthread_sigframe *psf);
  55
  56 #define SA_KILL         0x01            /* terminates process by default */
  57 #define SA_STOP         0x02
  58 #define SA_CONT         0x04
  59
  60 static int sigproptbl[NSIG] = {
  61         SA_KILL,        /* SIGHUP */
  62         SA_KILL,        /* SIGINT */
  63         SA_KILL,        /* SIGQUIT */
  64         SA_KILL,        /* SIGILL */
  65         SA_KILL,        /* SIGTRAP */
  66         SA_KILL,        /* SIGABRT */
  67         SA_KILL,        /* SIGEMT */
  68         SA_KILL,        /* SIGFPE */
  69         SA_KILL,        /* SIGKILL */
  70         SA_KILL,        /* SIGBUS */
  71         SA_KILL,        /* SIGSEGV */
  72         SA_KILL,        /* SIGSYS */
  73         SA_KILL,        /* SIGPIPE */
  74         SA_KILL,        /* SIGALRM */
  75         SA_KILL,        /* SIGTERM */
  76         0,              /* SIGURG */
  77         SA_STOP,        /* SIGSTOP */
  78         SA_STOP,        /* SIGTSTP */
  79         SA_CONT,        /* SIGCONT */
  80         0,              /* SIGCHLD */
  81         SA_STOP,        /* SIGTTIN */
  82         SA_STOP,        /* SIGTTOU */
  83         0,              /* SIGIO */
  84         SA_KILL,        /* SIGXCPU */
  85         SA_KILL,        /* SIGXFSZ */
  86         SA_KILL,        /* SIGVTALRM */
  87         SA_KILL,        /* SIGPROF */
  88         0,              /* SIGWINCH  */
  89         0,              /* SIGINFO */
  90         SA_KILL,        /* SIGUSR1 */
  91         SA_KILL         /* SIGUSR2 */
  92 };
  93
  94 /* #define DEBUG_SIGNAL */
  95 #ifdef DEBUG_SIGNAL
  96 #define DBG_MSG         stdout_debug
  97 #else
  98 #define DBG_MSG(x...)
  99 #endif
 100
 101 /*
 102  * Signal setup and delivery.
 103  *
 104  * 1) Delivering signals to threads in the same KSE.
 105  *    These signals are sent by upcall events and are set in the
 106  *    km_sigscaught field of the KSE mailbox.  Since these signals
 107  *    are received while operating on the KSE stack, they can be
 108  *    delivered either by using signalcontext() to add a stack frame
 109  *    to the target thread's stack, or by adding them in the thread's
 110  *    pending set and having the thread run them down after it
 111  * 2) Delivering signals to threads in other KSEs/KSEGs.
 112  * 3) Delivering signals to threads in critical regions.
 113  * 4) Delivering signals to threads after they change their signal masks.
 114  *
 115  * Methods of delivering signals.
 116  *
 117  *   1) Add a signal frame to the thread's saved context.
 118  *   2) Add the signal to the thread structure, mark the thread as
 119  *      having signals to handle, and let the thread run them down
 120  *      after it resumes from the KSE scheduler.
 121  *
 122  * Problem with 1).  You can't do this to a running thread or a
 123  * thread in a critical region.
 124  *
 125  * Problem with 2).  You can't do this to a thread that doesn't
 126  * yield in some way (explicitly enters the scheduler).  A thread
 127  * blocked in the kernel or a CPU hungry thread will not see the
 128  * signal without entering the scheduler.
 129  *
 130  * The solution is to use both 1) and 2) to deliver signals:
 131  *
 132  *   o Thread in critical region - use 2).  When the thread
 133  *     leaves the critical region it will check to see if it
 134  *     has pending signals and run them down.
 135  *
 136  *   o Thread enters scheduler explicitly - use 2).  The thread
 137  *     can check for pending signals after it returns from the
 138  *     the scheduler.
 139  *
 140  *   o Thread is running and not current thread - use 2).  When the
 141  *     thread hits a condition specified by one of the other bullets,
 142  *     the signal will be delivered.
 143  *
 144  *   o Thread is running and is current thread (e.g., the thread
 145  *     has just changed its signal mask and now sees that it has
 146  *     pending signals) - just run down the pending signals.
 147  *
 148  *   o Thread is swapped out due to quantum expiration - use 1)
 149  *
 150  *   o Thread is blocked in kernel - kse_thr_wakeup() and then
 151  *     use 1)
 152  */
 153
 154 /*
 155  * Rules for selecting threads for signals received:
 156  *
 157  *   1) If the signal is a sychronous signal, it is delivered to
 158  *      the generating (current thread).  If the thread has the
 159  *      signal masked, it is added to the threads pending signal
 160  *      set until the thread unmasks it.
 161  *
 162  *   2) A thread in sigwait() where the signal is in the thread's
 163  *      waitset.
 164  *
 165  *   3) A thread in sigsuspend() where the signal is not in the
 166  *      thread's suspended signal mask.
 167  *
 168  *   4) Any thread (first found/easiest to deliver) that has the
 169  *      signal unmasked.
 170  */
 171
 172 #ifndef SYSTEM_SCOPE_ONLY
 173
 174 static void *
 175 sig_daemon(void *arg __unused)
 176 {
 177         int i;
 178         kse_critical_t crit;
 179         struct timespec ts;
 180         sigset_t set;
 181         struct kse *curkse;
 182         struct pthread *curthread = _get_curthread();
 183
 184         DBG_MSG("signal daemon started(%p)\n", curthread);
 185
 186         curthread->name = strdup("signal thread");
 187         crit = _kse_critical_enter();
 188         curkse = _get_curkse();
 189
 190         /*
 191          * Daemon thread is a bound thread and we must be created with
 192          * all signals masked
 193          */
 194 #if 0
 195         SIGFILLSET(set);
 196         __sys_sigprocmask(SIG_SETMASK, &set, NULL);
 197 #endif
 198         __sys_sigpending(&set);
 199         ts.tv_sec = 0;
 200         ts.tv_nsec = 0;
 201         while (1) {
 202                 KSE_LOCK_ACQUIRE(curkse, &_thread_signal_lock);
 203                 _thr_proc_sigpending = set;
 204                 KSE_LOCK_RELEASE(curkse, &_thread_signal_lock);
 205                 for (i = 1; i <= _SIG_MAXSIG; i++) {
 206                         if (SIGISMEMBER(set, i) != 0)
 207                                 _thr_sig_dispatch(curkse, i,
 208                                     NULL /* no siginfo */);
 209                 }
 210                 ts.tv_sec = 30;
 211                 ts.tv_nsec = 0;
 212                 curkse->k_kcb->kcb_kmbx.km_flags =
 213                     KMF_NOUPCALL | KMF_NOCOMPLETED | KMF_WAITSIGEVENT;
 214                 kse_release(&ts);
 215                 curkse->k_kcb->kcb_kmbx.km_flags = 0;
 216                 set = curkse->k_kcb->kcb_kmbx.km_sigscaught;
 217         }
 218         return (0);
 219 }
 220
 221
 222 /* Utility function to create signal daemon thread */
 223 int
 224 _thr_start_sig_daemon(void)
 225 {
 226         pthread_attr_t attr;
 227         sigset_t sigset, oldset;
 228
 229         SIGFILLSET(sigset);
 230         _pthread_sigmask(SIG_SETMASK, &sigset, &oldset);
 231         _pthread_attr_init(&attr);
 232         _pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
 233         attr->flags |= THR_SIGNAL_THREAD;
 234         /* sigmask will be inherited */
 235         if (_pthread_create(&_thr_sig_daemon, &attr, sig_daemon, NULL))
 236                 PANIC("can not create signal daemon thread!\n");
 237         _pthread_attr_destroy(&attr);
 238         _pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 239         return (0);
 240 }
 241
 242 /*
 243  * This signal handler only delivers asynchronous signals.
 244  * This must be called with upcalls disabled and without
 245  * holding any locks.
 246  */
 247 void
 248 _thr_sig_dispatch(struct kse *curkse, int sig, siginfo_t *info)
 249 {
 250         struct kse_mailbox *kmbx;
 251         struct pthread *thread;
 252
 253         DBG_MSG(">>> _thr_sig_dispatch(%d)\n", sig);
 254
 255         /* Check if the signal requires a dump of thread information: */
 256         if (_thr_dump_enabled() && (sig == SIGINFO)) {
 257                 /* Dump thread information to file: */
 258                 _thread_dump_info();
 259         }
 260
 261         while ((thread = thr_sig_find(curkse, sig, info)) != NULL) {
 262                 /*
 263                  * Setup the target thread to receive the signal:
 264                  */
 265                 DBG_MSG("Got signal %d, selecting thread %p\n", sig, thread);
 266                 KSE_SCHED_LOCK(curkse, thread->kseg);
 267                 if ((thread->state == PS_DEAD) ||
 268                     (thread->state == PS_DEADLOCK) ||
 269                     THR_IS_EXITING(thread) || THR_IS_SUSPENDED(thread)) {
 270                         KSE_SCHED_UNLOCK(curkse, thread->kseg);
 271                         _thr_ref_delete(NULL, thread);
 272                 } else if (SIGISMEMBER(thread->sigmask, sig)) {
 273                         KSE_SCHED_UNLOCK(curkse, thread->kseg);
 274                         _thr_ref_delete(NULL, thread);
 275                 } else {
 276                         kmbx = _thr_sig_add(thread, sig, info);
 277                         KSE_SCHED_UNLOCK(curkse, thread->kseg);
 278                         _thr_ref_delete(NULL, thread);
 279                         if (kmbx != NULL)
 280                                 kse_wakeup(kmbx);
 281                         break;
 282                 }
 283         }
 284         DBG_MSG("<<< _thr_sig_dispatch\n");
 285 }
 286
 287 #endif /* ! SYSTEM_SCOPE_ONLY */
 288
 289 static __inline int
 290 sigprop(int sig)
 291 {
 292
 293         if (sig > 0 && sig < NSIG)
 294                 return (sigproptbl[_SIG_IDX(sig)]);
 295         return (0);
 296 }
 297
 298 typedef void (*ohandler)(int sig, int code,
 299         struct sigcontext *scp, char *addr, __sighandler_t *catcher);
 300
 301 void
 302 _thr_sig_handler(int sig, siginfo_t *info, void *ucp_arg)
 303 {
 304         struct pthread_sigframe psf;
 305         __siginfohandler_t *sigfunc;
 306         struct pthread *curthread;
 307         struct kse *curkse;
 308         ucontext_t *ucp;
 309         struct sigaction act;
 310         int sa_flags, err_save;
 311
 312         err_save = errno;
 313         ucp = (ucontext_t *)ucp_arg;
 314
 315         DBG_MSG(">>> _thr_sig_handler(%d)\n", sig);
 316
 317         curthread = _get_curthread();
 318         if (curthread == NULL)
 319                 PANIC("No current thread.\n");
 320         if (!(curthread->attr.flags & PTHREAD_SCOPE_SYSTEM))
 321                 PANIC("Thread is not system scope.\n");
 322         if (curthread->flags & THR_FLAGS_EXITING) {
 323                 errno = err_save;
 324                 return;
 325         }
 326
 327         curkse = _get_curkse();
 328         /*
 329          * If thread is in critical region or if thread is on
 330          * the way of state transition, then latch signal into buffer.
 331          */
 332         if (_kse_in_critical() || THR_IN_CRITICAL(curthread) ||
 333             curthread->state != PS_RUNNING) {
 334                 DBG_MSG(">>> _thr_sig_handler(%d) in critical\n", sig);
 335                 curthread->siginfo[sig-1] = *info;
 336                 curthread->check_pending = 1;
 337                 curkse->k_sigseqno++;
 338                 SIGADDSET(curthread->sigpend, sig);
 339                 /*
 340                  * If the kse is on the way to idle itself, but
 341                  * we have signal ready, we should prevent it
 342                  * to sleep, kernel will latch the wakeup request,
 343                  * so kse_release will return from kernel immediately.
 344                  */
 345                 if (KSE_IS_IDLE(curkse))
 346                         kse_wakeup(&curkse->k_kcb->kcb_kmbx);
 347                 errno = err_save;
 348                 return;
 349         }
 350
 351         /* Check if the signal requires a dump of thread information: */
 352         if (_thr_dump_enabled() && (sig == SIGINFO)) {
 353                 /* Dump thread information to file: */
 354                 _thread_dump_info();
 355         }
 356
 357         /* Check the threads previous state: */
 358         curthread->critical_count++;
 359         if (curthread->sigbackout != NULL)
 360                 curthread->sigbackout((void *)curthread);
 361         curthread->critical_count--;
 362         thr_sigframe_save(curthread, &psf);
 363         THR_ASSERT(!(curthread->sigbackout), "sigbackout was not cleared.");
 364
 365         _kse_critical_enter();
 366         /* Get a fresh copy of signal mask */
 367         __sys_sigprocmask(SIG_BLOCK, NULL, &curthread->sigmask);
 368         KSE_LOCK_ACQUIRE(curkse, &_thread_signal_lock);
 369         sigfunc = _thread_sigact[sig - 1].sa_sigaction;
 370         sa_flags = _thread_sigact[sig - 1].sa_flags;
 371         if (sa_flags & SA_RESETHAND) {
 372                 act.sa_handler = SIG_DFL;
 373                 act.sa_flags = SA_RESTART;
 374                 SIGEMPTYSET(act.sa_mask);
 375                 __sys_sigaction(sig, &act, NULL);
 376                 __sys_sigaction(sig, NULL, &_thread_sigact[sig - 1]);
 377         }
 378         KSE_LOCK_RELEASE(curkse, &_thread_signal_lock);
 379         _kse_critical_leave(&curthread->tcb->tcb_tmbx);
 380
 381         /* Now invoke real handler */
 382         if (((__sighandler_t *)sigfunc != SIG_DFL) &&
 383             ((__sighandler_t *)sigfunc != SIG_IGN) &&
 384             (sigfunc != (__siginfohandler_t *)_thr_sig_handler)) {
 385                 if ((sa_flags & SA_SIGINFO) != 0 || info == NULL)
 386                         (*(sigfunc))(sig, info, ucp);
 387                 else {
 388                         ((ohandler)(*sigfunc))(
 389                                 sig, info->si_code, (struct sigcontext *)ucp,
 390                                 info->si_addr, (__sighandler_t *)sigfunc);
 391                 }
 392         } else {
 393                 if ((__sighandler_t *)sigfunc == SIG_DFL) {
 394                         if (sigprop(sig) & SA_KILL) {
 395                                 if (_kse_isthreaded())
 396                                         kse_thr_interrupt(NULL,
 397                                                  KSE_INTR_SIGEXIT, sig);
 398                                 else
 399                                         kill(getpid(), sig);
 400                         }
 401 #ifdef NOTYET
 402                         else if (sigprop(sig) & SA_STOP)
 403                                 kse_thr_interrupt(NULL, KSE_INTR_JOBSTOP, sig);
 404 #endif
 405                 }
 406         }
 407         _kse_critical_enter();
 408         curthread->sigmask = ucp->uc_sigmask;
 409         SIG_CANTMASK(curthread->sigmask);
 410         _kse_critical_leave(&curthread->tcb->tcb_tmbx);
 411
 412         thr_sigframe_restore(curthread, &psf);
 413
 414         DBG_MSG("<<< _thr_sig_handler(%d)\n", sig);
 415
 416         errno = err_save;
 417 }
 418
 419 struct sighandle_info {
 420         __siginfohandler_t *sigfunc;
 421         int sa_flags;
 422         int sig;
 423         siginfo_t *info;
 424         ucontext_t *ucp;
 425 };
 426
 427 static void handle_signal(struct pthread *curthread,
 428         struct sighandle_info *shi);
 429 static void handle_signal_altstack(struct pthread *curthread,
 430         struct sighandle_info *shi);
 431
 432 /* Must be called with signal lock and schedule lock held in order */
 433 static void
 434 thr_sig_invoke_handler(struct pthread *curthread, int sig, siginfo_t *info,
 435     ucontext_t *ucp)
 436 {
 437         __siginfohandler_t *sigfunc;
 438         sigset_t sigmask;
 439         int sa_flags;
 440         int onstack;
 441         struct sigaction act;
 442         struct kse *curkse;
 443         struct sighandle_info shi;
 444
 445         /*
 446          * Invoke the signal handler without going through the scheduler:
 447          */
 448         DBG_MSG("Got signal %d, calling handler for current thread %p\n",
 449             sig, curthread);
 450
 451         if (!_kse_in_critical())
 452                 PANIC("thr_sig_invoke_handler without in critical\n");
 453         curkse = curthread->kse;
 454         /*
 455          * Check that a custom handler is installed and if
 456          * the signal is not blocked:
 457          */
 458         sigfunc = _thread_sigact[sig - 1].sa_sigaction;
 459         sa_flags = _thread_sigact[sig - 1].sa_flags;
 460         sigmask = curthread->sigmask;
 461         SIGSETOR(curthread->sigmask, _thread_sigact[sig - 1].sa_mask);
 462         if (!(sa_flags & (SA_NODEFER | SA_RESETHAND)))
 463                 SIGADDSET(curthread->sigmask, sig);
 464         if ((sig != SIGILL) && (sa_flags & SA_RESETHAND)) {
 465                 act.sa_handler = SIG_DFL;
 466                 act.sa_flags = SA_RESTART;
 467                 SIGEMPTYSET(act.sa_mask);
 468                 __sys_sigaction(sig, &act, NULL);
 469                 __sys_sigaction(sig, NULL, &_thread_sigact[sig - 1]);
 470         }
 471         KSE_LOCK_RELEASE(curkse, &_thread_signal_lock);
 472         KSE_SCHED_UNLOCK(curkse, curkse->k_kseg);
 473         /*
 474          * We are processing buffered signals, synchronize working
 475          * signal mask into kernel.
 476          */
 477         if (curthread->attr.flags & PTHREAD_SCOPE_SYSTEM)
 478                 __sys_sigprocmask(SIG_SETMASK, &curthread->sigmask, NULL);
 479         onstack = _thr_sigonstack(&sigfunc);
 480         ucp->uc_stack = curthread->sigstk;
 481         ucp->uc_stack.ss_flags = (curthread->sigstk.ss_flags & SS_DISABLE)
 482                 ? SS_DISABLE : ((onstack) ? SS_ONSTACK : 0);
 483         if (curthread->oldsigmask) {
 484                 ucp->uc_sigmask = *(curthread->oldsigmask);
 485                 curthread->oldsigmask = NULL;
 486         } else
 487                 ucp->uc_sigmask = sigmask;
 488         shi.sigfunc = sigfunc;
 489         shi.sig = sig;
 490         shi.sa_flags = sa_flags;
 491         shi.info = info;
 492         shi.ucp = ucp;
 493         if ((curthread->sigstk.ss_flags & SS_DISABLE) == 0) {
 494                 /* Deliver signal on alternative stack */
 495                 if (sa_flags & SA_ONSTACK && !onstack)
 496                         handle_signal_altstack(curthread, &shi);
 497                 else
 498                         handle_signal(curthread, &shi);
 499         } else {
 500                 handle_signal(curthread, &shi);
 501         }
 502
 503         _kse_critical_enter();
 504         /* Don't trust after critical leave/enter */
 505         curkse = curthread->kse;
 506
 507         /*
 508          * Restore the thread's signal mask.
 509          */
 510         curthread->sigmask = ucp->uc_sigmask;
 511         SIG_CANTMASK(curthread->sigmask);
 512         if (curthread->attr.flags & PTHREAD_SCOPE_SYSTEM)
 513                 __sys_sigprocmask(SIG_SETMASK, &ucp->uc_sigmask, NULL);
 514         KSE_SCHED_LOCK(curkse, curkse->k_kseg);
 515         KSE_LOCK_ACQUIRE(curkse, &_thread_signal_lock);
 516
 517         DBG_MSG("Got signal %d, handler returned %p\n", sig, curthread);
 518 }
 519
 520 static void
 521 handle_signal(struct pthread *curthread, struct sighandle_info *shi)
 522 {
 523         _kse_critical_leave(&curthread->tcb->tcb_tmbx);
 524
 525         /* Check if the signal requires a dump of thread information: */
 526         if (_thr_dump_enabled() && (shi->sig == SIGINFO)) {
 527                 /* Dump thread information to file: */
 528                 _thread_dump_info();
 529         }
 530
 531         if (((__sighandler_t *)shi->sigfunc != SIG_DFL) &&
 532             ((__sighandler_t *)shi->sigfunc != SIG_IGN)) {
 533                 if ((shi->sa_flags & SA_SIGINFO) != 0 || shi->info == NULL)
 534                         (*(shi->sigfunc))(shi->sig, shi->info, shi->ucp);
 535                 else {
 536                         ((ohandler)(*shi->sigfunc))(
 537                                 shi->sig, shi->info->si_code,
 538                                 (struct sigcontext *)shi->ucp,
 539                                 shi->info->si_addr,
 540                                 (__sighandler_t *)shi->sigfunc);
 541                 }
 542         } else {
 543                 if ((__sighandler_t *)shi->sigfunc == SIG_DFL) {
 544                         if (sigprop(shi->sig) & SA_KILL) {
 545                                 if (_kse_isthreaded())
 546                                         kse_thr_interrupt(NULL,
 547                                                  KSE_INTR_SIGEXIT, shi->sig);
 548                                 else
 549                                         kill(getpid(), shi->sig);
 550                         }
 551 #ifdef NOTYET
 552                         else if (sigprop(shi->sig) & SA_STOP)
 553                                 kse_thr_interrupt(NULL, KSE_INTR_JOBSTOP,
 554                                         shi->sig);
 555 #endif
 556                 }
 557         }
 558 }
 559
 560 static void
 561 handle_signal_wrapper(struct pthread *curthread, ucontext_t *ret_uc,
 562         struct sighandle_info *shi)
 563 {
 564         shi->ucp->uc_stack.ss_flags = SS_ONSTACK;
 565         handle_signal(curthread, shi);
 566         if (curthread->attr.flags & PTHREAD_SCOPE_SYSTEM)
 567                 setcontext(ret_uc);
 568         else {
 569                 /* Work around for ia64, THR_SETCONTEXT does not work */
 570                 _kse_critical_enter();
 571                 curthread->tcb->tcb_tmbx.tm_context = *ret_uc;
 572                 _thread_switch(curthread->kse->k_kcb, curthread->tcb, 1);
 573                 /* THR_SETCONTEXT */
 574         }
 575 }
 576
 577 /*
 578  * Jump to stack set by sigaltstack before invoking signal handler
 579  */
 580 static void
 581 handle_signal_altstack(struct pthread *curthread, struct sighandle_info *shi)
 582 {
 583         volatile int once;
 584         ucontext_t uc1, *uc2;
 585
 586         THR_ASSERT(_kse_in_critical(), "Not in critical");
 587
 588         once = 0;
 589         THR_GETCONTEXT(&uc1);
 590         if (once == 0) {
 591                 once = 1;
 592                 /* XXX
 593                  * We are still in critical region, it is safe to operate thread
 594                  * context
 595                  */
 596                 uc2 = &curthread->tcb->tcb_tmbx.tm_context;
 597                 uc2->uc_stack = curthread->sigstk;
 598                 makecontext(uc2, (void (*)(void))handle_signal_wrapper,
 599                         3, curthread, &uc1, shi);
 600                 if (curthread->attr.flags & PTHREAD_SCOPE_SYSTEM)
 601                         setcontext(uc2);
 602                 else {
 603                         _thread_switch(curthread->kse->k_kcb, curthread->tcb, 1);
 604                         /* THR_SETCONTEXT(uc2); */
 605                 }
 606         }
 607 }
 608
 609 int
 610 _thr_getprocsig(int sig, siginfo_t *siginfo)
 611 {
 612         kse_critical_t crit;
 613         struct kse *curkse;
 614         int ret;
 615
 616         DBG_MSG(">>> _thr_getprocsig\n");
 617
 618         crit = _kse_critical_enter();
 619         curkse = _get_curkse();
 620         KSE_LOCK_ACQUIRE(curkse, &_thread_signal_lock);
 621         ret = _thr_getprocsig_unlocked(sig, siginfo);
 622         KSE_LOCK_RELEASE(curkse, &_thread_signal_lock);
 623         _kse_critical_leave(crit);
 624
 625         DBG_MSG("<<< _thr_getprocsig\n");
 626         return (ret);
 627 }
 628
 629 int
 630 _thr_getprocsig_unlocked(int sig, siginfo_t *siginfo)
 631 {
 632         sigset_t sigset;
 633         struct timespec ts;
 634
 635         /* try to retrieve signal from kernel */
 636         SIGEMPTYSET(sigset);
 637         SIGADDSET(sigset, sig);
 638         ts.tv_sec = 0;
 639         ts.tv_nsec = 0;
 640         SIGDELSET(_thr_proc_sigpending, sig);
 641         if (__sys_sigtimedwait(&sigset, siginfo, &ts) > 0)
 642                 return (sig);
 643         return (0);
 644 }
 645
 646 #ifndef SYSTEM_SCOPE_ONLY
 647 /*
 648  * Find a thread that can handle the signal.  This must be called
 649  * with upcalls disabled.
 650  */
 651 struct pthread *
 652 thr_sig_find(struct kse *curkse, int sig, siginfo_t *info __unused)
 653 {
 654         struct kse_mailbox *kmbx = NULL;
 655         struct pthread  *pthread;
 656         struct pthread  *suspended_thread, *signaled_thread;
 657         __siginfohandler_t *sigfunc;
 658         siginfo_t si;
 659
 660         DBG_MSG("Looking for thread to handle signal %d\n", sig);
 661
 662         /*
 663          * Enter a loop to look for threads that have the signal
 664          * unmasked.  POSIX specifies that a thread in a sigwait
 665          * will get the signal over any other threads.  Second
 666          * preference will be threads in a sigsuspend.  Third
 667          * preference will be the current thread.  If none of the
 668          * above, then the signal is delivered to the first thread
 669          * that is found.  Note that if a custom handler is not
 670          * installed, the signal only affects threads in sigwait.
 671          */
 672         suspended_thread = NULL;
 673         signaled_thread = NULL;
 674
 675         KSE_LOCK_ACQUIRE(curkse, &_thread_list_lock);
 676         TAILQ_FOREACH(pthread, &_thread_list, tle) {
 677                 if (pthread == _thr_sig_daemon)
 678                         continue;
 679                 /* Signal delivering to bound thread is done by kernel */
 680                 if (pthread->attr.flags & PTHREAD_SCOPE_SYSTEM)
 681                         continue;
 682                 /* Take the scheduling lock. */
 683                 KSE_SCHED_LOCK(curkse, pthread->kseg);
 684                 if ((pthread->state == PS_DEAD)         ||
 685                     (pthread->state == PS_DEADLOCK)     ||
 686                     THR_IS_EXITING(pthread)             ||
 687                     THR_IS_SUSPENDED(pthread)) {
 688                         ; /* Skip this thread. */
 689                 } else if (pthread->state == PS_SIGWAIT &&
 690                            SIGISMEMBER(*(pthread->data.sigwait->waitset), sig)) {
 691                         /*
 692                          * retrieve signal from kernel, if it is job control
 693                          * signal, and sigaction is SIG_DFL, then we will
 694                          * be stopped in kernel, we hold lock here, but that
 695                          * does not matter, because that's job control, and
 696                          * whole process should be stopped.
 697                          */
 698                         if (_thr_getprocsig(sig, &si)) {
 699                                 DBG_MSG("Waking thread %p in sigwait"
 700                                         " with signal %d\n", pthread, sig);
 701                                 /*  where to put siginfo ? */
 702                                 *(pthread->data.sigwait->siginfo) = si;
 703                                 kmbx = _thr_setrunnable_unlocked(pthread);
 704                         }
 705                         KSE_SCHED_UNLOCK(curkse, pthread->kseg);
 706                         /*
 707                          * POSIX doesn't doesn't specify which thread
 708                          * will get the signal if there are multiple
 709                          * waiters, so we give it to the first thread
 710                          * we find.
 711                          *
 712                          * Do not attempt to deliver this signal
 713                          * to other threads and do not add the signal
 714                          * to the process pending set.
 715                          */
 716                         KSE_LOCK_RELEASE(curkse, &_thread_list_lock);
 717                         if (kmbx != NULL)
 718                                 kse_wakeup(kmbx);
 719                         if (suspended_thread != NULL)
 720                                 _thr_ref_delete(NULL, suspended_thread);
 721                         if (signaled_thread != NULL)
 722                                 _thr_ref_delete(NULL, signaled_thread);
 723                         return (NULL);
 724                 } else if (!SIGISMEMBER(pthread->sigmask, sig)) {
 725                         /*
 726                          * If debugger is running, we don't quick exit,
 727                          * and give it a chance to check the signal.
 728                          */
 729                         if (_libkse_debug == 0) {
 730                                 sigfunc = _thread_sigact[sig - 1].sa_sigaction;
 731                                 if ((__sighandler_t *)sigfunc == SIG_DFL) {
 732                                         if (sigprop(sig) & SA_KILL) {
 733                                                 kse_thr_interrupt(NULL,
 734                                                          KSE_INTR_SIGEXIT, sig);
 735                                                 /* Never reach */
 736                                         }
 737                                 }
 738                         }
 739                         if (pthread->state == PS_SIGSUSPEND) {
 740                                 if (suspended_thread == NULL) {
 741                                         suspended_thread = pthread;
 742                                         suspended_thread->refcount++;
 743                                 }
 744                         } else if (signaled_thread == NULL) {
 745                                 signaled_thread = pthread;
 746                                 signaled_thread->refcount++;
 747                         }
 748                 }
 749                 KSE_SCHED_UNLOCK(curkse, pthread->kseg);
 750         }
 751         KSE_LOCK_RELEASE(curkse, &_thread_list_lock);
 752
 753         if (suspended_thread != NULL) {
 754                 pthread = suspended_thread;
 755                 if (signaled_thread)
 756                         _thr_ref_delete(NULL, signaled_thread);
 757         } else if (signaled_thread) {
 758                 pthread = signaled_thread;
 759         } else {
 760                 pthread = NULL;
 761         }
 762         return (pthread);
 763 }
 764 #endif /* ! SYSTEM_SCOPE_ONLY */
 765
 766 static inline void
 767 build_siginfo(siginfo_t *info, int signo)
 768 {
 769         bzero(info, sizeof(*info));
 770         info->si_signo = signo;
 771         info->si_pid = _thr_pid;
 772 }
 773
 774 /*
 775  * This is called by a thread when it has pending signals to deliver.
 776  * It should only be called from the context of the thread.
 777  */
 778 void
 779 _thr_sig_rundown(struct pthread *curthread, ucontext_t *ucp)
 780 {
 781         struct pthread_sigframe psf;
 782         siginfo_t siginfo;
 783         int i, err_save;
 784         kse_critical_t crit;
 785         struct kse *curkse;
 786         sigset_t sigmask;
 787
 788         err_save = errno;
 789
 790         DBG_MSG(">>> thr_sig_rundown (%p)\n", curthread);
 791
 792         /* Check the threads previous state: */
 793         curthread->critical_count++;
 794         if (curthread->sigbackout != NULL)
 795                 curthread->sigbackout((void *)curthread);
 796         curthread->critical_count--;
 797
 798         THR_ASSERT(!(curthread->sigbackout), "sigbackout was not cleared.");
 799         THR_ASSERT((curthread->state == PS_RUNNING), "state is not PS_RUNNING");
 800
 801         thr_sigframe_save(curthread, &psf);
 802         /*
 803          * Lower the priority before calling the handler in case
 804          * it never returns (longjmps back):
 805          */
 806         crit = _kse_critical_enter();
 807         curkse = curthread->kse;
 808         KSE_SCHED_LOCK(curkse, curkse->k_kseg);
 809         KSE_LOCK_ACQUIRE(curkse, &_thread_signal_lock);
 810         curthread->active_priority &= ~THR_SIGNAL_PRIORITY;
 811         SIGFILLSET(sigmask);
 812         while (1) {
 813                 /*
 814                  * For bound thread, we mask all signals and get a fresh
 815                  * copy of signal mask from kernel
 816                  */
 817                 if (curthread->attr.flags & PTHREAD_SCOPE_SYSTEM) {
 818                         __sys_sigprocmask(SIG_SETMASK, &sigmask,
 819                                  &curthread->sigmask);
 820                 }
 821                 for (i = 1; i <= _SIG_MAXSIG; i++) {
 822                         if (SIGISMEMBER(curthread->sigmask, i))
 823                                 continue;
 824                         if (SIGISMEMBER(curthread->sigpend, i)) {
 825                                 SIGDELSET(curthread->sigpend, i);
 826                                 siginfo = curthread->siginfo[i-1];
 827                                 break;
 828                         }
 829                         if (!(curthread->attr.flags & PTHREAD_SCOPE_SYSTEM)
 830                             && SIGISMEMBER(_thr_proc_sigpending, i)) {
 831                                 if (_thr_getprocsig_unlocked(i, &siginfo))
 832                                         break;
 833                         }
 834                 }
 835                 if (i <= _SIG_MAXSIG)
 836                         thr_sig_invoke_handler(curthread, i, &siginfo, ucp);
 837                 else {
 838                         if (curthread->attr.flags & PTHREAD_SCOPE_SYSTEM) {
 839                                 __sys_sigprocmask(SIG_SETMASK,
 840                                                  &curthread->sigmask, NULL);
 841                         }
 842                         break;
 843                 }
 844         }
 845
 846         /* Don't trust after signal handling */
 847         curkse = curthread->kse;
 848         KSE_LOCK_RELEASE(curkse, &_thread_signal_lock);
 849         KSE_SCHED_UNLOCK(curkse, curkse->k_kseg);
 850         _kse_critical_leave(&curthread->tcb->tcb_tmbx);
 851         /* repost masked signal to kernel, it hardly happens in real world */
 852         if ((curthread->attr.flags & PTHREAD_SCOPE_SYSTEM) &&
 853             !SIGISEMPTY(curthread->sigpend)) { /* dirty read */
 854                 __sys_sigprocmask(SIG_SETMASK, &sigmask, &curthread->sigmask);
 855                 for (i = 1; i <= _SIG_MAXSIG; ++i) {
 856                         if (SIGISMEMBER(curthread->sigpend, i)) {
 857                                 SIGDELSET(curthread->sigpend, i);
 858                                 if (!_kse_isthreaded())
 859                                         kill(getpid(), i);
 860                                 else
 861                                         kse_thr_interrupt(
 862                                                 &curthread->tcb->tcb_tmbx,
 863                                                 KSE_INTR_SENDSIG,
 864                                                 i);
 865                         }
 866                 }
 867                 __sys_sigprocmask(SIG_SETMASK, &curthread->sigmask, NULL);
 868         }
 869         DBG_MSG("<<< thr_sig_rundown (%p)\n", curthread);
 870
 871         thr_sigframe_restore(curthread, &psf);
 872         errno = err_save;
 873 }
 874
 875 /*
 876  * This checks pending signals for the current thread.  It should be
 877  * called whenever a thread changes its signal mask.  Note that this
 878  * is called from a thread (using its stack).
 879  *
 880  * XXX - We might want to just check to see if there are pending
 881  *       signals for the thread here, but enter the UTS scheduler
 882  *       to actually install the signal handler(s).
 883  */
 884 void
 885 _thr_sig_check_pending(struct pthread *curthread)
 886 {
 887         ucontext_t uc;
 888         volatile int once;
 889         int errsave;
 890
 891         /*
 892          * If the thread is in critical region, delay processing signals.
 893          * If the thread state is not PS_RUNNING, it might be switching
 894          * into UTS and but a THR_LOCK_RELEASE saw check_pending, and it
 895          * goes here, in the case we delay processing signals, lets UTS
 896          * process complicated things, normally UTS will call _thr_sig_add
 897          * to resume the thread, so we needn't repeat doing it here.
 898          */
 899         if (THR_IN_CRITICAL(curthread) || curthread->state != PS_RUNNING)
 900                 return;
 901
 902         errsave = errno;
 903         once = 0;
 904         THR_GETCONTEXT(&uc);
 905         if (once == 0) {
 906                 once = 1;
 907                 curthread->check_pending = 0;
 908                 _thr_sig_rundown(curthread, &uc);
 909         }
 910         errno = errsave;
 911 }
 912
 913 /*
 914  * Perform thread specific actions in response to a signal.
 915  * This function is only called if there is a handler installed
 916  * for the signal, and if the target thread has the signal
 917  * unmasked.
 918  *
 919  * This must be called with the thread's scheduling lock held.
 920  */
 921 struct kse_mailbox *
 922 _thr_sig_add(struct pthread *pthread, int sig, siginfo_t *info)
 923 {
 924         siginfo_t siginfo;
 925         struct kse *curkse;
 926         struct kse_mailbox *kmbx = NULL;
 927         struct pthread *curthread = _get_curthread();
 928         int     restart;
 929         int     suppress_handler = 0;
 930         int     fromproc = 0;
 931         __sighandler_t *sigfunc;
 932
 933         DBG_MSG(">>> _thr_sig_add %p (%d)\n", pthread, sig);
 934
 935         curkse = _get_curkse();
 936         restart = _thread_sigact[sig - 1].sa_flags & SA_RESTART;
 937         sigfunc = _thread_sigact[sig - 1].sa_handler;
 938         fromproc = (curthread == _thr_sig_daemon);
 939
 940         if (pthread->state == PS_DEAD || pthread->state == PS_DEADLOCK ||
 941             pthread->state == PS_STATE_MAX)
 942                 return (NULL); /* return false */
 943
 944         if ((pthread->attr.flags & PTHREAD_SCOPE_SYSTEM) &&
 945             (curthread != pthread)) {
 946                 PANIC("Please use _thr_send_sig for bound thread");
 947                 return (NULL);
 948         }
 949
 950         if (pthread->state != PS_SIGWAIT &&
 951             SIGISMEMBER(pthread->sigmask, sig)) {
 952                 /* signal is masked, just add signal to thread. */
 953                 if (!fromproc) {
 954                         SIGADDSET(pthread->sigpend, sig);
 955                         if (info == NULL)
 956                                 build_siginfo(&pthread->siginfo[sig-1], sig);
 957                         else if (info != &pthread->siginfo[sig-1])
 958                                 memcpy(&pthread->siginfo[sig-1], info,
 959                                          sizeof(*info));
 960                 } else {
 961                         if (!_thr_getprocsig(sig, &pthread->siginfo[sig-1]))
 962                                 return (NULL);
 963                         SIGADDSET(pthread->sigpend, sig);
 964                 }
 965         }
 966         else {
 967                 /* if process signal not exists, just return */
 968                 if (fromproc) {
 969                         if (!_thr_getprocsig(sig, &siginfo))
 970                                 return (NULL);
 971                         info = &siginfo;
 972                 }
 973
 974                 if (pthread->state != PS_SIGWAIT && sigfunc == SIG_DFL &&
 975                     (sigprop(sig) & SA_KILL)) {
 976                         kse_thr_interrupt(NULL, KSE_INTR_SIGEXIT, sig);
 977                         /* Never reach */
 978                 }
 979
 980                 /*
 981                  * Process according to thread state:
 982                  */
 983                 switch (pthread->state) {
 984                 case PS_DEAD:
 985                 case PS_DEADLOCK:
 986                 case PS_STATE_MAX:
 987                         return (NULL);  /* XXX return false */
 988                 case PS_LOCKWAIT:
 989                 case PS_SUSPENDED:
 990                         /*
 991                          * You can't call a signal handler for threads in these
 992                          * states.
 993                          */
 994                         suppress_handler = 1;
 995                         break;
 996                 case PS_RUNNING:
 997                         if ((pthread->flags & THR_FLAGS_IN_RUNQ)) {
 998                                 THR_RUNQ_REMOVE(pthread);
 999                                 pthread->active_priority |= THR_SIGNAL_PRIORITY;
1000                                 THR_RUNQ_INSERT_TAIL(pthread);
1001                         } else {
1002                                 /* Possible not in RUNQ and has curframe ? */
1003                                 pthread->active_priority |= THR_SIGNAL_PRIORITY;
1004                         }
1005                         break;
1006                 /*
1007                  * States which cannot be interrupted but still require the
1008                  * signal handler to run:
1009                  */
1010                 case PS_COND_WAIT:
1011                 case PS_MUTEX_WAIT:
1012                         break;
1013
1014                 case PS_SLEEP_WAIT:
1015                         /*
1016                          * Unmasked signals always cause sleep to terminate
1017                          * early regardless of SA_RESTART:
1018                          */
1019                         pthread->interrupted = 1;
1020                         break;
1021
1022                 case PS_JOIN:
1023                         break;
1024
1025                 case PS_SIGSUSPEND:
1026                         pthread->interrupted = 1;
1027                         break;
1028
1029                 case PS_SIGWAIT:
1030                         if (info == NULL)
1031                                 build_siginfo(&pthread->siginfo[sig-1], sig);
1032                         else if (info != &pthread->siginfo[sig-1])
1033                                 memcpy(&pthread->siginfo[sig-1], info,
1034                                         sizeof(*info));
1035                         /*
1036                          * The signal handler is not called for threads in
1037                          * SIGWAIT.
1038                          */
1039                         suppress_handler = 1;
1040                         /* Wake up the thread if the signal is not blocked. */
1041                         if (SIGISMEMBER(*(pthread->data.sigwait->waitset), sig)) {
1042                                 /* Return the signal number: */
1043                                 *(pthread->data.sigwait->siginfo) = pthread->siginfo[sig-1];
1044                                 /* Make the thread runnable: */
1045                                 kmbx = _thr_setrunnable_unlocked(pthread);
1046                         } else {
1047                                 /* Increment the pending signal count. */
1048                                 SIGADDSET(pthread->sigpend, sig);
1049                                 if (!SIGISMEMBER(pthread->sigmask, sig)) {
1050                                         if (sigfunc == SIG_DFL &&
1051                                             sigprop(sig) & SA_KILL) {
1052                                                 kse_thr_interrupt(NULL,
1053                                                          KSE_INTR_SIGEXIT,
1054                                                          sig);
1055                                                 /* Never reach */
1056                                         }
1057                                         pthread->check_pending = 1;
1058                                         pthread->interrupted = 1;
1059                                         kmbx = _thr_setrunnable_unlocked(pthread);
1060                                 }
1061                         }
1062                         return (kmbx);
1063                 }
1064
1065                 SIGADDSET(pthread->sigpend, sig);
1066                 if (info == NULL)
1067                         build_siginfo(&pthread->siginfo[sig-1], sig);
1068                 else if (info != &pthread->siginfo[sig-1])
1069                         memcpy(&pthread->siginfo[sig-1], info, sizeof(*info));
1070                 pthread->check_pending = 1;
1071                 if (!(pthread->attr.flags & PTHREAD_SCOPE_SYSTEM) &&
1072                     (pthread->blocked != 0) && !THR_IN_CRITICAL(pthread))
1073                         kse_thr_interrupt(&pthread->tcb->tcb_tmbx,
1074                             restart ? KSE_INTR_RESTART : KSE_INTR_INTERRUPT, 0);
1075                 if (suppress_handler == 0) {
1076                         /*
1077                          * Setup a signal frame and save the current threads
1078                          * state:
1079                          */
1080                         if (pthread->state != PS_RUNNING) {
1081                                 if (pthread->flags & THR_FLAGS_IN_RUNQ)
1082                                         THR_RUNQ_REMOVE(pthread);
1083                                 pthread->active_priority |= THR_SIGNAL_PRIORITY;
1084                                 kmbx = _thr_setrunnable_unlocked(pthread);
1085                         }
1086                 }
1087         }
1088         return (kmbx);
1089 }
1090
1091 /*
1092  * Send a signal to a specific thread (ala pthread_kill):
1093  */
1094 void
1095 _thr_sig_send(struct pthread *pthread, int sig)
1096 {
1097         struct pthread *curthread = _get_curthread();
1098         struct kse_mailbox *kmbx;
1099
1100         if (pthread->attr.flags & PTHREAD_SCOPE_SYSTEM) {
1101                 kse_thr_interrupt(&pthread->tcb->tcb_tmbx, KSE_INTR_SENDSIG, sig);
1102                 return;
1103         }
1104
1105         /* Lock the scheduling queue of the target thread. */
1106         THR_SCHED_LOCK(curthread, pthread);
1107         if (_thread_sigact[sig - 1].sa_handler != SIG_IGN) {
1108                 kmbx = _thr_sig_add(pthread, sig, NULL);
1109                 /* Add a preemption point. */
1110                 if (kmbx == NULL && (curthread->kseg == pthread->kseg) &&
1111                     (pthread->active_priority > curthread->active_priority))
1112                         curthread->critical_yield = 1;
1113                 THR_SCHED_UNLOCK(curthread, pthread);
1114                 if (kmbx != NULL)
1115                         kse_wakeup(kmbx);
1116                 /* XXX
1117                  * If thread sent signal to itself, check signals now.
1118                  * It is not really needed, _kse_critical_leave should
1119                  * have already checked signals.
1120                  */
1121                 if (pthread == curthread && curthread->check_pending)
1122                         _thr_sig_check_pending(curthread);
1123
1124         } else  {
1125                 THR_SCHED_UNLOCK(curthread, pthread);
1126         }
1127 }
1128
1129 static inline void
1130 thr_sigframe_restore(struct pthread *curthread, struct pthread_sigframe *psf)
1131 {
1132         kse_critical_t crit;
1133         struct kse *curkse;
1134
1135         THR_THREAD_LOCK(curthread, curthread);
1136         curthread->cancelflags = psf->psf_cancelflags;
1137         crit = _kse_critical_enter();
1138         curkse = curthread->kse;
1139         KSE_SCHED_LOCK(curkse, curthread->kseg);
1140         curthread->flags = psf->psf_flags;
1141         curthread->interrupted = psf->psf_interrupted;
1142         curthread->timeout = psf->psf_timeout;
1143         curthread->data = psf->psf_wait_data;
1144         curthread->wakeup_time = psf->psf_wakeup_time;
1145         curthread->continuation = psf->psf_continuation;
1146         KSE_SCHED_UNLOCK(curkse, curthread->kseg);
1147         _kse_critical_leave(crit);
1148         THR_THREAD_UNLOCK(curthread, curthread);
1149 }
1150
1151 static inline void
1152 thr_sigframe_save(struct pthread *curthread, struct pthread_sigframe *psf)
1153 {
1154         kse_critical_t crit;
1155         struct kse *curkse;
1156
1157         THR_THREAD_LOCK(curthread, curthread);
1158         psf->psf_cancelflags = curthread->cancelflags;
1159         crit = _kse_critical_enter();
1160         curkse = curthread->kse;
1161         KSE_SCHED_LOCK(curkse, curthread->kseg);
1162         /* This has to initialize all members of the sigframe. */
1163         psf->psf_flags = (curthread->flags & (THR_FLAGS_PRIVATE | THR_FLAGS_EXITING));
1164         psf->psf_interrupted = curthread->interrupted;
1165         psf->psf_timeout = curthread->timeout;
1166         psf->psf_wait_data = curthread->data;
1167         psf->psf_wakeup_time = curthread->wakeup_time;
1168         psf->psf_continuation = curthread->continuation;
1169         KSE_SCHED_UNLOCK(curkse, curthread->kseg);
1170         _kse_critical_leave(crit);
1171         THR_THREAD_UNLOCK(curthread, curthread);
1172 }
1173
1174 void
1175 _thr_signal_init(void)
1176 {
1177         struct sigaction act;
1178         __siginfohandler_t *sigfunc;
1179         int i;
1180         sigset_t sigset;
1181
1182         SIGFILLSET(sigset);
1183         __sys_sigprocmask(SIG_SETMASK, &sigset, &_thr_initial->sigmask);
1184         /* Enter a loop to get the existing signal status: */
1185         for (i = 1; i <= _SIG_MAXSIG; i++) {
1186                 /* Get the signal handler details: */
1187                 if (__sys_sigaction(i, NULL, &_thread_sigact[i - 1]) != 0) {
1188                         /*
1189                          * Abort this process if signal
1190                          * initialisation fails:
1191                          */
1192                         PANIC("Cannot read signal handler info");
1193                 }
1194                 /* Intall wrapper if handler was set */
1195                 sigfunc = _thread_sigact[i - 1].sa_sigaction;
1196                 if (((__sighandler_t *)sigfunc) != SIG_DFL &&
1197                     ((__sighandler_t *)sigfunc) != SIG_IGN) {
1198                         act = _thread_sigact[i - 1];
1199                         act.sa_flags |= SA_SIGINFO;
1200                         act.sa_sigaction =
1201                                 (__siginfohandler_t *)_thr_sig_handler;
1202                         __sys_sigaction(i, &act, NULL);
1203                 }
1204         }
1205         if (_thr_dump_enabled()) {
1206                 /*
1207                  * Install the signal handler for SIGINFO.  It isn't
1208                  * really needed, but it is nice to have for debugging
1209                  * purposes.
1210                  */
1211                 _thread_sigact[SIGINFO - 1].sa_flags = SA_SIGINFO | SA_RESTART;
1212                 SIGEMPTYSET(act.sa_mask);
1213                 act.sa_flags = SA_SIGINFO | SA_RESTART;
1214                 act.sa_sigaction = (__siginfohandler_t *)&_thr_sig_handler;
1215                 if (__sys_sigaction(SIGINFO, &act, NULL) != 0) {
1216                         __sys_sigprocmask(SIG_SETMASK, &_thr_initial->sigmask,
1217                             NULL);
1218                         /*
1219                          * Abort this process if signal initialisation fails:
1220                          */
1221                         PANIC("Cannot initialize signal handler");
1222                 }
1223         }
1224         __sys_sigprocmask(SIG_SETMASK, &_thr_initial->sigmask, NULL);
1225         __sys_sigaltstack(NULL, &_thr_initial->sigstk);
1226 }
1227
1228 void
1229 _thr_signal_deinit(void)
1230 {
1231         int i;
1232         struct pthread *curthread = _get_curthread();
1233
1234         /* Clear process pending signals. */
1235         sigemptyset(&_thr_proc_sigpending);
1236
1237         /* Enter a loop to get the existing signal status: */
1238         for (i = 1; i <= _SIG_MAXSIG; i++) {
1239                 /* Check for signals which cannot be trapped: */
1240                 if (i == SIGKILL || i == SIGSTOP) {
1241                 }
1242
1243                 /* Set the signal handler details: */
1244                 else if (__sys_sigaction(i, &_thread_sigact[i - 1],
1245                          NULL) != 0) {
1246                         /*
1247                          * Abort this process if signal
1248                          * initialisation fails:
1249                          */
1250                         PANIC("Cannot set signal handler info");
1251                 }
1252         }
1253         __sys_sigaltstack(&curthread->sigstk, NULL);
1254 }
1255