Lines Matching refs:mod
116 static void mod_update_bounds(struct module *mod)
119 struct module_memory *mod_mem = &mod->mem[type];
152 static inline int strong_try_module_get(struct module *mod)
154 BUG_ON(mod && mod->state == MODULE_STATE_UNFORMED);
155 if (mod && mod->state == MODULE_STATE_COMING)
157 if (try_module_get(mod))
163 static inline void add_taint_module(struct module *mod, unsigned flag,
167 set_bit(flag, &mod->taints);
174 void __noreturn __module_put_and_kthread_exit(struct module *mod, long code)
176 module_put(mod);
311 struct module *mod;
320 list_for_each_entry_rcu(mod, &modules, list,
323 { mod->syms, mod->syms + mod->num_syms, mod->crcs,
325 { mod->gpl_syms, mod->gpl_syms + mod->num_gpl_syms,
326 mod->gpl_crcs,
330 if (mod->state == MODULE_STATE_UNFORMED)
334 if (find_exported_symbol_in_section(&arr[i], mod, fsa))
349 struct module *mod;
353 list_for_each_entry_rcu(mod, &modules, list,
355 if (!even_unformed && mod->state == MODULE_STATE_UNFORMED)
357 if (strlen(mod->name) == len && !memcmp(mod->name, name, len))
358 return mod;
370 static inline void __percpu *mod_percpu(struct module *mod)
372 return mod->percpu;
375 static int percpu_modalloc(struct module *mod, struct load_info *info)
385 mod->name, align, PAGE_SIZE);
389 mod->percpu = __alloc_reserved_percpu(pcpusec->sh_size, align);
390 if (!mod->percpu) {
392 mod->name, (unsigned long)pcpusec->sh_size);
395 mod->percpu_size = pcpusec->sh_size;
399 static void percpu_modfree(struct module *mod)
401 free_percpu(mod->percpu);
409 static void percpu_modcopy(struct module *mod,
415 memcpy(per_cpu_ptr(mod->percpu, cpu), from, size);
420 struct module *mod;
425 list_for_each_entry_rcu(mod, &modules, list) {
426 if (mod->state == MODULE_STATE_UNFORMED)
428 if (!mod->percpu_size)
431 void *start = per_cpu_ptr(mod->percpu, cpu);
434 if (va >= start && va < start + mod->percpu_size) {
438 per_cpu_ptr(mod->percpu,
466 static inline void __percpu *mod_percpu(struct module *mod)
470 static int percpu_modalloc(struct module *mod, struct load_info *info)
477 static inline void percpu_modfree(struct module *mod)
484 static inline void percpu_modcopy(struct module *mod,
503 static void setup_modinfo_##field(struct module *mod, const char *s) \
505 mod->field = kstrdup(s, GFP_KERNEL); \
510 return scnprintf(buffer, PAGE_SIZE, "%s\n", mk->mod->field); \
512 static int modinfo_##field##_exists(struct module *mod) \
514 return mod->field != NULL; \
516 static void free_modinfo_##field(struct module *mod) \
518 kfree(mod->field); \
519 mod->field = NULL; \
545 static int module_unload_init(struct module *mod)
551 atomic_set(&mod->refcnt, MODULE_REF_BASE);
553 INIT_LIST_HEAD(&mod->source_list);
554 INIT_LIST_HEAD(&mod->target_list);
557 atomic_inc(&mod->refcnt);
620 static void module_unload_free(struct module *mod)
625 list_for_each_entry_safe(use, tmp, &mod->target_list, target_list) {
627 pr_debug("%s unusing %s\n", mod->name, i->name);
652 static int try_release_module_ref(struct module *mod)
657 ret = atomic_sub_return(MODULE_REF_BASE, &mod->refcnt);
661 ret = atomic_add_unless(&mod->refcnt, MODULE_REF_BASE, 0);
666 static int try_stop_module(struct module *mod, int flags, int *forced)
669 if (try_release_module_ref(mod) != 0) {
676 mod->state = MODULE_STATE_GOING;
683 * @mod: the module we're checking
689 int module_refcount(struct module *mod)
691 return atomic_read(&mod->refcnt) - MODULE_REF_BASE;
696 static void free_module(struct module *mod);
701 struct module *mod;
718 mod = find_module(name);
719 if (!mod) {
724 if (!list_empty(&mod->source_list)) {
731 if (mod->state != MODULE_STATE_LIVE) {
733 pr_debug("%s already dying\n", mod->name);
739 if (mod->init && !mod->exit) {
748 ret = try_stop_module(mod, flags, &forced);
754 if (mod->exit != NULL)
755 mod->exit();
757 MODULE_STATE_GOING, mod);
758 klp_module_going(mod);
759 ftrace_release_mod(mod);
764 strscpy(last_unloaded_module.name, mod->name, sizeof(last_unloaded_module.name));
765 strscpy(last_unloaded_module.taints, module_flags(mod, buf, false), sizeof(last_unloaded_module.taints));
767 free_module(mod);
814 return sprintf(buffer, "%i\n", module_refcount(mk->mod));
858 static inline void module_unload_free(struct module *mod)
867 static inline int module_unload_init(struct module *mod)
891 switch (mk->mod->state) {
926 unsigned int size = mk->mod->mem[MOD_TEXT].size;
930 size += mk->mod->mem[type].size;
945 size += mk->mod->mem[type].size;
959 size += mk->mod->mem[type].size;
971 l = module_flags_taint(mk->mod->taints, buffer);
1000 int try_to_force_load(struct module *mod, const char *reason)
1004 pr_warn("%s: %s: kernel tainted.\n", mod->name, reason);
1005 add_taint_module(mod, TAINT_FORCED_MODULE, LOCKDEP_NOW_UNRELIABLE);
1064 struct module *mod)
1081 mod->name, kernel_symbol_name(sym), namespace);
1089 static bool inherit_taint(struct module *mod, struct module *owner, const char *name)
1094 if (mod->using_gplonly_symbols) {
1096 mod->name, name, owner->name);
1100 if (!test_bit(TAINT_PROPRIETARY_MODULE, &mod->taints)) {
1102 mod->name, name, owner->name);
1103 set_bit(TAINT_PROPRIETARY_MODULE, &mod->taints);
1109 static const struct kernel_symbol *resolve_symbol(struct module *mod,
1116 .gplok = !(mod->taints & (1 << TAINT_PROPRIETARY_MODULE)),
1132 mod->using_gplonly_symbols = true;
1134 if (!inherit_taint(mod, fsa.owner, name)) {
1139 if (!check_version(info, name, mod, fsa.crc)) {
1144 err = verify_namespace_is_imported(info, fsa.sym, mod);
1150 err = ref_module(mod, fsa.owner);
1165 resolve_symbol_wait(struct module *mod,
1173 !IS_ERR(ksym = resolve_symbol(mod, info, name, owner))
1177 mod->name, owner);
1192 void __weak module_arch_cleanup(struct module *mod)
1196 void __weak module_arch_freeing_init(struct module *mod)
1221 static void free_mod_mem(struct module *mod)
1224 struct module_memory *mod_mem = &mod->mem[type];
1235 /* MOD_DATA hosts mod, so free it at last */
1236 lockdep_free_key_range(mod->mem[MOD_DATA].base, mod->mem[MOD_DATA].size);
1237 module_memory_free(mod->mem[MOD_DATA].base, MOD_DATA);
1241 static void free_module(struct module *mod)
1243 trace_module_free(mod);
1245 mod_sysfs_teardown(mod);
1252 mod->state = MODULE_STATE_UNFORMED;
1256 module_arch_cleanup(mod);
1259 module_unload_free(mod);
1262 destroy_params(mod->kp, mod->num_kp);
1264 if (is_livepatch_module(mod))
1265 free_module_elf(mod);
1270 list_del_rcu(&mod->list);
1271 mod_tree_remove(mod);
1273 module_bug_cleanup(mod);
1274 /* Wait for RCU-sched synchronizing before releasing mod->list and buglist. */
1276 if (try_add_tainted_module(mod))
1278 mod->name);
1282 module_arch_freeing_init(mod);
1283 kfree(mod->args);
1284 percpu_modfree(mod);
1286 free_mod_mem(mod);
1321 static int verify_exported_symbols(struct module *mod)
1329 { mod->syms, mod->num_syms },
1330 { mod->gpl_syms, mod->num_gpl_syms },
1342 mod->name, kernel_symbol_name(s),
1367 static int simplify_symbols(struct module *mod, const struct load_info *info)
1391 mod->name);
1406 ksym = resolve_symbol_wait(mod, info, name);
1421 mod->name, name, ret);
1427 secbase = (unsigned long)mod_percpu(mod);
1438 static int apply_relocations(struct module *mod, const struct load_info *info)
1456 err = klp_apply_section_relocs(mod, info->sechdrs,
1463 info->index.sym, i, mod);
1466 info->index.sym, i, mod);
1474 unsigned int __weak arch_mod_section_prepend(struct module *mod,
1481 long module_get_offset_and_type(struct module *mod, enum mod_mem_type type,
1487 mod->mem[type].size += arch_mod_section_prepend(mod, section);
1488 offset = ALIGN(mod->mem[type].size, sechdr->sh_addralign ?: 1);
1489 mod->mem[type].size = offset + sechdr->sh_size;
1504 static void __layout_sections(struct module *mod, struct load_info *info, bool is_init)
1551 s->sh_entsize = module_get_offset_and_type(mod, type, s, i);
1563 static void layout_sections(struct module *mod, struct load_info *info)
1570 pr_debug("Core section allocation order for %s:\n", mod->name);
1571 __layout_sections(mod, info, false);
1573 pr_debug("Init section allocation order for %s:\n", mod->name);
1574 __layout_sections(mod, info, true);
1577 static void module_license_taint_check(struct module *mod, const char *license)
1585 mod->name, license);
1586 add_taint_module(mod, TAINT_PROPRIETARY_MODULE,
1591 static void setup_modinfo(struct module *mod, struct load_info *info)
1598 attr->setup(mod, get_modinfo(info, attr->attr.name));
1602 static void free_modinfo(struct module *mod)
1609 attr->free(mod);
1664 * As a last step we set info->mod to the temporary copy of the module in
1836 * modpost declares it on each modules's *.mod.c file. If the struct
1877 info->index.mod = mod_idx;
1879 /* This is temporary: point mod into copy of data. */
1880 info->mod = (void *)info->hdr + shdr->sh_offset;
1884 * on-disk struct mod 'name' field.
1887 info->name = info->mod->name;
1919 static int check_modinfo_livepatch(struct module *mod, struct load_info *info)
1925 if (set_livepatch_module(mod))
1929 mod->name);
1933 static void check_modinfo_retpoline(struct module *mod, struct load_info *info)
1939 mod->name);
2010 static void module_augment_kernel_taints(struct module *mod, struct load_info *info)
2017 mod->name);
2018 add_taint_module(mod, TAINT_OOT_MODULE, LOCKDEP_STILL_OK);
2021 check_modinfo_retpoline(mod, info);
2024 add_taint_module(mod, TAINT_CRAP, LOCKDEP_STILL_OK);
2026 "is unknown, you have been warned.\n", mod->name);
2029 if (is_livepatch_module(mod)) {
2030 add_taint_module(mod, TAINT_LIVEPATCH, LOCKDEP_STILL_OK);
2032 mod->name);
2035 module_license_taint_check(mod, get_modinfo(info, "license"));
2040 mod->name);
2041 add_taint_module(mod, TAINT_TEST, LOCKDEP_STILL_OK);
2044 mod->sig_ok = info->sig_ok;
2045 if (!mod->sig_ok) {
2048 "kernel\n", mod->name);
2049 add_taint_module(mod, TAINT_UNSIGNED_MODULE, LOCKDEP_STILL_OK);
2058 if (strcmp(mod->name, "ndiswrapper") == 0)
2062 if (strcmp(mod->name, "driverloader") == 0)
2063 add_taint_module(mod, TAINT_PROPRIETARY_MODULE,
2067 if (strcmp(mod->name, "lve") == 0)
2068 add_taint_module(mod, TAINT_PROPRIETARY_MODULE,
2072 pr_warn("%s: module license taints kernel.\n", mod->name);
2076 static int check_modinfo(struct module *mod, struct load_info *info, int flags)
2086 err = try_to_force_load(mod, "bad vermagic");
2095 err = check_modinfo_livepatch(mod, info);
2102 static int find_module_sections(struct module *mod, struct load_info *info)
2104 mod->kp = section_objs(info, "__param",
2105 sizeof(*mod->kp), &mod->num_kp);
2106 mod->syms = section_objs(info, "__ksymtab",
2107 sizeof(*mod->syms), &mod->num_syms);
2108 mod->crcs = section_addr(info, "__kcrctab");
2109 mod->gpl_syms = section_objs(info, "__ksymtab_gpl",
2110 sizeof(*mod->gpl_syms),
2111 &mod->num_gpl_syms);
2112 mod->gpl_crcs = section_addr(info, "__kcrctab_gpl");
2115 mod->ctors = section_objs(info, ".ctors",
2116 sizeof(*mod->ctors), &mod->num_ctors);
2117 if (!mod->ctors)
2118 mod->ctors = section_objs(info, ".init_array",
2119 sizeof(*mod->ctors), &mod->num_ctors);
2126 mod->name);
2131 mod->noinstr_text_start = section_objs(info, ".noinstr.text", 1,
2132 &mod->noinstr_text_size);
2135 mod->tracepoints_ptrs = section_objs(info, "__tracepoints_ptrs",
2136 sizeof(*mod->tracepoints_ptrs),
2137 &mod->num_tracepoints);
2140 mod->srcu_struct_ptrs = section_objs(info, "___srcu_struct_ptrs",
2141 sizeof(*mod->srcu_struct_ptrs),
2142 &mod->num_srcu_structs);
2145 mod->bpf_raw_events = section_objs(info, "__bpf_raw_tp_map",
2146 sizeof(*mod->bpf_raw_events),
2147 &mod->num_bpf_raw_events);
2150 mod->btf_data = any_section_objs(info, ".BTF", 1, &mod->btf_data_size);
2153 mod->jump_entries = section_objs(info, "__jump_table",
2154 sizeof(*mod->jump_entries),
2155 &mod->num_jump_entries);
2158 mod->trace_events = section_objs(info, "_ftrace_events",
2159 sizeof(*mod->trace_events),
2160 &mod->num_trace_events);
2161 mod->trace_evals = section_objs(info, "_ftrace_eval_map",
2162 sizeof(*mod->trace_evals),
2163 &mod->num_trace_evals);
2166 mod->trace_bprintk_fmt_start = section_objs(info, "__trace_printk_fmt",
2167 sizeof(*mod->trace_bprintk_fmt_start),
2168 &mod->num_trace_bprintk_fmt);
2172 mod->ftrace_callsites = section_objs(info, FTRACE_CALLSITE_SECTION,
2173 sizeof(*mod->ftrace_callsites),
2174 &mod->num_ftrace_callsites);
2177 mod->ei_funcs = section_objs(info, "_error_injection_whitelist",
2178 sizeof(*mod->ei_funcs),
2179 &mod->num_ei_funcs);
2182 mod->kprobes_text_start = section_objs(info, ".kprobes.text", 1,
2183 &mod->kprobes_text_size);
2184 mod->kprobe_blacklist = section_objs(info, "_kprobe_blacklist",
2186 &mod->num_kprobe_blacklist);
2189 mod->printk_index_start = section_objs(info, ".printk_index",
2190 sizeof(*mod->printk_index_start),
2191 &mod->printk_index_size);
2194 mod->static_call_sites = section_objs(info, ".static_call_sites",
2195 sizeof(*mod->static_call_sites),
2196 &mod->num_static_call_sites);
2199 mod->kunit_suites = section_objs(info, ".kunit_test_suites",
2200 sizeof(*mod->kunit_suites),
2201 &mod->num_kunit_suites);
2202 mod->kunit_init_suites = section_objs(info, ".kunit_init_test_suites",
2203 sizeof(*mod->kunit_init_suites),
2204 &mod->num_kunit_init_suites);
2207 mod->extable = section_objs(info, "__ex_table",
2208 sizeof(*mod->extable), &mod->num_exentries);
2211 pr_warn("%s: Ignoring obsolete parameters\n", mod->name);
2214 mod->dyndbg_info.descs = section_objs(info, "__dyndbg",
2215 sizeof(*mod->dyndbg_info.descs),
2216 &mod->dyndbg_info.num_descs);
2217 mod->dyndbg_info.classes = section_objs(info, "__dyndbg_classes",
2218 sizeof(*mod->dyndbg_info.classes),
2219 &mod->dyndbg_info.num_classes);
2225 static int move_module(struct module *mod, struct load_info *info)
2233 if (!mod->mem[type].size) {
2234 mod->mem[type].base = NULL;
2237 mod->mem[type].size = PAGE_ALIGN(mod->mem[type].size);
2238 ptr = module_memory_alloc(mod->mem[type].size, type);
2255 memset(ptr, 0, mod->mem[type].size);
2256 mod->mem[type].base = ptr;
2260 pr_debug("Final section addresses for %s:\n", mod->name);
2269 dest = mod->mem[type].base + (shdr->sh_entsize & SH_ENTSIZE_OFFSET_MASK);
2278 if (i == info->index.mod &&
2299 module_memory_free(mod->mem[t].base, t);
2303 static int check_export_symbol_versions(struct module *mod)
2306 if ((mod->num_syms && !mod->crcs) ||
2307 (mod->num_gpl_syms && !mod->gpl_crcs)) {
2308 return try_to_force_load(mod,
2315 static void flush_module_icache(const struct module *mod)
2323 const struct module_memory *mod_mem = &mod->mem[type];
2340 struct module *mod)
2368 struct module *mod;
2374 info->secstrings, info->mod);
2379 info->secstrings, info->mod);
2409 layout_sections(info->mod, info);
2410 layout_symtab(info->mod, info);
2413 err = move_module(info->mod, info);
2418 mod = (void *)info->sechdrs[info->index.mod].sh_addr;
2419 kmemleak_load_module(mod, info);
2420 return mod;
2423 /* mod is no longer valid after this! */
2424 static void module_deallocate(struct module *mod, struct load_info *info)
2426 percpu_modfree(mod);
2427 module_arch_freeing_init(mod);
2429 free_mod_mem(mod);
2439 static int post_relocation(struct module *mod, const struct load_info *info)
2442 sort_extable(mod->extable, mod->extable + mod->num_exentries);
2445 percpu_modcopy(mod, (void *)info->sechdrs[info->index.pcpu].sh_addr,
2449 add_kallsyms(mod, info);
2452 return module_finalize(info->hdr, info->sechdrs, mod);
2456 static void do_mod_ctors(struct module *mod)
2461 for (i = 0; i < mod->num_ctors; i++)
2462 mod->ctors[i]();
2509 static noinline int do_init_module(struct module *mod)
2517 const struct module_memory *mod_mem = &mod->mem[type];
2531 freeinit->init_text = mod->mem[MOD_INIT_TEXT].base;
2532 freeinit->init_data = mod->mem[MOD_INIT_DATA].base;
2533 freeinit->init_rodata = mod->mem[MOD_INIT_RODATA].base;
2535 do_mod_ctors(mod);
2537 if (mod->init != NULL)
2538 ret = do_one_initcall(mod->init);
2546 __func__, mod->name, ret, __func__);
2551 mod->state = MODULE_STATE_LIVE;
2553 MODULE_STATE_LIVE, mod);
2556 kobject_uevent(&mod->mkobj.kobj, KOBJ_ADD);
2566 if (!mod->async_probe_requested)
2569 ftrace_free_mem(mod, mod->mem[MOD_INIT_TEXT].base,
2570 mod->mem[MOD_INIT_TEXT].base + mod->mem[MOD_INIT_TEXT].size);
2573 module_put(mod);
2574 trim_init_extable(mod);
2577 rcu_assign_pointer(mod->kallsyms, &mod->core_kallsyms);
2579 ret = module_enable_rodata_ro(mod, true);
2582 mod_tree_remove_init(mod);
2583 module_arch_freeing_init(mod);
2585 mod->mem[type].base = NULL;
2586 mod->mem[type].size = 0;
2591 mod->btf_data = NULL;
2625 mod->state = MODULE_STATE_GOING;
2627 module_put(mod);
2629 MODULE_STATE_GOING, mod);
2630 klp_module_going(mod);
2631 ftrace_release_mod(mod);
2632 free_module(mod);
2649 struct module *mod;
2659 mod = find_module_all(name, strlen(name), true);
2660 ret = !mod || mod->state == MODULE_STATE_LIVE
2661 || mod->state == MODULE_STATE_GOING;
2712 static int add_unformed_module(struct module *mod)
2716 mod->state = MODULE_STATE_UNFORMED;
2719 err = module_patient_check_exists(mod->name, FAIL_DUP_MOD_LOAD);
2723 mod_update_bounds(mod);
2724 list_add_rcu(&mod->list, &modules);
2725 mod_tree_insert(mod);
2733 static int complete_formation(struct module *mod, struct load_info *info)
2740 err = verify_exported_symbols(mod);
2745 module_bug_finalize(info->hdr, info->sechdrs, mod);
2746 module_cfi_finalize(info->hdr, info->sechdrs, mod);
2748 err = module_enable_rodata_ro(mod, false);
2751 err = module_enable_data_nx(mod);
2754 err = module_enable_text_rox(mod);
2762 mod->state = MODULE_STATE_COMING;
2768 module_bug_cleanup(mod);
2774 static int prepare_coming_module(struct module *mod)
2778 ftrace_module_enable(mod);
2779 err = klp_module_coming(mod);
2784 MODULE_STATE_COMING, MODULE_STATE_GOING, mod);
2787 klp_module_going(mod);
2795 struct module *mod = arg;
2799 if (kstrtobool(val, &mod->async_probe_requested))
2800 mod->async_probe_requested = true;
2830 if (!check_modstruct_version(info, info->mod))
2833 err = check_modinfo(info->mod, info, flags);
2838 err = module_patient_check_exists(info->mod->name, FAIL_DUP_MOD_BECOMING);
2851 struct module *mod;
2875 * info->mod to the userspace passed struct module.
2886 mod = layout_and_allocate(info, flags);
2887 if (IS_ERR(mod)) {
2888 err = PTR_ERR(mod);
2894 audit_log_kern_module(mod->name);
2897 err = add_unformed_module(mod);
2905 module_augment_kernel_taints(mod, info);
2908 err = percpu_modalloc(mod, info);
2913 err = module_unload_init(mod);
2917 init_param_lock(mod);
2923 err = find_module_sections(mod, info);
2927 err = check_export_symbol_versions(mod);
2932 setup_modinfo(mod, info);
2935 err = simplify_symbols(mod, info);
2939 err = apply_relocations(mod, info);
2943 err = post_relocation(mod, info);
2947 flush_module_icache(mod);
2950 mod->args = strndup_user(uargs, ~0UL >> 1);
2951 if (IS_ERR(mod->args)) {
2952 err = PTR_ERR(mod->args);
2956 init_build_id(mod, info);
2959 ftrace_module_init(mod);
2962 err = complete_formation(mod, info);
2966 err = prepare_coming_module(mod);
2970 mod->async_probe_requested = async_probe;
2973 after_dashes = parse_args(mod->name, mod->args, mod->kp, mod->num_kp,
2974 -32768, 32767, mod,
2981 mod->name, after_dashes);
2985 err = mod_sysfs_setup(mod, info, mod->kp, mod->num_kp);
2989 if (is_livepatch_module(mod)) {
2990 err = copy_module_elf(mod, info);
2999 trace_module_load(mod);
3001 return do_init_module(mod);
3004 mod_sysfs_teardown(mod);
3006 mod->state = MODULE_STATE_GOING;
3007 destroy_params(mod->kp, mod->num_kp);
3009 MODULE_STATE_GOING, mod);
3010 klp_module_going(mod);
3012 mod->state = MODULE_STATE_GOING;
3015 module_bug_cleanup(mod);
3019 ftrace_release_mod(mod);
3021 kfree(mod->args);
3023 module_arch_cleanup(mod);
3025 free_modinfo(mod);
3027 module_unload_free(mod);
3031 list_del_rcu(&mod->list);
3032 mod_tree_remove(mod);
3034 /* Wait for RCU-sched synchronizing before releasing mod->list. */
3041 lockdep_free_key_range(mod->mem[type].base,
3042 mod->mem[type].size);
3045 module_deallocate(mod, info);
3212 char *module_flags(struct module *mod, char *buf, bool show_state)
3216 BUG_ON(mod->state == MODULE_STATE_UNFORMED);
3217 if (!mod->taints && !show_state)
3219 if (mod->taints ||
3220 mod->state == MODULE_STATE_GOING ||
3221 mod->state == MODULE_STATE_COMING) {
3223 bx += module_flags_taint(mod->taints, buf + bx);
3225 if (mod->state == MODULE_STATE_GOING && show_state)
3228 if (mod->state == MODULE_STATE_COMING && show_state)
3242 struct module *mod;
3245 mod = __module_address(addr);
3246 if (!mod)
3249 if (!mod->num_exentries)
3252 e = search_extable(mod->extable,
3253 mod->num_exentries,
3292 struct module *mod;
3307 mod = mod_find(addr, &mod_tree);
3308 if (mod) {
3309 BUG_ON(!within_module(addr, mod));
3310 if (mod->state == MODULE_STATE_UNFORMED)
3311 mod = NULL;
3313 return mod;
3344 struct module *mod = __module_address(addr);
3345 if (mod) {
3347 if (!within_module_mem_type(addr, mod, MOD_TEXT) &&
3348 !within_module_mem_type(addr, mod, MOD_INIT_TEXT))
3349 mod = NULL;
3351 return mod;
3357 struct module *mod;
3363 list_for_each_entry_rcu(mod, &modules, list) {
3364 if (mod->state == MODULE_STATE_UNFORMED)
3366 pr_cont(" %s%s", mod->name, module_flags(mod, buf, true));