Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit fa0bad3f28a7c4a192769a128ede584c49a7e12f

Authored by Eric W. Biederman 2014-08-23 05:39:03 +0800

Committed by Greg Kroah-Hartman 2015-01-09 02:30:24 +0800

mnt: Update unprivileged remount test

commit 4a44a19b470a886997d6647a77bb3e38dcbfa8c5 upstream.

- MNT_NODEV should be irrelevant except when reading back mount flags,
  no longer specify MNT_NODEV on remount.

- Test MNT_NODEV on devpts where it is meaningful even for unprivileged mounts.

- Add a test to verify that remount of a prexisting mount with the same flags
  is allowed and does not change those flags.

- Cleanup up the definitions of MS_REC, MS_RELATIME, MS_STRICTATIME that are used
  when the code is built in an environment without them.

- Correct the test error messages when tests fail.  There were not 5 tests
  that tested MS_RELATIME.

Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

Showing 1 changed file with 142 additions and 30 deletions Inline Diff

tools/testing/selftests/mount/unprivileged-remount-test.c

tools/testing/selftests/mount/unprivileged-remount-test.c

Diff comments View file @ fa0bad3

 #define _GNU_SOURCE
 #include <sched.h>
 #include <stdio.h>
 #include <errno.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/mount.h>
 #include <sys/wait.h>
+#include <sys/vfs.h>
+#include <sys/statvfs.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <grp.h>
 #include <stdbool.h>
 #include <stdarg.h>
 #ifndef CLONE_NEWNS
 # define CLONE_NEWNS 0x00020000
 #endif
 #ifndef CLONE_NEWUTS
 # define CLONE_NEWUTS 0x04000000
 #endif
 #ifndef CLONE_NEWIPC
 # define CLONE_NEWIPC 0x08000000
 #endif
 #ifndef CLONE_NEWNET
 # define CLONE_NEWNET 0x40000000
 #endif
 #ifndef CLONE_NEWUSER
 # define CLONE_NEWUSER 0x10000000
 #endif
 #ifndef CLONE_NEWPID
 # define CLONE_NEWPID 0x20000000
 #endif
+#ifndef MS_REC
+# define MS_REC 16384
+#endif
 #ifndef MS_RELATIME
-#define MS_RELATIME (1 << 21)
+# define MS_RELATIME (1 << 21)
 #endif
 #ifndef MS_STRICTATIME
-#define MS_STRICTATIME (1 << 24)
+# define MS_STRICTATIME (1 << 24)
 #endif
 static void die(char *fmt, ...)
 {
 	va_list ap;
 	va_start(ap, fmt);
 	vfprintf(stderr, fmt, ap);
 	va_end(ap);
 	exit(EXIT_FAILURE);
 }
 static void write_file(char *filename, char *fmt, ...)
 {
 	char buf[4096];
 	int fd;
 	ssize_t written;
 	int buf_len;
 	va_list ap;
 	va_start(ap, fmt);
 	buf_len = vsnprintf(buf, sizeof(buf), fmt, ap);
 	va_end(ap);
 	if (buf_len < 0) {
 		die("vsnprintf failed: %s\n",
 		    strerror(errno));
 	}
 	if (buf_len >= sizeof(buf)) {
 		die("vsnprintf output truncated\n");
 	}
 	fd = open(filename, O_WRONLY);
 	if (fd < 0) {
 		die("open of %s failed: %s\n",
 		    filename, strerror(errno));
 	}
 	written = write(fd, buf, buf_len);
 	if (written != buf_len) {
 		if (written >= 0) {
 			die("short write to %s\n", filename);
 		} else {
 			die("write to %s failed: %s\n",
 				filename, strerror(errno));
 		}
 	}
 	if (close(fd) != 0) {
 		die("close of %s failed: %s\n",
 			filename, strerror(errno));
 	}
 }
+static int read_mnt_flags(const char *path)
+{
+	int ret;
+	struct statvfs stat;
+	int mnt_flags;
+	ret = statvfs(path, &stat);
+	if (ret != 0) {
+		die("statvfs of %s failed: %s\n",
+			path, strerror(errno));
+	}
+	if (stat.f_flag & ~(ST_RDONLY | ST_NOSUID | ST_NODEV | \
+			ST_NOEXEC | ST_NOATIME | ST_NODIRATIME | ST_RELATIME | \
+			ST_SYNCHRONOUS | ST_MANDLOCK)) {
+		die("Unrecognized mount flags\n");
+	}
+	mnt_flags = 0;
+	if (stat.f_flag & ST_RDONLY)
+		mnt_flags |= MS_RDONLY;
+	if (stat.f_flag & ST_NOSUID)
+		mnt_flags |= MS_NOSUID;
+	if (stat.f_flag & ST_NODEV)
+		mnt_flags |= MS_NODEV;
+	if (stat.f_flag & ST_NOEXEC)
+		mnt_flags |= MS_NOEXEC;
+	if (stat.f_flag & ST_NOATIME)
+		mnt_flags |= MS_NOATIME;
+	if (stat.f_flag & ST_NODIRATIME)
+		mnt_flags |= MS_NODIRATIME;
+	if (stat.f_flag & ST_RELATIME)
+		mnt_flags |= MS_RELATIME;
+	if (stat.f_flag & ST_SYNCHRONOUS)
+		mnt_flags |= MS_SYNCHRONOUS;
+	if (stat.f_flag & ST_MANDLOCK)
+		mnt_flags |= ST_MANDLOCK;
+	return mnt_flags;
+}
 static void create_and_enter_userns(void)
 {
 	uid_t uid;
 	gid_t gid;
 	uid = getuid();
 	gid = getgid();
 	if (unshare(CLONE_NEWUSER) !=0) {
 		die("unshare(CLONE_NEWUSER) failed: %s\n",
 			strerror(errno));
 	}
 	write_file("/proc/self/uid_map", "0 %d 1", uid);
 	write_file("/proc/self/gid_map", "0 %d 1", gid);
 	if (setgroups(0, NULL) != 0) {
 		die("setgroups failed: %s\n",
 			strerror(errno));
 	}
 	if (setgid(0) != 0) {
 		die ("setgid(0) failed %s\n",
 			strerror(errno));
 	}
 	if (setuid(0) != 0) {
 		die("setuid(0) failed %s\n",
 			strerror(errno));
 	}
 }
 static
-bool test_unpriv_remount(int mount_flags, int remount_flags, int invalid_flags)
+bool test_unpriv_remount(const char *fstype, const char *mount_options,
+			 int mount_flags, int remount_flags, int invalid_flags)
 {
 	pid_t child;
 	child = fork();
 	if (child == -1) {
 		die("fork failed: %s\n",
 			strerror(errno));
 	}
 	if (child != 0) { /* parent */
 		pid_t pid;
 		int status;
 		pid = waitpid(child, &status, 0);
 		if (pid == -1) {
 			die("waitpid failed: %s\n",
 				strerror(errno));
 		}
 		if (pid != child) {
 			die("waited for %d got %d\n",
 				child, pid);
 		}
 		if (!WIFEXITED(status)) {
 			die("child did not terminate cleanly\n");
 		}
 		return WEXITSTATUS(status) == EXIT_SUCCESS ? true : false;
 	}
 	create_and_enter_userns();
 	if (unshare(CLONE_NEWNS) != 0) {
 		die("unshare(CLONE_NEWNS) failed: %s\n",
 			strerror(errno));
 	}
-	if (mount("testing", "/tmp", "ramfs", mount_flags, NULL) != 0) {
+	if (mount("testing", "/tmp", fstype, mount_flags, mount_options) != 0) {
-		die("mount of /tmp failed: %s\n",
+		die("mount of %s with options '%s' on /tmp failed: %s\n",
-			strerror(errno));
+		    fstype,
+		    mount_options? mount_options : "",
+		    strerror(errno));
 	}
 	create_and_enter_userns();
 	if (unshare(CLONE_NEWNS) != 0) {
 		die("unshare(CLONE_NEWNS) failed: %s\n",
 			strerror(errno));
 	}
 	if (mount("/tmp", "/tmp", "none",
 		  MS_REMOUNT | MS_BIND | remount_flags, NULL) != 0) {
 		/* system("cat /proc/self/mounts"); */
 		die("remount of /tmp failed: %s\n",
 		    strerror(errno));
 	}
 	if (mount("/tmp", "/tmp", "none",
 		  MS_REMOUNT | MS_BIND | invalid_flags, NULL) == 0) {
 		/* system("cat /proc/self/mounts"); */
 		die("remount of /tmp with invalid flags "
 		    "succeeded unexpectedly\n");
 	}
 	exit(EXIT_SUCCESS);
 }
 static bool test_unpriv_remount_simple(int mount_flags)
 {
-	return test_unpriv_remount(mount_flags, mount_flags, 0);
+	return test_unpriv_remount("ramfs", NULL, mount_flags, mount_flags, 0);
 }
 static bool test_unpriv_remount_atime(int mount_flags, int invalid_flags)
 {
-	return test_unpriv_remount(mount_flags, mount_flags, invalid_flags);
+	return test_unpriv_remount("ramfs", NULL, mount_flags, mount_flags,
+				   invalid_flags);
 }
+static bool test_priv_mount_unpriv_remount(void)
+{
+	pid_t child;
+	int ret;
+	const char *orig_path = "/dev";
+	const char *dest_path = "/tmp";
+	int orig_mnt_flags, remount_mnt_flags;
+	child = fork();
+	if (child == -1) {
+		die("fork failed: %s\n",
+			strerror(errno));
+	}
+	if (child != 0) { /* parent */
+		pid_t pid;
+		int status;
+		pid = waitpid(child, &status, 0);
+		if (pid == -1) {
+			die("waitpid failed: %s\n",
+				strerror(errno));
+		}
+		if (pid != child) {
+			die("waited for %d got %d\n",
+				child, pid);
+		}
+		if (!WIFEXITED(status)) {
+			die("child did not terminate cleanly\n");
+		}
+		return WEXITSTATUS(status) == EXIT_SUCCESS ? true : false;
+	}
+	orig_mnt_flags = read_mnt_flags(orig_path);
+	create_and_enter_userns();
+	ret = unshare(CLONE_NEWNS);
+	if (ret != 0) {
+		die("unshare(CLONE_NEWNS) failed: %s\n",
+			strerror(errno));
+	}
+	ret = mount(orig_path, dest_path, "bind", MS_BIND | MS_REC, NULL);
+	if (ret != 0) {
+		die("recursive bind mount of %s onto %s failed: %s\n",
+			orig_path, dest_path, strerror(errno));
+	}
+	ret = mount(dest_path, dest_path, "none",
+		    MS_REMOUNT | MS_BIND | orig_mnt_flags , NULL);
+	if (ret != 0) {
+		/* system("cat /proc/self/mounts"); */
+		die("remount of /tmp failed: %s\n",
+		    strerror(errno));
+	}
+	remount_mnt_flags = read_mnt_flags(dest_path);
+	if (orig_mnt_flags != remount_mnt_flags) {
+		die("Mount flags unexpectedly changed during remount of %s originally mounted on %s\n",
+			dest_path, orig_path);
+	}
+	exit(EXIT_SUCCESS);
+}
 int main(int argc, char **argv)
 {
-	if (!test_unpriv_remount_simple(MS_RDONLY|MS_NODEV)) {
+	if (!test_unpriv_remount_simple(MS_RDONLY)) {
 		die("MS_RDONLY malfunctions\n");
 	}
-	if (!test_unpriv_remount_simple(MS_NODEV)) {
+	if (!test_unpriv_remount("devpts", "newinstance", MS_NODEV, MS_NODEV, 0)) {
 		die("MS_NODEV malfunctions\n");
 	}
-	if (!test_unpriv_remount_simple(MS_NOSUID|MS_NODEV)) {
+	if (!test_unpriv_remount_simple(MS_NOSUID)) {
 		die("MS_NOSUID malfunctions\n");
 	}
-	if (!test_unpriv_remount_simple(MS_NOEXEC|MS_NODEV)) {
+	if (!test_unpriv_remount_simple(MS_NOEXEC)) {
 		die("MS_NOEXEC malfunctions\n");
 	}
-	if (!test_unpriv_remount_atime(MS_RELATIME|MS_NODEV,
+	if (!test_unpriv_remount_atime(MS_RELATIME,
-				       MS_NOATIME|MS_NODEV))
+				       MS_NOATIME))
 	{
 		die("MS_RELATIME malfunctions\n");
 	}
-	if (!test_unpriv_remount_atime(MS_STRICTATIME|MS_NODEV,
+	if (!test_unpriv_remount_atime(MS_STRICTATIME,
-				       MS_NOATIME|MS_NODEV))
+				       MS_NOATIME))
 	{
 		die("MS_STRICTATIME malfunctions\n");
 	}
-	if (!test_unpriv_remount_atime(MS_NOATIME|MS_NODEV,
+	if (!test_unpriv_remount_atime(MS_NOATIME,
-				       MS_STRICTATIME|MS_NODEV))
+				       MS_STRICTATIME))
 	{
-		die("MS_RELATIME malfunctions\n");
+		die("MS_NOATIME malfunctions\n");
 	}
-	if (!test_unpriv_remount_atime(MS_RELATIME|MS_NODIRATIME|MS_NODEV,
+	if (!test_unpriv_remount_atime(MS_RELATIME|MS_NODIRATIME,
-				       MS_NOATIME|MS_NODEV))
+				       MS_NOATIME))
 	{
-		die("MS_RELATIME malfunctions\n");
+		die("MS_RELATIME|MS_NODIRATIME malfunctions\n");
 	}
-	if (!test_unpriv_remount_atime(MS_STRICTATIME|MS_NODIRATIME|MS_NODEV,
+	if (!test_unpriv_remount_atime(MS_STRICTATIME|MS_NODIRATIME,
-				       MS_NOATIME|MS_NODEV))
+				       MS_NOATIME))
 	{
-		die("MS_RELATIME malfunctions\n");
+		die("MS_STRICTATIME|MS_NODIRATIME malfunctions\n");
 	}
-	if (!test_unpriv_remount_atime(MS_NOATIME|MS_NODIRATIME|MS_NODEV,
+	if (!test_unpriv_remount_atime(MS_NOATIME|MS_NODIRATIME,
-				       MS_STRICTATIME|MS_NODEV))
+				       MS_STRICTATIME))
 	{
-		die("MS_RELATIME malfunctions\n");
+		die("MS_NOATIME|MS_DIRATIME malfunctions\n");
 	}
-	if (!test_unpriv_remount(MS_STRICTATIME|MS_NODEV, MS_NODEV,
+	if (!test_unpriv_remount("ramfs", NULL, MS_STRICTATIME, 0, MS_NOATIME))
-				 MS_NOATIME|MS_NODEV))
 	{
 		die("Default atime malfunctions\n");
+	}
+	if (!test_priv_mount_unpriv_remount()) {
+		die("Mount flags unexpectedly changed after remount\n");
 	}
 	return EXIT_SUCCESS;
 }