xref: /linux/tools/testing/selftests/mount_setattr/mount_setattr_test.c (revision a4eb44a6435d6d8f9e642407a4a06f65eb90ca04)
1 // SPDX-License-Identifier: GPL-2.0
2 #define _GNU_SOURCE
3 #include <sched.h>
4 #include <stdio.h>
5 #include <errno.h>
6 #include <pthread.h>
7 #include <string.h>
8 #include <sys/stat.h>
9 #include <sys/types.h>
10 #include <sys/mount.h>
11 #include <sys/wait.h>
12 #include <sys/vfs.h>
13 #include <sys/statvfs.h>
14 #include <sys/sysinfo.h>
15 #include <stdlib.h>
16 #include <unistd.h>
17 #include <fcntl.h>
18 #include <grp.h>
19 #include <stdbool.h>
20 #include <stdarg.h>
21 
22 #include "../kselftest_harness.h"
23 
24 #ifndef CLONE_NEWNS
25 #define CLONE_NEWNS 0x00020000
26 #endif
27 
28 #ifndef CLONE_NEWUSER
29 #define CLONE_NEWUSER 0x10000000
30 #endif
31 
32 #ifndef MS_REC
33 #define MS_REC 16384
34 #endif
35 
36 #ifndef MS_RELATIME
37 #define MS_RELATIME (1 << 21)
38 #endif
39 
40 #ifndef MS_STRICTATIME
41 #define MS_STRICTATIME (1 << 24)
42 #endif
43 
44 #ifndef MOUNT_ATTR_RDONLY
45 #define MOUNT_ATTR_RDONLY 0x00000001
46 #endif
47 
48 #ifndef MOUNT_ATTR_NOSUID
49 #define MOUNT_ATTR_NOSUID 0x00000002
50 #endif
51 
52 #ifndef MOUNT_ATTR_NOEXEC
53 #define MOUNT_ATTR_NOEXEC 0x00000008
54 #endif
55 
56 #ifndef MOUNT_ATTR_NODIRATIME
57 #define MOUNT_ATTR_NODIRATIME 0x00000080
58 #endif
59 
60 #ifndef MOUNT_ATTR__ATIME
61 #define MOUNT_ATTR__ATIME 0x00000070
62 #endif
63 
64 #ifndef MOUNT_ATTR_RELATIME
65 #define MOUNT_ATTR_RELATIME 0x00000000
66 #endif
67 
68 #ifndef MOUNT_ATTR_NOATIME
69 #define MOUNT_ATTR_NOATIME 0x00000010
70 #endif
71 
72 #ifndef MOUNT_ATTR_STRICTATIME
73 #define MOUNT_ATTR_STRICTATIME 0x00000020
74 #endif
75 
76 #ifndef AT_RECURSIVE
77 #define AT_RECURSIVE 0x8000
78 #endif
79 
80 #ifndef MS_SHARED
81 #define MS_SHARED (1 << 20)
82 #endif
83 
84 #define DEFAULT_THREADS 4
85 #define ptr_to_int(p) ((int)((intptr_t)(p)))
86 #define int_to_ptr(u) ((void *)((intptr_t)(u)))
87 
88 #ifndef __NR_mount_setattr
89 	#if defined __alpha__
90 		#define __NR_mount_setattr 552
91 	#elif defined _MIPS_SIM
92 		#if _MIPS_SIM == _MIPS_SIM_ABI32	/* o32 */
93 			#define __NR_mount_setattr (442 + 4000)
94 		#endif
95 		#if _MIPS_SIM == _MIPS_SIM_NABI32	/* n32 */
96 			#define __NR_mount_setattr (442 + 6000)
97 		#endif
98 		#if _MIPS_SIM == _MIPS_SIM_ABI64	/* n64 */
99 			#define __NR_mount_setattr (442 + 5000)
100 		#endif
101 	#elif defined __ia64__
102 		#define __NR_mount_setattr (442 + 1024)
103 	#else
104 		#define __NR_mount_setattr 442
105 	#endif
106 
107 struct mount_attr {
108 	__u64 attr_set;
109 	__u64 attr_clr;
110 	__u64 propagation;
111 	__u64 userns_fd;
112 };
113 #endif
114 
115 #ifndef __NR_open_tree
116 	#if defined __alpha__
117 		#define __NR_open_tree 538
118 	#elif defined _MIPS_SIM
119 		#if _MIPS_SIM == _MIPS_SIM_ABI32	/* o32 */
120 			#define __NR_open_tree 4428
121 		#endif
122 		#if _MIPS_SIM == _MIPS_SIM_NABI32	/* n32 */
123 			#define __NR_open_tree 6428
124 		#endif
125 		#if _MIPS_SIM == _MIPS_SIM_ABI64	/* n64 */
126 			#define __NR_open_tree 5428
127 		#endif
128 	#elif defined __ia64__
129 		#define __NR_open_tree (428 + 1024)
130 	#else
131 		#define __NR_open_tree 428
132 	#endif
133 #endif
134 
135 #ifndef MOUNT_ATTR_IDMAP
136 #define MOUNT_ATTR_IDMAP 0x00100000
137 #endif
138 
139 #ifndef MOUNT_ATTR_NOSYMFOLLOW
140 #define MOUNT_ATTR_NOSYMFOLLOW 0x00200000
141 #endif
142 
143 static inline int sys_mount_setattr(int dfd, const char *path, unsigned int flags,
144 				    struct mount_attr *attr, size_t size)
145 {
146 	return syscall(__NR_mount_setattr, dfd, path, flags, attr, size);
147 }
148 
149 #ifndef OPEN_TREE_CLONE
150 #define OPEN_TREE_CLONE 1
151 #endif
152 
153 #ifndef OPEN_TREE_CLOEXEC
154 #define OPEN_TREE_CLOEXEC O_CLOEXEC
155 #endif
156 
157 #ifndef AT_RECURSIVE
158 #define AT_RECURSIVE 0x8000 /* Apply to the entire subtree */
159 #endif
160 
161 static inline int sys_open_tree(int dfd, const char *filename, unsigned int flags)
162 {
163 	return syscall(__NR_open_tree, dfd, filename, flags);
164 }
165 
166 static ssize_t write_nointr(int fd, const void *buf, size_t count)
167 {
168 	ssize_t ret;
169 
170 	do {
171 		ret = write(fd, buf, count);
172 	} while (ret < 0 && errno == EINTR);
173 
174 	return ret;
175 }
176 
177 static int write_file(const char *path, const void *buf, size_t count)
178 {
179 	int fd;
180 	ssize_t ret;
181 
182 	fd = open(path, O_WRONLY | O_CLOEXEC | O_NOCTTY | O_NOFOLLOW);
183 	if (fd < 0)
184 		return -1;
185 
186 	ret = write_nointr(fd, buf, count);
187 	close(fd);
188 	if (ret < 0 || (size_t)ret != count)
189 		return -1;
190 
191 	return 0;
192 }
193 
194 static int create_and_enter_userns(void)
195 {
196 	uid_t uid;
197 	gid_t gid;
198 	char map[100];
199 
200 	uid = getuid();
201 	gid = getgid();
202 
203 	if (unshare(CLONE_NEWUSER))
204 		return -1;
205 
206 	if (write_file("/proc/self/setgroups", "deny", sizeof("deny") - 1) &&
207 	    errno != ENOENT)
208 		return -1;
209 
210 	snprintf(map, sizeof(map), "0 %d 1", uid);
211 	if (write_file("/proc/self/uid_map", map, strlen(map)))
212 		return -1;
213 
214 
215 	snprintf(map, sizeof(map), "0 %d 1", gid);
216 	if (write_file("/proc/self/gid_map", map, strlen(map)))
217 		return -1;
218 
219 	if (setgid(0))
220 		return -1;
221 
222 	if (setuid(0))
223 		return -1;
224 
225 	return 0;
226 }
227 
228 static int prepare_unpriv_mountns(void)
229 {
230 	if (create_and_enter_userns())
231 		return -1;
232 
233 	if (unshare(CLONE_NEWNS))
234 		return -1;
235 
236 	if (mount(NULL, "/", NULL, MS_REC | MS_PRIVATE, 0))
237 		return -1;
238 
239 	return 0;
240 }
241 
242 #ifndef ST_NOSYMFOLLOW
243 #define ST_NOSYMFOLLOW 0x2000 /* do not follow symlinks */
244 #endif
245 
246 static int read_mnt_flags(const char *path)
247 {
248 	int ret;
249 	struct statvfs stat;
250 	unsigned int mnt_flags;
251 
252 	ret = statvfs(path, &stat);
253 	if (ret != 0)
254 		return -EINVAL;
255 
256 	if (stat.f_flag & ~(ST_RDONLY | ST_NOSUID | ST_NODEV | ST_NOEXEC |
257 			    ST_NOATIME | ST_NODIRATIME | ST_RELATIME |
258 			    ST_SYNCHRONOUS | ST_MANDLOCK | ST_NOSYMFOLLOW))
259 		return -EINVAL;
260 
261 	mnt_flags = 0;
262 	if (stat.f_flag & ST_RDONLY)
263 		mnt_flags |= MS_RDONLY;
264 	if (stat.f_flag & ST_NOSUID)
265 		mnt_flags |= MS_NOSUID;
266 	if (stat.f_flag & ST_NODEV)
267 		mnt_flags |= MS_NODEV;
268 	if (stat.f_flag & ST_NOEXEC)
269 		mnt_flags |= MS_NOEXEC;
270 	if (stat.f_flag & ST_NOATIME)
271 		mnt_flags |= MS_NOATIME;
272 	if (stat.f_flag & ST_NODIRATIME)
273 		mnt_flags |= MS_NODIRATIME;
274 	if (stat.f_flag & ST_RELATIME)
275 		mnt_flags |= MS_RELATIME;
276 	if (stat.f_flag & ST_SYNCHRONOUS)
277 		mnt_flags |= MS_SYNCHRONOUS;
278 	if (stat.f_flag & ST_MANDLOCK)
279 		mnt_flags |= ST_MANDLOCK;
280 	if (stat.f_flag & ST_NOSYMFOLLOW)
281 		mnt_flags |= ST_NOSYMFOLLOW;
282 
283 	return mnt_flags;
284 }
285 
286 static char *get_field(char *src, int nfields)
287 {
288 	int i;
289 	char *p = src;
290 
291 	for (i = 0; i < nfields; i++) {
292 		while (*p && *p != ' ' && *p != '\t')
293 			p++;
294 
295 		if (!*p)
296 			break;
297 
298 		p++;
299 	}
300 
301 	return p;
302 }
303 
304 static void null_endofword(char *word)
305 {
306 	while (*word && *word != ' ' && *word != '\t')
307 		word++;
308 	*word = '\0';
309 }
310 
311 static bool is_shared_mount(const char *path)
312 {
313 	size_t len = 0;
314 	char *line = NULL;
315 	FILE *f = NULL;
316 
317 	f = fopen("/proc/self/mountinfo", "re");
318 	if (!f)
319 		return false;
320 
321 	while (getline(&line, &len, f) != -1) {
322 		char *opts, *target;
323 
324 		target = get_field(line, 4);
325 		if (!target)
326 			continue;
327 
328 		opts = get_field(target, 2);
329 		if (!opts)
330 			continue;
331 
332 		null_endofword(target);
333 
334 		if (strcmp(target, path) != 0)
335 			continue;
336 
337 		null_endofword(opts);
338 		if (strstr(opts, "shared:"))
339 			return true;
340 	}
341 
342 	free(line);
343 	fclose(f);
344 
345 	return false;
346 }
347 
348 static void *mount_setattr_thread(void *data)
349 {
350 	struct mount_attr attr = {
351 		.attr_set	= MOUNT_ATTR_RDONLY | MOUNT_ATTR_NOSUID,
352 		.attr_clr	= 0,
353 		.propagation	= MS_SHARED,
354 	};
355 
356 	if (sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)))
357 		pthread_exit(int_to_ptr(-1));
358 
359 	pthread_exit(int_to_ptr(0));
360 }
361 
362 /* Attempt to de-conflict with the selftests tree. */
363 #ifndef SKIP
364 #define SKIP(s, ...)	XFAIL(s, ##__VA_ARGS__)
365 #endif
366 
367 static bool mount_setattr_supported(void)
368 {
369 	int ret;
370 
371 	ret = sys_mount_setattr(-EBADF, "", AT_EMPTY_PATH, NULL, 0);
372 	if (ret < 0 && errno == ENOSYS)
373 		return false;
374 
375 	return true;
376 }
377 
378 FIXTURE(mount_setattr) {
379 };
380 
381 #define NOSYMFOLLOW_TARGET "/mnt/A/AA/data"
382 #define NOSYMFOLLOW_SYMLINK "/mnt/A/AA/symlink"
383 
384 FIXTURE_SETUP(mount_setattr)
385 {
386 	int fd = -EBADF;
387 
388 	if (!mount_setattr_supported())
389 		SKIP(return, "mount_setattr syscall not supported");
390 
391 	ASSERT_EQ(prepare_unpriv_mountns(), 0);
392 
393 	(void)umount2("/mnt", MNT_DETACH);
394 	(void)umount2("/tmp", MNT_DETACH);
395 
396 	ASSERT_EQ(mount("testing", "/tmp", "tmpfs", MS_NOATIME | MS_NODEV,
397 			"size=100000,mode=700"), 0);
398 
399 	ASSERT_EQ(mkdir("/tmp/B", 0777), 0);
400 
401 	ASSERT_EQ(mount("testing", "/tmp/B", "tmpfs", MS_NOATIME | MS_NODEV,
402 			"size=100000,mode=700"), 0);
403 
404 	ASSERT_EQ(mkdir("/tmp/B/BB", 0777), 0);
405 
406 	ASSERT_EQ(mount("testing", "/tmp/B/BB", "tmpfs", MS_NOATIME | MS_NODEV,
407 			"size=100000,mode=700"), 0);
408 
409 	ASSERT_EQ(mount("testing", "/mnt", "tmpfs", MS_NOATIME | MS_NODEV,
410 			"size=100000,mode=700"), 0);
411 
412 	ASSERT_EQ(mkdir("/mnt/A", 0777), 0);
413 
414 	ASSERT_EQ(mount("testing", "/mnt/A", "tmpfs", MS_NOATIME | MS_NODEV,
415 			"size=100000,mode=700"), 0);
416 
417 	ASSERT_EQ(mkdir("/mnt/A/AA", 0777), 0);
418 
419 	ASSERT_EQ(mount("/tmp", "/mnt/A/AA", NULL, MS_BIND | MS_REC, NULL), 0);
420 
421 	ASSERT_EQ(mkdir("/mnt/B", 0777), 0);
422 
423 	ASSERT_EQ(mount("testing", "/mnt/B", "ramfs",
424 			MS_NOATIME | MS_NODEV | MS_NOSUID, 0), 0);
425 
426 	ASSERT_EQ(mkdir("/mnt/B/BB", 0777), 0);
427 
428 	ASSERT_EQ(mount("testing", "/tmp/B/BB", "devpts",
429 			MS_RELATIME | MS_NOEXEC | MS_RDONLY, 0), 0);
430 
431 	fd = creat(NOSYMFOLLOW_TARGET, O_RDWR | O_CLOEXEC);
432 	ASSERT_GT(fd, 0);
433 	ASSERT_EQ(symlink(NOSYMFOLLOW_TARGET, NOSYMFOLLOW_SYMLINK), 0);
434 	ASSERT_EQ(close(fd), 0);
435 }
436 
437 FIXTURE_TEARDOWN(mount_setattr)
438 {
439 	if (!mount_setattr_supported())
440 		SKIP(return, "mount_setattr syscall not supported");
441 
442 	(void)umount2("/mnt/A", MNT_DETACH);
443 	(void)umount2("/tmp", MNT_DETACH);
444 }
445 
446 TEST_F(mount_setattr, invalid_attributes)
447 {
448 	struct mount_attr invalid_attr = {
449 		.attr_set = (1U << 31),
450 	};
451 
452 	if (!mount_setattr_supported())
453 		SKIP(return, "mount_setattr syscall not supported");
454 
455 	ASSERT_NE(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &invalid_attr,
456 				    sizeof(invalid_attr)), 0);
457 
458 	invalid_attr.attr_set	= 0;
459 	invalid_attr.attr_clr	= (1U << 31);
460 	ASSERT_NE(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &invalid_attr,
461 				    sizeof(invalid_attr)), 0);
462 
463 	invalid_attr.attr_clr		= 0;
464 	invalid_attr.propagation	= (1U << 31);
465 	ASSERT_NE(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &invalid_attr,
466 				    sizeof(invalid_attr)), 0);
467 
468 	invalid_attr.attr_set		= (1U << 31);
469 	invalid_attr.attr_clr		= (1U << 31);
470 	invalid_attr.propagation	= (1U << 31);
471 	ASSERT_NE(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &invalid_attr,
472 				    sizeof(invalid_attr)), 0);
473 
474 	ASSERT_NE(sys_mount_setattr(-1, "mnt/A", AT_RECURSIVE, &invalid_attr,
475 				    sizeof(invalid_attr)), 0);
476 }
477 
478 TEST_F(mount_setattr, extensibility)
479 {
480 	unsigned int old_flags = 0, new_flags = 0, expected_flags = 0;
481 	char *s = "dummy";
482 	struct mount_attr invalid_attr = {};
483 	struct mount_attr_large {
484 		struct mount_attr attr1;
485 		struct mount_attr attr2;
486 		struct mount_attr attr3;
487 	} large_attr = {};
488 
489 	if (!mount_setattr_supported())
490 		SKIP(return, "mount_setattr syscall not supported");
491 
492 	old_flags = read_mnt_flags("/mnt/A");
493 	ASSERT_GT(old_flags, 0);
494 
495 	ASSERT_NE(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, NULL,
496 				    sizeof(invalid_attr)), 0);
497 	ASSERT_EQ(errno, EFAULT);
498 
499 	ASSERT_NE(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, (void *)s,
500 				    sizeof(invalid_attr)), 0);
501 	ASSERT_EQ(errno, EINVAL);
502 
503 	ASSERT_NE(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &invalid_attr, 0), 0);
504 	ASSERT_EQ(errno, EINVAL);
505 
506 	ASSERT_NE(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &invalid_attr,
507 				    sizeof(invalid_attr) / 2), 0);
508 	ASSERT_EQ(errno, EINVAL);
509 
510 	ASSERT_NE(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &invalid_attr,
511 				    sizeof(invalid_attr) / 2), 0);
512 	ASSERT_EQ(errno, EINVAL);
513 
514 	ASSERT_EQ(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE,
515 				    (void *)&large_attr, sizeof(large_attr)), 0);
516 
517 	large_attr.attr3.attr_set = MOUNT_ATTR_RDONLY;
518 	ASSERT_NE(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE,
519 				    (void *)&large_attr, sizeof(large_attr)), 0);
520 
521 	large_attr.attr3.attr_set = 0;
522 	large_attr.attr1.attr_set = MOUNT_ATTR_RDONLY;
523 	ASSERT_EQ(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE,
524 				    (void *)&large_attr, sizeof(large_attr)), 0);
525 
526 	expected_flags = old_flags;
527 	expected_flags |= MS_RDONLY;
528 
529 	new_flags = read_mnt_flags("/mnt/A");
530 	ASSERT_EQ(new_flags, expected_flags);
531 
532 	new_flags = read_mnt_flags("/mnt/A/AA");
533 	ASSERT_EQ(new_flags, expected_flags);
534 
535 	new_flags = read_mnt_flags("/mnt/A/AA/B");
536 	ASSERT_EQ(new_flags, expected_flags);
537 
538 	new_flags = read_mnt_flags("/mnt/A/AA/B/BB");
539 	ASSERT_EQ(new_flags, expected_flags);
540 }
541 
542 TEST_F(mount_setattr, basic)
543 {
544 	unsigned int old_flags = 0, new_flags = 0, expected_flags = 0;
545 	struct mount_attr attr = {
546 		.attr_set	= MOUNT_ATTR_RDONLY | MOUNT_ATTR_NOEXEC | MOUNT_ATTR_RELATIME,
547 		.attr_clr	= MOUNT_ATTR__ATIME,
548 	};
549 
550 	if (!mount_setattr_supported())
551 		SKIP(return, "mount_setattr syscall not supported");
552 
553 	old_flags = read_mnt_flags("/mnt/A");
554 	ASSERT_GT(old_flags, 0);
555 
556 	ASSERT_EQ(sys_mount_setattr(-1, "/mnt/A", 0, &attr, sizeof(attr)), 0);
557 
558 	expected_flags = old_flags;
559 	expected_flags |= MS_RDONLY;
560 	expected_flags |= MS_NOEXEC;
561 	expected_flags &= ~MS_NOATIME;
562 	expected_flags |= MS_RELATIME;
563 
564 	new_flags = read_mnt_flags("/mnt/A");
565 	ASSERT_EQ(new_flags, expected_flags);
566 
567 	new_flags = read_mnt_flags("/mnt/A/AA");
568 	ASSERT_EQ(new_flags, old_flags);
569 
570 	new_flags = read_mnt_flags("/mnt/A/AA/B");
571 	ASSERT_EQ(new_flags, old_flags);
572 
573 	new_flags = read_mnt_flags("/mnt/A/AA/B/BB");
574 	ASSERT_EQ(new_flags, old_flags);
575 }
576 
577 TEST_F(mount_setattr, basic_recursive)
578 {
579 	int fd;
580 	unsigned int old_flags = 0, new_flags = 0, expected_flags = 0;
581 	struct mount_attr attr = {
582 		.attr_set	= MOUNT_ATTR_RDONLY | MOUNT_ATTR_NOEXEC | MOUNT_ATTR_RELATIME,
583 		.attr_clr	= MOUNT_ATTR__ATIME,
584 	};
585 
586 	if (!mount_setattr_supported())
587 		SKIP(return, "mount_setattr syscall not supported");
588 
589 	old_flags = read_mnt_flags("/mnt/A");
590 	ASSERT_GT(old_flags, 0);
591 
592 	ASSERT_EQ(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)), 0);
593 
594 	expected_flags = old_flags;
595 	expected_flags |= MS_RDONLY;
596 	expected_flags |= MS_NOEXEC;
597 	expected_flags &= ~MS_NOATIME;
598 	expected_flags |= MS_RELATIME;
599 
600 	new_flags = read_mnt_flags("/mnt/A");
601 	ASSERT_EQ(new_flags, expected_flags);
602 
603 	new_flags = read_mnt_flags("/mnt/A/AA");
604 	ASSERT_EQ(new_flags, expected_flags);
605 
606 	new_flags = read_mnt_flags("/mnt/A/AA/B");
607 	ASSERT_EQ(new_flags, expected_flags);
608 
609 	new_flags = read_mnt_flags("/mnt/A/AA/B/BB");
610 	ASSERT_EQ(new_flags, expected_flags);
611 
612 	memset(&attr, 0, sizeof(attr));
613 	attr.attr_clr = MOUNT_ATTR_RDONLY;
614 	attr.propagation = MS_SHARED;
615 	ASSERT_EQ(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)), 0);
616 
617 	expected_flags &= ~MS_RDONLY;
618 	new_flags = read_mnt_flags("/mnt/A");
619 	ASSERT_EQ(new_flags, expected_flags);
620 
621 	ASSERT_EQ(is_shared_mount("/mnt/A"), true);
622 
623 	new_flags = read_mnt_flags("/mnt/A/AA");
624 	ASSERT_EQ(new_flags, expected_flags);
625 
626 	ASSERT_EQ(is_shared_mount("/mnt/A/AA"), true);
627 
628 	new_flags = read_mnt_flags("/mnt/A/AA/B");
629 	ASSERT_EQ(new_flags, expected_flags);
630 
631 	ASSERT_EQ(is_shared_mount("/mnt/A/AA/B"), true);
632 
633 	new_flags = read_mnt_flags("/mnt/A/AA/B/BB");
634 	ASSERT_EQ(new_flags, expected_flags);
635 
636 	ASSERT_EQ(is_shared_mount("/mnt/A/AA/B/BB"), true);
637 
638 	fd = open("/mnt/A/AA/B/b", O_RDWR | O_CLOEXEC | O_CREAT | O_EXCL, 0777);
639 	ASSERT_GE(fd, 0);
640 
641 	/*
642 	 * We're holding a fd open for writing so this needs to fail somewhere
643 	 * in the middle and the mount options need to be unchanged.
644 	 */
645 	attr.attr_set = MOUNT_ATTR_RDONLY;
646 	ASSERT_LT(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)), 0);
647 
648 	new_flags = read_mnt_flags("/mnt/A");
649 	ASSERT_EQ(new_flags, expected_flags);
650 
651 	ASSERT_EQ(is_shared_mount("/mnt/A"), true);
652 
653 	new_flags = read_mnt_flags("/mnt/A/AA");
654 	ASSERT_EQ(new_flags, expected_flags);
655 
656 	ASSERT_EQ(is_shared_mount("/mnt/A/AA"), true);
657 
658 	new_flags = read_mnt_flags("/mnt/A/AA/B");
659 	ASSERT_EQ(new_flags, expected_flags);
660 
661 	ASSERT_EQ(is_shared_mount("/mnt/A/AA/B"), true);
662 
663 	new_flags = read_mnt_flags("/mnt/A/AA/B/BB");
664 	ASSERT_EQ(new_flags, expected_flags);
665 
666 	ASSERT_EQ(is_shared_mount("/mnt/A/AA/B/BB"), true);
667 
668 	EXPECT_EQ(close(fd), 0);
669 }
670 
671 TEST_F(mount_setattr, mount_has_writers)
672 {
673 	int fd, dfd;
674 	unsigned int old_flags = 0, new_flags = 0;
675 	struct mount_attr attr = {
676 		.attr_set	= MOUNT_ATTR_RDONLY | MOUNT_ATTR_NOEXEC | MOUNT_ATTR_RELATIME,
677 		.attr_clr	= MOUNT_ATTR__ATIME,
678 		.propagation	= MS_SHARED,
679 	};
680 
681 	if (!mount_setattr_supported())
682 		SKIP(return, "mount_setattr syscall not supported");
683 
684 	old_flags = read_mnt_flags("/mnt/A");
685 	ASSERT_GT(old_flags, 0);
686 
687 	fd = open("/mnt/A/AA/B/b", O_RDWR | O_CLOEXEC | O_CREAT | O_EXCL, 0777);
688 	ASSERT_GE(fd, 0);
689 
690 	/*
691 	 * We're holding a fd open to a mount somwhere in the middle so this
692 	 * needs to fail somewhere in the middle. After this the mount options
693 	 * need to be unchanged.
694 	 */
695 	ASSERT_LT(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)), 0);
696 
697 	new_flags = read_mnt_flags("/mnt/A");
698 	ASSERT_EQ(new_flags, old_flags);
699 
700 	ASSERT_EQ(is_shared_mount("/mnt/A"), false);
701 
702 	new_flags = read_mnt_flags("/mnt/A/AA");
703 	ASSERT_EQ(new_flags, old_flags);
704 
705 	ASSERT_EQ(is_shared_mount("/mnt/A/AA"), false);
706 
707 	new_flags = read_mnt_flags("/mnt/A/AA/B");
708 	ASSERT_EQ(new_flags, old_flags);
709 
710 	ASSERT_EQ(is_shared_mount("/mnt/A/AA/B"), false);
711 
712 	new_flags = read_mnt_flags("/mnt/A/AA/B/BB");
713 	ASSERT_EQ(new_flags, old_flags);
714 
715 	ASSERT_EQ(is_shared_mount("/mnt/A/AA/B/BB"), false);
716 
717 	dfd = open("/mnt/A/AA/B", O_DIRECTORY | O_CLOEXEC);
718 	ASSERT_GE(dfd, 0);
719 	EXPECT_EQ(fsync(dfd), 0);
720 	EXPECT_EQ(close(dfd), 0);
721 
722 	EXPECT_EQ(fsync(fd), 0);
723 	EXPECT_EQ(close(fd), 0);
724 
725 	/* All writers are gone so this should succeed. */
726 	ASSERT_EQ(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)), 0);
727 }
728 
729 TEST_F(mount_setattr, mixed_mount_options)
730 {
731 	unsigned int old_flags1 = 0, old_flags2 = 0, new_flags = 0, expected_flags = 0;
732 	struct mount_attr attr = {
733 		.attr_clr = MOUNT_ATTR_RDONLY | MOUNT_ATTR_NOSUID | MOUNT_ATTR_NOEXEC | MOUNT_ATTR__ATIME,
734 		.attr_set = MOUNT_ATTR_RELATIME,
735 	};
736 
737 	if (!mount_setattr_supported())
738 		SKIP(return, "mount_setattr syscall not supported");
739 
740 	old_flags1 = read_mnt_flags("/mnt/B");
741 	ASSERT_GT(old_flags1, 0);
742 
743 	old_flags2 = read_mnt_flags("/mnt/B/BB");
744 	ASSERT_GT(old_flags2, 0);
745 
746 	ASSERT_EQ(sys_mount_setattr(-1, "/mnt/B", AT_RECURSIVE, &attr, sizeof(attr)), 0);
747 
748 	expected_flags = old_flags2;
749 	expected_flags &= ~(MS_RDONLY | MS_NOEXEC | MS_NOATIME | MS_NOSUID);
750 	expected_flags |= MS_RELATIME;
751 
752 	new_flags = read_mnt_flags("/mnt/B");
753 	ASSERT_EQ(new_flags, expected_flags);
754 
755 	expected_flags = old_flags2;
756 	expected_flags &= ~(MS_RDONLY | MS_NOEXEC | MS_NOATIME | MS_NOSUID);
757 	expected_flags |= MS_RELATIME;
758 
759 	new_flags = read_mnt_flags("/mnt/B/BB");
760 	ASSERT_EQ(new_flags, expected_flags);
761 }
762 
763 TEST_F(mount_setattr, time_changes)
764 {
765 	unsigned int old_flags = 0, new_flags = 0, expected_flags = 0;
766 	struct mount_attr attr = {
767 		.attr_set	= MOUNT_ATTR_NODIRATIME | MOUNT_ATTR_NOATIME,
768 	};
769 
770 	if (!mount_setattr_supported())
771 		SKIP(return, "mount_setattr syscall not supported");
772 
773 	ASSERT_NE(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)), 0);
774 
775 	attr.attr_set = MOUNT_ATTR_STRICTATIME;
776 	ASSERT_NE(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)), 0);
777 
778 	attr.attr_set = MOUNT_ATTR_STRICTATIME | MOUNT_ATTR_NOATIME;
779 	ASSERT_NE(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)), 0);
780 
781 	attr.attr_set = MOUNT_ATTR_STRICTATIME | MOUNT_ATTR_NOATIME;
782 	attr.attr_clr = MOUNT_ATTR__ATIME;
783 	ASSERT_NE(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)), 0);
784 
785 	attr.attr_set = 0;
786 	attr.attr_clr = MOUNT_ATTR_STRICTATIME;
787 	ASSERT_NE(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)), 0);
788 
789 	attr.attr_clr = MOUNT_ATTR_NOATIME;
790 	ASSERT_NE(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)), 0);
791 
792 	old_flags = read_mnt_flags("/mnt/A");
793 	ASSERT_GT(old_flags, 0);
794 
795 	attr.attr_set = MOUNT_ATTR_NODIRATIME | MOUNT_ATTR_NOATIME;
796 	attr.attr_clr = MOUNT_ATTR__ATIME;
797 	ASSERT_EQ(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)), 0);
798 
799 	expected_flags = old_flags;
800 	expected_flags |= MS_NOATIME;
801 	expected_flags |= MS_NODIRATIME;
802 
803 	new_flags = read_mnt_flags("/mnt/A");
804 	ASSERT_EQ(new_flags, expected_flags);
805 
806 	new_flags = read_mnt_flags("/mnt/A/AA");
807 	ASSERT_EQ(new_flags, expected_flags);
808 
809 	new_flags = read_mnt_flags("/mnt/A/AA/B");
810 	ASSERT_EQ(new_flags, expected_flags);
811 
812 	new_flags = read_mnt_flags("/mnt/A/AA/B/BB");
813 	ASSERT_EQ(new_flags, expected_flags);
814 
815 	memset(&attr, 0, sizeof(attr));
816 	attr.attr_set &= ~MOUNT_ATTR_NOATIME;
817 	attr.attr_set |= MOUNT_ATTR_RELATIME;
818 	attr.attr_clr |= MOUNT_ATTR__ATIME;
819 	ASSERT_EQ(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)), 0);
820 
821 	expected_flags &= ~MS_NOATIME;
822 	expected_flags |= MS_RELATIME;
823 
824 	new_flags = read_mnt_flags("/mnt/A");
825 	ASSERT_EQ(new_flags, expected_flags);
826 
827 	new_flags = read_mnt_flags("/mnt/A/AA");
828 	ASSERT_EQ(new_flags, expected_flags);
829 
830 	new_flags = read_mnt_flags("/mnt/A/AA/B");
831 	ASSERT_EQ(new_flags, expected_flags);
832 
833 	new_flags = read_mnt_flags("/mnt/A/AA/B/BB");
834 	ASSERT_EQ(new_flags, expected_flags);
835 
836 	memset(&attr, 0, sizeof(attr));
837 	attr.attr_set &= ~MOUNT_ATTR_RELATIME;
838 	attr.attr_set |= MOUNT_ATTR_STRICTATIME;
839 	attr.attr_clr |= MOUNT_ATTR__ATIME;
840 	ASSERT_EQ(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)), 0);
841 
842 	expected_flags &= ~MS_RELATIME;
843 
844 	new_flags = read_mnt_flags("/mnt/A");
845 	ASSERT_EQ(new_flags, expected_flags);
846 
847 	new_flags = read_mnt_flags("/mnt/A/AA");
848 	ASSERT_EQ(new_flags, expected_flags);
849 
850 	new_flags = read_mnt_flags("/mnt/A/AA/B");
851 	ASSERT_EQ(new_flags, expected_flags);
852 
853 	new_flags = read_mnt_flags("/mnt/A/AA/B/BB");
854 	ASSERT_EQ(new_flags, expected_flags);
855 
856 	memset(&attr, 0, sizeof(attr));
857 	attr.attr_set &= ~MOUNT_ATTR_STRICTATIME;
858 	attr.attr_set |= MOUNT_ATTR_NOATIME;
859 	attr.attr_clr |= MOUNT_ATTR__ATIME;
860 	ASSERT_EQ(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)), 0);
861 
862 	expected_flags |= MS_NOATIME;
863 	new_flags = read_mnt_flags("/mnt/A");
864 	ASSERT_EQ(new_flags, expected_flags);
865 
866 	new_flags = read_mnt_flags("/mnt/A/AA");
867 	ASSERT_EQ(new_flags, expected_flags);
868 
869 	new_flags = read_mnt_flags("/mnt/A/AA/B");
870 	ASSERT_EQ(new_flags, expected_flags);
871 
872 	new_flags = read_mnt_flags("/mnt/A/AA/B/BB");
873 	ASSERT_EQ(new_flags, expected_flags);
874 
875 	memset(&attr, 0, sizeof(attr));
876 	ASSERT_EQ(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)), 0);
877 
878 	new_flags = read_mnt_flags("/mnt/A");
879 	ASSERT_EQ(new_flags, expected_flags);
880 
881 	new_flags = read_mnt_flags("/mnt/A/AA");
882 	ASSERT_EQ(new_flags, expected_flags);
883 
884 	new_flags = read_mnt_flags("/mnt/A/AA/B");
885 	ASSERT_EQ(new_flags, expected_flags);
886 
887 	new_flags = read_mnt_flags("/mnt/A/AA/B/BB");
888 	ASSERT_EQ(new_flags, expected_flags);
889 
890 	memset(&attr, 0, sizeof(attr));
891 	attr.attr_clr = MOUNT_ATTR_NODIRATIME;
892 	ASSERT_EQ(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)), 0);
893 
894 	expected_flags &= ~MS_NODIRATIME;
895 
896 	new_flags = read_mnt_flags("/mnt/A");
897 	ASSERT_EQ(new_flags, expected_flags);
898 
899 	new_flags = read_mnt_flags("/mnt/A/AA");
900 	ASSERT_EQ(new_flags, expected_flags);
901 
902 	new_flags = read_mnt_flags("/mnt/A/AA/B");
903 	ASSERT_EQ(new_flags, expected_flags);
904 
905 	new_flags = read_mnt_flags("/mnt/A/AA/B/BB");
906 	ASSERT_EQ(new_flags, expected_flags);
907 }
908 
909 TEST_F(mount_setattr, multi_threaded)
910 {
911 	int i, j, nthreads, ret = 0;
912 	unsigned int old_flags = 0, new_flags = 0, expected_flags = 0;
913 	pthread_attr_t pattr;
914 	pthread_t threads[DEFAULT_THREADS];
915 
916 	if (!mount_setattr_supported())
917 		SKIP(return, "mount_setattr syscall not supported");
918 
919 	old_flags = read_mnt_flags("/mnt/A");
920 	ASSERT_GT(old_flags, 0);
921 
922 	/* Try to change mount options from multiple threads. */
923 	nthreads = get_nprocs_conf();
924 	if (nthreads > DEFAULT_THREADS)
925 		nthreads = DEFAULT_THREADS;
926 
927 	pthread_attr_init(&pattr);
928 	for (i = 0; i < nthreads; i++)
929 		ASSERT_EQ(pthread_create(&threads[i], &pattr, mount_setattr_thread, NULL), 0);
930 
931 	for (j = 0; j < i; j++) {
932 		void *retptr = NULL;
933 
934 		EXPECT_EQ(pthread_join(threads[j], &retptr), 0);
935 
936 		ret += ptr_to_int(retptr);
937 		EXPECT_EQ(ret, 0);
938 	}
939 	pthread_attr_destroy(&pattr);
940 
941 	ASSERT_EQ(ret, 0);
942 
943 	expected_flags = old_flags;
944 	expected_flags |= MS_RDONLY;
945 	expected_flags |= MS_NOSUID;
946 	new_flags = read_mnt_flags("/mnt/A");
947 	ASSERT_EQ(new_flags, expected_flags);
948 
949 	ASSERT_EQ(is_shared_mount("/mnt/A"), true);
950 
951 	new_flags = read_mnt_flags("/mnt/A/AA");
952 	ASSERT_EQ(new_flags, expected_flags);
953 
954 	ASSERT_EQ(is_shared_mount("/mnt/A/AA"), true);
955 
956 	new_flags = read_mnt_flags("/mnt/A/AA/B");
957 	ASSERT_EQ(new_flags, expected_flags);
958 
959 	ASSERT_EQ(is_shared_mount("/mnt/A/AA/B"), true);
960 
961 	new_flags = read_mnt_flags("/mnt/A/AA/B/BB");
962 	ASSERT_EQ(new_flags, expected_flags);
963 
964 	ASSERT_EQ(is_shared_mount("/mnt/A/AA/B/BB"), true);
965 }
966 
967 TEST_F(mount_setattr, wrong_user_namespace)
968 {
969 	int ret;
970 	struct mount_attr attr = {
971 		.attr_set = MOUNT_ATTR_RDONLY,
972 	};
973 
974 	if (!mount_setattr_supported())
975 		SKIP(return, "mount_setattr syscall not supported");
976 
977 	EXPECT_EQ(create_and_enter_userns(), 0);
978 	ret = sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr));
979 	ASSERT_LT(ret, 0);
980 	ASSERT_EQ(errno, EPERM);
981 }
982 
983 TEST_F(mount_setattr, wrong_mount_namespace)
984 {
985 	int fd, ret;
986 	struct mount_attr attr = {
987 		.attr_set = MOUNT_ATTR_RDONLY,
988 	};
989 
990 	if (!mount_setattr_supported())
991 		SKIP(return, "mount_setattr syscall not supported");
992 
993 	fd = open("/mnt/A", O_DIRECTORY | O_CLOEXEC);
994 	ASSERT_GE(fd, 0);
995 
996 	ASSERT_EQ(unshare(CLONE_NEWNS), 0);
997 
998 	ret = sys_mount_setattr(fd, "", AT_EMPTY_PATH | AT_RECURSIVE, &attr, sizeof(attr));
999 	ASSERT_LT(ret, 0);
1000 	ASSERT_EQ(errno, EINVAL);
1001 }
1002 
1003 FIXTURE(mount_setattr_idmapped) {
1004 };
1005 
1006 FIXTURE_SETUP(mount_setattr_idmapped)
1007 {
1008 	int img_fd = -EBADF;
1009 
1010 	ASSERT_EQ(unshare(CLONE_NEWNS), 0);
1011 
1012 	ASSERT_EQ(mount(NULL, "/", NULL, MS_REC | MS_PRIVATE, 0), 0);
1013 
1014 	(void)umount2("/mnt", MNT_DETACH);
1015 	(void)umount2("/tmp", MNT_DETACH);
1016 
1017 	ASSERT_EQ(mount("testing", "/tmp", "tmpfs", MS_NOATIME | MS_NODEV,
1018 			"size=100000,mode=700"), 0);
1019 
1020 	ASSERT_EQ(mkdir("/tmp/B", 0777), 0);
1021 	ASSERT_EQ(mknodat(-EBADF, "/tmp/B/b", S_IFREG | 0644, 0), 0);
1022 	ASSERT_EQ(chown("/tmp/B/b", 0, 0), 0);
1023 
1024 	ASSERT_EQ(mount("testing", "/tmp/B", "tmpfs", MS_NOATIME | MS_NODEV,
1025 			"size=100000,mode=700"), 0);
1026 
1027 	ASSERT_EQ(mkdir("/tmp/B/BB", 0777), 0);
1028 	ASSERT_EQ(mknodat(-EBADF, "/tmp/B/BB/b", S_IFREG | 0644, 0), 0);
1029 	ASSERT_EQ(chown("/tmp/B/BB/b", 0, 0), 0);
1030 
1031 	ASSERT_EQ(mount("testing", "/tmp/B/BB", "tmpfs", MS_NOATIME | MS_NODEV,
1032 			"size=100000,mode=700"), 0);
1033 
1034 	ASSERT_EQ(mount("testing", "/mnt", "tmpfs", MS_NOATIME | MS_NODEV,
1035 			"size=100000,mode=700"), 0);
1036 
1037 	ASSERT_EQ(mkdir("/mnt/A", 0777), 0);
1038 
1039 	ASSERT_EQ(mount("testing", "/mnt/A", "tmpfs", MS_NOATIME | MS_NODEV,
1040 			"size=100000,mode=700"), 0);
1041 
1042 	ASSERT_EQ(mkdir("/mnt/A/AA", 0777), 0);
1043 
1044 	ASSERT_EQ(mount("/tmp", "/mnt/A/AA", NULL, MS_BIND | MS_REC, NULL), 0);
1045 
1046 	ASSERT_EQ(mkdir("/mnt/B", 0777), 0);
1047 
1048 	ASSERT_EQ(mount("testing", "/mnt/B", "ramfs",
1049 			MS_NOATIME | MS_NODEV | MS_NOSUID, 0), 0);
1050 
1051 	ASSERT_EQ(mkdir("/mnt/B/BB", 0777), 0);
1052 
1053 	ASSERT_EQ(mount("testing", "/tmp/B/BB", "devpts",
1054 			MS_RELATIME | MS_NOEXEC | MS_RDONLY, 0), 0);
1055 
1056 	ASSERT_EQ(mkdir("/mnt/C", 0777), 0);
1057 	ASSERT_EQ(mkdir("/mnt/D", 0777), 0);
1058 	img_fd = openat(-EBADF, "/mnt/C/ext4.img", O_CREAT | O_WRONLY, 0600);
1059 	ASSERT_GE(img_fd, 0);
1060 	ASSERT_EQ(ftruncate(img_fd, 1024 * 2048), 0);
1061 	ASSERT_EQ(system("mkfs.ext4 -q /mnt/C/ext4.img"), 0);
1062 	ASSERT_EQ(system("mount -o loop -t ext4 /mnt/C/ext4.img /mnt/D/"), 0);
1063 	ASSERT_EQ(close(img_fd), 0);
1064 }
1065 
1066 FIXTURE_TEARDOWN(mount_setattr_idmapped)
1067 {
1068 	(void)umount2("/mnt/A", MNT_DETACH);
1069 	(void)umount2("/tmp", MNT_DETACH);
1070 }
1071 
1072 /**
1073  * Validate that negative fd values are rejected.
1074  */
1075 TEST_F(mount_setattr_idmapped, invalid_fd_negative)
1076 {
1077 	struct mount_attr attr = {
1078 		.attr_set	= MOUNT_ATTR_IDMAP,
1079 		.userns_fd	= -EBADF,
1080 	};
1081 
1082 	if (!mount_setattr_supported())
1083 		SKIP(return, "mount_setattr syscall not supported");
1084 
1085 	ASSERT_NE(sys_mount_setattr(-1, "/", 0, &attr, sizeof(attr)), 0) {
1086 		TH_LOG("failure: created idmapped mount with negative fd");
1087 	}
1088 }
1089 
1090 /**
1091  * Validate that excessively large fd values are rejected.
1092  */
1093 TEST_F(mount_setattr_idmapped, invalid_fd_large)
1094 {
1095 	struct mount_attr attr = {
1096 		.attr_set	= MOUNT_ATTR_IDMAP,
1097 		.userns_fd	= INT64_MAX,
1098 	};
1099 
1100 	if (!mount_setattr_supported())
1101 		SKIP(return, "mount_setattr syscall not supported");
1102 
1103 	ASSERT_NE(sys_mount_setattr(-1, "/", 0, &attr, sizeof(attr)), 0) {
1104 		TH_LOG("failure: created idmapped mount with too large fd value");
1105 	}
1106 }
1107 
1108 /**
1109  * Validate that closed fd values are rejected.
1110  */
1111 TEST_F(mount_setattr_idmapped, invalid_fd_closed)
1112 {
1113 	int fd;
1114 	struct mount_attr attr = {
1115 		.attr_set = MOUNT_ATTR_IDMAP,
1116 	};
1117 
1118 	if (!mount_setattr_supported())
1119 		SKIP(return, "mount_setattr syscall not supported");
1120 
1121 	fd = open("/dev/null", O_RDONLY | O_CLOEXEC);
1122 	ASSERT_GE(fd, 0);
1123 	ASSERT_GE(close(fd), 0);
1124 
1125 	attr.userns_fd = fd;
1126 	ASSERT_NE(sys_mount_setattr(-1, "/", 0, &attr, sizeof(attr)), 0) {
1127 		TH_LOG("failure: created idmapped mount with closed fd");
1128 	}
1129 }
1130 
1131 /**
1132  * Validate that the initial user namespace is rejected.
1133  */
1134 TEST_F(mount_setattr_idmapped, invalid_fd_initial_userns)
1135 {
1136 	int open_tree_fd = -EBADF;
1137 	struct mount_attr attr = {
1138 		.attr_set = MOUNT_ATTR_IDMAP,
1139 	};
1140 
1141 	if (!mount_setattr_supported())
1142 		SKIP(return, "mount_setattr syscall not supported");
1143 
1144 	open_tree_fd = sys_open_tree(-EBADF, "/mnt/D",
1145 				     AT_NO_AUTOMOUNT |
1146 				     AT_SYMLINK_NOFOLLOW |
1147 				     OPEN_TREE_CLOEXEC | OPEN_TREE_CLONE);
1148 	ASSERT_GE(open_tree_fd, 0);
1149 
1150 	attr.userns_fd = open("/proc/1/ns/user", O_RDONLY | O_CLOEXEC);
1151 	ASSERT_GE(attr.userns_fd, 0);
1152 	ASSERT_NE(sys_mount_setattr(open_tree_fd, "", AT_EMPTY_PATH, &attr, sizeof(attr)), 0);
1153 	ASSERT_EQ(errno, EPERM);
1154 	ASSERT_EQ(close(attr.userns_fd), 0);
1155 	ASSERT_EQ(close(open_tree_fd), 0);
1156 }
1157 
1158 static int map_ids(pid_t pid, unsigned long nsid, unsigned long hostid,
1159 		   unsigned long range)
1160 {
1161 	char map[100], procfile[256];
1162 
1163 	snprintf(procfile, sizeof(procfile), "/proc/%d/uid_map", pid);
1164 	snprintf(map, sizeof(map), "%lu %lu %lu", nsid, hostid, range);
1165 	if (write_file(procfile, map, strlen(map)))
1166 		return -1;
1167 
1168 
1169 	snprintf(procfile, sizeof(procfile), "/proc/%d/gid_map", pid);
1170 	snprintf(map, sizeof(map), "%lu %lu %lu", nsid, hostid, range);
1171 	if (write_file(procfile, map, strlen(map)))
1172 		return -1;
1173 
1174 	return 0;
1175 }
1176 
1177 #define __STACK_SIZE (8 * 1024 * 1024)
1178 static pid_t do_clone(int (*fn)(void *), void *arg, int flags)
1179 {
1180 	void *stack;
1181 
1182 	stack = malloc(__STACK_SIZE);
1183 	if (!stack)
1184 		return -ENOMEM;
1185 
1186 #ifdef __ia64__
1187 	return __clone2(fn, stack, __STACK_SIZE, flags | SIGCHLD, arg, NULL);
1188 #else
1189 	return clone(fn, stack + __STACK_SIZE, flags | SIGCHLD, arg, NULL);
1190 #endif
1191 }
1192 
1193 static int get_userns_fd_cb(void *data)
1194 {
1195 	return kill(getpid(), SIGSTOP);
1196 }
1197 
1198 static int wait_for_pid(pid_t pid)
1199 {
1200 	int status, ret;
1201 
1202 again:
1203 	ret = waitpid(pid, &status, 0);
1204 	if (ret == -1) {
1205 		if (errno == EINTR)
1206 			goto again;
1207 
1208 		return -1;
1209 	}
1210 
1211 	if (!WIFEXITED(status))
1212 		return -1;
1213 
1214 	return WEXITSTATUS(status);
1215 }
1216 
1217 static int get_userns_fd(unsigned long nsid, unsigned long hostid, unsigned long range)
1218 {
1219 	int ret;
1220 	pid_t pid;
1221 	char path[256];
1222 
1223 	pid = do_clone(get_userns_fd_cb, NULL, CLONE_NEWUSER);
1224 	if (pid < 0)
1225 		return -errno;
1226 
1227 	ret = map_ids(pid, nsid, hostid, range);
1228 	if (ret < 0)
1229 		return ret;
1230 
1231 	snprintf(path, sizeof(path), "/proc/%d/ns/user", pid);
1232 	ret = open(path, O_RDONLY | O_CLOEXEC);
1233 	kill(pid, SIGKILL);
1234 	wait_for_pid(pid);
1235 	return ret;
1236 }
1237 
1238 /**
1239  * Validate that an attached mount in our mount namespace cannot be idmapped.
1240  * (The kernel enforces that the mount's mount namespace and the caller's mount
1241  *  namespace match.)
1242  */
1243 TEST_F(mount_setattr_idmapped, attached_mount_inside_current_mount_namespace)
1244 {
1245 	int open_tree_fd = -EBADF;
1246 	struct mount_attr attr = {
1247 		.attr_set = MOUNT_ATTR_IDMAP,
1248 	};
1249 
1250 	if (!mount_setattr_supported())
1251 		SKIP(return, "mount_setattr syscall not supported");
1252 
1253 	open_tree_fd = sys_open_tree(-EBADF, "/mnt/D",
1254 				     AT_EMPTY_PATH |
1255 				     AT_NO_AUTOMOUNT |
1256 				     AT_SYMLINK_NOFOLLOW |
1257 				     OPEN_TREE_CLOEXEC);
1258 	ASSERT_GE(open_tree_fd, 0);
1259 
1260 	attr.userns_fd	= get_userns_fd(0, 10000, 10000);
1261 	ASSERT_GE(attr.userns_fd, 0);
1262 	ASSERT_NE(sys_mount_setattr(open_tree_fd, "", AT_EMPTY_PATH, &attr, sizeof(attr)), 0);
1263 	ASSERT_EQ(close(attr.userns_fd), 0);
1264 	ASSERT_EQ(close(open_tree_fd), 0);
1265 }
1266 
1267 /**
1268  * Validate that idmapping a mount is rejected if the mount's mount namespace
1269  * and our mount namespace don't match.
1270  * (The kernel enforces that the mount's mount namespace and the caller's mount
1271  *  namespace match.)
1272  */
1273 TEST_F(mount_setattr_idmapped, attached_mount_outside_current_mount_namespace)
1274 {
1275 	int open_tree_fd = -EBADF;
1276 	struct mount_attr attr = {
1277 		.attr_set = MOUNT_ATTR_IDMAP,
1278 	};
1279 
1280 	if (!mount_setattr_supported())
1281 		SKIP(return, "mount_setattr syscall not supported");
1282 
1283 	open_tree_fd = sys_open_tree(-EBADF, "/mnt/D",
1284 				     AT_EMPTY_PATH |
1285 				     AT_NO_AUTOMOUNT |
1286 				     AT_SYMLINK_NOFOLLOW |
1287 				     OPEN_TREE_CLOEXEC);
1288 	ASSERT_GE(open_tree_fd, 0);
1289 
1290 	ASSERT_EQ(unshare(CLONE_NEWNS), 0);
1291 
1292 	attr.userns_fd	= get_userns_fd(0, 10000, 10000);
1293 	ASSERT_GE(attr.userns_fd, 0);
1294 	ASSERT_NE(sys_mount_setattr(open_tree_fd, "", AT_EMPTY_PATH, &attr,
1295 				    sizeof(attr)), 0);
1296 	ASSERT_EQ(close(attr.userns_fd), 0);
1297 	ASSERT_EQ(close(open_tree_fd), 0);
1298 }
1299 
1300 /**
1301  * Validate that an attached mount in our mount namespace can be idmapped.
1302  */
1303 TEST_F(mount_setattr_idmapped, detached_mount_inside_current_mount_namespace)
1304 {
1305 	int open_tree_fd = -EBADF;
1306 	struct mount_attr attr = {
1307 		.attr_set = MOUNT_ATTR_IDMAP,
1308 	};
1309 
1310 	if (!mount_setattr_supported())
1311 		SKIP(return, "mount_setattr syscall not supported");
1312 
1313 	open_tree_fd = sys_open_tree(-EBADF, "/mnt/D",
1314 				     AT_EMPTY_PATH |
1315 				     AT_NO_AUTOMOUNT |
1316 				     AT_SYMLINK_NOFOLLOW |
1317 				     OPEN_TREE_CLOEXEC |
1318 				     OPEN_TREE_CLONE);
1319 	ASSERT_GE(open_tree_fd, 0);
1320 
1321 	/* Changing mount properties on a detached mount. */
1322 	attr.userns_fd	= get_userns_fd(0, 10000, 10000);
1323 	ASSERT_GE(attr.userns_fd, 0);
1324 	ASSERT_EQ(sys_mount_setattr(open_tree_fd, "",
1325 				    AT_EMPTY_PATH, &attr, sizeof(attr)), 0);
1326 	ASSERT_EQ(close(attr.userns_fd), 0);
1327 	ASSERT_EQ(close(open_tree_fd), 0);
1328 }
1329 
1330 /**
1331  * Validate that a detached mount not in our mount namespace can be idmapped.
1332  */
1333 TEST_F(mount_setattr_idmapped, detached_mount_outside_current_mount_namespace)
1334 {
1335 	int open_tree_fd = -EBADF;
1336 	struct mount_attr attr = {
1337 		.attr_set = MOUNT_ATTR_IDMAP,
1338 	};
1339 
1340 	if (!mount_setattr_supported())
1341 		SKIP(return, "mount_setattr syscall not supported");
1342 
1343 	open_tree_fd = sys_open_tree(-EBADF, "/mnt/D",
1344 				     AT_EMPTY_PATH |
1345 				     AT_NO_AUTOMOUNT |
1346 				     AT_SYMLINK_NOFOLLOW |
1347 				     OPEN_TREE_CLOEXEC |
1348 				     OPEN_TREE_CLONE);
1349 	ASSERT_GE(open_tree_fd, 0);
1350 
1351 	ASSERT_EQ(unshare(CLONE_NEWNS), 0);
1352 
1353 	/* Changing mount properties on a detached mount. */
1354 	attr.userns_fd	= get_userns_fd(0, 10000, 10000);
1355 	ASSERT_GE(attr.userns_fd, 0);
1356 	ASSERT_EQ(sys_mount_setattr(open_tree_fd, "",
1357 				    AT_EMPTY_PATH, &attr, sizeof(attr)), 0);
1358 	ASSERT_EQ(close(attr.userns_fd), 0);
1359 	ASSERT_EQ(close(open_tree_fd), 0);
1360 }
1361 
1362 /**
1363  * Validate that currently changing the idmapping of an idmapped mount fails.
1364  */
1365 TEST_F(mount_setattr_idmapped, change_idmapping)
1366 {
1367 	int open_tree_fd = -EBADF;
1368 	struct mount_attr attr = {
1369 		.attr_set = MOUNT_ATTR_IDMAP,
1370 	};
1371 
1372 	if (!mount_setattr_supported())
1373 		SKIP(return, "mount_setattr syscall not supported");
1374 
1375 	open_tree_fd = sys_open_tree(-EBADF, "/mnt/D",
1376 				     AT_EMPTY_PATH |
1377 				     AT_NO_AUTOMOUNT |
1378 				     AT_SYMLINK_NOFOLLOW |
1379 				     OPEN_TREE_CLOEXEC |
1380 				     OPEN_TREE_CLONE);
1381 	ASSERT_GE(open_tree_fd, 0);
1382 
1383 	attr.userns_fd	= get_userns_fd(0, 10000, 10000);
1384 	ASSERT_GE(attr.userns_fd, 0);
1385 	ASSERT_EQ(sys_mount_setattr(open_tree_fd, "",
1386 				    AT_EMPTY_PATH, &attr, sizeof(attr)), 0);
1387 	ASSERT_EQ(close(attr.userns_fd), 0);
1388 
1389 	/* Change idmapping on a detached mount that is already idmapped. */
1390 	attr.userns_fd	= get_userns_fd(0, 20000, 10000);
1391 	ASSERT_GE(attr.userns_fd, 0);
1392 	ASSERT_NE(sys_mount_setattr(open_tree_fd, "", AT_EMPTY_PATH, &attr, sizeof(attr)), 0);
1393 	ASSERT_EQ(close(attr.userns_fd), 0);
1394 	ASSERT_EQ(close(open_tree_fd), 0);
1395 }
1396 
1397 static bool expected_uid_gid(int dfd, const char *path, int flags,
1398 			     uid_t expected_uid, gid_t expected_gid)
1399 {
1400 	int ret;
1401 	struct stat st;
1402 
1403 	ret = fstatat(dfd, path, &st, flags);
1404 	if (ret < 0)
1405 		return false;
1406 
1407 	return st.st_uid == expected_uid && st.st_gid == expected_gid;
1408 }
1409 
1410 TEST_F(mount_setattr_idmapped, idmap_mount_tree_invalid)
1411 {
1412 	int open_tree_fd = -EBADF;
1413 	struct mount_attr attr = {
1414 		.attr_set = MOUNT_ATTR_IDMAP,
1415 	};
1416 
1417 	if (!mount_setattr_supported())
1418 		SKIP(return, "mount_setattr syscall not supported");
1419 
1420 	ASSERT_EQ(expected_uid_gid(-EBADF, "/tmp/B/b", 0, 0, 0), 0);
1421 	ASSERT_EQ(expected_uid_gid(-EBADF, "/tmp/B/BB/b", 0, 0, 0), 0);
1422 
1423 	open_tree_fd = sys_open_tree(-EBADF, "/mnt/A",
1424 				     AT_RECURSIVE |
1425 				     AT_EMPTY_PATH |
1426 				     AT_NO_AUTOMOUNT |
1427 				     AT_SYMLINK_NOFOLLOW |
1428 				     OPEN_TREE_CLOEXEC |
1429 				     OPEN_TREE_CLONE);
1430 	ASSERT_GE(open_tree_fd, 0);
1431 
1432 	attr.userns_fd	= get_userns_fd(0, 10000, 10000);
1433 	ASSERT_GE(attr.userns_fd, 0);
1434 	ASSERT_NE(sys_mount_setattr(open_tree_fd, "", AT_EMPTY_PATH, &attr, sizeof(attr)), 0);
1435 	ASSERT_EQ(close(attr.userns_fd), 0);
1436 	ASSERT_EQ(close(open_tree_fd), 0);
1437 
1438 	ASSERT_EQ(expected_uid_gid(-EBADF, "/tmp/B/b", 0, 0, 0), 0);
1439 	ASSERT_EQ(expected_uid_gid(-EBADF, "/tmp/B/BB/b", 0, 0, 0), 0);
1440 	ASSERT_EQ(expected_uid_gid(open_tree_fd, "B/b", 0, 0, 0), 0);
1441 	ASSERT_EQ(expected_uid_gid(open_tree_fd, "B/BB/b", 0, 0, 0), 0);
1442 }
1443 
1444 TEST_F(mount_setattr, mount_attr_nosymfollow)
1445 {
1446 	int fd;
1447 	unsigned int old_flags = 0, new_flags = 0, expected_flags = 0;
1448 	struct mount_attr attr = {
1449 		.attr_set	= MOUNT_ATTR_NOSYMFOLLOW,
1450 	};
1451 
1452 	if (!mount_setattr_supported())
1453 		SKIP(return, "mount_setattr syscall not supported");
1454 
1455 	fd = open(NOSYMFOLLOW_SYMLINK, O_RDWR | O_CLOEXEC);
1456 	ASSERT_GT(fd, 0);
1457 	ASSERT_EQ(close(fd), 0);
1458 
1459 	old_flags = read_mnt_flags("/mnt/A");
1460 	ASSERT_GT(old_flags, 0);
1461 
1462 	ASSERT_EQ(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)), 0);
1463 
1464 	expected_flags = old_flags;
1465 	expected_flags |= ST_NOSYMFOLLOW;
1466 
1467 	new_flags = read_mnt_flags("/mnt/A");
1468 	ASSERT_EQ(new_flags, expected_flags);
1469 
1470 	new_flags = read_mnt_flags("/mnt/A/AA");
1471 	ASSERT_EQ(new_flags, expected_flags);
1472 
1473 	new_flags = read_mnt_flags("/mnt/A/AA/B");
1474 	ASSERT_EQ(new_flags, expected_flags);
1475 
1476 	new_flags = read_mnt_flags("/mnt/A/AA/B/BB");
1477 	ASSERT_EQ(new_flags, expected_flags);
1478 
1479 	fd = open(NOSYMFOLLOW_SYMLINK, O_RDWR | O_CLOEXEC);
1480 	ASSERT_LT(fd, 0);
1481 	ASSERT_EQ(errno, ELOOP);
1482 
1483 	attr.attr_set &= ~MOUNT_ATTR_NOSYMFOLLOW;
1484 	attr.attr_clr |= MOUNT_ATTR_NOSYMFOLLOW;
1485 
1486 	ASSERT_EQ(sys_mount_setattr(-1, "/mnt/A", AT_RECURSIVE, &attr, sizeof(attr)), 0);
1487 
1488 	expected_flags &= ~ST_NOSYMFOLLOW;
1489 	new_flags = read_mnt_flags("/mnt/A");
1490 	ASSERT_EQ(new_flags, expected_flags);
1491 
1492 	new_flags = read_mnt_flags("/mnt/A/AA");
1493 	ASSERT_EQ(new_flags, expected_flags);
1494 
1495 	new_flags = read_mnt_flags("/mnt/A/AA/B");
1496 	ASSERT_EQ(new_flags, expected_flags);
1497 
1498 	new_flags = read_mnt_flags("/mnt/A/AA/B/BB");
1499 	ASSERT_EQ(new_flags, expected_flags);
1500 
1501 	fd = open(NOSYMFOLLOW_SYMLINK, O_RDWR | O_CLOEXEC);
1502 	ASSERT_GT(fd, 0);
1503 	ASSERT_EQ(close(fd), 0);
1504 }
1505 
1506 TEST_HARNESS_MAIN
1507