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.main_thread && !ret) {
		pthread_t self = __pthread_self();
		self->tid = self->pid = syscall(SYS_getpid);
		memset(&self->robust_list, 0, sizeof self->robust_list);
		libc.threads_minus_1 = 0;
		libc.main_thread = self;
	}
	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);`
fix minor bugs due to incorrect threaded-predicate semantics some functions that should have been testing whether pthread_self() had been called and initialized the thread pointer were instead testing whether pthread_create() had been called and actually made the program "threaded". while it's unlikely any mismatch would occur in real-world problems, this could have introduced subtle bugs. now, we store the address of the main thread's thread descriptor in the libc structure and use its presence as a flag that the thread register is initialized. note that after fork, the calling thread (not necessarily the original main thread) is the new main thread. 2011-04-20 21:41:45 -04:00			`if (libc.main_thread && !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);`
ensure in fork that child gets its own new robust mutex list 2011-07-16 23:17:17 -04:00			`memset(&self->robust_list, 0, sizeof self->robust_list);`
make fork properly initialize the main thread in the child process 2011-03-09 20:23:44 -05:00			`libc.threads_minus_1 = 0;`
fix minor bugs due to incorrect threaded-predicate semantics some functions that should have been testing whether pthread_self() had been called and initialized the thread pointer were instead testing whether pthread_create() had been called and actually made the program "threaded". while it's unlikely any mismatch would occur in real-world problems, this could have introduced subtle bugs. now, we store the address of the main thread's thread descriptor in the libc structure and use its presence as a flag that the thread register is initialized. note that after fork, the calling thread (not necessarily the original main thread) is the new main thread. 2011-04-20 21:41:45 -04:00			`libc.main_thread = self;`
make fork properly initialize the main thread in the child process 2011-03-09 20:23:44 -05:00			`}`
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			`}`