On 05-12 15:58, Pratyush Yadav wrote:
> On Tue, Apr 14 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.
>
> Same comment as previous patch about a general linked block data
> structure here.
>
> >
> > ABI Changes:
> > - Define 'struct luo_file_header_ser' to manage linked blocks in preserved
> > memory.
> > - Update 'struct luo_file_set_ser' to point to the head of the block chain.
> > - Bump the session ABI version to 'luo-session-v4' to reflect these breaking
> > changes.
> >
> > Signed-off-by: Pasha Tatashin <[email protected]>
> > ---
> > include/linux/kho/abi/luo.h | 35 ++++-
> > kernel/liveupdate/luo_file.c | 226 ++++++++++++++++++++-----------
> > kernel/liveupdate/luo_internal.h | 17 ++-
> > 3 files changed, 189 insertions(+), 89 deletions(-)
> >
> > diff --git a/include/linux/kho/abi/luo.h b/include/linux/kho/abi/luo.h
> > index f5732958545e..a15f6a0f3d93 100644
> > --- a/include/linux/kho/abi/luo.h
> > +++ b/include/linux/kho/abi/luo.h
> > @@ -84,8 +84,13 @@
> > *
> > * - 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 luo_file_header_ser` for all files in that
> > session.
> > + * Multiple blocks are linked via the `next` field in the header.
> > + *
> > + * - struct luo_file_header_ser:
> > + * Header for the file data block. Contains the physical address of the
> > + * next file data block and the number of `struct luo_file_ser` entries
> > + * that follow this header in the current block.
> > *
> > * - struct luo_file_ser:
> > * Metadata for a single preserved file. Contains the `compatible`
> > string to
> > @@ -134,11 +139,29 @@ struct luo_file_ser {
> > u64 token;
> > } __packed;
> >
> > +/**
> > + * struct luo_file_header_ser - Header for the serialized file data block.
> > + * @next: Physical address of the next struct luo_file_header_ser.
> > + * @count: The number of `struct luo_file_ser` entries that immediately
> > + * follow this header in the memory block.
> > + *
> > + * This structure is located at the beginning of a block of
> > + * physical memory preserved across the kexec. It provides the necessary
> > + * metadata to interpret the array of file entries that follow.
> > + *
> > + * If this structure is modified, `LUO_FDT_SESSION_COMPATIBLE` must be
> > updated.
> > + */
> > +struct luo_file_header_ser {
>
> Nit: Same as before, can we rename it to make it clear that this is a
> block header?
Done
>
> > + u64 next;
> > + u64 count;
> > +} __packed;
> > +
> > /**
> > * 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
> > luo_file_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.
> > @@ -154,7 +177,7 @@ struct luo_file_set_ser {
> > * luo_session_header_ser
> > */
> > #define LUO_FDT_SESSION_NODE_NAME "luo-session"
> > -#define LUO_FDT_SESSION_COMPATIBLE "luo-session-v3"
> > +#define LUO_FDT_SESSION_COMPATIBLE "luo-session-v4"
> > #define LUO_FDT_SESSION_HEADER "luo-session-header"
> >
> > /**
> > diff --git a/kernel/liveupdate/luo_file.c b/kernel/liveupdate/luo_file.c
> > index dedbb8d02e6a..20a2d776cff4 100644
> > --- a/kernel/liveupdate/luo_file.c
> > +++ b/kernel/liveupdate/luo_file.c
> > @@ -119,10 +119,12 @@ 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 */
> > +/* 2 4K pages, give space for 127 files per block */
> > #define LUO_FILE_PGCNT 2ul
> > -#define LUO_FILE_MAX
> > \
> > - ((LUO_FILE_PGCNT << PAGE_SHIFT) / sizeof(struct luo_file_ser))
> > +#define LUO_FILE_BLOCK_MAX \
> > + (((LUO_FILE_PGCNT << PAGE_SHIFT) - \
> > + sizeof(struct luo_file_header_ser)) / \
> > + sizeof(struct luo_file_ser))
> >
> > /**
> > * struct luo_file - Represents a single preserved file instance.
> > @@ -158,7 +160,7 @@ static DEFINE_XARRAY(luo_preserved_files);
> > * and the serialized state handle returned by the handler's .preserve()
> > * operation.
> > *
> > - * These instances are tracked in a per-file_set list. The @serialized_data
> > + * These structures are tracked in a per-file_set list. The
> > @serialized_data
> > * field, which holds a handle to the file's serialized state, may be
> > updated
> > * during the .freeze() callback before being serialized for the next
> > kernel.
> > * After reboot, these structures are recreated by luo_file_deserialize()
> > and
> > @@ -175,37 +177,68 @@ struct luo_file {
> > u64 token;
> > };
> >
> > -static int luo_alloc_files_mem(struct luo_file_set *file_set)
> > +static int luo_file_add_block(struct luo_file_set *file_set,
> > + struct luo_file_header_ser *ser)
> > {
> > - size_t size;
> > - void *mem;
> > + struct luo_file_block *block;
> >
> > - if (file_set->files)
> > - return 0;
> > -
> > - WARN_ON_ONCE(file_set->count);
> > + if (file_set->nblocks >= LUO_MAX_BLOCKS)
> > + return -ENOSPC;
> >
> > - size = LUO_FILE_PGCNT << PAGE_SHIFT;
> > - mem = kho_alloc_preserve(size);
> > - if (IS_ERR(mem))
> > - return PTR_ERR(mem);
> > + block = kzalloc_obj(*block);
> > + if (!block)
> > + return -ENOMEM;
> >
> > - file_set->files = mem;
> > + block->ser = ser;
> > + list_add_tail(&block->list, &file_set->blocks);
> > + file_set->nblocks++;
> >
> > return 0;
> > }
> >
> > -static void luo_free_files_mem(struct luo_file_set *file_set)
> > +static int luo_file_create_ser_block(struct luo_file_set *file_set)
> > {
> > - /* If file_set has files, no need to free preservation memory */
> > - if (file_set->count)
> > - return;
> > + struct luo_file_block *last = NULL;
> > + struct luo_file_header_ser *ser;
> > + int err;
> >
> > - if (!file_set->files)
> > - return;
> > + ser = kho_alloc_preserve(LUO_FILE_PGCNT << PAGE_SHIFT);
> > + if (IS_ERR(ser))
> > + return PTR_ERR(ser);
> > +
> > + if (!list_empty(&file_set->blocks))
> > + last = list_last_entry(&file_set->blocks, struct
> > luo_file_block, list);
> > +
> > + err = luo_file_add_block(file_set, ser);
> > + if (err)
> > + goto err_unpreserve;
> > +
> > + if (last)
> > + last->ser->next = virt_to_phys(ser);
>
> Same comments as last patch about list_last_entry_or_null() and moving
> this to luo_file_add_block().
Done
>
> > +
> > + return 0;
> >
> > - kho_unpreserve_free(file_set->files);
> > - file_set->files = NULL;
> > +err_unpreserve:
> > + kho_unpreserve_free(ser);
> > + return err;
> > +}
> > +
> > +static void luo_file_destroy_ser_blocks(struct luo_file_set *file_set,
> > + bool unpreserve)
> > +{
> > + struct luo_file_block *block, *tmp;
> > +
> > + list_for_each_entry_safe(block, tmp, &file_set->blocks, list) {
> > + if (block->ser) {
>
> Same here. block is always created with its ser, so why have this check?
Removed.
>
> > + if (unpreserve)
> > + kho_unpreserve_free(block->ser);
> > + else
> > + kho_restore_free(block->ser);
>
> And same comment about the nastiness here, but once again I have nothing
> better to offer.
>
> > + }
> > + list_del(&block->list);
> > + kfree(block);
> > + file_set->nblocks--;
> > + }
> > }
> >
> > static unsigned long luo_get_id(struct liveupdate_file_handler *fh,
> > @@ -247,7 +280,9 @@ static bool luo_token_is_used(struct luo_file_set
> > *file_set, u64 token)
> > * 3. Iterates through registered handlers, calling can_preserve() to find
> > one
> > * compatible with the given @fd.
> > * 4. Calls the handler's .preserve() operation, which saves the file's
> > state
> > - * and returns an opaque private data handle.
> > + * and returns an opaque u64 handle. This is typically performed while
> > the
> > + * workload is still active to minimize the downtime during the
> > + * actual reboot transition.
> > * 5. Adds the new instance to the file_set's internal list.
> > *
> > * On success, LUO takes a reference to the 'struct file' and considers it
> > @@ -277,17 +312,16 @@ 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;
> > + if (file_set->count == file_set->nblocks * LUO_FILE_BLOCK_MAX) {
> > + err = luo_file_create_ser_block(file_set);
> > + if (err)
> > + return err;
> > + }
> >
> > file = fget(fd);
> > if (!file)
> > return -EBADF;
> >
> > - err = luo_alloc_files_mem(file_set);
> > - if (err)
> > - goto err_fput;
> > -
> > err = -ENOENT;
> > down_read(&luo_register_rwlock);
> > list_private_for_each_entry(fh, &luo_file_handler_list, list) {
> > @@ -301,7 +335,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;
> >
> > /* safe to use fh because its module is pinned */
> > err = xa_insert(&luo_preserved_files, luo_get_id(fh, file),
> > @@ -345,8 +379,6 @@ 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);
> >
> > @@ -399,7 +431,7 @@ void luo_file_unpreserve_files(struct luo_file_set
> > *file_set)
> > kfree(luo_file);
> > }
> >
> > - luo_free_files_mem(file_set);
> > + luo_file_destroy_ser_blocks(file_set, true);
> > }
> >
> > static int luo_file_freeze_one(struct luo_file_set *file_set,
> > @@ -446,6 +478,7 @@ static void __luo_file_unfreeze(struct luo_file_set
> > *file_set,
> > struct luo_file *failed_entry)
> > {
> > struct list_head *files_list = &file_set->files_list;
> > + struct luo_file_block *block;
> > struct luo_file *luo_file;
> >
> > list_for_each_entry(luo_file, files_list, list) {
> > @@ -455,7 +488,11 @@ 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);
> > + list_for_each_entry(block, &file_set->blocks, list) {
> > + block->ser->count = 0;
> > + memset(block->ser + 1, 0,
> > + (LUO_FILE_PGCNT << PAGE_SHIFT) - sizeof(*block->ser));
> > + }
> > }
> >
> > /**
> > @@ -494,7 +531,8 @@ 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_block *block;
> > + struct luo_file_ser *file_ser;
> > struct luo_file *luo_file;
> > int err;
> > int i;
> > @@ -502,11 +540,18 @@ int luo_file_freeze(struct luo_file_set *file_set,
> > if (!file_set->count)
> > return 0;
> >
> > - if (WARN_ON(!file_ser))
> > - return -EINVAL;
> > + block = list_first_entry(&file_set->blocks, struct luo_file_block,
> > list);
> > + file_ser = (void *)(block->ser + 1);
> >
> > i = 0;
> > list_for_each_entry(luo_file, &file_set->files_list, list) {
> > + if (i == LUO_FILE_BLOCK_MAX) {
> > + block->ser->count = i;
> > + block = list_next_entry(block, list);
> > + file_ser = (void *)(block->ser + 1);
> > + i = 0;
> > + }
> > +
> > err = luo_file_freeze_one(file_set, luo_file);
> > if (err < 0) {
> > pr_warn("Freeze failed for token[%#0llx] handler[%s]
> > err[%pe]\n",
> > @@ -521,10 +566,13 @@ int luo_file_freeze(struct luo_file_set *file_set,
> > file_ser[i].token = luo_file->token;
> > i++;
> > }
> > + block->ser->count = i;
> >
> > 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->blocks)) {
> > + block = list_first_entry(&file_set->blocks, struct
> > luo_file_block, list);
> > + file_set_ser->files = virt_to_phys(block->ser);
> > + }
> >
> > return 0;
> >
> > @@ -746,10 +794,7 @@ int luo_file_finish(struct luo_file_set *file_set)
> > kfree(luo_file);
> > }
> >
> > - if (file_set->files) {
> > - kho_restore_free(file_set->files);
> > - file_set->files = NULL;
> > - }
> > + luo_file_destroy_ser_blocks(file_set, false);
> >
> > return 0;
> > }
> > @@ -782,8 +827,10 @@ int luo_file_finish(struct luo_file_set *file_set)
> > int luo_file_deserialize(struct luo_file_set *file_set,
> > struct luo_file_set_ser *file_set_ser)
> > {
> > - struct luo_file_ser *file_ser;
> > - u64 i;
> > + struct luo_file_header_ser *header_ser;
> > + struct luo_file_block *block;
> > + u64 header_ser_pa;
> > + int err;
> >
> > if (!file_set_ser->files) {
> > WARN_ON(file_set_ser->count);
> > @@ -791,7 +838,15 @@ int luo_file_deserialize(struct luo_file_set *file_set,
> > }
> >
> > file_set->count = file_set_ser->count;
> > - file_set->files = phys_to_virt(file_set_ser->files);
> > + header_ser_pa = file_set_ser->files;
> > +
> > + while (header_ser_pa) {
> > + header_ser = phys_to_virt(header_ser_pa);
> > + err = luo_file_add_block(file_set, header_ser);
> > + if (err)
> > + return err;
> > + header_ser_pa = header_ser->next;
> > + }
> >
> > /*
> > * Note on error handling:
> > @@ -808,42 +863,51 @@ 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++) {
> > - struct liveupdate_file_handler *fh;
> > - bool handler_found = false;
> > - struct luo_file *luo_file;
> > -
> > - down_read(&luo_register_rwlock);
> > - list_private_for_each_entry(fh, &luo_file_handler_list, list) {
> > - if (!strcmp(fh->compatible, file_ser[i].compatible)) {
> > - if (try_module_get(fh->ops->owner))
> > - handler_found = true;
> > - break;
> > - }
> > - }
> > - up_read(&luo_register_rwlock);
> > + list_for_each_entry(block, &file_set->blocks, list) {
> > + struct luo_file_ser *file_ser = (void *)(block->ser + 1);
> >
> > - if (!handler_found) {
> > - pr_warn("No registered handler for compatible '%.*s'\n",
> > - (int)sizeof(file_ser[i].compatible),
> > - file_ser[i].compatible);
> > - return -ENOENT;
> > + if (block->ser->count > LUO_FILE_BLOCK_MAX) {
> > + pr_warn("File block contains too many entries: %llu\n",
> > + block->ser->count);
> > + return -EINVAL;
> > }
> >
> > - luo_file = kzalloc_obj(*luo_file);
> > - if (!luo_file) {
> > - module_put(fh->ops->owner);
> > - return -ENOMEM;
> > - }
> > + for (int i = 0; i < block->ser->count; i++) {
> > + struct liveupdate_file_handler *fh;
> > + bool handler_found = false;
> > + struct luo_file *luo_file;
> > +
> > + down_read(&luo_register_rwlock);
> > + list_private_for_each_entry(fh, &luo_file_handler_list,
> > list) {
> > + if (!strcmp(fh->compatible,
> > file_ser[i].compatible)) {
> > + if (try_module_get(fh->ops->owner))
> > + handler_found = true;
> > + break;
> > + }
> > + }
> > + up_read(&luo_register_rwlock);
> >
> > - /* safe to use fh because its module is pinned */
> > - luo_file->fh = fh;
> > - luo_file->file = NULL;
> > - luo_file->serialized_data = file_ser[i].data;
> > - luo_file->token = file_ser[i].token;
> > - mutex_init(&luo_file->mutex);
> > - list_add_tail(&luo_file->list, &file_set->files_list);
> > + if (!handler_found) {
> > + pr_warn("No registered handler for compatible
> > '%.*s'\n",
> > + (int)sizeof(file_ser[i].compatible),
> > + file_ser[i].compatible);
> > + return -ENOENT;
> > + }
> > +
> > + luo_file = kzalloc_obj(*luo_file);
> > + if (!luo_file) {
> > + module_put(fh->ops->owner);
> > + return -ENOMEM;
> > + }
> > +
> > + /* safe to use fh because its module is pinned */
> > + luo_file->fh = fh;
> > + luo_file->file = NULL;
> > + luo_file->serialized_data = file_ser[i].data;
> > + luo_file->token = file_ser[i].token;
> > + mutex_init(&luo_file->mutex);
> > + list_add_tail(&luo_file->list, &file_set->files_list);
> > + }
>
> Nit: this diff is very hard to read. Perhaps splitting this into helper
> functions would help?
Done, also added a patch to do the same for sessions.
>
> > }
> >
> > return 0;
> > @@ -852,12 +916,14 @@ int luo_file_deserialize(struct luo_file_set
> > *file_set,
> > void luo_file_set_init(struct luo_file_set *file_set)
> > {
> > INIT_LIST_HEAD(&file_set->files_list);
> > + INIT_LIST_HEAD(&file_set->blocks);
> > }
> >
> > 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->blocks));
> > }
> >
> > /**
> > diff --git a/kernel/liveupdate/luo_internal.h
> > b/kernel/liveupdate/luo_internal.h
> > index a73f42069301..a92aaa9c073d 100644
> > --- a/kernel/liveupdate/luo_internal.h
> > +++ b/kernel/liveupdate/luo_internal.h
> > @@ -50,19 +50,30 @@ static inline int luo_ucmd_respond(struct luo_ucmd
> > *ucmd,
> > */
> > #define luo_restore_fail(__fmt, ...) panic(__fmt, ##__VA_ARGS__)
> >
> > +/**
> > + * struct luo_file_block - Internal representation of a file serialization
> > block.
> > + * @list: List head for linking blocks in memory.
> > + * @ser: Pointer to the serialized header in preserved memory.
> > + */
> > +struct luo_file_block {
> > + struct list_head list;
> > + struct luo_file_header_ser *ser;
> > +};
> > +
> > /**
> > * 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.
> > + * @blocks: The list of serialization blocks (struct luo_file_block).
> > * @count: A counter tracking the number of files currently stored in
> > the
> > * @files_list for this session.
> > + * @nblocks: The number of allocated serialization blocks.
> > */
> > struct luo_file_set {
> > struct list_head files_list;
> > - struct luo_file_ser *files;
> > + struct list_head blocks;
> > long count;
> > + long nblocks;
> > };
> >
> > /**
>
> --
> Regards,
> Pratyush Yadav
