+++ Zhiqiang Liu [20/07/19 22:40 +0800]:
Users can call ref_module func in their modules to construct relationships with other modules. However, the holders '/sys/module/<mod-name>/holders' of the target module donot include the users` module. So lsmod command misses detailed info of 'Used by'.When load module, the process is given as follows, load_module() -> mod_sysfs_setup() -> add_usage_links -> do_init_module -> mod->init() add_usage_links func creates holders of target modules linking to this module. If ref_module is called in mod->init() func, the usage links cannot be added. Consider that add_module_usage and add usage_link may separate, the link_flag pram is added in ref_module func to decide whether add usage link after add_module_usage. If link_flag is true, it means usage link of a to b's holder_dir should be created immediately after add_module_usage. V2->V3: - add link_flag pram in ref_module func to decide whether add usage link V1->V2: - remove incorrect Fixes tag - fix error handling of sysfs_create_link as suggested by Jessica Yu Signed-off-by: Zhiqiang Liu <liuzhiqian...@huawei.com> Suggested-by: Jessica Yu <j...@kernel.org> Reviewed-by: Kang Zhou <zhouka...@huawei.com> --- include/linux/module.h | 2 +- kernel/module.c | 27 ++++++++++++++++++++------- 2 files changed, 21 insertions(+), 8 deletions(-) diff --git a/include/linux/module.h b/include/linux/module.h index 188998d3dca9..9ec04b9e93e8 100644 --- a/include/linux/module.h +++ b/include/linux/module.h @@ -632,7 +632,7 @@ static inline void __module_get(struct module *module) #define symbol_put_addr(p) do { } while (0) #endif /* CONFIG_MODULE_UNLOAD */ -int ref_module(struct module *a, struct module *b); +int ref_module(struct module *a, struct module *b, bool link_flag); /* This is a #define so the string doesn't get put in every .o file */ #define module_name(mod) \ diff --git a/kernel/module.c b/kernel/module.c index 80c7c09584cf..00e4862a8ef7 100644 --- a/kernel/module.c +++ b/kernel/module.c @@ -837,25 +837,26 @@ static int already_uses(struct module *a, struct module *b) * 'b' can walk the list to see who sourced them), and of 'a' * targets (so 'a' can see what modules it targets). */ -static int add_module_usage(struct module *a, struct module *b) +static struct module_use *add_module_usage(struct module *a, struct module *b) { struct module_use *use; pr_debug("Allocating new usage for %s.\n", a->name); use = kmalloc(sizeof(*use), GFP_ATOMIC); if (!use) - return -ENOMEM; + return NULL; use->source = a; use->target = b; list_add(&use->source_list, &b->source_list); list_add(&use->target_list, &a->target_list); - return 0; + return use; } /* Module a uses b: caller needs module_mutex() */ -int ref_module(struct module *a, struct module *b) +int ref_module(struct module *a, struct module *b, bool link_flag) { + struct module_use *use; int err; if (b == NULL || already_uses(a, b)) @@ -866,9 +867,21 @@ int ref_module(struct module *a, struct module *b) if (err) return err; - err = add_module_usage(a, b); + use = add_module_usage(a, b); + if (!use) { + module_put(b); + return -ENOMEM; + } + + if (!link_flag) + return 0; + + err = sysfs_create_link(b->holders_dir, &a->mkobj.kobj, a->name); if (err) { module_put(b); + list_del(&use->source_list); + list_del(&use->target_list); + kfree(use); return err; } return 0; @@ -1152,7 +1165,7 @@ static inline void module_unload_free(struct module *mod) { } -int ref_module(struct module *a, struct module *b) +int ref_module(struct module *a, struct module *b, bool link_flag) { return strong_try_module_get(b); } @@ -1407,7 +1420,7 @@ static const struct kernel_symbol *resolve_symbol(struct module *mod, goto getname; } - err = ref_module(mod, owner); + err = ref_module(mod, owner, false);
Thanks a lot for pinging me. If I'm remembering correctly, we had to do this because sysfs intialization is being done too late in load_module(). The last time I was tinkering with a solution, I think I was able to avoid needing this extra link_flag param by moving the mod_sysfs_setup() call earlier in load_module(). It just looks a lot cleaner that way, without that extra param. Have you looked into trying that? I would prefer that solution rather than adding another argument to ref_module(). Thanks, Jessica
