]> Git Repo - J-linux.git/blob - tools/testing/selftests/clone3/clone3.c
Merge tag 'vfs-6.13-rc7.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
[J-linux.git] / tools / testing / selftests / clone3 / clone3.c
1 // SPDX-License-Identifier: GPL-2.0
2
3 /* Based on Christian Brauner's clone3() example */
4
5 #define _GNU_SOURCE
6 #include <errno.h>
7 #include <inttypes.h>
8 #include <linux/types.h>
9 #include <linux/sched.h>
10 #include <stdbool.h>
11 #include <stdint.h>
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <sys/syscall.h>
15 #include <sys/types.h>
16 #include <sys/un.h>
17 #include <sys/wait.h>
18 #include <unistd.h>
19 #include <sched.h>
20
21 #include "../kselftest.h"
22 #include "clone3_selftests.h"
23
24 enum test_mode {
25         CLONE3_ARGS_NO_TEST,
26         CLONE3_ARGS_ALL_0,
27         CLONE3_ARGS_INVAL_EXIT_SIGNAL_BIG,
28         CLONE3_ARGS_INVAL_EXIT_SIGNAL_NEG,
29         CLONE3_ARGS_INVAL_EXIT_SIGNAL_CSIG,
30         CLONE3_ARGS_INVAL_EXIT_SIGNAL_NSIG,
31 };
32
33 static int call_clone3(uint64_t flags, size_t size, enum test_mode test_mode)
34 {
35         struct __clone_args args = {
36                 .flags = flags,
37                 .exit_signal = SIGCHLD,
38         };
39
40         struct clone_args_extended {
41                 struct __clone_args args;
42                 __aligned_u64 excess_space[2];
43         } args_ext;
44
45         pid_t pid = -1;
46         int status;
47
48         memset(&args_ext, 0, sizeof(args_ext));
49         if (size > sizeof(struct __clone_args))
50                 args_ext.excess_space[1] = 1;
51
52         if (size == 0)
53                 size = sizeof(struct __clone_args);
54
55         switch (test_mode) {
56         case CLONE3_ARGS_NO_TEST:
57                 /*
58                  * Uses default 'flags' and 'SIGCHLD'
59                  * assignment.
60                  */
61                 break;
62         case CLONE3_ARGS_ALL_0:
63                 args.flags = 0;
64                 args.exit_signal = 0;
65                 break;
66         case CLONE3_ARGS_INVAL_EXIT_SIGNAL_BIG:
67                 args.exit_signal = 0xbadc0ded00000000ULL;
68                 break;
69         case CLONE3_ARGS_INVAL_EXIT_SIGNAL_NEG:
70                 args.exit_signal = 0x0000000080000000ULL;
71                 break;
72         case CLONE3_ARGS_INVAL_EXIT_SIGNAL_CSIG:
73                 args.exit_signal = 0x0000000000000100ULL;
74                 break;
75         case CLONE3_ARGS_INVAL_EXIT_SIGNAL_NSIG:
76                 args.exit_signal = 0x00000000000000f0ULL;
77                 break;
78         }
79
80         memcpy(&args_ext.args, &args, sizeof(struct __clone_args));
81
82         pid = sys_clone3((struct __clone_args *)&args_ext, size);
83         if (pid < 0) {
84                 ksft_print_msg("%s - Failed to create new process\n",
85                                 strerror(errno));
86                 return -errno;
87         }
88
89         if (pid == 0) {
90                 ksft_print_msg("I am the child, my PID is %d\n", getpid());
91                 _exit(EXIT_SUCCESS);
92         }
93
94         ksft_print_msg("I am the parent (%d). My child's pid is %d\n",
95                         getpid(), pid);
96
97         if (waitpid(-1, &status, __WALL) < 0) {
98                 ksft_print_msg("waitpid() returned %s\n", strerror(errno));
99                 return -errno;
100         }
101         if (!WIFEXITED(status)) {
102                 ksft_print_msg("Child did not exit normally, status 0x%x\n",
103                                status);
104                 return EXIT_FAILURE;
105         }
106         if (WEXITSTATUS(status))
107                 return WEXITSTATUS(status);
108
109         return 0;
110 }
111
112 static bool test_clone3(uint64_t flags, size_t size, int expected,
113                         enum test_mode test_mode)
114 {
115         int ret;
116
117         ksft_print_msg(
118                 "[%d] Trying clone3() with flags %#" PRIx64 " (size %zu)\n",
119                 getpid(), flags, size);
120         ret = call_clone3(flags, size, test_mode);
121         ksft_print_msg("[%d] clone3() with flags says: %d expected %d\n",
122                         getpid(), ret, expected);
123         if (ret != expected) {
124                 ksft_print_msg(
125                         "[%d] Result (%d) is different than expected (%d)\n",
126                         getpid(), ret, expected);
127                 return false;
128         }
129
130         return true;
131 }
132
133 typedef bool (*filter_function)(void);
134 typedef size_t (*size_function)(void);
135
136 static bool not_root(void)
137 {
138         if (getuid() != 0) {
139                 ksft_print_msg("Not running as root\n");
140                 return true;
141         }
142
143         return false;
144 }
145
146 static bool no_timenamespace(void)
147 {
148         if (not_root())
149                 return true;
150
151         if (!access("/proc/self/ns/time", F_OK))
152                 return false;
153
154         ksft_print_msg("Time namespaces are not supported\n");
155         return true;
156 }
157
158 static size_t page_size_plus_8(void)
159 {
160         return getpagesize() + 8;
161 }
162
163 struct test {
164         const char *name;
165         uint64_t flags;
166         size_t size;
167         size_function size_function;
168         int expected;
169         enum test_mode test_mode;
170         filter_function filter;
171 };
172
173 static const struct test tests[] = {
174         {
175                 .name = "simple clone3()",
176                 .flags = 0,
177                 .size = 0,
178                 .expected = 0,
179                 .test_mode = CLONE3_ARGS_NO_TEST,
180         },
181         {
182                 .name = "clone3() in a new PID_NS",
183                 .flags = CLONE_NEWPID,
184                 .size = 0,
185                 .expected = 0,
186                 .test_mode = CLONE3_ARGS_NO_TEST,
187                 .filter = not_root,
188         },
189         {
190                 .name = "CLONE_ARGS_SIZE_VER0",
191                 .flags = 0,
192                 .size = CLONE_ARGS_SIZE_VER0,
193                 .expected = 0,
194                 .test_mode = CLONE3_ARGS_NO_TEST,
195         },
196         {
197                 .name = "CLONE_ARGS_SIZE_VER0 - 8",
198                 .flags = 0,
199                 .size = CLONE_ARGS_SIZE_VER0 - 8,
200                 .expected = -EINVAL,
201                 .test_mode = CLONE3_ARGS_NO_TEST,
202         },
203         {
204                 .name = "sizeof(struct clone_args) + 8",
205                 .flags = 0,
206                 .size = sizeof(struct __clone_args) + 8,
207                 .expected = 0,
208                 .test_mode = CLONE3_ARGS_NO_TEST,
209         },
210         {
211                 .name = "exit_signal with highest 32 bits non-zero",
212                 .flags = 0,
213                 .size = 0,
214                 .expected = -EINVAL,
215                 .test_mode = CLONE3_ARGS_INVAL_EXIT_SIGNAL_BIG,
216         },
217         {
218                 .name = "negative 32-bit exit_signal",
219                 .flags = 0,
220                 .size = 0,
221                 .expected = -EINVAL,
222                 .test_mode = CLONE3_ARGS_INVAL_EXIT_SIGNAL_NEG,
223         },
224         {
225                 .name = "exit_signal not fitting into CSIGNAL mask",
226                 .flags = 0,
227                 .size = 0,
228                 .expected = -EINVAL,
229                 .test_mode = CLONE3_ARGS_INVAL_EXIT_SIGNAL_CSIG,
230         },
231         {
232                 .name = "NSIG < exit_signal < CSIG",
233                 .flags = 0,
234                 .size = 0,
235                 .expected = -EINVAL,
236                 .test_mode = CLONE3_ARGS_INVAL_EXIT_SIGNAL_NSIG,
237         },
238         {
239                 .name = "Arguments sizeof(struct clone_args) + 8",
240                 .flags = 0,
241                 .size = sizeof(struct __clone_args) + 8,
242                 .expected = 0,
243                 .test_mode = CLONE3_ARGS_ALL_0,
244         },
245         {
246                 .name = "Arguments sizeof(struct clone_args) + 16",
247                 .flags = 0,
248                 .size = sizeof(struct __clone_args) + 16,
249                 .expected = -E2BIG,
250                 .test_mode = CLONE3_ARGS_ALL_0,
251         },
252         {
253                 .name = "Arguments sizeof(struct clone_arg) * 2",
254                 .flags = 0,
255                 .size = sizeof(struct __clone_args) + 16,
256                 .expected = -E2BIG,
257                 .test_mode = CLONE3_ARGS_ALL_0,
258         },
259         {
260                 .name = "Arguments > page size",
261                 .flags = 0,
262                 .size_function = page_size_plus_8,
263                 .expected = -E2BIG,
264                 .test_mode = CLONE3_ARGS_NO_TEST,
265         },
266         {
267                 .name = "CLONE_ARGS_SIZE_VER0 in a new PID NS",
268                 .flags = CLONE_NEWPID,
269                 .size = CLONE_ARGS_SIZE_VER0,
270                 .expected = 0,
271                 .test_mode = CLONE3_ARGS_NO_TEST,
272                 .filter = not_root,
273         },
274         {
275                 .name = "CLONE_ARGS_SIZE_VER0 - 8 in a new PID NS",
276                 .flags = CLONE_NEWPID,
277                 .size = CLONE_ARGS_SIZE_VER0 - 8,
278                 .expected = -EINVAL,
279                 .test_mode = CLONE3_ARGS_NO_TEST,
280         },
281         {
282                 .name = "sizeof(struct clone_args) + 8 in a new PID NS",
283                 .flags = CLONE_NEWPID,
284                 .size = sizeof(struct __clone_args) + 8,
285                 .expected = 0,
286                 .test_mode = CLONE3_ARGS_NO_TEST,
287                 .filter = not_root,
288         },
289         {
290                 .name = "Arguments > page size in a new PID NS",
291                 .flags = CLONE_NEWPID,
292                 .size_function = page_size_plus_8,
293                 .expected = -E2BIG,
294                 .test_mode = CLONE3_ARGS_NO_TEST,
295         },
296         {
297                 .name = "New time NS",
298                 .flags = CLONE_NEWTIME,
299                 .size = 0,
300                 .expected = 0,
301                 .test_mode = CLONE3_ARGS_NO_TEST,
302                 .filter = no_timenamespace,
303         },
304         {
305                 .name = "exit signal (SIGCHLD) in flags",
306                 .flags = SIGCHLD,
307                 .size = 0,
308                 .expected = -EINVAL,
309                 .test_mode = CLONE3_ARGS_NO_TEST,
310         },
311 };
312
313 int main(int argc, char *argv[])
314 {
315         size_t size;
316         int i;
317
318         ksft_print_header();
319         ksft_set_plan(ARRAY_SIZE(tests));
320         test_clone3_supported();
321
322         for (i = 0; i < ARRAY_SIZE(tests); i++) {
323                 if (tests[i].filter && tests[i].filter()) {
324                         ksft_test_result_skip("%s\n", tests[i].name);
325                         continue;
326                 }
327
328                 if (tests[i].size_function)
329                         size = tests[i].size_function();
330                 else
331                         size = tests[i].size;
332
333                 ksft_print_msg("Running test '%s'\n", tests[i].name);
334
335                 ksft_test_result(test_clone3(tests[i].flags, size,
336                                              tests[i].expected,
337                                              tests[i].test_mode),
338                                  "%s\n", tests[i].name);
339         }
340
341         ksft_finished();
342 }
This page took 0.046358 seconds and 4 git commands to generate.