[PATCH 2/6] liveupdate: Protect FLB lists with rwsem

Pasha Tatashin
2026-03-17T02:51:01Z

Because liveupdate FLB objects will soon drop their persistent module
references when registered, list traversals must be protected against
concurrent module unloading.

Introduce two read-write semaphores to provide this protection:
1. A global luo_flb_lock protects the global registry of FLBs.
2. A per-handler flb_lock protects the handler's specific list of FLB
dependencies.

Read locks are used during concurrent list traversals (e.g., during
preservation and serialization). Write locks are taken during registration
and unregistration. When both locks are required, the global luo_flb_lock
is strictly acquired before the per-handler flb_lock to prevent deadlocks.

Signed-off-by: Pasha Tatashin <pasha.tatashin@soleen.com>
---
include/linux/liveupdate.h | 3 +++
kernel/liveupdate/luo_flb.c | 16 ++++++++++++++++
2 files changed, 19 insertions(+)

diff --git a/include/linux/liveupdate.h b/include/linux/liveupdate.h
index dd11fdc76a5f..8394fb2d8774 100644
--- a/include/linux/liveupdate.h
+++ b/include/linux/liveupdate.h
@@ -12,6 +12,7 @@
#include <linux/kho/abi/luo.h>
#include <linux/list.h>
#include <linux/mutex.h>
+#include <linux/rwsem.h>
#include <linux/types.h>
#include <uapi/linux/liveupdate.h>

@@ -107,6 +108,8 @@ struct liveupdate_file_handler {
struct list_head __private list;
/* A list of FLB dependencies. */
struct list_head __private flb_list;
+ /* Protects flb_list */
+ struct rw_semaphore __private flb_lock;
};

/**
diff --git a/kernel/liveupdate/luo_flb.c b/kernel/liveupdate/luo_flb.c
index f52e8114837e..91910d806d1d 100644
--- a/kernel/liveupdate/luo_flb.c
+++ b/kernel/liveupdate/luo_flb.c
@@ -49,6 +49,7 @@
#include <linux/liveupdate.h>
#include <linux/module.h>
#include <linux/mutex.h>
+#include <linux/rwsem.h>
#include <linux/slab.h>
#include <linux/unaligned.h>
#include "luo_internal.h"
@@ -70,6 +71,7 @@ struct luo_flb_global {
long count;
};

+static DECLARE_RWSEM(luo_flb_lock);
static struct luo_flb_global luo_flb_global = {
.list = LIST_HEAD_INIT(luo_flb_global.list),
};
@@ -240,6 +242,8 @@ int luo_flb_file_preserve(struct liveupdate_file_handler *fh)
struct luo_flb_link *iter;
int err = 0;

+ guard(rwsem_read)(&ACCESS_PRIVATE(fh, flb_lock));
+
list_for_each_entry(iter, flb_list, list) {
err = luo_flb_file_preserve_one(iter->flb);
if (err)
@@ -272,6 +276,8 @@ void luo_flb_file_unpreserve(struct liveupdate_file_handler *fh)
struct list_head *flb_list = &ACCESS_PRIVATE(fh, flb_list);
struct luo_flb_link *iter;

+ guard(rwsem_read)(&ACCESS_PRIVATE(fh, flb_lock));
+
list_for_each_entry_reverse(iter, flb_list, list)
luo_flb_file_unpreserve_one(iter->flb);
}
@@ -292,6 +298,8 @@ void luo_flb_file_finish(struct liveupdate_file_handler *fh)
struct list_head *flb_list = &ACCESS_PRIVATE(fh, flb_list);
struct luo_flb_link *iter;

+ guard(rwsem_read)(&ACCESS_PRIVATE(fh, flb_lock));
+
list_for_each_entry_reverse(iter, flb_list, list)
luo_flb_file_finish_one(iter->flb);
}
@@ -355,6 +363,9 @@ int liveupdate_register_flb(struct liveupdate_file_handler *fh,
if (!luo_session_quiesce())
return -EBUSY;

+ guard(rwsem_write)(&luo_flb_lock);
+ guard(rwsem_write)(&ACCESS_PRIVATE(fh, flb_lock));
+
/* Check that this FLB is not already linked to this file handler */
err = -EEXIST;
list_for_each_entry(iter, flb_list, list) {
@@ -444,6 +455,9 @@ int liveupdate_unregister_flb(struct liveupdate_file_handler *fh,
if (!luo_session_quiesce())
return -EBUSY;

+ guard(rwsem_write)(&luo_flb_lock);
+ guard(rwsem_write)(&ACCESS_PRIVATE(fh, flb_lock));
+
/* Find and remove the link from the file handler's list */
list_for_each_entry(iter, flb_list, list) {
if (iter->flb == flb) {
@@ -638,6 +652,8 @@ void luo_flb_serialize(void)
struct liveupdate_flb *gflb;
int i = 0;

+ guard(rwsem_read)(&luo_flb_lock);
+
list_private_for_each_entry(gflb, &luo_flb_global.list, private.list) {
struct luo_flb_private *private = luo_flb_get_private(gflb);

--
2.53.0.851.ga537e3e6e9-goog