sys/compat/linux/linux_fork.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2004 Tim J. Robbins
   5  * Copyright (c) 2002 Doug Rabson
   6  * Copyright (c) 2000 Marcel Moolenaar
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer
  14  *    in this position and unchanged.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include "opt_compat.h"
  35
  36 #include <sys/param.h>
  37 #include <sys/systm.h>
  38 #include <sys/imgact.h>
  39 #include <sys/ktr.h>
  40 #include <sys/lock.h>
  41 #include <sys/mutex.h>
  42 #include <sys/proc.h>
  43 #include <sys/ptrace.h>
  44 #include <sys/racct.h>
  45 #include <sys/sched.h>
  46 #include <sys/syscallsubr.h>
  47 #include <sys/sx.h>
  48 #include <sys/umtxvar.h>
  49 #include <sys/unistd.h>
  50 #include <sys/wait.h>
  51
  52 #include <vm/vm.h>
  53 #include <vm/pmap.h>
  54 #include <vm/vm_map.h>
  55
  56 #ifdef COMPAT_LINUX32
  57 #include <machine/../linux32/linux.h>
  58 #include <machine/../linux32/linux32_proto.h>
  59 #else
  60 #include <machine/../linux/linux.h>
  61 #include <machine/../linux/linux_proto.h>
  62 #endif
  63 #include <compat/linux/linux.h>
  64 #include <compat/linux/linux_emul.h>
  65 #include <compat/linux/linux_fork.h>
  66 #include <compat/linux/linux_futex.h>
  67 #include <compat/linux/linux_mib.h>
  68 #include <compat/linux/linux_misc.h>
  69 #include <compat/linux/linux_util.h>
  70
  71 #ifdef LINUX_LEGACY_SYSCALLS
  72 int
  73 linux_fork(struct thread *td, struct linux_fork_args *args)
  74 {
  75         struct fork_req fr;
  76         int error;
  77         struct proc *p2;
  78         struct thread *td2;
  79
  80         bzero(&fr, sizeof(fr));
  81         fr.fr_flags = RFFDG | RFPROC | RFSTOPPED;
  82         fr.fr_procp = &p2;
  83         if ((error = fork1(td, &fr)) != 0)
  84                 return (error);
  85
  86         td2 = FIRST_THREAD_IN_PROC(p2);
  87
  88         linux_proc_init(td, td2, false);
  89
  90         td->td_retval[0] = p2->p_pid;
  91
  92         /*
  93          * Make this runnable after we are finished with it.
  94          */
  95         thread_lock(td2);
  96         TD_SET_CAN_RUN(td2);
  97         sched_add(td2, SRQ_BORING);
  98
  99         return (0);
 100 }
 101
 102 int
 103 linux_vfork(struct thread *td, struct linux_vfork_args *args)
 104 {
 105         struct fork_req fr;
 106         int error;
 107         struct proc *p2;
 108         struct thread *td2;
 109
 110         bzero(&fr, sizeof(fr));
 111         fr.fr_flags = RFFDG | RFPROC | RFMEM | RFPPWAIT | RFSTOPPED;
 112         fr.fr_procp = &p2;
 113         if ((error = fork1(td, &fr)) != 0)
 114                 return (error);
 115
 116         td2 = FIRST_THREAD_IN_PROC(p2);
 117
 118         linux_proc_init(td, td2, false);
 119
 120         td->td_retval[0] = p2->p_pid;
 121
 122         /*
 123          * Make this runnable after we are finished with it.
 124          */
 125         thread_lock(td2);
 126         TD_SET_CAN_RUN(td2);
 127         sched_add(td2, SRQ_BORING);
 128
 129         return (0);
 130 }
 131 #endif
 132
 133 static int
 134 linux_clone_proc(struct thread *td, struct l_clone_args *args)
 135 {
 136         struct fork_req fr;
 137         int error, ff, f2;
 138         struct proc *p2;
 139         struct thread *td2;
 140         int exit_signal;
 141         struct linux_emuldata *em;
 142
 143         f2 = 0;
 144         ff = RFPROC | RFSTOPPED;
 145         if (LINUX_SIG_VALID(args->exit_signal)) {
 146                 exit_signal = linux_to_bsd_signal(args->exit_signal);
 147         } else if (args->exit_signal != 0)
 148                 return (EINVAL);
 149         else
 150                 exit_signal = 0;
 151
 152         if (args->flags & LINUX_CLONE_VM)
 153                 ff |= RFMEM;
 154         if (args->flags & LINUX_CLONE_SIGHAND)
 155                 ff |= RFSIGSHARE;
 156         if ((args->flags & LINUX_CLONE_CLEAR_SIGHAND) != 0)
 157                 f2 |= FR2_DROPSIG_CAUGHT;
 158         if (args->flags & LINUX_CLONE_FILES) {
 159                 if (!(args->flags & LINUX_CLONE_FS))
 160                         f2 |= FR2_SHARE_PATHS;
 161         } else {
 162                 ff |= RFFDG;
 163                 if (args->flags & LINUX_CLONE_FS)
 164                         f2 |= FR2_SHARE_PATHS;
 165         }
 166
 167         if (args->flags & LINUX_CLONE_PARENT_SETTID)
 168                 if (args->parent_tid == NULL)
 169                         return (EINVAL);
 170
 171         if (args->flags & LINUX_CLONE_VFORK)
 172                 ff |= RFPPWAIT;
 173
 174         bzero(&fr, sizeof(fr));
 175         fr.fr_flags = ff;
 176         fr.fr_flags2 = f2;
 177         fr.fr_procp = &p2;
 178         error = fork1(td, &fr);
 179         if (error)
 180                 return (error);
 181
 182         td2 = FIRST_THREAD_IN_PROC(p2);
 183
 184         /* create the emuldata */
 185         linux_proc_init(td, td2, false);
 186
 187         em = em_find(td2);
 188         KASSERT(em != NULL, ("clone_proc: emuldata not found.\n"));
 189
 190         if (args->flags & LINUX_CLONE_CHILD_SETTID)
 191                 em->child_set_tid = args->child_tid;
 192         else
 193                 em->child_set_tid = NULL;
 194
 195         if (args->flags & LINUX_CLONE_CHILD_CLEARTID)
 196                 em->child_clear_tid = args->child_tid;
 197         else
 198                 em->child_clear_tid = NULL;
 199
 200         if (args->flags & LINUX_CLONE_PARENT_SETTID) {
 201                 error = copyout(&p2->p_pid, args->parent_tid,
 202                     sizeof(p2->p_pid));
 203                 if (error)
 204                         linux_msg(td, "copyout p_pid failed!");
 205         }
 206
 207         PROC_LOCK(p2);
 208         p2->p_sigparent = exit_signal;
 209         PROC_UNLOCK(p2);
 210         /*
 211          * In a case of stack = NULL, we are supposed to COW calling process
 212          * stack. This is what normal fork() does, so we just keep tf_rsp arg
 213          * intact.
 214          */
 215         linux_set_upcall(td2, args->stack);
 216
 217         if (args->flags & LINUX_CLONE_SETTLS)
 218                 linux_set_cloned_tls(td2, PTRIN(args->tls));
 219
 220         /*
 221          * If CLONE_PARENT is set, then the parent of the new process will be
 222          * the same as that of the calling process.
 223          */
 224         if (args->flags & LINUX_CLONE_PARENT) {
 225                 sx_xlock(&proctree_lock);
 226                 PROC_LOCK(p2);
 227                 proc_reparent(p2, td->td_proc->p_pptr, true);
 228                 PROC_UNLOCK(p2);
 229                 sx_xunlock(&proctree_lock);
 230         }
 231
 232         /*
 233          * Make this runnable after we are finished with it.
 234          */
 235         thread_lock(td2);
 236         TD_SET_CAN_RUN(td2);
 237         sched_add(td2, SRQ_BORING);
 238
 239         td->td_retval[0] = p2->p_pid;
 240
 241         return (0);
 242 }
 243
 244 static int
 245 linux_clone_thread(struct thread *td, struct l_clone_args *args)
 246 {
 247         struct linux_emuldata *em;
 248         struct thread *newtd;
 249         struct proc *p;
 250         int error;
 251
 252         LINUX_CTR4(clone_thread, "thread(%d) flags %x ptid %p ctid %p",
 253             td->td_tid, (unsigned)args->flags,
 254             args->parent_tid, args->child_tid);
 255
 256         if ((args->flags & LINUX_CLONE_PARENT) != 0)
 257                 return (EINVAL);
 258         if (args->flags & LINUX_CLONE_PARENT_SETTID)
 259                 if (args->parent_tid == NULL)
 260                         return (EINVAL);
 261
 262         /* Threads should be created with own stack */
 263         if (PTRIN(args->stack) == NULL)
 264                 return (EINVAL);
 265
 266         p = td->td_proc;
 267
 268 #ifdef RACCT
 269         if (racct_enable) {
 270                 PROC_LOCK(p);
 271                 error = racct_add(p, RACCT_NTHR, 1);
 272                 PROC_UNLOCK(p);
 273                 if (error != 0)
 274                         return (EPROCLIM);
 275         }
 276 #endif
 277
 278         /* Initialize our td */
 279         error = kern_thr_alloc(p, 0, &newtd);
 280         if (error)
 281                 goto fail;
 282
 283         cpu_copy_thread(newtd, td);
 284
 285         bzero(&newtd->td_startzero,
 286             __rangeof(struct thread, td_startzero, td_endzero));
 287         bcopy(&td->td_startcopy, &newtd->td_startcopy,
 288             __rangeof(struct thread, td_startcopy, td_endcopy));
 289
 290         newtd->td_proc = p;
 291         thread_cow_get(newtd, td);
 292
 293         /* create the emuldata */
 294         linux_proc_init(td, newtd, true);
 295
 296         em = em_find(newtd);
 297         KASSERT(em != NULL, ("clone_thread: emuldata not found.\n"));
 298
 299         if (args->flags & LINUX_CLONE_SETTLS)
 300                 linux_set_cloned_tls(newtd, PTRIN(args->tls));
 301
 302         if (args->flags & LINUX_CLONE_CHILD_SETTID)
 303                 em->child_set_tid = args->child_tid;
 304         else
 305                 em->child_set_tid = NULL;
 306
 307         if (args->flags & LINUX_CLONE_CHILD_CLEARTID)
 308                 em->child_clear_tid = args->child_tid;
 309         else
 310                 em->child_clear_tid = NULL;
 311
 312         cpu_thread_clean(newtd);
 313
 314         linux_set_upcall(newtd, args->stack);
 315
 316         PROC_LOCK(p);
 317         p->p_flag |= P_HADTHREADS;
 318         thread_link(newtd, p);
 319         bcopy(p->p_comm, newtd->td_name, sizeof(newtd->td_name));
 320
 321         thread_lock(td);
 322         /* let the scheduler know about these things. */
 323         sched_fork_thread(td, newtd);
 324         thread_unlock(td);
 325         if (P_SHOULDSTOP(p))
 326                 newtd->td_flags |= TDF_ASTPENDING | TDF_NEEDSUSPCHK;
 327
 328         if (p->p_ptevents & PTRACE_LWP)
 329                 newtd->td_dbgflags |= TDB_BORN;
 330         PROC_UNLOCK(p);
 331
 332         tidhash_add(newtd);
 333
 334         LINUX_CTR2(clone_thread, "thread(%d) successful clone to %d",
 335             td->td_tid, newtd->td_tid);
 336
 337         if (args->flags & LINUX_CLONE_PARENT_SETTID) {
 338                 error = copyout(&newtd->td_tid, args->parent_tid,
 339                     sizeof(newtd->td_tid));
 340                 if (error)
 341                         linux_msg(td, "clone_thread: copyout td_tid failed!");
 342         }
 343
 344         /*
 345          * Make this runnable after we are finished with it.
 346          */
 347         thread_lock(newtd);
 348         TD_SET_CAN_RUN(newtd);
 349         sched_add(newtd, SRQ_BORING);
 350
 351         td->td_retval[0] = newtd->td_tid;
 352
 353         return (0);
 354
 355 fail:
 356 #ifdef RACCT
 357         if (racct_enable) {
 358                 PROC_LOCK(p);
 359                 racct_sub(p, RACCT_NTHR, 1);
 360                 PROC_UNLOCK(p);
 361         }
 362 #endif
 363         return (error);
 364 }
 365
 366 int
 367 linux_clone(struct thread *td, struct linux_clone_args *args)
 368 {
 369         struct l_clone_args ca = {
 370                 .flags = (lower_32_bits(args->flags) & ~LINUX_CSIGNAL),
 371                 .child_tid = args->child_tidptr,
 372                 .parent_tid = args->parent_tidptr,
 373                 .exit_signal = (lower_32_bits(args->flags) & LINUX_CSIGNAL),
 374                 .stack = args->stack,
 375                 .tls = args->tls,
 376         };
 377
 378         if (args->flags & LINUX_CLONE_THREAD)
 379                 return (linux_clone_thread(td, &ca));
 380         else
 381                 return (linux_clone_proc(td, &ca));
 382 }
 383
 384
 385 static int
 386 linux_clone3_args_valid(struct l_user_clone_args *uca)
 387 {
 388
 389         /* Verify that no unknown flags are passed along. */
 390         if ((uca->flags & ~(LINUX_CLONE_LEGACY_FLAGS |
 391             LINUX_CLONE_CLEAR_SIGHAND | LINUX_CLONE_INTO_CGROUP)) != 0)
 392                 return (EINVAL);
 393         if ((uca->flags & (LINUX_CLONE_DETACHED | LINUX_CSIGNAL)) != 0)
 394                 return (EINVAL);
 395
 396         if ((uca->flags & (LINUX_CLONE_SIGHAND | LINUX_CLONE_CLEAR_SIGHAND)) ==
 397             (LINUX_CLONE_SIGHAND | LINUX_CLONE_CLEAR_SIGHAND))
 398                 return (EINVAL);
 399         if ((uca->flags & (LINUX_CLONE_THREAD | LINUX_CLONE_PARENT)) != 0 &&
 400             uca->exit_signal != 0)
 401                 return (EINVAL);
 402
 403         /* We don't support set_tid, only validate input. */
 404         if (uca->set_tid_size > LINUX_MAX_PID_NS_LEVEL)
 405                 return (EINVAL);
 406         if (uca->set_tid == 0 && uca->set_tid_size > 0)
 407                 return (EINVAL);
 408         if (uca->set_tid != 0 && uca->set_tid_size == 0)
 409                 return (EINVAL);
 410
 411         if (uca->stack == 0 && uca->stack_size > 0)
 412                 return (EINVAL);
 413         if (uca->stack != 0 && uca->stack_size == 0)
 414                 return (EINVAL);
 415
 416         /* Verify that higher 32bits of exit_signal are unset. */
 417         if ((uca->exit_signal & ~(uint64_t)LINUX_CSIGNAL) != 0)
 418                 return (EINVAL);
 419
 420         /* Verify that no unsupported flags are passed along. */
 421         if ((uca->flags & LINUX_CLONE_NEWTIME) != 0) {
 422                 LINUX_RATELIMIT_MSG("unsupported clone3 option CLONE_NEWTIME");
 423                 return (ENOSYS);
 424         }
 425         if ((uca->flags & LINUX_CLONE_INTO_CGROUP) != 0) {
 426                 LINUX_RATELIMIT_MSG("unsupported clone3 option CLONE_INTO_CGROUP");
 427                 return (ENOSYS);
 428         }
 429         if (uca->set_tid != 0 || uca->set_tid_size != 0) {
 430                 LINUX_RATELIMIT_MSG("unsupported clone3 set_tid");
 431                 return (ENOSYS);
 432         }
 433
 434         return (0);
 435 }
 436
 437 int
 438 linux_clone3(struct thread *td, struct linux_clone3_args *args)
 439 {
 440         struct l_user_clone_args *uca;
 441         struct l_clone_args *ca;
 442         size_t size;
 443         int error;
 444
 445         if (args->usize > PAGE_SIZE)
 446                 return (E2BIG);
 447         if (args->usize < LINUX_CLONE_ARGS_SIZE_VER0)
 448                 return (EINVAL);
 449
 450         /*
 451          * usize can be less than size of struct clone_args, to avoid using
 452          * of uninitialized data of struct clone_args, allocate at least
 453          * sizeof(struct clone_args) storage and zero it.
 454          */
 455         size = max(args->usize, sizeof(*uca));
 456         uca = malloc(size, M_LINUX, M_WAITOK | M_ZERO);
 457         error = copyin(args->uargs, uca, args->usize);
 458         if (error != 0)
 459                 goto out;
 460         error = linux_clone3_args_valid(uca);
 461         if (error != 0)
 462                 goto out;
 463         ca = malloc(sizeof(*ca), M_LINUX, M_WAITOK | M_ZERO);
 464         ca->flags = uca->flags;
 465         ca->child_tid = PTRIN(uca->child_tid);
 466         ca->parent_tid = PTRIN(uca->parent_tid);
 467         ca->exit_signal = uca->exit_signal;
 468         ca->stack = uca->stack + uca->stack_size;
 469         ca->stack_size = uca->stack_size;
 470         ca->tls = uca->tls;
 471
 472         if ((ca->flags & LINUX_CLONE_THREAD) != 0)
 473                 error = linux_clone_thread(td, ca);
 474         else
 475                 error = linux_clone_proc(td, ca);
 476         free(ca, M_LINUX);
 477 out:
 478         free(uca, M_LINUX);
 479         return (error);
 480 }
 481
 482 int
 483 linux_exit(struct thread *td, struct linux_exit_args *args)
 484 {
 485         struct linux_emuldata *em __diagused;
 486
 487         em = em_find(td);
 488         KASSERT(em != NULL, ("exit: emuldata not found.\n"));
 489
 490         LINUX_CTR2(exit, "thread(%d) (%d)", em->em_tid, args->rval);
 491
 492         linux_thread_detach(td);
 493
 494         /*
 495          * XXX. When the last two threads of a process
 496          * exit via pthread_exit() try thr_exit() first.
 497          */
 498         kern_thr_exit(td);
 499         exit1(td, args->rval, 0);
 500                 /* NOTREACHED */
 501 }
 502
 503 int
 504 linux_set_tid_address(struct thread *td, struct linux_set_tid_address_args *args)
 505 {
 506         struct linux_emuldata *em;
 507
 508         em = em_find(td);
 509         KASSERT(em != NULL, ("set_tid_address: emuldata not found.\n"));
 510
 511         em->child_clear_tid = args->tidptr;
 512
 513         td->td_retval[0] = em->em_tid;
 514
 515         LINUX_CTR3(set_tid_address, "tidptr(%d) %p, returns %d",
 516             em->em_tid, args->tidptr, td->td_retval[0]);
 517
 518         return (0);
 519 }
 520
 521 void
 522 linux_thread_detach(struct thread *td)
 523 {
 524         struct linux_emuldata *em;
 525         int *child_clear_tid;
 526         int error;
 527
 528         em = em_find(td);
 529         KASSERT(em != NULL, ("thread_detach: emuldata not found.\n"));
 530
 531         LINUX_CTR1(thread_detach, "thread(%d)", em->em_tid);
 532
 533         release_futexes(td, em);
 534
 535         child_clear_tid = em->child_clear_tid;
 536
 537         if (child_clear_tid != NULL) {
 538                 LINUX_CTR2(thread_detach, "thread(%d) %p",
 539                     em->em_tid, child_clear_tid);
 540
 541                 error = suword32(child_clear_tid, 0);
 542                 if (error != 0)
 543                         return;
 544
 545                 error = futex_wake(td, child_clear_tid, 1, false);
 546                 /*
 547                  * this cannot happen at the moment and if this happens it
 548                  * probably means there is a user space bug
 549                  */
 550                 if (error != 0)
 551                         linux_msg(td, "futex stuff in thread_detach failed.");
 552         }
 553
 554         /*
 555          * Do not rely on the robust list which is maintained by userspace,
 556          * cleanup remaining pi (if any) after release_futexes anyway.
 557          */
 558         umtx_thread_exit(td);
 559 }