1 /* Copyright (C) 1991-2019 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 Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the 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 Lesser General Public License for more details.
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <http://www.gnu.org/licenses/>. */
22 #include <cthreads.h> /* For `struct mutex'. */
25 #include <mach/thread_switch.h>
26 #include <mach/mig_support.h>
30 #include <hurd/signal.h>
32 #include "hurdfault.h"
33 #include "hurdmalloc.h" /* XXX */
34 #include "../locale/localeinfo.h"
36 #include <libc-diag.h>
38 const char *_hurdsig_getenv (const char *);
40 struct mutex _hurd_siglock
;
43 /* Port that receives signals and other miscellaneous messages. */
44 mach_port_t _hurd_msgport
;
46 /* Thread listening on it. */
47 thread_t _hurd_msgport_thread
;
49 /* Thread which receives task-global signals. */
50 thread_t _hurd_sigthread
;
52 /* These are set up by _hurdsig_init. */
53 unsigned long int __hurd_sigthread_stack_base
;
54 unsigned long int __hurd_sigthread_stack_end
;
56 /* Linked-list of per-thread signal state. */
57 struct hurd_sigstate
*_hurd_sigstates
;
59 /* Timeout for RPC's after interrupt_operation. */
60 mach_msg_timeout_t _hurd_interrupted_rpc_timeout
= 60000;
63 default_sigaction (struct sigaction actions
[NSIG
])
67 __sigemptyset (&actions
[0].sa_mask
);
68 actions
[0].sa_flags
= SA_RESTART
;
69 actions
[0].sa_handler
= SIG_DFL
;
71 for (signo
= 1; signo
< NSIG
; ++signo
)
72 actions
[signo
] = actions
[0];
75 struct hurd_sigstate
*
76 _hurd_thread_sigstate (thread_t thread
)
78 struct hurd_sigstate
*ss
;
79 __mutex_lock (&_hurd_siglock
);
80 for (ss
= _hurd_sigstates
; ss
!= NULL
; ss
= ss
->next
)
81 if (ss
->thread
== thread
)
85 ss
= malloc (sizeof (*ss
));
87 __libc_fatal ("hurd: Can't allocate thread sigstate\n");
89 __spin_lock_init (&ss
->lock
);
91 /* Initialize default state. */
92 __sigemptyset (&ss
->blocked
);
93 __sigemptyset (&ss
->pending
);
94 memset (&ss
->sigaltstack
, 0, sizeof (ss
->sigaltstack
));
95 ss
->sigaltstack
.ss_flags
|= SS_DISABLE
;
96 ss
->preemptors
= NULL
;
97 ss
->suspended
= MACH_PORT_NULL
;
98 ss
->intr_port
= MACH_PORT_NULL
;
101 /* Initialize the sigaction vector from the default signal receiving
102 thread's state, and its from the system defaults. */
103 if (thread
== _hurd_sigthread
)
104 default_sigaction (ss
->actions
);
107 struct hurd_sigstate
*s
;
108 for (s
= _hurd_sigstates
; s
!= NULL
; s
= s
->next
)
109 if (s
->thread
== _hurd_sigthread
)
113 __spin_lock (&s
->lock
);
114 memcpy (ss
->actions
, s
->actions
, sizeof (s
->actions
));
115 __spin_unlock (&s
->lock
);
118 default_sigaction (ss
->actions
);
121 ss
->next
= _hurd_sigstates
;
122 _hurd_sigstates
= ss
;
124 __mutex_unlock (&_hurd_siglock
);
127 libc_hidden_def (_hurd_thread_sigstate
)
129 /* Signal delivery itself is on this page. */
132 #include <hurd/crash.h>
133 #include <hurd/resource.h>
134 #include <hurd/paths.h>
137 #include <sys/wait.h>
138 #include <thread_state.h>
139 #include <hurd/msg_server.h>
140 #include <hurd/msg_reply.h> /* For __msg_sig_post_reply. */
141 #include <hurd/interrupt.h>
146 /* Call the crash dump server to mummify us before we die.
147 Returns nonzero if a core file was written. */
149 write_corefile (int signo
, const struct hurd_signal_detail
*detail
)
152 mach_port_t coreserver
;
153 file_t file
, coredir
;
156 /* Don't bother locking since we just read the one word. */
157 rlim_t corelimit
= _hurd_rlimits
[RLIMIT_CORE
].rlim_cur
;
160 /* No core dumping, thank you very much. Note that this makes
161 `ulimit -c 0' prevent crash-suspension too, which is probably
162 what the user wanted. */
166 When we have a protocol to make the server return an error
167 for RLIMIT_FSIZE, then tell the corefile fs server the RLIMIT_CORE
168 value in place of the RLIMIT_FSIZE value. */
170 /* First get a port to the core dumping server. */
171 coreserver
= MACH_PORT_NULL
;
172 name
= _hurdsig_getenv ("CRASHSERVER");
174 coreserver
= __file_name_lookup (name
, 0, 0);
175 if (coreserver
== MACH_PORT_NULL
)
176 coreserver
= __file_name_lookup (_SERVERS_CRASH
, 0, 0);
177 if (coreserver
== MACH_PORT_NULL
)
180 /* Get a port to the directory where the new core file will reside. */
181 file
= MACH_PORT_NULL
;
182 name
= _hurdsig_getenv ("COREFILE");
185 coredir
= __file_name_split (name
, (char **) &name
);
186 if (coredir
!= MACH_PORT_NULL
)
187 /* Create the new file, but don't link it into the directory yet. */
188 __dir_mkfile (coredir
, O_WRONLY
|O_CREAT
,
189 0600 & ~_hurd_umask
, /* XXX ? */
192 /* Call the core dumping server to write the core file. */
193 err
= __crash_dump_task (coreserver
,
196 signo
, detail
->code
, detail
->error
,
197 detail
->exc
, detail
->exc_code
, detail
->exc_subcode
,
198 _hurd_ports
[INIT_PORT_CTTYID
].port
,
199 MACH_MSG_TYPE_COPY_SEND
);
200 __mach_port_deallocate (__mach_task_self (), coreserver
);
202 if (! err
&& file
!= MACH_PORT_NULL
)
203 /* The core dump into FILE succeeded, so now link it into the
205 err
= __dir_link (coredir
, file
, name
, 1);
206 __mach_port_deallocate (__mach_task_self (), file
);
207 __mach_port_deallocate (__mach_task_self (), coredir
);
208 return !err
&& file
!= MACH_PORT_NULL
;
212 /* The lowest-numbered thread state flavor value is 1,
213 so we use bit 0 in machine_thread_all_state.set to
214 record whether we have done thread_abort. */
215 #define THREAD_ABORTED 1
217 /* SS->thread is suspended. Abort the thread and get its basic state. */
219 abort_thread (struct hurd_sigstate
*ss
, struct machine_thread_all_state
*state
,
220 void (*reply
) (void))
222 if (!(state
->set
& THREAD_ABORTED
))
224 error_t err
= __thread_abort (ss
->thread
);
226 /* Clear all thread state flavor set bits, because thread_abort may
227 have changed the state. */
228 state
->set
= THREAD_ABORTED
;
234 machine_get_basic_state (ss
->thread
, state
);
237 /* Find the location of the MiG reply port cell in use by the thread whose
238 state is described by THREAD_STATE. If SIGTHREAD is nonzero, make sure
239 that this location can be set without faulting, or else return NULL. */
242 interrupted_reply_port_location (thread_t thread
,
243 struct machine_thread_all_state
*thread_state
,
246 mach_port_t
*portloc
= &THREAD_TCB(thread
, thread_state
)->reply_port
;
248 if (sigthread
&& _hurdsig_catch_memory_fault (portloc
))
249 /* Faulted trying to read the TCB. */
252 DIAG_PUSH_NEEDS_COMMENT
;
253 /* GCC 6 and before seem to be confused by the setjmp call inside
254 _hurdsig_catch_memory_fault and think that we may be returning a second
255 time to here with portloc uninitialized (but we never do). */
256 DIAG_IGNORE_NEEDS_COMMENT (6, "-Wmaybe-uninitialized");
257 /* Fault now if this pointer is bogus. */
258 *(volatile mach_port_t
*) portloc
= *portloc
;
259 DIAG_POP_NEEDS_COMMENT
;
262 _hurdsig_end_catch_fault ();
267 #include <hurd/sigpreempt.h>
268 #include <intr-msg.h>
270 /* Timeout on interrupt_operation calls. */
271 mach_msg_timeout_t _hurdsig_interrupt_timeout
= 1000;
273 /* SS->thread is suspended.
275 Abort any interruptible RPC operation the thread is doing.
277 This uses only the constant member SS->thread and the unlocked, atomically
278 set member SS->intr_port, so no locking is needed.
280 If successfully sent an interrupt_operation and therefore the thread should
281 wait for its pending RPC to return (possibly EINTR) before taking the
282 incoming signal, returns the reply port to be received on. Otherwise
283 returns MACH_PORT_NULL.
285 SIGNO is used to find the applicable SA_RESTART bit. If SIGNO is zero,
286 the RPC fails with EINTR instead of restarting (thread_cancel).
288 *STATE_CHANGE is set nonzero if STATE->basic was modified and should
289 be applied back to the thread if it might ever run again, else zero. */
292 _hurdsig_abort_rpcs (struct hurd_sigstate
*ss
, int signo
, int sigthread
,
293 struct machine_thread_all_state
*state
, int *state_change
,
294 void (*reply
) (void))
296 extern const void _hurd_intr_rpc_msg_about_to
;
297 extern const void _hurd_intr_rpc_msg_in_trap
;
298 mach_port_t rcv_port
= MACH_PORT_NULL
;
299 mach_port_t intr_port
;
303 intr_port
= ss
->intr_port
;
304 if (intr_port
== MACH_PORT_NULL
)
305 /* No interruption needs done. */
306 return MACH_PORT_NULL
;
308 /* Abort the thread's kernel context, so any pending message send or
309 receive completes immediately or aborts. */
310 abort_thread (ss
, state
, reply
);
312 if (state
->basic
.PC
>= (natural_t
) &_hurd_intr_rpc_msg_about_to
313 && state
->basic
.PC
< (natural_t
) &_hurd_intr_rpc_msg_in_trap
)
315 /* The thread is about to do the RPC, but hasn't yet entered
316 mach_msg. Mutate the thread's state so it knows not to try
318 INTR_MSG_BACK_OUT (&state
->basic
);
319 MACHINE_THREAD_STATE_SET_PC (&state
->basic
,
320 &_hurd_intr_rpc_msg_in_trap
);
321 state
->basic
.SYSRETURN
= MACH_SEND_INTERRUPTED
;
324 else if (state
->basic
.PC
== (natural_t
) &_hurd_intr_rpc_msg_in_trap
325 /* The thread was blocked in the system call. After thread_abort,
326 the return value register indicates what state the RPC was in
328 && state
->basic
.SYSRETURN
== MACH_RCV_INTERRUPTED
)
330 /* The RPC request message was sent and the thread was waiting for
331 the reply message; now the message receive has been aborted, so
332 the mach_msg call will return MACH_RCV_INTERRUPTED. We must tell
333 the server to interrupt the pending operation. The thread must
334 wait for the reply message before running the signal handler (to
335 guarantee that the operation has finished being interrupted), so
336 our nonzero return tells the trampoline code to finish the message
337 receive operation before running the handler. */
339 mach_port_t
*reply
= interrupted_reply_port_location (ss
->thread
,
342 error_t err
= __interrupt_operation (intr_port
, _hurdsig_interrupt_timeout
);
348 /* The interrupt didn't work.
349 Destroy the receive right the thread is blocked on. */
350 __mach_port_destroy (__mach_task_self (), *reply
);
351 *reply
= MACH_PORT_NULL
;
354 /* The system call return value register now contains
355 MACH_RCV_INTERRUPTED; when mach_msg resumes, it will retry the
356 call. Since we have just destroyed the receive right, the
357 retry will fail with MACH_RCV_INVALID_NAME. Instead, just
358 change the return value here to EINTR so mach_msg will not
359 retry and the EINTR error code will propagate up. */
360 state
->basic
.SYSRETURN
= EINTR
;
366 /* All threads whose RPCs were interrupted by the interrupt_operation
367 call above will retry their RPCs unless we clear SS->intr_port.
368 So we clear it for the thread taking a signal when SA_RESTART is
369 clear, so that its call returns EINTR. */
370 if (! signo
|| !(ss
->actions
[signo
].sa_flags
& SA_RESTART
))
371 ss
->intr_port
= MACH_PORT_NULL
;
378 /* Abort the RPCs being run by all threads but this one;
379 all other threads should be suspended. If LIVE is nonzero, those
380 threads may run again, so they should be adjusted as necessary to be
381 happy when resumed. STATE is clobbered as a scratch area; its initial
382 contents are ignored, and its contents on return are not useful. */
385 abort_all_rpcs (int signo
, struct machine_thread_all_state
*state
, int live
)
387 /* We can just loop over the sigstates. Any thread doing something
388 interruptible must have one. We needn't bother locking because all
389 other threads are stopped. */
391 struct hurd_sigstate
*ss
;
393 mach_port_t
*reply_ports
;
395 /* First loop over the sigstates to count them.
396 We need to know how big a vector we will need for REPLY_PORTS. */
398 for (ss
= _hurd_sigstates
; ss
!= NULL
; ss
= ss
->next
)
401 reply_ports
= alloca (nthreads
* sizeof *reply_ports
);
404 for (ss
= _hurd_sigstates
; ss
!= NULL
; ss
= ss
->next
, ++nthreads
)
405 if (ss
->thread
== _hurd_msgport_thread
)
406 reply_ports
[nthreads
] = MACH_PORT_NULL
;
410 state
->set
= 0; /* Reset scratch area. */
412 /* Abort any operation in progress with interrupt_operation.
413 Record the reply port the thread is waiting on.
414 We will wait for all the replies below. */
415 reply_ports
[nthreads
] = _hurdsig_abort_rpcs (ss
, signo
, 1,
416 state
, &state_changed
,
420 if (reply_ports
[nthreads
] != MACH_PORT_NULL
)
422 /* We will wait for the reply to this RPC below, so the
423 thread must issue a new RPC rather than waiting for the
424 reply to the one it sent. */
425 state
->basic
.SYSRETURN
= EINTR
;
429 /* Aborting the RPC needed to change this thread's state,
430 and it might ever run again. So write back its state. */
431 __thread_set_state (ss
->thread
, MACHINE_THREAD_STATE_FLAVOR
,
432 (natural_t
*) &state
->basic
,
433 MACHINE_THREAD_STATE_COUNT
);
437 /* Wait for replies from all the successfully interrupted RPCs. */
438 while (nthreads
-- > 0)
439 if (reply_ports
[nthreads
] != MACH_PORT_NULL
)
442 mach_msg_header_t head
;
443 err
= __mach_msg (&head
, MACH_RCV_MSG
|MACH_RCV_TIMEOUT
, 0, sizeof head
,
444 reply_ports
[nthreads
],
445 _hurd_interrupted_rpc_timeout
, MACH_PORT_NULL
);
448 case MACH_RCV_TIMED_OUT
:
449 case MACH_RCV_TOO_LARGE
:
458 struct hurd_signal_preemptor
*_hurdsig_preemptors
= 0;
459 sigset_t _hurdsig_preempted_set
;
461 /* XXX temporary to deal with spelling fix */
462 weak_alias (_hurdsig_preemptors
, _hurdsig_preempters
)
464 /* Mask of stop signals. */
465 #define STOPSIGS (sigmask (SIGTTIN) | sigmask (SIGTTOU) \
466 | sigmask (SIGSTOP) | sigmask (SIGTSTP))
468 /* Deliver a signal. SS is not locked. */
470 _hurd_internal_post_signal (struct hurd_sigstate
*ss
,
471 int signo
, struct hurd_signal_detail
*detail
,
472 mach_port_t reply_port
,
473 mach_msg_type_name_t reply_port_type
,
477 struct machine_thread_all_state thread_state
;
478 enum { stop
, ignore
, core
, term
, handle
} act
;
479 sighandler_t handler
;
483 /* Reply to this sig_post message. */
484 __typeof (__msg_sig_post_reply
) *reply_rpc
485 = (untraced
? __msg_sig_post_untraced_reply
: __msg_sig_post_reply
);
489 if (reply_port
== MACH_PORT_NULL
)
491 err
= (*reply_rpc
) (reply_port
, reply_port_type
, 0);
492 reply_port
= MACH_PORT_NULL
;
493 if (err
!= MACH_SEND_INVALID_DEST
) /* Ignore dead reply port. */
497 /* Mark the signal as pending. */
498 void mark_pending (void)
500 __sigaddset (&ss
->pending
, signo
);
501 /* Save the details to be given to the handler when SIGNO is
503 ss
->pending_data
[signo
] = *detail
;
506 /* Suspend the process with SIGNO. */
509 /* Stop all other threads and mark ourselves stopped. */
512 /* Hold the siglock while stopping other threads to be
513 sure it is not held by another thread afterwards. */
514 __mutex_lock (&_hurd_siglock
);
515 __proc_dostop (port
, _hurd_msgport_thread
);
516 __mutex_unlock (&_hurd_siglock
);
517 abort_all_rpcs (signo
, &thread_state
, 1);
519 __proc_mark_stop (port
, signo
, detail
->code
);
523 /* Resume the process after a suspension. */
526 /* Resume the process from being stopped. */
528 mach_msg_type_number_t nthreads
, i
;
534 /* Tell the proc server we are continuing. */
535 __USEPORT (PROC
, __proc_mark_cont (port
));
536 /* Fetch ports to all our threads and resume them. */
537 err
= __task_threads (__mach_task_self (), &threads
, &nthreads
);
539 for (i
= 0; i
< nthreads
; ++i
)
541 if (threads
[i
] != _hurd_msgport_thread
542 && (act
!= handle
|| threads
[i
] != ss
->thread
))
544 err
= __thread_resume (threads
[i
]);
547 err
= __mach_port_deallocate (__mach_task_self (),
551 __vm_deallocate (__mach_task_self (),
552 (vm_address_t
) threads
,
553 nthreads
* sizeof *threads
);
556 /* The thread that will run the handler is already suspended. */
563 /* This is PTRACE_CONTINUE. */
566 /* This call is just to check for pending signals. */
567 __spin_lock (&ss
->lock
);
568 goto check_pending_signals
;
573 thread_state
.set
= 0; /* We know nothing. */
575 __spin_lock (&ss
->lock
);
577 /* Check for a preempted signal. Preempted signals can arrive during
578 critical sections. */
580 inline sighandler_t
try_preemptor (struct hurd_signal_preemptor
*pe
)
581 { /* PE cannot be null. */
584 if (HURD_PREEMPT_SIGNAL_P (pe
, signo
, detail
->code
))
588 sighandler_t handler
= (*pe
->preemptor
) (pe
, ss
,
590 if (handler
!= SIG_ERR
)
601 handler
= ss
->preemptors
? try_preemptor (ss
->preemptors
) : SIG_ERR
;
603 /* If no thread-specific preemptor, check for a global one. */
604 if (handler
== SIG_ERR
&& __sigismember (&_hurdsig_preempted_set
, signo
))
606 __mutex_lock (&_hurd_siglock
);
607 handler
= try_preemptor (_hurdsig_preemptors
);
608 __mutex_unlock (&_hurd_siglock
);
614 if (handler
== SIG_IGN
)
615 /* Ignore the signal altogether. */
617 else if (handler
!= SIG_ERR
)
618 /* Run the preemption-provided handler. */
622 /* No preemption. Do normal handling. */
624 if (!untraced
&& __sigismember (&_hurdsig_traced
, signo
))
626 /* We are being traced. Stop to tell the debugger of the signal. */
628 /* Already stopped. Mark the signal as pending;
629 when resumed, we will notice it and stop again. */
633 __spin_unlock (&ss
->lock
);
638 handler
= ss
->actions
[signo
].sa_handler
;
640 if (handler
== SIG_DFL
)
641 /* Figure out the default action for this signal. */
645 /* A sig_post msg with SIGNO==0 is sent to
646 tell us to check for pending signals. */
678 if (_hurd_pgrp
== _hurd_pid
)
680 /* We are the process group leader. Since there is no
681 user-specified handler for SIGINFO, we use a default one
682 which prints something interesting. We use the normal
683 handler mechanism instead of just doing it here to avoid
684 the signal thread faulting or blocking in this
685 potentially hairy operation. */
687 handler
= _hurd_siginfo_handler
;
697 else if (handler
== SIG_IGN
)
702 if (__sigmask (signo
) & STOPSIGS
)
703 /* Stop signals clear a pending SIGCONT even if they
704 are handled or ignored (but not if preempted). */
705 __sigdelset (&ss
->pending
, SIGCONT
);
708 if (signo
== SIGCONT
)
709 /* Even if handled or ignored (but not preempted), SIGCONT clears
710 stop signals and resumes the process. */
711 ss
->pending
&= ~STOPSIGS
;
713 if (_hurd_stopped
&& act
!= stop
&& (untraced
|| signo
== SIGCONT
))
718 if (_hurd_orphaned
&& act
== stop
719 && (__sigmask (signo
) & (__sigmask (SIGTTIN
) | __sigmask (SIGTTOU
)
720 | __sigmask (SIGTSTP
))))
722 /* If we would ordinarily stop for a job control signal, but we are
723 orphaned so noone would ever notice and continue us again, we just
724 quietly die, alone and in the dark. */
725 detail
->code
= signo
;
730 /* Handle receipt of a blocked signal, or any signal while stopped. */
731 if (act
!= ignore
/* Signals ignored now are forgotten now. */
732 && __sigismember (&ss
->blocked
, signo
)
733 || (signo
!= SIGKILL
&& _hurd_stopped
))
739 /* Perform the chosen action for the signal. */
745 /* We are already stopped, but receiving an untraced stop
746 signal. Instead of resuming and suspending again, just
747 notify the proc server of the new stop signal. */
748 error_t err
= __USEPORT (PROC
, __proc_mark_stop
749 (port
, signo
, detail
->code
));
753 /* Suspend the process. */
759 /* Blocking or ignoring a machine exception is fatal.
760 Otherwise we could just spin on the faulting instruction. */
763 /* Nobody cares about this signal. If there was a call to resume
764 above in SIGCONT processing and we've left a thread suspended,
765 now's the time to set it going. */
768 err
= __thread_resume (ss
->thread
);
775 /* We got a fault setting up the stack frame for the handler.
776 Nothing to do but die; BSD gets SIGILL in this case. */
777 detail
->code
= signo
; /* XXX ? */
784 case term
: /* Time to die. */
785 case core
: /* And leave a rotting corpse. */
786 /* Have the proc server stop all other threads in our task. */
787 err
= __USEPORT (PROC
, __proc_dostop (port
, _hurd_msgport_thread
));
789 /* No more user instructions will be executed.
790 The signal can now be considered delivered. */
792 /* Abort all server operations now in progress. */
793 abort_all_rpcs (signo
, &thread_state
, 0);
796 int status
= W_EXITCODE (0, signo
);
797 /* Do a core dump if desired. Only set the wait status bit saying we
798 in fact dumped core if the operation was actually successful. */
799 if (act
== core
&& write_corefile (signo
, detail
))
801 /* Tell proc how we died and then stick the saber in the gut. */
807 /* Call a handler for this signal. */
809 struct sigcontext
*scp
, ocontext
;
810 int wait_for_reply
, state_changed
;
812 /* Stop the thread and abort its pending RPC operations. */
815 err
= __thread_suspend (ss
->thread
);
819 /* Abort the thread's kernel context, so any pending message send
820 or receive completes immediately or aborts. If an interruptible
821 RPC is in progress, abort_rpcs will do this. But we must always
822 do it before fetching the thread's state, because
823 thread_get_state is never kosher before thread_abort. */
824 abort_thread (ss
, &thread_state
, NULL
);
828 /* We have a previous sigcontext that sigreturn was about
829 to restore when another signal arrived. */
833 if (_hurdsig_catch_memory_fault (ss
->context
))
835 /* We faulted reading the thread's stack. Forget that
836 context and pretend it wasn't there. It almost
837 certainly crash if this handler returns, but that's it's
843 /* Copy the context from the thread's stack before
844 we start diddling the stack to set up the handler. */
845 ocontext
= *ss
->context
;
846 ss
->context
= &ocontext
;
848 _hurdsig_end_catch_fault ();
850 if (! machine_get_basic_state (ss
->thread
, &thread_state
))
852 loc
= interrupted_reply_port_location (ss
->thread
,
854 if (loc
&& *loc
!= MACH_PORT_NULL
)
855 /* This is the reply port for the context which called
856 sigreturn. Since we are abandoning that context entirely
857 and restoring SS->context instead, destroy this port. */
858 __mach_port_destroy (__mach_task_self (), *loc
);
860 /* The thread was in sigreturn, not in any interruptible RPC. */
863 assert (! __spin_lock_locked (&ss
->critical_section_lock
));
867 int crit
= __spin_lock_locked (&ss
->critical_section_lock
);
870 = (_hurdsig_abort_rpcs (ss
,
871 /* In a critical section, any RPC
872 should be cancelled instead of
873 restarted, regardless of
874 SA_RESTART, so the entire
875 "atomic" operation can be aborted
878 &thread_state
, &state_changed
,
884 /* The thread is in a critical section. Mark the signal as
885 pending. When it finishes the critical section, it will
886 check for pending signals. */
889 /* Some cases of interrupting an RPC must change the
890 thread state to back out the call. Normally this
891 change is rolled into the warping to the handler and
892 sigreturn, but we are not running the handler now
893 because the thread is in a critical section. Instead,
894 mutate the thread right away for the RPC interruption
895 and resume it; the RPC will return early so the
896 critical section can end soon. */
897 __thread_set_state (ss
->thread
, MACHINE_THREAD_STATE_FLAVOR
,
898 (natural_t
*) &thread_state
.basic
,
899 MACHINE_THREAD_STATE_COUNT
);
901 ss
->intr_port
= MACH_PORT_NULL
;
902 __thread_resume (ss
->thread
);
907 /* Call the machine-dependent function to set the thread up
908 to run the signal handler, and preserve its old context. */
909 scp
= _hurd_setup_sighandler (ss
, handler
, signo
, detail
,
910 wait_for_reply
, &thread_state
);
914 /* Set the machine-independent parts of the signal context. */
917 /* Fetch the thread variable for the MiG reply port,
918 and set it to MACH_PORT_NULL. */
919 mach_port_t
*loc
= interrupted_reply_port_location (ss
->thread
,
924 scp
->sc_reply_port
= *loc
;
925 *loc
= MACH_PORT_NULL
;
928 scp
->sc_reply_port
= MACH_PORT_NULL
;
930 /* Save the intr_port in use by the interrupted code,
931 and clear the cell before running the trampoline. */
932 scp
->sc_intr_port
= ss
->intr_port
;
933 ss
->intr_port
= MACH_PORT_NULL
;
937 /* After the handler runs we will restore to the state in
938 SS->context, not the state of the thread now. So restore
939 that context's reply port and intr port. */
941 scp
->sc_reply_port
= ss
->context
->sc_reply_port
;
942 scp
->sc_intr_port
= ss
->context
->sc_intr_port
;
948 /* Backdoor extra argument to signal handler. */
949 scp
->sc_error
= detail
->error
;
951 /* Block requested signals while running the handler. */
952 scp
->sc_mask
= ss
->blocked
;
953 __sigorset (&ss
->blocked
, &ss
->blocked
, &ss
->actions
[signo
].sa_mask
);
955 /* Also block SIGNO unless we're asked not to. */
956 if (! (ss
->actions
[signo
].sa_flags
& (SA_RESETHAND
| SA_NODEFER
)))
957 __sigaddset (&ss
->blocked
, signo
);
959 /* Reset to SIG_DFL if requested. SIGILL and SIGTRAP cannot
960 be automatically reset when delivered; the system silently
961 enforces this restriction. */
962 if (ss
->actions
[signo
].sa_flags
& SA_RESETHAND
963 && signo
!= SIGILL
&& signo
!= SIGTRAP
)
964 ss
->actions
[signo
].sa_handler
= SIG_DFL
;
966 /* Start the thread running the handler (or possibly waiting for an
967 RPC reply before running the handler). */
968 err
= __thread_set_state (ss
->thread
, MACHINE_THREAD_STATE_FLAVOR
,
969 (natural_t
*) &thread_state
.basic
,
970 MACHINE_THREAD_STATE_COUNT
);
972 err
= __thread_resume (ss
->thread
);
974 thread_state
.set
= 0; /* Everything we know is now wrong. */
979 /* The signal has either been ignored or is now being handled. We can
980 consider it delivered and reply to the killer. */
983 /* We get here unless the signal was fatal. We still hold SS->lock.
984 Check for pending signals, and loop to post them. */
986 /* Return nonzero if SS has any signals pending we should worry about.
987 We don't worry about any pending signals if we are stopped, nor if
988 SS is in a critical section. We are guaranteed to get a sig_post
989 message before any of them become deliverable: either the SIGCONT
990 signal, or a sig_post with SIGNO==0 as an explicit poll when the
991 thread finishes its critical section. */
992 inline int signals_pending (void)
994 if (_hurd_stopped
|| __spin_lock_locked (&ss
->critical_section_lock
))
996 return pending
= ss
->pending
& ~ss
->blocked
;
999 check_pending_signals
:
1002 if (signals_pending ())
1004 for (signo
= 1; signo
< NSIG
; ++signo
)
1005 if (__sigismember (&pending
, signo
))
1008 __sigdelset (&ss
->pending
, signo
);
1009 *detail
= ss
->pending_data
[signo
];
1010 __spin_unlock (&ss
->lock
);
1015 /* No pending signals left undelivered for this thread.
1016 If we were sent signal 0, we need to check for pending
1017 signals for all threads. */
1020 __spin_unlock (&ss
->lock
);
1021 __mutex_lock (&_hurd_siglock
);
1022 for (ss
= _hurd_sigstates
; ss
!= NULL
; ss
= ss
->next
)
1024 __spin_lock (&ss
->lock
);
1025 for (signo
= 1; signo
< NSIG
; ++signo
)
1026 if (__sigismember (&ss
->pending
, signo
)
1027 && (!__sigismember (&ss
->blocked
, signo
)
1028 /* We "deliver" immediately pending blocked signals whose
1029 action might be to ignore, so that if ignored they are
1030 dropped right away. */
1031 || ss
->actions
[signo
].sa_handler
== SIG_IGN
1032 || ss
->actions
[signo
].sa_handler
== SIG_DFL
))
1034 __mutex_unlock (&_hurd_siglock
);
1035 goto deliver_pending
;
1037 __spin_unlock (&ss
->lock
);
1039 __mutex_unlock (&_hurd_siglock
);
1043 /* No more signals pending; SS->lock is still locked.
1044 Wake up any sigsuspend call that is blocking SS->thread. */
1045 if (ss
->suspended
!= MACH_PORT_NULL
)
1047 /* There is a sigsuspend waiting. Tell it to wake up. */
1049 mach_msg_header_t msg
;
1050 msg
.msgh_bits
= MACH_MSGH_BITS (MACH_MSG_TYPE_MAKE_SEND
, 0);
1051 msg
.msgh_remote_port
= ss
->suspended
;
1052 msg
.msgh_local_port
= MACH_PORT_NULL
;
1053 /* These values do not matter. */
1054 msg
.msgh_id
= 8675309; /* Jenny, Jenny. */
1055 ss
->suspended
= MACH_PORT_NULL
;
1056 err
= __mach_msg (&msg
, MACH_SEND_MSG
, sizeof msg
, 0,
1057 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
1059 assert_perror (err
);
1061 __spin_unlock (&ss
->lock
);
1065 /* All pending signals delivered to all threads.
1066 Now we can send the reply message even for signal 0. */
1070 /* Decide whether REFPORT enables the sender to send us a SIGNO signal.
1071 Returns zero if so, otherwise the error code to return to the sender. */
1074 signal_allowed (int signo
, mach_port_t refport
)
1076 if (signo
< 0 || signo
>= NSIG
)
1079 if (refport
== __mach_task_self ())
1080 /* Can send any signal. */
1083 /* Avoid needing to check for this below. */
1084 if (refport
== MACH_PORT_NULL
)
1097 /* Job control signals can be sent by the controlling terminal. */
1098 if (__USEPORT (CTTYID
, port
== refport
))
1104 /* A continue signal can be sent by anyone in the session. */
1105 mach_port_t sessport
;
1106 if (! __USEPORT (PROC
, __proc_getsidport (port
, &sessport
)))
1108 __mach_port_deallocate (__mach_task_self (), sessport
);
1109 if (refport
== sessport
)
1118 /* Any io object a file descriptor refers to might send us
1119 one of these signals using its async ID port for REFPORT.
1121 This is pretty wide open; it is not unlikely that some random
1122 process can at least open for reading something we have open,
1123 get its async ID port, and send us a spurious SIGIO or SIGURG
1124 signal. But BSD is actually wider open than that!--you can set
1125 the owner of an io object to any process or process group
1126 whatsoever and send them gratuitous signals.
1128 Someday we could implement some reasonable scheme for
1129 authorizing SIGIO and SIGURG signals properly. */
1132 int lucky
= 0; /* True if we find a match for REFPORT. */
1133 __mutex_lock (&_hurd_dtable_lock
);
1134 for (d
= 0; !lucky
&& (unsigned) d
< (unsigned) _hurd_dtablesize
; ++d
)
1136 struct hurd_userlink ulink
;
1138 mach_port_t asyncid
;
1139 if (_hurd_dtable
[d
] == NULL
)
1141 port
= _hurd_port_get (&_hurd_dtable
[d
]->port
, &ulink
);
1142 if (! __io_get_icky_async_id (port
, &asyncid
))
1144 if (refport
== asyncid
)
1145 /* Break out of the loop on the next iteration. */
1147 __mach_port_deallocate (__mach_task_self (), asyncid
);
1149 _hurd_port_free (&_hurd_dtable
[d
]->port
, &ulink
, port
);
1151 __mutex_unlock (&_hurd_dtable_lock
);
1152 /* If we found a lucky winner, we've set D to -1 in the loop. */
1158 /* If this signal is legit, we have done `goto win' by now.
1159 When we return the error, mig deallocates REFPORT. */
1163 /* Deallocate the REFPORT send right; we are done with it. */
1164 __mach_port_deallocate (__mach_task_self (), refport
);
1169 /* Implement the sig_post RPC from <hurd/msg.defs>;
1170 sent when someone wants us to get a signal. */
1172 _S_msg_sig_post (mach_port_t me
,
1173 mach_port_t reply_port
, mach_msg_type_name_t reply_port_type
,
1174 int signo
, natural_t sigcode
,
1175 mach_port_t refport
)
1178 struct hurd_signal_detail d
;
1180 if (err
= signal_allowed (signo
, refport
))
1186 /* Post the signal to the designated signal-receiving thread. This will
1187 reply when the signal can be considered delivered. */
1188 _hurd_internal_post_signal (_hurd_thread_sigstate (_hurd_sigthread
),
1189 signo
, &d
, reply_port
, reply_port_type
,
1190 0); /* Stop if traced. */
1192 return MIG_NO_REPLY
; /* Already replied. */
1195 /* Implement the sig_post_untraced RPC from <hurd/msg.defs>;
1196 sent when the debugger wants us to really get a signal
1197 even if we are traced. */
1199 _S_msg_sig_post_untraced (mach_port_t me
,
1200 mach_port_t reply_port
,
1201 mach_msg_type_name_t reply_port_type
,
1202 int signo
, natural_t sigcode
,
1203 mach_port_t refport
)
1206 struct hurd_signal_detail d
;
1208 if (err
= signal_allowed (signo
, refport
))
1214 /* Post the signal to the designated signal-receiving thread. This will
1215 reply when the signal can be considered delivered. */
1216 _hurd_internal_post_signal (_hurd_thread_sigstate (_hurd_sigthread
),
1217 signo
, &d
, reply_port
, reply_port_type
,
1218 1); /* Untraced flag. */
1220 return MIG_NO_REPLY
; /* Already replied. */
1223 extern void __mig_init (void *);
1225 #include <mach/task_special_ports.h>
1227 /* Initialize the message port and _hurd_sigthread and start the signal
1231 _hurdsig_init (const int *intarray
, size_t intarraysize
)
1234 vm_size_t stacksize
;
1235 struct hurd_sigstate
*ss
;
1237 __mutex_init (&_hurd_siglock
);
1239 err
= __mach_port_allocate (__mach_task_self (),
1240 MACH_PORT_RIGHT_RECEIVE
,
1242 assert_perror (err
);
1244 /* Make a send right to the signal port. */
1245 err
= __mach_port_insert_right (__mach_task_self (),
1248 MACH_MSG_TYPE_MAKE_SEND
);
1249 assert_perror (err
);
1251 /* Initialize the main thread's signal state. */
1252 ss
= _hurd_self_sigstate ();
1254 /* Copy inherited values from our parent (or pre-exec process state)
1255 into the signal settings of the main thread. */
1256 if (intarraysize
> INIT_SIGMASK
)
1257 ss
->blocked
= intarray
[INIT_SIGMASK
];
1258 if (intarraysize
> INIT_SIGPENDING
)
1259 ss
->pending
= intarray
[INIT_SIGPENDING
];
1260 if (intarraysize
> INIT_SIGIGN
&& intarray
[INIT_SIGIGN
] != 0)
1263 for (signo
= 1; signo
< NSIG
; ++signo
)
1264 if (intarray
[INIT_SIGIGN
] & __sigmask(signo
))
1265 ss
->actions
[signo
].sa_handler
= SIG_IGN
;
1268 /* Set the default thread to receive task-global signals
1269 to this one, the main (first) user thread. */
1270 _hurd_sigthread
= ss
->thread
;
1272 /* Start the signal thread listening on the message port. */
1274 #pragma weak __cthread_fork
1275 if (!__cthread_fork
)
1277 err
= __thread_create (__mach_task_self (), &_hurd_msgport_thread
);
1278 assert_perror (err
);
1280 stacksize
= __vm_page_size
* 8; /* Small stack for signal thread. */
1281 err
= __mach_setup_thread (__mach_task_self (), _hurd_msgport_thread
,
1282 _hurd_msgport_receive
,
1283 (vm_address_t
*) &__hurd_sigthread_stack_base
,
1285 assert_perror (err
);
1286 err
= __mach_setup_tls (_hurd_msgport_thread
);
1287 assert_perror (err
);
1289 __hurd_sigthread_stack_end
= __hurd_sigthread_stack_base
+ stacksize
;
1291 /* Reinitialize the MiG support routines so they will use a per-thread
1292 variable for the cached reply port. */
1293 __mig_init ((void *) __hurd_sigthread_stack_base
);
1295 err
= __thread_resume (_hurd_msgport_thread
);
1296 assert_perror (err
);
1300 /* When cthreads is being used, we need to make the signal thread a
1301 proper cthread. Otherwise it cannot use mutex_lock et al, which
1302 will be the cthreads versions. Various of the message port RPC
1303 handlers need to take locks, so we need to be able to call into
1304 cthreads code and meet its assumptions about how our thread and
1305 its stack are arranged. Since cthreads puts it there anyway,
1306 we'll let the signal thread's per-thread variables be found as for
1307 any normal cthread, and just leave the magic __hurd_sigthread_*
1308 values all zero so they'll be ignored. */
1309 #pragma weak __cthread_detach
1310 #pragma weak __pthread_getattr_np
1311 #pragma weak __pthread_attr_getstack
1312 __cthread_t thread
= __cthread_fork (
1313 (cthread_fn_t
) &_hurd_msgport_receive
, 0);
1314 __cthread_detach (thread
);
1316 if (__pthread_getattr_np
)
1318 /* Record signal thread stack layout for fork() */
1319 pthread_attr_t attr
;
1323 __pthread_getattr_np ((pthread_t
) thread
, &attr
);
1324 __pthread_attr_getstack (&attr
, &addr
, &size
);
1325 __hurd_sigthread_stack_base
= (uintptr_t) addr
;
1326 __hurd_sigthread_stack_end
= __hurd_sigthread_stack_base
+ size
;
1329 /* XXX We need the thread port for the signal thread further on
1330 in this thread (see hurdfault.c:_hurdsigfault_init).
1331 Therefore we block until _hurd_msgport_thread is initialized
1332 by the newly created thread. This really shouldn't be
1333 necessary; we should be able to fetch the thread port for a
1334 cthread from here. */
1335 while (_hurd_msgport_thread
== 0)
1339 /* Receive exceptions on the signal port. */
1340 #ifdef TASK_EXCEPTION_PORT
1341 __task_set_special_port (__mach_task_self (),
1342 TASK_EXCEPTION_PORT
, _hurd_msgport
);
1343 #elif defined (EXC_MASK_ALL)
1344 __task_set_exception_ports (__mach_task_self (),
1345 EXC_MASK_ALL
& ~(EXC_MASK_SYSCALL
1346 | EXC_MASK_MACH_SYSCALL
1347 | EXC_MASK_RPC_ALERT
),
1349 EXCEPTION_DEFAULT
, MACHINE_THREAD_STATE
);
1351 # error task_set_exception_port?
1354 /* Sanity check. Any pending, unblocked signals should have been
1355 taken by our predecessor incarnation (i.e. parent or pre-exec state)
1356 before packing up our init ints. This assert is last (not above)
1357 so that signal handling is all set up to handle the abort. */
1358 assert ((ss
->pending
&~ ss
->blocked
) == 0);
1361 /* Reauthenticate with the proc server. */
1364 reauth_proc (mach_port_t
new)
1366 mach_port_t ref
, ignore
;
1368 ref
= __mach_reply_port ();
1369 if (! HURD_PORT_USE (&_hurd_ports
[INIT_PORT_PROC
],
1370 __proc_reauthenticate (port
, ref
,
1371 MACH_MSG_TYPE_MAKE_SEND
)
1372 || __auth_user_authenticate (new, ref
,
1373 MACH_MSG_TYPE_MAKE_SEND
,
1375 && ignore
!= MACH_PORT_NULL
)
1376 __mach_port_deallocate (__mach_task_self (), ignore
);
1377 __mach_port_destroy (__mach_task_self (), ref
);
1379 /* Set the owner of the process here too. */
1380 __mutex_lock (&_hurd_id
.lock
);
1381 if (!_hurd_check_ids ())
1382 HURD_PORT_USE (&_hurd_ports
[INIT_PORT_PROC
],
1383 __proc_setowner (port
,
1385 ? _hurd_id
.gen
.uids
[0] : 0),
1386 !_hurd_id
.gen
.nuids
));
1387 __mutex_unlock (&_hurd_id
.lock
);
1389 (void) &reauth_proc
; /* Silence compiler warning. */
1391 text_set_element (_hurd_reauth_hook
, reauth_proc
);
1393 /* Like `getenv', but safe for the signal thread to run.
1394 If the environment is trashed, this will just return NULL. */
1397 _hurdsig_getenv (const char *variable
)
1399 if (__libc_enable_secure
)
1402 if (_hurdsig_catch_memory_fault (__environ
))
1403 /* We bombed in getenv. */
1407 const size_t len
= strlen (variable
);
1409 char *volatile *ep
= __environ
;
1412 const char *p
= *ep
;
1413 _hurdsig_fault_preemptor
.first
= (long int) p
;
1414 _hurdsig_fault_preemptor
.last
= VM_MAX_ADDRESS
;
1415 if (! strncmp (p
, variable
, len
) && p
[len
] == '=')
1419 valuelen
= strlen (p
);
1420 _hurdsig_fault_preemptor
.last
= (long int) (p
+ valuelen
);
1421 value
= malloc (++valuelen
);
1423 memcpy (value
, p
, valuelen
);
1426 _hurdsig_fault_preemptor
.first
= (long int) ++ep
;
1427 _hurdsig_fault_preemptor
.last
= (long int) (ep
+ 1);
1429 _hurdsig_end_catch_fault ();