1 /* Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
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.
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.
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 not,
16 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 Boston, MA 02111-1307, USA. */
22 #include <hurd/signal.h>
23 #include <cthreads.h> /* For `struct mutex'. */
26 #include "hurdfault.h"
27 #include "hurdmalloc.h" /* XXX */
29 const char *_hurdsig_getenv (const char *);
31 struct mutex _hurd_siglock;
34 /* Port that receives signals and other miscellaneous messages. */
35 mach_port_t _hurd_msgport;
37 /* Thread listening on it. */
38 thread_t _hurd_msgport_thread;
40 /* Thread which receives task-global signals. */
41 thread_t _hurd_sigthread;
43 /* These are set up by _hurdsig_init. */
44 unsigned long int __hurd_sigthread_stack_base;
45 unsigned long int __hurd_sigthread_stack_end;
46 unsigned long int *__hurd_sigthread_variables;
48 /* Linked-list of per-thread signal state. */
49 struct hurd_sigstate *_hurd_sigstates;
51 /* Timeout for RPC's after interrupt_operation. */
52 mach_msg_timeout_t _hurd_interrupted_rpc_timeout = 3000;
55 default_sigaction (struct sigaction actions[NSIG])
59 __sigemptyset (&actions[0].sa_mask);
60 actions[0].sa_flags = SA_RESTART;
61 actions[0].sa_handler = SIG_DFL;
63 for (signo = 1; signo < NSIG; ++signo)
64 actions[signo] = actions[0];
67 struct hurd_sigstate *
68 _hurd_thread_sigstate (thread_t thread)
70 struct hurd_sigstate *ss;
71 __mutex_lock (&_hurd_siglock);
72 for (ss = _hurd_sigstates; ss != NULL; ss = ss->next)
73 if (ss->thread == thread)
77 ss = malloc (sizeof (*ss));
79 __libc_fatal ("hurd: Can't allocate thread sigstate\n");
81 __spin_lock_init (&ss->lock);
83 /* Initialize default state. */
84 __sigemptyset (&ss->blocked);
85 __sigemptyset (&ss->pending);
86 memset (&ss->sigaltstack, 0, sizeof (ss->sigaltstack));
87 ss->preemptors = NULL;
89 ss->intr_port = MACH_PORT_NULL;
92 /* Initialize the sigaction vector from the default signal receiving
93 thread's state, and its from the system defaults. */
94 if (thread == _hurd_sigthread)
95 default_sigaction (ss->actions);
98 struct hurd_sigstate *s;
99 for (s = _hurd_sigstates; s != NULL; s = s->next)
100 if (s->thread == _hurd_sigthread)
104 __spin_lock (&s->lock);
105 memcpy (ss->actions, s->actions, sizeof (s->actions));
106 __spin_unlock (&s->lock);
109 default_sigaction (ss->actions);
112 ss->next = _hurd_sigstates;
113 _hurd_sigstates = ss;
115 __mutex_unlock (&_hurd_siglock);
119 /* Signal delivery itself is on this page. */
122 #include <hurd/crash.h>
123 #include <hurd/paths.h>
126 #include <sys/wait.h>
127 #include "thread_state.h"
128 #include <hurd/msg_server.h>
129 #include <hurd/msg_reply.h> /* For __msg_sig_post_reply. */
130 #include <hurd/interrupt.h>
134 int _hurd_core_limit; /* XXX */
136 /* Call the crash dump server to mummify us before we die.
137 Returns nonzero if a core file was written. */
139 write_corefile (int signo, const struct hurd_signal_detail *detail)
142 mach_port_t coreserver;
143 file_t file, coredir;
147 When we have a protocol to make the server return an error
148 for RLIMIT_FSIZE, then tell the corefile fs server the RLIMIT_CORE
149 value in place of the RLIMIT_FSIZE value. */
151 /* First get a port to the core dumping server. */
152 coreserver = MACH_PORT_NULL;
153 name = _hurdsig_getenv ("CRASHSERVER");
155 coreserver = __file_name_lookup (name, 0, 0);
156 if (coreserver == MACH_PORT_NULL)
157 coreserver = __file_name_lookup (_SERVERS_CRASH, 0, 0);
158 if (coreserver == MACH_PORT_NULL)
161 /* Get a port to the directory where the new core file will reside. */
162 file = MACH_PORT_NULL;
163 name = _hurdsig_getenv ("COREFILE");
166 coredir = __file_name_split (name, (char **) &name);
167 if (coredir != MACH_PORT_NULL)
168 /* Create the new file, but don't link it into the directory yet. */
169 __dir_mkfile (coredir, O_WRONLY|O_CREAT,
170 0600 & ~_hurd_umask, /* XXX ? */
173 /* Call the core dumping server to write the core file. */
174 err = __crash_dump_task (coreserver,
177 signo, detail->code, detail->error,
178 detail->exc, detail->exc_code, detail->exc_subcode,
179 _hurd_ports[INIT_PORT_CTTYID].port,
180 MACH_MSG_TYPE_COPY_SEND);
181 __mach_port_deallocate (__mach_task_self (), coreserver);
183 if (! err && file != MACH_PORT_NULL)
184 /* The core dump into FILE succeeded, so now link it into the
186 err = __dir_link (file, coredir, name, 1);
187 __mach_port_deallocate (__mach_task_self (), file);
188 __mach_port_deallocate (__mach_task_self (), coredir);
189 return !err && file != MACH_PORT_NULL;
193 /* The lowest-numbered thread state flavor value is 1,
194 so we use bit 0 in machine_thread_all_state.set to
195 record whether we have done thread_abort. */
196 #define THREAD_ABORTED 1
198 /* SS->thread is suspended. Abort the thread and get its basic state. */
200 abort_thread (struct hurd_sigstate *ss, struct machine_thread_all_state *state,
201 void (*reply) (void))
203 if (!(state->set & THREAD_ABORTED))
205 error_t err = __thread_abort (ss->thread);
207 /* Clear all thread state flavor set bits, because thread_abort may
208 have changed the state. */
209 state->set = THREAD_ABORTED;
215 machine_get_basic_state (ss->thread, state);
218 /* Find the location of the MiG reply port cell in use by the thread whose
219 state is described by THREAD_STATE. If SIGTHREAD is nonzero, make sure
220 that this location can be set without faulting, or else return NULL. */
223 interrupted_reply_port_location (struct machine_thread_all_state *thread_state,
226 mach_port_t *portloc = (mach_port_t *) __hurd_threadvar_location_from_sp
227 (_HURD_THREADVAR_MIG_REPLY, (void *) thread_state->basic.SP);
229 if (sigthread && _hurdsig_catch_memory_fault (portloc))
230 /* Faulted trying to read the stack. */
233 /* Fault now if this pointer is bogus. */
234 *(volatile mach_port_t *) portloc = *portloc;
237 _hurdsig_end_catch_fault ();
242 #include <hurd/sigpreempt.h>
243 #include "intr-msg.h"
245 /* Timeout on interrupt_operation calls. */
246 mach_msg_timeout_t _hurdsig_interrupt_timeout = 1000;
248 /* SS->thread is suspended.
250 Abort any interruptible RPC operation the thread is doing.
252 This uses only the constant member SS->thread and the unlocked, atomically
253 set member SS->intr_port, so no locking is needed.
255 If successfully sent an interrupt_operation and therefore the thread should
256 wait for its pending RPC to return (possibly EINTR) before taking the
257 incoming signal, returns the reply port to be received on. Otherwise
258 returns MACH_PORT_NULL.
260 SIGNO is used to find the applicable SA_RESTART bit. If SIGNO is zero,
261 the RPC fails with EINTR instead of restarting (thread_cancel).
263 *STATE_CHANGE is set nonzero if STATE->basic was modified and should
264 be applied back to the thread if it might ever run again, else zero. */
267 _hurdsig_abort_rpcs (struct hurd_sigstate *ss, int signo, int sigthread,
268 struct machine_thread_all_state *state, int *state_change,
269 void (*reply) (void))
271 extern const void _hurd_intr_rpc_msg_in_trap;
272 mach_port_t rcv_port = MACH_PORT_NULL;
273 mach_port_t intr_port;
277 intr_port = ss->intr_port;
278 if (intr_port == MACH_PORT_NULL)
279 /* No interruption needs done. */
280 return MACH_PORT_NULL;
282 /* Abort the thread's kernel context, so any pending message send or
283 receive completes immediately or aborts. */
284 abort_thread (ss, state, reply);
286 if (state->basic.PC < (natural_t) &_hurd_intr_rpc_msg_in_trap)
288 /* The thread is about to do the RPC, but hasn't yet entered
289 mach_msg. Mutate the thread's state so it knows not to try
291 INTR_MSG_BACK_OUT (&state->basic);
292 MACHINE_THREAD_STATE_SET_PC (&state->basic,
293 &_hurd_intr_rpc_msg_in_trap);
294 state->basic.SYSRETURN = MACH_SEND_INTERRUPTED;
297 else if (state->basic.PC == (natural_t) &_hurd_intr_rpc_msg_in_trap &&
298 /* The thread was blocked in the system call. After thread_abort,
299 the return value register indicates what state the RPC was in
301 state->basic.SYSRETURN == MACH_RCV_INTERRUPTED)
303 /* The RPC request message was sent and the thread was waiting for
304 the reply message; now the message receive has been aborted, so
305 the mach_msg call will return MACH_RCV_INTERRUPTED. We must tell
306 the server to interrupt the pending operation. The thread must
307 wait for the reply message before running the signal handler (to
308 guarantee that the operation has finished being interrupted), so
309 our nonzero return tells the trampoline code to finish the message
310 receive operation before running the handler. */
312 mach_port_t *reply = interrupted_reply_port_location (state,
314 error_t err = __interrupt_operation (intr_port, _hurdsig_interrupt_timeout);
320 /* The interrupt didn't work.
321 Destroy the receive right the thread is blocked on. */
322 __mach_port_destroy (__mach_task_self (), *reply);
323 *reply = MACH_PORT_NULL;
326 /* The system call return value register now contains
327 MACH_RCV_INTERRUPTED; when mach_msg resumes, it will retry the
328 call. Since we have just destroyed the receive right, the
329 retry will fail with MACH_RCV_INVALID_NAME. Instead, just
330 change the return value here to EINTR so mach_msg will not
331 retry and the EINTR error code will propagate up. */
332 state->basic.SYSRETURN = EINTR;
338 /* All threads whose RPCs were interrupted by the interrupt_operation
339 call above will retry their RPCs unless we clear SS->intr_port.
340 So we clear it for the thread taking a signal when SA_RESTART is
341 clear, so that its call returns EINTR. */
342 if (! signo || !(ss->actions[signo].sa_flags & SA_RESTART))
343 ss->intr_port = MACH_PORT_NULL;
350 /* Abort the RPCs being run by all threads but this one;
351 all other threads should be suspended. If LIVE is nonzero, those
352 threads may run again, so they should be adjusted as necessary to be
353 happy when resumed. STATE is clobbered as a scratch area; its initial
354 contents are ignored, and its contents on return are not useful. */
357 abort_all_rpcs (int signo, struct machine_thread_all_state *state, int live)
359 /* We can just loop over the sigstates. Any thread doing something
360 interruptible must have one. We needn't bother locking because all
361 other threads are stopped. */
363 struct hurd_sigstate *ss;
365 mach_port_t *reply_ports;
367 /* First loop over the sigstates to count them.
368 We need to know how big a vector we will need for REPLY_PORTS. */
370 for (ss = _hurd_sigstates; ss != NULL; ss = ss->next)
373 reply_ports = alloca (nthreads * sizeof *reply_ports);
376 for (ss = _hurd_sigstates; ss != NULL; ss = ss->next, ++nthreads)
377 if (ss->thread == _hurd_msgport_thread)
378 reply_ports[nthreads] = MACH_PORT_NULL;
382 state->set = 0; /* Reset scratch area. */
384 /* Abort any operation in progress with interrupt_operation.
385 Record the reply port the thread is waiting on.
386 We will wait for all the replies below. */
387 reply_ports[nthreads] = _hurdsig_abort_rpcs (ss, signo, 1,
388 state, &state_changed,
392 if (reply_ports[nthreads] != MACH_PORT_NULL)
394 /* We will wait for the reply to this RPC below, so the
395 thread must issue a new RPC rather than waiting for the
396 reply to the one it sent. */
397 state->basic.SYSRETURN = EINTR;
401 /* Aborting the RPC needed to change this thread's state,
402 and it might ever run again. So write back its state. */
403 __thread_set_state (ss->thread, MACHINE_THREAD_STATE_FLAVOR,
404 (natural_t *) &state->basic,
405 MACHINE_THREAD_STATE_COUNT);
409 /* Wait for replies from all the successfully interrupted RPCs. */
410 while (nthreads-- > 0)
411 if (reply_ports[nthreads] != MACH_PORT_NULL)
414 mach_msg_header_t head;
415 err = __mach_msg (&head, MACH_RCV_MSG|MACH_RCV_TIMEOUT, 0, sizeof head,
416 reply_ports[nthreads],
417 _hurd_interrupted_rpc_timeout, MACH_PORT_NULL);
420 case MACH_RCV_TIMED_OUT:
421 case MACH_RCV_TOO_LARGE:
430 struct hurd_signal_preemptor *_hurdsig_preemptors = 0;
431 sigset_t _hurdsig_preempted_set;
433 /* XXX temporary to deal with spelling fix */
434 weak_alias (_hurdsig_preemptors, _hurdsig_preempters)
436 /* Mask of stop signals. */
437 #define STOPSIGS (sigmask (SIGTTIN) | sigmask (SIGTTOU) | \
438 sigmask (SIGSTOP) | sigmask (SIGTSTP))
440 /* Deliver a signal. SS is not locked. */
442 _hurd_internal_post_signal (struct hurd_sigstate *ss,
443 int signo, struct hurd_signal_detail *detail,
444 mach_port_t reply_port,
445 mach_msg_type_name_t reply_port_type,
449 struct machine_thread_all_state thread_state;
450 enum { stop, ignore, core, term, handle } act;
451 struct hurd_signal_preemptor *pe;
452 sighandler_t handler;
456 /* Reply to this sig_post message. */
457 __typeof (__msg_sig_post_reply) *reply_rpc
458 = (untraced ? __msg_sig_post_untraced_reply : __msg_sig_post_reply);
462 if (reply_port == MACH_PORT_NULL)
464 err = (*reply_rpc) (reply_port, reply_port_type, 0);
465 reply_port = MACH_PORT_NULL;
466 if (err != MACH_SEND_INVALID_DEST) /* Ignore dead reply port. */
470 /* Mark the signal as pending. */
471 void mark_pending (void)
473 __sigaddset (&ss->pending, signo);
474 /* Save the details to be given to the handler when SIGNO is
476 ss->pending_data[signo] = *detail;
479 /* Suspend the process with SIGNO. */
482 /* Stop all other threads and mark ourselves stopped. */
485 /* Hold the siglock while stopping other threads to be
486 sure it is not held by another thread afterwards. */
487 __mutex_lock (&_hurd_siglock);
488 __proc_dostop (port, _hurd_msgport_thread);
489 __mutex_unlock (&_hurd_siglock);
490 abort_all_rpcs (signo, &thread_state, 1);
492 __proc_mark_stop (port, signo, detail->code);
496 /* Resume the process after a suspension. */
499 /* Resume the process from being stopped. */
501 mach_msg_type_number_t nthreads, i;
507 /* Tell the proc server we are continuing. */
508 __USEPORT (PROC, __proc_mark_cont (port));
509 /* Fetch ports to all our threads and resume them. */
510 err = __task_threads (__mach_task_self (), &threads, &nthreads);
512 for (i = 0; i < nthreads; ++i)
514 if (threads[i] != _hurd_msgport_thread &&
515 (act != handle || threads[i] != ss->thread))
517 err = __thread_resume (threads[i]);
520 err = __mach_port_deallocate (__mach_task_self (),
524 __vm_deallocate (__mach_task_self (),
525 (vm_address_t) threads,
526 nthreads * sizeof *threads);
529 /* The thread that will run the handler is already suspended. */
536 /* This is PTRACE_CONTINUE. */
539 /* This call is just to check for pending signals. */
540 __spin_lock (&ss->lock);
541 goto check_pending_signals;
546 thread_state.set = 0; /* We know nothing. */
548 __spin_lock (&ss->lock);
550 /* Check for a preempted signal. Preempted signals can arrive during
551 critical sections. */
554 for (pe = ss->preemptors; pe && handler == SIG_ERR; pe = pe->next)
555 if (HURD_PREEMPT_SIGNAL_P (pe, signo, detail->code))
556 handler = (*pe->preemptor) (pe, ss, &signo, detail);
558 if (handler == SIG_ERR && (__sigmask (signo) & _hurdsig_preempted_set))
560 __mutex_lock (&_hurd_siglock);
561 for (pe = _hurdsig_preemptors; pe && handler == SIG_ERR; pe = pe->next)
562 if (HURD_PREEMPT_SIGNAL_P (pe, signo, detail->code))
563 handler = (*pe->preemptor) (pe, ss, &signo, detail);
564 __mutex_unlock (&_hurd_siglock);
569 if (handler == SIG_IGN)
570 /* Ignore the signal altogether. */
572 if (handler != SIG_ERR)
573 /* Run the preemption-provided handler. */
577 /* No preemption. Do normal handling. */
579 if (!untraced && __sigismember (&_hurdsig_traced, signo))
581 /* We are being traced. Stop to tell the debugger of the signal. */
583 /* Already stopped. Mark the signal as pending;
584 when resumed, we will notice it and stop again. */
588 __spin_unlock (&ss->lock);
593 handler = ss->actions[signo].sa_handler;
595 if (handler == SIG_DFL)
596 /* Figure out the default action for this signal. */
600 /* A sig_post msg with SIGNO==0 is sent to
601 tell us to check for pending signals. */
633 if (_hurd_pgrp == _hurd_pid)
635 /* We are the process group leader. Since there is no
636 user-specified handler for SIGINFO, we use a default one
637 which prints something interesting. We use the normal
638 handler mechanism instead of just doing it here to avoid
639 the signal thread faulting or blocking in this
640 potentially hairy operation. */
642 handler = _hurd_siginfo_handler;
652 else if (handler == SIG_IGN)
657 if (__sigmask (signo) & STOPSIGS)
658 /* Stop signals clear a pending SIGCONT even if they
659 are handled or ignored (but not if preempted). */
660 ss->pending &= ~sigmask (SIGCONT);
663 if (signo == SIGCONT)
664 /* Even if handled or ignored (but not preempted), SIGCONT clears
665 stop signals and resumes the process. */
666 ss->pending &= ~STOPSIGS;
668 if (_hurd_stopped && act != stop && (untraced || signo == SIGCONT))
673 if (_hurd_orphaned && act == stop &&
674 (__sigmask (signo) & (__sigmask (SIGTTIN) | __sigmask (SIGTTOU) |
675 __sigmask (SIGTSTP))))
677 /* If we would ordinarily stop for a job control signal, but we are
678 orphaned so noone would ever notice and continue us again, we just
679 quietly die, alone and in the dark. */
680 detail->code = signo;
685 /* Handle receipt of a blocked signal, or any signal while stopped. */
686 if (act != ignore && /* Signals ignored now are forgotten now. */
687 __sigismember (&ss->blocked, signo) ||
688 (signo != SIGKILL && _hurd_stopped))
694 /* Perform the chosen action for the signal. */
700 /* We are already stopped, but receiving an untraced stop
701 signal. Instead of resuming and suspending again, just
702 notify the proc server of the new stop signal. */
703 error_t err = __USEPORT (PROC, __proc_mark_stop
704 (port, signo, detail->code));
708 /* Suspend the process. */
713 /* Nobody cares about this signal. If there was a call to resume
714 above in SIGCONT processing and we've left a thread suspended,
715 now's the time to set it going. */
718 err = __thread_resume (ss->thread);
725 /* We got a fault setting up the stack frame for the handler.
726 Nothing to do but die; BSD gets SIGILL in this case. */
727 detail->code = signo; /* XXX ? */
732 case term: /* Time to die. */
733 case core: /* And leave a rotting corpse. */
734 /* Have the proc server stop all other threads in our task. */
735 err = __USEPORT (PROC, __proc_dostop (port, _hurd_msgport_thread));
737 /* No more user instructions will be executed.
738 The signal can now be considered delivered. */
740 /* Abort all server operations now in progress. */
741 abort_all_rpcs (signo, &thread_state, 0);
744 int status = W_EXITCODE (0, signo);
745 /* Do a core dump if desired. Only set the wait status bit saying we
746 in fact dumped core if the operation was actually successful. */
747 if (act == core && write_corefile (signo, detail))
749 /* Tell proc how we died and then stick the saber in the gut. */
755 /* Call a handler for this signal. */
757 struct sigcontext *scp, ocontext;
758 int wait_for_reply, state_changed;
760 /* Stop the thread and abort its pending RPC operations. */
763 err = __thread_suspend (ss->thread);
767 /* Abort the thread's kernel context, so any pending message send
768 or receive completes immediately or aborts. If an interruptible
769 RPC is in progress, abort_rpcs will do this. But we must always
770 do it before fetching the thread's state, because
771 thread_get_state is never kosher before thread_abort. */
772 abort_thread (ss, &thread_state, NULL);
776 /* We have a previous sigcontext that sigreturn was about
777 to restore when another signal arrived. */
781 if (_hurdsig_catch_memory_fault (ss->context))
783 /* We faulted reading the thread's stack. Forget that
784 context and pretend it wasn't there. It almost
785 certainly crash if this handler returns, but that's it's
791 /* Copy the context from the thread's stack before
792 we start diddling the stack to set up the handler. */
793 ocontext = *ss->context;
794 ss->context = &ocontext;
796 _hurdsig_end_catch_fault ();
798 if (! machine_get_basic_state (ss->thread, &thread_state))
800 loc = interrupted_reply_port_location (&thread_state, 1);
801 if (loc && *loc != MACH_PORT_NULL)
802 /* This is the reply port for the context which called
803 sigreturn. Since we are abandoning that context entirely
804 and restoring SS->context instead, destroy this port. */
805 __mach_port_destroy (__mach_task_self (), *loc);
807 /* The thread was in sigreturn, not in any interruptible RPC. */
810 assert (! __spin_lock_locked (&ss->critical_section_lock));
814 int crit = __spin_lock_locked (&ss->critical_section_lock);
817 = (_hurdsig_abort_rpcs (ss,
818 /* In a critical section, any RPC
819 should be cancelled instead of
820 restarted, regardless of
821 SA_RESTART, so the entire
822 "atomic" operation can be aborted
825 &thread_state, &state_changed,
831 /* The thread is in a critical section. Mark the signal as
832 pending. When it finishes the critical section, it will
833 check for pending signals. */
836 /* Some cases of interrupting an RPC must change the
837 thread state to back out the call. Normally this
838 change is rolled into the warping to the handler and
839 sigreturn, but we are not running the handler now
840 because the thread is in a critical section. Instead,
841 mutate the thread right away for the RPC interruption
842 and resume it; the RPC will return early so the
843 critical section can end soon. */
844 __thread_set_state (ss->thread, MACHINE_THREAD_STATE_FLAVOR,
845 (natural_t *) &thread_state.basic,
846 MACHINE_THREAD_STATE_COUNT);
848 ss->intr_port = MACH_PORT_NULL;
849 __thread_resume (ss->thread);
854 /* Call the machine-dependent function to set the thread up
855 to run the signal handler, and preserve its old context. */
856 scp = _hurd_setup_sighandler (ss, handler, signo, detail,
857 wait_for_reply, &thread_state);
861 /* Set the machine-independent parts of the signal context. */
864 /* Fetch the thread variable for the MiG reply port,
865 and set it to MACH_PORT_NULL. */
866 mach_port_t *loc = interrupted_reply_port_location (&thread_state,
870 scp->sc_reply_port = *loc;
871 *loc = MACH_PORT_NULL;
874 scp->sc_reply_port = MACH_PORT_NULL;
876 /* Save the intr_port in use by the interrupted code,
877 and clear the cell before running the trampoline. */
878 scp->sc_intr_port = ss->intr_port;
879 ss->intr_port = MACH_PORT_NULL;
883 /* After the handler runs we will restore to the state in
884 SS->context, not the state of the thread now. So restore
885 that context's reply port and intr port. */
887 scp->sc_reply_port = ss->context->sc_reply_port;
888 scp->sc_intr_port = ss->context->sc_intr_port;
894 /* Backdoor extra argument to signal handler. */
895 scp->sc_error = detail->error;
897 /* Block SIGNO and requested signals while running the handler. */
898 scp->sc_mask = ss->blocked;
899 ss->blocked |= __sigmask (signo) | ss->actions[signo].sa_mask;
901 /* Start the thread running the handler (or possibly waiting for an
902 RPC reply before running the handler). */
903 err = __thread_set_state (ss->thread, MACHINE_THREAD_STATE_FLAVOR,
904 (natural_t *) &thread_state.basic,
905 MACHINE_THREAD_STATE_COUNT);
907 err = __thread_resume (ss->thread);
909 thread_state.set = 0; /* Everything we know is now wrong. */
914 /* The signal has either been ignored or is now being handled. We can
915 consider it delivered and reply to the killer. */
918 /* We get here unless the signal was fatal. We still hold SS->lock.
919 Check for pending signals, and loop to post them. */
921 /* Return nonzero if SS has any signals pending we should worry about.
922 We don't worry about any pending signals if we are stopped, nor if
923 SS is in a critical section. We are guaranteed to get a sig_post
924 message before any of them become deliverable: either the SIGCONT
925 signal, or a sig_post with SIGNO==0 as an explicit poll when the
926 thread finishes its critical section. */
927 inline int signals_pending (void)
929 if (_hurd_stopped || __spin_lock_locked (&ss->critical_section_lock))
931 return pending = ss->pending & ~ss->blocked;
934 check_pending_signals:
937 if (signals_pending ())
939 for (signo = 1; signo < NSIG; ++signo)
940 if (__sigismember (&pending, signo))
943 __sigdelset (&ss->pending, signo);
944 *detail = ss->pending_data[signo];
945 __spin_unlock (&ss->lock);
950 /* No pending signals left undelivered for this thread.
951 If we were sent signal 0, we need to check for pending
952 signals for all threads. */
955 __spin_unlock (&ss->lock);
956 __mutex_lock (&_hurd_siglock);
957 for (ss = _hurd_sigstates; ss != NULL; ss = ss->next)
959 __spin_lock (&ss->lock);
960 for (signo = 1; signo < NSIG; ++signo)
961 if (__sigismember (&ss->pending, signo)
962 && (!__sigismember (&ss->blocked, signo)
963 /* We "deliver" immediately pending blocked signals whose
964 action might be to ignore, so that if ignored they are
965 dropped right away. */
966 || ss->actions[signo].sa_handler == SIG_IGN
967 || ss->actions[signo].sa_handler == SIG_DFL))
969 mutex_unlock (&_hurd_siglock);
970 goto deliver_pending;
972 __spin_unlock (&ss->lock);
974 __mutex_unlock (&_hurd_siglock);
978 /* No more signals pending; SS->lock is still locked.
979 Wake up any sigsuspend call that is blocking SS->thread. */
980 if (ss->suspended != MACH_PORT_NULL)
982 /* There is a sigsuspend waiting. Tell it to wake up. */
984 mach_msg_header_t msg;
985 err = __mach_port_insert_right (__mach_task_self (),
986 ss->suspended, ss->suspended,
987 MACH_MSG_TYPE_MAKE_SEND);
989 msg.msgh_bits = MACH_MSGH_BITS (MACH_MSG_TYPE_MOVE_SEND, 0);
990 msg.msgh_remote_port = ss->suspended;
991 msg.msgh_local_port = MACH_PORT_NULL;
992 /* These values do not matter. */
993 msg.msgh_id = 8675309; /* Jenny, Jenny. */
994 msg.msgh_seqno = 17; /* Random. */
995 ss->suspended = MACH_PORT_NULL;
996 err = __mach_msg (&msg, MACH_SEND_MSG, sizeof msg, 0,
997 MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
1001 __spin_unlock (&ss->lock);
1005 /* All pending signals delivered to all threads.
1006 Now we can send the reply message even for signal 0. */
1010 /* Decide whether REFPORT enables the sender to send us a SIGNO signal.
1011 Returns zero if so, otherwise the error code to return to the sender. */
1014 signal_allowed (int signo, mach_port_t refport)
1016 if (signo < 0 || signo >= NSIG)
1019 if (refport == __mach_task_self ())
1020 /* Can send any signal. */
1023 /* Avoid needing to check for this below. */
1024 if (refport == MACH_PORT_NULL)
1037 /* Job control signals can be sent by the controlling terminal. */
1038 if (__USEPORT (CTTYID, port == refport))
1044 /* A continue signal can be sent by anyone in the session. */
1045 mach_port_t sessport;
1046 if (! __USEPORT (PROC, __proc_getsidport (port, &sessport)))
1048 __mach_port_deallocate (__mach_task_self (), sessport);
1049 if (refport == sessport)
1058 /* Any io object a file descriptor refers to might send us
1059 one of these signals using its async ID port for REFPORT.
1061 This is pretty wide open; it is not unlikely that some random
1062 process can at least open for reading something we have open,
1063 get its async ID port, and send us a spurious SIGIO or SIGURG
1064 signal. But BSD is actually wider open than that!--you can set
1065 the owner of an io object to any process or process group
1066 whatsoever and send them gratuitous signals.
1068 Someday we could implement some reasonable scheme for
1069 authorizing SIGIO and SIGURG signals properly. */
1072 int lucky = 0; /* True if we find a match for REFPORT. */
1073 __mutex_lock (&_hurd_dtable_lock);
1074 for (d = 0; !lucky && (unsigned) d < (unsigned) _hurd_dtablesize; ++d)
1076 struct hurd_userlink ulink;
1078 mach_port_t asyncid;
1079 if (_hurd_dtable[d] == NULL)
1081 port = _hurd_port_get (&_hurd_dtable[d]->port, &ulink);
1082 if (! __io_get_icky_async_id (port, &asyncid))
1084 if (refport == asyncid)
1085 /* Break out of the loop on the next iteration. */
1087 __mach_port_deallocate (__mach_task_self (), asyncid);
1089 _hurd_port_free (&_hurd_dtable[d]->port, &ulink, port);
1091 /* If we found a lucky winner, we've set D to -1 in the loop. */
1097 /* If this signal is legit, we have done `goto win' by now.
1098 When we return the error, mig deallocates REFPORT. */
1102 /* Deallocate the REFPORT send right; we are done with it. */
1103 __mach_port_deallocate (__mach_task_self (), refport);
1108 /* Implement the sig_post RPC from <hurd/msg.defs>;
1109 sent when someone wants us to get a signal. */
1111 _S_msg_sig_post (mach_port_t me,
1112 mach_port_t reply_port, mach_msg_type_name_t reply_port_type,
1113 int signo, natural_t sigcode,
1114 mach_port_t refport)
1117 struct hurd_signal_detail d;
1119 if (err = signal_allowed (signo, refport))
1125 /* Post the signal to the designated signal-receiving thread. This will
1126 reply when the signal can be considered delivered. */
1127 _hurd_internal_post_signal (_hurd_thread_sigstate (_hurd_sigthread),
1128 signo, &d, reply_port, reply_port_type,
1129 0); /* Stop if traced. */
1131 return MIG_NO_REPLY; /* Already replied. */
1134 /* Implement the sig_post_untraced RPC from <hurd/msg.defs>;
1135 sent when the debugger wants us to really get a signal
1136 even if we are traced. */
1138 _S_msg_sig_post_untraced (mach_port_t me,
1139 mach_port_t reply_port,
1140 mach_msg_type_name_t reply_port_type,
1141 int signo, natural_t sigcode,
1142 mach_port_t refport)
1145 struct hurd_signal_detail d;
1147 if (err = signal_allowed (signo, refport))
1153 /* Post the signal to the designated signal-receiving thread. This will
1154 reply when the signal can be considered delivered. */
1155 _hurd_internal_post_signal (_hurd_thread_sigstate (_hurd_sigthread),
1156 signo, &d, reply_port, reply_port_type,
1157 1); /* Untraced flag. */
1159 return MIG_NO_REPLY; /* Already replied. */
1162 extern void __mig_init (void *);
1164 #include <mach/task_special_ports.h>
1166 /* Initialize the message port and _hurd_sigthread and start the signal
1170 _hurdsig_init (const int *intarray, size_t intarraysize)
1173 vm_size_t stacksize;
1174 struct hurd_sigstate *ss;
1176 __mutex_init (&_hurd_siglock);
1178 err = __mach_port_allocate (__mach_task_self (),
1179 MACH_PORT_RIGHT_RECEIVE,
1181 assert_perror (err);
1183 /* Make a send right to the signal port. */
1184 err = __mach_port_insert_right (__mach_task_self (),
1187 MACH_MSG_TYPE_MAKE_SEND);
1188 assert_perror (err);
1190 /* Initialize the main thread's signal state. */
1191 ss = _hurd_self_sigstate ();
1193 /* Copy inherited values from our parent (or pre-exec process state)
1194 into the signal settings of the main thread. */
1195 if (intarraysize > INIT_SIGMASK)
1196 ss->blocked = intarray[INIT_SIGMASK];
1197 if (intarraysize > INIT_SIGPENDING)
1198 ss->blocked = intarray[INIT_SIGPENDING];
1199 if (intarraysize > INIT_SIGIGN && intarray[INIT_SIGIGN] != 0)
1202 for (signo = 1; signo < NSIG; ++signo)
1203 if (intarray[INIT_SIGIGN] & __sigmask(signo))
1204 ss->actions[signo].sa_handler = SIG_IGN;
1207 /* Set the default thread to receive task-global signals
1208 to this one, the main (first) user thread. */
1209 _hurd_sigthread = ss->thread;
1211 /* Start the signal thread listening on the message port. */
1213 err = __thread_create (__mach_task_self (), &_hurd_msgport_thread);
1214 assert_perror (err);
1216 stacksize = __vm_page_size * 8; /* Small stack for signal thread. */
1217 err = __mach_setup_thread (__mach_task_self (), _hurd_msgport_thread,
1218 _hurd_msgport_receive,
1219 (vm_address_t *) &__hurd_sigthread_stack_base,
1221 assert_perror (err);
1223 __hurd_sigthread_stack_end = __hurd_sigthread_stack_base + stacksize;
1224 __hurd_sigthread_variables =
1225 malloc (__hurd_threadvar_max * sizeof (unsigned long int));
1226 if (__hurd_sigthread_variables == NULL)
1227 __libc_fatal ("hurd: Can't allocate thread variables for signal thread\n");
1229 /* Reinitialize the MiG support routines so they will use a per-thread
1230 variable for the cached reply port. */
1231 __mig_init ((void *) __hurd_sigthread_stack_base);
1233 err = __thread_resume (_hurd_msgport_thread);
1234 assert_perror (err);
1236 /* Receive exceptions on the signal port. */
1237 __task_set_special_port (__mach_task_self (),
1238 TASK_EXCEPTION_PORT, _hurd_msgport);
1241 /* Reauthenticate with the proc server. */
1244 reauth_proc (mach_port_t new)
1246 mach_port_t ref, ignore;
1248 ref = __mach_reply_port ();
1249 if (! HURD_PORT_USE (&_hurd_ports[INIT_PORT_PROC],
1250 __proc_reauthenticate (port, ref,
1251 MACH_MSG_TYPE_MAKE_SEND) ||
1252 __auth_user_authenticate (new, ref,
1253 MACH_MSG_TYPE_MAKE_SEND,
1255 && ignore != MACH_PORT_NULL)
1256 __mach_port_deallocate (__mach_task_self (), ignore);
1257 __mach_port_destroy (__mach_task_self (), ref);
1259 /* Set the owner of the process here too. */
1260 mutex_lock (&_hurd_id.lock);
1261 if (!_hurd_check_ids ())
1262 HURD_PORT_USE (&_hurd_ports[INIT_PORT_PROC],
1263 __proc_setowner (port,
1265 ? _hurd_id.gen.uids[0] : 0),
1266 !_hurd_id.gen.nuids));
1267 mutex_unlock (&_hurd_id.lock);
1269 (void) &reauth_proc; /* Silence compiler warning. */
1271 text_set_element (_hurd_reauth_hook, reauth_proc);
1273 /* Like `getenv', but safe for the signal thread to run.
1274 If the environment is trashed, this will just return NULL. */
1277 _hurdsig_getenv (const char *variable)
1279 if (_hurdsig_catch_memory_fault (__environ))
1280 /* We bombed in getenv. */
1284 const size_t len = strlen (variable);
1286 char *volatile *ep = __environ;
1289 const char *p = *ep;
1290 _hurdsig_fault_preemptor.first = (long int) p;
1291 _hurdsig_fault_preemptor.last = VM_MAX_ADDRESS;
1292 if (! strncmp (p, variable, len) && p[len] == '=')
1297 valuelen = strlen (p);
1298 _hurdsig_fault_preemptor.last = (long int) (p + valuelen);
1299 value = malloc (++valuelen);
1301 memcpy (value, p, valuelen);
1304 _hurdsig_fault_preemptor.first = (long int) ++ep;
1305 _hurdsig_fault_preemptor.last = (long int) (ep + 1);
1307 _hurdsig_end_catch_fault ();