On Tue 2021-01-26 15:25:16, Jessica Yu wrote:

+++ 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.

We need to make sure that the module is not freed before we manipulate mod->klp_alive.

One solution would be to take the reference and block it during this operation.

Alternatively it might be to rely on RCU. It seems that the struct is protected by RCU because of kallsyms. But I am not sure if it is safe in all module states. But it should be. We find the module via the same list like kallsyms.

Best Regards, Petr