about summary refs log tree commit diff
path: root/sysdeps/mach/hurd/fork.c
blob: 395cbe1e07c1923fc8bcba87e1d83823ce87966f (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
/* Copyright (C) 1994-2019 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <https://www.gnu.org/licenses/>.  */

#include <errno.h>
#include <unistd.h>
#include <hurd.h>
#include <hurd/signal.h>
#include <hurd/threadvar.h>
#include <setjmp.h>
#include <thread_state.h>
#include <sysdep.h>		/* For stack growth direction.  */
#include "set-hooks.h"
#include <assert.h>
#include "hurdmalloc.h"		/* XXX */
#include <tls.h>
#include <malloc/malloc-internal.h>

#undef __fork


/* Things that want to be locked while forking.  */
symbol_set_declare (_hurd_fork_locks)


/* Application callbacks registered through pthread_atfork.  */
DEFINE_HOOK (_hurd_atfork_prepare_hook, (void));
DEFINE_HOOK (_hurd_atfork_child_hook, (void));
DEFINE_HOOK (_hurd_atfork_parent_hook, (void));

/* Things that want to be called before we fork, to prepare the parent for
   task_create, when the new child task will inherit our address space.  */
DEFINE_HOOK (_hurd_fork_prepare_hook, (void));

/* Things that want to be called when we are forking, with the above all
   locked.  They are passed the task port of the child.  The child process
   is all set up except for doing proc_child, and has no threads yet.  */
DEFINE_HOOK (_hurd_fork_setup_hook, (void));

/* Things to be run in the child fork.  */
DEFINE_HOOK (_hurd_fork_child_hook, (void));

/* Things to be run in the parent fork.  */
DEFINE_HOOK (_hurd_fork_parent_hook, (void));


/* Clone the calling process, creating an exact copy.
   Return -1 for errors, 0 to the new process,
   and the process ID of the new process to the old process.  */
pid_t
__fork (void)
{
  jmp_buf env;
  pid_t pid;
  size_t i;
  error_t err;
  struct hurd_sigstate *volatile ss;

  RUN_HOOK (_hurd_atfork_prepare_hook, ());

  ss = _hurd_self_sigstate ();
  __spin_lock (&ss->critical_section_lock);

#undef	LOSE
#define LOSE do { assert_perror (err); goto lose; } while (0) /* XXX */

  if (! setjmp (env))
    {
      process_t newproc;
      task_t newtask;
      thread_t thread, sigthread;
      mach_port_urefs_t thread_refs, sigthread_refs;
      struct machine_thread_state state;
      mach_msg_type_number_t statecount;
      mach_port_t *portnames = NULL;
      mach_msg_type_number_t nportnames = 0;
      mach_port_type_t *porttypes = NULL;
      mach_msg_type_number_t nporttypes = 0;
      thread_t *threads = NULL;
      mach_msg_type_number_t nthreads = 0;
      int ports_locked = 0, stopped = 0;

      void resume_threads (void)
	{
	  if (! stopped)
	    return;

	  assert (threads);

	  for (i = 0; i < nthreads; ++i)
	    if (threads[i] != ss->thread)
	      __thread_resume (threads[i]);
	  stopped = 0;
	}

      /* Run things that prepare for forking before we create the task.  */
      RUN_HOOK (_hurd_fork_prepare_hook, ());

      /* Lock things that want to be locked before we fork.  */
      {
	void *const *p;
	for (p = symbol_set_first_element (_hurd_fork_locks);
	     ! symbol_set_end_p (_hurd_fork_locks, p);
	     ++p)
	  __mutex_lock (*p);
      }
      __mutex_lock (&_hurd_siglock);

      /* Acquire malloc locks.  This needs to come last because fork
	 handlers may use malloc, and the libio list lock has an
	 indirect malloc dependency as well (via the getdelim
	 function).  */
      call_function_static_weak (__malloc_fork_lock_parent);
      _hurd_malloc_fork_prepare ();

      newtask = MACH_PORT_NULL;
      thread = sigthread = MACH_PORT_NULL;
      newproc = MACH_PORT_NULL;

      /* Lock all the port cells for the standard ports while we copy the
	 address space.  We want to insert all the send rights into the
	 child with the same names.  */
      for (i = 0; i < _hurd_nports; ++i)
	__spin_lock (&_hurd_ports[i].lock);
      ports_locked = 1;


      /* Keep our SS locked while stopping other threads, so they don't get a
         chance to have it locked in the copied space.  */
      __spin_lock (&ss->lock);
      /* Stop all other threads while copying the address space,
	 so nothing changes.  */
      err = __proc_dostop (_hurd_ports[INIT_PORT_PROC].port, ss->thread);
      __spin_unlock (&ss->lock);
      if (!err)
	{
	  stopped = 1;

#define XXX_KERNEL_PAGE_FAULT_BUG /* XXX work around page fault bug in mk */

#ifdef XXX_KERNEL_PAGE_FAULT_BUG
	  /* Gag me with a pitchfork.
	     The bug scenario is this:

	     - The page containing __mach_task_self_ is paged out.
	     - The signal thread was faulting on that page when we
	       suspended it via proc_dostop.  It holds some lock, or set
	       some busy bit, or somesuch.
	     - Now this thread faults on that same page.
	     - GRATUIOUS DEADLOCK

	     We can break the deadlock by aborting the thread that faulted
	     first, which if the bug happened was the signal thread because
	     it is the only other thread and we just suspended it.
	     */
	  __thread_abort (_hurd_msgport_thread);
#endif
	  /* Create the child task.  It will inherit a copy of our memory.  */
	  err = __task_create (__mach_task_self (),
#ifdef KERN_INVALID_LEDGER
			       NULL, 0,	/* OSF Mach */
#endif
			       1, &newtask);
	}

      /* Unlock the global signal state lock, so we do not
	 block the signal thread any longer than necessary.  */
      __mutex_unlock (&_hurd_siglock);

      if (err)
	LOSE;

      /* Fetch the names of all ports used in this task.  */
      if (err = __mach_port_names (__mach_task_self (),
				   &portnames, &nportnames,
				   &porttypes, &nporttypes))
	LOSE;
      if (nportnames != nporttypes)
	{
	  err = EGRATUITOUS;
	  LOSE;
	}

      /* Get send rights for all the threads in this task.
	 We want to avoid giving these rights to the child.  */
      if (err = __task_threads (__mach_task_self (), &threads, &nthreads))
	LOSE;

      /* Get the child process's proc server port.  We will insert it into
	 the child with the same name as we use for our own proc server
	 port; and we will need it to set the child's message port.  */
      if (err = __proc_task2proc (_hurd_ports[INIT_PORT_PROC].port,
				  newtask, &newproc))
	LOSE;

      /* Insert all our port rights into the child task.  */
      thread_refs = sigthread_refs = 0;
      for (i = 0; i < nportnames; ++i)
	{
	  if (porttypes[i] & MACH_PORT_TYPE_RECEIVE)
	    {
	      /* This is a receive right.  We want to give the child task
		 its own new receive right under the same name.  */
	      if (err = __mach_port_allocate_name (newtask,
						   MACH_PORT_RIGHT_RECEIVE,
						   portnames[i]))
		LOSE;
	      if (porttypes[i] & MACH_PORT_TYPE_SEND)
		{
		  /* Give the child as many send rights for its receive
		     right as we have for ours.  */
		  mach_port_urefs_t refs;
		  mach_port_t port;
		  mach_msg_type_name_t poly;
		  if (err = __mach_port_get_refs (__mach_task_self (),
						  portnames[i],
						  MACH_PORT_RIGHT_SEND,
						  &refs))
		    LOSE;
		  if (err = __mach_port_extract_right (newtask,
						       portnames[i],
						       MACH_MSG_TYPE_MAKE_SEND,
						       &port, &poly))
		    LOSE;
		  if (portnames[i] == _hurd_msgport)
		    {
		      /* We just created a receive right for the child's
			 message port and are about to insert send rights
			 for it.  Now, while we happen to have a send right
			 for it, give it to the proc server.  */
		      mach_port_t old;
		      if (err = __proc_setmsgport (newproc, port, &old))
			LOSE;
		      if (old != MACH_PORT_NULL)
			/* XXX what to do here? */
			__mach_port_deallocate (__mach_task_self (), old);
		      /* The new task will receive its own exceptions
			 on its message port.  */
		      if (err =
#ifdef TASK_EXCEPTION_PORT
			  __task_set_special_port (newtask,
						   TASK_EXCEPTION_PORT,
						   port)
#elif defined (EXC_MASK_ALL)
			  __task_set_exception_ports
			  (newtask, EXC_MASK_ALL & ~(EXC_MASK_SYSCALL
						     | EXC_MASK_MACH_SYSCALL
						     | EXC_MASK_RPC_ALERT),
			   port, EXCEPTION_DEFAULT, MACHINE_THREAD_STATE)
#else
# error task_set_exception_port?
#endif
			  )
			LOSE;
		    }
		  if (err = __mach_port_insert_right (newtask,
						      portnames[i],
						      port,
						      MACH_MSG_TYPE_MOVE_SEND))
		    LOSE;
		  if (refs > 1
		      && (err = __mach_port_mod_refs (newtask,
						      portnames[i],
						      MACH_PORT_RIGHT_SEND,
						      refs - 1)))
		    LOSE;
		}
	      if (porttypes[i] & MACH_PORT_TYPE_SEND_ONCE)
		{
		  /* Give the child a send-once right for its receive right,
		     since we have one for ours.  */
		  mach_port_t port;
		  mach_msg_type_name_t poly;
		  if (err = __mach_port_extract_right
		      (newtask,
		       portnames[i],
		       MACH_MSG_TYPE_MAKE_SEND_ONCE,
		       &port, &poly))
		    LOSE;
		  if (err = __mach_port_insert_right
		      (newtask,
		       portnames[i], port,
		       MACH_MSG_TYPE_MOVE_SEND_ONCE))
		    LOSE;
		}
	    }
	  else if (porttypes[i]
		   & (MACH_PORT_TYPE_SEND|MACH_PORT_TYPE_DEAD_NAME))
	    {
	      /* This is a send right or a dead name.
		 Give the child as many references for it as we have.  */
	      mach_port_urefs_t refs = 0, *record_refs = NULL;
	      mach_port_t insert;
	      mach_msg_type_name_t insert_type = MACH_MSG_TYPE_COPY_SEND;
	      if (portnames[i] == newtask || portnames[i] == newproc)
		/* Skip the name we use for the child's task or proc ports.  */
		continue;
	      if (portnames[i] == __mach_task_self ())
		/* For the name we use for our own task port,
		   insert the child's task port instead.  */
		insert = newtask;
	      else if (portnames[i] == _hurd_ports[INIT_PORT_PROC].port)
		{
		  /* Use the proc server port for the new task.  */
		  insert = newproc;
		  insert_type = MACH_MSG_TYPE_COPY_SEND;
		}
	      else if (portnames[i] == ss->thread)
		{
		  /* For the name we use for our own thread port, we will
		     insert the thread port for the child main user thread
		     after we create it.  */
		  insert = MACH_PORT_NULL;
		  record_refs = &thread_refs;
		  /* Allocate a dead name right for this name as a
		     placeholder, so the kernel will not chose this name
		     for any other new port (it might use it for one of the
		     rights created when a thread is created).  */
		  if (err = __mach_port_allocate_name
		      (newtask, MACH_PORT_RIGHT_DEAD_NAME, portnames[i]))
		    LOSE;
		}
	      else if (portnames[i] == _hurd_msgport_thread)
		/* For the name we use for our signal thread's thread port,
		   we will insert the thread port for the child's signal
		   thread after we create it.  */
		{
		  insert = MACH_PORT_NULL;
		  record_refs = &sigthread_refs;
		  /* Allocate a dead name right as a placeholder.  */
		  if (err = __mach_port_allocate_name
		      (newtask, MACH_PORT_RIGHT_DEAD_NAME, portnames[i]))
		    LOSE;
		}
	      else
		{
		  /* Skip the name we use for any of our own thread ports.  */
		  mach_msg_type_number_t j;
		  for (j = 0; j < nthreads; ++j)
		    if (portnames[i] == threads[j])
		      break;
		  if (j < nthreads)
		    continue;

		  /* Copy our own send right.  */
		  insert = portnames[i];
		}
	      /* Find out how many user references we have for
		 the send right with this name.  */
	      if (err = __mach_port_get_refs (__mach_task_self (),
					      portnames[i],
					      MACH_PORT_RIGHT_SEND,
					      record_refs ?: &refs))
		LOSE;
	      if (insert == MACH_PORT_NULL)
		continue;
	      if (insert == portnames[i]
		  && (porttypes[i] & MACH_PORT_TYPE_DEAD_NAME))
		/* This is a dead name; allocate another dead name
		   with the same name in the child.  */
	      allocate_dead_name:
		err = __mach_port_allocate_name (newtask,
						 MACH_PORT_RIGHT_DEAD_NAME,
						 portnames[i]);
	      else
		/* Insert the chosen send right into the child.  */
		err = __mach_port_insert_right (newtask,
						portnames[i],
						insert, insert_type);
	      switch (err)
		{
		case KERN_NAME_EXISTS:
		  {
		    /* It already has a send right under this name (?!).
		       Well, it starts out with a send right for its task
		       port, and inherits the bootstrap and exception ports
		       from us.  */
		    mach_port_t childport;
		    mach_msg_type_name_t poly;
		    assert (__mach_port_extract_right (newtask, portnames[i],
						       MACH_MSG_TYPE_COPY_SEND,
						       &childport,
						       &poly) == 0
			    && childport == insert
			    && __mach_port_deallocate (__mach_task_self (),
						       childport) == 0);
		    break;
		  }

		case KERN_INVALID_CAPABILITY:
		  /* The port just died.  It was a send right,
		     and now it's a dead name.  */
		  goto allocate_dead_name;

		default:
		  LOSE;
		  break;

		case KERN_SUCCESS:
		  /* Give the child as many user references as we have.  */
		  if (refs > 1
		      && (err = __mach_port_mod_refs (newtask,
						      portnames[i],
						      MACH_PORT_RIGHT_SEND,
						      refs - 1)))
		    LOSE;
		}
	    }
	}

      /* Unlock the standard port cells.  The child must unlock its own
	 copies too.  */
      for (i = 0; i < _hurd_nports; ++i)
	__spin_unlock (&_hurd_ports[i].lock);
      ports_locked = 0;

      /* All state has now been copied from the parent.  It is safe to
	 resume other parent threads.  */
      resume_threads ();

      /* Create the child main user thread and signal thread.  */
      if ((err = __thread_create (newtask, &thread))
	  || (err = __thread_create (newtask, &sigthread)))
	LOSE;

      /* Insert send rights for those threads.  We previously allocated
	 dead name rights with the names we want to give the thread ports
	 in the child as placeholders.  Now deallocate them so we can use
	 the names.  */
      if ((err = __mach_port_deallocate (newtask, ss->thread))
	  || (err = __mach_port_insert_right (newtask, ss->thread,
					      thread,
					      MACH_MSG_TYPE_COPY_SEND)))
	LOSE;
      /* XXX consumed? (_hurd_sigthread is no more) */
      if (thread_refs > 1
	  && (err = __mach_port_mod_refs (newtask, ss->thread,
					  MACH_PORT_RIGHT_SEND,
					  thread_refs - 1)))
	LOSE;
      if ((_hurd_msgport_thread != MACH_PORT_NULL) /* Let user have none.  */
	  && ((err = __mach_port_deallocate (newtask, _hurd_msgport_thread))
	      || (err = __mach_port_insert_right (newtask,
						  _hurd_msgport_thread,
						  sigthread,
						  MACH_MSG_TYPE_COPY_SEND))))
	LOSE;
      if (sigthread_refs > 1
	  && (err = __mach_port_mod_refs (newtask, _hurd_msgport_thread,
					  MACH_PORT_RIGHT_SEND,
					  sigthread_refs - 1)))
	LOSE;

      /* This seems like a convenient juncture to copy the proc server's
	 idea of what addresses our argv and envp are found at from the
	 parent into the child.  Since we happen to know that the child
	 shares our memory image, it is we who should do this copying.  */
      {
	vm_address_t argv, envp;
	err = (__USEPORT (PROC, __proc_get_arg_locations (port, &argv, &envp))
	       ?: __proc_set_arg_locations (newproc, argv, envp));
	if (err)
	  LOSE;
      }

      /* Set the child signal thread up to run the msgport server function
	 using the same signal thread stack copied from our address space.
	 We fetch the state before longjmp'ing it so that miscellaneous
	 registers not affected by longjmp (such as i386 segment registers)
	 are in their normal default state.  */
      statecount = MACHINE_THREAD_STATE_COUNT;
      if (err = __thread_get_state (_hurd_msgport_thread,
				    MACHINE_THREAD_STATE_FLAVOR,
				    (natural_t *) &state, &statecount))
	LOSE;
#ifdef STACK_GROWTH_UP
      if (__hurd_sigthread_stack_base == 0)
	{
	  state.SP &= __hurd_threadvar_stack_mask;
	  state.SP += __hurd_threadvar_stack_offset;
	}
      else
	state.SP = __hurd_sigthread_stack_base;
#else
      if (__hurd_sigthread_stack_end == 0)
	{
	  /* The signal thread has a stack assigned by cthreads.
	     The threadvar_stack variables conveniently tell us how
	     to get to the highest address in the stack, just below
	     the per-thread variables.  */
	  state.SP &= __hurd_threadvar_stack_mask;
	  state.SP += __hurd_threadvar_stack_offset;
	}
      else
	state.SP = __hurd_sigthread_stack_end;
#endif
      MACHINE_THREAD_STATE_SET_PC (&state,
				   (unsigned long int) _hurd_msgport_receive);

      /* Do special signal thread setup for TLS if needed.  */
      if (err = _hurd_tls_fork (sigthread, _hurd_msgport_thread, &state))
	LOSE;

      if (err = __thread_set_state (sigthread, MACHINE_THREAD_STATE_FLAVOR,
				    (natural_t *) &state, statecount))
	LOSE;
      /* We do not thread_resume SIGTHREAD here because the child
	 fork needs to do more setup before it can take signals.  */

      /* Set the child user thread up to return 1 from the setjmp above.  */
      _hurd_longjmp_thread_state (&state, env, 1);

      /* Do special thread setup for TLS if needed.  */
      if (err = _hurd_tls_fork (thread, ss->thread, &state))
	LOSE;

      if (err = __thread_set_state (thread, MACHINE_THREAD_STATE_FLAVOR,
				    (natural_t *) &state, statecount))
	LOSE;

      /* Get the PID of the child from the proc server.  We must do this
	 before calling proc_child below, because at that point any
	 authorized POSIX.1 process may kill the child task with SIGKILL.  */
      if (err = __USEPORT (PROC, __proc_task2pid (port, newtask, &pid)))
	LOSE;

      /* Register the child with the proc server.  It is important that
	 this be that last thing we do before starting the child thread
	 running.  Once proc_child has been done for the task, it appears
	 as a POSIX.1 process.  Any errors we get must be detected before
	 this point, and the child must have a message port so it responds
	 to POSIX.1 signals.  */
      if (err = __USEPORT (PROC, __proc_child (port, newtask)))
	LOSE;

      /* This must be the absolutely last thing we do; we can't assume that
	 the child will remain alive for even a moment once we do this.  We
	 ignore errors because we have committed to the fork and are not
	 allowed to return them after the process becomes visible to
	 POSIX.1 (which happened right above when we called proc_child).  */
      (void) __thread_resume (thread);

    lose:
      if (ports_locked)
	for (i = 0; i < _hurd_nports; ++i)
	  __spin_unlock (&_hurd_ports[i].lock);

      resume_threads ();

      if (newtask != MACH_PORT_NULL)
	{
	  if (err)
	    __task_terminate (newtask);
	  __mach_port_deallocate (__mach_task_self (), newtask);
	}
      if (thread != MACH_PORT_NULL)
	__mach_port_deallocate (__mach_task_self (), thread);
      if (sigthread != MACH_PORT_NULL)
	__mach_port_deallocate (__mach_task_self (), sigthread);
      if (newproc != MACH_PORT_NULL)
	__mach_port_deallocate (__mach_task_self (), newproc);

      if (portnames)
	__vm_deallocate (__mach_task_self (),
			 (vm_address_t) portnames,
			 nportnames * sizeof (*portnames));
      if (porttypes)
	__vm_deallocate (__mach_task_self (),
			 (vm_address_t) porttypes,
			 nporttypes * sizeof (*porttypes));
      if (threads)
	{
	  for (i = 0; i < nthreads; ++i)
	    __mach_port_deallocate (__mach_task_self (), threads[i]);
	  __vm_deallocate (__mach_task_self (),
			   (vm_address_t) threads,
			   nthreads * sizeof (*threads));
	}

      /* Release malloc locks.  */
      _hurd_malloc_fork_parent ();
      call_function_static_weak (__malloc_fork_unlock_parent);

      /* Run things that want to run in the parent to restore it to
	 normality.  Usually prepare hooks and parent hooks are
	 symmetrical: the prepare hook arrests state in some way for the
	 fork, and the parent hook restores the state for the parent to
	 continue executing normally.  */
      RUN_HOOK (_hurd_fork_parent_hook, ());
    }
  else
    {
      struct hurd_sigstate *oldstates;

      /* We are the child task.  Unlock the standard port cells, which were
	 locked in the parent when we copied its memory.  The parent has
	 inserted send rights with the names that were in the cells then.  */
      for (i = 0; i < _hurd_nports; ++i)
	__spin_unlock (&_hurd_ports[i].lock);

      /* Claim our sigstate structure and unchain the rest: the
	 threads existed in the parent task but don't exist in this
	 task (the child process).  Delay freeing them until later
	 because some of the further setup and unlocking might be
	 required for free to work.  Before we finish cleaning up,
	 we will reclaim the signal thread's sigstate structure (if
	 it had one).  */
      oldstates = _hurd_sigstates;
      if (oldstates == ss)
	oldstates = ss->next;
      else
	{
	  while (_hurd_sigstates->next != ss)
	    _hurd_sigstates = _hurd_sigstates->next;
	  _hurd_sigstates->next = ss->next;
	}
      ss->next = NULL;
      _hurd_sigstates = ss;
      __mutex_unlock (&_hurd_siglock);
      /* Earlier on, the global sigstate may have been tainted and now needs to
         be reinitialized.  Nobody is interested in its present state anymore:
         we're not, the signal thread will be restarted, and there are no other
         threads.

         We can't simply allocate a fresh global sigstate here, as
         _hurd_thread_sigstate will call malloc and that will deadlock trying
         to determine the current thread's sigstate.  */
#if 0
      _hurd_thread_sigstate_init (_hurd_global_sigstate, MACH_PORT_NULL);
#else
      /* Only reinitialize the lock -- otherwise we might have to do additional
         setup as done in hurdsig.c:_hurdsig_init.  */
      __spin_lock_init (&_hurd_global_sigstate->lock);
#endif

      /* We are one of the (exactly) two threads in this new task, we
	 will take the task-global signals.  */
      _hurd_sigstate_set_global_rcv (ss);

      /* Fetch our new process IDs from the proc server.  No need to
	 refetch our pgrp; it is always inherited from the parent (so
	 _hurd_pgrp is already correct), and the proc server will send us a
	 proc_newids notification when it changes.  */
      err = __USEPORT (PROC, __proc_getpids (port, &_hurd_pid, &_hurd_ppid,
					     &_hurd_orphaned));

      /* Forking clears the trace flag and pending masks.  */
      __sigemptyset (&_hurdsig_traced);
      __sigemptyset (&_hurd_global_sigstate->pending);
      __sigemptyset (&ss->pending);

      /* Release malloc locks.  */
      _hurd_malloc_fork_child ();
      call_function_static_weak (__malloc_fork_unlock_child);

      /* Run things that want to run in the child task to set up.  */
      RUN_HOOK (_hurd_fork_child_hook, ());

      /* Set up proc server-assisted fault recovery for the signal thread.  */
      _hurdsig_fault_init ();

      /* Start the signal thread listening on the message port.  */
      if (!err)
	err = __thread_resume (_hurd_msgport_thread);

      /* Reclaim the signal thread's sigstate structure and free the
	 other old sigstate structures.  */
      while (oldstates != NULL)
	{
	  struct hurd_sigstate *next = oldstates->next;

	  if (oldstates->thread == _hurd_msgport_thread)
	    {
	      /* If we have a second signal state structure then we
		 must have been through here before--not good.  */
	      assert (_hurd_sigstates->next == 0);
	      _hurd_sigstates->next = oldstates;
	      oldstates->next = 0;
	    }
	  else
	    free (oldstates);

	  oldstates = next;
	}

      /* XXX what to do if we have any errors here? */

      pid = 0;
    }

  /* Unlock things we locked before creating the child task.
     They are locked in both the parent and child tasks.  */
  {
    void *const *p;
    for (p = symbol_set_first_element (_hurd_fork_locks);
	 ! symbol_set_end_p (_hurd_fork_locks, p);
	 ++p)
      __mutex_unlock (*p);
  }

  _hurd_critical_section_unlock (ss);

  if (!err)
    {
      if (pid != 0)
	RUN_HOOK (_hurd_atfork_parent_hook, ());
      else
	RUN_HOOK (_hurd_atfork_child_hook, ());
    }

  return err ? __hurd_fail (err) : pid;
}
libc_hidden_def (__fork)

weak_alias (__fork, fork)