Skip to contentSkip to conversation

mm: memfd_luo: preserve file seals

PATCH Superseded Pratyush Yadav 3 participants 12 messages Jan 23 – Feb 10

Subsystems (4)

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore

Pratyush Yadav

author maintainer
#0 lore raw

cover mm: memfd_luo: preserve file seals

From: "Pratyush Yadav (Google)" <[email protected]>

Hi,

This series adds support for preserving file seals when preserving a memfd using LUO. Patch 1 exports some memfd seal manipulation functions and patch 2 adds support for preserving them. Since it makes changes to the serialized data structure for memfd, it also bumps the version number.

I also plan to add some tests for this. I quickly hacked together something to test this series, but I am working on some patches that would add multiple selftests for memfd preservation. It might take me a couple weeks to get to it, so sending the main support now in the hopes of making it into the upcoming merge window.

Regards,
Pratyush Yadav

Pratyush Yadav (Google) (2):
memfd: export memfd_{add,get}_seals()
mm: memfd_luo: preserve file seals

 include/linux/kho/abi/memfd.h |  9 ++++++++-
 include/linux/memfd.h         | 12 ++++++++++++
 mm/memfd.c                    |  4 ++--
 mm/memfd_luo.c                | 23 +++++++++++++++++++++--
 4 files changed, 43 insertions(+), 5 deletions(-)
Signature · 1 line
2.52.0.457.g6b5491de43-goog
author maintainer
#1 lore raw

PATCH 1/2 memfd: export memfd_{add,get}_seals()

From: "Pratyush Yadav (Google)" <[email protected]>

Support for preserving file seals will be added to memfd preservation using the Live Update Orchestrator (LUO). Export memfd_{add,get}_seals)() so memfd_luo can use them to manipulate the seals.

---
 include/linux/memfd.h | 12 ++++++++++++
 mm/memfd.c            |  4 ++--
 2 files changed, 14 insertions(+), 2 deletions(-)
include/linux/memfd.h +12 -0
index c328a7b356d0..b4fda09dab9f 100644
@@ -18,6 +18,8 @@ struct folio *memfd_alloc_folio(struct file *memfd, pgoff_t idx);
  */
 int memfd_check_seals_mmap(struct file *file, vm_flags_t *vm_flags_ptr);
 struct file *memfd_alloc_file(const char *name, unsigned int flags);
+int memfd_get_seals(struct file *file);
+int memfd_add_seals(struct file *file, unsigned int seals);
 #else
 static inline long memfd_fcntl(struct file *f, unsigned int c, unsigned int a)
 {
@@ -37,6 +39,16 @@ static inline struct file *memfd_alloc_file(const char *name, unsigned int flags
 {
 	return ERR_PTR(-EINVAL);
 }
+
+static inline int memfd_get_seals(struct file *file)
+{
+	return -EINVAL;
+}
+
+static inline int memfd_add_seals(struct file *file, unsigned int seals)
+{
+	return -EINVAL;
+}
 #endif
 
 #endif /* __LINUX_MEMFD_H */
mm/memfd.c +2 -2
index f032c6052926..46c5508beea4 100644
@@ -228,7 +228,7 @@ static unsigned int *memfd_file_seals_ptr(struct file *file)
 		     F_SEAL_WRITE | \
 		     F_SEAL_FUTURE_WRITE)
 
-static int memfd_add_seals(struct file *file, unsigned int seals)
+int memfd_add_seals(struct file *file, unsigned int seals)
 {
 	struct inode *inode = file_inode(file);
 	unsigned int *file_seals;
@@ -310,7 +310,7 @@ static int memfd_add_seals(struct file *file, unsigned int seals)
 	return error;
 }
 
-static int memfd_get_seals(struct file *file)
+int memfd_get_seals(struct file *file)
 {
 	unsigned int *seals = memfd_file_seals_ptr(file);
 
Signature · 1 line
2.52.0.457.g6b5491de43-goog
maintainer Acked-by on v1 1/2
#2 lore raw

Re: [PATCH 1/2] memfd: export memfd_{add,get}_seals()

Quoted 8 lines · Pratyush Yadav

From: "Pratyush Yadav (Google)" <[email protected]>

Support for preserving file seals will be added to memfd preservation using the Live Update Orchestrator (LUO). Export memfd_{add,get}_seals)() so memfd_luo can use them to manipulate the seals.

Quoted 60 lines
---
 include/linux/memfd.h | 12 ++++++++++++
 mm/memfd.c            |  4 ++--
 2 files changed, 14 insertions(+), 2 deletions(-)
include/linux/memfd.h +12 -0
index c328a7b356d0..b4fda09dab9f 100644
@@ -18,6 +18,8 @@ struct folio *memfd_alloc_folio(struct file *memfd, pgoff_t idx);
  */
 int memfd_check_seals_mmap(struct file *file, vm_flags_t *vm_flags_ptr);
 struct file *memfd_alloc_file(const char *name, unsigned int flags);
+int memfd_get_seals(struct file *file);
+int memfd_add_seals(struct file *file, unsigned int seals);
 #else
 static inline long memfd_fcntl(struct file *f, unsigned int c, unsigned int a)
 {
@@ -37,6 +39,16 @@ static inline struct file *memfd_alloc_file(const char *name, unsigned int flags
 {
 	return ERR_PTR(-EINVAL);
 }
+
+static inline int memfd_get_seals(struct file *file)
+{
+	return -EINVAL;
+}
+
+static inline int memfd_add_seals(struct file *file, unsigned int seals)
+{
+	return -EINVAL;
+}
 #endif
 
 #endif /* __LINUX_MEMFD_H */
mm/memfd.c +2 -2
index f032c6052926..46c5508beea4 100644
@@ -228,7 +228,7 @@ static unsigned int *memfd_file_seals_ptr(struct file *file)
 		     F_SEAL_WRITE | \
 		     F_SEAL_FUTURE_WRITE)
 
-static int memfd_add_seals(struct file *file, unsigned int seals)
+int memfd_add_seals(struct file *file, unsigned int seals)
 {
 	struct inode *inode = file_inode(file);
 	unsigned int *file_seals;
@@ -310,7 +310,7 @@ static int memfd_add_seals(struct file *file, unsigned int seals)
 	return error;
 }
 
-static int memfd_get_seals(struct file *file)
+int memfd_get_seals(struct file *file)
 {
 	unsigned int *seals = memfd_file_seals_ptr(file);
 
Signature · 1 line
2.52.0.457.g6b5491de43-goog
Signature · 2 lines
Sincerely yours,
Mike.
author maintainer
#3 lore raw

PATCH 2/2 mm: memfd_luo: preserve file seals

In reply to Pratyush Yadav

From: "Pratyush Yadav (Google)" <[email protected]>

File seals are used on memfd for making shared memory communication with untrusted peers safer and simpler. Seals provide a guarantee that certain operations won't be allowed on the file such as writes or truncations. Maintaining these guarantees across a live update will help keeping such use cases secure.

These guarantees will also be needed for IOMMUFD preservation with LUO. Normally when IOMMUFD maps a memfd, it pins all its pages to make sure any truncation operations on the memfd don't lead to IOMMUFD using freed memory. This doesn't work with LUO since the preserved memfd might have completely different pages after a live update, and mapping them back to the IOMMUFD will cause all sorts of problems. Using and preserving the seals allows IOMMUFD preservation logic to trust the memfd.

Preserve the seals by introducing a new 8-bit-wide bitfield. There are currently only 6 possible seals but 2 extra bits are used to provide room for future expansion. Since the seals are UAPI, it is safe to use them directly in the ABI.

Back the 8-bit field with a u64, leaving 56 unused bits. This is done to keep the struct nice and aligned. The unused bits can be used to add new flags later, potentially without even needing to bump the version number.

Since the serialization structure is changed, bump the version number to "memfd-v2".

---
 include/linux/kho/abi/memfd.h |  9 ++++++++-
 mm/memfd_luo.c                | 23 +++++++++++++++++++++--
 2 files changed, 29 insertions(+), 3 deletions(-)
include/linux/kho/abi/memfd.h +8 -1
index 68cb6303b846..bd549c81f1d2 100644
@@ -60,6 +60,11 @@ struct memfd_luo_folio_ser {
  * struct memfd_luo_ser - Main serialization structure for a memfd.
  * @pos:       The file's current position (f_pos).
  * @size:      The total size of the file in bytes (i_size).
+ * @seals:     The seals present on the memfd. The seals are UAPI so it is safe
+ *             to directly use them in the ABI. Note: currently there are 6
+ *             seals possible but this field is 8 bits to leave room for future
+ *             expansion.
+ * @__reserved: Reserved bits. May be used later to add more flags.
  * @nr_folios: Number of folios in the folios array.
  * @folios:    KHO vmalloc descriptor pointing to the array of
  *             struct memfd_luo_folio_ser.
@@ -67,11 +72,13 @@ struct memfd_luo_folio_ser {
 struct memfd_luo_ser {
 	u64 pos;
 	u64 size;
+	u64 seals:8;
+	u64 __reserved:56;
 	u64 nr_folios;
 	struct kho_vmalloc folios;
 } __packed;
 
 /* The compatibility string for memfd file handler */
-#define MEMFD_LUO_FH_COMPATIBLE	"memfd-v1"
+#define MEMFD_LUO_FH_COMPATIBLE	"memfd-v2"
 
 #endif /* _LINUX_KHO_ABI_MEMFD_H */
mm/memfd_luo.c +21 -2
index a34fccc23b6a..eb68e0b5457f 100644
@@ -79,6 +79,8 @@
 #include <linux/shmem_fs.h>
 #include <linux/vmalloc.h>
 #include <linux/memfd.h>
+#include <uapi/linux/memfd.h>
+
 #include "internal.h"
 
 static int memfd_luo_preserve_folios(struct file *file,
@@ -222,7 +224,7 @@ static int memfd_luo_preserve(struct liveupdate_file_op_args *args)
 	struct memfd_luo_folio_ser *folios_ser;
 	struct memfd_luo_ser *ser;
 	u64 nr_folios;
-	int err = 0;
+	int err = 0, seals;
 
 	inode_lock(inode);
 	shmem_freeze(inode, true);
@@ -234,8 +236,15 @@ static int memfd_luo_preserve(struct liveupdate_file_op_args *args)
 		goto err_unlock;
 	}
 
+	seals = memfd_get_seals(args->file);
+	if (seals < 0) {
+		err = seals;
+		goto err_free_ser;
+	}
+
 	ser->pos = args->file->f_pos;
 	ser->size = i_size_read(inode);
+	ser->seals = seals;
 
 	err = memfd_luo_preserve_folios(args->file, &ser->folios,
 					&folios_ser, &nr_folios);
@@ -444,13 +453,23 @@ static int memfd_luo_retrieve(struct liveupdate_file_op_args *args)
 	if (!ser)
 		return -EINVAL;
 
-	file = memfd_alloc_file("", 0);
+	/*
+	 * The seals are preserved. Allow sealing here so they can be added
+	 * later.
+	 */
+	file = memfd_alloc_file("", MFD_ALLOW_SEALING);
 	if (IS_ERR(file)) {
 		pr_err("failed to setup file: %pe\n", file);
 		err = PTR_ERR(file);
 		goto free_ser;
 	}
 
+	err = memfd_add_seals(file, ser->seals);
+	if (err) {
+		pr_err("failed to add seals: %pe\n", ERR_PTR(err));
+		goto put_file;
+	}
+
 	vfs_setpos(file, ser->pos, MAX_LFS_FILESIZE);
 	file->f_inode->i_size = ser->size;
 
Signature · 1 line
2.52.0.457.g6b5491de43-goog
maintainer
#4 lore raw
Quoted 52 lines · Pratyush Yadav

From: "Pratyush Yadav (Google)" <[email protected]>

File seals are used on memfd for making shared memory communication with untrusted peers safer and simpler. Seals provide a guarantee that certain operations won't be allowed on the file such as writes or truncations. Maintaining these guarantees across a live update will help keeping such use cases secure.

These guarantees will also be needed for IOMMUFD preservation with LUO. Normally when IOMMUFD maps a memfd, it pins all its pages to make sure any truncation operations on the memfd don't lead to IOMMUFD using freed memory. This doesn't work with LUO since the preserved memfd might have completely different pages after a live update, and mapping them back to the IOMMUFD will cause all sorts of problems. Using and preserving the seals allows IOMMUFD preservation logic to trust the memfd.

Preserve the seals by introducing a new 8-bit-wide bitfield. There are currently only 6 possible seals but 2 extra bits are used to provide room for future expansion. Since the seals are UAPI, it is safe to use them directly in the ABI.

Back the 8-bit field with a u64, leaving 56 unused bits. This is done to keep the struct nice and aligned. The unused bits can be used to add new flags later, potentially without even needing to bump the version number.

Since the serialization structure is changed, bump the version number to "memfd-v2".

---
 include/linux/kho/abi/memfd.h |  9 ++++++++-
 mm/memfd_luo.c                | 23 +++++++++++++++++++++--
 2 files changed, 29 insertions(+), 3 deletions(-)
include/linux/kho/abi/memfd.h +5 -0
index 68cb6303b846..bd549c81f1d2 100644
@@ -60,6 +60,11 @@ struct memfd_luo_folio_ser {
  * struct memfd_luo_ser - Main serialization structure for a memfd.
  * @pos:       The file's current position (f_pos).
  * @size:      The total size of the file in bytes (i_size).
+ * @seals:     The seals present on the memfd. The seals are UAPI so it is safe
+ *             to directly use them in the ABI. Note: currently there are 6
+ *             seals possible but this field is 8 bits to leave room for future
+ *             expansion.
+ * @__reserved: Reserved bits. May be used later to add more flags.
  * @nr_folios: Number of folios in the folios array.
  * @folios:    KHO vmalloc descriptor pointing to the array of
  *             struct memfd_luo_folio_ser.

include/linux/kho/abi/memfd.h struct memfd_luo_folio_ser { · line 75

Quoted 4 lines
include/linux/kho/abi/memfd.h +1 -0
@@ -67,11 +72,13 @@ struct memfd_luo_folio_ser {
 struct memfd_luo_ser {
 	u64 pos;
 	u64 size;
+	u64 seals:8;

Kernel uABI defines seals as unsigned int, I think we can spare u32 for them and reserve a u32 flags for other memfd flags (MFD_CLOEXEC, MFD_HUGETLB etc).

Quoted 49 lines
include/linux/kho/abi/memfd.h +2 -1
+	u64 __reserved:56;
 	u64 nr_folios;
 	struct kho_vmalloc folios;
 } __packed;
 
 /* The compatibility string for memfd file handler */
-#define MEMFD_LUO_FH_COMPATIBLE	"memfd-v1"
+#define MEMFD_LUO_FH_COMPATIBLE	"memfd-v2"
 
 #endif /* _LINUX_KHO_ABI_MEMFD_H */
mm/memfd_luo.c +10 -1
index a34fccc23b6a..eb68e0b5457f 100644
@@ -79,6 +79,8 @@
 #include <linux/shmem_fs.h>
 #include <linux/vmalloc.h>
 #include <linux/memfd.h>
+#include <uapi/linux/memfd.h>
+
 #include "internal.h"
 
 static int memfd_luo_preserve_folios(struct file *file,
@@ -222,7 +224,7 @@ static int memfd_luo_preserve(struct liveupdate_file_op_args *args)
 	struct memfd_luo_folio_ser *folios_ser;
 	struct memfd_luo_ser *ser;
 	u64 nr_folios;
-	int err = 0;
+	int err = 0, seals;
 
 	inode_lock(inode);
 	shmem_freeze(inode, true);
@@ -234,8 +236,15 @@ static int memfd_luo_preserve(struct liveupdate_file_op_args *args)
 		goto err_unlock;
 	}
 
+	seals = memfd_get_seals(args->file);
+	if (seals < 0) {
+		err = seals;
+		goto err_free_ser;
+	}
+
 	ser->pos = args->file->f_pos;
 	ser->size = i_size_read(inode);
+	ser->seals = seals;
 
 	err = memfd_luo_preserve_folios(args->file, &ser->folios,
 					&folios_ser, &nr_folios);

mm/memfd_luo.c static int memfd_luo_retrieve(struct liveupdate_file_op_args *args) · line 460

Quoted 9 lines
mm/memfd_luo.c +5 -1
@@ -444,13 +453,23 @@ static int memfd_luo_retrieve(struct liveupdate_file_op_args *args)
 	if (!ser)
 		return -EINVAL;
 
-	file = memfd_alloc_file("", 0);
+	/*
+	 * The seals are preserved. Allow sealing here so they can be added
+	 * later.
+	 */
+	file = memfd_alloc_file("", MFD_ALLOW_SEALING);

I think we should select flags passed to memfd_alloc_file() based on ser->seals (and later based on ser->seals and ser->flags).

mm/memfd_luo.c static int memfd_luo_retrieve(struct liveupdate_file_op_args *args) · line 467

Quoted 7 lines
mm/memfd_luo.c +1 -0
 	if (IS_ERR(file)) {
 		pr_err("failed to setup file: %pe\n", file);
 		err = PTR_ERR(file);
 		goto free_ser;
 	}
 
+	err = memfd_add_seals(file, ser->seals);

I'm not sure using MFD_ALLOW_SEALING is enough if there was F_SEAL_EXEC in seals.

Quoted 11 lines
mm/memfd_luo.c +5 -0
+	if (err) {
+		pr_err("failed to add seals: %pe\n", ERR_PTR(err));
+		goto put_file;
+	}
+
 	vfs_setpos(file, ser->pos, MAX_LFS_FILESIZE);
 	file->f_inode->i_size = ser->size;
 
Signature · 1 line
2.52.0.457.g6b5491de43-goog
Signature · 2 lines
Sincerely yours,
Mike.
author maintainer
#5 lore raw

Hi Mike,

Quoted 53 lines · Mike Rapoport
Quoted 52 lines · Pratyush Yadav

From: "Pratyush Yadav (Google)" <[email protected]>

File seals are used on memfd for making shared memory communication with untrusted peers safer and simpler. Seals provide a guarantee that certain operations won't be allowed on the file such as writes or truncations. Maintaining these guarantees across a live update will help keeping such use cases secure.

These guarantees will also be needed for IOMMUFD preservation with LUO. Normally when IOMMUFD maps a memfd, it pins all its pages to make sure any truncation operations on the memfd don't lead to IOMMUFD using freed memory. This doesn't work with LUO since the preserved memfd might have completely different pages after a live update, and mapping them back to the IOMMUFD will cause all sorts of problems. Using and preserving the seals allows IOMMUFD preservation logic to trust the memfd.

Preserve the seals by introducing a new 8-bit-wide bitfield. There are currently only 6 possible seals but 2 extra bits are used to provide room for future expansion. Since the seals are UAPI, it is safe to use them directly in the ABI.

Back the 8-bit field with a u64, leaving 56 unused bits. This is done to keep the struct nice and aligned. The unused bits can be used to add new flags later, potentially without even needing to bump the version number.

Since the serialization structure is changed, bump the version number to "memfd-v2".

---
 include/linux/kho/abi/memfd.h |  9 ++++++++-
 mm/memfd_luo.c                | 23 +++++++++++++++++++++--
 2 files changed, 29 insertions(+), 3 deletions(-)
include/linux/kho/abi/memfd.h +5 -0
index 68cb6303b846..bd549c81f1d2 100644
@@ -60,6 +60,11 @@ struct memfd_luo_folio_ser {
  * struct memfd_luo_ser - Main serialization structure for a memfd.
  * @pos:       The file's current position (f_pos).
  * @size:      The total size of the file in bytes (i_size).
+ * @seals:     The seals present on the memfd. The seals are UAPI so it is safe
+ *             to directly use them in the ABI. Note: currently there are 6
+ *             seals possible but this field is 8 bits to leave room for future
+ *             expansion.
+ * @__reserved: Reserved bits. May be used later to add more flags.
  * @nr_folios: Number of folios in the folios array.
  * @folios:    KHO vmalloc descriptor pointing to the array of
  *             struct memfd_luo_folio_ser.
@@ -67,11 +72,13 @@ struct memfd_luo_folio_ser {
Quoted 8 lines

include/linux/kho/abi/memfd.h struct memfd_luo_folio_ser { · line 75

Quoted 4 lines
include/linux/kho/abi/memfd.h +1 -0
 struct memfd_luo_ser {
 	u64 pos;
 	u64 size;
+	u64 seals:8;

Kernel uABI defines seals as unsigned int, I think we can spare u32 for them and reserve a u32 flags for other memfd flags (MFD_CLOEXEC, MFD_HUGETLB etc).

Sure, will do.

Quoted 53 lines
Quoted 53 lines
include/linux/kho/abi/memfd.h +2 -1
+	u64 __reserved:56;
 	u64 nr_folios;
 	struct kho_vmalloc folios;
 } __packed;
 
 /* The compatibility string for memfd file handler */
-#define MEMFD_LUO_FH_COMPATIBLE	"memfd-v1"
+#define MEMFD_LUO_FH_COMPATIBLE	"memfd-v2"
 
 #endif /* _LINUX_KHO_ABI_MEMFD_H */
mm/memfd_luo.c +10 -1
index a34fccc23b6a..eb68e0b5457f 100644
@@ -79,6 +79,8 @@
 #include <linux/shmem_fs.h>
 #include <linux/vmalloc.h>
 #include <linux/memfd.h>
+#include <uapi/linux/memfd.h>
+
 #include "internal.h"
 
 static int memfd_luo_preserve_folios(struct file *file,
@@ -222,7 +224,7 @@ static int memfd_luo_preserve(struct liveupdate_file_op_args *args)
 	struct memfd_luo_folio_ser *folios_ser;
 	struct memfd_luo_ser *ser;
 	u64 nr_folios;
-	int err = 0;
+	int err = 0, seals;
 
 	inode_lock(inode);
 	shmem_freeze(inode, true);
@@ -234,8 +236,15 @@ static int memfd_luo_preserve(struct liveupdate_file_op_args *args)
 		goto err_unlock;
 	}
 
+	seals = memfd_get_seals(args->file);
+	if (seals < 0) {
+		err = seals;
+		goto err_free_ser;
+	}
+
 	ser->pos = args->file->f_pos;
 	ser->size = i_size_read(inode);
+	ser->seals = seals;
 
 	err = memfd_luo_preserve_folios(args->file, &ser->folios,
 					&folios_ser, &nr_folios);
@@ -444,13 +453,23 @@ static int memfd_luo_retrieve(struct liveupdate_file_op_args *args)
 	if (!ser)
 		return -EINVAL;
 
Quoted 9 lines

mm/memfd_luo.c static int memfd_luo_retrieve(struct liveupdate_file_op_args *args) · line 460

Quoted 6 lines
mm/memfd_luo.c +5 -1
-	file = memfd_alloc_file("", 0);
+	/*
+	 * The seals are preserved. Allow sealing here so they can be added
+	 * later.
+	 */
+	file = memfd_alloc_file("", MFD_ALLOW_SEALING);

I think we should select flags passed to memfd_alloc_file() based on ser->seals (and later based on ser->seals and ser->flags).

Not sure what you mean.

I think the only seal we can set via memfd_alloc_file() flags is MFD_NOEXEC_SEAL, which is really a F_SEAL_EXEC and plus a change of the inode's mode. And now that I think of it, that is a valid use case that we might as well support. But I think that should be done by preserving the mode of the inode directly, and then copying the seals back. The main reason for that is that the mode can be changed after the memfd is created too.

Other than that, all other seals are set by fcntl (via memfd_add_seals()), so I don't see what else we can pass to memfd_alloc_file().

Quoted 11 lines

mm/memfd_luo.c static int memfd_luo_retrieve(struct liveupdate_file_op_args *args) · line 467

Quoted 8 lines
mm/memfd_luo.c +1 -0
 	if (IS_ERR(file)) {
 		pr_err("failed to setup file: %pe\n", file);
 		err = PTR_ERR(file);
 		goto free_ser;
 	}
 
+	err = memfd_add_seals(file, ser->seals);

I'm not sure using MFD_ALLOW_SEALING is enough if there was F_SEAL_EXEC in seals.

Why not? memfd_add_seals() can handle F_SEAL_EXEC as far as I can tell.

Quoted 12 lines
Quoted 12 lines
mm/memfd_luo.c +5 -0
+	if (err) {
+		pr_err("failed to add seals: %pe\n", ERR_PTR(err));
+		goto put_file;
+	}
+
 	vfs_setpos(file, ser->pos, MAX_LFS_FILESIZE);
 	file->f_inode->i_size = ser->size;
 
Signature · 1 line
2.52.0.457.g6b5491de43-goog
Signature · 2 lines
Regards,
Pratyush Yadav
maintainer
#6 lore raw

Hi Pratyush,

Quoted 4 lines · Pratyush Yadav

Hi Mike,

Quoted 1 line · Mike Rapoport

On Fri, Jan 23, 2026 at 10:58:51AM +0100, Pratyush Yadav wrote:

...

Quoted 20 lines
Quoted 9 lines

mm/memfd_luo.c static int memfd_luo_retrieve(struct liveupdate_file_op_args *args) · line 460

Quoted 6 lines
mm/memfd_luo.c +5 -1
-	file = memfd_alloc_file("", 0);
+	/*
+	 * The seals are preserved. Allow sealing here so they can be added
+	 * later.
+	 */
+	file = memfd_alloc_file("", MFD_ALLOW_SEALING);

I think we should select flags passed to memfd_alloc_file() based on ser->seals (and later based on ser->seals and ser->flags).

Not sure what you mean.

I think the only seal we can set via memfd_alloc_file() flags is MFD_NOEXEC_SEAL, which is really a F_SEAL_EXEC and plus a change of the inode's mode. And now that I think of it, that is a valid use case that we might as well support. But I think that should be done by preserving the mode of the inode directly, and then copying the seals back. The main reason for that is that the mode can be changed after the memfd is created too.

Quoted 3 lines

Other than that, all other seals are set by fcntl (via memfd_add_seals()), so I don't see what else we can pass to memfd_alloc_file().

Hmm, "using ser->seals" was bad phrasing :)

Now we add support for creating memfd with MFD_ALLOW_SEALING and at some point we'd want MFD_HUGETLB and huge page size.
So I think we should have a field in ser that will define what flags should be used for creation of memfd and based on the value of that field pass the flags to memfd_alloc_file().

For seals support this field can be hardwired to MFD_ALLOW_SEALING at preserve time.

Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
mm/memfd_luo.c +0 -0
 	if (IS_ERR(file)) {
 		pr_err("failed to setup file: %pe\n", file);
 		err = PTR_ERR(file);
 		goto free_ser;
 	}
Quoted 6 lines
Quoted 4 lines

mm/memfd_luo.c static int memfd_luo_retrieve(struct liveupdate_file_op_args *args) · line 467

Quoted 1 line
mm/memfd_luo.c +1 -0
+	err = memfd_add_seals(file, ser->seals);

I'm not sure using MFD_ALLOW_SEALING is enough if there was F_SEAL_EXEC in seals.

Why not? memfd_add_seals() can handle F_SEAL_EXEC as far as I can tell.

I just noticed it behaved differently :)
Looks like F_SEAL_EXEC indeed can handle it.

Quoted 3 lines
Signature · 2 lines
Regards,
Pratyush Yadav
Signature · 2 lines
Sincerely yours,
Mike.
author maintainer
#7 lore raw
Quoted 34 lines · Mike Rapoport

Hi Pratyush,

Quoted 4 lines · Pratyush Yadav

Hi Mike,

Quoted 1 line · Mike Rapoport

On Fri, Jan 23, 2026 at 10:58:51AM +0100, Pratyush Yadav wrote:

...

Quoted 20 lines
Quoted 9 lines

mm/memfd_luo.c static int memfd_luo_retrieve(struct liveupdate_file_op_args *args) · line 460

Quoted 6 lines
mm/memfd_luo.c +5 -1
-	file = memfd_alloc_file("", 0);
+	/*
+	 * The seals are preserved. Allow sealing here so they can be added
+	 * later.
+	 */
+	file = memfd_alloc_file("", MFD_ALLOW_SEALING);

I think we should select flags passed to memfd_alloc_file() based on ser->seals (and later based on ser->seals and ser->flags).

Not sure what you mean.

I think the only seal we can set via memfd_alloc_file() flags is MFD_NOEXEC_SEAL, which is really a F_SEAL_EXEC and plus a change of the inode's mode. And now that I think of it, that is a valid use case that we might as well support. But I think that should be done by preserving the mode of the inode directly, and then copying the seals back. The main reason for that is that the mode can be changed after the memfd is created too.

Quoted 3 lines

Other than that, all other seals are set by fcntl (via memfd_add_seals()), so I don't see what else we can pass to memfd_alloc_file().

Quoted 7 lines

Hmm, "using ser->seals" was bad phrasing :)

Now we add support for creating memfd with MFD_ALLOW_SEALING and at some point we'd want MFD_HUGETLB and huge page size.
So I think we should have a field in ser that will define what flags should be used for creation of memfd and based on the value of that field pass the flags to memfd_alloc_file().

I am not planning to re-use any of memfd machinery we have now for HugeTLB. The main reason is that the HugeTLB support is different enough that any shared code or data structures aren't worth the extra complexity.

So HugeTLB gets its own serialization structures and file handlers. struct hugemfd_ser in [0] has a field for order which we can use to decide the flags.

[0] https://lore.kernel.org/linux-mm/[email protected]/

Quoted 3 lines

For seals support this field can be hardwired to MFD_ALLOW_SEALING at preserve time.

[...]

Signature · 2 lines
Regards,
Pratyush Yadav
#8 lore raw
In reply to Mike Rapoport
Quoted 9 lines · Mike Rapoport

include/linux/kho/abi/memfd.h struct memfd_luo_folio_ser { · line 75

Quoted 5 lines
include/linux/kho/abi/memfd.h +1 -0
@@ -67,11 +72,13 @@ struct memfd_luo_folio_ser {
 struct memfd_luo_ser {
 	u64 pos;
 	u64 size;
+	u64 seals:8;

Kernel uABI defines seals as unsigned int, I think we can spare u32 for them and reserve a u32 flags for other memfd flags (MFD_CLOEXEC, MFD_HUGETLB etc).

It is a bit worse than that, the "v2" version is only going to support some set of seals (probably the set defined in v6.19) and if there are new seals down the road then this needs a version bump.

So I'd check that only supported seals are set here:

Quoted 9 lines
Quoted 9 lines
mm/memfd_luo.c +7 -0
+     seals = memfd_get_seals(args->file);
+     if (seals < 0) {
+             err = seals;
+             goto err_free_ser;
+     }
+
      ser->pos = args->file->f_pos;
      ser->size = i_size_read(inode);
+     ser->seals = seals;

..

Quoted 16 lines
Quoted 16 lines
mm/memfd_luo.c +5 -1
@@ -444,13 +453,23 @@ static int memfd_luo_retrieve(struct liveupdate_file_op_args *args)
 	if (!ser)
 		return -EINVAL;
 
-	file = memfd_alloc_file("", 0);
+	/*
+	 * The seals are preserved. Allow sealing here so they can be added
+	 * later.
+	 */
+	file = memfd_alloc_file("", MFD_ALLOW_SEALING);
 	if (IS_ERR(file)) {
 		pr_err("failed to setup file: %pe\n", file);
 		err = PTR_ERR(file);
 		goto free_ser;
 	}
 
Quoted 1 line

mm/memfd_luo.c static int memfd_luo_retrieve(struct liveupdate_file_op_args *args) · line 467

Quoted 1 line
mm/memfd_luo.c +1 -0
+	err = memfd_add_seals(file, ser->seals);

Because we really don't want this to fail :\

Jason

author maintainer
#9 lore raw

Hi Jason,

Quoted 11 lines · Jason Gunthorpe
Quoted 9 lines · Mike Rapoport

include/linux/kho/abi/memfd.h struct memfd_luo_folio_ser { · line 75

Quoted 5 lines
include/linux/kho/abi/memfd.h +1 -0
@@ -67,11 +72,13 @@ struct memfd_luo_folio_ser {
 struct memfd_luo_ser {
 	u64 pos;
 	u64 size;
+	u64 seals:8;

Kernel uABI defines seals as unsigned int, I think we can spare u32 for them and reserve a u32 flags for other memfd flags (MFD_CLOEXEC, MFD_HUGETLB etc).

Quoted 3 lines

It is a bit worse than that, the "v2" version is only going to support some set of seals (probably the set defined in v6.19) and if there are new seals down the road then this needs a version bump.

If we are running say kernel X, then X + 1 will always support a superset of the seals, since the seals are UAPI. So it should be able to handle all the seals that are given to it by X. This only becomes a problem on rollbacks. Is this what you are worried about or am I missing something?

Quoted 36 lines

So I'd check that only supported seals are set here:

Quoted 9 lines
Quoted 9 lines
mm/memfd_luo.c +7 -0
+     seals = memfd_get_seals(args->file);
+     if (seals < 0) {
+             err = seals;
+             goto err_free_ser;
+     }
+
      ser->pos = args->file->f_pos;
      ser->size = i_size_read(inode);
+     ser->seals = seals;

..

Quoted 16 lines
Quoted 16 lines
mm/memfd_luo.c +5 -1
@@ -444,13 +453,23 @@ static int memfd_luo_retrieve(struct liveupdate_file_op_args *args)
 	if (!ser)
 		return -EINVAL;
 
-	file = memfd_alloc_file("", 0);
+	/*
+	 * The seals are preserved. Allow sealing here so they can be added
+	 * later.
+	 */
+	file = memfd_alloc_file("", MFD_ALLOW_SEALING);
 	if (IS_ERR(file)) {
 		pr_err("failed to setup file: %pe\n", file);
 		err = PTR_ERR(file);
 		goto free_ser;
 	}
 
Quoted 1 line

mm/memfd_luo.c static int memfd_luo_retrieve(struct liveupdate_file_op_args *args) · line 467

Quoted 1 line
mm/memfd_luo.c +1 -0
+	err = memfd_add_seals(file, ser->seals);

Because we really don't want this to fail :\

Jason

Signature · 2 lines
Regards,
Pratyush Yadav
#10 lore raw
Quoted 19 lines · Pratyush Yadav

Hi Jason,

Quoted 11 lines · Jason Gunthorpe
Quoted 9 lines · Mike Rapoport

include/linux/kho/abi/memfd.h struct memfd_luo_folio_ser { · line 75

Quoted 5 lines
include/linux/kho/abi/memfd.h +1 -0
@@ -67,11 +72,13 @@ struct memfd_luo_folio_ser {
 struct memfd_luo_ser {
 	u64 pos;
 	u64 size;
+	u64 seals:8;

Kernel uABI defines seals as unsigned int, I think we can spare u32 for them and reserve a u32 flags for other memfd flags (MFD_CLOEXEC, MFD_HUGETLB etc).

Quoted 3 lines

It is a bit worse than that, the "v2" version is only going to support some set of seals (probably the set defined in v6.19) and if there are new seals down the road then this needs a version bump.

Quoted 5 lines

If we are running say kernel X, then X + 1 will always support a superset of the seals, since the seals are UAPI. So it should be able to handle all the seals that are given to it by X. This only becomes a problem on rollbacks. Is this what you are worried about or am I missing something?

I think you need a check at some point only permitting seals that are defined right now.

Eg some future v7.19 kernel has MEMFD_SEAL_XX it should not be allowed through luo until the API is bumped to v3

Jason

author maintainer
#11 lore raw
Quoted 26 lines · Jason Gunthorpe
Quoted 19 lines · Pratyush Yadav

Hi Jason,

Quoted 11 lines · Jason Gunthorpe
Quoted 9 lines · Mike Rapoport

include/linux/kho/abi/memfd.h struct memfd_luo_folio_ser { · line 75

Quoted 5 lines
include/linux/kho/abi/memfd.h +1 -0
@@ -67,11 +72,13 @@ struct memfd_luo_folio_ser {
 struct memfd_luo_ser {
 	u64 pos;
 	u64 size;
+	u64 seals:8;

Kernel uABI defines seals as unsigned int, I think we can spare u32 for them and reserve a u32 flags for other memfd flags (MFD_CLOEXEC, MFD_HUGETLB etc).

Quoted 3 lines

It is a bit worse than that, the "v2" version is only going to support some set of seals (probably the set defined in v6.19) and if there are new seals down the road then this needs a version bump.

Quoted 5 lines

If we are running say kernel X, then X + 1 will always support a superset of the seals, since the seals are UAPI. So it should be able to handle all the seals that are given to it by X. This only becomes a problem on rollbacks. Is this what you are worried about or am I missing something?

Quoted 5 lines

I think you need a check at some point only permitting seals that are defined right now.

Eg some future v7.19 kernel has MEMFD_SEAL_XX it should not be allowed through luo until the API is bumped to v3

Makes sense. Will add.

Signature · 2 lines
Regards,
Pratyush Yadav