On Sat, Nov 15, 2025 at 06:34:00PM -0500, Pasha Tatashin wrote:
> From: Pratyush Yadav <pratyush@kernel.org>
>
> Currently file handlers only get the serialized_data field to store
> their state. This field has a pointer to the serialized state of the
> file, and it becomes a part of LUO file's serialized state.
>
> File handlers can also need some runtime state to track information that
> shouldn't make it in the serialized data.
>
> One such example is a vmalloc pointer. While kho_preserve_vmalloc()
> preserves the memory backing a vmalloc allocation, it does not store the
> original vmap pointer, since that has no use being passed to the next
> kernel. The pointer is needed to free the memory in case the file is
> unpreserved.
>
> Provide a private field in struct luo_file and pass it to all the
> callbacks. The field's can be set by preserve, and must be freed by
> unpreserve.
>
> Signed-off-by: Pratyush Yadav <pratyush@kernel.org>
> Co-developed-by: Pasha Tatashin <pasha.tatashin@soleen.com>
> Signed-off-by: Pasha Tatashin <pasha.tatashin@soleen.com>
Reviewed-by: Mike Rapoport (Microsoft) <rppt@kernel.org>
> ---
> include/linux/liveupdate.h | 5 +++++
> kernel/liveupdate/luo_file.c | 9 +++++++++
> 2 files changed, 14 insertions(+)
>
> diff --git a/include/linux/liveupdate.h b/include/linux/liveupdate.h
> index 36a831ae3ead..defc69a1985d 100644
> --- a/include/linux/liveupdate.h
> +++ b/include/linux/liveupdate.h
> @@ -29,6 +29,10 @@ struct file;
> * this to the file being operated on.
> * @serialized_data: The opaque u64 handle, preserve/prepare/freeze may update
> * this field.
> + * @private_data: Private data for the file used to hold runtime state that
> + * is not preserved. Set by the handler's .preserve()
> + * callback, and must be freed in the handler's
> + * .unpreserve() callback.
> *
> * This structure bundles all parameters for the file operation callbacks.
> * The 'data' and 'file' fields are used for both input and output.
> @@ -39,6 +43,7 @@ struct liveupdate_file_op_args {
> bool retrieved;
> struct file *file;
> u64 serialized_data;
> + void *private_data;
> };
>
> /**
> diff --git a/kernel/liveupdate/luo_file.c b/kernel/liveupdate/luo_file.c
> index 3d3bd84cb281..df337c9c4f21 100644
> --- a/kernel/liveupdate/luo_file.c
> +++ b/kernel/liveupdate/luo_file.c
> @@ -126,6 +126,10 @@ static LIST_HEAD(luo_file_handler_list);
> * This handle is passed back to the handler's .freeze(),
> * .retrieve(), and .finish() callbacks, allowing it to track
> * and update its serialized state across phases.
> + * @private_data: Pointer to the private data for the file used to hold runtime
> + * state that is not preserved. Set by the handler's .preserve()
> + * callback, and must be freed in the handler's .unpreserve()
> + * callback.
> * @retrieved: A flag indicating whether a user/kernel in the new kernel has
> * successfully called retrieve() on this file. This prevents
> * multiple retrieval attempts.
> @@ -152,6 +156,7 @@ struct luo_file {
> struct liveupdate_file_handler *fh;
> struct file *file;
> u64 serialized_data;
> + void *private_data;
> bool retrieved;
> struct mutex mutex;
> struct list_head list;
> @@ -309,6 +314,7 @@ int luo_preserve_file(struct luo_session *session, u64 token, int fd)
> goto exit_err;
> } else {
> luo_file->serialized_data = args.serialized_data;
> + luo_file->private_data = args.private_data;
> list_add_tail(&luo_file->list, &session->files_list);
> session->count++;
> }
> @@ -356,6 +362,7 @@ void luo_file_unpreserve_files(struct luo_session *session)
> args.session = (struct liveupdate_session *)session;
> args.file = luo_file->file;
> args.serialized_data = luo_file->serialized_data;
> + args.private_data = luo_file->private_data;
> luo_file->fh->ops->unpreserve(&args);
> luo_flb_file_unpreserve(luo_file->fh);
>
> @@ -384,6 +391,7 @@ static int luo_file_freeze_one(struct luo_session *session,
> args.session = (struct liveupdate_session *)session;
> args.file = luo_file->file;
> args.serialized_data = luo_file->serialized_data;
> + args.private_data = luo_file->private_data;
>
> err = luo_file->fh->ops->freeze(&args);
> if (!err)
> @@ -405,6 +413,7 @@ static void luo_file_unfreeze_one(struct luo_session *session,
> args.session = (struct liveupdate_session *)session;
> args.file = luo_file->file;
> args.serialized_data = luo_file->serialized_data;
> + args.private_data = luo_file->private_data;
>
> luo_file->fh->ops->unfreeze(&args);
> }
> --
> 2.52.0.rc1.455.g30608eb744-goog
>
--
Sincerely yours,
Mike.