[PATCH 2/5] liveupdate: Remove limit on the number of files per session

Pasha Tatashin
2026-04-14T20:02:43Z

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.

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 <pasha.tatashin@soleen.com>
---
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 {
+ 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);
+
+ 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) {
+ if (unpreserve)
+ kho_unpreserve_free(block->ser);
+ else
+ kho_restore_free(block->ser);
+ }
+ 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);
+ }
}

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;
};

/**
--
2.43.0