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. */
124 #include <hurd/interrupt.h>
128 int _hurd_core_limit
; /* XXX */
130 /* Call the crash dump server to mummify us before we die.
131 Returns nonzero if a core file was written. */
133 write_corefile (int signo
, long int sigcode
, int sigerror
)
136 mach_port_t coreserver
;
137 file_t file
, coredir
;
141 When we have a protocol to make the server return an error
142 for RLIMIT_FSIZE, then tell the corefile fs server the RLIMIT_CORE
143 value in place of the RLIMIT_FSIZE value. */
145 /* First get a port to the core dumping server. */
146 coreserver
= MACH_PORT_NULL
;
147 name
= _hurdsig_getenv ("CRASHSERVER");
149 coreserver
= __file_name_lookup (name
, 0, 0);
150 if (coreserver
== MACH_PORT_NULL
)
151 coreserver
= __file_name_lookup (_SERVERS_CRASH
, 0, 0);
152 if (coreserver
== MACH_PORT_NULL
)
155 /* Get a port to the directory where the new core file will reside. */
156 name
= _hurdsig_getenv ("COREFILE");
159 coredir
= __file_name_split (name
, (char **) &name
);
160 if (coredir
== MACH_PORT_NULL
)
162 /* Create the new file, but don't link it into the directory yet. */
163 if (err
= __dir_mkfile (coredir
, O_WRONLY
|O_CREAT
,
164 0600 & ~_hurd_umask
, /* XXX ? */
168 /* Call the core dumping server to write the core file. */
169 err
= __crash_dump_task (coreserver
,
171 file
, _hurdsig_getenv ("GNUTARGET"),
172 signo
, sigcode
, sigerror
);
173 __mach_port_deallocate (__mach_task_self (), coreserver
);
175 /* The core dump into FILE succeeded, so now link it into the
177 err
= __dir_link (file
, coredir
, name
);
178 __mach_port_deallocate (__mach_task_self (), file
);
179 __mach_port_deallocate (__mach_task_self (), coredir
);
184 /* The lowest-numbered thread state flavor value is 1,
185 so we use bit 0 in machine_thread_all_state.set to
186 record whether we have done thread_abort. */
187 #define THREAD_ABORTED 1
189 /* SS->thread is suspended. Abort the thread and get its basic state. */
191 abort_thread (struct hurd_sigstate
*ss
, struct machine_thread_all_state
*state
,
192 void (*reply
) (void))
194 if (!(state
->set
& THREAD_ABORTED
))
196 error_t err
= __thread_abort (ss
->thread
);
198 /* Clear all thread state flavor set bits, because thread_abort may
199 have changed the state. */
200 state
->set
= THREAD_ABORTED
;
206 machine_get_basic_state (ss
->thread
, state
);
209 /* Find the location of the MiG reply port cell in use by the thread whose
210 state is described by THREAD_STATE. If SIGTHREAD is nonzero, make sure
211 that this location can be set without faulting, or else return NULL. */
214 interrupted_reply_port_location (struct machine_thread_all_state
*thread_state
,
217 mach_port_t
*portloc
= (mach_port_t
*) __hurd_threadvar_location_from_sp
218 (_HURD_THREADVAR_MIG_REPLY
, (void *) thread_state
->basic
.SP
);
220 if (sigthread
&& _hurdsig_catch_memory_fault (portloc
))
221 /* Faulted trying to read the stack. */
224 /* Fault now if this pointer is bogus. */
225 *(volatile mach_port_t
*) portloc
= *portloc
;
228 _hurdsig_end_catch_fault ();
233 #include <hurd/sigpreempt.h>
234 #include "intr-msg.h"
236 /* Timeout on interrupt_operation calls. */
237 mach_msg_timeout_t _hurdsig_interrupt_timeout
= 1000;
239 /* SS->thread is suspended.
241 Abort any interruptible RPC operation the thread is doing.
243 This uses only the constant member SS->thread and the unlocked, atomically
244 set member SS->intr_port, so no locking is needed.
246 If successfully sent an interrupt_operation and therefore the thread should
247 wait for its pending RPC to return (possibly EINTR) before taking the
248 incoming signal, returns the reply port to be received on. Otherwise
249 returns MACH_PORT_NULL.
251 SIGNO is used to find the applicable SA_RESTART bit. If SIGNO is zero,
252 the RPC fails with EINTR instead of restarting (thread_cancel).
254 *STATE_CHANGE is set nonzero if STATE->basic was modified and should
255 be applied back to the thread if it might ever run again, else zero. */
258 _hurdsig_abort_rpcs (struct hurd_sigstate
*ss
, int signo
, int sigthread
,
259 struct machine_thread_all_state
*state
, int *state_change
,
260 void (*reply
) (void))
262 extern const void _hurd_intr_rpc_msg_in_trap
;
263 mach_port_t rcv_port
= MACH_PORT_NULL
;
264 mach_port_t intr_port
;
268 intr_port
= ss
->intr_port
;
269 if (intr_port
== MACH_PORT_NULL
)
270 /* No interruption needs done. */
271 return MACH_PORT_NULL
;
273 /* Abort the thread's kernel context, so any pending message send or
274 receive completes immediately or aborts. */
275 abort_thread (ss
, state
, reply
);
277 if (state
->basic
.PC
< (natural_t
) &_hurd_intr_rpc_msg_in_trap
)
279 /* The thread is about to do the RPC, but hasn't yet entered
280 mach_msg. Mutate the thread's state so it knows not to try
282 INTR_MSG_BACK_OUT (&state
->basic
);
283 MACHINE_THREAD_STATE_SET_PC (&state
->basic
,
284 &_hurd_intr_rpc_msg_in_trap
);
285 state
->basic
.SYSRETURN
= MACH_SEND_INTERRUPTED
;
288 else if (state
->basic
.PC
== (natural_t
) &_hurd_intr_rpc_msg_in_trap
&&
289 /* The thread was blocked in the system call. After thread_abort,
290 the return value register indicates what state the RPC was in
292 state
->basic
.SYSRETURN
== MACH_RCV_INTERRUPTED
)
294 /* The RPC request message was sent and the thread was waiting for
295 the reply message; now the message receive has been aborted, so
296 the mach_msg call will return MACH_RCV_INTERRUPTED. We must tell
297 the server to interrupt the pending operation. The thread must
298 wait for the reply message before running the signal handler (to
299 guarantee that the operation has finished being interrupted), so
300 our nonzero return tells the trampoline code to finish the message
301 receive operation before running the handler. */
303 mach_port_t
*reply
= interrupted_reply_port_location (state
,
305 error_t err
= __interrupt_operation (intr_port
, _hurdsig_interrupt_timeout
);
311 /* The interrupt didn't work.
312 Destroy the receive right the thread is blocked on. */
313 __mach_port_destroy (__mach_task_self (), *reply
);
314 *reply
= MACH_PORT_NULL
;
317 /* The system call return value register now contains
318 MACH_RCV_INTERRUPTED; when mach_msg resumes, it will retry the
319 call. Since we have just destroyed the receive right, the
320 retry will fail with MACH_RCV_INVALID_NAME. Instead, just
321 change the return value here to EINTR so mach_msg will not
322 retry and the EINTR error code will propagate up. */
323 state
->basic
.SYSRETURN
= EINTR
;
329 /* All threads whose RPCs were interrupted by the interrupt_operation
330 call above will retry their RPCs unless we clear SS->intr_port.
331 So we clear it for the thread taking a signal when SA_RESTART is
332 clear, so that its call returns EINTR. */
333 if (! signo
|| !(ss
->actions
[signo
].sa_flags
& SA_RESTART
))
334 ss
->intr_port
= MACH_PORT_NULL
;
341 /* Abort the RPCs being run by all threads but this one;
342 all other threads should be suspended. If LIVE is nonzero, those
343 threads may run again, so they should be adjusted as necessary to be
344 happy when resumed. STATE is clobbered as a scratch area; its initial
345 contents are ignored, and its contents on return are not useful. */
348 abort_all_rpcs (int signo
, struct machine_thread_all_state
*state
, int live
)
350 /* We can just loop over the sigstates. Any thread doing something
351 interruptible must have one. We needn't bother locking because all
352 other threads are stopped. */
354 struct hurd_sigstate
*ss
;
356 mach_port_t
*reply_ports
;
358 /* First loop over the sigstates to count them.
359 We need to know how big a vector we will need for REPLY_PORTS. */
361 for (ss
= _hurd_sigstates
; ss
!= NULL
; ss
= ss
->next
)
364 reply_ports
= alloca (nthreads
* sizeof *reply_ports
);
367 for (ss
= _hurd_sigstates
; ss
!= NULL
; ss
= ss
->next
, ++nthreads
)
368 if (ss
->thread
== _hurd_msgport_thread
)
369 reply_ports
[nthreads
] = MACH_PORT_NULL
;
373 state
->set
= 0; /* Reset scratch area. */
375 /* Abort any operation in progress with interrupt_operation.
376 Record the reply port the thread is waiting on.
377 We will wait for all the replies below. */
378 reply_ports
[nthreads
] = _hurdsig_abort_rpcs (ss
, signo
, 1,
379 state
, &state_changed
,
383 if (reply_ports
[nthreads
] != MACH_PORT_NULL
)
385 /* We will wait for the reply to this RPC below, so the
386 thread must issue a new RPC rather than waiting for the
387 reply to the one it sent. */
388 state
->basic
.SYSRETURN
= EINTR
;
392 /* Aborting the RPC needed to change this thread's state,
393 and it might ever run again. So write back its state. */
394 __thread_set_state (ss
->thread
, MACHINE_THREAD_STATE_FLAVOR
,
395 (natural_t
*) &state
->basic
,
396 MACHINE_THREAD_STATE_COUNT
);
400 /* Wait for replies from all the successfully interrupted RPCs. */
401 while (nthreads
-- > 0)
402 if (reply_ports
[nthreads
] != MACH_PORT_NULL
)
405 mach_msg_header_t head
;
406 err
= __mach_msg (&head
, MACH_RCV_MSG
|MACH_RCV_TIMEOUT
, 0, sizeof head
,
407 reply_ports
[nthreads
],
408 _hurd_interrupted_rpc_timeout
, MACH_PORT_NULL
);
411 case MACH_RCV_TIMED_OUT
:
412 case MACH_RCV_TOO_LARGE
:
421 struct hurd_signal_preempter
*_hurdsig_preempters
;
422 sigset_t _hurdsig_preempted_set
;
424 /* Mask of stop signals. */
425 #define STOPSIGS (sigmask (SIGTTIN) | sigmask (SIGTTOU) | \
426 sigmask (SIGSTOP) | sigmask (SIGTSTP))
428 /* Deliver a signal. SS is not locked. */
430 _hurd_internal_post_signal (struct hurd_sigstate
*ss
,
431 int signo
, struct hurd_signal_detail
*detail
,
432 mach_port_t reply_port
,
433 mach_msg_type_name_t reply_port_type
,
437 struct machine_thread_all_state thread_state
;
438 enum { stop
, ignore
, core
, term
, handle
} act
;
439 struct hurd_signal_preempter
*pe
;
440 sighandler_t handler
;
444 /* Reply to this sig_post message. */
445 __typeof (__msg_sig_post_reply
) *reply_rpc
446 = (untraced
? __msg_sig_post_untraced_reply
: __msg_sig_post_reply
);
450 if (reply_port
== MACH_PORT_NULL
)
452 err
= (*reply_rpc
) (reply_port
, reply_port_type
, 0);
453 reply_port
= MACH_PORT_NULL
;
454 if (err
!= MACH_SEND_INVALID_DEST
) /* Ignore dead reply port. */
458 /* Mark the signal as pending. */
459 void mark_pending (void)
461 __sigaddset (&ss
->pending
, signo
);
462 /* Save the details to be given to the handler when SIGNO is
464 ss
->pending_data
[signo
] = *detail
;
467 /* Suspend the process with SIGNO. */
470 /* Stop all other threads and mark ourselves stopped. */
473 /* Hold the siglock while stopping other threads to be
474 sure it is not held by another thread afterwards. */
475 __mutex_lock (&_hurd_siglock
);
476 __proc_dostop (port
, _hurd_msgport_thread
);
477 __mutex_unlock (&_hurd_siglock
);
478 abort_all_rpcs (signo
, &thread_state
, 1);
480 __proc_mark_stop (port
, signo
);
484 /* Resume the process after a suspension. */
487 /* Resume the process from being stopped. */
489 mach_msg_type_number_t nthreads
, i
;
495 /* Tell the proc server we are continuing. */
496 __USEPORT (PROC
, __proc_mark_cont (port
));
497 /* Fetch ports to all our threads and resume them. */
498 err
= __task_threads (__mach_task_self (), &threads
, &nthreads
);
500 for (i
= 0; i
< nthreads
; ++i
)
502 if (threads
[i
] != _hurd_msgport_thread
&&
503 (act
!= handle
|| threads
[i
] != ss
->thread
))
505 err
= __thread_resume (threads
[i
]);
508 err
= __mach_port_deallocate (__mach_task_self (),
512 __vm_deallocate (__mach_task_self (),
513 (vm_address_t
) threads
,
514 nthreads
* sizeof *threads
);
516 /* The thread that will run the handler is already suspended. */
523 /* This is PTRACE_CONTINUE. */
526 /* This call is just to check for pending signals. */
527 __spin_lock (&ss
->lock
);
528 goto check_pending_signals
;
533 thread_state
.set
= 0; /* We know nothing. */
535 __spin_lock (&ss
->lock
);
537 /* Check for a preempted signal. Preempted signals can arrive during
538 critical sections. */
541 for (pe
= ss
->preempters
; pe
&& handler
== SIG_ERR
; pe
= pe
->next
)
542 if (HURD_PREEMPT_SIGNAL_P (pe
, signo
, detail
->code
))
543 handler
= (*pe
->preempter
) (pe
, ss
, &signo
, detail
);
545 if (handler
== SIG_ERR
&& (__sigmask (signo
) & _hurdsig_preempted_set
))
547 __mutex_lock (&_hurd_siglock
);
548 for (pe
= _hurdsig_preempters
; pe
&& handler
== SIG_ERR
; pe
= pe
->next
)
549 if (HURD_PREEMPT_SIGNAL_P (pe
, signo
, sigcode
))
550 handler
= (*pe
->preempter
) (pe
, ss
, &signo
, &sigcode
, &sigerror
);
551 __mutex_unlock (&_hurd_siglock
);
556 if (handler
== SIG_IGN
)
557 /* Ignore the signal altogether. */
559 if (handler
!= SIG_ERR
)
560 /* Run the preemption-provided handler. */
564 /* No preemption. Do normal handling. */
566 if (!untraced
&& __sigismember (&_hurdsig_traced
, signo
))
568 /* We are being traced. Stop to tell the debugger of the signal. */
570 /* Already stopped. Mark the signal as pending;
571 when resumed, we will notice it and stop again. */
575 __spin_unlock (&ss
->lock
);
580 handler
= ss
->actions
[signo
].sa_handler
;
582 if (handler
== SIG_DFL
)
583 /* Figure out the default action for this signal. */
587 /* A sig_post msg with SIGNO==0 is sent to
588 tell us to check for pending signals. */
620 if (_hurd_pgrp
== _hurd_pid
)
622 /* We are the process group leader. Since there is no
623 user-specified handler for SIGINFO, we use a default one
624 which prints something interesting. We use the normal
625 handler mechanism instead of just doing it here to avoid
626 the signal thread faulting or blocking in this
627 potentially hairy operation. */
629 handler
= _hurd_siginfo_handler
;
639 else if (handler
== SIG_IGN
)
644 if (__sigmask (signo
) & STOPSIGS
)
645 /* Stop signals clear a pending SIGCONT even if they
646 are handled or ignored (but not if preempted). */
647 ss
->pending
&= ~sigmask (SIGCONT
);
650 if (signo
== SIGCONT
)
651 /* Even if handled or ignored (but not preempted), SIGCONT clears
652 stop signals and resumes the process. */
653 ss
->pending
&= ~STOPSIGS
;
655 if (_hurd_stopped
&& act
!= stop
&& (untraced
|| signo
== SIGCONT
))
660 if (_hurd_orphaned
&& act
== stop
&&
661 (__sigmask (signo
) & (__sigmask (SIGTTIN
) | __sigmask (SIGTTOU
) |
662 __sigmask (SIGTSTP
))))
664 /* If we would ordinarily stop for a job control signal, but we are
665 orphaned so noone would ever notice and continue us again, we just
666 quietly die, alone and in the dark. */
672 /* Handle receipt of a blocked signal, or any signal while stopped. */
673 if (__sigismember (&ss
->blocked
, signo
) ||
674 (signo
!= SIGKILL
&& _hurd_stopped
))
680 /* Perform the chosen action for the signal. */
686 /* We are already stopped, but receiving an untraced stop
687 signal. Instead of resuming and suspending again, just
688 notify the proc server of the new stop signal. */
689 error_t err
= __USEPORT (PROC
, __proc_mark_stop (port
, signo
));
693 /* Suspend the process. */
698 /* Nobody cares about this signal. */
702 /* We got a fault setting up the stack frame for the handler.
703 Nothing to do but die; BSD gets SIGILL in this case. */
704 sigcode
= signo
; /* XXX ? */
709 case term
: /* Time to die. */
710 case core
: /* And leave a rotting corpse. */
711 /* Have the proc server stop all other threads in our task. */
712 err
= __USEPORT (PROC
, __proc_dostop (port
, _hurd_msgport_thread
));
714 /* No more user instructions will be executed.
715 The signal can now be considered delivered. */
717 /* Abort all server operations now in progress. */
718 abort_all_rpcs (signo
, &thread_state
, 0);
721 int status
= W_EXITCODE (0, signo
);
722 /* Do a core dump if desired. Only set the wait status bit saying we
723 in fact dumped core if the operation was actually successful. */
724 if (act
== core
&& write_corefile (signo
, sigcode
, sigerror
))
726 /* Tell proc how we died and then stick the saber in the gut. */
732 /* Call a handler for this signal. */
734 struct sigcontext
*scp
, ocontext
;
735 int wait_for_reply
, state_changed
;
737 /* Stop the thread and abort its pending RPC operations. */
740 err
= __thread_suspend (ss
->thread
);
744 /* Abort the thread's kernel context, so any pending message send
745 or receive completes immediately or aborts. If an interruptible
746 RPC is in progress, abort_rpcs will do this. But we must always
747 do it before fetching the thread's state, because
748 thread_get_state is never kosher before thread_abort. */
749 abort_thread (ss
, &thread_state
, NULL
);
753 /* We have a previous sigcontext that sigreturn was about
754 to restore when another signal arrived. */
758 if (_hurdsig_catch_memory_fault (ss
->context
))
760 /* We faulted reading the thread's stack. Forget that
761 context and pretend it wasn't there. It almost
762 certainly crash if this handler returns, but that's it's
768 /* Copy the context from the thread's stack before
769 we start diddling the stack to set up the handler. */
770 ocontext
= *ss
->context
;
771 ss
->context
= &ocontext
;
773 _hurdsig_end_catch_fault ();
775 if (! machine_get_basic_state (ss
->thread
, &thread_state
))
777 loc
= interrupted_reply_port_location (&thread_state
, 1);
778 if (loc
&& *loc
!= MACH_PORT_NULL
)
779 /* This is the reply port for the context which called
780 sigreturn. Since we are abandoning that context entirely
781 and restoring SS->context instead, destroy this port. */
782 __mach_port_destroy (__mach_task_self (), *loc
);
784 /* The thread was in sigreturn, not in any interruptible RPC. */
787 assert (! __spin_lock_locked (&ss
->critical_section_lock
));
792 = (_hurdsig_abort_rpcs (ss
, signo
, 1,
793 &thread_state
, &state_changed
,
797 if (__spin_lock_locked (&ss
->critical_section_lock
))
799 /* The thread is in a critical section. Mark the signal as
800 pending. When it finishes the critical section, it will
801 check for pending signals. */
803 assert (! state_changed
);
804 __thread_resume (ss
->thread
);
809 /* Call the machine-dependent function to set the thread up
810 to run the signal handler, and preserve its old context. */
811 scp
= _hurd_setup_sighandler (ss
, handler
,
813 wait_for_reply
, &thread_state
);
817 /* Set the machine-independent parts of the signal context. */
820 /* Fetch the thread variable for the MiG reply port,
821 and set it to MACH_PORT_NULL. */
822 mach_port_t
*loc
= interrupted_reply_port_location (&thread_state
,
826 scp
->sc_reply_port
= *loc
;
827 *loc
= MACH_PORT_NULL
;
830 scp
->sc_reply_port
= MACH_PORT_NULL
;
832 /* Save the intr_port in use by the interrupted code,
833 and clear the cell before running the trampoline. */
834 scp
->sc_intr_port
= ss
->intr_port
;
835 ss
->intr_port
= MACH_PORT_NULL
;
839 /* After the handler runs we will restore to the state in
840 SS->context, not the state of the thread now. So restore
841 that context's reply port and intr port. */
843 scp
->sc_reply_port
= ss
->context
->sc_reply_port
;
844 scp
->sc_intr_port
= ss
->context
->sc_intr_port
;
850 /* Backdoor extra argument to signal handler. */
851 scp
->sc_error
= sigerror
;
853 /* Block SIGNO and requested signals while running the handler. */
854 scp
->sc_mask
= ss
->blocked
;
855 ss
->blocked
|= __sigmask (signo
) | ss
->actions
[signo
].sa_mask
;
857 /* Start the thread running the handler (or possibly waiting for an
858 RPC reply before running the handler). */
859 err
= __thread_set_state (ss
->thread
, MACHINE_THREAD_STATE_FLAVOR
,
860 (natural_t
*) &thread_state
.basic
,
861 MACHINE_THREAD_STATE_COUNT
);
863 err
= __thread_resume (ss
->thread
);
865 thread_state
.set
= 0; /* Everything we know is now wrong. */
870 /* The signal has either been ignored or is now being handled. We can
871 consider it delivered and reply to the killer. */
874 /* We get here unless the signal was fatal. We still hold SS->lock.
875 Check for pending signals, and loop to post them. */
877 /* Return nonzero if SS has any signals pending we should worry about.
878 We don't worry about any pending signals if we are stopped, nor if
879 SS is in a critical section. We are guaranteed to get a sig_post
880 message before any of them become deliverable: either the SIGCONT
881 signal, or a sig_post with SIGNO==0 as an explicit poll when the
882 thread finishes its critical section. */
883 inline int signals_pending (void)
885 if (_hurd_stopped
|| __spin_lock_locked (&ss
->critical_section_lock
))
887 return pending
= ss
->pending
& ~ss
->blocked
;
890 check_pending_signals
:
893 if (signals_pending ())
896 for (signo
= 1; signo
< NSIG
; ++signo
)
897 if (__sigismember (&pending
, signo
))
899 __sigdelset (&ss
->pending
, signo
);
900 sigcode
= ss
->pending_data
[signo
].code
;
901 sigerror
= ss
->pending_data
[signo
].error
;
902 __spin_unlock (&ss
->lock
);
907 /* No pending signals left undelivered for this thread.
908 If we were sent signal 0, we need to check for pending
909 signals for all threads. */
912 __spin_unlock (&ss
->lock
);
913 __mutex_lock (&_hurd_siglock
);
914 for (ss
= _hurd_sigstates
; ss
!= NULL
; ss
= ss
->next
)
916 __spin_lock (&ss
->lock
);
917 if (signals_pending ())
919 __spin_unlock (&ss
->lock
);
921 __mutex_unlock (&_hurd_siglock
);
925 /* No more signals pending; SS->lock is still locked.
926 Wake up any sigsuspend call that is blocking SS->thread. */
927 if (ss
->suspended
!= MACH_PORT_NULL
)
929 /* There is a sigsuspend waiting. Tell it to wake up. */
931 mach_msg_header_t msg
;
932 err
= __mach_port_insert_right (__mach_task_self (),
933 ss
->suspended
, ss
->suspended
,
934 MACH_MSG_TYPE_MAKE_SEND
);
936 msg
.msgh_bits
= MACH_MSGH_BITS (MACH_MSG_TYPE_MOVE_SEND
, 0);
937 msg
.msgh_remote_port
= ss
->suspended
;
938 msg
.msgh_local_port
= MACH_PORT_NULL
;
939 /* These values do not matter. */
940 msg
.msgh_id
= 8675309; /* Jenny, Jenny. */
941 msg
.msgh_seqno
= 17; /* Random. */
942 ss
->suspended
= MACH_PORT_NULL
;
943 err
= __mach_msg (&msg
, MACH_SEND_MSG
, sizeof msg
, 0,
944 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
948 __spin_unlock (&ss
->lock
);
952 /* All pending signals delivered to all threads.
953 Now we can send the reply message even for signal 0. */
957 /* Decide whether REFPORT enables the sender to send us a SIGNO signal.
958 Returns zero if so, otherwise the error code to return to the sender. */
961 signal_allowed (int signo
, mach_port_t refport
)
963 if (signo
< 0 || signo
>= NSIG
)
966 if (refport
== __mach_task_self ())
967 /* Can send any signal. */
970 /* Avoid needing to check for this below. */
971 if (refport
== MACH_PORT_NULL
)
983 /* Job control signals can be sent by the controlling terminal. */
984 if (__USEPORT (CTTYID
, port
== refport
))
990 /* A continue signal can be sent by anyone in the session. */
991 mach_port_t sessport
;
992 if (! __USEPORT (PROC
, __proc_getsidport (port
, &sessport
)))
994 __mach_port_deallocate (__mach_task_self (), sessport
);
995 if (refport
== sessport
)
1004 /* Any io object a file descriptor refers to might send us
1005 one of these signals using its async ID port for REFPORT.
1007 This is pretty wide open; it is not unlikely that some random
1008 process can at least open for reading something we have open,
1009 get its async ID port, and send us a spurious SIGIO or SIGURG
1010 signal. But BSD is actually wider open than that!--you can set
1011 the owner of an io object to any process or process group
1012 whatsoever and send them gratuitous signals.
1014 Someday we could implement some reasonable scheme for
1015 authorizing SIGIO and SIGURG signals properly. */
1018 int lucky
= 0; /* True if we find a match for REFPORT. */
1019 __mutex_lock (&_hurd_dtable_lock
);
1020 for (d
= 0; !lucky
&& (unsigned) d
< (unsigned) _hurd_dtablesize
; ++d
)
1022 struct hurd_userlink ulink
;
1024 mach_port_t asyncid
;
1025 if (_hurd_dtable
[d
] == NULL
)
1027 port
= _hurd_port_get (&_hurd_dtable
[d
]->port
, &ulink
);
1028 if (! __io_get_icky_async_id (port
, &asyncid
))
1030 if (refport
== asyncid
)
1031 /* Break out of the loop on the next iteration. */
1033 __mach_port_deallocate (__mach_task_self (), asyncid
);
1035 _hurd_port_free (&_hurd_dtable
[d
]->port
, &ulink
, port
);
1037 /* If we found a lucky winner, we've set D to -1 in the loop. */
1043 /* If this signal is legit, we have done `goto win' by now.
1044 When we return the error, mig deallocates REFPORT. */
1048 /* Deallocate the REFPORT send right; we are done with it. */
1049 __mach_port_deallocate (__mach_task_self (), refport
);
1054 /* Implement the sig_post RPC from <hurd/msg.defs>;
1055 sent when someone wants us to get a signal. */
1057 _S_msg_sig_post (mach_port_t me
,
1058 mach_port_t reply_port
, mach_msg_type_name_t reply_port_type
,
1059 int signo
, natural_t sigcode
,
1060 mach_port_t refport
)
1063 struct hurd_signal_detail d
;
1065 if (err
= signal_allowed (signo
, refport
))
1071 /* Post the signal to the designated signal-receiving thread. This will
1072 reply when the signal can be considered delivered. */
1073 _hurd_internal_post_signal (_hurd_thread_sigstate (_hurd_sigthread
),
1074 signo
, &d
, reply_port
, reply_port_type
,
1075 0); /* Stop if traced. */
1077 return MIG_NO_REPLY
; /* Already replied. */
1080 /* Implement the sig_post_untraced RPC from <hurd/msg.defs>;
1081 sent when the debugger wants us to really get a signal
1082 even if we are traced. */
1084 _S_msg_sig_post_untraced (mach_port_t me
,
1085 mach_port_t reply_port
,
1086 mach_msg_type_name_t reply_port_type
,
1087 int signo
, natural_t sigcode
,
1088 mach_port_t refport
)
1091 struct hurd_signal_detail d
;
1093 if (err
= signal_allowed (signo
, refport
))
1099 /* Post the signal to the designated signal-receiving thread. This will
1100 reply when the signal can be considered delivered. */
1101 _hurd_internal_post_signal (_hurd_thread_sigstate (_hurd_sigthread
),
1102 signo
, &d
, reply_port
, reply_port_type
,
1103 1); /* Untraced flag. */
1105 return MIG_NO_REPLY
; /* Already replied. */
1108 extern void __mig_init (void *);
1110 #include <mach/task_special_ports.h>
1112 /* Initialize the message port and _hurd_sigthread and start the signal
1116 _hurdsig_init (void)
1119 vm_size_t stacksize
;
1121 __mutex_init (&_hurd_siglock
);
1123 err
= __mach_port_allocate (__mach_task_self (),
1124 MACH_PORT_RIGHT_RECEIVE
,
1126 assert_perror (err
);
1128 /* Make a send right to the signal port. */
1129 err
= __mach_port_insert_right (__mach_task_self (),
1132 MACH_MSG_TYPE_MAKE_SEND
);
1133 assert_perror (err
);
1135 /* Set the default thread to receive task-global signals
1136 to this one, the main (first) user thread. */
1137 _hurd_sigthread
= __mach_thread_self ();
1139 /* Start the signal thread listening on the message port. */
1141 err
= __thread_create (__mach_task_self (), &_hurd_msgport_thread
);
1142 assert_perror (err
);
1144 stacksize
= __vm_page_size
* 4; /* Small stack for signal thread. */
1145 err
= __mach_setup_thread (__mach_task_self (), _hurd_msgport_thread
,
1146 _hurd_msgport_receive
,
1147 (vm_address_t
*) &__hurd_sigthread_stack_base
,
1149 assert_perror (err
);
1151 __hurd_sigthread_stack_end
= __hurd_sigthread_stack_base
+ stacksize
;
1152 __hurd_sigthread_variables
=
1153 malloc (__hurd_threadvar_max
* sizeof (unsigned long int));
1154 if (__hurd_sigthread_variables
== NULL
)
1155 __libc_fatal ("hurd: Can't allocate thread variables for signal thread\n");
1157 /* Reinitialize the MiG support routines so they will use a per-thread
1158 variable for the cached reply port. */
1159 __mig_init ((void *) __hurd_sigthread_stack_base
);
1161 err
= __thread_resume (_hurd_msgport_thread
);
1162 assert_perror (err
);
1164 /* Receive exceptions on the signal port. */
1165 __task_set_special_port (__mach_task_self (),
1166 TASK_EXCEPTION_PORT
, _hurd_msgport
);
1169 /* Reauthenticate with the proc server. */
1172 reauth_proc (mach_port_t
new)
1174 mach_port_t ref
, ignore
;
1176 ref
= __mach_reply_port ();
1177 if (! HURD_PORT_USE (&_hurd_ports
[INIT_PORT_PROC
],
1178 __proc_reauthenticate (port
, ref
,
1179 MACH_MSG_TYPE_MAKE_SEND
) ||
1180 __auth_user_authenticate (new, ref
,
1181 MACH_MSG_TYPE_MAKE_SEND
,
1183 && ignore
!= MACH_PORT_NULL
)
1184 __mach_port_deallocate (__mach_task_self (), ignore
);
1185 __mach_port_destroy (__mach_task_self (), ref
);
1187 (void) &reauth_proc
; /* Silence compiler warning. */
1189 text_set_element (_hurd_reauth_hook
, reauth_proc
);
1191 /* Like `getenv', but safe for the signal thread to run.
1192 If the environment is trashed, this will just return NULL. */
1195 _hurdsig_getenv (const char *variable
)
1197 if (_hurdsig_catch_memory_fault (__environ
))
1198 /* We bombed in getenv. */
1202 const size_t len
= strlen (variable
);
1204 char *volatile *ep
= __environ
;
1207 const char *p
= *ep
;
1208 _hurdsig_fault_preempter
.first
= (long int) p
;
1209 _hurdsig_fault_preempter
.last
= VM_MAX_ADDRESS
;
1210 if (! strncmp (p
, variable
, len
) && p
[len
] == '=')
1215 valuelen
= strlen (p
);
1216 _hurdsig_fault_preempter
.last
= (long int) (p
+ valuelen
);
1217 value
= malloc (++valuelen
);
1219 memcpy (value
, p
, valuelen
);
1222 _hurdsig_fault_preempter
.first
= (long int) ++ep
;
1223 _hurdsig_fault_preempter
.last
= (long int) (ep
+ 1);
1225 _hurdsig_end_catch_fault ();