selftests: add memfd_create() + sealing tests

Some basic tests to verify sealing on memfds works as expected and
guarantees the advertised semantics.

Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
Acked-by: Hugh Dickins <hughd@google.com>
Cc: Michael Kerrisk <mtk.manpages@gmail.com>
Cc: Ryan Lortie <desrt@desrt.ca>
Cc: Lennart Poettering <lennart@poettering.net>
Cc: Daniel Mack <zonque@gmail.com>
Cc: Andy Lutomirski <luto@amacapital.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

4 files changed, 945 insertions, 0 deletions

diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
index d10f95ce2ea4..6fd2a4402069 100644
--- a/tools/testing/selftests/Makefile
+++ b/tools/testing/selftests/Makefile
@@ -2,6 +2,7 @@ TARGETS = breakpoints
 TARGETS += cpu-hotplug
 TARGETS += efivarfs
 TARGETS += kcmp
+TARGETS += memfd
 TARGETS += memory-hotplug
 TARGETS += mqueue
 TARGETS += net
diff --git a/tools/testing/selftests/memfd/.gitignore b/tools/testing/selftests/memfd/.gitignore
new file mode 100644
index 000000000000..bcc8ee20c710
--- /dev/null
+++ b/tools/testing/selftests/memfd/.gitignore
@@ -0,0 +1,2 @@
+memfd_test
+memfd-test-file
diff --git a/tools/testing/selftests/memfd/Makefile b/tools/testing/selftests/memfd/Makefile
new file mode 100644
index 000000000000..36653b903140
--- /dev/null
+++ b/tools/testing/selftests/memfd/Makefile
@@ -0,0 +1,29 @@
+uname_M := $(shell uname -m 2>/dev/null || echo not)
+ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/i386/)
+ifeq ($(ARCH),i386)
+        ARCH := X86
+endif
+ifeq ($(ARCH),x86_64)
+        ARCH := X86
+endif
+
+CFLAGS += -I../../../../arch/x86/include/generated/uapi/
+CFLAGS += -I../../../../arch/x86/include/uapi/
+CFLAGS += -I../../../../include/uapi/
+CFLAGS += -I../../../../include/
+
+all:
+ifeq ($(ARCH),X86)
+        gcc $(CFLAGS) memfd_test.c -o memfd_test
+else
+        echo "Not an x86 target, can't build memfd selftest"
+endif
+
+run_tests: all
+ifeq ($(ARCH),X86)
+        gcc $(CFLAGS) memfd_test.c -o memfd_test
+endif
+        @./memfd_test || echo "memfd_test: [FAIL]"
+
+clean:
+        $(RM) memfd_test
diff --git a/tools/testing/selftests/memfd/memfd_test.c b/tools/testing/selftests/memfd/memfd_test.c
new file mode 100644
index 000000000000..3634c909b1b0
--- /dev/null
+++ b/tools/testing/selftests/memfd/memfd_test.c
@@ -0,0 +1,913 @@
+#define _GNU_SOURCE
+#define __EXPORTED_HEADERS__
+
+#include <errno.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <linux/falloc.h>
+#include <linux/fcntl.h>
+#include <linux/memfd.h>
+#include <sched.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+
+#define MFD_DEF_SIZE 8192
+#define STACK_SIZE 65535
+
+static int sys_memfd_create(const char *name,
+                            unsigned int flags)
+{
+        return syscall(__NR_memfd_create, name, flags);
+}
+
+static int mfd_assert_new(const char *name, loff_t sz, unsigned int flags)
+{
+        int r, fd;
+
+        fd = sys_memfd_create(name, flags);
+        if (fd < 0) {
+                printf("memfd_create(\"%s\", %u) failed: %m\n",
+                       name, flags);
+                abort();
+        }
+
+        r = ftruncate(fd, sz);
+        if (r < 0) {
+                printf("ftruncate(%llu) failed: %m\n", (unsigned long long)sz);
+                abort();
+        }
+
+        return fd;
+}
+
+static void mfd_fail_new(const char *name, unsigned int flags)
+{
+        int r;
+
+        r = sys_memfd_create(name, flags);
+        if (r >= 0) {
+                printf("memfd_create(\"%s\", %u) succeeded, but failure expected\n",
+                       name, flags);
+                close(r);
+                abort();
+        }
+}
+
+static __u64 mfd_assert_get_seals(int fd)
+{
+        long r;
+
+        r = fcntl(fd, F_GET_SEALS);
+        if (r < 0) {
+                printf("GET_SEALS(%d) failed: %m\n", fd);
+                abort();
+        }
+
+        return r;
+}
+
+static void mfd_assert_has_seals(int fd, __u64 seals)
+{
+        __u64 s;
+
+        s = mfd_assert_get_seals(fd);
+        if (s != seals) {
+                printf("%llu != %llu = GET_SEALS(%d)\n",
+                       (unsigned long long)seals, (unsigned long long)s, fd);
+                abort();
+        }
+}
+
+static void mfd_assert_add_seals(int fd, __u64 seals)
+{
+        long r;
+        __u64 s;
+
+        s = mfd_assert_get_seals(fd);
+        r = fcntl(fd, F_ADD_SEALS, seals);
+        if (r < 0) {
+                printf("ADD_SEALS(%d, %llu -> %llu) failed: %m\n",
+                       fd, (unsigned long long)s, (unsigned long long)seals);
+                abort();
+        }
+}
+
+static void mfd_fail_add_seals(int fd, __u64 seals)
+{
+        long r;
+        __u64 s;
+
+        r = fcntl(fd, F_GET_SEALS);
+        if (r < 0)
+                s = 0;
+        else
+                s = r;
+
+        r = fcntl(fd, F_ADD_SEALS, seals);
+        if (r >= 0) {
+                printf("ADD_SEALS(%d, %llu -> %llu) didn't fail as expected\n",
+                       fd, (unsigned long long)s, (unsigned long long)seals);
+                abort();
+        }
+}
+
+static void mfd_assert_size(int fd, size_t size)
+{
+        struct stat st;
+        int r;
+
+        r = fstat(fd, &st);
+        if (r < 0) {
+                printf("fstat(%d) failed: %m\n", fd);
+                abort();
+        } else if (st.st_size != size) {
+                printf("wrong file size %lld, but expected %lld\n",
+                       (long long)st.st_size, (long long)size);
+                abort();
+        }
+}
+
+static int mfd_assert_dup(int fd)
+{
+        int r;