2013-01-01 17:29:10 +01:00
|
|
|
/* Copyright (C) 1994-2012 Free Software Foundation, Inc.
|
1997-06-23 23:55:26 +02:00
|
|
|
This file is part of the GNU C Library.
|
1995-02-18 02:27:10 +01:00
|
|
|
|
1997-06-23 23:55:26 +02:00
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
2001-07-06 06:58:11 +02:00
|
|
|
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.
|
1995-02-18 02:27:10 +01:00
|
|
|
|
1997-06-23 23:55:26 +02:00
|
|
|
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
|
2001-07-06 06:58:11 +02:00
|
|
|
Lesser General Public License for more details.
|
1995-02-18 02:27:10 +01:00
|
|
|
|
2001-07-06 06:58:11 +02:00
|
|
|
You should have received a copy of the GNU Lesser General Public
|
2012-02-10 00:18:22 +01:00
|
|
|
License along with the GNU C Library; if not, see
|
|
|
|
<http://www.gnu.org/licenses/>. */
|
1995-02-18 02:27:10 +01:00
|
|
|
|
|
|
|
#include <errno.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <hurd.h>
|
|
|
|
#include <hurd/signal.h>
|
|
|
|
#include <setjmp.h>
|
2005-12-21 23:16:34 +01:00
|
|
|
#include <thread_state.h>
|
1995-02-18 02:27:10 +01:00
|
|
|
#include <sysdep.h> /* For stack growth direction. */
|
|
|
|
#include "set-hooks.h"
|
|
|
|
#include <assert.h>
|
|
|
|
#include "hurdmalloc.h" /* XXX */
|
2004-10-27 09:48:08 +02:00
|
|
|
#include <tls.h>
|
1995-02-18 02:27:10 +01:00
|
|
|
|
Update.
* sysdeps/mach/hurd/chown.c: Use INTDEF for __chown.
* sysdeps/unix/sysv/aix/chown.c: Likewise.
* sysdeps/unix/grantpt.c: Use INTUSE for __chown calls.
* sysdeps/unix/sysv/linux/m68k/chown.c: Likewise.
* sysdeps/unix/sysv/linux/powerpc/chown.c: Likewise.
* sysdeps/unix/sysv/linux/i386/chown.c: Use INTDEF2 to define
__chown_internal.
* sysdeps/unix/sysv/linux/s390/s390-32//chown.c: Likewise.
* intl/dcngettext.c [_LIBC]: Use INTUSE for __dcngettext.
* intl/dngettext.c [_LIBC] (DCNGETTEXT): Use INTUSE.
* intl/ngettext.c: Likewise.
* include/sys/socket.h: Declare __connect_internal and define
__connect macro if not NOT_IN_libc.
* sysdeps/mach/hurd/connect.c: Use INTDEF for __connect.
* sysdeps/unix/sysv/aix/connect.c: Likewise.
* sysdeps/unix/sysv/linux/connect.S: Add __connect_internal alias.
* include/unistd.h: Declare __close_internal and define __close macro
if not NOT_IN_libc.
* libio/libioP.h (JUMO0, JUMP1, JUMP2, JUMP3, WJUMP0, WJUMP1, WJUMP2,
WJUMP3): Add extra parenthesis to avoid expanding element names with
macors like __close.
* sysdeps/unix/syscalls.list: Add __close_internal alias.
* include/unistd.h: Declare __dup2_internal and define __dup2 macro
if not NOT_IN_libc.
* sysdeps/mach/hurd/dup2.c: Use INTDEF for __dup2.
* sysdeps/posix/dup2.c: Use INTDEF for __dup2.
* sysdeps/unix/syscalls.list: Add __dup2_internal alias.
* include/unistd.h: Declare __fork_internal and define __fork macro
if not NOT_IN_libc.
* sysdeps/mach/hurd/fork.c: Use INTDEF for __fork.
* sysdeps/unix/sysv/aix/fork.c: Likewise.
* sysdeps/unix/sysv/linux/syscalls.list: Add __fork_internal alias.
* include/stdio_ext.h: Declare __fsetlocking_internal and define
__fsetlocking macro to use it if not NOT_IN_libc.
* libio/__fsetlocking.c: Use INTDEF for __fsetlocking.
* libio/__fbufsize.c: Correct copyright.
* libio/__flbf.c: Likewise.
* libio/__fpending.c: Likewise.
* libio/__fpurge.c: Likewise.
* libio/__freadable.c: Likewise.
* libio/__freading.c: Likewise.
* libio/__fsetlocking.c: Likewise.
* libio/__fwritable.c: Likewise.
* libio/__fwriting.c: Likewise.
* include/stdio.h: Declare __asprintf_internal and define __asprintf
macro to use it if not NOT_IN_libc.
* stdio-common/asprintf.c: Use INTDEF for __asprintf.
* include/mntent.h: Declare __setmntent_internal,
__getmntent_r_internal, __endmntent_internal. Define __setmntent,
__getmntent_r, and __endmntent macros to use these functions if not
NOT_IN_libc.
* misc/mntent_r.c: Use INTDEF for __setmntent, __getmntent_r, and
__endmntent.
* include/math.h: Declare __finite_internal, __finitef_internal, and
__finitel_internal. Redefine isfinite macro if in libc or libm using
these functions.
* sysdeps/generic/s_ldexp.c: Use INTUSE for __finite calls.
* sysdeps/generic/s_ldexpf.c: Use INTUSE for __finitef calls.
* sysdeps/generic/s_ldexpl.c: Use INTUSE for __finitel calls.
* sysdeps/i386/fpu/s_finite.S: Define _internal alias.
* sysdeps/i386/fpu/s_finitef.S: Likewise.
* sysdeps/i386/fpu/s_finitel.S: Likewise.
* sysdeps/ieee754/dbl-64/s_finite.c: Likewise.
* sysdeps/ieee754/flt-32/s_finitef.c: Likewise.
* sysdeps/ieee754/ldbl-128/s_finitel.c: Likewise.
* sysdeps/ieee754/ldbl-96/s_finitel.c: Likewise.
* include/fcntl.h: Declare __fcntl_internal. Define __fcntl macro
to use this function if not NOT_IN_libc.
* libio/iofdopen.c (_IO_fcntl): Use INTUSE.
* sysdeps/generic/fcntl.c: Use INTDEF for __fcntl.
* sysdeps/mach/hurd/fcntl.c: Likewise.
* sysdeps/unix/sysv/aix/fcntl.c: Likewise.
* sysdeps/unix/sysv/linux/i386/fcntl.c: Likewise.
* include/argz.h: Declare __argz_count_internal and
__argz_stringify_internal.
* intl/l10nflist.c [_LIBC]: Use INTUSE for __argz_count and
__argz_stringify.
* string/argz-count.c: Use INTDEF for __argz_count.
* string/argz-stringify.c: Use INTDEF for __argz_stringify.
* include/stdlib.h: Declare __cxa_atexit_internal and define
__cxa_atexit macro if not NOT_IN_libc.
* stdlib/cxa_atexit.c: Use INTDEF for __cxa_atexit.
* dlfcn/Makefile: Define NOT_IN_libc when compiling modcxaatexit.c.
* assert/assert.c: Use INTDEF for __assert_fail.
* assert/__assert.c: Use INTUSE for call to __assert_fail.
* include/assert.h: Declare __assert_fail_internal.
2002-04-09 22:36:24 +02:00
|
|
|
#undef __fork
|
|
|
|
|
1995-02-18 02:27:10 +01:00
|
|
|
|
|
|
|
/* Things that want to be locked while forking. */
|
1995-08-18 00:55:22 +02:00
|
|
|
symbol_set_declare (_hurd_fork_locks)
|
1995-02-18 02:27:10 +01:00
|
|
|
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
|
|
|
ss = _hurd_self_sigstate ();
|
1996-05-04 11:46:57 +02:00
|
|
|
__spin_lock (&ss->critical_section_lock);
|
1995-04-24 11:00:07 +02:00
|
|
|
|
|
|
|
#undef LOSE
|
2001-06-14 07:32:26 +02:00
|
|
|
#define LOSE do { assert_perror (err); goto lose; } while (0) /* XXX */
|
1995-02-18 02:27:10 +01:00
|
|
|
|
|
|
|
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;
|
1995-08-18 00:55:22 +02:00
|
|
|
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;
|
|
|
|
}
|
1995-02-18 02:27:10 +01:00
|
|
|
|
|
|
|
/* 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. */
|
1995-08-18 00:55:22 +02:00
|
|
|
{
|
|
|
|
void *const *p;
|
|
|
|
for (p = symbol_set_first_element (_hurd_fork_locks);
|
|
|
|
! symbol_set_end_p (_hurd_fork_locks, p);
|
|
|
|
++p)
|
|
|
|
__mutex_lock (*p);
|
|
|
|
}
|
1995-04-24 11:00:07 +02:00
|
|
|
__mutex_lock (&_hurd_siglock);
|
1995-12-22 06:57:24 +01:00
|
|
|
|
1995-02-18 02:27:10 +01:00
|
|
|
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;
|
|
|
|
|
1995-12-22 06:57:24 +01:00
|
|
|
|
1995-08-18 00:55:22 +02:00
|
|
|
/* Stop all other threads while copying the address space,
|
|
|
|
so nothing changes. */
|
|
|
|
err = __proc_dostop (_hurd_ports[INIT_PORT_PROC].port, ss->thread);
|
|
|
|
if (!err)
|
1997-06-23 23:55:26 +02:00
|
|
|
{
|
|
|
|
stopped = 1;
|
1995-08-18 00:55:22 +02:00
|
|
|
|
1996-01-04 01:06:01 +01:00
|
|
|
#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
|
1995-08-18 00:55:22 +02:00
|
|
|
/* Create the child task. It will inherit a copy of our memory. */
|
2002-01-02 11:23:33 +01:00
|
|
|
err = __task_create (__mach_task_self (),
|
|
|
|
#ifdef KERN_INVALID_LEDGER
|
|
|
|
NULL, 0, /* OSF Mach */
|
|
|
|
#endif
|
|
|
|
1, &newtask);
|
1997-06-23 23:55:26 +02:00
|
|
|
}
|
1995-04-24 11:00:07 +02:00
|
|
|
|
|
|
|
/* 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;
|
1995-02-18 02:27:10 +01:00
|
|
|
|
|
|
|
/* Fetch the names of all ports used in this task. */
|
|
|
|
if (err = __mach_port_names (__mach_task_self (),
|
|
|
|
&portnames, &nportnames,
|
|
|
|
&porttypes, &nporttypes))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
if (nportnames != nporttypes)
|
|
|
|
{
|
|
|
|
err = EGRATUITOUS;
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
|
|
|
|
/* 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))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
|
|
|
|
/* 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. */
|
|
|
|
err = __mach_port_allocate_name (newtask,
|
|
|
|
MACH_PORT_RIGHT_RECEIVE,
|
|
|
|
portnames[i]);
|
|
|
|
if (err == KERN_NAME_EXISTS)
|
|
|
|
{
|
|
|
|
/* It already has a right under this name (?!). Well,
|
|
|
|
there is this bizarre old Mach IPC feature (in #ifdef
|
|
|
|
MACH_IPC_COMPAT in the ukernel) which results in new
|
|
|
|
tasks getting a new receive right for task special
|
|
|
|
port number 2. What else might be going on I'm not
|
|
|
|
sure. So let's check. */
|
|
|
|
#if !MACH_IPC_COMPAT
|
|
|
|
#define TASK_NOTIFY_PORT 2
|
|
|
|
#endif
|
|
|
|
assert (({ mach_port_t thisport, notify_port;
|
|
|
|
mach_msg_type_name_t poly;
|
|
|
|
(__task_get_special_port (newtask,
|
|
|
|
TASK_NOTIFY_PORT,
|
|
|
|
¬ify_port) == 0 &&
|
1995-12-22 06:57:24 +01:00
|
|
|
__mach_port_extract_right
|
1995-02-18 02:27:10 +01:00
|
|
|
(newtask,
|
|
|
|
portnames[i],
|
|
|
|
MACH_MSG_TYPE_MAKE_SEND,
|
|
|
|
&thisport, &poly) == 0 &&
|
|
|
|
(thisport == notify_port) &&
|
|
|
|
__mach_port_deallocate (__mach_task_self (),
|
|
|
|
thisport) == 0 &&
|
|
|
|
__mach_port_deallocate (__mach_task_self (),
|
|
|
|
notify_port) == 0);
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
else if (err)
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
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))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
if (err = __mach_port_extract_right (newtask,
|
|
|
|
portnames[i],
|
|
|
|
MACH_MSG_TYPE_MAKE_SEND,
|
|
|
|
&port, &poly))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
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))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
if (old != MACH_PORT_NULL)
|
|
|
|
/* XXX what to do here? */
|
|
|
|
__mach_port_deallocate (__mach_task_self (), old);
|
1996-02-08 03:10:15 +01:00
|
|
|
/* The new task will receive its own exceptions
|
|
|
|
on its message port. */
|
2002-01-02 11:23:33 +01:00
|
|
|
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
|
|
|
|
)
|
1996-02-08 03:10:15 +01:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
}
|
|
|
|
if (err = __mach_port_insert_right (newtask,
|
|
|
|
portnames[i],
|
|
|
|
port,
|
|
|
|
MACH_MSG_TYPE_MOVE_SEND))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
if (refs > 1 &&
|
|
|
|
(err = __mach_port_mod_refs (newtask,
|
|
|
|
portnames[i],
|
|
|
|
MACH_PORT_RIGHT_SEND,
|
|
|
|
refs - 1)))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
}
|
|
|
|
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))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
if (err = __mach_port_insert_right
|
|
|
|
(newtask,
|
|
|
|
portnames[i], port,
|
|
|
|
MACH_MSG_TYPE_MOVE_SEND_ONCE))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
}
|
|
|
|
}
|
1995-04-24 11:00:07 +02:00
|
|
|
else if (porttypes[i] &
|
|
|
|
(MACH_PORT_TYPE_SEND|MACH_PORT_TYPE_DEAD_NAME))
|
1995-02-18 02:27:10 +01:00
|
|
|
{
|
|
|
|
/* This is a send right or a dead name.
|
|
|
|
Give the child as many references for it as we have. */
|
2011-09-08 18:37:42 +02:00
|
|
|
mach_port_urefs_t refs = 0, *record_refs = NULL;
|
1995-02-18 02:27:10 +01:00
|
|
|
mach_port_t insert;
|
1996-04-07 19:44:31 +02:00
|
|
|
mach_msg_type_name_t insert_type = MACH_MSG_TYPE_COPY_SEND;
|
2001-04-09 23:24:34 +02:00
|
|
|
if (portnames[i] == newtask || portnames[i] == newproc)
|
|
|
|
/* Skip the name we use for the child's task or proc ports. */
|
1995-02-18 02:27:10 +01:00
|
|
|
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)
|
|
|
|
{
|
2001-04-09 23:24:34 +02:00
|
|
|
/* Use the proc server port for the new task. */
|
|
|
|
insert = newproc;
|
|
|
|
insert_type = MACH_MSG_TYPE_COPY_SEND;
|
1995-02-18 02:27:10 +01:00
|
|
|
}
|
1995-08-18 00:55:22 +02:00
|
|
|
else if (portnames[i] == ss->thread)
|
1995-02-18 02:27:10 +01:00
|
|
|
{
|
|
|
|
/* 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
|
1997-06-23 23:55:26 +02:00
|
|
|
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). */
|
1995-02-18 02:27:10 +01:00
|
|
|
if (err = __mach_port_allocate_name
|
|
|
|
(newtask, MACH_PORT_RIGHT_DEAD_NAME, portnames[i]))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
}
|
|
|
|
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]))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
}
|
|
|
|
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;
|
|
|
|
|
1996-04-07 19:44:31 +02:00
|
|
|
/* Copy our own send right. */
|
1995-02-18 02:27:10 +01:00
|
|
|
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))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
if (insert == MACH_PORT_NULL)
|
|
|
|
continue;
|
1995-04-24 11:00:07 +02:00
|
|
|
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],
|
1999-06-13 11:53:59 +02:00
|
|
|
insert, insert_type);
|
1995-04-24 11:00:07 +02:00
|
|
|
switch (err)
|
1995-02-18 02:27:10 +01:00
|
|
|
{
|
1995-04-24 11:00:07 +02:00
|
|
|
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;
|
1995-02-18 02:27:10 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
1995-08-18 00:55:22 +02:00
|
|
|
/* All state has now been copied from the parent. It is safe to
|
1997-06-23 23:55:26 +02:00
|
|
|
resume other parent threads. */
|
1995-08-18 00:55:22 +02:00
|
|
|
resume_threads ();
|
|
|
|
|
1995-02-18 02:27:10 +01:00
|
|
|
/* Create the child main user thread and signal thread. */
|
|
|
|
if ((err = __thread_create (newtask, &thread)) ||
|
|
|
|
(err = __thread_create (newtask, &sigthread)))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
|
|
|
|
/* Insert send rights for those threads. We previously allocated
|
1997-06-23 23:55:26 +02:00
|
|
|
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. */
|
1995-08-18 00:55:22 +02:00
|
|
|
if ((err = __mach_port_deallocate (newtask, ss->thread)) ||
|
|
|
|
(err = __mach_port_insert_right (newtask, ss->thread,
|
1995-02-18 02:27:10 +01:00
|
|
|
thread, MACH_MSG_TYPE_COPY_SEND)))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
/* We have one extra user reference created at the beginning of this
|
|
|
|
function, accounted for by mach_port_names (and which will thus be
|
|
|
|
accounted for in the child below). This extra right gets consumed
|
|
|
|
in the child by the store into _hurd_sigthread in the child fork. */
|
|
|
|
if (thread_refs > 1 &&
|
1995-08-18 00:55:22 +02:00
|
|
|
(err = __mach_port_mod_refs (newtask, ss->thread,
|
1995-02-18 02:27:10 +01:00
|
|
|
MACH_PORT_RIGHT_SEND,
|
1995-08-18 00:55:22 +02:00
|
|
|
thread_refs)))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
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))))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
if (sigthread_refs > 1 &&
|
|
|
|
(err = __mach_port_mod_refs (newtask, _hurd_msgport_thread,
|
|
|
|
MACH_PORT_RIGHT_SEND,
|
|
|
|
sigthread_refs - 1)))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
|
|
|
|
/* 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)
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
}
|
1995-12-22 06:57:24 +01:00
|
|
|
|
1995-02-18 02:27:10 +01:00
|
|
|
/* 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))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
#if STACK_GROWTH_UP
|
1999-11-18 Roland McGrath <roland@baalperazim.frob.com>
* hurd/hurdsig.c (_hurdsig_init): If __hurd_threadvar_stack_mask is
nonzero, use cthread_fork to create the signal thread.
* hurd/msgportdemux.c (_hurd_msgport_receive): Initialize
_hurd_msgport_thread here (to self).
* sysdeps/mach/hurd/fork.c (__fork): When __hurd_sigthread_stack_end
is zero, instead compute child signal thread's starting SP from parent
signal thread's current SP and the threadvar_stack variables.
* hurd/Versions (GLIBC_2.1.3): Add cthread_fork, cthread_detach.
These are now referenced weakly by _hurdsig_init.
* hurd/report-wait.c (_S_msg_report_wait): Fix typo:
&_hurd_itimer_thread not &_hurd_msgport_thread.
1999-10-01 Roland McGrath <roland@baalperazim.frob.com>
* hurd/hurdfchdir.c (_hurd_change_directory_port_from_fd): Rewrite
without HURD_DPORT_USE to clean up warnings.
* hurd/dtable.c (get_dtable_port): Likewise.
* hurd/hurdioctl.c (rectty_dtable): Renamed to install_ctty.
(install_ctty): Do the changing of the cttyid port cell here, inside
the critical section while we holding the dtable lock.
(_hurd_setcttyid, tiocsctty, tiocnotty): Use that instead of changing
the port cell and calling rectty_dtable.
(_hurd_locked_install_cttyid): New function, split out of install_ctty.
(install_ctty): Use it inside a critical section, with the lock held.
* sysdeps/mach/hurd/setsid.c (__setsid): Use
_hurd_locked_install_cttyid to effect the cttyid and dtable changes
after proc_setsid, having held the dtable lock throughout.
* hurd/dtable.c (ctty_new_pgrp): With the dtable lock held, check the
cttyid port for null and bail out early if so. The dtable lock
serializes us after any cttyid change and its associated dtable update.
1999-12-03 06:01:23 +01:00
|
|
|
#define THREADVAR_SPACE (__hurd_threadvar_max \
|
|
|
|
* sizeof *__hurd_sightread_variables)
|
|
|
|
if (__hurd_sigthread_stack_base == 0)
|
|
|
|
{
|
|
|
|
state.SP &= __hurd_threadvar_stack_mask;
|
|
|
|
state.SP += __hurd_threadvar_stack_offset + THREADVAR_SPACE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
state.SP = __hurd_sigthread_stack_base;
|
1995-02-18 02:27:10 +01:00
|
|
|
#else
|
1999-11-18 Roland McGrath <roland@baalperazim.frob.com>
* hurd/hurdsig.c (_hurdsig_init): If __hurd_threadvar_stack_mask is
nonzero, use cthread_fork to create the signal thread.
* hurd/msgportdemux.c (_hurd_msgport_receive): Initialize
_hurd_msgport_thread here (to self).
* sysdeps/mach/hurd/fork.c (__fork): When __hurd_sigthread_stack_end
is zero, instead compute child signal thread's starting SP from parent
signal thread's current SP and the threadvar_stack variables.
* hurd/Versions (GLIBC_2.1.3): Add cthread_fork, cthread_detach.
These are now referenced weakly by _hurdsig_init.
* hurd/report-wait.c (_S_msg_report_wait): Fix typo:
&_hurd_itimer_thread not &_hurd_msgport_thread.
1999-10-01 Roland McGrath <roland@baalperazim.frob.com>
* hurd/hurdfchdir.c (_hurd_change_directory_port_from_fd): Rewrite
without HURD_DPORT_USE to clean up warnings.
* hurd/dtable.c (get_dtable_port): Likewise.
* hurd/hurdioctl.c (rectty_dtable): Renamed to install_ctty.
(install_ctty): Do the changing of the cttyid port cell here, inside
the critical section while we holding the dtable lock.
(_hurd_setcttyid, tiocsctty, tiocnotty): Use that instead of changing
the port cell and calling rectty_dtable.
(_hurd_locked_install_cttyid): New function, split out of install_ctty.
(install_ctty): Use it inside a critical section, with the lock held.
* sysdeps/mach/hurd/setsid.c (__setsid): Use
_hurd_locked_install_cttyid to effect the cttyid and dtable changes
after proc_setsid, having held the dtable lock throughout.
* hurd/dtable.c (ctty_new_pgrp): With the dtable lock held, check the
cttyid port for null and bail out early if so. The dtable lock
serializes us after any cttyid change and its associated dtable update.
1999-12-03 06:01:23 +01:00
|
|
|
if (__hurd_sigthread_stack_end == 0)
|
|
|
|
{
|
|
|
|
/* The signal thread has a normal 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;
|
1995-12-22 06:57:24 +01:00
|
|
|
#endif
|
1995-02-18 02:27:10 +01:00
|
|
|
MACHINE_THREAD_STATE_SET_PC (&state,
|
|
|
|
(unsigned long int) _hurd_msgport_receive);
|
|
|
|
if (err = __thread_set_state (sigthread, MACHINE_THREAD_STATE_FLAVOR,
|
|
|
|
(natural_t *) &state, statecount))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
/* 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);
|
2004-10-27 09:48:08 +02:00
|
|
|
|
|
|
|
/* Do special thread setup for TLS if needed. */
|
|
|
|
if (err = _hurd_tls_fork (thread, &state))
|
|
|
|
LOSE;
|
|
|
|
|
1995-02-18 02:27:10 +01:00
|
|
|
if (err = __thread_set_state (thread, MACHINE_THREAD_STATE_FLAVOR,
|
|
|
|
(natural_t *) &state, statecount))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
|
|
|
|
/* 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)))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
|
|
|
|
/* 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)))
|
1995-04-24 11:00:07 +02:00
|
|
|
LOSE;
|
1995-02-18 02:27:10 +01:00
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
1995-08-18 00:55:22 +02:00
|
|
|
resume_threads ();
|
|
|
|
|
1995-02-18 02:27:10 +01:00
|
|
|
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));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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
|
1997-06-23 23:55:26 +02:00
|
|
|
locked in the parent when we copied its memory. The parent has
|
|
|
|
inserted send rights with the names that were in the cells then. */
|
1995-02-18 02:27:10 +01:00
|
|
|
for (i = 0; i < _hurd_nports; ++i)
|
|
|
|
__spin_unlock (&_hurd_ports[i].lock);
|
|
|
|
|
2002-09-20 05:31:58 +02:00
|
|
|
/* We are one of the (exactly) two threads in this new task, we
|
|
|
|
will take the task-global signals. */
|
1995-08-18 00:55:22 +02:00
|
|
|
_hurd_sigthread = ss->thread;
|
1995-02-18 02:27:10 +01:00
|
|
|
|
2002-09-20 05:31:58 +02:00
|
|
|
/* 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). */
|
1995-02-18 02:27:10 +01:00
|
|
|
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;
|
1995-04-24 11:00:07 +02:00
|
|
|
__mutex_unlock (&_hurd_siglock);
|
1995-02-18 02:27:10 +01:00
|
|
|
|
|
|
|
/* 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));
|
|
|
|
|
1996-02-02 19:41:42 +01:00
|
|
|
/* Forking clears the trace flag. */
|
1996-05-04 11:46:57 +02:00
|
|
|
__sigemptyset (&_hurdsig_traced);
|
1996-02-02 19:41:42 +01:00
|
|
|
|
1995-02-18 02:27:10 +01:00
|
|
|
/* 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);
|
|
|
|
|
2002-09-20 05:31:58 +02:00
|
|
|
/* Reclaim the signal thread's sigstate structure and free the
|
|
|
|
other old sigstate structures. */
|
1995-02-18 02:27:10 +01:00
|
|
|
while (oldstates != NULL)
|
|
|
|
{
|
|
|
|
struct hurd_sigstate *next = oldstates->next;
|
2002-09-20 05:31:58 +02:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
1995-02-18 02:27:10 +01:00
|
|
|
oldstates = next;
|
|
|
|
}
|
2002-09-20 05:31:58 +02:00
|
|
|
|
1995-02-18 02:27:10 +01:00
|
|
|
/* 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. */
|
1995-08-18 00:55:22 +02:00
|
|
|
{
|
|
|
|
void *const *p;
|
|
|
|
for (p = symbol_set_first_element (_hurd_fork_locks);
|
|
|
|
! symbol_set_end_p (_hurd_fork_locks, p);
|
|
|
|
++p)
|
|
|
|
__mutex_unlock (*p);
|
|
|
|
}
|
1995-02-18 02:27:10 +01:00
|
|
|
|
1995-04-24 11:00:07 +02:00
|
|
|
_hurd_critical_section_unlock (ss);
|
1995-02-18 02:27:10 +01:00
|
|
|
|
|
|
|
return err ? __hurd_fail (err) : pid;
|
|
|
|
}
|
2002-12-31 12:12:11 +01:00
|
|
|
libc_hidden_def (__fork)
|
1995-02-18 02:27:10 +01:00
|
|
|
|
|
|
|
weak_alias (__fork, fork)
|