1 /* Copyright (C) 1991, 92, 93, 94, 95, 96 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
16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
17 Cambridge, MA 02139, USA. */
22 #include <hurd/signal.h>
23 #include <cthreads.h> /* For `struct mutex'. */
25 #include "hurdfault.h"
26 #include "hurdmalloc.h" /* XXX */
28 const char *_hurdsig_getenv (const char *);
30 struct mutex _hurd_siglock;
33 /* Port that receives signals and other miscellaneous messages. */
34 mach_port_t _hurd_msgport;
36 /* Thread listening on it. */
37 thread_t _hurd_msgport_thread;
39 /* Thread which receives task-global signals. */
40 thread_t _hurd_sigthread;
42 /* Linked-list of per-thread signal state. */
43 struct hurd_sigstate *_hurd_sigstates;
45 /* Timeout for RPC's after interrupt_operation. */
46 mach_msg_timeout_t _hurd_interrupted_rpc_timeout = 3000;
49 default_sigaction (struct sigaction actions[NSIG])
53 __sigemptyset (&actions[0].sa_mask);
54 actions[0].sa_flags = SA_RESTART;
55 actions[0].sa_handler = SIG_DFL;
57 for (signo = 1; signo < NSIG; ++signo)
58 actions[signo] = actions[0];
61 struct hurd_sigstate *
62 _hurd_thread_sigstate (thread_t thread)
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)
71 ss = malloc (sizeof (*ss));
73 __libc_fatal ("hurd: Can't allocate thread sigstate\n");
75 __spin_lock_init (&ss->lock);
77 /* Initialize default state. */
78 __sigemptyset (&ss->blocked);
79 __sigemptyset (&ss->pending);
80 memset (&ss->sigaltstack, 0, sizeof (ss->sigaltstack));
81 ss->preempters = NULL;
83 ss->intr_port = MACH_PORT_NULL;
86 /* Initialize the sigaction vector from the default signal receiving
87 thread's state, and its from the system defaults. */
88 if (thread == _hurd_sigthread)
89 default_sigaction (ss->actions);
92 struct hurd_sigstate *s;
93 for (s = _hurd_sigstates; s != NULL; s = s->next)
94 if (s->thread == _hurd_sigthread)
98 __spin_lock (&s->lock);
99 memcpy (ss->actions, s->actions, sizeof (s->actions));
100 __spin_unlock (&s->lock);
103 default_sigaction (ss->actions);
106 ss->next = _hurd_sigstates;
107 _hurd_sigstates = ss;
109 __mutex_unlock (&_hurd_siglock);
113 /* Signal delivery itself is on this page. */
116 #include <hurd/crash.h>
117 #include <hurd/paths.h>
120 #include <sys/wait.h>
121 #include "thread_state.h"
122 #include <hurd/msg_server.h>
123 #include <hurd/msg_reply.h> /* For __msg_sig_post_reply. */
125 #include <hurd/interrupt.h>
127 int _hurd_core_limit; /* XXX */
129 /* Call the crash dump server to mummify us before we die.
130 Returns nonzero if a core file was written. */
132 write_corefile (int signo, long int sigcode, int sigerror)
135 mach_port_t coreserver;
136 file_t file, coredir;
140 When we have a protocol to make the server return an error
141 for RLIMIT_FSIZE, then tell the corefile fs server the RLIMIT_CORE
142 value in place of the RLIMIT_FSIZE value. */
144 /* First get a port to the core dumping server. */
145 coreserver = MACH_PORT_NULL;
146 name = _hurdsig_getenv ("CRASHSERVER");
148 coreserver = __file_name_lookup (name, 0, 0);
149 if (coreserver == MACH_PORT_NULL)
150 coreserver = __file_name_lookup (_SERVERS_CRASH, 0, 0);
151 if (coreserver == MACH_PORT_NULL)
154 /* Get a port to the directory where the new core file will reside. */
155 name = _hurdsig_getenv ("COREFILE");
158 coredir = __file_name_split (name, (char **) &name);
159 if (coredir == MACH_PORT_NULL)
161 /* Create the new file, but don't link it into the directory yet. */
162 if (err = __dir_mkfile (coredir, O_WRONLY|O_CREAT,
163 0600 & ~_hurd_umask, /* XXX ? */
167 /* Call the core dumping server to write the core file. */
168 err = __crash_dump_task (coreserver,
170 file, _hurdsig_getenv ("GNUTARGET"),
171 signo, sigcode, sigerror);
172 __mach_port_deallocate (__mach_task_self (), coreserver);
174 /* The core dump into FILE succeeded, so now link it into the
176 err = __dir_link (file, coredir, name);
177 __mach_port_deallocate (__mach_task_self (), file);
178 __mach_port_deallocate (__mach_task_self (), coredir);
183 /* The lowest-numbered thread state flavor value is 1,
184 so we use bit 0 in machine_thread_all_state.set to
185 record whether we have done thread_abort. */
186 #define THREAD_ABORTED 1
188 /* SS->thread is suspended. Abort the thread and get its basic state. */
190 abort_thread (struct hurd_sigstate *ss, struct machine_thread_all_state *state,
191 void (*reply) (void))
193 if (!(state->set & THREAD_ABORTED))
195 error_t err = __thread_abort (ss->thread);
197 /* Clear all thread state flavor set bits, because thread_abort may
198 have changed the state. */
199 state->set = THREAD_ABORTED;
205 machine_get_basic_state (ss->thread, state);
208 /* Find the location of the MiG reply port cell in use by the thread whose
209 state is described by THREAD_STATE. If SIGTHREAD is nonzero, make sure
210 that this location can be set without faulting, or else return NULL. */
213 interrupted_reply_port_location (struct machine_thread_all_state *thread_state,
216 mach_port_t *portloc = (mach_port_t *) __hurd_threadvar_location_from_sp
217 (_HURD_THREADVAR_MIG_REPLY, (void *) thread_state->basic.SP);
219 if (sigthread && _hurdsig_catch_fault (SIGSEGV))
221 assert (_hurdsig_fault_sigcode == (long int) portloc);
222 /* Faulted trying to read the stack. */
226 /* Fault now if this pointer is bogus. */
227 *(volatile mach_port_t *) portloc = *portloc;
230 _hurdsig_end_catch_fault ();
235 #include <hurd/sigpreempt.h>
236 #include "intr-msg.h"
238 /* SS->thread is suspended.
240 Abort any interruptible RPC operation the thread is doing.
242 This uses only the constant member SS->thread and the unlocked, atomically
243 set member SS->intr_port, so no locking is needed.
245 If successfully sent an interrupt_operation and therefore the thread should
246 wait for its pending RPC to return (possibly EINTR) before taking the
247 incoming signal, returns the reply port to be received on. Otherwise
248 returns MACH_PORT_NULL.
250 SIGNO is used to find the applicable SA_RESTART bit. If SIGNO is zero,
251 the RPC fails with EINTR instead of restarting (thread_cancel).
253 *STATE_CHANGE is set nonzero if STATE->basic was modified and should
254 be applied back to the thread if it might ever run again, else zero. */
257 _hurdsig_abort_rpcs (struct hurd_sigstate *ss, int signo, int sigthread,
258 struct machine_thread_all_state *state, int *state_change,
259 void (*reply) (void))
261 extern const void _hurd_intr_rpc_msg_in_trap;
262 mach_port_t rcv_port = MACH_PORT_NULL;
263 mach_port_t intr_port;
267 intr_port = ss->intr_port;
268 if (intr_port == MACH_PORT_NULL)
269 /* No interruption needs done. */
270 return MACH_PORT_NULL;
272 /* Abort the thread's kernel context, so any pending message send or
273 receive completes immediately or aborts. */
274 abort_thread (ss, state, reply);
276 if (state->basic.PC < (natural_t) &_hurd_intr_rpc_msg_in_trap)
278 /* The thread is about to do the RPC, but hasn't yet entered
279 mach_msg. Mutate the thread's state so it knows not to try
281 INTR_MSG_BACK_OUT (&state->basic);
282 MACHINE_THREAD_STATE_SET_PC (&state->basic,
283 &_hurd_intr_rpc_msg_in_trap);
284 state->basic.SYSRETURN = MACH_SEND_INTERRUPTED;
287 else if (state->basic.PC == (natural_t) &_hurd_intr_rpc_msg_in_trap &&
288 /* The thread was blocked in the system call. After thread_abort,
289 the return value register indicates what state the RPC was in
291 state->basic.SYSRETURN == MACH_RCV_INTERRUPTED)
293 /* The RPC request message was sent and the thread was waiting for
294 the reply message; now the message receive has been aborted, so
295 the mach_msg call will return MACH_RCV_INTERRUPTED. We must tell
296 the server to interrupt the pending operation. The thread must
297 wait for the reply message before running the signal handler (to
298 guarantee that the operation has finished being interrupted), so
299 our nonzero return tells the trampoline code to finish the message
300 receive operation before running the handler. */
302 mach_port_t *reply = interrupted_reply_port_location (state,
304 error_t err = __interrupt_operation (intr_port);
310 /* The interrupt didn't work.
311 Destroy the receive right the thread is blocked on. */
312 __mach_port_destroy (__mach_task_self (), *reply);
313 *reply = MACH_PORT_NULL;
316 /* The system call return value register now contains
317 MACH_RCV_INTERRUPTED; when mach_msg resumes, it will retry the
318 call. Since we have just destroyed the receive right, the
319 retry will fail with MACH_RCV_INVALID_NAME. Instead, just
320 change the return value here to EINTR so mach_msg will not
321 retry and the EINTR error code will propagate up. */
322 state->basic.SYSRETURN = EINTR;
328 /* All threads whose RPCs were interrupted by the interrupt_operation
329 call above will retry their RPCs unless we clear SS->intr_port.
330 So we clear it for the thread taking a signal when SA_RESTART is
331 clear, so that its call returns EINTR. */
332 if (! signo || !(ss->actions[signo].sa_flags & SA_RESTART))
333 ss->intr_port = MACH_PORT_NULL;
340 /* Abort the RPCs being run by all threads but this one;
341 all other threads should be suspended. If LIVE is nonzero, those
342 threads may run again, so they should be adjusted as necessary to be
343 happy when resumed. STATE is clobbered as a scratch area; its initial
344 contents are ignored, and its contents on return are not useful. */
347 abort_all_rpcs (int signo, struct machine_thread_all_state *state, int live)
349 /* We can just loop over the sigstates. Any thread doing something
350 interruptible must have one. We needn't bother locking because all
351 other threads are stopped. */
353 struct hurd_sigstate *ss;
355 mach_port_t *reply_ports;
357 /* First loop over the sigstates to count them.
358 We need to know how big a vector we will need for REPLY_PORTS. */
360 for (ss = _hurd_sigstates; ss != NULL; ss = ss->next)
363 reply_ports = alloca (nthreads * sizeof *reply_ports);
366 for (ss = _hurd_sigstates; ss != NULL; ss = ss->next)
367 if (ss->thread == _hurd_msgport_thread)
368 reply_ports[nthreads++] = MACH_PORT_NULL;
372 state->set = 0; /* Reset scratch area. */
374 /* Abort any operation in progress with interrupt_operation.
375 Record the reply port the thread is waiting on.
376 We will wait for all the replies below. */
377 reply_ports[nthreads++] = _hurdsig_abort_rpcs (ss, signo, 1,
378 state, &state_changed,
380 if (state_changed && live)
381 /* Aborting the RPC needed to change this thread's state,
382 and it might ever run again. So write back its state. */
383 __thread_set_state (ss->thread, MACHINE_THREAD_STATE_FLAVOR,
384 (natural_t *) &state->basic,
385 MACHINE_THREAD_STATE_COUNT);
388 /* Wait for replies from all the successfully interrupted RPCs. */
389 while (nthreads-- > 0)
390 if (reply_ports[nthreads] != MACH_PORT_NULL)
393 mach_msg_header_t head;
394 err = __mach_msg (&head, MACH_RCV_MSG|MACH_RCV_TIMEOUT, 0, sizeof head,
395 reply_ports[nthreads],
396 _hurd_interrupted_rpc_timeout, MACH_PORT_NULL);
399 case MACH_RCV_TIMED_OUT:
400 case MACH_RCV_TOO_LARGE:
409 struct hurd_signal_preempter *_hurdsig_preempters;
410 sigset_t _hurdsig_preempted_set;
412 /* Mask of stop signals. */
413 #define STOPSIGS (sigmask (SIGTTIN) | sigmask (SIGTTOU) | \
414 sigmask (SIGSTOP) | sigmask (SIGTSTP))
416 /* Deliver a signal. SS is not locked. */
418 _hurd_internal_post_signal (struct hurd_sigstate *ss,
419 int signo, long int sigcode, int sigerror,
420 mach_port_t reply_port,
421 mach_msg_type_name_t reply_port_type,
425 struct machine_thread_all_state thread_state;
426 enum { stop, ignore, core, term, handle } act;
427 struct hurd_signal_preempter *pe;
428 sighandler_t handler;
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);
438 if (reply_port == MACH_PORT_NULL)
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. */
446 /* Mark the signal as pending. */
447 void mark_pending (void)
449 __sigaddset (&ss->pending, signo);
450 /* Save the code to be given to the handler when SIGNO is
452 ss->pending_data[signo].code = sigcode;
453 ss->pending_data[signo].error = sigerror;
456 /* Suspend the process with SIGNO. */
459 /* Stop all other threads and mark ourselves stopped. */
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);
469 __proc_mark_stop (port, signo);
473 /* Resume the process after a suspension. */
476 /* Resume the process from being stopped. */
478 mach_msg_type_number_t nthreads, i;
484 /* Tell the proc server we are continuing. */
485 __USEPORT (PROC, __proc_mark_cont (port));
486 /* Fetch ports to all our threads and resume them. */
487 err = __task_threads (__mach_task_self (), &threads, &nthreads);
489 for (i = 0; i < nthreads; ++i)
491 if (threads[i] != _hurd_msgport_thread &&
492 (act != handle || threads[i] != ss->thread))
494 err = __thread_resume (threads[i]);
497 err = __mach_port_deallocate (__mach_task_self (),
501 __vm_deallocate (__mach_task_self (),
502 (vm_address_t) threads,
503 nthreads * sizeof *threads);
505 /* The thread that will run the handler is already suspended. */
512 /* This is PTRACE_CONTINUE. */
515 /* This call is just to check for pending signals. */
516 __spin_lock (&ss->lock);
517 goto check_pending_signals;
522 thread_state.set = 0; /* We know nothing. */
524 __spin_lock (&ss->lock);
526 /* Check for a preempted signal. Preempted signals can arrive during
527 critical sections. */
530 for (pe = ss->preempters; pe && handler == SIG_ERR; pe = pe->next)
531 if (HURD_PREEMPT_SIGNAL_P (pe, signo, sigcode))
532 handler = (*pe->preempter) (pe, ss, &signo, &sigcode, &sigerror);
534 if (handler == SIG_ERR && (__sigmask (signo) & _hurdsig_preempted_set))
536 __mutex_lock (&_hurd_siglock);
537 for (pe = _hurdsig_preempters; pe && handler == SIG_ERR; pe = pe->next)
538 if (HURD_PREEMPT_SIGNAL_P (pe, signo, sigcode))
539 handler = (*pe->preempter) (pe, ss, &signo, &sigcode, &sigerror);
540 __mutex_unlock (&_hurd_siglock);
545 if (handler == SIG_IGN)
546 /* Ignore the signal altogether. */
548 if (handler != SIG_ERR)
549 /* Run the preemption-provided handler. */
553 /* No preemption. Do normal handling. */
555 if (!untraced && (_hurd_exec_flags & EXEC_TRACED))
557 /* We are being traced. Stop to tell the debugger of the signal. */
559 /* Already stopped. Mark the signal as pending;
560 when resumed, we will notice it and stop again. */
564 __spin_unlock (&ss->lock);
569 handler = ss->actions[signo].sa_handler;
571 if (handler == SIG_DFL)
572 /* Figure out the default action for this signal. */
576 /* A sig_post msg with SIGNO==0 is sent to
577 tell us to check for pending signals. */
609 if (_hurd_pgrp == _hurd_pid)
611 /* We are the process group leader. Since there is no
612 user-specified handler for SIGINFO, we use a default one
613 which prints something interesting. We use the normal
614 handler mechanism instead of just doing it here to avoid
615 the signal thread faulting or blocking in this
616 potentially hairy operation. */
618 handler = _hurd_siginfo_handler;
628 else if (handler == SIG_IGN)
633 if (__sigmask (signo) & STOPSIGS)
634 /* Stop signals clear a pending SIGCONT even if they
635 are handled or ignored (but not if preempted). */
636 ss->pending &= ~sigmask (SIGCONT);
639 if (signo == SIGCONT)
640 /* Even if handled or ignored (but not preempted), SIGCONT clears
641 stop signals and resumes the process. */
642 ss->pending &= ~STOPSIGS;
644 if (_hurd_stopped && act != stop && (untraced || signo == SIGCONT))
649 if (_hurd_orphaned && act == stop &&
650 (__sigmask (signo) & (__sigmask (SIGTTIN) | __sigmask (SIGTTOU) |
651 __sigmask (SIGTSTP))))
653 /* If we would ordinarily stop for a job control signal, but we are
654 orphaned so noone would ever notice and continue us again, we just
655 quietly die, alone and in the dark. */
661 /* Handle receipt of a blocked signal, or any signal while stopped. */
662 if (__sigismember (&ss->blocked, signo) ||
663 (signo != SIGKILL && _hurd_stopped))
669 /* Perform the chosen action for the signal. */
675 /* We are already stopped, but receiving an untraced stop
676 signal. Instead of resuming and suspending again, just
677 notify the proc server of the new stop signal. */
678 error_t err = __USEPORT (PROC, __proc_mark_stop (port, signo));
682 /* Suspend the process. */
687 /* Nobody cares about this signal. */
691 /* We got a fault setting up the stack frame for the handler.
692 Nothing to do but die; BSD gets SIGILL in this case. */
693 sigcode = signo; /* XXX ? */
698 case term: /* Time to die. */
699 case core: /* And leave a rotting corpse. */
700 /* Have the proc server stop all other threads in our task. */
701 err = __USEPORT (PROC, __proc_dostop (port, _hurd_msgport_thread));
703 /* No more user instructions will be executed.
704 The signal can now be considered delivered. */
706 /* Abort all server operations now in progress. */
707 abort_all_rpcs (signo, &thread_state, 0);
710 int status = W_EXITCODE (0, signo);
711 /* Do a core dump if desired. Only set the wait status bit saying we
712 in fact dumped core if the operation was actually successful. */
713 if (act == core && write_corefile (signo, sigcode, sigerror))
715 /* Tell proc how we died and then stick the saber in the gut. */
721 /* Call a handler for this signal. */
723 struct sigcontext *scp, ocontext;
724 int wait_for_reply, state_changed;
726 /* Stop the thread and abort its pending RPC operations. */
729 err = __thread_suspend (ss->thread);
733 /* Abort the thread's kernel context, so any pending message send
734 or receive completes immediately or aborts. If an interruptible
735 RPC is in progress, abort_rpcs will do this. But we must always
736 do it before fetching the thread's state, because
737 thread_get_state is never kosher before thread_abort. */
738 abort_thread (ss, &thread_state, NULL);
742 /* We have a previous sigcontext that sigreturn was about
743 to restore when another signal arrived. */
747 if (_hurdsig_catch_fault (SIGSEGV))
749 assert (_hurdsig_fault_sigcode >= (long int) ss->context &&
750 _hurdsig_fault_sigcode < (long int) (ss->context + 1));
751 /* We faulted reading the thread's stack. Forget that
752 context and pretend it wasn't there. It almost
753 certainly crash if this handler returns, but that's it's
759 /* Copy the context from the thread's stack before
760 we start diddling the stack to set up the handler. */
761 ocontext = *ss->context;
762 ss->context = &ocontext;
764 _hurdsig_end_catch_fault ();
766 if (! machine_get_basic_state (ss->thread, &thread_state))
768 loc = interrupted_reply_port_location (&thread_state, 1);
769 if (loc && *loc != MACH_PORT_NULL)
770 /* This is the reply port for the context which called
771 sigreturn. Since we are abandoning that context entirely
772 and restoring SS->context instead, destroy this port. */
773 __mach_port_destroy (__mach_task_self (), *loc);
775 /* The thread was in sigreturn, not in any interruptible RPC. */
778 assert (! ss->critical_section);
783 = (_hurdsig_abort_rpcs (ss, signo, 1,
784 &thread_state, &state_changed,
788 if (ss->critical_section)
790 /* The thread is in a critical section. Mark the signal as
791 pending. When it finishes the critical section, it will
792 check for pending signals. */
794 assert (! state_changed);
795 __thread_resume (ss->thread);
800 /* Call the machine-dependent function to set the thread up
801 to run the signal handler, and preserve its old context. */
802 scp = _hurd_setup_sighandler (ss, handler,
804 wait_for_reply, &thread_state);
808 /* Set the machine-independent parts of the signal context. */
811 /* Fetch the thread variable for the MiG reply port,
812 and set it to MACH_PORT_NULL. */
813 mach_port_t *loc = interrupted_reply_port_location (&thread_state,
817 scp->sc_reply_port = *loc;
818 *loc = MACH_PORT_NULL;
821 scp->sc_reply_port = MACH_PORT_NULL;
823 /* Save the intr_port in use by the interrupted code,
824 and clear the cell before running the trampoline. */
825 scp->sc_intr_port = ss->intr_port;
826 ss->intr_port = MACH_PORT_NULL;
830 /* After the handler runs we will restore to the state in
831 SS->context, not the state of the thread now. So restore
832 that context's reply port and intr port. */
834 scp->sc_reply_port = ss->context->sc_reply_port;
835 scp->sc_intr_port = ss->context->sc_intr_port;
841 /* Backdoor extra argument to signal handler. */
842 scp->sc_error = sigerror;
844 /* Block SIGNO and requested signals while running the handler. */
845 scp->sc_mask = ss->blocked;
846 ss->blocked |= __sigmask (signo) | ss->actions[signo].sa_mask;
848 /* Start the thread running the handler (or possibly waiting for an
849 RPC reply before running the handler). */
850 err = __thread_set_state (ss->thread, MACHINE_THREAD_STATE_FLAVOR,
851 (natural_t *) &thread_state.basic,
852 MACHINE_THREAD_STATE_COUNT);
854 err = __thread_resume (ss->thread);
856 thread_state.set = 0; /* Everything we know is now wrong. */
861 /* The signal has either been ignored or is now being handled. We can
862 consider it delivered and reply to the killer. */
865 /* We get here unless the signal was fatal. We still hold SS->lock.
866 Check for pending signals, and loop to post them. */
868 /* Return nonzero if SS has any signals pending we should worry about.
869 We don't worry about any pending signals if we are stopped, nor if
870 SS is in a critical section. We are guaranteed to get a sig_post
871 message before any of them become deliverable: either the SIGCONT
872 signal, or a sig_post with SIGNO==0 as an explicit poll when the
873 thread finishes its critical section. */
874 inline int signals_pending (void)
876 if (_hurd_stopped || ss->critical_section)
878 return pending = ss->pending & ~ss->blocked;
881 check_pending_signals:
884 if (signals_pending ())
887 for (signo = 1; signo < NSIG; ++signo)
888 if (__sigismember (&pending, signo))
890 __sigdelset (&ss->pending, signo);
891 sigcode = ss->pending_data[signo].code;
892 sigerror = ss->pending_data[signo].error;
893 __spin_unlock (&ss->lock);
898 /* No pending signals left undelivered for this thread.
899 If we were sent signal 0, we need to check for pending
900 signals for all threads. */
903 __spin_unlock (&ss->lock);
904 __mutex_lock (&_hurd_siglock);
905 for (ss = _hurd_sigstates; ss != NULL; ss = ss->next)
907 __spin_lock (&ss->lock);
908 if (signals_pending ())
910 __spin_unlock (&ss->lock);
912 __mutex_unlock (&_hurd_siglock);
916 /* No more signals pending; SS->lock is still locked.
917 Wake up any sigsuspend call that is blocking SS->thread. */
918 if (ss->suspended != MACH_PORT_NULL)
920 /* There is a sigsuspend waiting. Tell it to wake up. */
922 mach_msg_header_t msg;
923 err = __mach_port_insert_right (__mach_task_self (),
924 ss->suspended, ss->suspended,
925 MACH_MSG_TYPE_MAKE_SEND);
927 msg.msgh_bits = MACH_MSGH_BITS (MACH_MSG_TYPE_MOVE_SEND, 0);
928 msg.msgh_remote_port = ss->suspended;
929 msg.msgh_local_port = MACH_PORT_NULL;
930 /* These values do not matter. */
931 msg.msgh_id = 8675309; /* Jenny, Jenny. */
932 msg.msgh_seqno = 17; /* Random. */
933 ss->suspended = MACH_PORT_NULL;
934 err = __mach_msg (&msg, MACH_SEND_MSG, sizeof msg, 0,
935 MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
939 __spin_unlock (&ss->lock);
943 /* All pending signals delivered to all threads.
944 Now we can send the reply message even for signal 0. */
948 /* Decide whether REFPORT enables the sender to send us a SIGNO signal.
949 Returns zero if so, otherwise the error code to return to the sender. */
952 signal_allowed (int signo, mach_port_t refport)
954 if (signo < 0 || signo >= NSIG)
957 if (refport == __mach_task_self ())
958 /* Can send any signal. */
961 /* Avoid needing to check for this below. */
962 if (refport == MACH_PORT_NULL)
974 /* Job control signals can be sent by the controlling terminal. */
975 if (__USEPORT (CTTYID, port == refport))
981 /* A continue signal can be sent by anyone in the session. */
982 mach_port_t sessport;
983 if (! __USEPORT (PROC, __proc_getsidport (port, &sessport)))
985 __mach_port_deallocate (__mach_task_self (), sessport);
986 if (refport == sessport)
995 /* Any io object a file descriptor refers to might send us
996 one of these signals using its async ID port for REFPORT.
998 This is pretty wide open; it is not unlikely that some random
999 process can at least open for reading something we have open,
1000 get its async ID port, and send us a spurious SIGIO or SIGURG
1001 signal. But BSD is actually wider open than that!--you can set
1002 the owner of an io object to any process or process group
1003 whatsoever and send them gratuitous signals.
1005 Someday we could implement some reasonable scheme for
1006 authorizing SIGIO and SIGURG signals properly. */
1009 __mutex_lock (&_hurd_dtable_lock);
1010 for (d = 0; (unsigned int) d < (unsigned int) _hurd_dtablesize; ++d)
1012 struct hurd_userlink ulink;
1014 mach_port_t asyncid;
1015 if (_hurd_dtable[d] == NULL)
1017 port = _hurd_port_get (&_hurd_dtable[d]->port, &ulink);
1018 if (! __io_get_icky_async_id (port, &asyncid))
1020 if (refport == asyncid)
1021 /* Break out of the loop on the next iteration. */
1023 __mach_port_deallocate (__mach_task_self (), asyncid);
1025 _hurd_port_free (&_hurd_dtable[d]->port, &ulink, port);
1027 /* If we found a lucky winner, we've set D to -1 in the loop. */
1033 /* If this signal is legit, we have done `goto win' by now.
1034 When we return the error, mig deallocates REFPORT. */
1038 /* Deallocate the REFPORT send right; we are done with it. */
1039 __mach_port_deallocate (__mach_task_self (), refport);
1044 /* Implement the sig_post RPC from <hurd/msg.defs>;
1045 sent when someone wants us to get a signal. */
1047 _S_msg_sig_post (mach_port_t me,
1048 mach_port_t reply_port, mach_msg_type_name_t reply_port_type,
1050 mach_port_t refport)
1054 if (err = signal_allowed (signo, refport))
1057 /* Post the signal to the designated signal-receiving thread. This will
1058 reply when the signal can be considered delivered. */
1059 _hurd_internal_post_signal (_hurd_thread_sigstate (_hurd_sigthread),
1060 signo, 0, 0, reply_port, reply_port_type,
1061 0); /* Stop if traced. */
1063 return MIG_NO_REPLY; /* Already replied. */
1066 /* Implement the sig_post_untraced RPC from <hurd/msg.defs>;
1067 sent when the debugger wants us to really get a signal
1068 even if we are traced. */
1070 _S_msg_sig_post_untraced (mach_port_t me,
1071 mach_port_t reply_port,
1072 mach_msg_type_name_t reply_port_type,
1074 mach_port_t refport)
1078 if (err = signal_allowed (signo, refport))
1081 /* Post the signal to the designated signal-receiving thread. This will
1082 reply when the signal can be considered delivered. */
1083 _hurd_internal_post_signal (_hurd_thread_sigstate (_hurd_sigthread),
1084 signo, 0, 0, reply_port, reply_port_type,
1085 1); /* Untraced flag. */
1087 return MIG_NO_REPLY; /* Already replied. */
1090 extern void __mig_init (void *);
1092 #include <mach/task_special_ports.h>
1094 /* Initialize the message port and _hurd_sigthread and start the signal
1098 _hurdsig_init (void)
1101 vm_size_t stacksize;
1103 __mutex_init (&_hurd_siglock);
1105 err = __mach_port_allocate (__mach_task_self (),
1106 MACH_PORT_RIGHT_RECEIVE,
1108 assert_perror (err);
1110 /* Make a send right to the signal port. */
1111 err = __mach_port_insert_right (__mach_task_self (),
1114 MACH_MSG_TYPE_MAKE_SEND);
1115 assert_perror (err);
1117 /* Set the default thread to receive task-global signals
1118 to this one, the main (first) user thread. */
1119 _hurd_sigthread = __mach_thread_self ();
1121 /* Start the signal thread listening on the message port. */
1123 err = __thread_create (__mach_task_self (), &_hurd_msgport_thread);
1124 assert_perror (err);
1126 stacksize = __vm_page_size * 4; /* Small stack for signal thread. */
1127 err = __mach_setup_thread (__mach_task_self (), _hurd_msgport_thread,
1128 _hurd_msgport_receive,
1129 (vm_address_t *) &__hurd_sigthread_stack_base,
1131 assert_perror (err);
1133 __hurd_sigthread_stack_end = __hurd_sigthread_stack_base + stacksize;
1134 __hurd_sigthread_variables =
1135 malloc (__hurd_threadvar_max * sizeof (unsigned long int));
1136 if (__hurd_sigthread_variables == NULL)
1137 __libc_fatal ("hurd: Can't allocate thread variables for signal thread\n");
1139 /* Reinitialize the MiG support routines so they will use a per-thread
1140 variable for the cached reply port. */
1141 __mig_init ((void *) __hurd_sigthread_stack_base);
1143 err = __thread_resume (_hurd_msgport_thread);
1144 assert_perror (err);
1146 /* Receive exceptions on the signal port. */
1147 __task_set_special_port (__mach_task_self (),
1148 TASK_EXCEPTION_PORT, _hurd_msgport);
1151 /* Reauthenticate with the proc server. */
1154 reauth_proc (mach_port_t new)
1156 mach_port_t ref, ignore;
1158 ref = __mach_reply_port ();
1159 if (! HURD_PORT_USE (&_hurd_ports[INIT_PORT_PROC],
1160 __proc_reauthenticate (port, ref,
1161 MACH_MSG_TYPE_MAKE_SEND) ||
1162 __auth_user_authenticate (new, port, ref,
1163 MACH_MSG_TYPE_MAKE_SEND,
1165 && ignore != MACH_PORT_NULL)
1166 __mach_port_deallocate (__mach_task_self (), ignore);
1167 __mach_port_destroy (__mach_task_self (), ref);
1169 (void) &reauth_proc; /* Silence compiler warning. */
1171 text_set_element (_hurd_reauth_hook, reauth_proc);
1173 /* Like `getenv', but safe for the signal thread to run.
1174 If the environment is trashed, this will just return NULL. */
1177 _hurdsig_getenv (const char *variable)
1179 if (_hurdsig_catch_fault (SIGSEGV))
1180 /* We bombed in getenv. */
1184 const char *value = getenv (variable);
1185 /* Fault now if VALUE is a bogus string. */
1186 (void) strlen (value);
1187 _hurdsig_end_catch_fault ();