[PATCH v4 10/13] liveupdate: Remove limit on the number of files per session
Pratyush Yadav
pratyush at kernel.org
Mon Jun 1 07:16:25 PDT 2026
On Sat, May 30 2026, Pasha Tatashin wrote:
> To remove the fixed limit on the number of preserved files per session,
> transition the file metadata serialization from a single contiguous
> memory block to a chain of linked blocks.
>
> Acked-by: Mike Rapoport (Microsoft) <rppt at kernel.org>
> Signed-off-by: Pasha Tatashin <pasha.tatashin at soleen.com>
> ---
> include/linux/kho/abi/luo.h | 13 +--
> kernel/liveupdate/luo_file.c | 144 +++++++++++++++----------------
> kernel/liveupdate/luo_internal.h | 6 +-
> 3 files changed, 80 insertions(+), 83 deletions(-)
>
> diff --git a/include/linux/kho/abi/luo.h b/include/linux/kho/abi/luo.h
> index 79758d92ed5f..16df550ef143 100644
> --- a/include/linux/kho/abi/luo.h
> +++ b/include/linux/kho/abi/luo.h
> @@ -35,8 +35,8 @@
> *
> * - struct luo_session_ser:
> * Metadata for a single session, including its name and a physical pointer
> - * to another preserved memory block containing an array of
> - * `struct luo_file_ser` for all files in that session.
> + * to the first `struct kho_block_header_ser` for all files in that session.
> + * Multiple blocks are linked via the `next` field in the header.
> *
> * - struct luo_file_ser:
> * Metadata for a single preserved file. Contains the `compatible` string to
> @@ -65,7 +65,7 @@
> * The LUO state is registered under this KHO entry name.
> */
> #define LUO_KHO_ENTRY_NAME "LUO"
> -#define LUO_COMPAT_BASE "luo-v3"
> +#define LUO_COMPAT_BASE "luo-v4"
> #define LUO_ABI_COMPATIBLE LUO_COMPAT_BASE "-" KHO_BLOCK_ABI_COMPATIBLE
> #define LUO_ABI_COMPAT_LEN ALIGN(sizeof(LUO_ABI_COMPATIBLE), 8)
>
> @@ -103,9 +103,10 @@ struct luo_file_ser {
>
> /**
> * struct luo_file_set_ser - Represents the serialized metadata for file set
> - * @files: The physical address of a contiguous memory block that holds
> - * the serialized state of files (array of luo_file_ser) in this file
> - * set.
> + * @files: The physical address of the first `struct kho_block_header_ser`.
> + * This structure is the header for a block of memory containing
> + * an array of `struct luo_file_ser` entries. Multiple blocks are
> + * linked via the `next` field in the header.
> * @count: The total number of files that were part of this session during
> * serialization. Used for iteration and validation during
> * restoration.
> diff --git a/kernel/liveupdate/luo_file.c b/kernel/liveupdate/luo_file.c
> index 9eec07a9e9fc..a445b1950ca7 100644
> --- a/kernel/liveupdate/luo_file.c
> +++ b/kernel/liveupdate/luo_file.c
> @@ -118,11 +118,6 @@ static LIST_HEAD(luo_file_handler_list);
> /* Keep track of files being preserved by LUO */
> static DEFINE_XARRAY(luo_preserved_files);
>
> -/* 2 4K pages, give space for 128 files per file_set */
> -#define LUO_FILE_PGCNT 2ul
> -#define LUO_FILE_MAX \
> - ((LUO_FILE_PGCNT << PAGE_SHIFT) / sizeof(struct luo_file_ser))
> -
> /**
> * struct luo_file - Represents a single preserved file instance.
> * @fh: Pointer to the &struct liveupdate_file_handler that manages
> @@ -174,39 +169,6 @@ struct luo_file {
> u64 token;
> };
>
> -static int luo_alloc_files_mem(struct luo_file_set *file_set)
> -{
> - size_t size;
> - void *mem;
> -
> - if (file_set->files)
> - return 0;
> -
> - WARN_ON_ONCE(file_set->count);
> -
> - size = LUO_FILE_PGCNT << PAGE_SHIFT;
> - mem = kho_alloc_preserve(size);
> - if (IS_ERR(mem))
> - return PTR_ERR(mem);
> -
> - file_set->files = mem;
> -
> - return 0;
> -}
> -
> -static void luo_free_files_mem(struct luo_file_set *file_set)
> -{
> - /* If file_set has files, no need to free preservation memory */
> - if (file_set->count)
> - return;
> -
> - if (!file_set->files)
> - return;
> -
> - kho_unpreserve_free(file_set->files);
> - file_set->files = NULL;
> -}
> -
> static unsigned long luo_get_id(struct liveupdate_file_handler *fh,
> struct file *file)
> {
> @@ -276,16 +238,15 @@ int luo_preserve_file(struct luo_file_set *file_set, u64 token, int fd)
> if (luo_token_is_used(file_set, token))
> return -EEXIST;
>
> - if (file_set->count == LUO_FILE_MAX)
> - return -ENOSPC;
> + err = kho_block_grow(&file_set->block_set, file_set->count);
> + if (err)
> + return err;
>
> file = fget(fd);
> - if (!file)
> - return -EBADF;
> -
> - err = luo_alloc_files_mem(file_set);
> - if (err)
> - goto err_fput;
> + if (!file) {
> + err = -EBADF;
> + goto err_shrink;
> + }
>
> err = -ENOENT;
> down_read(&luo_register_rwlock);
> @@ -300,7 +261,7 @@ int luo_preserve_file(struct luo_file_set *file_set, u64 token, int fd)
>
> /* err is still -ENOENT if no handler was found */
> if (err)
> - goto err_free_files_mem;
> + goto err_fput;
>
> err = xa_insert(&luo_preserved_files, luo_get_id(fh, file),
> file, GFP_KERNEL);
> @@ -343,10 +304,10 @@ int luo_preserve_file(struct luo_file_set *file_set, u64 token, int fd)
> xa_erase(&luo_preserved_files, luo_get_id(fh, file));
> err_module_put:
> module_put(fh->ops->owner);
> -err_free_files_mem:
> - luo_free_files_mem(file_set);
> err_fput:
> fput(file);
> +err_shrink:
> + kho_block_shrink(&file_set->block_set, file_set->count);
>
> return err;
> }
> @@ -392,13 +353,14 @@ void luo_file_unpreserve_files(struct luo_file_set *file_set)
>
> list_del(&luo_file->list);
> file_set->count--;
> + kho_block_shrink(&file_set->block_set, file_set->count);
>
> fput(luo_file->file);
> mutex_destroy(&luo_file->mutex);
> kfree(luo_file);
> }
>
> - luo_free_files_mem(file_set);
> + kho_block_destroy(&file_set->block_set);
> }
>
> static int luo_file_freeze_one(struct luo_file_set *file_set,
> @@ -454,7 +416,7 @@ static void __luo_file_unfreeze(struct luo_file_set *file_set,
> luo_file_unfreeze_one(file_set, luo_file);
> }
>
> - memset(file_set->files, 0, LUO_FILE_PGCNT << PAGE_SHIFT);
> + kho_block_set_clear(&file_set->block_set);
> }
>
> /**
> @@ -493,19 +455,23 @@ static void __luo_file_unfreeze(struct luo_file_set *file_set,
> int luo_file_freeze(struct luo_file_set *file_set,
> struct luo_file_set_ser *file_set_ser)
> {
> - struct luo_file_ser *file_ser = file_set->files;
> struct luo_file *luo_file;
> + struct kho_block_it it;
> int err;
> - int i;
>
> if (!file_set->count)
> return 0;
>
> - if (WARN_ON(!file_ser))
> - return -EINVAL;
> + kho_block_it_init(&it, &file_set->block_set);
>
> - i = 0;
> list_for_each_entry(luo_file, &file_set->files_list, list) {
> + struct luo_file_ser *file_ser = kho_block_it_next(&it);
> +
> + if (!file_ser) {
> + err = -ENOSPC;
> + goto err_unfreeze;
> + }
This should not fail normally, right? Since we pre-allocate the memory.
Perhaps add a comment saying that?
> +
> err = luo_file_freeze_one(file_set, luo_file);
> if (err < 0) {
> pr_warn("Freeze failed for token[%#0llx] handler[%s] err[%pe]\n",
> @@ -514,16 +480,21 @@ int luo_file_freeze(struct luo_file_set *file_set,
> goto err_unfreeze;
> }
>
> - strscpy(file_ser[i].compatible, luo_file->fh->compatible,
> - sizeof(file_ser[i].compatible));
> - file_ser[i].data = luo_file->serialized_data;
> - file_ser[i].token = luo_file->token;
> - i++;
> + strscpy(file_ser->compatible, luo_file->fh->compatible,
> + sizeof(file_ser->compatible));
> + file_ser->data = luo_file->serialized_data;
> + file_ser->token = luo_file->token;
> }
> + kho_block_it_finalize(&it);
>
> file_set_ser->count = file_set->count;
> - if (file_set->files)
> - file_set_ser->files = virt_to_phys(file_set->files);
> + if (!list_empty(&file_set->block_set.blocks)) {
> + struct kho_block *block;
> +
> + block = list_first_entry(&file_set->block_set.blocks,
> + struct kho_block, list);
> + file_set_ser->files = virt_to_phys(block->ser);
> + }
Please, add an API in KHO block to return the header physical address.
Poking into the internals of the data structure like this is not a good
idea.
I missed that patch 9 also does this. So please use that there too.
>
> return 0;
>
> @@ -741,14 +712,12 @@ int luo_file_finish(struct luo_file_set *file_set)
> module_put(luo_file->fh->ops->owner);
> list_del(&luo_file->list);
> file_set->count--;
> + kho_block_shrink(&file_set->block_set, file_set->count);
> mutex_destroy(&luo_file->mutex);
> kfree(luo_file);
> }
>
> - if (file_set->files) {
> - kho_restore_free(file_set->files);
> - file_set->files = NULL;
> - }
> + kho_block_destroy(&file_set->block_set);
>
> return 0;
> }
> @@ -822,16 +791,18 @@ int luo_file_deserialize(struct luo_file_set *file_set,
> struct luo_file_set_ser *file_set_ser)
> {
> struct luo_file_ser *file_ser;
> + struct kho_block_it it;
> int err;
> - u64 i;
>
> if (!file_set_ser->files) {
> WARN_ON(file_set_ser->count);
> return 0;
> }
>
> - file_set->count = file_set_ser->count;
> - file_set->files = phys_to_virt(file_set_ser->files);
> + file_set->count = 0;
> + err = kho_block_restore(&file_set->block_set, file_set_ser->files);
> + if (err)
> + return err;
>
> /*
> * Note on error handling:
> @@ -848,25 +819,50 @@ int luo_file_deserialize(struct luo_file_set *file_set,
> * userspace to detect the failure and trigger a reboot, which will
> * reliably reset devices and reclaim memory.
> */
> - file_ser = file_set->files;
> - for (i = 0; i < file_set->count; i++) {
> - err = luo_file_deserialize_one(file_set, &file_ser[i]);
> + kho_block_it_init(&it, &file_set->block_set);
> + while ((file_ser = kho_block_it_read(&it))) {
> + err = luo_file_deserialize_one(file_set, file_ser);
> if (err)
> - return err;
> + goto err_destroy_blocks;
> + file_set->count++;
> + }
> +
> + if (file_set->count != file_set_ser->count) {
> + pr_warn("File count mismatch: expected %llu, found %llu\n",
> + file_set_ser->count, file_set->count);
> + err = -EINVAL;
> + goto err_destroy_blocks;
> }
>
> return 0;
> +
> +err_destroy_blocks:
> + while (!list_empty(&file_set->files_list)) {
> + struct luo_file *luo_file;
> +
> + luo_file = list_first_entry(&file_set->files_list,
> + struct luo_file, list);
> + list_del(&luo_file->list);
> + module_put(luo_file->fh->ops->owner);
> + mutex_destroy(&luo_file->mutex);
> + kfree(luo_file);
> + }
> + file_set->count = 0;
> + kho_block_destroy(&file_set->block_set);
> + return err;
> }
>
> void luo_file_set_init(struct luo_file_set *file_set)
> {
> INIT_LIST_HEAD(&file_set->files_list);
> + kho_block_set_init(&file_set->block_set, sizeof(struct luo_file_ser));
> }
>
> void luo_file_set_destroy(struct luo_file_set *file_set)
> {
> WARN_ON(file_set->count);
> WARN_ON(!list_empty(&file_set->files_list));
> + WARN_ON(!list_empty(&file_set->block_set.blocks));
Here too.
> }
>
> /**
> diff --git a/kernel/liveupdate/luo_internal.h b/kernel/liveupdate/luo_internal.h
> index ee18f9a11b91..64879ffe7378 100644
> --- a/kernel/liveupdate/luo_internal.h
> +++ b/kernel/liveupdate/luo_internal.h
> @@ -10,6 +10,7 @@
>
> #include <linux/liveupdate.h>
> #include <linux/uaccess.h>
> +#include <linux/kho_block.h>
>
> struct luo_ucmd {
> void __user *ubuffer;
> @@ -44,14 +45,13 @@ static inline int luo_ucmd_respond(struct luo_ucmd *ucmd,
> * struct luo_file_set - A set of files that belong to the same sessions.
> * @files_list: An ordered list of files associated with this session, it is
> * ordered by preservation time.
> - * @files: The physically contiguous memory block that holds the serialized
> - * state of files.
> + * @block_set: The set of serialization blocks.
> * @count: A counter tracking the number of files currently stored in the
> * @files_list for this session.
> */
> struct luo_file_set {
> struct list_head files_list;
> - struct luo_file_ser *files;
> + struct kho_block_set block_set;
> u64 count;
> };
--
Regards,
Pratyush Yadav
More information about the kexec
mailing list