musl/src/process/fork.c

#include <unistd.h>
#include "syscall.h"
#include "libc.h"
#include "pthread_impl.h"

pid_t fork(void)
{
	pid_t ret;
	if (libc.fork_handler) libc.fork_handler(-1);
	ret = syscall(SYS_fork);
	if (libc.threaded && !ret) {
		pthread_t self = __pthread_self();
		self->tid = self->pid = syscall(SYS_getpid);
		libc.threads_minus_1 = 0;
	}
	if (libc.fork_handler) libc.fork_handler(!ret);
	return ret;
}
initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00			`#include <unistd.h>`
			`#include "syscall.h"`
add pthread_atfork interface note that this presently does not handle consistency of the libc's own global state during forking. as per POSIX 2008, if the parent process was threaded, the child process may only call async-signal-safe functions until one of the exec-family functions is called, so the current behavior is believed to be conformant even if non-ideal. it may be improved at some later time. 2011-02-18 19:52:42 -05:00			`#include "libc.h"`
make fork properly initialize the main thread in the child process 2011-03-09 20:23:44 -05:00			`#include "pthread_impl.h"`
initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00
			`pid_t fork(void)`
			`{`
add pthread_atfork interface note that this presently does not handle consistency of the libc's own global state during forking. as per POSIX 2008, if the parent process was threaded, the child process may only call async-signal-safe functions until one of the exec-family functions is called, so the current behavior is believed to be conformant even if non-ideal. it may be improved at some later time. 2011-02-18 19:52:42 -05:00			`pid_t ret;`
			`if (libc.fork_handler) libc.fork_handler(-1);`
global cleanup to use the new syscall interface 2011-03-20 00:16:43 -04:00			`ret = syscall(SYS_fork);`
clean up handling of thread/nothread mode, locking 2011-04-17 16:53:54 -04:00			`if (libc.threaded && !ret) {`
make fork properly initialize the main thread in the child process 2011-03-09 20:23:44 -05:00			`pthread_t self = __pthread_self();`
speed up threaded fork after fork, we have a new process and the pid is equal to the tid of the new main thread. there is no need to make two separate syscalls to obtain the same number. 2011-04-12 17:52:14 -04:00			`self->tid = self->pid = syscall(SYS_getpid);`
make fork properly initialize the main thread in the child process 2011-03-09 20:23:44 -05:00			`libc.threads_minus_1 = 0;`
			`}`
add pthread_atfork interface note that this presently does not handle consistency of the libc's own global state during forking. as per POSIX 2008, if the parent process was threaded, the child process may only call async-signal-safe functions until one of the exec-family functions is called, so the current behavior is believed to be conformant even if non-ideal. it may be improved at some later time. 2011-02-18 19:52:42 -05:00			`if (libc.fork_handler) libc.fork_handler(!ret);`
			`return ret;`
initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00			`}`