xref: /freebsd/sys/compat/linux/linux_fork.c (revision 4436b51dff5736e74da464946049ea6899a88938)
1 /*-
2  * Copyright (c) 2004 Tim J. Robbins
3  * Copyright (c) 2002 Doug Rabson
4  * Copyright (c) 2000 Marcel Moolenaar
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer
12  *    in this position and unchanged.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28 
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31 
32 #include "opt_compat.h"
33 
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/imgact.h>
37 #include <sys/ktr.h>
38 #include <sys/lock.h>
39 #include <sys/mutex.h>
40 #include <sys/proc.h>
41 #include <sys/racct.h>
42 #include <sys/sched.h>
43 #include <sys/syscallsubr.h>
44 #include <sys/sx.h>
45 #include <sys/unistd.h>
46 #include <sys/wait.h>
47 
48 #include <vm/vm.h>
49 #include <vm/pmap.h>
50 #include <vm/vm_map.h>
51 
52 #ifdef COMPAT_LINUX32
53 #include <machine/../linux32/linux.h>
54 #include <machine/../linux32/linux32_proto.h>
55 #else
56 #include <machine/../linux/linux.h>
57 #include <machine/../linux/linux_proto.h>
58 #endif
59 #include <compat/linux/linux_emul.h>
60 #include <compat/linux/linux_futex.h>
61 #include <compat/linux/linux_misc.h>
62 #include <compat/linux/linux_util.h>
63 
64 int
65 linux_fork(struct thread *td, struct linux_fork_args *args)
66 {
67 	int error;
68 	struct proc *p2;
69 	struct thread *td2;
70 
71 #ifdef DEBUG
72 	if (ldebug(fork))
73 		printf(ARGS(fork, ""));
74 #endif
75 
76 	if ((error = fork1(td, RFFDG | RFPROC | RFSTOPPED, 0, &p2, NULL, 0,
77 	    NULL)) != 0)
78 		return (error);
79 
80 	td2 = FIRST_THREAD_IN_PROC(p2);
81 
82 	linux_proc_init(td, td2, 0);
83 
84 	td->td_retval[0] = p2->p_pid;
85 
86 	/*
87 	 * Make this runnable after we are finished with it.
88 	 */
89 	thread_lock(td2);
90 	TD_SET_CAN_RUN(td2);
91 	sched_add(td2, SRQ_BORING);
92 	thread_unlock(td2);
93 
94 	return (0);
95 }
96 
97 int
98 linux_vfork(struct thread *td, struct linux_vfork_args *args)
99 {
100 	int error;
101 	struct proc *p2;
102 	struct thread *td2;
103 
104 #ifdef DEBUG
105 	if (ldebug(vfork))
106 		printf(ARGS(vfork, ""));
107 #endif
108 
109 	/* Exclude RFPPWAIT */
110 	if ((error = fork1(td, RFFDG | RFPROC | RFMEM | RFSTOPPED, 0, &p2,
111 	    NULL, 0, NULL)) != 0)
112 		return (error);
113 
114 
115 	td2 = FIRST_THREAD_IN_PROC(p2);
116 
117 	linux_proc_init(td, td2, 0);
118 
119 	PROC_LOCK(p2);
120 	p2->p_flag |= P_PPWAIT;
121 	PROC_UNLOCK(p2);
122 
123    	td->td_retval[0] = p2->p_pid;
124 
125 	/*
126 	 * Make this runnable after we are finished with it.
127 	 */
128 	thread_lock(td2);
129 	TD_SET_CAN_RUN(td2);
130 	sched_add(td2, SRQ_BORING);
131 	thread_unlock(td2);
132 
133 	/* wait for the children to exit, ie. emulate vfork */
134 	PROC_LOCK(p2);
135 	while (p2->p_flag & P_PPWAIT)
136 		cv_wait(&p2->p_pwait, &p2->p_mtx);
137 	PROC_UNLOCK(p2);
138 
139 	return (0);
140 }
141 
142 static int
143 linux_clone_proc(struct thread *td, struct linux_clone_args *args)
144 {
145 	int error, ff = RFPROC | RFSTOPPED;
146 	struct proc *p2;
147 	struct thread *td2;
148 	int exit_signal;
149 	struct linux_emuldata *em;
150 
151 #ifdef DEBUG
152 	if (ldebug(clone)) {
153 		printf(ARGS(clone, "flags %x, stack %p, parent tid: %p, "
154 		    "child tid: %p"), (unsigned)args->flags,
155 		    args->stack, args->parent_tidptr, args->child_tidptr);
156 	}
157 #endif
158 
159 	exit_signal = args->flags & 0x000000ff;
160 	if (LINUX_SIG_VALID(exit_signal)) {
161 		exit_signal = linux_to_bsd_signal(exit_signal);
162 	} else if (exit_signal != 0)
163 		return (EINVAL);
164 
165 	if (args->flags & LINUX_CLONE_VM)
166 		ff |= RFMEM;
167 	if (args->flags & LINUX_CLONE_SIGHAND)
168 		ff |= RFSIGSHARE;
169 	/*
170 	 * XXX: In Linux, sharing of fs info (chroot/cwd/umask)
171 	 * and open files is independant.  In FreeBSD, its in one
172 	 * structure but in reality it does not cause any problems
173 	 * because both of these flags are usually set together.
174 	 */
175 	if (!(args->flags & (LINUX_CLONE_FILES | LINUX_CLONE_FS)))
176 		ff |= RFFDG;
177 
178 	if (args->flags & LINUX_CLONE_PARENT_SETTID)
179 		if (args->parent_tidptr == NULL)
180 			return (EINVAL);
181 
182 	error = fork1(td, ff, 0, &p2, NULL, 0, NULL);
183 	if (error)
184 		return (error);
185 
186 	td2 = FIRST_THREAD_IN_PROC(p2);
187 
188 	/* create the emuldata */
189 	linux_proc_init(td, td2, args->flags);
190 
191 	em = em_find(td2);
192 	KASSERT(em != NULL, ("clone_proc: emuldata not found.\n"));
193 
194 	if (args->flags & LINUX_CLONE_CHILD_SETTID)
195 		em->child_set_tid = args->child_tidptr;
196 	else
197 	   	em->child_set_tid = NULL;
198 
199 	if (args->flags & LINUX_CLONE_CHILD_CLEARTID)
200 		em->child_clear_tid = args->child_tidptr;
201 	else
202 	   	em->child_clear_tid = NULL;
203 
204 	if (args->flags & LINUX_CLONE_PARENT_SETTID) {
205 		error = copyout(&p2->p_pid, args->parent_tidptr,
206 		    sizeof(p2->p_pid));
207 		if (error)
208 			printf(LMSG("copyout failed!"));
209 	}
210 
211 	PROC_LOCK(p2);
212 	p2->p_sigparent = exit_signal;
213 	PROC_UNLOCK(p2);
214 	/*
215 	 * In a case of stack = NULL, we are supposed to COW calling process
216 	 * stack. This is what normal fork() does, so we just keep tf_rsp arg
217 	 * intact.
218 	 */
219 	linux_set_upcall_kse(td2, PTROUT(args->stack));
220 
221 	if (args->flags & LINUX_CLONE_SETTLS)
222 		linux_set_cloned_tls(td2, args->tls);
223 
224 #ifdef DEBUG
225 	if (ldebug(clone))
226 		printf(LMSG("clone: successful rfork to %d, "
227 		    "stack %p sig = %d"), (int)p2->p_pid, args->stack,
228 		    exit_signal);
229 #endif
230 
231 	if (args->flags & LINUX_CLONE_VFORK) {
232 	   	PROC_LOCK(p2);
233 	   	p2->p_flag |= P_PPWAIT;
234 	   	PROC_UNLOCK(p2);
235 	}
236 
237 	/*
238 	 * Make this runnable after we are finished with it.
239 	 */
240 	thread_lock(td2);
241 	TD_SET_CAN_RUN(td2);
242 	sched_add(td2, SRQ_BORING);
243 	thread_unlock(td2);
244 
245 	td->td_retval[0] = p2->p_pid;
246 
247 	if (args->flags & LINUX_CLONE_VFORK) {
248 		/* wait for the children to exit, ie. emulate vfork */
249 		PROC_LOCK(p2);
250 		while (p2->p_flag & P_PPWAIT)
251 			cv_wait(&p2->p_pwait, &p2->p_mtx);
252 		PROC_UNLOCK(p2);
253 	}
254 
255 	return (0);
256 }
257 
258 static int
259 linux_clone_thread(struct thread *td, struct linux_clone_args *args)
260 {
261 	struct linux_emuldata *em;
262 	struct thread *newtd;
263 	struct proc *p;
264 	int error;
265 
266 #ifdef DEBUG
267 	if (ldebug(clone)) {
268 		printf(ARGS(clone, "thread: flags %x, stack %p, parent tid: %p, "
269 		    "child tid: %p"), (unsigned)args->flags,
270 		    args->stack, args->parent_tidptr, args->child_tidptr);
271 	}
272 #endif
273 
274 	LINUX_CTR4(clone_thread, "thread(%d) flags %x ptid %p ctid %p",
275 	    td->td_tid, (unsigned)args->flags,
276 	    args->parent_tidptr, args->child_tidptr);
277 
278 	if (args->flags & LINUX_CLONE_PARENT_SETTID)
279 		if (args->parent_tidptr == NULL)
280 			return (EINVAL);
281 
282 	/* Threads should be created with own stack */
283 	if (args->stack == NULL)
284 		return (EINVAL);
285 
286 	p = td->td_proc;
287 
288 #ifdef RACCT
289 	if (racct_enable) {
290 		PROC_LOCK(p);
291 		error = racct_add(p, RACCT_NTHR, 1);
292 		PROC_UNLOCK(p);
293 		if (error != 0)
294 			return (EPROCLIM);
295 	}
296 #endif
297 
298 	/* Initialize our td */
299 	error = kern_thr_alloc(p, 0, &newtd);
300 	if (error)
301 		goto fail;
302 
303 	cpu_set_upcall(newtd, td);
304 
305 	bzero(&newtd->td_startzero,
306 	    __rangeof(struct thread, td_startzero, td_endzero));
307 	bcopy(&td->td_startcopy, &newtd->td_startcopy,
308 	    __rangeof(struct thread, td_startcopy, td_endcopy));
309 
310 	newtd->td_proc = p;
311 	thread_cow_get(newtd, td);
312 
313 	/* create the emuldata */
314 	linux_proc_init(td, newtd, args->flags);
315 
316 	em = em_find(newtd);
317 	KASSERT(em != NULL, ("clone_thread: emuldata not found.\n"));
318 
319 	if (args->flags & LINUX_CLONE_SETTLS)
320 		linux_set_cloned_tls(newtd, args->tls);
321 
322 	if (args->flags & LINUX_CLONE_CHILD_SETTID)
323 		em->child_set_tid = args->child_tidptr;
324 	else
325 	   	em->child_set_tid = NULL;
326 
327 	if (args->flags & LINUX_CLONE_CHILD_CLEARTID)
328 		em->child_clear_tid = args->child_tidptr;
329 	else
330 	   	em->child_clear_tid = NULL;
331 
332 	cpu_thread_clean(newtd);
333 
334 	linux_set_upcall_kse(newtd, PTROUT(args->stack));
335 
336 	PROC_LOCK(p);
337 	p->p_flag |= P_HADTHREADS;
338 	bcopy(p->p_comm, newtd->td_name, sizeof(newtd->td_name));
339 
340 	if (args->flags & LINUX_CLONE_PARENT)
341 		thread_link(newtd, p->p_pptr);
342 	else
343 		thread_link(newtd, p);
344 
345 	thread_lock(td);
346 	/* let the scheduler know about these things. */
347 	sched_fork_thread(td, newtd);
348 	thread_unlock(td);
349 	if (P_SHOULDSTOP(p))
350 		newtd->td_flags |= TDF_ASTPENDING | TDF_NEEDSUSPCHK;
351 	PROC_UNLOCK(p);
352 
353 	tidhash_add(newtd);
354 
355 #ifdef DEBUG
356 	if (ldebug(clone))
357 		printf(ARGS(clone, "successful clone to %d, stack %p"),
358 		(int)newtd->td_tid, args->stack);
359 #endif
360 
361 	LINUX_CTR2(clone_thread, "thread(%d) successful clone to %d",
362 	    td->td_tid, newtd->td_tid);
363 
364 	if (args->flags & LINUX_CLONE_PARENT_SETTID) {
365 		error = copyout(&newtd->td_tid, args->parent_tidptr,
366 		    sizeof(newtd->td_tid));
367 		if (error)
368 			printf(LMSG("clone_thread: copyout failed!"));
369 	}
370 
371 	/*
372 	 * Make this runnable after we are finished with it.
373 	 */
374 	thread_lock(newtd);
375 	TD_SET_CAN_RUN(newtd);
376 	sched_add(newtd, SRQ_BORING);
377 	thread_unlock(newtd);
378 
379 	td->td_retval[0] = newtd->td_tid;
380 
381 	return (0);
382 
383 fail:
384 #ifdef RACCT
385 	if (racct_enable) {
386 		PROC_LOCK(p);
387 		racct_sub(p, RACCT_NTHR, 1);
388 		PROC_UNLOCK(p);
389 	}
390 #endif
391 	return (error);
392 }
393 
394 int
395 linux_clone(struct thread *td, struct linux_clone_args *args)
396 {
397 
398 	if (args->flags & LINUX_CLONE_THREAD)
399 		return (linux_clone_thread(td, args));
400 	else
401 		return (linux_clone_proc(td, args));
402 }
403 
404 int
405 linux_exit(struct thread *td, struct linux_exit_args *args)
406 {
407 	struct linux_emuldata *em;
408 
409 	em = em_find(td);
410 	KASSERT(em != NULL, ("exit: emuldata not found.\n"));
411 
412 	LINUX_CTR2(exit, "thread(%d) (%d)", em->em_tid, args->rval);
413 
414 	linux_thread_detach(td);
415 
416 	/*
417 	 * XXX. When the last two threads of a process
418 	 * exit via pthread_exit() try thr_exit() first.
419 	 */
420 	kern_thr_exit(td);
421 	exit1(td, args->rval, 0);
422 		/* NOTREACHED */
423 }
424 
425 int
426 linux_set_tid_address(struct thread *td, struct linux_set_tid_address_args *args)
427 {
428 	struct linux_emuldata *em;
429 
430 	em = em_find(td);
431 	KASSERT(em != NULL, ("set_tid_address: emuldata not found.\n"));
432 
433 	em->child_clear_tid = args->tidptr;
434 
435 	td->td_retval[0] = em->em_tid;
436 
437 	LINUX_CTR3(set_tid_address, "tidptr(%d) %p, returns %d",
438 	    em->em_tid, args->tidptr, td->td_retval[0]);
439 
440 	return (0);
441 }
442 
443 void
444 linux_thread_detach(struct thread *td)
445 {
446 	struct linux_sys_futex_args cup;
447 	struct linux_emuldata *em;
448 	int *child_clear_tid;
449 	int error;
450 
451 	em = em_find(td);
452 	KASSERT(em != NULL, ("thread_detach: emuldata not found.\n"));
453 
454 	LINUX_CTR1(thread_detach, "thread(%d)", em->em_tid);
455 
456 	release_futexes(td, em);
457 
458 	child_clear_tid = em->child_clear_tid;
459 
460 	if (child_clear_tid != NULL) {
461 
462 		LINUX_CTR2(thread_detach, "thread(%d) %p",
463 		    em->em_tid, child_clear_tid);
464 
465 		error = suword32(child_clear_tid, 0);
466 		if (error != 0)
467 			return;
468 
469 		cup.uaddr = child_clear_tid;
470 		cup.op = LINUX_FUTEX_WAKE;
471 		cup.val = 1;		/* wake one */
472 		cup.timeout = NULL;
473 		cup.uaddr2 = NULL;
474 		cup.val3 = 0;
475 		error = linux_sys_futex(td, &cup);
476 		/*
477 		 * this cannot happen at the moment and if this happens it
478 		 * probably means there is a user space bug
479 		 */
480 		if (error != 0)
481 			linux_msg(td, "futex stuff in thread_detach failed.");
482 	}
483 }
484