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