Warning: That file was not part of the compilation database. It may have many parsing errors.

1/* Copyright (C) 1991-2019 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU 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.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
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/>. */
17
18#include <stdio.h>
19#include <stdlib.h>
20#include <string.h>
21
22#include <cthreads.h> /* For `struct mutex'. */
23#include <pthreadP.h>
24#include <mach.h>
25#include <mach/thread_switch.h>
26#include <mach/mig_support.h>
27
28#include <hurd.h>
29#include <hurd/id.h>
30#include <hurd/signal.h>
31
32#include "hurdfault.h"
33#include "hurdmalloc.h" /* XXX */
34#include "../locale/localeinfo.h"
35
36#include <libc-diag.h>
37
38const char *_hurdsig_getenv (const char *);
39
40struct mutex _hurd_siglock;
41int _hurd_stopped;
42
43/* Port that receives signals and other miscellaneous messages. */
44mach_port_t _hurd_msgport;
45
46/* Thread listening on it. */
47thread_t _hurd_msgport_thread;
48
49/* Thread which receives task-global signals. */
50thread_t _hurd_sigthread;
51
52/* These are set up by _hurdsig_init. */
53unsigned long int __hurd_sigthread_stack_base;
54unsigned long int __hurd_sigthread_stack_end;
55
56/* Linked-list of per-thread signal state. */
57struct hurd_sigstate *_hurd_sigstates;
58
59/* Timeout for RPC's after interrupt_operation. */
60mach_msg_timeout_t _hurd_interrupted_rpc_timeout = 60000;
61
62static void
63default_sigaction (struct sigaction actions[NSIG])
64{
65 int signo;
66
67 __sigemptyset (&actions[0].sa_mask);
68 actions[0].sa_flags = SA_RESTART;
69 actions[0].sa_handler = SIG_DFL;
70
71 for (signo = 1; signo < NSIG; ++signo)
72 actions[signo] = actions[0];
73}
74
75struct hurd_sigstate *
76_hurd_thread_sigstate (thread_t thread)
77{
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)
82 break;
83 if (ss == NULL)
84 {
85 ss = malloc (sizeof (*ss));
86 if (ss == NULL)
87 __libc_fatal ("hurd: Can't allocate thread sigstate\n");
88 ss->thread = thread;
89 __spin_lock_init (&ss->lock);
90
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;
99 ss->context = NULL;
100
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);
105 else
106 {
107 struct hurd_sigstate *s;
108 for (s = _hurd_sigstates; s != NULL; s = s->next)
109 if (s->thread == _hurd_sigthread)
110 break;
111 if (s)
112 {
113 __spin_lock (&s->lock);
114 memcpy (ss->actions, s->actions, sizeof (s->actions));
115 __spin_unlock (&s->lock);
116 }
117 else
118 default_sigaction (ss->actions);
119 }
120
121 ss->next = _hurd_sigstates;
122 _hurd_sigstates = ss;
123 }
124 __mutex_unlock (&_hurd_siglock);
125 return ss;
126}
127libc_hidden_def (_hurd_thread_sigstate)
128
129/* Signal delivery itself is on this page. */
130
131#include <hurd/fd.h>
132#include <hurd/crash.h>
133#include <hurd/resource.h>
134#include <hurd/paths.h>
135#include <setjmp.h>
136#include <fcntl.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>
142#include <assert.h>
143#include <unistd.h>
144
145
146/* Call the crash dump server to mummify us before we die.
147 Returns nonzero if a core file was written. */
148static int
149write_corefile (int signo, const struct hurd_signal_detail *detail)
150{
151 error_t err;
152 mach_port_t coreserver;
153 file_t file, coredir;
154 const char *name;
155
156 /* Don't bother locking since we just read the one word. */
157 rlim_t corelimit = _hurd_rlimits[RLIMIT_CORE].rlim_cur;
158
159 if (corelimit == 0)
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. */
163 return 0;
164
165 /* XXX RLIMIT_CORE:
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. */
169
170 /* First get a port to the core dumping server. */
171 coreserver = MACH_PORT_NULL;
172 name = _hurdsig_getenv ("CRASHSERVER");
173 if (name != NULL)
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)
178 return 0;
179
180 /* Get a port to the directory where the new core file will reside. */
181 file = MACH_PORT_NULL;
182 name = _hurdsig_getenv ("COREFILE");
183 if (name == NULL)
184 name = "core";
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 ? */
190 &file);
191
192 /* Call the core dumping server to write the core file. */
193 err = __crash_dump_task (coreserver,
194 __mach_task_self (),
195 file,
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);
201
202 if (! err && file != MACH_PORT_NULL)
203 /* The core dump into FILE succeeded, so now link it into the
204 directory. */
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;
209}
210
211
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
216
217/* SS->thread is suspended. Abort the thread and get its basic state. */
218static void
219abort_thread (struct hurd_sigstate *ss, struct machine_thread_all_state *state,
220 void (*reply) (void))
221{
222 if (!(state->set & THREAD_ABORTED))
223 {
224 error_t err = __thread_abort (ss->thread);
225 assert_perror (err);
226 /* Clear all thread state flavor set bits, because thread_abort may
227 have changed the state. */
228 state->set = THREAD_ABORTED;
229 }
230
231 if (reply)
232 (*reply) ();
233
234 machine_get_basic_state (ss->thread, state);
235}
236
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. */
240
241static mach_port_t *
242interrupted_reply_port_location (thread_t thread,
243 struct machine_thread_all_state *thread_state,
244 int sigthread)
245{
246 mach_port_t *portloc = &THREAD_TCB(thread, thread_state)->reply_port;
247
248 if (sigthread && _hurdsig_catch_memory_fault (portloc))
249 /* Faulted trying to read the TCB. */
250 return NULL;
251
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;
260
261 if (sigthread)
262 _hurdsig_end_catch_fault ();
263
264 return portloc;
265}
266
267#include <hurd/sigpreempt.h>
268#include <intr-msg.h>
269
270/* Timeout on interrupt_operation calls. */
271mach_msg_timeout_t _hurdsig_interrupt_timeout = 1000;
272
273/* SS->thread is suspended.
274
275 Abort any interruptible RPC operation the thread is doing.
276
277 This uses only the constant member SS->thread and the unlocked, atomically
278 set member SS->intr_port, so no locking is needed.
279
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.
284
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).
287
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. */
290
291mach_port_t
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))
295{
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;
300
301 *state_change = 0;
302
303 intr_port = ss->intr_port;
304 if (intr_port == MACH_PORT_NULL)
305 /* No interruption needs done. */
306 return MACH_PORT_NULL;
307
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);
311
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)
314 {
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
317 the RPC. */
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;
322 *state_change = 1;
323 }
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
327 when interrupted. */
328 && state->basic.SYSRETURN == MACH_RCV_INTERRUPTED)
329 {
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. */
338
339 mach_port_t *reply = interrupted_reply_port_location (ss->thread,
340 state,
341 sigthread);
342 error_t err = __interrupt_operation (intr_port, _hurdsig_interrupt_timeout);
343
344 if (err)
345 {
346 if (reply)
347 {
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;
352 }
353
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;
361 *state_change = 1;
362 }
363 else if (reply)
364 rcv_port = *reply;
365
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;
372 }
373
374 return rcv_port;
375}
376
377
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. */
383
384static void
385abort_all_rpcs (int signo, struct machine_thread_all_state *state, int live)
386{
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. */
390
391 struct hurd_sigstate *ss;
392 size_t nthreads;
393 mach_port_t *reply_ports;
394
395 /* First loop over the sigstates to count them.
396 We need to know how big a vector we will need for REPLY_PORTS. */
397 nthreads = 0;
398 for (ss = _hurd_sigstates; ss != NULL; ss = ss->next)
399 ++nthreads;
400
401 reply_ports = alloca (nthreads * sizeof *reply_ports);
402
403 nthreads = 0;
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;
407 else
408 {
409 int state_changed;
410 state->set = 0; /* Reset scratch area. */
411
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,
417 NULL);
418 if (live)
419 {
420 if (reply_ports[nthreads] != MACH_PORT_NULL)
421 {
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;
426 state_changed = 1;
427 }
428 if (state_changed)
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);
434 }
435 }
436
437 /* Wait for replies from all the successfully interrupted RPCs. */
438 while (nthreads-- > 0)
439 if (reply_ports[nthreads] != MACH_PORT_NULL)
440 {
441 error_t err;
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);
446 switch (err)
447 {
448 case MACH_RCV_TIMED_OUT:
449 case MACH_RCV_TOO_LARGE:
450 break;
451
452 default:
453 assert_perror (err);
454 }
455 }
456}
457
458struct hurd_signal_preemptor *_hurdsig_preemptors = 0;
459sigset_t _hurdsig_preempted_set;
460
461/* XXX temporary to deal with spelling fix */
462weak_alias (_hurdsig_preemptors, _hurdsig_preempters)
463
464/* Mask of stop signals. */
465#define STOPSIGS (sigmask (SIGTTIN) | sigmask (SIGTTOU) \
466 | sigmask (SIGSTOP) | sigmask (SIGTSTP))
467
468/* Deliver a signal. SS is not locked. */
469void
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,
474 int untraced)
475{
476 error_t err;
477 struct machine_thread_all_state thread_state;
478 enum { stop, ignore, core, term, handle } act;
479 sighandler_t handler;
480 sigset_t pending;
481 int ss_suspended;
482
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);
486 void reply (void)
487 {
488 error_t err;
489 if (reply_port == MACH_PORT_NULL)
490 return;
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. */
494 assert_perror (err);
495 }
496
497 /* Mark the signal as pending. */
498 void mark_pending (void)
499 {
500 __sigaddset (&ss->pending, signo);
501 /* Save the details to be given to the handler when SIGNO is
502 unblocked. */
503 ss->pending_data[signo] = *detail;
504 }
505
506 /* Suspend the process with SIGNO. */
507 void suspend (void)
508 {
509 /* Stop all other threads and mark ourselves stopped. */
510 __USEPORT (PROC,
511 ({
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);
518 reply ();
519 __proc_mark_stop (port, signo, detail->code);
520 }));
521 _hurd_stopped = 1;
522 }
523 /* Resume the process after a suspension. */
524 void resume (void)
525 {
526 /* Resume the process from being stopped. */
527 thread_t *threads;
528 mach_msg_type_number_t nthreads, i;
529 error_t err;
530
531 if (! _hurd_stopped)
532 return;
533
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);
538 assert_perror (err);
539 for (i = 0; i < nthreads; ++i)
540 {
541 if (threads[i] != _hurd_msgport_thread
542 && (act != handle || threads[i] != ss->thread))
543 {
544 err = __thread_resume (threads[i]);
545 assert_perror (err);
546 }
547 err = __mach_port_deallocate (__mach_task_self (),
548 threads[i]);
549 assert_perror (err);
550 }
551 __vm_deallocate (__mach_task_self (),
552 (vm_address_t) threads,
553 nthreads * sizeof *threads);
554 _hurd_stopped = 0;
555 if (act == handle)
556 /* The thread that will run the handler is already suspended. */
557 ss_suspended = 1;
558 }
559
560 if (signo == 0)
561 {
562 if (untraced)
563 /* This is PTRACE_CONTINUE. */
564 resume ();
565
566 /* This call is just to check for pending signals. */
567 __spin_lock (&ss->lock);
568 goto check_pending_signals;
569 }
570
571 post_signal:
572
573 thread_state.set = 0; /* We know nothing. */
574
575 __spin_lock (&ss->lock);
576
577 /* Check for a preempted signal. Preempted signals can arrive during
578 critical sections. */
579 {
580 inline sighandler_t try_preemptor (struct hurd_signal_preemptor *pe)
581 { /* PE cannot be null. */
582 do
583 {
584 if (HURD_PREEMPT_SIGNAL_P (pe, signo, detail->code))
585 {
586 if (pe->preemptor)
587 {
588 sighandler_t handler = (*pe->preemptor) (pe, ss,
589 &signo, detail);
590 if (handler != SIG_ERR)
591 return handler;
592 }
593 else
594 return pe->handler;
595 }
596 pe = pe->next;
597 } while (pe != 0);
598 return SIG_ERR;
599 }
600
601 handler = ss->preemptors ? try_preemptor (ss->preemptors) : SIG_ERR;
602
603 /* If no thread-specific preemptor, check for a global one. */
604 if (handler == SIG_ERR && __sigismember (&_hurdsig_preempted_set, signo))
605 {
606 __mutex_lock (&_hurd_siglock);
607 handler = try_preemptor (_hurdsig_preemptors);
608 __mutex_unlock (&_hurd_siglock);
609 }
610 }
611
612 ss_suspended = 0;
613
614 if (handler == SIG_IGN)
615 /* Ignore the signal altogether. */
616 act = ignore;
617 else if (handler != SIG_ERR)
618 /* Run the preemption-provided handler. */
619 act = handle;
620 else
621 {
622 /* No preemption. Do normal handling. */
623
624 if (!untraced && __sigismember (&_hurdsig_traced, signo))
625 {
626 /* We are being traced. Stop to tell the debugger of the signal. */
627 if (_hurd_stopped)
628 /* Already stopped. Mark the signal as pending;
629 when resumed, we will notice it and stop again. */
630 mark_pending ();
631 else
632 suspend ();
633 __spin_unlock (&ss->lock);
634 reply ();
635 return;
636 }
637
638 handler = ss->actions[signo].sa_handler;
639
640 if (handler == SIG_DFL)
641 /* Figure out the default action for this signal. */
642 switch (signo)
643 {
644 case 0:
645 /* A sig_post msg with SIGNO==0 is sent to
646 tell us to check for pending signals. */
647 act = ignore;
648 break;
649
650 case SIGTTIN:
651 case SIGTTOU:
652 case SIGSTOP:
653 case SIGTSTP:
654 act = stop;
655 break;
656
657 case SIGCONT:
658 case SIGIO:
659 case SIGURG:
660 case SIGCHLD:
661 case SIGWINCH:
662 act = ignore;
663 break;
664
665 case SIGQUIT:
666 case SIGILL:
667 case SIGTRAP:
668 case SIGIOT:
669 case SIGEMT:
670 case SIGFPE:
671 case SIGBUS:
672 case SIGSEGV:
673 case SIGSYS:
674 act = core;
675 break;
676
677 case SIGINFO:
678 if (_hurd_pgrp == _hurd_pid)
679 {
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. */
686 act = handle;
687 handler = _hurd_siginfo_handler;
688 }
689 else
690 act = ignore;
691 break;
692
693 default:
694 act = term;
695 break;
696 }
697 else if (handler == SIG_IGN)
698 act = ignore;
699 else
700 act = handle;
701
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);
706 else
707 {
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;
712
713 if (_hurd_stopped && act != stop && (untraced || signo == SIGCONT))
714 resume ();
715 }
716 }
717
718 if (_hurd_orphaned && act == stop
719 && (__sigmask (signo) & (__sigmask (SIGTTIN) | __sigmask (SIGTTOU)
720 | __sigmask (SIGTSTP))))
721 {
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;
726 signo = SIGKILL;
727 act = term;
728 }
729
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))
734 {
735 mark_pending ();
736 act = ignore;
737 }
738
739 /* Perform the chosen action for the signal. */
740 switch (act)
741 {
742 case stop:
743 if (_hurd_stopped)
744 {
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));
750 assert_perror (err);
751 }
752 else
753 /* Suspend the process. */
754 suspend ();
755 break;
756
757 case ignore:
758 if (detail->exc)
759 /* Blocking or ignoring a machine exception is fatal.
760 Otherwise we could just spin on the faulting instruction. */
761 goto fatal;
762
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. */
766 if (ss_suspended)
767 {
768 err = __thread_resume (ss->thread);
769 assert_perror (err);
770 ss_suspended = 0;
771 }
772 break;
773
774 sigbomb:
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 ? */
778 signo = SIGILL;
779
780 fatal:
781 act = core;
782 /* FALLTHROUGH */
783
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));
788 assert_perror (err);
789 /* No more user instructions will be executed.
790 The signal can now be considered delivered. */
791 reply ();
792 /* Abort all server operations now in progress. */
793 abort_all_rpcs (signo, &thread_state, 0);
794
795 {
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))
800 status |= WCOREFLAG;
801 /* Tell proc how we died and then stick the saber in the gut. */
802 _hurd_exit (status);
803 /* NOTREACHED */
804 }
805
806 case handle:
807 /* Call a handler for this signal. */
808 {
809 struct sigcontext *scp, ocontext;
810 int wait_for_reply, state_changed;
811
812 /* Stop the thread and abort its pending RPC operations. */
813 if (! ss_suspended)
814 {
815 err = __thread_suspend (ss->thread);
816 assert_perror (err);
817 }
818
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);
825
826 if (ss->context)
827 {
828 /* We have a previous sigcontext that sigreturn was about
829 to restore when another signal arrived. */
830
831 mach_port_t *loc;
832
833 if (_hurdsig_catch_memory_fault (ss->context))
834 {
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
838 problem. */
839 ss->context = NULL;
840 }
841 else
842 {
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;
847 }
848 _hurdsig_end_catch_fault ();
849
850 if (! machine_get_basic_state (ss->thread, &thread_state))
851 goto sigbomb;
852 loc = interrupted_reply_port_location (ss->thread,
853 &thread_state, 1);
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);
859
860 /* The thread was in sigreturn, not in any interruptible RPC. */
861 wait_for_reply = 0;
862
863 assert (! __spin_lock_locked (&ss->critical_section_lock));
864 }
865 else
866 {
867 int crit = __spin_lock_locked (&ss->critical_section_lock);
868
869 wait_for_reply
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
876 as a unit. */
877 crit ? 0 : signo, 1,
878 &thread_state, &state_changed,
879 &reply)
880 != MACH_PORT_NULL);
881
882 if (crit)
883 {
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. */
887 mark_pending ();
888 if (state_changed)
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);
900 /* */
901 ss->intr_port = MACH_PORT_NULL;
902 __thread_resume (ss->thread);
903 break;
904 }
905 }
906
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);
911 if (scp == NULL)
912 goto sigbomb;
913
914 /* Set the machine-independent parts of the signal context. */
915
916 {
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,
920 &thread_state,
921 1);
922 if (loc)
923 {
924 scp->sc_reply_port = *loc;
925 *loc = MACH_PORT_NULL;
926 }
927 else
928 scp->sc_reply_port = MACH_PORT_NULL;
929
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;
934
935 if (ss->context)
936 {
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. */
940
941 scp->sc_reply_port = ss->context->sc_reply_port;
942 scp->sc_intr_port = ss->context->sc_intr_port;
943
944 ss->context = NULL;
945 }
946 }
947
948 /* Backdoor extra argument to signal handler. */
949 scp->sc_error = detail->error;
950
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);
954
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);
958
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;
965
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);
971 assert_perror (err);
972 err = __thread_resume (ss->thread);
973 assert_perror (err);
974 thread_state.set = 0; /* Everything we know is now wrong. */
975 break;
976 }
977 }
978
979 /* The signal has either been ignored or is now being handled. We can
980 consider it delivered and reply to the killer. */
981 reply ();
982
983 /* We get here unless the signal was fatal. We still hold SS->lock.
984 Check for pending signals, and loop to post them. */
985 {
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)
993 {
994 if (_hurd_stopped || __spin_lock_locked (&ss->critical_section_lock))
995 return 0;
996 return pending = ss->pending & ~ss->blocked;
997 }
998
999 check_pending_signals:
1000 untraced = 0;
1001
1002 if (signals_pending ())
1003 {
1004 for (signo = 1; signo < NSIG; ++signo)
1005 if (__sigismember (&pending, signo))
1006 {
1007 deliver_pending:
1008 __sigdelset (&ss->pending, signo);
1009 *detail = ss->pending_data[signo];
1010 __spin_unlock (&ss->lock);
1011 goto post_signal;
1012 }
1013 }
1014
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. */
1018 if (signo == 0)
1019 {
1020 __spin_unlock (&ss->lock);
1021 __mutex_lock (&_hurd_siglock);
1022 for (ss = _hurd_sigstates; ss != NULL; ss = ss->next)
1023 {
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))
1033 {
1034 __mutex_unlock (&_hurd_siglock);
1035 goto deliver_pending;
1036 }
1037 __spin_unlock (&ss->lock);
1038 }
1039 __mutex_unlock (&_hurd_siglock);
1040 }
1041 else
1042 {
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)
1046 {
1047 /* There is a sigsuspend waiting. Tell it to wake up. */
1048 error_t err;
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,
1058 MACH_PORT_NULL);
1059 assert_perror (err);
1060 }
1061 __spin_unlock (&ss->lock);
1062 }
1063 }
1064
1065 /* All pending signals delivered to all threads.
1066 Now we can send the reply message even for signal 0. */
1067 reply ();
1068}
1069
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. */
1072
1073static error_t
1074signal_allowed (int signo, mach_port_t refport)
1075{
1076 if (signo < 0 || signo >= NSIG)
1077 return EINVAL;
1078
1079 if (refport == __mach_task_self ())
1080 /* Can send any signal. */
1081 goto win;
1082
1083 /* Avoid needing to check for this below. */
1084 if (refport == MACH_PORT_NULL)
1085 return EPERM;
1086
1087 switch (signo)
1088 {
1089 case SIGINT:
1090 case SIGQUIT:
1091 case SIGTSTP:
1092 case SIGHUP:
1093 case SIGINFO:
1094 case SIGTTIN:
1095 case SIGTTOU:
1096 case SIGWINCH:
1097 /* Job control signals can be sent by the controlling terminal. */
1098 if (__USEPORT (CTTYID, port == refport))
1099 goto win;
1100 break;
1101
1102 case SIGCONT:
1103 {
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)))
1107 {
1108 __mach_port_deallocate (__mach_task_self (), sessport);
1109 if (refport == sessport)
1110 goto win;
1111 }
1112 }
1113 break;
1114
1115 case SIGIO:
1116 case SIGURG:
1117 {
1118 /* Any io object a file descriptor refers to might send us
1119 one of these signals using its async ID port for REFPORT.
1120
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.
1127
1128 Someday we could implement some reasonable scheme for
1129 authorizing SIGIO and SIGURG signals properly. */
1130
1131 int d;
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)
1135 {
1136 struct hurd_userlink ulink;
1137 io_t port;
1138 mach_port_t asyncid;
1139 if (_hurd_dtable[d] == NULL)
1140 continue;
1141 port = _hurd_port_get (&_hurd_dtable[d]->port, &ulink);
1142 if (! __io_get_icky_async_id (port, &asyncid))
1143 {
1144 if (refport == asyncid)
1145 /* Break out of the loop on the next iteration. */
1146 lucky = 1;
1147 __mach_port_deallocate (__mach_task_self (), asyncid);
1148 }
1149 _hurd_port_free (&_hurd_dtable[d]->port, &ulink, port);
1150 }
1151 __mutex_unlock (&_hurd_dtable_lock);
1152 /* If we found a lucky winner, we've set D to -1 in the loop. */
1153 if (lucky)
1154 goto win;
1155 }
1156 }
1157
1158 /* If this signal is legit, we have done `goto win' by now.
1159 When we return the error, mig deallocates REFPORT. */
1160 return EPERM;
1161
1162 win:
1163 /* Deallocate the REFPORT send right; we are done with it. */
1164 __mach_port_deallocate (__mach_task_self (), refport);
1165
1166 return 0;
1167}
1168
1169/* Implement the sig_post RPC from <hurd/msg.defs>;
1170 sent when someone wants us to get a signal. */
1171kern_return_t
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)
1176{
1177 error_t err;
1178 struct hurd_signal_detail d;
1179
1180 if (err = signal_allowed (signo, refport))
1181 return err;
1182
1183 d.code = sigcode;
1184 d.exc = 0;
1185
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. */
1191
1192 return MIG_NO_REPLY; /* Already replied. */
1193}
1194
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. */
1198kern_return_t
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)
1204{
1205 error_t err;
1206 struct hurd_signal_detail d;
1207
1208 if (err = signal_allowed (signo, refport))
1209 return err;
1210
1211 d.code = sigcode;
1212 d.exc = 0;
1213
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. */
1219
1220 return MIG_NO_REPLY; /* Already replied. */
1221}
1222
1223extern void __mig_init (void *);
1224
1225#include <mach/task_special_ports.h>
1226
1227/* Initialize the message port and _hurd_sigthread and start the signal
1228 thread. */
1229
1230void
1231_hurdsig_init (const int *intarray, size_t intarraysize)
1232{
1233 error_t err;
1234 vm_size_t stacksize;
1235 struct hurd_sigstate *ss;
1236
1237 __mutex_init (&_hurd_siglock);
1238
1239 err = __mach_port_allocate (__mach_task_self (),
1240 MACH_PORT_RIGHT_RECEIVE,
1241 &_hurd_msgport);
1242 assert_perror (err);
1243
1244 /* Make a send right to the signal port. */
1245 err = __mach_port_insert_right (__mach_task_self (),
1246 _hurd_msgport,
1247 _hurd_msgport,
1248 MACH_MSG_TYPE_MAKE_SEND);
1249 assert_perror (err);
1250
1251 /* Initialize the main thread's signal state. */
1252 ss = _hurd_self_sigstate ();
1253
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)
1261 {
1262 int signo;
1263 for (signo = 1; signo < NSIG; ++signo)
1264 if (intarray[INIT_SIGIGN] & __sigmask(signo))
1265 ss->actions[signo].sa_handler = SIG_IGN;
1266 }
1267
1268 /* Set the default thread to receive task-global signals
1269 to this one, the main (first) user thread. */
1270 _hurd_sigthread = ss->thread;
1271
1272 /* Start the signal thread listening on the message port. */
1273
1274#pragma weak __cthread_fork
1275 if (!__cthread_fork)
1276 {
1277 err = __thread_create (__mach_task_self (), &_hurd_msgport_thread);
1278 assert_perror (err);
1279
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,
1284 &stacksize);
1285 assert_perror (err);
1286 err = __mach_setup_tls (_hurd_msgport_thread);
1287 assert_perror (err);
1288
1289 __hurd_sigthread_stack_end = __hurd_sigthread_stack_base + stacksize;
1290
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);
1294
1295 err = __thread_resume (_hurd_msgport_thread);
1296 assert_perror (err);
1297 }
1298 else
1299 {
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);
1315
1316 if (__pthread_getattr_np)
1317 {
1318 /* Record signal thread stack layout for fork() */
1319 pthread_attr_t attr;
1320 void *addr;
1321 size_t size;
1322
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;
1327 }
1328
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)
1336 __swtch_pri (0);
1337 }
1338
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),
1348 _hurd_msgport,
1349 EXCEPTION_DEFAULT, MACHINE_THREAD_STATE);
1350#else
1351# error task_set_exception_port?
1352#endif
1353
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);
1359}
1360 /* XXXX */
1361/* Reauthenticate with the proc server. */
1362
1363static void
1364reauth_proc (mach_port_t new)
1365{
1366 mach_port_t ref, ignore;
1367
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,
1374 &ignore))
1375 && ignore != MACH_PORT_NULL)
1376 __mach_port_deallocate (__mach_task_self (), ignore);
1377 __mach_port_destroy (__mach_task_self (), ref);
1378
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,
1384 (_hurd_id.gen.nuids
1385 ? _hurd_id.gen.uids[0] : 0),
1386 !_hurd_id.gen.nuids));
1387 __mutex_unlock (&_hurd_id.lock);
1388
1389 (void) &reauth_proc; /* Silence compiler warning. */
1390}
1391text_set_element (_hurd_reauth_hook, reauth_proc);
1392
1393/* Like `getenv', but safe for the signal thread to run.
1394 If the environment is trashed, this will just return NULL. */
1395
1396const char *
1397_hurdsig_getenv (const char *variable)
1398{
1399 if (__libc_enable_secure)
1400 return NULL;
1401
1402 if (_hurdsig_catch_memory_fault (__environ))
1403 /* We bombed in getenv. */
1404 return NULL;
1405 else
1406 {
1407 const size_t len = strlen (variable);
1408 char *value = NULL;
1409 char *volatile *ep = __environ;
1410 while (*ep)
1411 {
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] == '=')
1416 {
1417 size_t valuelen;
1418 p += len + 1;
1419 valuelen = strlen (p);
1420 _hurdsig_fault_preemptor.last = (long int) (p + valuelen);
1421 value = malloc (++valuelen);
1422 if (value)
1423 memcpy (value, p, valuelen);
1424 break;
1425 }
1426 _hurdsig_fault_preemptor.first = (long int) ++ep;
1427 _hurdsig_fault_preemptor.last = (long int) (ep + 1);
1428 }
1429 _hurdsig_end_catch_fault ();
1430 return value;
1431 }
1432}
1433

Warning: That file was not part of the compilation database. It may have many parsing errors.