man2/clone.2

   1 .\" Copyright (c) 1992 Drew Eckhardt <drew@cs.colorado.edu>, March 28, 1992
   2 .\" and Copyright (c) Michael Kerrisk, 2001, 2002, 2005, 2013
   3 .\"
   4 .\" %%%LICENSE_START(GPL_NOVERSION_ONELINE)
   5 .\" May be distributed under the GNU General Public License.
   6 .\" %%%LICENSE_END
   7 .\"
   8 .\" Modified by Michael Haardt <michael@moria.de>
   9 .\" Modified 24 Jul 1993 by Rik Faith <faith@cs.unc.edu>
  10 .\" Modified 21 Aug 1994 by Michael Chastain <mec@shell.portal.com>:
  11 .\"   New man page (copied from 'fork.2').
  12 .\" Modified 10 June 1995 by Andries Brouwer <aeb@cwi.nl>
  13 .\" Modified 25 April 1998 by Xavier Leroy <Xavier.Leroy@inria.fr>
  14 .\" Modified 26 Jun 2001 by Michael Kerrisk
  15 .\"     Mostly upgraded to 2.4.x
  16 .\"     Added prototype for sys_clone() plus description
  17 .\"     Added CLONE_THREAD with a brief description of thread groups
  18 .\"     Added CLONE_PARENT and revised entire page remove ambiguity
  19 .\"             between "calling process" and "parent process"
  20 .\"     Added CLONE_PTRACE and CLONE_VFORK
  21 .\"     Added EPERM and EINVAL error codes
  22 .\"     Renamed "__clone" to "clone" (which is the prototype in <sched.h>)
  23 .\"     various other minor tidy ups and clarifications.
  24 .\" Modified 26 Jun 2001 by Michael Kerrisk <mtk.manpages@gmail.com>
  25 .\"     Updated notes for 2.4.7+ behavior of CLONE_THREAD
  26 .\" Modified 15 Oct 2002 by Michael Kerrisk <mtk.manpages@gmail.com>
  27 .\"     Added description for CLONE_NEWNS, which was added in 2.4.19
  28 .\" Slightly rephrased, aeb.
  29 .\" Modified 1 Feb 2003 - added CLONE_SIGHAND restriction, aeb.
  30 .\" Modified 1 Jan 2004 - various updates, aeb
  31 .\" Modified 2004-09-10 - added CLONE_PARENT_SETTID etc. - aeb.
  32 .\" 2005-04-12, mtk, noted the PID caching behavior of NPTL's getpid()
  33 .\"     wrapper under BUGS.
  34 .\" 2005-05-10, mtk, added CLONE_SYSVSEM, CLONE_UNTRACED, CLONE_STOPPED.
  35 .\" 2005-05-17, mtk, Substantially enhanced discussion of CLONE_THREAD.
  36 .\" 2008-11-18, mtk, order CLONE_* flags alphabetically
  37 .\" 2008-11-18, mtk, document CLONE_NEWPID
  38 .\" 2008-11-19, mtk, document CLONE_NEWUTS
  39 .\" 2008-11-19, mtk, document CLONE_NEWIPC
  40 .\" 2008-11-19, Jens Axboe, mtk, document CLONE_IO
  41 .\"
  42 .TH CLONE 2 2017-09-15 "Linux" "Linux Programmer's Manual"
  43 .SH NAME
  44 clone, __clone2 \- create a child process
  45 .SH SYNOPSIS
  46 .nf
  47 /* Prototype for the glibc wrapper function */
  48 .PP
  49 .B #define _GNU_SOURCE
  50 .B #include <sched.h>
  51 .PP
  52 .BI "int clone(int (*" "fn" ")(void *), void *" child_stack ,
  53 .BI "          int " flags ", void *" "arg" ", ... "
  54 .BI "          /* pid_t *" ptid ", void *" newtls \
  55 ", pid_t *" ctid " */ );"
  56 .PP
  57 /* For the prototype of the raw system call, see NOTES */
  58 .fi
  59 .SH DESCRIPTION
  60 .BR clone ()
  61 creates a new process, in a manner similar to
  62 .BR fork (2).
  63 .PP
  64 This page describes both the glibc
  65 .BR clone ()
  66 wrapper function and the underlying system call on which it is based.
  67 The main text describes the wrapper function;
  68 the differences for the raw system call
  69 are described toward the end of this page.
  70 .PP
  71 Unlike
  72 .BR fork (2),
  73 .BR clone ()
  74 allows the child process to share parts of its execution context with
  75 the calling process, such as the virtual address space, the table of file
  76 descriptors, and the table of signal handlers.
  77 (Note that on this manual
  78 page, "calling process" normally corresponds to "parent process".
  79 But see the description of
  80 .B CLONE_PARENT
  81 below.)
  82 .PP
  83 One use of
  84 .BR clone ()
  85 is to implement threads: multiple flows of control in a program that
  86 run concurrently in a shared address space.
  87 .PP
  88 When the child process is created with
  89 .BR clone (),
  90 it commences execution by calling the function pointed to by the argument
  91 .IR fn .
  92 (This differs from
  93 .BR fork (2),
  94 where execution continues in the child from the point
  95 of the
  96 .BR fork (2)
  97 call.)
  98 The
  99 .I arg
 100 argument is passed as the argument of the function
 101 .IR fn .
 102 .PP
 103 When the
 104 .IR fn ( arg )
 105 function returns, the child process terminates.
 106 The integer returned by
 107 .I fn
 108 is the exit status for the child process.
 109 The child process may also terminate explicitly by calling
 110 .BR exit (2)
 111 or after receiving a fatal signal.
 112 .PP
 113 The
 114 .I child_stack
 115 argument specifies the location of the stack used by the child process.
 116 Since the child and calling process may share memory,
 117 it is not possible for the child process to execute in the
 118 same stack as the calling process.
 119 The calling process must therefore
 120 set up memory space for the child stack and pass a pointer to this
 121 space to
 122 .BR clone ().
 123 Stacks grow downward on all processors that run Linux
 124 (except the HP PA processors), so
 125 .I child_stack
 126 usually points to the topmost address of the memory space set up for
 127 the child stack.
 128 .PP
 129 The low byte of
 130 .I flags
 131 contains the number of the
 132 .I "termination signal"
 133 sent to the parent when the child dies.
 134 If this signal is specified as anything other than
 135 .BR SIGCHLD ,
 136 then the parent process must specify the
 137 .B __WALL
 138 or
 139 .B __WCLONE
 140 options when waiting for the child with
 141 .BR wait (2).
 142 If no signal is specified, then the parent process is not signaled
 143 when the child terminates.
 144 .PP
 145 .I flags
 146 may also be bitwise-ORed with zero or more of the following constants,
 147 in order to specify what is shared between the calling process
 148 and the child process:
 149 .TP
 150 .BR CLONE_CHILD_CLEARTID " (since Linux 2.5.49)"
 151 Clear (zero) the child thread ID at the location
 152 .I ctid
 153 in child memory when the child exits, and do a wakeup on the futex
 154 at that address.
 155 The address involved may be changed by the
 156 .BR set_tid_address (2)
 157 system call.
 158 This is used by threading libraries.
 159 .TP
 160 .BR CLONE_CHILD_SETTID " (since Linux 2.5.49)"
 161 Store the child thread ID at the location
 162 .I ctid
 163 in the child's memory.
 164 The store operation completes before
 165 .BR clone ()
 166 returns control to user space.
 167 .TP
 168 .BR CLONE_FILES " (since Linux 2.0)"
 169 If
 170 .B CLONE_FILES
 171 is set, the calling process and the child process share the same file
 172 descriptor table.
 173 Any file descriptor created by the calling process or by the child
 174 process is also valid in the other process.
 175 Similarly, if one of the processes closes a file descriptor,
 176 or changes its associated flags (using the
 177 .BR fcntl (2)
 178 .B F_SETFD
 179 operation), the other process is also affected.
 180 If a process sharing a file descriptor table calls
 181 .BR execve (2),
 182 its file descriptor table is duplicated (unshared).
 183 .IP
 184 If
 185 .B CLONE_FILES
 186 is not set, the child process inherits a copy of all file descriptors
 187 opened in the calling process at the time of
 188 .BR clone ().
 189 Subsequent operations that open or close file descriptors,
 190 or change file descriptor flags,
 191 performed by either the calling
 192 process or the child process do not affect the other process.
 193 Note, however,
 194 that the duplicated file descriptors in the child refer to the same open file
 195 descriptions as the corresponding file descriptors in the calling process,
 196 and thus share file offsets and file status flags (see
 197 .BR open (2)).
 198 .TP
 199 .BR CLONE_FS " (since Linux 2.0)"
 200 If
 201 .B CLONE_FS
 202 is set, the caller and the child process share the same filesystem
 203 information.
 204 This includes the root of the filesystem, the current
 205 working directory, and the umask.
 206 Any call to
 207 .BR chroot (2),
 208 .BR chdir (2),
 209 or
 210 .BR umask (2)
 211 performed by the calling process or the child process also affects the
 212 other process.
 213 .IP
 214 If
 215 .B CLONE_FS
 216 is not set, the child process works on a copy of the filesystem
 217 information of the calling process at the time of the
 218 .BR clone ()
 219 call.
 220 Calls to
 221 .BR chroot (2),
 222 .BR chdir (2),
 223 or
 224 .BR umask (2)
 225 performed later by one of the processes do not affect the other process.
 226 .TP
 227 .BR CLONE_IO " (since Linux 2.6.25)"
 228 If
 229 .B CLONE_IO
 230 is set, then the new process shares an I/O context with
 231 the calling process.
 232 If this flag is not set, then (as with
 233 .BR fork (2))
 234 the new process has its own I/O context.
 235 .IP
 236 .\" The following based on text from Jens Axboe
 237 The I/O context is the I/O scope of the disk scheduler (i.e.,
 238 what the I/O scheduler uses to model scheduling of a process's I/O).
 239 If processes share the same I/O context,
 240 they are treated as one by the I/O scheduler.
 241 As a consequence, they get to share disk time.
 242 For some I/O schedulers,
 243 .\" the anticipatory and CFQ scheduler
 244 if two processes share an I/O context,
 245 they will be allowed to interleave their disk access.
 246 If several threads are doing I/O on behalf of the same process
 247 .RB ( aio_read (3),
 248 for instance), they should employ
 249 .BR CLONE_IO
 250 to get better I/O performance.
 251 .\" with CFQ and AS.
 252 .IP
 253 If the kernel is not configured with the
 254 .B CONFIG_BLOCK
 255 option, this flag is a no-op.
 256 .TP
 257 .BR CLONE_NEWCGROUP " (since Linux 4.6)"
 258 Create the process in a new cgroup namespace.
 259 If this flag is not set, then (as with
 260 .BR fork (2))
 261 the process is created in the same cgroup namespaces as the calling process.
 262 This flag is intended for the implementation of containers.
 263 .IP
 264 For further information on cgroup namespaces, see
 265 .BR cgroup_namespaces (7).
 266 .IP
 267 Only a privileged process
 268 .RB ( CAP_SYS_ADMIN )
 269 can employ
 270 .BR CLONE_NEWCGROUP .
 271 .\"
 272 .TP
 273 .BR CLONE_NEWIPC " (since Linux 2.6.19)"
 274 If
 275 .B CLONE_NEWIPC
 276 is set, then create the process in a new IPC namespace.
 277 If this flag is not set, then (as with
 278 .BR fork (2)),
 279 the process is created in the same IPC namespace as
 280 the calling process.
 281 This flag is intended for the implementation of containers.
 282 .IP
 283 An IPC namespace provides an isolated view of System\ V IPC objects (see
 284 .BR svipc (7))
 285 and (since Linux 2.6.30)
 286 .\" commit 7eafd7c74c3f2e67c27621b987b28397110d643f
 287 .\" https://lwn.net/Articles/312232/
 288 POSIX message queues
 289 (see
 290 .BR mq_overview (7)).
 291 The common characteristic of these IPC mechanisms is that IPC
 292 objects are identified by mechanisms other than filesystem
 293 pathnames.
 294 .IP
 295 Objects created in an IPC namespace are visible to all other processes
 296 that are members of that namespace,
 297 but are not visible to processes in other IPC namespaces.
 298 .IP
 299 When an IPC namespace is destroyed
 300 (i.e., when the last process that is a member of the namespace terminates),
 301 all IPC objects in the namespace are automatically destroyed.
 302 .IP
 303 Only a privileged process
 304 .RB ( CAP_SYS_ADMIN )
 305 can employ
 306 .BR CLONE_NEWIPC .
 307 This flag can't be specified in conjunction with
 308 .BR CLONE_SYSVSEM .
 309 .IP
 310 For further information on IPC namespaces, see
 311 .BR namespaces (7).
 312 .TP
 313 .BR CLONE_NEWNET " (since Linux 2.6.24)"
 314 (The implementation of this flag was completed only
 315 by about kernel version 2.6.29.)
 316 .IP
 317 If
 318 .B CLONE_NEWNET
 319 is set, then create the process in a new network namespace.
 320 If this flag is not set, then (as with
 321 .BR fork (2))
 322 the process is created in the same network namespace as
 323 the calling process.
 324 This flag is intended for the implementation of containers.
 325 .IP
 326 A network namespace provides an isolated view of the networking stack
 327 (network device interfaces, IPv4 and IPv6 protocol stacks,
 328 IP routing tables, firewall rules, the
 329 .I /proc/net
 330 and
 331 .I /sys/class/net
 332 directory trees, sockets, etc.).
 333 A physical network device can live in exactly one
 334 network namespace.
 335 A virtual network
 336 .RB ( veth (4))
 337 device pair provides a pipe-like abstraction
 338 that can be used to create tunnels between network namespaces,
 339 and can be used to create a bridge to a physical network device
 340 in another namespace.
 341 .IP
 342 When a network namespace is freed
 343 (i.e., when the last process in the namespace terminates),
 344 its physical network devices are moved back to the
 345 initial network namespace (not to the parent of the process).
 346 For further information on network namespaces, see
 347 .BR namespaces (7).
 348 .IP
 349 Only a privileged process
 350 .RB ( CAP_SYS_ADMIN )
 351 can employ
 352 .BR CLONE_NEWNET .
 353 .TP
 354 .BR CLONE_NEWNS " (since Linux 2.4.19)"
 355 If
 356 .B CLONE_NEWNS
 357 is set, the cloned child is started in a new mount namespace,
 358 initialized with a copy of the namespace of the parent.
 359 If
 360 .B CLONE_NEWNS
 361 is not set, the child lives in the same mount
 362 namespace as the parent.
 363 .IP
 364 Only a privileged process
 365 .RB ( CAP_SYS_ADMIN )
 366 can employ
 367 .BR CLONE_NEWNS .
 368 It is not permitted to specify both
 369 .B CLONE_NEWNS
 370 and
 371 .B CLONE_FS
 372 .\" See https://lwn.net/Articles/543273/
 373 in the same
 374 .BR clone ()
 375 call.
 376 .IP
 377 For further information on mount namespaces, see
 378 .BR namespaces (7)
 379 and
 380 .BR mount_namespaces (7).
 381 .TP
 382 .BR CLONE_NEWPID " (since Linux 2.6.24)"
 383 .\" This explanation draws a lot of details from
 384 .\" http://lwn.net/Articles/259217/
 385 .\" Authors: Pavel Emelyanov <xemul@openvz.org>
 386 .\" and Kir Kolyshkin <kir@openvz.org>
 387 .\"
 388 .\" The primary kernel commit is 30e49c263e36341b60b735cbef5ca37912549264
 389 .\" Author: Pavel Emelyanov <xemul@openvz.org>
 390 If
 391 .B CLONE_NEWPID
 392 is set, then create the process in a new PID namespace.
 393 If this flag is not set, then (as with
 394 .BR fork (2))
 395 the process is created in the same PID namespace as
 396 the calling process.
 397 This flag is intended for the implementation of containers.
 398 .IP
 399 For further information on PID namespaces, see
 400 .BR namespaces (7)
 401 and
 402 .BR pid_namespaces (7).
 403 .IP
 404 Only a privileged process
 405 .RB ( CAP_SYS_ADMIN )
 406 can employ
 407 .BR CLONE_NEWPID .
 408 This flag can't be specified in conjunction with
 409 .BR CLONE_THREAD
 410 or
 411 .BR CLONE_PARENT .
 412 .TP
 413 .BR CLONE_NEWUSER
 414 (This flag first became meaningful for
 415 .BR clone ()
 416 in Linux 2.6.23,
 417 the current
 418 .BR clone ()
 419 semantics were merged in Linux 3.5,
 420 and the final pieces to make the user namespaces completely usable were
 421 merged in Linux 3.8.)
 422 .IP
 423 If
 424 .B CLONE_NEWUSER
 425 is set, then create the process in a new user namespace.
 426 If this flag is not set, then (as with
 427 .BR fork (2))
 428 the process is created in the same user namespace as the calling process.
 429 .IP
 430 Before Linux 3.8, use of
 431 .BR CLONE_NEWUSER
 432 required that the caller have three capabilities:
 433 .BR CAP_SYS_ADMIN ,
 434 .BR CAP_SETUID ,
 435 and
 436 .BR CAP_SETGID .
 437 .\" Before Linux 2.6.29, it appears that only CAP_SYS_ADMIN was needed
 438 Starting with Linux 3.8,
 439 no privileges are needed to create a user namespace.
 440 .IP
 441 This flag can't be specified in conjunction with
 442 .BR CLONE_THREAD
 443 or
 444 .BR CLONE_PARENT .
 445 For security reasons,
 446 .\" commit e66eded8309ebf679d3d3c1f5820d1f2ca332c71
 447 .\" https://lwn.net/Articles/543273/
 448 .\" The fix actually went into 3.9 and into 3.8.3. However, user namespaces
 449 .\" were, for practical purposes, unusable in earlier 3.8.x because of the
 450 .\" various filesystems that didn't support userns.
 451 .BR CLONE_NEWUSER
 452 cannot be specified in conjunction with
 453 .BR CLONE_FS .
 454 .IP
 455 For further information on user namespaces, see
 456 .BR namespaces (7)
 457 and
 458 .BR user_namespaces (7).
 459 .TP
 460 .BR CLONE_NEWUTS " (since Linux 2.6.19)"
 461 If
 462 .B CLONE_NEWUTS
 463 is set, then create the process in a new UTS namespace,
 464 whose identifiers are initialized by duplicating the identifiers
 465 from the UTS namespace of the calling process.
 466 If this flag is not set, then (as with
 467 .BR fork (2))
 468 the process is created in the same UTS namespace as
 469 the calling process.
 470 This flag is intended for the implementation of containers.
 471 .IP
 472 A UTS namespace is the set of identifiers returned by
 473 .BR uname (2);
 474 among these, the domain name and the hostname can be modified by
 475 .BR setdomainname (2)
 476 and
 477 .BR sethostname (2),
 478 respectively.
 479 Changes made to the identifiers in a UTS namespace
 480 are visible to all other processes in the same namespace,
 481 but are not visible to processes in other UTS namespaces.
 482 .IP
 483 Only a privileged process
 484 .RB ( CAP_SYS_ADMIN )
 485 can employ
 486 .BR CLONE_NEWUTS .
 487 .IP
 488 For further information on UTS namespaces, see
 489 .BR namespaces (7).
 490 .TP
 491 .BR CLONE_PARENT " (since Linux 2.3.12)"
 492 If
 493 .B CLONE_PARENT
 494 is set, then the parent of the new child (as returned by
 495 .BR getppid (2))
 496 will be the same as that of the calling process.
 497 .IP
 498 If
 499 .B CLONE_PARENT
 500 is not set, then (as with
 501 .BR fork (2))
 502 the child's parent is the calling process.
 503 .IP
 504 Note that it is the parent process, as returned by
 505 .BR getppid (2),
 506 which is signaled when the child terminates, so that
 507 if
 508 .B CLONE_PARENT
 509 is set, then the parent of the calling process, rather than the
 510 calling process itself, will be signaled.
 511 .TP
 512 .BR CLONE_PARENT_SETTID " (since Linux 2.5.49)"
 513 Store the child thread ID at the location
 514 .I ptid
 515 in the parent's memory.
 516 (In Linux 2.5.32-2.5.48 there was a flag
 517 .B CLONE_SETTID
 518 that did this.)
 519 The store operation completes before
 520 .BR clone ()
 521 returns control to user space.
 522 .TP
 523 .BR CLONE_PID " (Linux 2.0 to 2.5.15)"
 524 If
 525 .B CLONE_PID
 526 is set, the child process is created with the same process ID as
 527 the calling process.
 528 This is good for hacking the system, but otherwise
 529 of not much use.
 530 From Linux 2.3.21 onward, this flag could be
 531 specified only by the system boot process (PID 0).
 532 The flag disappeared completely from the kernel sources in Linux 2.5.16.
 533 Since then, the kernel silently ignores this bit if it is specified in
 534 .IR flags .
 535 .TP
 536 .BR CLONE_PTRACE " (since Linux 2.2)"
 537 If
 538 .B CLONE_PTRACE
 539 is specified, and the calling process is being traced,
 540 then trace the child also (see
 541 .BR ptrace (2)).
 542 .TP
 543 .BR CLONE_SETTLS " (since Linux 2.5.32)"
 544 The TLS (Thread Local Storage) descriptor is set to
 545 .IR newtls .
 546 .IP
 547 The interpretation of
 548 .I newtls
 549 and the resulting effect is architecture dependent.
 550 On x86,
 551 .I newtls
 552 is interpreted as a
 553 .IR "struct user_desc\ *"
 554 (see
 555 .BR set_thread_area (2)).
 556 On x86-64 it is the new value to be set for the %fs base register
 557 (see the
 558 .B ARCH_SET_FS
 559 argument to
 560 .BR arch_prctl (2)).
 561 On architectures with a dedicated TLS register, it is the new value
 562 of that register.
 563 .TP
 564 .BR CLONE_SIGHAND " (since Linux 2.0)"
 565 If
 566 .B CLONE_SIGHAND
 567 is set, the calling process and the child process share the same table of
 568 signal handlers.
 569 If the calling process or child process calls
 570 .BR sigaction (2)
 571 to change the behavior associated with a signal, the behavior is
 572 changed in the other process as well.
 573 However, the calling process and child
 574 processes still have distinct signal masks and sets of pending
 575 signals.
 576 So, one of them may block or unblock signals using
 577 .BR sigprocmask (2)
 578 without affecting the other process.
 579 .IP
 580 If
 581 .B CLONE_SIGHAND
 582 is not set, the child process inherits a copy of the signal handlers
 583 of the calling process at the time
 584 .BR clone ()
 585 is called.
 586 Calls to
 587 .BR sigaction (2)
 588 performed later by one of the processes have no effect on the other
 589 process.
 590 .IP
 591 Since Linux 2.6.0-test6,
 592 .I flags
 593 must also include
 594 .B CLONE_VM
 595 if
 596 .B CLONE_SIGHAND
 597 is specified
 598 .TP
 599 .BR CLONE_STOPPED " (since Linux 2.6.0-test2)"
 600 If
 601 .B CLONE_STOPPED
 602 is set, then the child is initially stopped (as though it was sent a
 603 .B SIGSTOP
 604 signal), and must be resumed by sending it a
 605 .B SIGCONT
 606 signal.
 607 .IP
 608 This flag was
 609 .I deprecated
 610 from Linux 2.6.25 onward,
 611 and was
 612 .I removed
 613 altogether in Linux 2.6.38.
 614 Since then, the kernel silently ignores it without error.
 615 .\" glibc 2.8 removed this defn from bits/sched.h
 616 Starting with Linux 4.6, the same bit was reused for the
 617 .BR CLONE_NEWCGROUP
 618 flag.
 619 .TP
 620 .BR CLONE_SYSVSEM " (since Linux 2.5.10)"
 621 If
 622 .B CLONE_SYSVSEM
 623 is set, then the child and the calling process share
 624 a single list of System V semaphore adjustment
 625 .RI ( semadj )
 626 values (see
 627 .BR semop (2)).
 628 In this case, the shared list accumulates
 629 .I semadj
 630 values across all processes sharing the list,
 631 and semaphore adjustments are performed only when the last process
 632 that is sharing the list terminates (or ceases sharing the list using
 633 .BR unshare (2)).
 634 If this flag is not set, then the child has a separate
 635 .I semadj
 636 list that is initially empty.
 637 .TP
 638 .BR CLONE_THREAD " (since Linux 2.4.0-test8)"
 639 If
 640 .B CLONE_THREAD
 641 is set, the child is placed in the same thread group as the calling process.
 642 To make the remainder of the discussion of
 643 .B CLONE_THREAD
 644 more readable, the term "thread" is used to refer to the
 645 processes within a thread group.
 646 .IP
 647 Thread groups were a feature added in Linux 2.4 to support the
 648 POSIX threads notion of a set of threads that share a single PID.
 649 Internally, this shared PID is the so-called
 650 thread group identifier (TGID) for the thread group.
 651 Since Linux 2.4, calls to
 652 .BR getpid (2)
 653 return the TGID of the caller.
 654 .IP
 655 The threads within a group can be distinguished by their (system-wide)
 656 unique thread IDs (TID).
 657 A new thread's TID is available as the function result
 658 returned to the caller of
 659 .BR clone (),
 660 and a thread can obtain
 661 its own TID using
 662 .BR gettid (2).
 663 .IP
 664 When a call is made to
 665 .BR clone ()
 666 without specifying
 667 .BR CLONE_THREAD ,
 668 then the resulting thread is placed in a new thread group
 669 whose TGID is the same as the thread's TID.
 670 This thread is the
 671 .I leader
 672 of the new thread group.
 673 .IP
 674 A new thread created with
 675 .B CLONE_THREAD
 676 has the same parent process as the caller of
 677 .BR clone ()
 678 (i.e., like
 679 .BR CLONE_PARENT ),
 680 so that calls to
 681 .BR getppid (2)
 682 return the same value for all of the threads in a thread group.
 683 When a
 684 .B CLONE_THREAD
 685 thread terminates, the thread that created it using
 686 .BR clone ()
 687 is not sent a
 688 .B SIGCHLD
 689 (or other termination) signal;
 690 nor can the status of such a thread be obtained
 691 using
 692 .BR wait (2).
 693 (The thread is said to be
 694 .IR detached .)
 695 .IP
 696 After all of the threads in a thread group terminate
 697 the parent process of the thread group is sent a
 698 .B SIGCHLD
 699 (or other termination) signal.
 700 .IP
 701 If any of the threads in a thread group performs an
 702 .BR execve (2),
 703 then all threads other than the thread group leader are terminated,
 704 and the new program is executed in the thread group leader.
 705 .IP
 706 If one of the threads in a thread group creates a child using
 707 .BR fork (2),
 708 then any thread in the group can
 709 .BR wait (2)
 710 for that child.
 711 .IP
 712 Since Linux 2.5.35,
 713 .I flags
 714 must also include
 715 .B CLONE_SIGHAND
 716 if
 717 .B CLONE_THREAD
 718 is specified
 719 (and note that, since Linux 2.6.0-test6,
 720 .BR CLONE_SIGHAND
 721 also requires
 722 .BR CLONE_VM
 723 to be included).
 724 .IP
 725 Signal dispositions and actions are process-wide:
 726 if an unhandled signal is delivered to a thread, then
 727 it will affect (terminate, stop, continue, be ignored in)
 728 all members of the thread group.
 729 .IP
 730 Each thread has its own signal mask, as set by
 731 .BR sigprocmask (2).
 732 .IP
 733 A signal may be process-directed or thread-directed.
 734 A process-directed signal is targeted at a thread group (i.e., a TGID),
 735 and is delivered to an arbitrarily selected thread from among those
 736 that are not blocking the signal.
 737 A signal may be process directed because it was generated by the kernel
 738 for reasons other than a hardware exception, or because it was sent using
 739 .BR kill (2)
 740 or
 741 .BR sigqueue (3).
 742 A thread-directed signal is targeted at (i.e., delivered to)
 743 a specific thread.
 744 A signal may be thread directed because it was sent using
 745 .BR tgkill (2)
 746 or
 747 .BR pthread_sigqueue (3),
 748 or because the thread executed a machine language instruction that triggered
 749 a hardware exception
 750 (e.g., invalid memory access triggering
 751 .BR SIGSEGV
 752 or a floating-point exception triggering
 753 .BR SIGFPE ).
 754 .IP
 755 A call to
 756 .BR sigpending (2)
 757 returns a signal set that is the union of the pending process-directed
 758 signals and the signals that are pending for the calling thread.
 759 .IP
 760 If a process-directed signal is delivered to a thread group,
 761 and the thread group has installed a handler for the signal, then
 762 the handler will be invoked in exactly one, arbitrarily selected
 763 member of the thread group that has not blocked the signal.
 764 If multiple threads in a group are waiting to accept the same signal using
 765 .BR sigwaitinfo (2),
 766 the kernel will arbitrarily select one of these threads
 767 to receive the signal.
 768 .TP
 769 .BR CLONE_UNTRACED " (since Linux 2.5.46)"
 770 If
 771 .B CLONE_UNTRACED
 772 is specified, then a tracing process cannot force
 773 .B CLONE_PTRACE
 774 on this child process.
 775 .TP
 776 .BR CLONE_VFORK " (since Linux 2.2)"
 777 If
 778 .B CLONE_VFORK
 779 is set, the execution of the calling process is suspended
 780 until the child releases its virtual memory
 781 resources via a call to
 782 .BR execve (2)
 783 or
 784 .BR _exit (2)
 785 (as with
 786 .BR vfork (2)).
 787 .IP
 788 If
 789 .B CLONE_VFORK
 790 is not set, then both the calling process and the child are schedulable
 791 after the call, and an application should not rely on execution occurring
 792 in any particular order.
 793 .TP
 794 .BR CLONE_VM " (since Linux 2.0)"
 795 If
 796 .B CLONE_VM
 797 is set, the calling process and the child process run in the same memory
 798 space.
 799 In particular, memory writes performed by the calling process
 800 or by the child process are also visible in the other process.
 801 Moreover, any memory mapping or unmapping performed with
 802 .BR mmap (2)
 803 or
 804 .BR munmap (2)
 805 by the child or calling process also affects the other process.
 806 .IP
 807 If
 808 .B CLONE_VM
 809 is not set, the child process runs in a separate copy of the memory
 810 space of the calling process at the time of
 811 .BR clone ().
 812 Memory writes or file mappings/unmappings performed by one of the
 813 processes do not affect the other, as with
 814 .BR fork (2).
 815 .SH NOTES
 816 Note that the glibc
 817 .BR clone ()
 818 wrapper function makes some changes
 819 in the memory pointed to by
 820 .I child_stack
 821 (changes required to set the stack up correctly for the child)
 822 .I before
 823 invoking the
 824 .BR clone ()
 825 system call.
 826 So, in cases where
 827 .BR clone ()
 828 is used to recursively create children,
 829 do not use the buffer employed for the parent's stack
 830 as the stack of the child.
 831 .\"
 832 .SS C library/kernel differences
 833 The raw
 834 .BR clone ()
 835 system call corresponds more closely to
 836 .BR fork (2)
 837 in that execution in the child continues from the point of the
 838 call.
 839 As such, the
 840 .I fn
 841 and
 842 .I arg
 843 arguments of the
 844 .BR clone ()
 845 wrapper function are omitted.
 846 .PP
 847 Another difference for the raw
 848 .BR clone ()
 849 system call is that the
 850 .I child_stack
 851 argument may be NULL,
 852 in which case the child uses a duplicate of the parent's stack.
 853 (Copy-on-write semantics ensure that the child gets separate copies
 854 of stack pages when either process modifies the stack.)
 855 In this case, for correct operation, the
 856 .B CLONE_VM
 857 option should not be specified.
 858 (If the child
 859 .I shares
 860 the parent's memory because of the use of the
 861 .BR CLONE_VM
 862 flag,
 863 then no copy-on-write duplication occurs and chaos is likely to result.)
 864 .PP
 865 The order of the arguments also differs in the raw system call,
 866 and there are variations in the arguments across architectures,
 867 as detailed in the following paragraphs.
 868 .PP
 869 The raw system call interface on x86-64 and some other architectures
 870 (including sh, tile, ia-64, and alpha) is:
 871 .PP
 872 .in +4
 873 .EX
 874 .BI "long clone(unsigned long " flags ", void *" child_stack ,
 875 .BI "           int *" ptid ", int *" ctid ,
 876 .BI "           unsigned long " newtls );
 877 .EE
 878 .in
 879 .PP
 880 On x86-32, and several other common architectures
 881 (including score, ARM, ARM 64, PA-RISC, arc, Power PC, xtensa,
 882 and MIPS),
 883 .\" CONFIG_CLONE_BACKWARDS
 884 the order of the last two arguments is reversed:
 885 .PP
 886 .in +4
 887 .EX
 888 .BI "long clone(unsigned long " flags ", void *" child_stack ,
 889 .BI "          int *" ptid ", unsigned long " newtls ,
 890 .BI "          int *" ctid );
 891 .EE
 892 .in
 893 .PP
 894 On the cris and s390 architectures,
 895 .\" CONFIG_CLONE_BACKWARDS2
 896 the order of the first two arguments is reversed:
 897 .PP
 898 .in +4
 899 .EX
 900 .BI "long clone(void *" child_stack ", unsigned long " flags ,
 901 .BI "           int *" ptid ", int *" ctid ,
 902 .BI "           unsigned long " newtls );
 903 .EE
 904 .in
 905 .PP
 906 On the microblaze architecture,
 907 .\" CONFIG_CLONE_BACKWARDS3
 908 an additional argument is supplied:
 909 .PP
 910 .in +4
 911 .EX
 912 .BI "long clone(unsigned long " flags ", void *" child_stack ,
 913 .BI "           int " stack_size , "\fR         /* Size of stack */"
 914 .BI "           int *" ptid ", int *" ctid ,
 915 .BI "           unsigned long " newtls );
 916 .EE
 917 .in
 918 .\"
 919 .SS blackfin, m68k, and sparc
 920 .\" Mike Frysinger noted in a 2013 mail:
 921 .\"     these arches don't define __ARCH_WANT_SYS_CLONE:
 922 .\"     blackfin ia64 m68k sparc
 923 The argument-passing conventions on
 924 blackfin, m68k, and sparc are different from the descriptions above.
 925 For details, see the kernel (and glibc) source.
 926 .SS ia64
 927 On ia64, a different interface is used:
 928 .PP
 929 .in +4
 930 .EX
 931 .BI "int __clone2(int (*" "fn" ")(void *), "
 932 .BI "             void *" child_stack_base ", size_t " stack_size ,
 933 .BI "             int " flags ", void *" "arg" ", ... "
 934 .BI "          /* pid_t *" ptid ", struct user_desc *" tls \
 935 ", pid_t *" ctid " */ );"
 936 .EE
 937 .in
 938 .PP
 939 The prototype shown above is for the glibc wrapper function;
 940 for the system call itself,
 941 the prototype can be described as follows (it is identical to the
 942 .BR clone ()
 943 prototype on microblaze):
 944 .PP
 945 .in +4
 946 .EX
 947 .BI "long clone2(unsigned long " flags ", void *" child_stack_base ,
 948 .BI "            int " stack_size , "\fR         /* Size of stack */"
 949 .BI "            int *" ptid ", int *" ctid ,
 950 .BI "            unsigned long " tls );
 951 .EE
 952 .in
 953 .PP
 954 .BR __clone2 ()
 955 operates in the same way as
 956 .BR clone (),
 957 except that
 958 .I child_stack_base
 959 points to the lowest address of the child's stack area,
 960 and
 961 .I stack_size
 962 specifies the size of the stack pointed to by
 963 .IR child_stack_base .
 964 .SS Linux 2.4 and earlier
 965 In Linux 2.4 and earlier,
 966 .BR clone ()
 967 does not take arguments
 968 .IR ptid ,
 969 .IR tls ,
 970 and
 971 .IR ctid .
 972 .SH RETURN VALUE
 973 .\" gettid(2) returns current->pid;
 974 .\" getpid(2) returns current->tgid;
 975 On success, the thread ID of the child process is returned
 976 in the caller's thread of execution.
 977 On failure, \-1 is returned
 978 in the caller's context, no child process will be created, and
 979 .I errno
 980 will be set appropriately.
 981 .SH ERRORS
 982 .TP
 983 .B EAGAIN
 984 Too many processes are already running; see
 985 .BR fork (2).
 986 .TP
 987 .B EINVAL
 988 .B CLONE_SIGHAND
 989 was specified, but
 990 .B CLONE_VM
 991 was not.
 992 (Since Linux 2.6.0-test6.)
 993 .TP
 994 .B EINVAL
 995 .B CLONE_THREAD
 996 was specified, but
 997 .B CLONE_SIGHAND
 998 was not.
 999 (Since Linux 2.5.35.)
1000 .\" .TP
1001 .\" .B EINVAL
1002 .\" Precisely one of
1003 .\" .B CLONE_DETACHED
1004 .\" and
1005 .\" .B CLONE_THREAD
1006 .\" was specified.
1007 .\" (Since Linux 2.6.0-test6.)
1008 .TP
1009 .B EINVAL
1010 .\" commit e66eded8309ebf679d3d3c1f5820d1f2ca332c71
1011 Both
1012 .B CLONE_FS
1013 and
1014 .B CLONE_NEWNS
1015 were specified in
1016 .IR flags .
1017 .TP
1018 .BR EINVAL " (since Linux 3.9)"
1019 Both
1020 .B CLONE_NEWUSER
1021 and
1022 .B CLONE_FS
1023 were specified in
1024 .IR flags .
1025 .TP
1026 .B EINVAL
1027 Both
1028 .B CLONE_NEWIPC
1029 and
1030 .B CLONE_SYSVSEM
1031 were specified in
1032 .IR flags .
1033 .TP
1034 .B EINVAL
1035 One (or both) of
1036 .BR CLONE_NEWPID
1037 or
1038 .BR CLONE_NEWUSER
1039 and one (or both) of
1040 .BR CLONE_THREAD
1041 or
1042 .BR CLONE_PARENT
1043 were specified in
1044 .IR flags .
1045 .TP
1046 .B EINVAL
1047 Returned by the glibc
1048 .BR clone ()
1049 wrapper function when
1050 .IR fn
1051 or
1052 .IR child_stack
1053 is specified as NULL.
1054 .TP
1055 .B EINVAL
1056 .BR CLONE_NEWIPC
1057 was specified in
1058 .IR flags ,
1059 but the kernel was not configured with the
1060 .B CONFIG_SYSVIPC
1061 and
1062 .BR CONFIG_IPC_NS
1063 options.
1064 .TP
1065 .B EINVAL
1066 .BR CLONE_NEWNET
1067 was specified in
1068 .IR flags ,
1069 but the kernel was not configured with the
1070 .B CONFIG_NET_NS
1071 option.
1072 .TP
1073 .B EINVAL
1074 .BR CLONE_NEWPID
1075 was specified in
1076 .IR flags ,
1077 but the kernel was not configured with the
1078 .B CONFIG_PID_NS
1079 option.
1080 .TP
1081 .B EINVAL
1082 .BR CLONE_NEWUSER
1083 was specified in
1084 .IR flags ,
1085 but the kernel was not configured with the
1086 .B CONFIG_USER_NS
1087 option.
1088 .TP
1089 .B EINVAL
1090 .BR CLONE_NEWUTS
1091 was specified in
1092 .IR flags ,
1093 but the kernel was not configured with the
1094 .B CONFIG_UTS_NS
1095 option.
1096 .TP
1097 .B EINVAL
1098 .I child_stack
1099 is not aligned to a suitable boundary for this architecture.
1100 For example, on aarch64,
1101 .I child_stack
1102 must be a multiple of 16.
1103 .TP
1104 .B ENOMEM
1105 Cannot allocate sufficient memory to allocate a task structure for the
1106 child, or to copy those parts of the caller's context that need to be
1107 copied.
1108 .TP
1109 .BR ENOSPC " (since Linux 3.7)"
1110 .\" commit f2302505775fd13ba93f034206f1e2a587017929
1111 .B CLONE_NEWPID
1112 was specified in flags,
1113 but the limit on the nesting depth of PID namespaces
1114 would have been exceeded; see
1115 .BR pid_namespaces (7).
1116 .TP
1117 .BR ENOSPC " (since Linux 4.9; beforehand " EUSERS )
1118 .B CLONE_NEWUSER
1119 was specified in
1120 .IR flags ,
1121 and the call would cause the limit on the number of
1122 nested user namespaces to be exceeded.
1123 See
1124 .BR user_namespaces (7).
1125 .IP
1126 From Linux 3.11 to Linux 4.8, the error diagnosed in this case was
1127 .BR EUSERS .
1128 .TP
1129 .BR ENOSPC " (since Linux 4.9)"
1130 One of the values in
1131 .I flags
1132 specified the creation of a new user namespace,
1133 but doing so would have caused the limit defined by the corresponding file in
1134 .IR /proc/sys/user
1135 to be exceeded.
1136 For further details, see
1137 .BR namespaces (7).
1138 .TP
1139 .B EPERM
1140 .BR CLONE_NEWCGROUP ,
1141 .BR CLONE_NEWIPC ,
1142 .BR CLONE_NEWNET ,
1143 .BR CLONE_NEWNS ,
1144 .BR CLONE_NEWPID ,
1145 or
1146 .BR CLONE_NEWUTS
1147 was specified by an unprivileged process (process without \fBCAP_SYS_ADMIN\fP).
1148 .TP
1149 .B EPERM
1150 .B CLONE_PID
1151 was specified by a process other than process 0.
1152 (This error occurs only on Linux 2.5.15 and earlier.)
1153 .TP
1154 .B EPERM
1155 .BR CLONE_NEWUSER
1156 was specified in
1157 .IR flags ,
1158 but either the effective user ID or the effective group ID of the caller
1159 does not have a mapping in the parent namespace (see
1160 .BR user_namespaces (7)).
1161 .TP
1162 .BR EPERM " (since Linux 3.9)"
1163 .\" commit 3151527ee007b73a0ebd296010f1c0454a919c7d
1164 .B CLONE_NEWUSER
1165 was specified in
1166 .I flags
1167 and the caller is in a chroot environment
1168 .\" FIXME What is the rationale for this restriction?
1169 (i.e., the caller's root directory does not match the root directory
1170 of the mount namespace in which it resides).
1171 .TP
1172 .BR ERESTARTNOINTR " (since Linux 2.6.17)"
1173 .\" commit 4a2c7a7837da1b91468e50426066d988050e4d56
1174 System call was interrupted by a signal and will be restarted.
1175 (This can be seen only during a trace.)
1176 .TP
1177 .BR EUSERS " (Linux 3.11 to Linux 4.8)"
1178 .B CLONE_NEWUSER
1179 was specified in
1180 .IR flags ,
1181 and the limit on the number of nested user namespaces would be exceeded.
1182 See the discussion of the
1183 .BR ENOSPC
1184 error above.
1185 .\" .SH VERSIONS
1186 .\" There is no entry for
1187 .\" .BR clone ()
1188 .\" in libc5.
1189 .\" glibc2 provides
1190 .\" .BR clone ()
1191 .\" as described in this manual page.
1192 .SH CONFORMING TO
1193 .BR clone ()
1194 is Linux-specific and should not be used in programs
1195 intended to be portable.
1196 .SH NOTES
1197 The
1198 .BR kcmp (2)
1199 system call can be used to test whether two processes share various
1200 resources such as a file descriptor table,
1201 System V semaphore undo operations, or a virtual address space.
1202 .PP
1203 .PP
1204 Handlers registered using
1205 .BR pthread_atfork (3)
1206 are not executed during a call to
1207 .BR clone ().
1208 .PP
1209 In the Linux 2.4.x series,
1210 .B CLONE_THREAD
1211 generally does not make the parent of the new thread the same
1212 as the parent of the calling process.
1213 However, for kernel versions 2.4.7 to 2.4.18 the
1214 .B CLONE_THREAD
1215 flag implied the
1216 .B CLONE_PARENT
1217 flag (as in Linux 2.6.0 and later).
1218 .PP
1219 For a while there was
1220 .B CLONE_DETACHED
1221 (introduced in 2.5.32):
1222 parent wants no child-exit signal.
1223 In Linux 2.6.2, the need to give this flag together with
1224 .B CLONE_THREAD
1225 disappeared.
1226 This flag is still defined, but has no effect.
1227 .PP
1228 On i386,
1229 .BR clone ()
1230 should not be called through vsyscall, but directly through
1231 .IR "int $0x80" .
1232 .SH BUGS
1233 GNU C library versions 2.3.4 up to and including 2.24
1234 contained a wrapper function for
1235 .BR getpid (2)
1236 that performed caching of PIDs.
1237 This caching relied on support in the glibc wrapper for
1238 .BR clone (),
1239 but limitations in the implementation
1240 meant that the cache was not up to date in some circumstances.
1241 In particular,
1242 if a signal was delivered to the child immediately after the
1243 .BR clone ()
1244 call, then a call to
1245 .BR getpid (2)
1246 in a handler for the signal could return the PID
1247 of the calling process ("the parent"),
1248 if the clone wrapper had not yet had a chance to update the PID
1249 cache in the child.
1250 (This discussion ignores the case where the child was created using
1251 .BR CLONE_THREAD ,
1252 when
1253 .BR getpid (2)
1254 .I should
1255 return the same value in the child and in the process that called
1256 .BR clone (),
1257 since the caller and the child are in the same thread group.
1258 The stale-cache problem also does not occur if the
1259 .I flags
1260 argument includes
1261 .BR CLONE_VM .)
1262 To get the truth, it was sometimes necessary to use code such as the following:
1263 .PP
1264 .in +4n
1265 .EX
1266 #include <syscall.h>
1267
1268 pid_t mypid;
1269
1270 mypid = syscall(SYS_getpid);
1271 .EE
1272 .in
1273 .\" See also the following bug reports
1274 .\" https://bugzilla.redhat.com/show_bug.cgi?id=417521
1275 .\" http://sourceware.org/bugzilla/show_bug.cgi?id=6910
1276 .PP
1277 Because of the stale-cache problem, as well as other problems noted in
1278 .BR getpid (2),
1279 the PID caching feature was removed in glibc 2.25.
1280 .SH EXAMPLE
1281 The following program demonstrates the use of
1282 .BR clone ()
1283 to create a child process that executes in a separate UTS namespace.
1284 The child changes the hostname in its UTS namespace.
1285 Both parent and child then display the system hostname,
1286 making it possible to see that the hostname
1287 differs in the UTS namespaces of the parent and child.
1288 For an example of the use of this program, see
1289 .BR setns (2).
1290 .SS Program source
1291 .EX
1292 #define _GNU_SOURCE
1293 #include <sys/wait.h>
1294 #include <sys/utsname.h>
1295 #include <sched.h>
1296 #include <string.h>
1297 #include <stdio.h>
1298 #include <stdlib.h>
1299 #include <unistd.h>
1300
1301 #define errExit(msg)    do { perror(msg); exit(EXIT_FAILURE); \\
1302                         } while (0)
1303
1304 static int              /* Start function for cloned child */
1305 childFunc(void *arg)
1306 {
1307     struct utsname uts;
1308
1309     /* Change hostname in UTS namespace of child */
1310
1311     if (sethostname(arg, strlen(arg)) == \-1)
1312         errExit("sethostname");
1313
1314     /* Retrieve and display hostname */
1315
1316     if (uname(&uts) == \-1)
1317         errExit("uname");
1318     printf("uts.nodename in child:  %s\\n", uts.nodename);
1319
1320     /* Keep the namespace open for a while, by sleeping.
1321        This allows some experimentation\-\-for example, another
1322        process might join the namespace. */
1323
1324     sleep(200);
1325
1326     return 0;           /* Child terminates now */
1327 }
1328
1329 #define STACK_SIZE (1024 * 1024)    /* Stack size for cloned child */
1330
1331 int
1332 main(int argc, char *argv[])
1333 {
1334     char *stack;                    /* Start of stack buffer */
1335     char *stackTop;                 /* End of stack buffer */
1336     pid_t pid;
1337     struct utsname uts;
1338
1339     if (argc < 2) {
1340         fprintf(stderr, "Usage: %s <child\-hostname>\\n", argv[0]);
1341         exit(EXIT_SUCCESS);
1342     }
1343
1344     /* Allocate stack for child */
1345
1346     stack = malloc(STACK_SIZE);
1347     if (stack == NULL)
1348         errExit("malloc");
1349     stackTop = stack + STACK_SIZE;  /* Assume stack grows downward */
1350
1351     /* Create child that has its own UTS namespace;
1352        child commences execution in childFunc() */
1353
1354     pid = clone(childFunc, stackTop, CLONE_NEWUTS | SIGCHLD, argv[1]);
1355     if (pid == \-1)
1356         errExit("clone");
1357     printf("clone() returned %ld\\n", (long) pid);
1358
1359     /* Parent falls through to here */
1360
1361     sleep(1);           /* Give child time to change its hostname */
1362
1363     /* Display hostname in parent\(aqs UTS namespace. This will be
1364        different from hostname in child\(aqs UTS namespace. */
1365
1366     if (uname(&uts) == \-1)
1367         errExit("uname");
1368     printf("uts.nodename in parent: %s\\n", uts.nodename);
1369
1370     if (waitpid(pid, NULL, 0) == \-1)    /* Wait for child */
1371         errExit("waitpid");
1372     printf("child has terminated\\n");
1373
1374     exit(EXIT_SUCCESS);
1375 }
1376 .EE
1377 .SH SEE ALSO
1378 .BR fork (2),
1379 .BR futex (2),
1380 .BR getpid (2),
1381 .BR gettid (2),
1382 .BR kcmp (2),
1383 .BR set_thread_area (2),
1384 .BR set_tid_address (2),
1385 .BR setns (2),
1386 .BR tkill (2),
1387 .BR unshare (2),
1388 .BR wait (2),
1389 .BR capabilities (7),
1390 .BR namespaces (7),
1391 .BR pthreads (7)