+++ Christoph Hellwig [21/01/21 08:49 +0100]:
To uncouple the livepatch code from module loader internals move a slightly refactored version of klp_find_object_module to module.c This allows to mark find_module static and removes one of the last users of module_mutex outside of module.c.
Signed-off-by: Christoph Hellwig hch@lst.de
include/linux/module.h | 3 +-- kernel/livepatch/core.c | 39 +++++++++++++-------------------------- kernel/module.c | 17 ++++++++++++++++- 3 files changed, 30 insertions(+), 29 deletions(-)
diff --git a/include/linux/module.h b/include/linux/module.h index b4654f8a408134..8588482bde4116 100644 --- a/include/linux/module.h +++ b/include/linux/module.h @@ -586,8 +586,7 @@ static inline bool within_module(unsigned long addr, const struct module *mod) return within_module_init(addr, mod) || within_module_core(addr, mod); }
-/* Search for module by name: must hold module_mutex. */ -struct module *find_module(const char *name); +struct module *find_klp_module(const char *name);
/* Check if a module is loaded. */ bool module_loaded(const char *name); diff --git a/kernel/livepatch/core.c b/kernel/livepatch/core.c index a7f625dc24add3..878759baadd81c 100644 --- a/kernel/livepatch/core.c +++ b/kernel/livepatch/core.c @@ -49,30 +49,6 @@ static bool klp_is_module(struct klp_object *obj) return obj->name; }
-/* sets obj->mod if object is not vmlinux and module is found */ -static void klp_find_object_module(struct klp_object *obj) -{
- struct module *mod;
- mutex_lock(&module_mutex);
- /*
* We do not want to block removal of patched modules and therefore* we do not take a reference here. The patches are removed by* klp_module_going() instead.*/- mod = find_module(obj->name);
- /*
* Do not mess work of klp_module_coming() and klp_module_going().* Note that the patch might still be needed before klp_module_going()* is called. Module functions can be called even in the GOING state* until mod->exit() finishes. This is especially important for* patches that modify semantic of the functions.*/- if (mod && mod->klp_alive)
obj->mod = mod;- mutex_unlock(&module_mutex);
-}
Hmm, I am not a huge fan of moving more livepatch code into module.c, I wonder if we can keep them separate.
Why not have module_is_loaded() kill two birds with one stone? That is, just have it return a module pointer to signify that the module is loaded, NULL if not. Then we don't need an extra find_klp_module() function just to call find_module() and return a pointer, as module_is_loaded() can just do that for us.
As for the mod->klp_alive check, I believe this function (klp_find_object_module()) is called with klp_mutex held, and mod->klp_alive is only modified under klp_mutex. Also, if klp_alive is true, the module is at least COMING and cannot be GOING until it acquires the klp_mutex again in klp_module_going(). So does that hunk really need to be under module_mutex? It has been a long time since I've looked at livepatch code so it would be great if someone could double check.
Jessica