hurd/hurdsig.c

   1 /* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
   2 This file is part of the GNU C Library.
   3
   4 The GNU C Library is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU Library General Public License as
   6 published by the Free Software Foundation; either version 2 of the
   7 License, or (at your option) any later version.
   8
   9 The GNU C Library is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 Library General Public License for more details.
  13
  14 You should have received a copy of the GNU Library General Public
  15 License along with the GNU C Library; see the file COPYING.LIB.  If
  16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  17 Cambridge, MA 02139, USA.  */
  18
  19 #include <stdlib.h>
  20 #include <stdio.h>
  21 #include <hurd.h>
  22 #include <hurd/signal.h>
  23 #include <cthreads.h>           /* For `struct mutex'.  */
  24 #include <string.h>
  25 #include "hurdfault.h"
  26 #include "hurdmalloc.h"         /* XXX */
  27
  28 const char *_hurdsig_getenv (const char *);
  29
  30 struct mutex _hurd_siglock;
  31 int _hurd_stopped;
  32
  33 /* Port that receives signals and other miscellaneous messages.  */
  34 mach_port_t _hurd_msgport;
  35
  36 /* Thread listening on it.  */
  37 thread_t _hurd_msgport_thread;
  38
  39 /* Thread which receives task-global signals.  */
  40 thread_t _hurd_sigthread;
  41
  42 /* Linked-list of per-thread signal state.  */
  43 struct hurd_sigstate *_hurd_sigstates;
  44
  45 /* Timeout for RPC's after interrupt_operation. */
  46 mach_msg_timeout_t _hurd_interrupted_rpc_timeout = 3000;
  47 \f
  48 static void
  49 default_sigaction (struct sigaction actions[NSIG])
  50 {
  51   int signo;
  52
  53   __sigemptyset (&actions[0].sa_mask);
  54   actions[0].sa_flags = SA_RESTART;
  55   actions[0].sa_handler = SIG_DFL;
  56
  57   for (signo = 1; signo < NSIG; ++signo)
  58     actions[signo] = actions[0];
  59 }
  60
  61 struct hurd_sigstate *
  62 _hurd_thread_sigstate (thread_t thread)
  63 {
  64   struct hurd_sigstate *ss;
  65   __mutex_lock (&_hurd_siglock);
  66   for (ss = _hurd_sigstates; ss != NULL; ss = ss->next)
  67     if (ss->thread == thread)
  68        break;
  69   if (ss == NULL)
  70     {
  71       ss = malloc (sizeof (*ss));
  72       if (ss == NULL)
  73         __libc_fatal ("hurd: Can't allocate thread sigstate\n");
  74       ss->thread = thread;
  75       __spin_lock_init (&ss->lock);
  76
  77       /* Initialze default state.  */
  78       __sigemptyset (&ss->blocked);
  79       __sigemptyset (&ss->pending);
  80       memset (&ss->sigaltstack, 0, sizeof (ss->sigaltstack));
  81       ss->suspended = 0;
  82       ss->intr_port = MACH_PORT_NULL;
  83       ss->context = NULL;
  84
  85       /* Initialize the sigaction vector from the default signal receiving
  86          thread's state, and its from the system defaults.  */
  87       if (thread == _hurd_sigthread)
  88         default_sigaction (ss->actions);
  89       else
  90         {
  91           struct hurd_sigstate *s;
  92           for (s = _hurd_sigstates; s != NULL; s = s->next)
  93             if (s->thread == _hurd_sigthread)
  94               break;
  95           if (s)
  96             {
  97               __spin_lock (&s->lock);
  98               memcpy (ss->actions, s->actions, sizeof (s->actions));
  99               __spin_unlock (&s->lock);
 100             }
 101           else
 102             default_sigaction (ss->actions);
 103         }
 104
 105       ss->next = _hurd_sigstates;
 106       _hurd_sigstates = ss;
 107     }
 108   __mutex_unlock (&_hurd_siglock);
 109   return ss;
 110 }
 111 \f
 112 /* Signal delivery itself is on this page.  */
 113
 114 #include <hurd/fd.h>
 115 #include <hurd/crash.h>
 116 #include <hurd/paths.h>
 117 #include <setjmp.h>
 118 #include <fcntl.h>
 119 #include <sys/wait.h>
 120 #include "thread_state.h"
 121 #include <hurd/msg_server.h>
 122 #include <hurd/msg_reply.h>     /* For __msg_sig_post_reply.  */
 123 #include <assert.h>
 124 #include <hurd/interrupt.h>
 125
 126 int _hurd_core_limit;   /* XXX */
 127
 128 /* Call the crash dump server to mummify us before we die.
 129    Returns nonzero if a core file was written.  */
 130 static int
 131 write_corefile (int signo, long int sigcode, int sigerror)
 132 {
 133   error_t err;
 134   mach_port_t coreserver;
 135   file_t file, coredir;
 136   const char *name;
 137
 138   /* XXX RLIMIT_CORE:
 139      When we have a protocol to make the server return an error
 140      for RLIMIT_FSIZE, then tell the corefile fs server the RLIMIT_CORE
 141      value in place of the RLIMIT_FSIZE value.  */
 142
 143   /* First get a port to the core dumping server.  */
 144   coreserver = MACH_PORT_NULL;
 145   name = _hurdsig_getenv ("CRASHSERVER");
 146   if (name != NULL)
 147     coreserver = __file_name_lookup (name, 0, 0);
 148   if (coreserver == MACH_PORT_NULL)
 149     coreserver = __file_name_lookup (_SERVERS_CRASH, 0, 0);
 150   if (coreserver == MACH_PORT_NULL)
 151     return 0;
 152
 153   /* Get a port to the directory where the new core file will reside.  */
 154   name = _hurdsig_getenv ("COREFILE");
 155   if (name == NULL)
 156     name = "core";
 157   coredir = __file_name_split (name, (char **) &name);
 158   if (coredir == MACH_PORT_NULL)
 159     return 0;
 160   /* Create the new file, but don't link it into the directory yet.  */
 161   if (err = __dir_mkfile (coredir, O_WRONLY|O_CREAT,
 162                           0600 & ~_hurd_umask, /* XXX ? */
 163                           &file))
 164     return 0;
 165
 166   /* Call the core dumping server to write the core file.  */
 167   err = __crash_dump_task (coreserver,
 168                            __mach_task_self (),
 169                            file, _hurdsig_getenv ("GNUTARGET"),
 170                            signo, sigcode, sigerror);
 171   __mach_port_deallocate (__mach_task_self (), coreserver);
 172   if (! err)
 173     /* The core dump into FILE succeeded, so now link it into the
 174        directory.  */
 175     err = __dir_link (file, coredir, name);
 176   __mach_port_deallocate (__mach_task_self (), file);
 177   __mach_port_deallocate (__mach_task_self (), coredir);
 178   return !err;
 179 }
 180
 181
 182 /* The lowest-numbered thread state flavor value is 1,
 183    so we use bit 0 in machine_thread_all_state.set to
 184    record whether we have done thread_abort.  */
 185 #define THREAD_ABORTED 1
 186
 187 /* SS->thread is suspended.  Abort the thread and get its basic state.  */
 188 static void
 189 abort_thread (struct hurd_sigstate *ss, struct machine_thread_all_state *state,
 190               void (*reply) (void))
 191 {
 192   if (!(state->set & THREAD_ABORTED))
 193     {
 194       error_t err = __thread_abort (ss->thread);
 195       assert_perror (err);
 196       /* Clear all thread state flavor set bits, because thread_abort may
 197          have changed the state.  */
 198       state->set = THREAD_ABORTED;
 199     }
 200
 201   if (reply)
 202     (*reply) ();
 203
 204   machine_get_basic_state (ss->thread, state);
 205 }
 206
 207 /* Find the location of the MiG reply port cell in use by the thread whose
 208    state is described by THREAD_STATE.  If SIGTHREAD is nonzero, make sure
 209    that this location can be set without faulting, or else return NULL.  */
 210
 211 static mach_port_t *
 212 interrupted_reply_port_location (struct machine_thread_all_state *thread_state,
 213                                  int sigthread)
 214 {
 215   mach_port_t *portloc = (mach_port_t *) __hurd_threadvar_location_from_sp
 216     (_HURD_THREADVAR_MIG_REPLY, (void *) thread_state->basic.SP);
 217
 218   if (sigthread && _hurdsig_catch_fault (SIGSEGV))
 219     {
 220       assert (_hurdsig_fault_sigcode == (long int) portloc);
 221       /* Faulted trying to read the stack.  */
 222       return NULL;
 223     }
 224
 225   /* Fault now if this pointer is bogus.  */
 226   *(volatile mach_port_t *) portloc = *portloc;
 227
 228   if (sigthread)
 229     _hurdsig_end_catch_fault ();
 230
 231   return portloc;
 232 }
 233 \f
 234 #include "intr-msg.h"
 235
 236 /* SS->thread is suspended.
 237
 238    Abort any interruptible RPC operation the thread is doing.
 239
 240    This uses only the constant member SS->thread and the unlocked, atomically
 241    set member SS->intr_port, so no locking is needed.
 242
 243    If successfully sent an interrupt_operation and therefore the thread should
 244    wait for its pending RPC to return (possibly EINTR) before taking the
 245    incoming signal, returns the reply port to be received on.  Otherwise
 246    returns MACH_PORT_NULL.
 247
 248    SIGNO is used to find the applicable SA_RESTART bit.  If SIGNO is zero,
 249    the RPC fails with EINTR instead of restarting (thread_cancel).
 250
 251    *STATE_CHANGE is set nonzero if STATE->basic was modified and should
 252    be applied back to the thread if it might ever run again, else zero.  */
 253
 254 mach_port_t
 255 _hurdsig_abort_rpcs (struct hurd_sigstate *ss, int signo, int sigthread,
 256                      struct machine_thread_all_state *state, int *state_change,
 257                      void (*reply) (void))
 258 {
 259   extern const void _hurd_intr_rpc_msg_in_trap;
 260   mach_port_t rcv_port = MACH_PORT_NULL;
 261   mach_port_t intr_port;
 262
 263   *state_change = 0;
 264
 265   intr_port = ss->intr_port;
 266   if (intr_port == MACH_PORT_NULL)
 267     /* No interruption needs done.  */
 268     return MACH_PORT_NULL;
 269
 270   /* Abort the thread's kernel context, so any pending message send or
 271      receive completes immediately or aborts.  */
 272   abort_thread (ss, state, reply);
 273
 274   if (state->basic.PC < (natural_t) &_hurd_intr_rpc_msg_in_trap)
 275     {
 276       /* The thread is about to do the RPC, but hasn't yet entered
 277          mach_msg.  Mutate the thread's state so it knows not to try
 278          the RPC.  */
 279       INTR_MSG_BACK_OUT (&state->basic);
 280       MACHINE_THREAD_STATE_SET_PC (&state->basic,
 281                                    &_hurd_intr_rpc_msg_in_trap);
 282       state->basic.SYSRETURN = MACH_SEND_INTERRUPTED;
 283       *state_change = 1;
 284     }
 285   else if (state->basic.PC == (natural_t) &_hurd_intr_rpc_msg_in_trap &&
 286            /* The thread was blocked in the system call.  After thread_abort,
 287               the return value register indicates what state the RPC was in
 288               when interrupted.  */
 289            state->basic.SYSRETURN == MACH_RCV_INTERRUPTED)
 290       {
 291         /* The RPC request message was sent and the thread was waiting for
 292            the reply message; now the message receive has been aborted, so
 293            the mach_msg call will return MACH_RCV_INTERRUPTED.  We must tell
 294            the server to interrupt the pending operation.  The thread must
 295            wait for the reply message before running the signal handler (to
 296            guarantee that the operation has finished being interrupted), so
 297            our nonzero return tells the trampoline code to finish the message
 298            receive operation before running the handler.  */
 299
 300         mach_port_t *reply = interrupted_reply_port_location (state,
 301                                                               sigthread);
 302         error_t err = __interrupt_operation (intr_port);
 303
 304         if (err)
 305           {
 306             if (reply)
 307               {
 308                 /* The interrupt didn't work.
 309                    Destroy the receive right the thread is blocked on.  */
 310                 __mach_port_destroy (__mach_task_self (), *reply);
 311                 *reply = MACH_PORT_NULL;
 312               }
 313
 314             /* The system call return value register now contains
 315                MACH_RCV_INTERRUPTED; when mach_msg resumes, it will retry the
 316                call.  Since we have just destroyed the receive right, the
 317                retry will fail with MACH_RCV_INVALID_NAME.  Instead, just
 318                change the return value here to EINTR so mach_msg will not
 319                retry and the EINTR error code will propagate up.  */
 320             state->basic.SYSRETURN = EINTR;
 321             *state_change = 1;
 322           }
 323         else if (reply)
 324           rcv_port = *reply;
 325
 326         /* All threads whose RPCs were interrupted by the interrupt_operation
 327            call above will retry their RPCs unless we clear SS->intr_port.
 328            So we clear it for the thread taking a signal when SA_RESTART is
 329            clear, so that its call returns EINTR.  */
 330         if (! signo || !(ss->actions[signo].sa_flags & SA_RESTART))
 331           ss->intr_port = MACH_PORT_NULL;
 332       }
 333
 334   return rcv_port;
 335 }
 336
 337
 338 /* Abort the RPCs being run by all threads but this one;
 339    all other threads should be suspended.  If LIVE is nonzero, those
 340    threads may run again, so they should be adjusted as necessary to be
 341    happy when resumed.  STATE is clobbered as a scratch area; its initial
 342    contents are ignored, and its contents on return are not useful.  */
 343
 344 static void
 345 abort_all_rpcs (int signo, struct machine_thread_all_state *state, int live)
 346 {
 347   /* We can just loop over the sigstates.  Any thread doing something
 348      interruptible must have one.  We needn't bother locking because all
 349      other threads are stopped.  */
 350
 351   struct hurd_sigstate *ss;
 352   size_t nthreads;
 353   mach_port_t *reply_ports;
 354
 355   /* First loop over the sigstates to count them.
 356      We need to know how big a vector we will need for REPLY_PORTS.  */
 357   nthreads = 0;
 358   for (ss = _hurd_sigstates; ss != NULL; ss = ss->next)
 359     ++nthreads;
 360
 361   reply_ports = alloca (nthreads * sizeof *reply_ports);
 362
 363   nthreads = 0;
 364   for (ss = _hurd_sigstates; ss != NULL; ss = ss->next)
 365     if (ss->thread == _hurd_msgport_thread)
 366       reply_ports[nthreads++] = MACH_PORT_NULL;
 367     else
 368       {
 369         int state_changed;
 370         state->set = 0;         /* Reset scratch area.  */
 371
 372         /* Abort any operation in progress with interrupt_operation.
 373            Record the reply port the thread is waiting on.
 374            We will wait for all the replies below.  */
 375         reply_ports[nthreads++] = _hurdsig_abort_rpcs (ss, signo, 1,
 376                                                        state, &state_changed,
 377                                                        NULL);
 378         if (state_changed && live)
 379           /* Aborting the RPC needed to change this thread's state,
 380              and it might ever run again.  So write back its state.  */
 381           __thread_set_state (ss->thread, MACHINE_THREAD_STATE_FLAVOR,
 382                               (natural_t *) &state->basic,
 383                               MACHINE_THREAD_STATE_COUNT);
 384       }
 385
 386   /* Wait for replies from all the successfully interrupted RPCs.  */
 387   while (nthreads-- > 0)
 388     if (reply_ports[nthreads] != MACH_PORT_NULL)
 389       {
 390         error_t err;
 391         mach_msg_header_t head;
 392         err = __mach_msg (&head, MACH_RCV_MSG|MACH_RCV_TIMEOUT, 0, sizeof head,
 393                           reply_ports[nthreads],
 394                           _hurd_interrupted_rpc_timeout, MACH_PORT_NULL);
 395         switch (err)
 396           {
 397           case MACH_RCV_TIMED_OUT:
 398           case MACH_RCV_TOO_LARGE:
 399             break;
 400
 401           default:
 402             assert_perror (err);
 403           }
 404       }
 405 }
 406
 407
 408 struct hurd_signal_preempt *_hurd_signal_preempt[NSIG];
 409 struct mutex _hurd_signal_preempt_lock;
 410
 411 /* Mask of stop signals.  */
 412 #define STOPSIGS (sigmask (SIGTTIN) | sigmask (SIGTTOU) | \
 413                   sigmask (SIGSTOP) | sigmask (SIGTSTP))
 414
 415 /* Deliver a signal.  SS is not locked.  */
 416 void
 417 _hurd_internal_post_signal (struct hurd_sigstate *ss,
 418                             int signo, long int sigcode, int sigerror,
 419                             mach_port_t reply_port,
 420                             mach_msg_type_name_t reply_port_type,
 421                             int untraced)
 422 {
 423   error_t err;
 424   struct machine_thread_all_state thread_state;
 425   enum { stop, ignore, core, term, handle } act;
 426   sighandler_t handler;
 427   struct hurd_signal_preempt *pe;
 428   sighandler_t (*preempt) (thread_t, int, long int, int) = NULL;
 429   sigset_t pending;
 430   int ss_suspended;
 431
 432   /* Reply to this sig_post message.  */
 433   __typeof (__msg_sig_post_reply) *reply_rpc
 434     = (untraced ? __msg_sig_post_untraced_reply : __msg_sig_post_reply);
 435   void reply (void)
 436     {
 437       error_t err;
 438       if (reply_port == MACH_PORT_NULL)
 439         return;
 440       err = (*reply_rpc) (reply_port, reply_port_type, 0);
 441       reply_port = MACH_PORT_NULL;
 442       if (err != MACH_SEND_INVALID_DEST) /* Ignore dead reply port.  */
 443         assert_perror (err);
 444     }
 445
 446   /* Mark the signal as pending.  */
 447   void mark_pending (void)
 448     {
 449       __sigaddset (&ss->pending, signo);
 450       /* Save the code to be given to the handler when SIGNO is
 451          unblocked.  */
 452       ss->pending_data[signo].code = sigcode;
 453       ss->pending_data[signo].error = sigerror;
 454     }
 455
 456   /* Suspend the process with SIGNO.  */
 457   void suspend (void)
 458     {
 459       /* Stop all other threads and mark ourselves stopped.  */
 460       __USEPORT (PROC,
 461                  ({
 462                    /* Hold the siglock while stopping other threads to be
 463                       sure it is not held by another thread afterwards.  */
 464                    __mutex_lock (&_hurd_siglock);
 465                    __proc_dostop (port, _hurd_msgport_thread);
 466                    __mutex_unlock (&_hurd_siglock);
 467                    abort_all_rpcs (signo, &thread_state, 1);
 468                    __proc_mark_stop (port, signo);
 469                  }));
 470       _hurd_stopped = 1;
 471     }
 472   /* Resume the process after a suspension.  */
 473   void resume (void)
 474     {
 475       /* Resume the process from being stopped.  */
 476       thread_t *threads;
 477       mach_msg_type_number_t nthreads, i;
 478       error_t err;
 479
 480       if (! _hurd_stopped)
 481         return;
 482
 483       /* Tell the proc server we are continuing.  */
 484       __USEPORT (PROC, __proc_mark_cont (port));
 485       /* Fetch ports to all our threads and resume them.  */
 486       err = __task_threads (__mach_task_self (), &threads, &nthreads);
 487       assert_perror (err);
 488       for (i = 0; i < nthreads; ++i)
 489         {
 490           if (threads[i] != _hurd_msgport_thread &&
 491               (act != handle || threads[i] != ss->thread))
 492             {
 493               err = __thread_resume (threads[i]);
 494               assert_perror (err);
 495             }
 496           err = __mach_port_deallocate (__mach_task_self (),
 497                                         threads[i]);
 498           assert_perror (err);
 499         }
 500       __vm_deallocate (__mach_task_self (),
 501                        (vm_address_t) threads,
 502                        nthreads * sizeof *threads);
 503       _hurd_stopped = 0;
 504       /* The thread that will run the handler is already suspended.  */
 505       ss_suspended = 1;
 506     }
 507
 508   if (signo == 0)
 509     {
 510       if (untraced)
 511         /* This is PTRACE_CONTINUE.  */
 512         resume ();
 513
 514       /* This call is just to check for pending signals.  */
 515       __spin_lock (&ss->lock);
 516       goto check_pending_signals;
 517     }
 518
 519  post_signal:
 520
 521   thread_state.set = 0;         /* We know nothing.  */
 522
 523   /* Check for a preempted signal.  Preempted signals
 524      can arrive during critical sections.  */
 525   __mutex_lock (&_hurd_signal_preempt_lock);
 526   for (pe = _hurd_signal_preempt[signo]; pe != NULL; pe = pe->next)
 527     if (pe->handler && sigcode >= pe->first && sigcode <= pe->last)
 528       {
 529         preempt = pe->handler;
 530         break;
 531       }
 532   __mutex_unlock (&_hurd_signal_preempt_lock);
 533
 534   handler = SIG_DFL;
 535   if (preempt)
 536     /* Let the preempting handler examine the thread.
 537        If it returns SIG_DFL, we run the normal handler;
 538        otherwise we use the handler it returns.  */
 539     handler = (*preempt) (ss->thread, signo, sigcode, sigerror);
 540
 541   ss_suspended = 0;
 542
 543   if (handler != SIG_DFL)
 544     /* Run the preemption-provided handler.  */
 545     act = handle;
 546   else
 547     {
 548       /* No preemption.  Do normal handling.  */
 549
 550       __spin_lock (&ss->lock);
 551
 552       if (!untraced && (_hurd_exec_flags & EXEC_TRACED))
 553         {
 554           /* We are being traced.  Stop to tell the debugger of the signal.  */
 555           if (_hurd_stopped)
 556             /* Already stopped.  Mark the signal as pending;
 557                when resumed, we will notice it and stop again.  */
 558             mark_pending ();
 559           else
 560             suspend ();
 561           __spin_unlock (&ss->lock);
 562           reply ();
 563           return;
 564         }
 565
 566       handler = ss->actions[signo].sa_handler;
 567
 568       if (handler == SIG_DFL)
 569         /* Figure out the default action for this signal.  */
 570         switch (signo)
 571           {
 572           case 0:
 573             /* A sig_post msg with SIGNO==0 is sent to
 574                tell us to check for pending signals.  */
 575             act = ignore;
 576             break;
 577
 578           case SIGTTIN:
 579           case SIGTTOU:
 580           case SIGSTOP:
 581           case SIGTSTP:
 582             act = stop;
 583             break;
 584
 585           case SIGCONT:
 586           case SIGIO:
 587           case SIGURG:
 588           case SIGCHLD:
 589           case SIGWINCH:
 590             act = ignore;
 591             break;
 592
 593           case SIGQUIT:
 594           case SIGILL:
 595           case SIGTRAP:
 596           case SIGIOT:
 597           case SIGEMT:
 598           case SIGFPE:
 599           case SIGBUS:
 600           case SIGSEGV:
 601           case SIGSYS:
 602             act = core;
 603             break;
 604
 605           case SIGINFO:
 606             if (_hurd_pgrp == _hurd_pid)
 607               {
 608                 /* We are the process group leader.  Since there is no
 609                    user-specified handler for SIGINFO, we use a default one
 610                    which prints something interesting.  We use the normal
 611                    handler mechanism instead of just doing it here to avoid
 612                    the signal thread faulting or blocking in this
 613                    potentially hairy operation.  */
 614                 act = handle;
 615                 handler = _hurd_siginfo_handler;
 616               }
 617             else
 618               act = ignore;
 619             break;
 620
 621           default:
 622             act = term;
 623             break;
 624           }
 625       else if (handler == SIG_IGN)
 626         act = ignore;
 627       else
 628         act = handle;
 629
 630       if (__sigmask (signo) & STOPSIGS)
 631         /* Stop signals clear a pending SIGCONT even if they
 632            are handled or ignored (but not if preempted).  */
 633         ss->pending &= ~sigmask (SIGCONT);
 634       else
 635         {
 636           if (signo == SIGCONT)
 637             /* Even if handled or ignored (but not preempted), SIGCONT clears
 638                stop signals and resumes the process.  */
 639             ss->pending &= ~STOPSIGS;
 640
 641           if (_hurd_stopped && act != stop && (untraced || signo == SIGCONT))
 642             resume ();
 643         }
 644     }
 645
 646   if (_hurd_orphaned && act == stop &&
 647       (__sigmask (signo) & (__sigmask (SIGTTIN) | __sigmask (SIGTTOU) |
 648                             __sigmask (SIGTSTP))))
 649     {
 650       /* If we would ordinarily stop for a job control signal, but we are
 651          orphaned so noone would ever notice and continue us again, we just
 652          quietly die, alone and in the dark.  */
 653       sigcode = signo;
 654       signo = SIGKILL;
 655       act = term;
 656     }
 657
 658   /* Handle receipt of a blocked signal, or any signal while stopped.  */
 659   if (__sigismember (&ss->blocked, signo) ||
 660       (signo != SIGKILL && _hurd_stopped))
 661     {
 662       mark_pending ();
 663       act = ignore;
 664     }
 665
 666   /* Perform the chosen action for the signal.  */
 667   switch (act)
 668     {
 669     case stop:
 670       if (_hurd_stopped)
 671         {
 672           /* We are already stopped, but receiving an untraced stop
 673              signal.  Instead of resuming and suspending again, just
 674              notify the proc server of the new stop signal.  */
 675           error_t err = __USEPORT (PROC, __proc_mark_stop (port, signo));
 676           assert_perror (err);
 677         }
 678       else
 679         /* Suspend the process.  */
 680         suspend ();
 681       break;
 682
 683     case ignore:
 684       /* Nobody cares about this signal.  */
 685       break;
 686
 687     sigbomb:
 688       /* We got a fault setting up the stack frame for the handler.
 689          Nothing to do but die; BSD gets SIGILL in this case.  */
 690       sigcode = signo;  /* XXX ? */
 691       signo = SIGILL;
 692       act = core;
 693       /* FALLTHROUGH */
 694
 695     case term:                  /* Time to die.  */
 696     case core:                  /* And leave a rotting corpse.  */
 697       /* Have the proc server stop all other threads in our task.  */
 698       err = __USEPORT (PROC, __proc_dostop (port, _hurd_msgport_thread));
 699       assert_perror (err);
 700       /* No more user instructions will be executed.
 701          The signal can now be considered delivered.  */
 702       reply ();
 703       /* Abort all server operations now in progress.  */
 704       abort_all_rpcs (signo, &thread_state, 0);
 705
 706       {
 707         int status = W_EXITCODE (0, signo);
 708         /* Do a core dump if desired.  Only set the wait status bit saying we
 709            in fact dumped core if the operation was actually successful.  */
 710         if (act == core && write_corefile (signo, sigcode, sigerror))
 711           status |= WCOREFLAG;
 712         /* Tell proc how we died and then stick the saber in the gut.  */
 713         _hurd_exit (status);
 714         /* NOTREACHED */
 715       }
 716
 717     case handle:
 718       /* Call a handler for this signal.  */
 719       {
 720         struct sigcontext *scp, ocontext;
 721         int wait_for_reply, state_changed;
 722
 723         /* Stop the thread and abort its pending RPC operations.  */
 724         if (! ss_suspended)
 725           {
 726             err = __thread_suspend (ss->thread);
 727             assert_perror (err);
 728           }
 729
 730         /* Abort the thread's kernel context, so any pending message send
 731            or receive completes immediately or aborts.  If an interruptible
 732            RPC is in progress, abort_rpcs will do this.  But we must always
 733            do it before fetching the thread's state, because
 734            thread_get_state is never kosher before thread_abort.  */
 735         abort_thread (ss, &thread_state, NULL);
 736
 737         if (ss->context)
 738           {
 739             /* We have a previous sigcontext that sigreturn was about
 740                to restore when another signal arrived.  */
 741
 742             mach_port_t *loc;
 743
 744             if (_hurdsig_catch_fault (SIGSEGV))
 745               {
 746                 assert (_hurdsig_fault_sigcode >= (long int) ss->context &&
 747                         _hurdsig_fault_sigcode < (long int) (ss->context + 1));
 748                 /* We faulted reading the thread's stack.  Forget that
 749                    context and pretend it wasn't there.  It almost
 750                    certainly crash if this handler returns, but that's it's
 751                    problem.  */
 752                 ss->context = NULL;
 753               }
 754             else
 755               {
 756                 /* Copy the context from the thread's stack before
 757                    we start diddling the stack to set up the handler.  */
 758                 ocontext = *ss->context;
 759                 ss->context = &ocontext;
 760               }
 761             _hurdsig_end_catch_fault ();
 762
 763             if (! machine_get_basic_state (ss->thread, &thread_state))
 764               goto sigbomb;
 765             loc = interrupted_reply_port_location (&thread_state, 1);
 766             if (loc && *loc != MACH_PORT_NULL)
 767               /* This is the reply port for the context which called
 768                  sigreturn.  Since we are abandoning that context entirely
 769                  and restoring SS->context instead, destroy this port.  */
 770               __mach_port_destroy (__mach_task_self (), *loc);
 771
 772             /* The thread was in sigreturn, not in any interruptible RPC.  */
 773             wait_for_reply = 0;
 774
 775             assert (! ss->critical_section);
 776           }
 777         else
 778           {
 779             wait_for_reply
 780               = (_hurdsig_abort_rpcs (ss, signo, 1,
 781                                       &thread_state, &state_changed,
 782                                       &reply)
 783                  != MACH_PORT_NULL);
 784
 785             if (ss->critical_section)
 786               {
 787                 /* The thread is in a critical section.  Mark the signal as
 788                    pending.  When it finishes the critical section, it will
 789                    check for pending signals.  */
 790                 mark_pending ();
 791                 assert (! state_changed);
 792                 __thread_resume (ss->thread);
 793                 break;
 794               }
 795           }
 796
 797         /* Call the machine-dependent function to set the thread up
 798            to run the signal handler, and preserve its old context.  */
 799         scp = _hurd_setup_sighandler (ss, handler,
 800                                       signo, sigcode,
 801                                       wait_for_reply, &thread_state);
 802         if (scp == NULL)
 803           goto sigbomb;
 804
 805         /* Set the machine-independent parts of the signal context.  */
 806
 807         {
 808           /* Fetch the thread variable for the MiG reply port,
 809              and set it to MACH_PORT_NULL.  */
 810           mach_port_t *loc = interrupted_reply_port_location (&thread_state,
 811                                                               1);
 812           if (loc)
 813             {
 814               scp->sc_reply_port = *loc;
 815               *loc = MACH_PORT_NULL;
 816             }
 817           else
 818             scp->sc_reply_port = MACH_PORT_NULL;
 819
 820           /* Save the intr_port in use by the interrupted code,
 821              and clear the cell before running the trampoline.  */
 822           scp->sc_intr_port = ss->intr_port;
 823           ss->intr_port = MACH_PORT_NULL;
 824
 825           if (ss->context)
 826             {
 827               /* After the handler runs we will restore to the state in
 828                  SS->context, not the state of the thread now.  So restore
 829                  that context's reply port and intr port.  */
 830
 831               scp->sc_reply_port = ss->context->sc_reply_port;
 832               scp->sc_intr_port = ss->context->sc_intr_port;
 833
 834               ss->context = NULL;
 835             }
 836         }
 837
 838         /* Backdoor extra argument to signal handler.  */
 839         scp->sc_error = sigerror;
 840
 841         /* Block SIGNO and requested signals while running the handler.  */
 842         scp->sc_mask = ss->blocked;
 843         ss->blocked |= __sigmask (signo) | ss->actions[signo].sa_mask;
 844
 845         /* Start the thread running the handler (or possibly waiting for an
 846            RPC reply before running the handler).  */
 847         err = __thread_set_state (ss->thread, MACHINE_THREAD_STATE_FLAVOR,
 848                                   (natural_t *) &thread_state.basic,
 849                                   MACHINE_THREAD_STATE_COUNT);
 850         assert_perror (err);
 851         err = __thread_resume (ss->thread);
 852         assert_perror (err);
 853         thread_state.set = 0;   /* Everything we know is now wrong.  */
 854         break;
 855       }
 856     }
 857
 858   /* The signal has either been ignored or is now being handled.  We can
 859      consider it delivered and reply to the killer.  */
 860   reply ();
 861
 862   /* We get here unless the signal was fatal.  We still hold SS->lock.
 863      Check for pending signals, and loop to post them.  */
 864   {
 865     /* Return nonzero if SS has any signals pending we should worry about.
 866        We don't worry about any pending signals if we are stopped, nor if
 867        SS is in a critical section.  We are guaranteed to get a sig_post
 868        message before any of them become deliverable: either the SIGCONT
 869        signal, or a sig_post with SIGNO==0 as an explicit poll when the
 870        thread finishes its critical section.  */
 871     inline int signals_pending (void)
 872       {
 873         if (_hurd_stopped || ss->critical_section)
 874           return 0;
 875         return pending = ss->pending & ~ss->blocked;
 876       }
 877
 878   check_pending_signals:
 879     untraced = 0;
 880
 881     if (signals_pending ())
 882       {
 883       pending:
 884         for (signo = 1; signo < NSIG; ++signo)
 885           if (__sigismember (&pending, signo))
 886             {
 887               __sigdelset (&ss->pending, signo);
 888               sigcode = ss->pending_data[signo].code;
 889               sigerror = ss->pending_data[signo].error;
 890               __spin_unlock (&ss->lock);
 891               goto post_signal;
 892             }
 893       }
 894
 895     /* No pending signals left undelivered for this thread.
 896        If we were sent signal 0, we need to check for pending
 897        signals for all threads.  */
 898     if (signo == 0)
 899       {
 900         __spin_unlock (&ss->lock);
 901         __mutex_lock (&_hurd_siglock);
 902         for (ss = _hurd_sigstates; ss != NULL; ss = ss->next)
 903           {
 904             __spin_lock (&ss->lock);
 905             if (signals_pending ())
 906               goto pending;
 907             __spin_unlock (&ss->lock);
 908           }
 909         __mutex_unlock (&_hurd_siglock);
 910       }
 911     else
 912       {
 913         /* No more signals pending; SS->lock is still locked.
 914            Wake up any sigsuspend call that is blocking SS->thread.  */
 915         if (ss->suspended != MACH_PORT_NULL)
 916           {
 917             /* There is a sigsuspend waiting.  Tell it to wake up.  */
 918             error_t err;
 919             mach_msg_header_t msg;
 920             err = __mach_port_insert_right (__mach_task_self (),
 921                                             ss->suspended, ss->suspended,
 922                                             MACH_MSG_TYPE_MAKE_SEND);
 923             assert_perror (err);
 924             msg.msgh_bits = MACH_MSGH_BITS (MACH_MSG_TYPE_MOVE_SEND, 0);
 925             msg.msgh_remote_port = ss->suspended;
 926             msg.msgh_local_port = MACH_PORT_NULL;
 927             /* These values do not matter.  */
 928             msg.msgh_id = 8675309; /* Jenny, Jenny.  */
 929             msg.msgh_seqno = 17; /* Random.  */
 930             ss->suspended = MACH_PORT_NULL;
 931             err = __mach_msg (&msg, MACH_SEND_MSG, sizeof msg, 0,
 932                               MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
 933                               MACH_PORT_NULL);
 934             assert_perror (err);
 935           }
 936         __spin_unlock (&ss->lock);
 937       }
 938   }
 939
 940   /* All pending signals delivered to all threads.
 941      Now we can send the reply message even for signal 0.  */
 942   reply ();
 943 }
 944 \f
 945 /* Decide whether REFPORT enables the sender to send us a SIGNO signal.
 946    Returns zero if so, otherwise the error code to return to the sender.  */
 947
 948 static error_t
 949 signal_allowed (int signo, mach_port_t refport)
 950 {
 951   if (signo < 0 || signo >= NSIG)
 952     return EINVAL;
 953
 954   if (refport == __mach_task_self ())
 955     /* Can send any signal.  */
 956     goto win;
 957
 958   /* Avoid needing to check for this below.  */
 959   if (refport == MACH_PORT_NULL)
 960     return EPERM;
 961
 962   switch (signo)
 963     {
 964     case SIGINT:
 965     case SIGQUIT:
 966     case SIGTSTP:
 967     case SIGHUP:
 968     case SIGINFO:
 969     case SIGTTIN:
 970     case SIGTTOU:
 971       /* Job control signals can be sent by the controlling terminal.  */
 972       if (__USEPORT (CTTYID, port == refport))
 973         goto win;
 974       break;
 975
 976     case SIGCONT:
 977       {
 978         /* A continue signal can be sent by anyone in the session.  */
 979         mach_port_t sessport;
 980         if (! __USEPORT (PROC, __proc_getsidport (port, &sessport)))
 981           {
 982             __mach_port_deallocate (__mach_task_self (), sessport);
 983             if (refport == sessport)
 984               goto win;
 985           }
 986       }
 987       break;
 988
 989     case SIGIO:
 990     case SIGURG:
 991       {
 992         /* Any io object a file descriptor refers to might send us
 993            one of these signals using its async ID port for REFPORT.
 994
 995            This is pretty wide open; it is not unlikely that some random
 996            process can at least open for reading something we have open,
 997            get its async ID port, and send us a spurious SIGIO or SIGURG
 998            signal.  But BSD is actually wider open than that!--you can set
 999            the owner of an io object to any process or process group
1000            whatsoever and send them gratuitous signals.
1001
1002            Someday we could implement some reasonable scheme for
1003            authorizing SIGIO and SIGURG signals properly.  */
1004
1005         int d;
1006         __mutex_lock (&_hurd_dtable_lock);
1007         for (d = 0; (unsigned int) d < (unsigned int) _hurd_dtablesize; ++d)
1008           {
1009             struct hurd_userlink ulink;
1010             io_t port;
1011             mach_port_t asyncid;
1012             if (_hurd_dtable[d] == NULL)
1013               continue;
1014             port = _hurd_port_get (&_hurd_dtable[d]->port, &ulink);
1015             if (! __io_get_icky_async_id (port, &asyncid))
1016               {
1017                 if (refport == asyncid)
1018                   /* Break out of the loop on the next iteration.  */
1019                   d = -1;
1020                 __mach_port_deallocate (__mach_task_self (), asyncid);
1021               }
1022             _hurd_port_free (&_hurd_dtable[d]->port, &ulink, port);
1023           }
1024         /* If we found a lucky winner, we've set D to -1 in the loop.  */
1025         if (d < 0)
1026           goto win;
1027       }
1028     }
1029
1030   /* If this signal is legit, we have done `goto win' by now.
1031      When we return the error, mig deallocates REFPORT.  */
1032   return EPERM;
1033
1034  win:
1035   /* Deallocate the REFPORT send right; we are done with it.  */
1036   __mach_port_deallocate (__mach_task_self (), refport);
1037
1038   return 0;
1039 }
1040
1041 /* Implement the sig_post RPC from <hurd/msg.defs>;
1042    sent when someone wants us to get a signal.  */
1043 kern_return_t
1044 _S_msg_sig_post (mach_port_t me,
1045                  mach_port_t reply_port, mach_msg_type_name_t reply_port_type,
1046                  int signo,
1047                  mach_port_t refport)
1048 {
1049   error_t err;
1050
1051   if (err = signal_allowed (signo, refport))
1052     return err;
1053
1054   /* Post the signal to the designated signal-receiving thread.  This will
1055      reply when the signal can be considered delivered.  */
1056   _hurd_internal_post_signal (_hurd_thread_sigstate (_hurd_sigthread),
1057                               signo, 0, 0, reply_port, reply_port_type,
1058                               0); /* Stop if traced.  */
1059
1060   return MIG_NO_REPLY;          /* Already replied.  */
1061 }
1062
1063 /* Implement the sig_post_untraced RPC from <hurd/msg.defs>;
1064    sent when the debugger wants us to really get a signal
1065    even if we are traced.  */
1066 kern_return_t
1067 _S_msg_sig_post_untraced (mach_port_t me,
1068                           mach_port_t reply_port,
1069                           mach_msg_type_name_t reply_port_type,
1070                           int signo,
1071                           mach_port_t refport)
1072 {
1073   error_t err;
1074
1075   if (err = signal_allowed (signo, refport))
1076     return err;
1077
1078   /* Post the signal to the designated signal-receiving thread.  This will
1079      reply when the signal can be considered delivered.  */
1080   _hurd_internal_post_signal (_hurd_thread_sigstate (_hurd_sigthread),
1081                               signo, 0, 0, reply_port, reply_port_type,
1082                               1); /* Untraced flag. */
1083
1084   return MIG_NO_REPLY;          /* Already replied.  */
1085 }
1086 \f
1087 extern void __mig_init (void *);
1088
1089 #include <mach/task_special_ports.h>
1090
1091 /* Initialize the message port and _hurd_sigthread and start the signal
1092    thread.  */
1093
1094 void
1095 _hurdsig_init (void)
1096 {
1097   error_t err;
1098   vm_size_t stacksize;
1099
1100   __mutex_init (&_hurd_siglock);
1101
1102   err = __mach_port_allocate (__mach_task_self (),
1103                               MACH_PORT_RIGHT_RECEIVE,
1104                               &_hurd_msgport);
1105   assert_perror (err);
1106
1107   /* Make a send right to the signal port.  */
1108   err = __mach_port_insert_right (__mach_task_self (),
1109                                   _hurd_msgport,
1110                                   _hurd_msgport,
1111                                   MACH_MSG_TYPE_MAKE_SEND);
1112   assert_perror (err);
1113
1114   /* Set the default thread to receive task-global signals
1115      to this one, the main (first) user thread.  */
1116   _hurd_sigthread = __mach_thread_self ();
1117
1118   /* Start the signal thread listening on the message port.  */
1119
1120   err = __thread_create (__mach_task_self (), &_hurd_msgport_thread);
1121   assert_perror (err);
1122
1123   stacksize = __vm_page_size * 4; /* Small stack for signal thread.  */
1124   err = __mach_setup_thread (__mach_task_self (), _hurd_msgport_thread,
1125                              _hurd_msgport_receive,
1126                              (vm_address_t *) &__hurd_sigthread_stack_base,
1127                              &stacksize);
1128   assert_perror (err);
1129
1130   __hurd_sigthread_stack_end = __hurd_sigthread_stack_base + stacksize;
1131   __hurd_sigthread_variables =
1132     malloc (__hurd_threadvar_max * sizeof (unsigned long int));
1133   if (__hurd_sigthread_variables == NULL)
1134     __libc_fatal ("hurd: Can't allocate thread variables for signal thread\n");
1135
1136   /* Reinitialize the MiG support routines so they will use a per-thread
1137      variable for the cached reply port.  */
1138   __mig_init ((void *) __hurd_sigthread_stack_base);
1139
1140   err = __thread_resume (_hurd_msgport_thread);
1141   assert_perror (err);
1142
1143   /* Receive exceptions on the signal port.  */
1144   __task_set_special_port (__mach_task_self (),
1145                            TASK_EXCEPTION_PORT, _hurd_msgport);
1146 }
1147 \f                               /* XXXX */
1148 /* Reauthenticate with the proc server.  */
1149
1150 static void
1151 reauth_proc (mach_port_t new)
1152 {
1153   mach_port_t ref, ignore;
1154
1155   ref = __mach_reply_port ();
1156   if (! HURD_PORT_USE (&_hurd_ports[INIT_PORT_PROC],
1157                        __proc_reauthenticate (port, ref,
1158                                               MACH_MSG_TYPE_MAKE_SEND) ||
1159                        __auth_user_authenticate (new, port, ref,
1160                                                  MACH_MSG_TYPE_MAKE_SEND,
1161                                                  &ignore))
1162       && ignore != MACH_PORT_NULL)
1163     __mach_port_deallocate (__mach_task_self (), ignore);
1164   __mach_port_destroy (__mach_task_self (), ref);
1165
1166   (void) &reauth_proc;          /* Silence compiler warning.  */
1167 }
1168 text_set_element (_hurd_reauth_hook, reauth_proc);
1169 \f
1170 /* Like `getenv', but safe for the signal thread to run.
1171    If the environment is trashed, this will just return NULL.  */
1172
1173 const char *
1174 _hurdsig_getenv (const char *variable)
1175 {
1176   if (_hurdsig_catch_fault (SIGSEGV))
1177     /* We bombed in getenv.  */
1178     return NULL;
1179   else
1180     {
1181       const char *value = getenv (variable);
1182       /* Fault now if VALUE is a bogus string.  */
1183       (void) strlen (value);
1184       _hurdsig_end_catch_fault ();
1185       return value;
1186     }
1187 }