1#define _GNU_SOURCE
 2#include <stdarg.h>
 3#include <unistd.h>
 4#include <sched.h>
 5#include "pthread_impl.h"
 6#include "syscall.h"
 7#include "lock.h"
 8#include "fork_impl.h"
 9
10struct clone_start_args {
11	int (*func)(void *);
12	void *arg;
13	sigset_t sigmask;
14};
15
16static int clone_start(void *arg)
17{
18	struct clone_start_args *csa = arg;
19	__post_Fork(0);
20	__restore_sigs(&csa->sigmask);
21	return csa->func(csa->arg);
22}
23
24int clone(int (*func)(void *), void *stack, int flags, void *arg, ...)
25{
26	struct clone_start_args csa;
27	va_list ap;
28	pid_t *ptid = 0, *ctid = 0;
29	void  *tls = 0;
30
31	/* Flags that produce an invalid thread/TLS state are disallowed. */
32	int badflags = CLONE_THREAD | CLONE_SETTLS | CLONE_CHILD_CLEARTID;
33
34	if ((flags & badflags) || !stack)
35		return __syscall_ret(-EINVAL);
36
37	va_start(ap, arg);
38	if (flags & (CLONE_PIDFD | CLONE_PARENT_SETTID | CLONE_CHILD_SETTID))
39	 	ptid = va_arg(ap, pid_t *);
40	if (flags & CLONE_CHILD_SETTID) {
41		tls = va_arg(ap, void *);
42		ctid = va_arg(ap, pid_t *);
43	}
44	va_end(ap);
45
46	/* If CLONE_VM is used, it's impossible to give the child a consistent
47	 * thread structure. In this case, the best we can do is assume the
48	 * caller is content with an extremely restrictive execution context
49	 * like the one vfork() would provide. */
50	if (flags & CLONE_VM) return __syscall_ret(
51		__clone(func, stack, flags, arg, ptid, tls, ctid));
52
53	__block_all_sigs(&csa.sigmask);
54	LOCK(__abort_lock);
55
56	/* Setup the a wrapper start function for the child process to do
57	 * mimic _Fork in producing a consistent execution state. */
58	csa.func = func;
59	csa.arg = arg;
60	int ret = __clone(clone_start, stack, flags, &csa, ptid, tls, ctid);
61
62	__post_Fork(ret);
63	__restore_sigs(&csa.sigmask);
64	return __syscall_ret(ret);
65}