Add flag as THP allocation hint for memfd_restricted() syscall

RFC PATCH In review Ackerley Tng 2 participants 5 messages Feb 18, 2023 – Feb 23, 2023

Subsystems (7)

Memory management Documentation VFS KVM +3 more subsystems

lore

Share & tools

lore

Ackerley Tng

author

2023-02-18 00:43 UTC #0 lore raw

cover Add flag as THP allocation hint for memfd_restricted() syscall

Hello,

This patchset builds upon the memfd_restricted() system call that has been discussed in the ‘KVM: mm: fd-based approach for supporting KVM’ patch series, at
https://lore.kernel.org/lkml/[email protected]/T/#m7e944d7892afdd1d62a03a287bd488c56e377b0c

The tree can be found at:
https://github.com/googleprodkernel/linux-cc/tree/restrictedmem-rmfd-hugepage

Following the RFC to provide mount for memfd_restricted() syscall at
https://lore.kernel.org/lkml/[email protected]/T/#u,
this patchset adds the RMFD_HUGEPAGE flag to the memfd_restricted() syscall, which will hint the kernel to use Transparent HugePages to back restrictedmem pages.

This supplements the interface proposed earlier, which requires the creation of a tmpfs mount to be passed to memfd_restricted(), with a more direct per-file hint.

Dependencies:

+ Sean’s iteration of the ‘KVM: mm: fd-based approach for supporting KVM’ patch series at
https://github.com/sean-jc/linux/tree/x86/upm_base_support
+ Proposed fix for restrictedmem_getattr() as mentioned on the mailing list at
https://lore.kernel.org/lkml/[email protected]/
+ Hugh’s patch:
https://lore.kernel.org/lkml/[email protected]/,
which provides functionality in shmem that reads the VM_HUGEPAGE flag in key functions shmem_is_huge() and shmem_get_inode()

Future work/TODOs:
+ man page for the memfd_restricted() syscall
+ Support for per file NUMA binding hints

Ackerley Tng (2):
mm: restrictedmem: Add flag as THP allocation hint for
memfd_restricted() syscall
selftests: restrictedmem: Add selftest for RMFD_HUGEPAGE

 include/uapi/linux/restrictedmem.h            |  1 +
 mm/restrictedmem.c                            | 27 ++++++++++++-------
 .../restrictedmem_hugepage_test.c             | 25 +++++++++++++++++
 3 files changed, 43 insertions(+), 10 deletions(-)

--
2.39.2.637.g21b0678d19-goog

Ackerley Tng

author

2023-02-18 00:43 UTC #1 lore raw

RFC PATCH 1/2 mm: restrictedmem: Add flag as THP allocation hint for memfd_restricted() syscall

Allow userspace to hint the kernel to use Transparent HugePages to back restricted memory on a per-file basis.

Signed-off-by Ackerley Tng <[email protected]>

---
 include/uapi/linux/restrictedmem.h |  1 +
 mm/restrictedmem.c                 | 27 +++++++++++++++++----------
 2 files changed, 18 insertions(+), 10 deletions(-)

include/uapi/linux/restrictedmem.h +1 -0

index 9f108dd1ac4c..f671ccbb43bc 100644
@@ -4,5 +4,6 @@
 
 /* flags for memfd_restricted */
 #define RMFD_TMPFILE		0x0001U
+#define RMFD_HUGEPAGE		0x0002U
 
 #endif /* _UAPI_LINUX_RESTRICTEDMEM_H */

mm/restrictedmem.c +17 ~~-10~~

index 97f3e2159e8b..87c829960b31 100644
@@ -190,19 +190,25 @@ static struct file *restrictedmem_file_create(struct file *memfd)
 	return file;
 }
 
-static int restrictedmem_create(struct vfsmount *mount)
+static int restrictedmem_create(unsigned int flags, struct vfsmount *mount)
 {
 	struct file *file, *restricted_file;
 	int fd, err;
+	unsigned long shmem_setup_flags = VM_NORESERVE;
 
 	fd = get_unused_fd_flags(0);
 	if (fd < 0)
 		return fd;
 
-	if (mount)
-		file = shmem_file_setup_with_mnt(mount, "memfd:restrictedmem", 0, VM_NORESERVE);
-	else
-		file = shmem_file_setup("memfd:restrictedmem", 0, VM_NORESERVE);
+	if (flags & RMFD_HUGEPAGE)
+		shmem_setup_flags |= VM_HUGEPAGE;
+
+	if (mount) {
+		file = shmem_file_setup_with_mnt(mount, "memfd:restrictedmem",
+						 0, shmem_setup_flags);
+	} else {
+		file = shmem_file_setup("memfd:restrictedmem", 0, shmem_setup_flags);
+	}
 
 	if (IS_ERR(file)) {
 		err = PTR_ERR(file);

@@ -230,7 +236,8 @@ static bool is_shmem_mount(struct vfsmount *mnt)
 	return mnt->mnt_sb->s_magic == TMPFS_MAGIC;
 }
 
-static int restrictedmem_create_from_path(const char __user *mount_path)
+static int restrictedmem_create_from_path(unsigned int flags,
+					  const char __user *mount_path)
 {
 	int ret;
 	struct path path;

@@ -250,7 +257,7 @@ static int restrictedmem_create_from_path(const char __user *mount_path)
 	if (unlikely(ret))
 		goto out;
 
-	ret = restrictedmem_create(path.mnt);
+	ret = restrictedmem_create(flags, path.mnt);
 
 	mnt_drop_write(path.mnt);
 out:

@@ -261,16 +268,16 @@ static int restrictedmem_create_from_path(const char __user *mount_path)
 
 SYSCALL_DEFINE2(memfd_restricted, unsigned int, flags, const char __user *, mount_path)
 {
-	if (flags & ~RMFD_TMPFILE)
+	if (flags & ~(RMFD_TMPFILE | RMFD_HUGEPAGE))
 		return -EINVAL;
 
 	if (flags == RMFD_TMPFILE) {
 		if (!mount_path)
 			return -EINVAL;
 
-		return restrictedmem_create_from_path(mount_path);
+		return restrictedmem_create_from_path(flags, mount_path);
 	} else {
-		return restrictedmem_create(NULL);
+		return restrictedmem_create(flags, NULL);
 	}
 }

Signature · 1 line

2.39.2.637.g21b0678d19-goog

Ackerley Tng

author

2023-02-18 00:43 UTC #2 lore raw

RFC PATCH 2/2 selftests: restrictedmem: Add selftest for RMFD_HUGEPAGE

In reply to Ackerley Tng

Tests that when RMFD_HUGEPAGE is specified, restrictedmem will be backed by Transparent HugePages.

Signed-off-by Ackerley Tng <[email protected]>

---
 .../restrictedmem_hugepage_test.c             | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

tools/testing/selftests/restrictedmem/restrictedmem_hugepage_test.c +25 -0

index 0d9cf2ced754..75283d68696f 100644
@@ -180,6 +180,31 @@ TEST_F(reset_shmem_enabled, restrictedmem_fstat_shmem_enabled_always)
 	close(mfd);
 }
 
+TEST(restrictedmem_invalid_flags)
+{
+	int mfd = memfd_restricted(99, NULL);
+
+	ASSERT_EQ(-1, mfd);
+	ASSERT_EQ(EINVAL, errno);
+}
+
+TEST_F(reset_shmem_enabled, restrictedmem_rmfd_hugepage)
+{
+	int mfd = -1;
+	struct stat stat;
+
+	ASSERT_EQ(0, set_shmem_thp_policy("never"));
+
+	mfd = memfd_restricted(RMFD_HUGEPAGE, NULL);
+	ASSERT_NE(-1, mfd);
+
+	ASSERT_EQ(0, fstat(mfd, &stat));
+
+	ASSERT_EQ(stat.st_blksize, get_hpage_pmd_size());
+
+	close(mfd);
+}
+
 TEST(restrictedmem_tmpfile_no_mount_path)
 {
 	int mfd = memfd_restricted(RMFD_TMPFILE, NULL);

Signature · 1 line

2.39.2.637.g21b0678d19-goog

Yuan Yao

2023-02-20 03:04 UTC #3 lore raw

In reply to Ackerley Tng

Quoted 22 lines · Ackerley Tng

Hello,
This patchset builds upon the memfd_restricted() system call that has been discussed in the ‘KVM: mm: fd-based approach for supporting KVM’ patch series, at
https://lore.kernel.org/lkml/[email protected]/T/#m7e944d7892afdd1d62a03a287bd488c56e377b0c
The tree can be found at:
https://github.com/googleprodkernel/linux-cc/tree/restrictedmem-rmfd-hugepage
Following the RFC to provide mount for memfd_restricted() syscall at
https://lore.kernel.org/lkml/[email protected]/T/#u,
this patchset adds the RMFD_HUGEPAGE flag to the memfd_restricted() syscall, which will hint the kernel to use Transparent HugePages to back restrictedmem pages.
This supplements the interface proposed earlier, which requires the creation of a tmpfs mount to be passed to memfd_restricted(), with a more direct per-file hint.
Dependencies:

Quoted 10 lines

+ Sean’s iteration of the ‘KVM: mm: fd-based approach for supporting KVM’ patch series at
https://github.com/sean-jc/linux/tree/x86/upm_base_support
+ Proposed fix for restrictedmem_getattr() as mentioned on the mailing list at
https://lore.kernel.org/lkml/[email protected]/
+ Hugh’s patch:
https://lore.kernel.org/lkml/[email protected]/,
which provides functionality in shmem that reads the VM_HUGEPAGE flag in key functions shmem_is_huge() and shmem_get_inode()

Will Hugh's patch be merged into 6.3 ? I didn't find it in 6.2-rc8. IMHO this patch won't work without Hugh's patch, or at least need another way, e.g. HMEM_SB(inode->i_sb)->huge.

Quoted 18 lines

Future work/TODOs:
+ man page for the memfd_restricted() syscall
+ Support for per file NUMA binding hints
Ackerley Tng (2):
mm: restrictedmem: Add flag as THP allocation hint for
memfd_restricted() syscall
selftests: restrictedmem: Add selftest for RMFD_HUGEPAGE
 include/uapi/linux/restrictedmem.h            |  1 +
 mm/restrictedmem.c                            | 27 ++++++++++++-------
 .../restrictedmem_hugepage_test.c             | 25 +++++++++++++++++
 3 files changed, 43 insertions(+), 10 deletions(-)
--
2.39.2.637.g21b0678d19-goog

Ackerley Tng

author

2023-02-23 01:31 UTC #4 lore raw

Quoted 32 lines · Yuan Yao

Quoted 31 lines · Ackerley Tng
Hello,
This patchset builds upon the memfd_restricted() system call that has been discussed in the ‘KVM: mm: fd-based approach for supporting KVM’ patch series, at
https://lore.kernel.org/lkml/[email protected]/T/#m7e944d7892afdd1d62a03a287bd488c56e377b0c
The tree can be found at:
https://github.com/googleprodkernel/linux-cc/tree/restrictedmem-rmfd-hugepage
Following the RFC to provide mount for memfd_restricted() syscall at
https://lore.kernel.org/lkml/[email protected]/T/#u,
this patchset adds the RMFD_HUGEPAGE flag to the memfd_restricted() syscall, which will hint the kernel to use Transparent HugePages to back restrictedmem pages.
This supplements the interface proposed earlier, which requires the creation of a tmpfs mount to be passed to memfd_restricted(), with a more direct per-file hint.
Dependencies:
+ Sean’s iteration of the ‘KVM: mm: fd-based approach for supporting KVM’ patch series at
https://github.com/sean-jc/linux/tree/x86/upm_base_support
+ Proposed fix for restrictedmem_getattr() as mentioned on the mailing list at
https://lore.kernel.org/lkml/[email protected]/
+ Hugh’s patch:

Quoted 7 lines

Quoted 3 lines
https://lore.kernel.org/lkml/[email protected]/,
which provides functionality in shmem that reads the VM_HUGEPAGE flag in key functions shmem_is_huge() and shmem_get_inode()
Will Hugh's patch be merged into 6.3 ? I didn't find it in 6.2-rc8. IMHO this patch won't work without Hugh's patch, or at least need another way, e.g. HMEM_SB(inode->i_sb)->huge.

Hugh's patch is still pending discussion and may not be merged so soon. These patches will not work without Hugh's patch.

I would like to understand what the community thinks of the proposed interface (RMFD_HUGEPAGE flag, passed to the memfd_restricted() syscall). If this interface is favorably received, we can definitely find another way for shmem to support this interface.

If I understand correctly, SHMEM_SB(inode->i_sb)->huge checks the state of hugepage-ness for the superblock. Since the proposed interface will only affect a single file, we will need something closer to

    bool shmem_is_huge(struct vm_area_struct *vma, struct inode *inode,
                       pgoff_t index, bool shmem_huge_force)
    {
            ...

            if (SHMEM_I(inode)->flags & VM_HUGEPAGE)
                    return true;

            ...
    }

from Hugh's patch.