Re: [PATCH v1 1/7] liveupdate: Add LIVEUPDATE_SESSION_FREEZE ioctl to freeze sessions early

[Pasha Tatashin <pasha.tatashin@soleen.com>]

On 10-20 13:08, Pratyush Yadav wrote:
> Hi,
> 
> On Thu, Oct 15 2026, Pasha Tatashin wrote:
> 
> > Currently, LUO sessions are frozen automatically only inside the
> > reboot(LINUX_REBOOT_CMD_KEXEC) pathway, where luo_session_serialize()
> > iterates through all outgoing sessions under global write locks and
> > freezes them serially during shutdown. Allowing userspace to decide when
> > to freeze a session once it is done with it (and to freeze multiple
> > sessions in parallel, since luo_session_freeze() only acquires the
> > per-session mutex) avoids postponing this work to kexec shutdown and
> > reduces blackout time.
> >
> > Introduce LIVEUPDATE_SESSION_FREEZE on session file descriptors to freeze
> > a session early. The ioctl runs .freeze() across all preserved files in the
> > session and serializes their metadata. Once frozen, no additional files can
> > be added to the session, and subsequent freeze calls return -EBUSY. Freeze
> > is only valid on outgoing sessions and returns -EINVAL on incoming ones.
> >
> > During kexec, sessions that were already frozen early are skipped, while
> > sessions that did not invoke this ioctl auto-freeze as before. If an
> > early-frozen session is released before kexec, its files are rolled back
> > via .unfreeze() before being unpreserved.
> >
> > Signed-off-by: Pasha Tatashin <pasha.tatashin@soleen.com>
> [...]
> > @@ -487,8 +488,10 @@ int luo_file_freeze(struct luo_file_set *file_set,
> >  		file_ser->token = luo_file->token;
> >  	}
> >  
> > -	file_set_ser->count = file_set->count;
> > -	file_set_ser->files = kho_block_set_head_pa(&file_set->block_set);
> > +	if (file_set_ser) {
> > +		file_set_ser->count = file_set->count;
> > +		file_set_ser->files = kho_block_set_head_pa(&file_set->block_set);
> > +	}
> >  
> >  	return 0;
> >  
> > @@ -501,7 +504,7 @@ int luo_file_freeze(struct luo_file_set *file_set,
> >  /**
> >   * luo_file_unfreeze - Unfreezes all files in a file_set and clear serialization
> >   * @file_set:     The file_set whose files are to be unfrozen.
> > - * @file_set_ser: Serialized file_set.
> > + * @file_set_ser: Serialized file_set, or %NULL if not serialized yet.
> >   *
> >   * This function rolls back the state of all files in a file_set after the
> >   * freeze phase has begun but must be aborted. It is the counterpart to
> > @@ -512,7 +515,8 @@ int luo_file_freeze(struct luo_file_set *file_set,
> >   * their respective .unfreeze() handler callbacks.
> >   *
> >   * Context: This is called when the live update is aborted during
> > - *          the reboot() syscall, after luo_file_freeze() has been called.
> > + *          the reboot() syscall, after luo_file_freeze() has been called,
> > + *          or when an early-frozen session is released before kexec.
> >   */
> >  void luo_file_unfreeze(struct luo_file_set *file_set,
> >  		       struct luo_file_set_ser *file_set_ser)
> > @@ -521,7 +525,8 @@ void luo_file_unfreeze(struct luo_file_set *file_set,
> >  		return;
> >  
> >  	__luo_file_unfreeze(file_set, NULL);
> > -	memset(file_set_ser, 0, sizeof(*file_set_ser));
> > +	if (file_set_ser)
> > +		memset(file_set_ser, 0, sizeof(*file_set_ser));
> >  }
> >  
> >  /**
> > diff --git a/kernel/liveupdate/luo_internal.h b/kernel/liveupdate/luo_internal.h
> > index 64879ffe73781..b42369c3b1f30 100644
> > --- a/kernel/liveupdate/luo_internal.h
> > +++ b/kernel/liveupdate/luo_internal.h
> > @@ -64,6 +64,8 @@ struct luo_file_set {
> >   *              previous kernel) sessions.
> >   * @retrieved:  A boolean flag indicating whether this session has been
> >   *              retrieved by a consumer in the new kernel.
> > + * @frozen:     A boolean flag indicating whether this session has been
> > + *              frozen early from userspace.
> >   * @file_set:   A set of files that belong to this session.
> >   * @mutex:      protects fields in the luo_session.
> >   */
> > @@ -71,6 +73,7 @@ struct luo_session {
> >  	char name[LIVEUPDATE_SESSION_NAME_LENGTH];
> >  	struct list_head list;
> >  	bool retrieved;
> > +	bool frozen;
> >  	struct luo_file_set file_set;
> >  	struct mutex mutex;
> >  };
> > diff --git a/kernel/liveupdate/luo_session.c b/kernel/liveupdate/luo_session.c
> > index f48e9a4185f97..403906937bc0f 100644
> > --- a/kernel/liveupdate/luo_session.c
> > +++ b/kernel/liveupdate/luo_session.c
> > @@ -34,10 +34,11 @@
> >   * 1.  Creation: A userspace agent calls `luo_session_create()` to create a
> >   *     new, empty session and receives a file descriptor for it.
> >   *
> > - * 2.  Serialization: When the `reboot(LINUX_REBOOT_CMD_KEXEC)` syscall is
> > - *     made, `luo_session_serialize()` is called. It iterates through all
> > - *     active sessions and writes their metadata into a memory area preserved
> > - *     by KHO.
> > + * 2.  Freeze / Serialization: Sessions may be frozen early from userspace
> > + *     via `LIVEUPDATE_SESSION_FREEZE`. When the `reboot(LINUX_REBOOT_CMD_KEXEC)`
> > + *     syscall is made, `luo_session_serialize()` is called to freeze any
> > + *     remaining active sessions and write all session metadata into a memory
> > + *     area preserved by KHO.
> >   *
> >   * 3.  Deserialization (in new kernel): After kexec, `luo_session_deserialize()`
> >   *     runs, reading the serialized data and creating a list of `struct
> > @@ -222,6 +223,10 @@ static void luo_session_unfreeze_one(struct luo_session *session,
> >  				     struct luo_session_ser *ser)
> >  {
> >  	guard(mutex)(&session->mutex);
> > +	if (session->frozen) {
> > +		memset(&ser->file_set_ser, 0, sizeof(ser->file_set_ser));
> > +		return;
> > +	}
> >  	luo_file_unfreeze(&session->file_set, &ser->file_set_ser);
> >  }
> >  
> > @@ -229,6 +234,12 @@ static int luo_session_freeze_one(struct luo_session *session,
> >  				  struct luo_session_ser *ser)
> >  {
> >  	guard(mutex)(&session->mutex);
> > +	if (session->frozen) {
> > +		ser->file_set_ser.count = session->file_set.count;
> > +		ser->file_set_ser.files =
> > +			kho_block_set_head_pa(&session->file_set.block_set);
> > +		return 0;
> > +	}
> 
> This is getting messy. If early freeze, then you set the file_set_ser
> here, if late freeze, you set it in luo_file_freeze().
> 
> I think it is better to just set it here, and drop the code from
> luo_file_freeze() entirely.
> 
> Same for unfreeze.
> 
> Maybe also rename the function to make it clear it only runs for
> serialization? The core of serialization is done by luo_file_freeze().

Agreed, that is cleaner. In v2 I dropped struct luo_file_set_ser * from 
luo_file_freeze() and luo_file_unfreeze() completely, and renamed the 
session helpers to luo_session_serialize_one() / 
luo_session_unserialize_one() so all of struct luo_session_ser is 
populated and cleared there.

Pasha

> 
> >  	return luo_file_freeze(&session->file_set, &ser->file_set_ser);
> >  }
> >  
> > @@ -249,8 +260,11 @@ static int luo_session_release(struct inode *inodep, struct file *filep)
> >  		}
> >  		sh = &luo_session_global.incoming;
> >  	} else {
> > -		scoped_guard(mutex, &session->mutex)
> > +		scoped_guard(mutex, &session->mutex) {
> > +			if (session->frozen)
> > +				luo_file_unfreeze(&session->file_set, NULL);
> >  			luo_file_unpreserve_files(&session->file_set);
> > +		}
> >  		sh = &luo_session_global.outgoing;
> >  	}
> >  
> > @@ -267,6 +281,9 @@ static int luo_session_preserve_fd(struct luo_session *session,
> >  	int err;
> >  
> >  	guard(mutex)(&session->mutex);
> > +	if (session->frozen)
> > +		return -EBUSY;
> > +
> >  	err = luo_preserve_file(&session->file_set, argp->token, argp->fd);
> >  	if (err)
> >  		return err;
> > @@ -340,11 +357,34 @@ static int luo_session_get_name(struct luo_session *session,
> >  	return luo_ucmd_respond(ucmd, sizeof(*argp));
> >  }
> >  
> > +static int luo_session_freeze(struct luo_session *session,
> > +			      struct luo_ucmd *ucmd)
> > +{
> > +	struct liveupdate_session_freeze *argp = ucmd->cmd;
> > +	int err;
> > +
> > +	if (argp->reserved)
> > +		return -EINVAL;
> > +
> > +	guard(mutex)(&session->mutex);
> > +	if (session->frozen)
> > +		return -EBUSY;
> > +
> > +	err = luo_file_freeze(&session->file_set, NULL);
> > +	if (err)
> > +		return err;
> > +
> > +	session->frozen = true;
> > +
> > +	return luo_ucmd_respond(ucmd, sizeof(*argp));
> > +}
> > +
> [...]
> 
> -- 
> Regards,
> Pratyush Yadav