summaryrefslogtreecommitdiffstats
path: root/man2/clone.2
blob: 38d2b9054385202d23aa7bf2e03ac25a52323c0c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
'\" t
.\" Copyright (c) 1992 Drew Eckhardt <drew@cs.colorado.edu>, March 28, 1992
.\" and Copyright (c) Michael Kerrisk, 2001, 2002, 2005, 2013, 2019
.\"
.\" SPDX-License-Identifier: GPL-1.0-or-later
.\"
.\" Modified by Michael Haardt <michael@moria.de>
.\" Modified 24 Jul 1993 by Rik Faith <faith@cs.unc.edu>
.\" Modified 21 Aug 1994 by Michael Chastain <mec@shell.portal.com>:
.\"   New man page (copied from 'fork.2').
.\" Modified 10 June 1995 by Andries Brouwer <aeb@cwi.nl>
.\" Modified 25 April 1998 by Xavier Leroy <Xavier.Leroy@inria.fr>
.\" Modified 26 Jun 2001 by Michael Kerrisk
.\"     Mostly upgraded to Linux 2.4.x
.\"     Added prototype for sys_clone() plus description
.\"	Added CLONE_THREAD with a brief description of thread groups
.\"	Added CLONE_PARENT and revised entire page remove ambiguity
.\"		between "calling process" and "parent process"
.\"	Added CLONE_PTRACE and CLONE_VFORK
.\"	Added EPERM and EINVAL error codes
.\"	Renamed "__clone" to "clone" (which is the prototype in <sched.h>)
.\"	various other minor tidy ups and clarifications.
.\" Modified 26 Jun 2001 by Michael Kerrisk <mtk.manpages@gmail.com>
.\"	Updated notes for 2.4.7+ behavior of CLONE_THREAD
.\" Modified 15 Oct 2002 by Michael Kerrisk <mtk.manpages@gmail.com>
.\"	Added description for CLONE_NEWNS, which was added in Linux 2.4.19
.\" Slightly rephrased, aeb.
.\" Modified 1 Feb 2003 - added CLONE_SIGHAND restriction, aeb.
.\" Modified 1 Jan 2004 - various updates, aeb
.\" Modified 2004-09-10 - added CLONE_PARENT_SETTID etc. - aeb.
.\" 2005-04-12, mtk, noted the PID caching behavior of NPTL's getpid()
.\"	wrapper under BUGS.
.\" 2005-05-10, mtk, added CLONE_SYSVSEM, CLONE_UNTRACED, CLONE_STOPPED.
.\" 2005-05-17, mtk, Substantially enhanced discussion of CLONE_THREAD.
.\" 2008-11-18, mtk, order CLONE_* flags alphabetically
.\" 2008-11-18, mtk, document CLONE_NEWPID
.\" 2008-11-19, mtk, document CLONE_NEWUTS
.\" 2008-11-19, mtk, document CLONE_NEWIPC
.\" 2008-11-19, Jens Axboe, mtk, document CLONE_IO
.\"
.TH clone 2 2023-05-03 "Linux man-pages 6.05.01"
.SH NAME
clone, __clone2, clone3 \- create a child process
.SH LIBRARY
Standard C library
.RI ( libc ", " \-lc )
.SH SYNOPSIS
.nf
/* Prototype for the glibc wrapper function */
.PP
.B #define _GNU_SOURCE
.B #include <sched.h>
.PP
.BI "int clone(int (*" "fn" ")(void *_Nullable), void *" stack \
", int " flags ,
.BI "          void *_Nullable " "arg" ", ..." \
"  \fR/*\fP" " pid_t *_Nullable " parent_tid ,
.BI "                                       void *_Nullable " tls ,
.BI "                                       pid_t *_Nullable " child_tid " \fR*/\fP );"
.PP
/* For the prototype of the raw clone() system call, see NOTES */
.PP
.BR "#include <linux/sched.h>" "    /* Definition of " "struct clone_args" " */"
.BR "#include <sched.h>" "          /* Definition of " CLONE_* " constants */"
.BR "#include <sys/syscall.h>" "    /* Definition of " SYS_* " constants */"
.B #include <unistd.h>
.PP
.BI "long syscall(SYS_clone3, struct clone_args *" cl_args ", size_t " size );
.fi
.PP
.IR Note :
glibc provides no wrapper for
.BR clone3 (),
necessitating the use of
.BR syscall (2).
.SH DESCRIPTION
These system calls
create a new ("child") process, in a manner similar to
.BR fork (2).
.PP
By contrast with
.BR fork (2),
these system calls provide more precise control over what pieces of execution
context are shared between the calling process and the child process.
For example, using these system calls, the caller can control whether
or not the two processes share the virtual address space,
the table of file descriptors, and the table of signal handlers.
These system calls also allow the new child process to be placed
in separate
.BR namespaces (7).
.PP
Note that in this manual
page, "calling process" normally corresponds to "parent process".
But see the descriptions of
.B CLONE_PARENT
and
.B CLONE_THREAD
below.
.PP
This page describes the following interfaces:
.IP \[bu] 3
The glibc
.BR clone ()
wrapper function and the underlying system call on which it is based.
The main text describes the wrapper function;
the differences for the raw system call
are described toward the end of this page.
.IP \[bu]
The newer
.BR clone3 ()
system call.
.PP
In the remainder of this page, the terminology "the clone call" is used
when noting details that apply to all of these interfaces,
.\"
.SS The clone() wrapper function
When the child process is created with the
.BR clone ()
wrapper function,
it commences execution by calling the function pointed to by the argument
.IR fn .
(This differs from
.BR fork (2),
where execution continues in the child from the point
of the
.BR fork (2)
call.)
The
.I arg
argument is passed as the argument of the function
.IR fn .
.PP
When the
.IR fn ( arg )
function returns, the child process terminates.
The integer returned by
.I fn
is the exit status for the child process.
The child process may also terminate explicitly by calling
.BR exit (2)
or after receiving a fatal signal.
.PP
The
.I stack
argument specifies the location of the stack used by the child process.
Since the child and calling process may share memory,
it is not possible for the child process to execute in the
same stack as the calling process.
The calling process must therefore
set up memory space for the child stack and pass a pointer to this
space to
.BR clone ().
Stacks grow downward on all processors that run Linux
(except the HP PA processors), so
.I stack
usually points to the topmost address of the memory space set up for
the child stack.
Note that
.BR clone ()
does not provide a means whereby the caller can inform the kernel of the
size of the stack area.
.PP
The remaining arguments to
.BR clone ()
are discussed below.
.\"
.SS clone3()
The
.BR clone3 ()
system call provides a superset of the functionality of the older
.BR clone ()
interface.
It also provides a number of API improvements, including:
space for additional flags bits;
cleaner separation in the use of various arguments;
and the ability to specify the size of the child's stack area.
.PP
As with
.BR fork (2),
.BR clone3 ()
returns in both the parent and the child.
It returns 0 in the child process and returns the PID of the child
in the parent.
.PP
The
.I cl_args
argument of
.BR clone3 ()
is a structure of the following form:
.PP
.in +4n
.EX
struct clone_args {
    u64 flags;        /* Flags bit mask */
    u64 pidfd;        /* Where to store PID file descriptor
                         (\fIint *\fP) */
    u64 child_tid;    /* Where to store child TID,
                         in child\[aq]s memory (\fIpid_t *\fP) */
    u64 parent_tid;   /* Where to store child TID,
                         in parent\[aq]s memory (\fIpid_t *\fP) */
    u64 exit_signal;  /* Signal to deliver to parent on
                         child termination */
    u64 stack;        /* Pointer to lowest byte of stack */
    u64 stack_size;   /* Size of stack */
    u64 tls;          /* Location of new TLS */
    u64 set_tid;      /* Pointer to a \fIpid_t\fP array
                         (since Linux 5.5) */
    u64 set_tid_size; /* Number of elements in \fIset_tid\fP
                         (since Linux 5.5) */
    u64 cgroup;       /* File descriptor for target cgroup
                         of child (since Linux 5.7) */
};
.EE
.in
.PP
The
.I size
argument that is supplied to
.BR clone3 ()
should be initialized to the size of this structure.
(The existence of the
.I size
argument permits future extensions to the
.I clone_args
structure.)
.PP
The stack for the child process is specified via
.IR cl_args.stack ,
which points to the lowest byte of the stack area,
and
.IR cl_args.stack_size ,
which specifies the size of the stack in bytes.
In the case where the
.B CLONE_VM
flag (see below) is specified, a stack must be explicitly allocated
and specified.
Otherwise, these two fields can be specified as NULL and 0,
which causes the child to use the same stack area as the parent
(in the child's own virtual address space).
.PP
The remaining fields in the
.I cl_args
argument are discussed below.
.\"
.SS Equivalence between clone() and clone3() arguments
Unlike the older
.BR clone ()
interface, where arguments are passed individually, in the newer
.BR clone3 ()
interface the arguments are packaged into the
.I clone_args
structure shown above.
This structure allows for a superset of the information passed via the
.BR clone ()
arguments.
.PP
The following table shows the equivalence between the arguments of
.BR clone ()
and the fields in the
.I clone_args
argument supplied to
.BR clone3 ():
.RS 4
.TS
lb lb lb
l l l
li li l.
clone()	clone3()	Notes
	\fIcl_args\fP field
flags & \[ti]0xff	flags	T{
For most flags; details below
T}
parent_tid	pidfd	See CLONE_PIDFD
child_tid	child_tid	See CLONE_CHILD_SETTID
parent_tid	parent_tid	See CLONE_PARENT_SETTID
flags & 0xff	exit_signal
stack	stack
\fP---\fP	stack_size
tls	tls	See CLONE_SETTLS
\fP---\fP	set_tid	See below for details
\fP---\fP	set_tid_size
\fP---\fP	cgroup	See CLONE_INTO_CGROUP
.TE
.RE
.\"
.SS The child termination signal
When the child process terminates, a signal may be sent to the parent.
The termination signal is specified in the low byte of
.I flags
.RB ( clone ())
or in
.I cl_args.exit_signal
.RB ( clone3 ()).
If this signal is specified as anything other than
.BR SIGCHLD ,
then the parent process must specify the
.B __WALL
or
.B __WCLONE
options when waiting for the child with
.BR wait (2).
If no signal (i.e., zero) is specified, then the parent process is not signaled
when the child terminates.
.\"
.SS The set_tid array
By default, the kernel chooses the next sequential PID for the new
process in each of the PID namespaces where it is present.
When creating a process with
.BR clone3 (),
the
.I set_tid
array (available since Linux 5.5)
can be used to select specific PIDs for the process in some
or all of the PID namespaces where it is present.
If the PID of the newly created process should be set only for the current
PID namespace or in the newly created PID namespace (if
.I flags
contains
.BR CLONE_NEWPID )
then the first element in the
.I set_tid
array has to be the desired PID and
.I set_tid_size
needs to be 1.
.PP
If the PID of the newly created process should have a certain value in
multiple PID namespaces, then the
.I set_tid
array can have multiple entries.
The first entry defines the PID in the most
deeply nested PID namespace and each of the following entries contains
the PID in the
corresponding ancestor PID namespace.
The number of PID namespaces in which a PID
should be set is defined by
.I set_tid_size
which cannot be larger than the number of currently nested PID namespaces.
.PP
To create a process with the following PIDs in a PID namespace hierarchy:
.RS 4
.TS
lb lb lb
l l l.
PID NS level	Requested PID	Notes
0	31496	Outermost PID namespace
1	42
2	7	Innermost PID namespace
.TE
.RE
.PP
Set the array to:
.PP
.in +4n
.EX
set_tid[0] = 7;
set_tid[1] = 42;
set_tid[2] = 31496;
set_tid_size = 3;
.EE
.in
.PP
If only the PIDs in the two innermost PID namespaces
need to be specified, set the array to:
.PP
.in +4n
.EX
set_tid[0] = 7;
set_tid[1] = 42;
set_tid_size = 2;
.EE
.in
.PP
The PID in the PID namespaces outside the two innermost PID namespaces
is selected the same way as any other PID is selected.
.PP
The
.I set_tid
feature requires
.B CAP_SYS_ADMIN
or
(since Linux 5.9)
.\" commit 124ea650d3072b005457faed69909221c2905a1f
.\" commit 1caef81da05a84a40dbf02110e967ce6d1135ff6
.B CAP_CHECKPOINT_RESTORE
in all owning user namespaces of the target PID namespaces.
.PP
Callers may only choose a PID greater than 1 in a given PID namespace
if an
.B init
process (i.e., a process with PID 1) already exists in that namespace.
Otherwise the PID
entry for this PID namespace must be 1.
.\"
.SS The flags mask
Both
.BR clone ()
and
.BR clone3 ()
allow a flags bit mask that modifies their behavior
and allows the caller to specify what is shared between the calling process
and the child process.
This bit mask\[em]the
.I flags
argument of
.BR clone ()
or the
.I cl_args.flags
field passed to
.BR clone3 ()\[em]is
referred to as the
.I flags
mask in the remainder of this page.
.PP
The
.I flags
mask is specified as a bitwise OR of zero or more of
the constants listed below.
Except as noted below, these flags are available
(and have the same effect) in both
.BR clone ()
and
.BR clone3 ().
.TP
.BR CLONE_CHILD_CLEARTID " (since Linux 2.5.49)"
Clear (zero) the child thread ID at the location pointed to by
.I child_tid
.RB ( clone ())
or
.I cl_args.child_tid
.RB ( clone3 ())
in child memory when the child exits, and do a wakeup on the futex
at that address.
The address involved may be changed by the
.BR set_tid_address (2)
system call.
This is used by threading libraries.
.TP
.BR CLONE_CHILD_SETTID " (since Linux 2.5.49)"
Store the child thread ID at the location pointed to by
.I child_tid
.RB ( clone ())
or
.I cl_args.child_tid
.RB ( clone3 ())
in the child's memory.
The store operation completes before the clone call
returns control to user space in the child process.
(Note that the store operation may not have completed before the clone call
returns in the parent process, which is relevant if the
.B CLONE_VM
flag is also employed.)
.TP
.BR CLONE_CLEAR_SIGHAND " (since Linux 5.5)"
.\" commit b612e5df4587c934bd056bf05f4a1deca4de4f75
By default, signal dispositions in the child thread are the same as
in the parent.
If this flag is specified,
then all signals that are handled in the parent
are reset to their default dispositions
.RB ( SIG_DFL )
in the child.
.IP
Specifying this flag together with
.B CLONE_SIGHAND
is nonsensical and disallowed.
.TP
.BR CLONE_DETACHED " (historical)"
For a while (during the Linux 2.5 development series)
.\" added in Linux 2.5.32; removed in Linux 2.6.0-test4
there was a
.B CLONE_DETACHED
flag,
which caused the parent not to receive a signal when the child terminated.
Ultimately, the effect of this flag was subsumed under the
.B CLONE_THREAD
flag and by the time Linux 2.6.0 was released, this flag had no effect.
Starting in Linux 2.6.2, the need to give this flag together with
.B CLONE_THREAD
disappeared.
.IP
This flag is still defined, but it is usually ignored when calling
.BR clone ().
However, see the description of
.B CLONE_PIDFD
for some exceptions.
.TP
.BR CLONE_FILES " (since Linux 2.0)"
If
.B CLONE_FILES
is set, the calling process and the child process share the same file
descriptor table.
Any file descriptor created by the calling process or by the child
process is also valid in the other process.
Similarly, if one of the processes closes a file descriptor,
or changes its associated flags (using the
.BR fcntl (2)
.B F_SETFD
operation), the other process is also affected.
If a process sharing a file descriptor table calls
.BR execve (2),
its file descriptor table is duplicated (unshared).
.IP
If
.B CLONE_FILES
is not set, the child process inherits a copy of all file descriptors
opened in the calling process at the time of the clone call.
Subsequent operations that open or close file descriptors,
or change file descriptor flags,
performed by either the calling
process or the child process do not affect the other process.
Note, however,
that the duplicated file descriptors in the child refer to the same
open file descriptions as the corresponding file descriptors
in the calling process,
and thus share file offsets and file status flags (see
.BR open (2)).
.TP
.BR CLONE_FS " (since Linux 2.0)"
If
.B CLONE_FS
is set, the caller and the child process share the same filesystem
information.
This includes the root of the filesystem, the current
working directory, and the umask.
Any call to
.BR chroot (2),
.BR chdir (2),
or
.BR umask (2)
performed by the calling process or the child process also affects the
other process.
.IP
If
.B CLONE_FS
is not set, the child process works on a copy of the filesystem
information of the calling process at the time of the clone call.
Calls to
.BR chroot (2),
.BR chdir (2),
or
.BR umask (2)
performed later by one of the processes do not affect the other process.
.TP
.BR CLONE_INTO_CGROUP " (since Linux 5.7)"
.\" commit ef2c41cf38a7559bbf91af42d5b6a4429db8fc68
By default, a child process is placed in the same version 2
cgroup as its parent.
The
.B CLONE_INTO_CGROUP
flag allows the child process to be created in a different version 2 cgroup.
(Note that
.B CLONE_INTO_CGROUP
has effect only for version 2 cgroups.)
.IP
In order to place the child process in a different cgroup,
the caller specifies
.B CLONE_INTO_CGROUP
in
.I cl_args.flags
and passes a file descriptor that refers to a version 2 cgroup in the
.I cl_args.cgroup
field.
(This file descriptor can be obtained by opening a cgroup v2 directory
using either the
.B O_RDONLY
or the
.B O_PATH
flag.)
Note that all of the usual restrictions (described in
.BR cgroups (7))
on placing a process into a version 2 cgroup apply.
.IP
Among the possible use cases for
.B CLONE_INTO_CGROUP
are the following:
.RS
.IP \[bu] 3
Spawning a process into a cgroup different from the parent's cgroup
makes it possible for a service manager to directly spawn new
services into dedicated cgroups.
This eliminates the accounting
jitter that would be caused if the child process was first created in the
same cgroup as the parent and then
moved into the target cgroup.
Furthermore, spawning the child process directly into a target cgroup
is significantly cheaper than moving the child process into
the target cgroup after it has been created.
.IP \[bu]
The
.B CLONE_INTO_CGROUP
flag also allows the creation of
frozen child processes by spawning them into a frozen cgroup.
(See
.BR cgroups (7)
for a description of the freezer controller.)
.IP \[bu]
For threaded applications (or even thread implementations which
make use of cgroups to limit individual threads), it is possible to
establish a fixed cgroup layout before spawning each thread
directly into its target cgroup.
.RE
.TP
.BR CLONE_IO " (since Linux 2.6.25)"
If
.B CLONE_IO
is set, then the new process shares an I/O context with
the calling process.
If this flag is not set, then (as with
.BR fork (2))
the new process has its own I/O context.
.IP
.\" The following based on text from Jens Axboe
The I/O context is the I/O scope of the disk scheduler (i.e.,
what the I/O scheduler uses to model scheduling of a process's I/O).
If processes share the same I/O context,
they are treated as one by the I/O scheduler.
As a consequence, they get to share disk time.
For some I/O schedulers,
.\" the anticipatory and CFQ scheduler
if two processes share an I/O context,
they will be allowed to interleave their disk access.
If several threads are doing I/O on behalf of the same process
.RB ( aio_read (3),
for instance), they should employ
.B CLONE_IO
to get better I/O performance.
.\" with CFQ and AS.
.IP
If the kernel is not configured with the
.B CONFIG_BLOCK
option, this flag is a no-op.
.TP
.BR CLONE_NEWCGROUP " (since Linux 4.6)"
Create the process in a new cgroup namespace.
If this flag is not set, then (as with
.BR fork (2))
the process is created in the same cgroup namespaces as the calling process.
.IP
For further information on cgroup namespaces, see
.BR cgroup_namespaces (7).
.IP
Only a privileged process
.RB ( CAP_SYS_ADMIN )
can employ
.BR CLONE_NEWCGROUP .
.\"
.TP
.BR CLONE_NEWIPC " (since Linux 2.6.19)"
If
.B CLONE_NEWIPC
is set, then create the process in a new IPC namespace.
If this flag is not set, then (as with
.BR fork (2)),
the process is created in the same IPC namespace as
the calling process.
.IP
For further information on IPC namespaces, see
.BR ipc_namespaces (7).
.IP
Only a privileged process
.RB ( CAP_SYS_ADMIN )
can employ
.BR CLONE_NEWIPC .
This flag can't be specified in conjunction with
.BR CLONE_SYSVSEM .
.TP
.BR CLONE_NEWNET " (since Linux 2.6.24)"
(The implementation of this flag was completed only
by about Linux 2.6.29.)
.IP
If
.B CLONE_NEWNET
is set, then create the process in a new network namespace.
If this flag is not set, then (as with
.BR fork (2))
the process is created in the same network namespace as
the calling process.
.IP
For further information on network namespaces, see
.BR network_namespaces (7).
.IP
Only a privileged process
.RB ( CAP_SYS_ADMIN )
can employ
.BR CLONE_NEWNET .
.TP
.BR CLONE_NEWNS " (since Linux 2.4.19)"
If
.B CLONE_NEWNS
is set, the cloned child is started in a new mount namespace,
initialized with a copy of the namespace of the parent.
If
.B CLONE_NEWNS
is not set, the child lives in the same mount
namespace as the parent.
.IP
For further information on mount namespaces, see
.BR namespaces (7)
and
.BR mount_namespaces (7).
.IP
Only a privileged process
.RB ( CAP_SYS_ADMIN )
can employ
.BR CLONE_NEWNS .
It is not permitted to specify both
.B CLONE_NEWNS
and
.B CLONE_FS
.\" See https://lwn.net/Articles/543273/
in the same clone call.
.TP
.BR CLONE_NEWPID " (since Linux 2.6.24)"
.\" This explanation draws a lot of details from
.\" http://lwn.net/Articles/259217/
.\" Authors: Pavel Emelyanov <xemul@openvz.org>
.\" and Kir Kolyshkin <kir@openvz.org>
.\"
.\" The primary kernel commit is 30e49c263e36341b60b735cbef5ca37912549264
.\" Author: Pavel Emelyanov <xemul@openvz.org>
If
.B CLONE_NEWPID
is set, then create the process in a new PID namespace.
If this flag is not set, then (as with
.BR fork (2))
the process is created in the same PID namespace as
the calling process.
.IP
For further information on PID namespaces, see
.BR namespaces (7)
and
.BR pid_namespaces (7).
.IP
Only a privileged process
.RB ( CAP_SYS_ADMIN )
can employ
.BR CLONE_NEWPID .
This flag can't be specified in conjunction with
.B CLONE_THREAD
or
.BR CLONE_PARENT .
.TP
.B CLONE_NEWUSER
(This flag first became meaningful for
.BR clone ()
in Linux 2.6.23,
the current
.BR clone ()
semantics were merged in Linux 3.5,
and the final pieces to make the user namespaces completely usable were
merged in Linux 3.8.)
.IP
If
.B CLONE_NEWUSER
is set, then create the process in a new user namespace.
If this flag is not set, then (as with
.BR fork (2))
the process is created in the same user namespace as the calling process.
.IP
For further information on user namespaces, see
.BR namespaces (7)
and
.BR user_namespaces (7).
.IP
Before Linux 3.8, use of
.B CLONE_NEWUSER
required that the caller have three capabilities:
.BR CAP_SYS_ADMIN ,
.BR CAP_SETUID ,
and
.BR CAP_SETGID .
.\" Before Linux 2.6.29, it appears that only CAP_SYS_ADMIN was needed
Starting with Linux 3.8,
no privileges are needed to create a user namespace.
.IP
This flag can't be specified in conjunction with
.B CLONE_THREAD
or
.BR CLONE_PARENT .
For security reasons,
.\" commit e66eded8309ebf679d3d3c1f5820d1f2ca332c71
.\" https://lwn.net/Articles/543273/
.\" The fix actually went into Linux 3.9 and into Linux 3.8.3. However, user namespaces
.\" were, for practical purposes, unusable in earlier Linux 3.8.x because of the
.\" various filesystems that didn't support userns.
.B CLONE_NEWUSER
cannot be specified in conjunction with
.BR CLONE_FS .
.TP
.BR CLONE_NEWUTS " (since Linux 2.6.19)"
If
.B CLONE_NEWUTS
is set, then create the process in a new UTS namespace,
whose identifiers are initialized by duplicating the identifiers
from the UTS namespace of the calling process.
If this flag is not set, then (as with
.BR fork (2))
the process is created in the same UTS namespace as
the calling process.
.IP
For further information on UTS namespaces, see
.BR uts_namespaces (7).
.IP
Only a privileged process
.RB ( CAP_SYS_ADMIN )
can employ
.BR CLONE_NEWUTS .
.TP
.BR CLONE_PARENT " (since Linux 2.3.12)"
If
.B CLONE_PARENT
is set, then the parent of the new child (as returned by
.BR getppid (2))
will be the same as that of the calling process.
.IP
If
.B CLONE_PARENT
is not set, then (as with
.BR fork (2))
the child's parent is the calling process.
.IP
Note that it is the parent process, as returned by
.BR getppid (2),
which is signaled when the child terminates, so that
if
.B CLONE_PARENT
is set, then the parent of the calling process, rather than the
calling process itself, is signaled.
.IP
The
.B CLONE_PARENT
flag can't be used in clone calls by the
global init process (PID 1 in the initial PID namespace)
and init processes in other PID namespaces.
This restriction prevents the creation of multi-rooted process trees
as well as the creation of unreapable zombies in the initial PID namespace.
.TP
.BR CLONE_PARENT_SETTID " (since Linux 2.5.49)"
Store the child thread ID at the location pointed to by
.I parent_tid
.RB ( clone ())
or
.I cl_args.parent_tid
.RB ( clone3 ())
in the parent's memory.
(In Linux 2.5.32-2.5.48 there was a flag
.B CLONE_SETTID
that did this.)
The store operation completes before the clone call
returns control to user space.
.TP
.BR CLONE_PID " (Linux 2.0 to Linux 2.5.15)"
If
.B CLONE_PID
is set, the child process is created with the same process ID as
the calling process.
This is good for hacking the system, but otherwise
of not much use.
From Linux 2.3.21 onward, this flag could be
specified only by the system boot process (PID 0).
The flag disappeared completely from the kernel sources in Linux 2.5.16.
Subsequently, the kernel silently ignored this bit if it was specified in the
.I flags
mask.
Much later, the same bit was recycled for use as the
.B CLONE_PIDFD
flag.
.TP
.BR CLONE_PIDFD " (since Linux 5.2)"
.\" commit b3e5838252665ee4cfa76b82bdf1198dca81e5be
If this flag is specified,
a PID file descriptor referring to the child process is allocated
and placed at a specified location in the parent's memory.
The close-on-exec flag is set on this new file descriptor.
PID file descriptors can be used for the purposes described in
.BR pidfd_open (2).
.RS
.IP \[bu] 3
When using
.BR clone3 (),
the PID file descriptor is placed at the location pointed to by
.IR cl_args.pidfd .
.IP \[bu]
When using
.BR clone (),
the PID file descriptor is placed at the location pointed to by
.IR parent_tid .
Since the
.I parent_tid
argument is used to return the PID file descriptor,
.B CLONE_PIDFD
cannot be used with
.B CLONE_PARENT_SETTID
when calling
.BR clone ().
.RE
.IP
It is currently not possible to use this flag together with
.B CLONE_THREAD.
This means that the process identified by the PID file descriptor
will always be a thread group leader.
.IP
If the obsolete
.B CLONE_DETACHED
flag is specified alongside
.B CLONE_PIDFD
when calling
.BR clone (),
an error is returned.
An error also results if
.B CLONE_DETACHED
is specified when calling
.BR clone3 ().
This error behavior ensures that the bit corresponding to
.B CLONE_DETACHED
can be reused for further PID file descriptor features in the future.
.TP
.BR CLONE_PTRACE " (since Linux 2.2)"
If
.B CLONE_PTRACE
is specified, and the calling process is being traced,
then trace the child also (see
.BR ptrace (2)).
.TP
.BR CLONE_SETTLS " (since Linux 2.5.32)"
The TLS (Thread Local Storage) descriptor is set to
.IR tls .
.IP
The interpretation of
.I tls
and the resulting effect is architecture dependent.
On x86,
.I tls
is interpreted as a
.I struct user_desc\~*
(see
.BR set_thread_area (2)).
On x86-64 it is the new value to be set for the %fs base register
(see the
.B ARCH_SET_FS
argument to
.BR arch_prctl (2)).
On architectures with a dedicated TLS register, it is the new value
of that register.
.IP
Use of this flag requires detailed knowledge and generally it
should not be used except in libraries implementing threading.
.TP
.BR CLONE_SIGHAND " (since Linux 2.0)"
If
.B CLONE_SIGHAND
is set, the calling process and the child process share the same table of
signal handlers.
If the calling process or child process calls
.BR sigaction (2)
to change the behavior associated with a signal, the behavior is
changed in the other process as well.
However, the calling process and child
processes still have distinct signal masks and sets of pending
signals.
So, one of them may block or unblock signals using
.BR sigprocmask (2)
without affecting the other process.
.IP
If
.B CLONE_SIGHAND
is not set, the child process inherits a copy of the signal handlers
of the calling process at the time of the clone call.
Calls to
.BR sigaction (2)
performed later by one of the processes have no effect on the other
process.
.IP
Since Linux 2.6.0,
.\" Precisely: Linux 2.6.0-test6
the
.I flags
mask must also include
.B CLONE_VM
if
.B CLONE_SIGHAND
is specified.
.TP
.BR CLONE_STOPPED " (since Linux 2.6.0)"
.\" Precisely: Linux 2.6.0-test2
If
.B CLONE_STOPPED
is set, then the child is initially stopped (as though it was sent a
.B SIGSTOP
signal), and must be resumed by sending it a
.B SIGCONT
signal.
.IP
This flag was
.I deprecated
from Linux 2.6.25 onward,
and was
.I removed
altogether in Linux 2.6.38.
Since then, the kernel silently ignores it without error.
.\" glibc 2.8 removed this defn from bits/sched.h
Starting with Linux 4.6, the same bit was reused for the
.B CLONE_NEWCGROUP
flag.
.TP
.BR CLONE_SYSVSEM " (since Linux 2.5.10)"
If
.B CLONE_SYSVSEM
is set, then the child and the calling process share
a single list of System V semaphore adjustment
.RI ( semadj )
values (see
.BR semop (2)).
In this case, the shared list accumulates
.I semadj
values across all processes sharing the list,
and semaphore adjustments are performed only when the last process
that is sharing the list terminates (or ceases sharing the list using
.BR unshare (2)).
If this flag is not set, then the child has a separate
.I semadj
list that is initially empty.
.TP
.BR CLONE_THREAD " (since Linux 2.4.0)"
.\" Precisely: Linux 2.6.0-test8
If
.B CLONE_THREAD
is set, the child is placed in the same thread group as the calling process.
To make the remainder of the discussion of
.B CLONE_THREAD
more readable, the term "thread" is used to refer to the
processes within a thread group.
.IP
Thread groups were a feature added in Linux 2.4 to support the
POSIX threads notion of a set of threads that share a single PID.
Internally, this shared PID is the so-called
thread group identifier (TGID) for the thread group.
Since Linux 2.4, calls to
.BR getpid (2)
return the TGID of the caller.
.IP
The threads within a group can be distinguished by their (system-wide)
unique thread IDs (TID).
A new thread's TID is available as the function result
returned to the caller,
and a thread can obtain
its own TID using
.BR gettid (2).
.IP
When a clone call is made without specifying
.BR CLONE_THREAD ,
then the resulting thread is placed in a new thread group
whose TGID is the same as the thread's TID.
This thread is the
.I leader
of the new thread group.
.IP
A new thread created with
.B CLONE_THREAD
has the same parent process as the process that made the clone call
(i.e., like
.BR CLONE_PARENT ),
so that calls to
.BR getppid (2)
return the same value for all of the threads in a thread group.
When a
.B CLONE_THREAD
thread terminates, the thread that created it is not sent a
.B SIGCHLD
(or other termination) signal;
nor can the status of such a thread be obtained
using
.BR wait (2).
(The thread is said to be
.IR detached .)
.IP
After all of the threads in a thread group terminate
the parent process of the thread group is sent a
.B SIGCHLD
(or other termination) signal.
.IP
If any of the threads in a thread group performs an
.BR execve (2),
then all threads other than the thread group leader are terminated,
and the new program is executed in the thread group leader.
.IP
If one of the threads in a thread group creates a child using
.BR fork (2),
then any thread in the group can
.BR wait (2)
for that child.
.IP
Since Linux 2.5.35, the
.I flags
mask must also include
.B CLONE_SIGHAND
if
.B CLONE_THREAD
is specified
(and note that, since Linux 2.6.0,
.\" Precisely: Linux 2.6.0-test6
.B CLONE_SIGHAND
also requires
.B CLONE_VM
to be included).
.IP
Signal dispositions and actions are process-wide:
if an unhandled signal is delivered to a thread, then
it will affect (terminate, stop, continue, be ignored in)
all members of the thread group.
.IP
Each thread has its own signal mask, as set by
.BR sigprocmask (2).
.IP
A signal may be process-directed or thread-directed.
A process-directed signal is targeted at a thread group (i.e., a TGID),
and is delivered to an arbitrarily selected thread from among those
that are not blocking the signal.
A signal may be process-directed because it was generated by the kernel
for reasons other than a hardware exception, or because it was sent using
.BR kill (2)
or
.BR sigqueue (3).
A thread-directed signal is targeted at (i.e., delivered to)
a specific thread.
A signal may be thread directed because it was sent using
.BR tgkill (2)
or
.BR pthread_sigqueue (3),
or because the thread executed a machine language instruction that triggered
a hardware exception
(e.g., invalid memory access triggering
.B SIGSEGV
or a floating-point exception triggering
.BR SIGFPE ).
.IP
A call to
.BR sigpending (2)
returns a signal set that is the union of the pending process-directed
signals and the signals that are pending for the calling thread.
.IP
If a process-directed signal is delivered to a thread group,
and the thread group has installed a handler for the signal, then
the handler is invoked in exactly one, arbitrarily selected
member of the thread group that has not blocked the signal.
If multiple threads in a group are waiting to accept the same signal using
.BR sigwaitinfo (2),
the kernel will arbitrarily select one of these threads
to receive the signal.
.TP
.BR CLONE_UNTRACED " (since Linux 2.5.46)"
If
.B CLONE_UNTRACED
is specified, then a tracing process cannot force
.B CLONE_PTRACE
on this child process.
.TP
.BR CLONE_VFORK " (since Linux 2.2)"
If
.B CLONE_VFORK
is set, the execution of the calling process is suspended
until the child releases its virtual memory
resources via a call to
.BR execve (2)
or
.BR _exit (2)
(as with
.BR vfork (2)).
.IP
If
.B CLONE_VFORK
is not set, then both the calling process and the child are schedulable
after the call, and an application should not rely on execution occurring
in any particular order.
.TP
.BR CLONE_VM " (since Linux 2.0)"
If
.B CLONE_VM
is set, the calling process and the child process run in the same memory
space.
In particular, memory writes performed by the calling process
or by the child process are also visible in the other process.
Moreover, any memory mapping or unmapping performed with
.BR mmap (2)
or
.BR munmap (2)
by the child or calling process also affects the other process.
.IP
If
.B CLONE_VM
is not set, the child process runs in a separate copy of the memory
space of the calling process at the time of the clone call.
Memory writes or file mappings/unmappings performed by one of the
processes do not affect the other, as with
.BR fork (2).
.IP
If the
.B CLONE_VM
flag is specified and the
.B CLONE_VFORK
flag is not specified,
then any alternate signal stack that was established by
.BR sigaltstack (2)
is cleared in the child process.
.SH RETURN VALUE
.\" gettid(2) returns current->pid;
.\" getpid(2) returns current->tgid;
On success, the thread ID of the child process is returned
in the caller's thread of execution.
On failure, \-1 is returned
in the caller's context, no child process is created, and
.I errno
is set to indicate the error.
.SH ERRORS
.TP
.BR EACCES " (" clone3 "() only)"
.B CLONE_INTO_CGROUP
was specified in
.IR cl_args.flags ,
but the restrictions (described in
.BR cgroups (7))
on placing the child process into the version 2 cgroup referred to by
.I cl_args.cgroup
are not met.
.TP
.B EAGAIN
Too many processes are already running; see
.BR fork (2).
.TP
.BR EBUSY " (" clone3 "() only)"
.B CLONE_INTO_CGROUP
was specified in
.IR cl_args.flags ,
but the file descriptor specified in
.I cl_args.cgroup
refers to a version 2 cgroup in which a domain controller is enabled.
.TP
.BR EEXIST " (" clone3 "() only)"
One (or more) of the PIDs specified in
.I set_tid
already exists in the corresponding PID namespace.
.TP
.B EINVAL
Both
.B CLONE_SIGHAND
and
.B CLONE_CLEAR_SIGHAND
were specified in the
.I flags
mask.
.TP
.B EINVAL
.B CLONE_SIGHAND
was specified in the
.I flags
mask, but
.B CLONE_VM
was not.
(Since Linux 2.6.0.)
.\" Precisely: Linux 2.6.0-test6
.TP
.B EINVAL
.B CLONE_THREAD
was specified in the
.I flags
mask, but
.B CLONE_SIGHAND
was not.
(Since Linux 2.5.35.)
.\" .TP
.\" .B EINVAL
.\" Precisely one of
.\" .B CLONE_DETACHED
.\" and
.\" .B CLONE_THREAD
.\" was specified.
.\" (Since Linux 2.6.0-test6.)
.TP
.B EINVAL
.B CLONE_THREAD
was specified in the
.I flags
mask, but the current process previously called
.BR unshare (2)
with the
.B CLONE_NEWPID
flag or used
.BR setns (2)
to reassociate itself with a PID namespace.
.TP
.B EINVAL
.\" commit e66eded8309ebf679d3d3c1f5820d1f2ca332c71
Both
.B CLONE_FS
and
.B CLONE_NEWNS
were specified in the
.I flags
mask.
.TP
.BR EINVAL " (since Linux 3.9)"
Both
.B CLONE_NEWUSER
and
.B CLONE_FS
were specified in the
.I flags
mask.
.TP
.B EINVAL
Both
.B CLONE_NEWIPC
and
.B CLONE_SYSVSEM
were specified in the
.I flags
mask.
.TP
.B EINVAL
One (or both) of
.B CLONE_NEWPID
or
.B CLONE_NEWUSER
and one (or both) of
.B CLONE_THREAD
or
.B CLONE_PARENT
were specified in the
.I flags
mask.
.TP
.BR EINVAL " (since Linux 2.6.32)"
.\" commit 123be07b0b399670a7cc3d82fef0cb4f93ef885c
.B CLONE_PARENT
was specified, and the caller is an init process.
.TP
.B EINVAL
Returned by the glibc
.BR clone ()
wrapper function when
.I fn
or
.I stack
is specified as NULL.
.TP
.B EINVAL
.B CLONE_NEWIPC
was specified in the
.I flags
mask,
but the kernel was not configured with the
.B CONFIG_SYSVIPC
and
.B CONFIG_IPC_NS
options.
.TP
.B EINVAL
.B CLONE_NEWNET
was specified in the
.I flags
mask,
but the kernel was not configured with the
.B CONFIG_NET_NS
option.
.TP
.B EINVAL
.B CLONE_NEWPID
was specified in the
.I flags
mask,
but the kernel was not configured with the
.B CONFIG_PID_NS
option.
.TP
.B EINVAL
.B CLONE_NEWUSER
was specified in the
.I flags
mask,
but the kernel was not configured with the
.B CONFIG_USER_NS
option.
.TP
.B EINVAL
.B CLONE_NEWUTS
was specified in the
.I flags
mask,
but the kernel was not configured with the
.B CONFIG_UTS_NS
option.
.TP
.B EINVAL
.I stack
is not aligned to a suitable boundary for this architecture.
For example, on aarch64,
.I stack
must be a multiple of 16.
.TP
.BR EINVAL " (" clone3 "() only)"
.B  CLONE_DETACHED
was specified in the
.I flags
mask.
.TP
.BR EINVAL " (" clone "() only)"
.B CLONE_PIDFD
was specified together with
.B CLONE_DETACHED
in the
.I flags
mask.
.TP
.B EINVAL
.B CLONE_PIDFD
was specified together with
.B CLONE_THREAD
in the
.I flags
mask.
.TP
.BR "EINVAL " "("  clone "() only)"
.B CLONE_PIDFD
was specified together with
.B CLONE_PARENT_SETTID
in the
.I flags
mask.
.TP
.BR EINVAL " (" clone3 "() only)"
.I set_tid_size
is greater than the number of nested PID namespaces.
.TP
.BR EINVAL " (" clone3 "() only)"
One of the PIDs specified in
.I set_tid
was an invalid.
.TP
.BR EINVAL " (" clone3 "() only)"
.\" commit 7f192e3cd316ba58c88dfa26796cf77789dd9872
.B CLONE_THREAD
or
.B CLONE_PARENT
was specified in the
.I flags
mask, but a signal was specified in
.I exit_signal.
.TP
.BR EINVAL " (AArch64 only, Linux 4.6 and earlier)"
.I stack
was not aligned to a 128-bit boundary.
.TP
.B ENOMEM
Cannot allocate sufficient memory to allocate a task structure for the
child, or to copy those parts of the caller's context that need to be
copied.
.TP
.BR ENOSPC " (since Linux 3.7)"
.\" commit f2302505775fd13ba93f034206f1e2a587017929
.B CLONE_NEWPID
was specified in the
.I flags
mask,
but the limit on the nesting depth of PID namespaces
would have been exceeded; see
.BR pid_namespaces (7).
.TP
.BR ENOSPC " (since Linux 4.9; beforehand " EUSERS )
.B CLONE_NEWUSER
was specified in the
.I flags
mask, and the call would cause the limit on the number of
nested user namespaces to be exceeded.
See
.BR user_namespaces (7).
.IP
From Linux 3.11 to Linux 4.8, the error diagnosed in this case was
.BR EUSERS .
.TP
.BR ENOSPC " (since Linux 4.9)"
One of the values in the
.I flags
mask specified the creation of a new user namespace,
but doing so would have caused the limit defined by the corresponding file in
.I /proc/sys/user
to be exceeded.
For further details, see
.BR namespaces (7).
.TP
.BR EOPNOTSUPP " (" clone3 "() only)"
.B CLONE_INTO_CGROUP
was specified in
.IR cl_args.flags ,
but the file descriptor specified in
.I cl_args.cgroup
refers to a version 2 cgroup that is in the
.I domain invalid
state.
.TP
.B EPERM
.BR CLONE_NEWCGROUP ,
.BR CLONE_NEWIPC ,
.BR CLONE_NEWNET ,
.BR CLONE_NEWNS ,
.BR CLONE_NEWPID ,
or
.B CLONE_NEWUTS
was specified by an unprivileged process (process without \fBCAP_SYS_ADMIN\fP).
.TP
.B EPERM
.B CLONE_PID
was specified by a process other than process 0.
(This error occurs only on Linux 2.5.15 and earlier.)
.TP
.B EPERM
.B CLONE_NEWUSER
was specified in the
.I flags
mask,
but either the effective user ID or the effective group ID of the caller
does not have a mapping in the parent namespace (see
.BR user_namespaces (7)).
.TP
.BR EPERM " (since Linux 3.9)"
.\" commit 3151527ee007b73a0ebd296010f1c0454a919c7d
.B CLONE_NEWUSER
was specified in the
.I flags
mask and the caller is in a chroot environment
.\" FIXME What is the rationale for this restriction?
(i.e., the caller's root directory does not match the root directory
of the mount namespace in which it resides).
.TP
.BR EPERM " (" clone3 "() only)"
.I set_tid_size
was greater than zero, and the caller lacks the
.B CAP_SYS_ADMIN
capability in one or more of the user namespaces that own the
corresponding PID namespaces.
.TP
.BR ERESTARTNOINTR " (since Linux 2.6.17)"
.\" commit 4a2c7a7837da1b91468e50426066d988050e4d56
System call was interrupted by a signal and will be restarted.
(This can be seen only during a trace.)
.TP
.BR EUSERS " (Linux 3.11 to Linux 4.8)"
.B CLONE_NEWUSER
was specified in the
.I flags
mask,
and the limit on the number of nested user namespaces would be exceeded.
See the discussion of the
.B ENOSPC
error above.
.SH VERSIONS
The glibc
.BR clone ()
wrapper function makes some changes
in the memory pointed to by
.I stack
(changes required to set the stack up correctly for the child)
.I before
invoking the
.BR clone ()
system call.
So, in cases where
.BR clone ()
is used to recursively create children,
do not use the buffer employed for the parent's stack
as the stack of the child.
.PP
On i386,
.BR clone ()
should not be called through vsyscall, but directly through
.IR "int $0x80" .
.SS C library/kernel differences
The raw
.BR clone ()
system call corresponds more closely to
.BR fork (2)
in that execution in the child continues from the point of the
call.
As such, the
.I fn
and
.I arg
arguments of the
.BR clone ()
wrapper function are omitted.
.PP
In contrast to the glibc wrapper, the raw
.BR clone ()
system call accepts NULL as a
.I stack
argument (and
.BR clone3 ()
likewise allows
.I cl_args.stack
to be NULL).
In this case, the child uses a duplicate of the parent's stack.
(Copy-on-write semantics ensure that the child gets separate copies
of stack pages when either process modifies the stack.)
In this case, for correct operation, the
.B CLONE_VM
option should not be specified.
(If the child
.I shares
the parent's memory because of the use of the
.B CLONE_VM
flag,
then no copy-on-write duplication occurs and chaos is likely to result.)
.PP
The order of the arguments also differs in the raw system call,
and there are variations in the arguments across architectures,
as detailed in the following paragraphs.
.PP
The raw system call interface on x86-64 and some other architectures
(including sh, tile, and alpha) is:
.PP
.in +4n
.EX
.BI "long clone(unsigned long " flags ", void *" stack ,
.BI "           int *" parent_tid ", int *" child_tid ,
.BI "           unsigned long " tls );
.EE
.in
.PP
On x86-32, and several other common architectures
(including score, ARM, ARM 64, PA-RISC, arc, Power PC, xtensa,
and MIPS),
.\" CONFIG_CLONE_BACKWARDS
the order of the last two arguments is reversed:
.PP
.in +4n
.EX
.BI "long clone(unsigned long " flags ", void *" stack ,
.BI "          int *" parent_tid ", unsigned long " tls ,
.BI "          int *" child_tid );
.EE
.in
.PP
On the cris and s390 architectures,
.\" CONFIG_CLONE_BACKWARDS2
the order of the first two arguments is reversed:
.PP
.in +4n
.EX
.BI "long clone(void *" stack ", unsigned long " flags ,
.BI "           int *" parent_tid ", int *" child_tid ,
.BI "           unsigned long " tls );
.EE
.in
.PP
On the microblaze architecture,
.\" CONFIG_CLONE_BACKWARDS3
an additional argument is supplied:
.PP
.in +4n
.EX
.BI "long clone(unsigned long " flags ", void *" stack ,
.BI "           int " stack_size , "\fR         /* Size of stack */"
.BI "           int *" parent_tid ", int *" child_tid ,
.BI "           unsigned long " tls );
.EE
.in
.\"
.SS blackfin, m68k, and sparc
.\" Mike Frysinger noted in a 2013 mail:
.\"     these arches don't define __ARCH_WANT_SYS_CLONE:
.\"     blackfin ia64 m68k sparc
The argument-passing conventions on
blackfin, m68k, and sparc are different from the descriptions above.
For details, see the kernel (and glibc) source.
.SS ia64
On ia64, a different interface is used:
.PP
.in +4n
.EX
.BI "int __clone2(int (*" "fn" ")(void *),"
.BI "             void *" stack_base ", size_t " stack_size ,
.BI "             int " flags ", void *" "arg" ", ..."
.BI "          /* pid_t *" parent_tid ", struct user_desc *" tls ,
.BI "             pid_t *" child_tid " */ );"
.EE
.in
.PP
The prototype shown above is for the glibc wrapper function;
for the system call itself,
the prototype can be described as follows (it is identical to the
.BR clone ()
prototype on microblaze):
.PP
.in +4n
.EX
.BI "long clone2(unsigned long " flags ", void *" stack_base ,
.BI "            int " stack_size , "\fR         /* Size of stack */"
.BI "            int *" parent_tid ", int *" child_tid ,
.BI "            unsigned long " tls );
.EE
.in
.PP
.BR __clone2 ()
operates in the same way as
.BR clone (),
except that
.I stack_base
points to the lowest address of the child's stack area,
and
.I stack_size
specifies the size of the stack pointed to by
.IR stack_base .
.SH STANDARDS
Linux.
.SH HISTORY
.TP
.BR clone3 ()
Linux 5.3.
.\" There is no entry for
.\" .BR clone ()
.\" in libc5.
.\" glibc2 provides
.\" .BR clone ()
.\" as described in this manual page.
.SS Linux 2.4 and earlier
In the Linux 2.4.x series,
.B CLONE_THREAD
generally does not make the parent of the new thread the same
as the parent of the calling process.
However, from Linux 2.4.7 to Linux 2.4.18 the
.B CLONE_THREAD
flag implied the
.B CLONE_PARENT
flag (as in Linux 2.6.0 and later).
.PP
In Linux 2.4 and earlier,
.BR clone ()
does not take arguments
.IR parent_tid ,
.IR tls ,
and
.IR child_tid .
.SH NOTES
One use of these systems calls
is to implement threads: multiple flows of control in a program that
run concurrently in a shared address space.
.PP
The
.BR kcmp (2)
system call can be used to test whether two processes share various
resources such as a file descriptor table,
System V semaphore undo operations, or a virtual address space.
.PP
Handlers registered using
.BR pthread_atfork (3)
are not executed during a clone call.
.SH BUGS
GNU C library versions 2.3.4 up to and including 2.24
contained a wrapper function for
.BR getpid (2)
that performed caching of PIDs.
This caching relied on support in the glibc wrapper for
.BR clone (),
but limitations in the implementation
meant that the cache was not up to date in some circumstances.
In particular,
if a signal was delivered to the child immediately after the
.BR clone ()
call, then a call to
.BR getpid (2)
in a handler for the signal could return the PID
of the calling process ("the parent"),
if the clone wrapper had not yet had a chance to update the PID
cache in the child.
(This discussion ignores the case where the child was created using
.BR CLONE_THREAD ,
when
.BR getpid (2)
.I should
return the same value in the child and in the process that called
.BR clone (),
since the caller and the child are in the same thread group.
The stale-cache problem also does not occur if the
.I flags
argument includes
.BR CLONE_VM .)
To get the truth, it was sometimes necessary to use code such as the following:
.PP
.in +4n
.EX
#include <syscall.h>
\&
pid_t mypid;
\&
mypid = syscall(SYS_getpid);
.EE
.in
.\" See also the following bug reports
.\" https://bugzilla.redhat.com/show_bug.cgi?id=417521
.\" http://sourceware.org/bugzilla/show_bug.cgi?id=6910
.PP
Because of the stale-cache problem, as well as other problems noted in
.BR getpid (2),
the PID caching feature was removed in glibc 2.25.
.SH EXAMPLES
The following program demonstrates the use of
.BR clone ()
to create a child process that executes in a separate UTS namespace.
The child changes the hostname in its UTS namespace.
Both parent and child then display the system hostname,
making it possible to see that the hostname
differs in the UTS namespaces of the parent and child.
For an example of the use of this program, see
.BR setns (2).
.PP
Within the sample program, we allocate the memory that is to
be used for the child's stack using
.BR mmap (2)
rather than
.BR malloc (3)
for the following reasons:
.IP \[bu] 3
.BR mmap (2)
allocates a block of memory that starts on a page
boundary and is a multiple of the page size.
This is useful if we want to establish a guard page (a page with protection
.BR PROT_NONE )
at the end of the stack using
.BR mprotect (2).
.IP \[bu]
We can specify the
.B MAP_STACK
flag to request a mapping that is suitable for a stack.
For the moment, this flag is a no-op on Linux,
but it exists and has effect on some other systems,
so we should include it for portability.
.SS Program source
.\" SRC BEGIN (clone.c)
.EX
#define _GNU_SOURCE
#include <err.h>
#include <sched.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/utsname.h>
#include <sys/wait.h>
#include <unistd.h>
\&
static int              /* Start function for cloned child */
childFunc(void *arg)
{
    struct utsname uts;
\&
    /* Change hostname in UTS namespace of child. */
\&
    if (sethostname(arg, strlen(arg)) == \-1)
        err(EXIT_FAILURE, "sethostname");
\&
    /* Retrieve and display hostname. */
\&
    if (uname(&uts) == \-1)
        err(EXIT_FAILURE, "uname");
    printf("uts.nodename in child:  %s\en", uts.nodename);
\&
    /* Keep the namespace open for a while, by sleeping.
       This allows some experimentation\-\-for example, another
       process might join the namespace. */
\&
    sleep(200);
\&
    return 0;           /* Child terminates now */
}
\&
#define STACK_SIZE (1024 * 1024)    /* Stack size for cloned child */
\&
int
main(int argc, char *argv[])
{
    char            *stack;         /* Start of stack buffer */
    char            *stackTop;      /* End of stack buffer */
    pid_t           pid;
    struct utsname  uts;
\&
    if (argc < 2) {
        fprintf(stderr, "Usage: %s <child\-hostname>\en", argv[0]);
        exit(EXIT_SUCCESS);
    }
\&
    /* Allocate memory to be used for the stack of the child. */
\&
    stack = mmap(NULL, STACK_SIZE, PROT_READ | PROT_WRITE,
                 MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, \-1, 0);
    if (stack == MAP_FAILED)
        err(EXIT_FAILURE, "mmap");
\&
    stackTop = stack + STACK_SIZE;  /* Assume stack grows downward */
\&
    /* Create child that has its own UTS namespace;
       child commences execution in childFunc(). */
\&
    pid = clone(childFunc, stackTop, CLONE_NEWUTS | SIGCHLD, argv[1]);
    if (pid == \-1)
        err(EXIT_FAILURE, "clone");
    printf("clone() returned %jd\en", (intmax_t) pid);
\&
    /* Parent falls through to here */
\&
    sleep(1);           /* Give child time to change its hostname */
\&
    /* Display hostname in parent\[aq]s UTS namespace. This will be
       different from hostname in child\[aq]s UTS namespace. */
\&
    if (uname(&uts) == \-1)
        err(EXIT_FAILURE, "uname");
    printf("uts.nodename in parent: %s\en", uts.nodename);
\&
    if (waitpid(pid, NULL, 0) == \-1)    /* Wait for child */
        err(EXIT_FAILURE, "waitpid");
    printf("child has terminated\en");
\&
    exit(EXIT_SUCCESS);
}
.EE
.\" SRC END
.SH SEE ALSO
.BR fork (2),
.BR futex (2),
.BR getpid (2),
.BR gettid (2),
.BR kcmp (2),
.BR mmap (2),
.BR pidfd_open (2),
.BR set_thread_area (2),
.BR set_tid_address (2),
.BR setns (2),
.BR tkill (2),
.BR unshare (2),
.BR wait (2),
.BR capabilities (7),
.BR namespaces (7),
.BR pthreads (7)