memfd: add tests

Testing for all the memfd features, namely support for CR of:
* the same fd shared by multiple processes
* the same file shared by multiple processes
* the memfd content
* file flags and fd flags
* mmaps, MAP_SHARED and MAP_PRIVATE
* seals, excluding F_SEAL_FUTURE_WRITE because this feature only exists
  in recent kernels (5.1 and up)
* inherited fd

Signed-off-by: Nicolas Viennot <Nicolas.Viennot@twosigma.com>

test/inhfd/memfd.py

@@ -0,0 +1,28 @@
+import os
+import ctypes
+libc = ctypes.CDLL(None)
+
+
+def memfd_create(name, flags):
+    return libc.memfd_create(name.encode('utf8'), flags)
+
+
+def create_fds():
+    def create_memfd_pair(name):
+        fd = memfd_create(name, 0)
+        fw = open('/proc/self/fd/{}'.format(fd), 'wb')
+        fr = open('/proc/self/fd/{}'.format(fd), 'rb')
+        os.close(fd)
+        return (fw, fr)
+
+    return [create_memfd_pair("name{}".format(i)) for i in range(10)]
+
+
+def filename(f):
+    name = os.readlink('/proc/self/fd/{}'.format(f.fileno()))
+    name = name.replace(' (deleted)', '')
+    return name
+
+
+def dump_opts(sockf):
+    return []

test/inhfd/memfd.py.checkskip

@@ -0,0 +1,7 @@
+#!/usr/bin/env python
+
+import ctypes
+libc = ctypes.CDLL(None)
+
+# libc may not have memfd_create (e.g., centos on travis)
+libc.memfd_create("test".encode('utf8'), 0)

test/inhfd/memfd.py.desc

@@ -0,0 +1 @@
+{ 'flavor': 'h' }

test/zdtm/static/Makefile

@@ -220,6 +220,10 @@ TST_NOFILE	:=				\
 		child_subreaper			\
 		child_subreaper_existing_child	\
 		child_subreaper_and_reparent	\
+		memfd00				\
+		memfd01				\
+		memfd02				\
+		memfd03				\
 #		jobctl00			\
 
 ifneq ($(ARCH),arm)

test/zdtm/static/memfd00.c

@@ -0,0 +1,103 @@
+#include <fcntl.h>
+#include <linux/memfd.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <sys/vfs.h>
+#include <unistd.h>
+
+#include "zdtmtst.h"
+
+const char *test_doc	= "memfd file descriptor";
+const char *test_author	= "Nicolas Viennot <Nicolas.Viennot@twosigma.com>";
+
+#define err(exitcode, msg, ...) ({ pr_perror(msg, ##__VA_ARGS__); exit(exitcode); })
+
+static int _memfd_create(const char *name, unsigned int flags)
+{
+	return syscall(SYS_memfd_create, name, flags);
+}
+
+int main(int argc, char *argv[])
+{
+	int fd, fl_flags1, fl_flags2, fd_flags1, fd_flags2;
+	struct statfs statfs1, statfs2;
+	off_t pos1, pos2;
+	char buf[5];
+
+	test_init(argc, argv);
+
+	fd = _memfd_create("somename", MFD_CLOEXEC);
+	if (fd < 0)
+		err(1, "Can't call memfd_create");
+
+	if (fcntl(fd, F_SETFL, O_APPEND) < 0)
+		err(1, "Can't get fl flags");
+
+	if ((fl_flags1 = fcntl(fd, F_GETFL)) == -1)
+		err(1, "Can't get fl flags");
+
+	if ((fd_flags1 = fcntl(fd, F_GETFD)) == -1)
+		err(1, "Can't get fd flags");
+
+	if (fstatfs(fd, &statfs1) < 0)
+		err(1, "statfs issue");
+
+	if (write(fd, "hello", 5) != 5)
+		err(1, "write error");
+
+	pos1 = 3;
+	if (lseek(fd, pos1, SEEK_SET) < 0)
+		err(1, "seek error");
+
+	test_daemon();
+	test_waitsig();
+
+	if ((fl_flags2 = fcntl(fd, F_GETFL)) == -1)
+		err(1, "Can't get fl flags");
+
+	if (fl_flags1 != fl_flags2) {
+		fail("fl flags differs");
+		return 1;
+	}
+
+	if ((fd_flags2 = fcntl(fd, F_GETFD)) == -1)
+		err(1, "Can't get fd flags");
+
+	if (fd_flags1 != fd_flags2) {
+		fail("fd flags differs");
+		return 1;
+	}
+
+	if (fstatfs(fd, &statfs2) < 0)
+		err(1, "statfs issue");
+
+	if (statfs1.f_type != statfs2.f_type) {
+		fail("statfs.f_type differs");
+		return 1;
+	}
+
+	pos2 = lseek(fd, 0, SEEK_CUR);
+	if (pos1 != pos2) {
+		fail("position differs");
+		return 1;
+	}
+
+	if (pread(fd, buf, sizeof(buf), 0) != sizeof(buf)) {
+		fail("read problem");
+		return 1;
+	}
+
+	if (memcmp(buf, "hello", sizeof(buf))) {
+		fail("content mismatch");
+		return 1;
+	}
+
+	pass();
+
+	return 0;
+}

test/zdtm/static/memfd01.c

@@ -0,0 +1,114 @@
+#include <fcntl.h>
+#include <linux/memfd.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/vfs.h>
+#include <unistd.h>
+
+#include "zdtmtst.h"
+
+const char *test_doc	= "memfd with different file pointer";
+const char *test_author	= "Nicolas Viennot <Nicolas.Viennot@twosigma.com>";
+
+#define err(exitcode, msg, ...) ({ pr_perror(msg, ##__VA_ARGS__); exit(exitcode); })
+
+static int _memfd_create(const char *name, unsigned int flags)
+{
+	return syscall(SYS_memfd_create, name, flags);
+}
+
+int main(int argc, char *argv[])
+{
+	pid_t pid, pid_child;
+	int fd, ret, status;
+	task_waiter_t t;
+
+	test_init(argc, argv);
+
+	task_waiter_init(&t);
+
+	fd = _memfd_create("somename", MFD_CLOEXEC);
+	if (fd < 0)
+		err(1, "Can't call memfd_create");
+
+	pid = getpid();
+
+	pid_child = fork();
+	if (pid_child < 0)
+		err(1, "Can't fork");
+
+	if (!pid_child) {
+		char fdpath[100];
+		char buf[1];
+		int fl_flags1, fl_flags2, fd_flags1, fd_flags2;
+
+		snprintf(fdpath, sizeof(fdpath), "/proc/%d/fd/%d", pid, fd);
+		/*
+		 * We pass O_LARGEFILE because in compat mode, our file
+		 * descriptor does not get O_LARGEFILE automatically, but the
+		 * restorer using non-compat open() is forced O_LARGEFILE.
+		 * This creates a flag difference, which we don't want to deal
+		 * with this at the moment.
+		 */
+		fd = open(fdpath, O_RDONLY | O_LARGEFILE);
+		if (fd < 0)
+			err(1, "Can't open memfd via proc");
+
+		if ((fl_flags1 = fcntl(fd, F_GETFL)) == -1)
+			err(1, "Can't get fl flags");
+
+		if ((fd_flags1 = fcntl(fd, F_GETFD)) == -1)
+			err(1, "Can't get fd flags");
+
+		task_waiter_complete(&t, 1);
+		// checkpoint-restore happens here
+		task_waiter_wait4(&t, 2);
+
+		if (read(fd, buf, 1) != 1)
+			err(1, "Can't read");
+
+		if ((fl_flags2 = fcntl(fd, F_GETFL)) == -1)
+			err(1, "Can't get fl flags");
+
+		if (fl_flags1 != fl_flags2)
+			err(1, "fl flags differs");
+
+		if ((fd_flags2 = fcntl(fd, F_GETFD)) == -1)
+			err(1, "Can't get fd flags");
+
+		if (fd_flags1 != fd_flags2)
+			err(1, "fd flags differs");
+
+		if (buf[0] != 'x')
+			err(1, "Read incorrect");
+
+		return 0;
+	}
+
+	task_waiter_wait4(&t, 1);
+
+	test_daemon();
+	test_waitsig();
+
+	if (write(fd, "x", 1) != 1)
+		err(1, "Can't write");
+
+	task_waiter_complete(&t, 2);
+
+	ret = wait(&status);
+	if (ret == -1 || !WIFEXITED(status) || WEXITSTATUS(status)) {
+		kill(pid, SIGKILL);
+		fail("child had issue");
+		return 1;
+	}
+
+	pass();
+
+	return 0;
+}

test/zdtm/static/memfd02.c

@@ -0,0 +1,87 @@
+#include <fcntl.h>
+#include <linux/memfd.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <sys/vfs.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+#include "zdtmtst.h"
+
+const char *test_doc	= "memfd mmap";
+const char *test_author	= "Nicolas Viennot <Nicolas.Viennot@twosigma.com>";
+
+#define err(exitcode, msg, ...) ({ pr_perror(msg, ##__VA_ARGS__); exit(exitcode); })
+
+static int _memfd_create(const char *name, unsigned int flags)
+{
+	return syscall(SYS_memfd_create, name, flags);
+}
+
+int main(int argc, char *argv[])
+{
+#define LEN 6
+	int fd;
+	void *addr_shared, *addr_private;
+	char buf[LEN];
+
+	test_init(argc, argv);
+
+	fd = _memfd_create("somename", MFD_CLOEXEC);
+	if (fd < 0)
+		err(1, "Can't call memfd_create");
+
+	if (ftruncate(fd, LEN) < 0)
+		err(1, "Can't truncate");
+
+	addr_shared = mmap(NULL, LEN, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+	if (addr_shared == MAP_FAILED)
+		err(1, "Can't mmap");
+
+	write(fd, "write1", LEN);
+
+	addr_private = mmap(NULL, LEN, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
+	if (addr_private == MAP_FAILED)
+		err(1, "Can't mmap");
+
+	test_daemon();
+	test_waitsig();
+
+	if (memcmp(addr_shared, "write1", LEN)) {
+		fail("content mismatch (shared)");
+		return 1;
+	}
+
+	strcpy(addr_shared, "write2");
+
+	if (pread(fd, buf, LEN, 0) != LEN) {
+		fail("read problem");
+		return 1;
+	}
+
+	if (memcmp(buf, "write2", LEN)) {
+		fail("content mismatch (shared)");
+		return 1;
+	}
+
+	if (memcmp(addr_private, "write2", LEN)) {
+		fail("content mismatch (private)");
+		return 1;
+	}
+
+	strcpy(addr_private, "write3");
+
+	if (memcmp(addr_shared, "write2", LEN)) {
+		fail("content mismatch (shared)");
+		return 1;
+	}
+
+	pass();
+
+	return 0;
+}

test/zdtm/static/memfd03.c

@@ -0,0 +1,97 @@
+#include <fcntl.h>
+#include <linux/memfd.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <sys/vfs.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+#include "zdtmtst.h"
+
+const char *test_doc	= "memfd seals";
+const char *test_author	= "Nicolas Viennot <Nicolas.Viennot@twosigma.com>";
+
+#define err(exitcode, msg, ...) ({ pr_perror(msg, ##__VA_ARGS__); exit(exitcode); })
+
+static int _memfd_create(const char *name, unsigned int flags)
+{
+	return syscall(SYS_memfd_create, name, flags);
+}
+
+
+#ifndef F_LINUX_SPECIFIC_BASE
+# define F_LINUX_SPECIFIC_BASE	1024
+#endif
+
+#ifndef F_ADD_SEALS
+  #define F_ADD_SEALS (F_LINUX_SPECIFIC_BASE + 9)
+#endif
+
+#ifndef F_GET_SEALS
+  #define F_GET_SEALS (F_LINUX_SPECIFIC_BASE + 10)
+#endif
+
+
+#ifndef F_SEAL_SEAL
+#define F_SEAL_SEAL	0x0001	/* prevent further seals from being set */
+#define F_SEAL_SHRINK	0x0002	/* prevent file from shrinking */
+#define F_SEAL_GROW	0x0004	/* prevent file from growing */
+#define F_SEAL_WRITE	0x0008	/* prevent writes */
+#endif
+
+int main(int argc, char *argv[])
+{
+#define LEN 5
+	int fd, fd2;
+	void *addr_write, *addr_read;
+	char fdpath[100];
+
+	test_init(argc, argv);
+
+	fd = _memfd_create("somename", MFD_ALLOW_SEALING | MFD_CLOEXEC);
+	if (fd < 0)
+		err(1, "Can't call memfd_create");
+
+	if (write(fd, "hello", LEN) != LEN)
+		err(1, "Can't write");
+
+	if (fcntl(fd, F_ADD_SEALS, F_SEAL_WRITE) < 0)
+		err(1, "Can't add seals");
+
+	test_daemon();
+	test_waitsig();
+
+	snprintf(fdpath, sizeof(fdpath), "/proc/self/fd/%d", fd);
+	fd2 = open(fdpath, O_RDWR);
+	if (fd2 < 0)
+		err(1, "Can't open memfd via proc");
+
+	if (fcntl(fd, F_GET_SEALS) != F_SEAL_WRITE) {
+		fail("Seals are different");
+		return 1;
+	}
+
+	addr_write = mmap(NULL, LEN, PROT_WRITE, MAP_SHARED, fd2, 0);
+	if (addr_write != MAP_FAILED) {
+		fail("Should not be able to get write access");
+		return 1;
+	}
+
+	addr_read = mmap(NULL, 1, PROT_READ, MAP_PRIVATE, fd2, 0);
+	if (addr_read == MAP_FAILED)
+		err(1, "Can't mmap");
+
+	if (memcmp(addr_read, "hello", LEN)) {
+		fail("Mapping has bad data");
+		return 1;
+	}
+
+	pass();
+
+	return 0;
+}