<div dir="ltr"><div dir="ltr">On Tue, Jun 20, 2023 at 9:36 AM lijiang <<a href="mailto:lijiang@redhat.com">lijiang@redhat.com</a>> wrote: </div><div class="gmail_quote"><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir="ltr"><div dir="ltr">On Wed, Jun 14, 2023 at 4:06 PM HAGIO KAZUHITO(萩尾　一仁) <<a href="mailto:k-hagio-ab@nec.com" target="_blank">k-hagio-ab@nec.com</a>> wrote: </div><div class="gmail_quote"><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex">Support module memory layout change on Linux 6.4 by kernel commit ac3b43283923 ("module: replace module_layout with module_memory") [1]. Without the patch, crash cannot even start a session with an error message like this: crash: invalid structure member offset: module_core_size FILE: kernel.c LINE: 3787 FUNCTION: module_init() [1] <a href="https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=ac3b43283923" rel="noreferrer" target="_blank">https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=ac3b43283923</a> Signed-off-by: Kazuhito Hagio <<a href="mailto:k-hagio-ab@nec.com" target="_blank">k-hagio-ab@nec.com</a>> --- RFC -> v1 - Applied a lot of Lianbo's comments and discussions - Rewrote {next,prev}_symbol() and splitted functions to skip regions that have only pseudo symbols - Squashed the patchset into one patch, after all (Please let me know if there are changes that should be splitted.) defs.h | 46 +- gdb-10.2.patch | 16 + kernel.c | 54 +- memory.c | 36 +- symbols.c | 1588 ++++++++++++++++++++++++++++++++++++++++++++---- 5 files changed, 1607 insertions(+), 133 deletions(-) </blockquote><div> </div><div>Good job, Kazu.</div><div> </div><div>The other changes look good, and I don't see any regression issues on my side. But I still have two comments below:</div><div> </div><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"> diff --git a/defs.h b/defs.h index bfda0c48d37b..96ea7630123f 100644 --- a/defs.h +++ b/defs.h @@ -675,6 +675,7 @@ struct new_utsname { #define IRQ_DESC_TREE_RADIX (0x40ULL) #define IRQ_DESC_TREE_XARRAY (0x80ULL) #define KMOD_PAX (0x100ULL) +#define KMOD_MEMORY (0x200ULL) #define XEN() (kt->flags & ARCH_XEN) #define OPENVZ() (kt->flags & ARCH_OPENVZ) @@ -682,6 +683,7 @@ struct new_utsname { #define PVOPS_XEN() (kt->flags & ARCH_PVOPS_XEN) #define PAX_MODULE_SPLIT() (kt->flags2 & KMOD_PAX) +#define MODULE_MEMORY() (kt->flags2 & KMOD_MEMORY) #define XEN_MACHINE_TO_MFN(m) ((ulonglong)(m) >> PAGESHIFT()) #define XEN_PFN_TO_PSEUDO(p) ((ulonglong)(p) << PAGESHIFT()) @@ -2220,6 +2222,9 @@ struct offset_table { /* stash of commonly-used offsets */ long kset_kobj; long subsys_private_subsys; long vmap_area_purge_list; + long module_mem; + long module_memory_base; + long module_memory_size; }; struct size_table { /* stash of commonly-used sizes */ @@ -2393,6 +2398,7 @@ struct size_table { /* stash of commonly-used sizes */ long percpu_counter; long maple_tree; long maple_node; + long module_memory; }; struct array_table { @@ -2925,6 +2931,23 @@ struct mod_section_data { ulong size; int priority; int flags; + ulong addr; +}; + +/* Emulate enum mod_mem_type in include/linux/module.h */ +#define MOD_TEXT (0) +#define MOD_DATA (1) +#define MOD_RODATA (2) +#define MOD_RO_AFTER_INIT (3) +#define MOD_INIT_TEXT (4) +#define MOD_INIT_DATA (5) +#define MOD_INIT_RODATA (6) +#define MOD_MEM_NUM_TYPES (7) +#define MOD_INVALID (-1) + +struct module_memory { + ulong base; + uint size; }; struct load_module { @@ -2960,19 +2983,29 @@ struct load_module { ulong mod_percpu; ulong mod_percpu_size; struct objfile *loaded_objfile; -}; -#define IN_MODULE(A,L) \ - (((ulong)(A) >= (L)->mod_base) && ((ulong)(A) < ((L)->mod_base+(L)->mod_size))) - -#define IN_MODULE_INIT(A,L) \ - (((ulong)(A) >= (L)->mod_init_module_ptr) && ((ulong)(A) < ((L)->mod_init_module_ptr+(L)->mod_init_size))) + /* For 6.4 module_memory */ + struct module_memory mem[MOD_MEM_NUM_TYPES]; + struct syment **symtable; + struct syment **symend; + struct syment *ext_symtable[MOD_MEM_NUM_TYPES]; + struct syment *ext_symend[MOD_MEM_NUM_TYPES]; + struct syment *load_symtable[MOD_MEM_NUM_TYPES]; + struct syment *load_symend[MOD_MEM_NUM_TYPES]; +}; +#define IN_MODULE(A,L) (in_module_range(A, L, MOD_TEXT, MOD_RO_AFTER_INIT) != MOD_INVALID) +#define IN_MODULE_INIT(A,L) (in_module_range(A, L, MOD_INIT_TEXT, MOD_INIT_RODATA) != MOD_INVALID) +#define IN_MODULE_TEXT(A,L) (in_module_range(A, L, MOD_TEXT, MOD_TEXT) == MOD_TEXT || \ + in_module_range(A, L, MOD_INIT_TEXT, MOD_INIT_TEXT) == MOD_INIT_TEXT) #define IN_MODULE_PERCPU(A,L) \ (((ulong)(A) >= (L)->mod_percpu) && ((ulong)(A) < ((L)->mod_percpu+(L)->mod_percpu_size))) #define MODULE_PERCPU_SYMS_LOADED(L) ((L)->mod_percpu && (L)->mod_percpu_size) +#define for_each_mod_mem_type(type) \ + for (int (type) = MOD_TEXT; (type) < MOD_MEM_NUM_TYPES; (type)++) + #ifndef GDB_COMMON #define KVADDR (0x1) @@ -5591,6 +5624,7 @@ void dump_struct_member(char *, ulong, unsigned); void dump_union(char *, ulong, unsigned); void store_module_symbols_v1(ulong, int); void store_module_symbols_v2(ulong, int); +void store_module_symbols_6_4(ulong, int); int is_datatype_command(void); int is_typedef(char *); int arg_to_datatype(char *, struct datatype_member *, ulong); diff --git a/gdb-10.2.patch b/gdb-10.2.patch index 835aae9859be..b3f6d8b086eb 100644 --- a/gdb-10.2.patch +++ b/gdb-10.2.patch @@ -3120,3 +3120,19 @@ exit 0 return result; } +--- gdb-10.2/gdb/symtab.c.orig ++++ gdb-10.2/gdb/symtab.c +@@ -7515,8 +7515,11 @@ gdb_add_symbol_file(struct gnu_request * + secname = lm->mod_section_data[i].name; + if ((lm->mod_section_data[i].flags & SEC_FOUND) && + !STREQ(secname, ".text")) { +- sprintf(buf, " -s %s 0x%lx", secname, +- lm->mod_section_data[i].offset + lm->mod_base); ++ if (lm->mod_section_data[i].addr) ++ sprintf(buf, " -s %s 0x%lx", secname, lm->mod_section_data[i].addr); ++ else ++ sprintf(buf, " -s %s 0x%lx", secname, ++ lm->mod_section_data[i].offset + lm->mod_base); + strcat(req->buf, buf); + } + } </blockquote></div></div></blockquote><div> </div><div>BTW: I can still get the following warnings:</div><div>...</div> CXX symtab.o symtab.c: In function ‘void gdb_command_funnel_1(gnu_request*)’: symtab.c:7519:64: warning: ‘%lx’ directive writing between 1 and 16 bytes into a region of size between 10 and 73 [-Wformat-overflow=] 7519 | sprintf(buf, " -s %s 0x%lx", secname, lm->mod_section_data[i].addr); | ^~~ symtab.c:7519:54: note: directive argument in the range [1, 18446744073709551615] 7519 | sprintf(buf, " -s %s 0x%lx", secname, lm->mod_section_data[i].addr); | ^~~~~~~~~~~~~~ <div> </div><div>Thanks.</div><div>Lianbo</div><div> </div><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir="ltr"><div class="gmail_quote"><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"> diff --git a/kernel.c b/kernel.c index 6e98f5f6f6b1..a4d20f5b122e 100644 --- a/kernel.c +++ b/kernel.c @@ -3571,7 +3571,21 @@ module_init(void) MEMBER_OFFSET_INIT(module_num_gpl_syms, "module", "num_gpl_syms"); - if (MEMBER_EXISTS("module", "module_core")) { + if (MEMBER_EXISTS("module", "mem")) { /* 6.4 and later */ + kt->flags2 |= KMOD_MEMORY; /* MODULE_MEMORY() can be used. */ + + MEMBER_OFFSET_INIT(module_mem, "module", "mem"); + MEMBER_OFFSET_INIT(module_memory_base, "module_memory", "base"); + MEMBER_OFFSET_INIT(module_memory_size, "module_memory", "size"); + STRUCT_SIZE_INIT(module_memory, "module_memory"); + + if (CRASHDEBUG(1)) + error(INFO, "struct module_memory detected.\n"); + + if (get_array_length("module.mem", NULL, 0) != MOD_MEM_NUM_TYPES) + error(WARNING, "module memory types have changed!\n"); + + } else if (MEMBER_EXISTS("module", "module_core")) { MEMBER_OFFSET_INIT(module_core_size, "module", "core_size"); MEMBER_OFFSET_INIT(module_init_size, "module", @@ -3757,6 +3771,8 @@ module_init(void) total += nsyms; total += 2; /* store the module's start/ending addresses */ total += 2; /* and the init start/ending addresses */ + if (MODULE_MEMORY()) /* 7 regions at most -> 14, so needs +10 */ + total += 10; /* * If the module has kallsyms, set up to grab them as well. @@ -3784,7 +3800,11 @@ module_init(void) case KALLSYMS_V2: if (THIS_KERNEL_VERSION >= LINUX(2,6,27)) { numksyms = UINT(modbuf + OFFSET(module_num_symtab)); - size = UINT(modbuf + MODULE_OFFSET2(module_core_size, rx)); + if (MODULE_MEMORY()) + /* check mem[MOD_TEXT].size only */ + size = UINT(modbuf + OFFSET(module_mem) + OFFSET(module_memory_size)); + else + size = UINT(modbuf + MODULE_OFFSET2(module_core_size, rx)); } else { numksyms = ULONG(modbuf + OFFSET(module_num_symtab)); size = ULONG(modbuf + MODULE_OFFSET2(module_core_size, rx)); @@ -3822,7 +3842,10 @@ module_init(void) store_module_symbols_v1(total, kt->mods_installed); break; case KMOD_V2: - store_module_symbols_v2(total, kt->mods_installed); + if (MODULE_MEMORY()) + store_module_symbols_6_4(total, kt->mods_installed); + else + store_module_symbols_v2(total, kt->mods_installed); break; } @@ -3893,8 +3916,13 @@ verify_modules(void) mod_base = mod; break; case KMOD_V2: - mod_base = ULONG(modbuf + - MODULE_OFFSET2(module_module_core, rx)); + if (MODULE_MEMORY()) + /* mem[MOD_TEXT].base */ + mod_base = ULONG(modbuf + OFFSET(module_mem) + + OFFSET(module_memory_base)); + else + mod_base = ULONG(modbuf + + MODULE_OFFSET2(module_module_core, rx)); break; } @@ -3916,7 +3944,17 @@ verify_modules(void) case KMOD_V2: module_name = modbuf + OFFSET(module_name); - if (THIS_KERNEL_VERSION >= LINUX(2,6,27)) + if (MODULE_MEMORY()) { + mod_size = 0; + for_each_mod_mem_type(t) { + if (t == MOD_INIT_TEXT) + break; + + mod_size += UINT(modbuf + OFFSET(module_mem) + + SIZE(module_memory) * t + + OFFSET(module_memory_size)); + } + } else if (THIS_KERNEL_VERSION >= LINUX(2,6,27)) mod_size = UINT(modbuf + MODULE_OFFSET2(module_core_size, rx)); else @@ -4536,7 +4574,7 @@ do_module_cmd(ulong flag, char *modref, ulong address, "MODULE"), mkstring(buf2, maxnamelen, LJUST, "NAME"), mkstring(buf4, VADDR_PRLEN, CENTER|LJUST, - "BASE"), + MODULE_MEMORY() ? "TEXT_BASE" : "BASE"), mkstring(buf3, maxsizelen, RJUST, "SIZE")); } @@ -6144,6 +6182,8 @@ dump_kernel_table(int verbose) fprintf(fp, "%sIRQ_DESC_TREE_XARRAY", others++ ? "|" : ""); if (kt->flags2 & KMOD_PAX) fprintf(fp, "%sKMOD_PAX", others++ ? "|" : ""); + if (kt->flags2 & KMOD_MEMORY) + fprintf(fp, "%sKMOD_MEMORY", others++ ? "|" : ""); fprintf(fp, ")\n"); fprintf(fp, " stext: %lx\n", kt->stext); diff --git a/memory.c b/memory.c index ea3005a5c01f..f282aee59952 100644 --- a/memory.c +++ b/memory.c @@ -15713,9 +15713,43 @@ static int next_module_vaddr(ulong vaddr, ulong *nextvaddr) { int i; - ulong start, end; + ulong start, end, min = (ulong)-1; struct load_module *lm; + if (!MODULE_MEMORY()) + goto old_module; + + for (i = 0; i < st->mods_installed; i++) { + lm = &st->load_modules[i]; + + for_each_mod_mem_type(t) { + if (!lm->mem[t].size) + continue; + + start = lm->mem[t].base; + end = start + lm->mem[t].size; + + if (vaddr >= end) + continue; + + if (vaddr < start) { + if (start < min) /* replace candidate */ + min = start; + continue; + } + + *nextvaddr = vaddr; + return TRUE; + } + } + + if (min != (ulong)-1) { + *nextvaddr = min; + return TRUE; + } + return FALSE; + +old_module: for (i = 0; i < st->mods_installed; i++) { lm = &st->load_modules[i]; start = lm->mod_base; diff --git a/symbols.c b/symbols.c index 7b1d59203b90..41a50ced8abd 100644 --- a/symbols.c +++ b/symbols.c @@ -48,8 +48,8 @@ static int load_module_index(struct syment *); static void section_header_info(bfd *, asection *, void *); static void store_section_data(struct load_module *, bfd *, asection *); static void calculate_load_order_v1(struct load_module *, bfd *); -static void calculate_load_order_v2(struct load_module *, bfd *, int, - void *, long, unsigned int); +static void calculate_load_order_v2(struct load_module *, bfd *, int, void *, long, unsigned int); +static void calculate_load_order_6_4(struct load_module *, bfd *, int, void *, long, unsigned int); static void check_insmod_builtin(struct load_module *, int, ulong *); static int is_insmod_builtin(struct load_module *, struct syment *); struct load_module; @@ -104,6 +104,42 @@ static unsigned char is_right_brace(const char *); static struct struct_elem *find_node(struct struct_elem *, char *); static void dump_node(struct struct_elem *, char *, unsigned char, unsigned char); +static int module_mem_type(ulong, struct load_module *); +static ulong module_mem_end(ulong, struct load_module *); +static int in_module_range(ulong, struct load_module *, int, int); +struct syment *value_search_module_6_4(ulong, ulong *); +struct syment *next_symbol_by_symname(char *); +struct syment *prev_symbol_by_symname(char *); +struct syment *next_module_symbol_by_value(ulong); +struct syment *prev_module_symbol_by_value(ulong); +struct syment *next_module_symbol_by_syment(struct syment *); +struct syment *prev_module_symbol_by_syment(struct syment *); + </blockquote><div> </div><div>The above functions are only used in the symbols.c, It should be good to add a 'static' keyword to them.</div><div> </div><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"> +struct module_tag { + char *start; + char *end; + char *start_str; + char *end_str; +}; + +#define MODULE_TAG(type, suffix) ("_MODULE_" #type "_" #suffix "_") +#define MODULE_STR(type, suffix) ( "MODULE " #type " " #suffix) +#define MODULE_TAGS(type) { \ + .start = MODULE_TAG(type, START), \ + .end = MODULE_TAG(type, END), \ + .start_str = MODULE_STR(type, START), \ + .end_str = MODULE_STR(type, END) \ +} + +static const struct module_tag module_tag[] = { + MODULE_TAGS(TEXT), + MODULE_TAGS(DATA), + MODULE_TAGS(RODATA), + MODULE_TAGS(RO_AFTER_INIT), + MODULE_TAGS(INIT_TEXT), + MODULE_TAGS(INIT_DATA), + MODULE_TAGS(INIT_RODATA), +}; /* * structure/union printing stuff @@ -1268,10 +1304,7 @@ symname_hash_search(struct syment *table[], char *name) * Output for sym -[lL] command. */ -#define MODULE_PSEUDO_SYMBOL(sp) \ - ((STRNEQ((sp)->name, "_MODULE_START_") || STRNEQ((sp)->name, "_MODULE_END_")) || \ - (STRNEQ((sp)->name, "_MODULE_INIT_START_") || STRNEQ((sp)->name, "_MODULE_INIT_END_")) || \ - (STRNEQ((sp)->name, "_MODULE_SECTION_"))) +#define MODULE_PSEUDO_SYMBOL(sp) (STRNEQ((sp)->name, "_MODULE_")) #define MODULE_START(sp) (STRNEQ((sp)->name, "_MODULE_START_")) #define MODULE_END(sp) (STRNEQ((sp)->name, "_MODULE_END_")) @@ -1280,6 +1313,76 @@ symname_hash_search(struct syment *table[], char *name) #define MODULE_SECTION_START(sp) (STRNEQ((sp)->name, "_MODULE_SECTION_START")) #define MODULE_SECTION_END(sp) (STRNEQ((sp)->name, "_MODULE_SECTION_END")) +#define MODULE_MEM_START(sp,t) (STRNEQ((sp)->name, module_tag[t].start)) +#define MODULE_MEM_END(sp,t) (STRNEQ((sp)->name, module_tag[t].end)) + +/* For 6.4 and later */ +static void +module_symbol_dump(char *module) +{ + int i; + struct syment *sp, *sp_end; + struct load_module *lm; + const char *p1, *p2; + + for (i = 0; i < st->mods_installed; i++) { + + lm = &st->load_modules[i]; + if (module && !STREQ(module, lm->mod_name)) + continue; + + if (received_SIGINT() || output_closed()) + return; + + /* + * module percpu symbols are within the .data..percpu section, + * not in any module memory regions. + */ + if (MODULE_PERCPU_SYMS_LOADED(lm)) { + p1 = "MODULE PERCPU START"; + p2 = lm->mod_name; + fprintf(fp, "%lx %s: %s\n", lm->mod_percpu, p1, p2); + + dump_percpu_symbols(lm); + + p1 = "MODULE PERCPU END"; + fprintf(fp, "%lx %s: %s\n", lm->mod_percpu + lm->mod_percpu_size, p1, p2); + } + + for_each_mod_mem_type(t) { + if (!lm->symtable[t]) + continue; + + sp = lm->symtable[t]; + sp_end = lm->symend[t]; + + for ( ; sp <= sp_end; sp++) { + if (MODULE_PSEUDO_SYMBOL(sp)) { + if (MODULE_MEM_START(sp, t)) { + p1 = module_tag[t].start_str; + p2 = sp->name + strlen(module_tag[t].start); + } else if (MODULE_MEM_END(sp, t)) { + p1 = module_tag[t].end_str; + p2 = sp->name + strlen(module_tag[t].end); + } else if (MODULE_SECTION_START(sp)) { + p1 = sp->name + strlen("_MODULE_SECTION_START "); + p2 = "section start"; + } else if (MODULE_SECTION_END(sp)) { + p1 = sp->name + strlen("_MODULE_SECTION_END "); + p2 = "section end"; + } else { + p1 = "unknown tag"; + p2 = sp->name; + } + + fprintf(fp, "%lx %s: %s\n", sp->value, p1, p2); + } else + show_symbol(sp, 0, SHOW_RADIX()); + } + } + } +} + static void symbol_dump(ulong flags, char *module) { @@ -1302,6 +1405,11 @@ symbol_dump(ulong flags, char *module) if (!(flags & MODULE_SYMS)) return; + if (MODULE_MEMORY()) { + module_symbol_dump(module); + return; + } + for (i = 0; i < st->mods_installed; i++) { lm = &st->load_modules[i]; @@ -1389,8 +1497,14 @@ dump_percpu_symbols(struct load_module *lm) struct syment *sp, *sp_end; if (MODULE_PERCPU_SYMS_LOADED(lm)) { - sp = lm->mod_symtable; - sp_end = lm->mod_symend; + if (MODULE_MEMORY()) { + /* The lm should have mod_load_symtable. */ + sp = lm->mod_load_symtable; + sp_end = lm->mod_load_symend; + } else { + sp = lm->mod_symtable; + sp_end = lm->mod_symend; + } for ( ; sp <= sp_end; sp++) { if (IN_MODULE_PERCPU(sp->value, lm)) show_symbol(sp, 0, SHOW_RADIX()); @@ -1425,8 +1539,13 @@ check_for_dups(struct load_module *lm) { struct syment *sp, *sp_end; - sp = lm->mod_symtable; - sp_end = lm->mod_symend; + if (MODULE_MEMORY()) { + sp = lm->mod_load_symtable; + sp_end = lm->mod_load_symend; + } else { + sp = lm->mod_symtable; + sp_end = lm->mod_symend; + } for ( ; sp <= sp_end; sp++) { if (symbol_name_count(sp->name) > 1) @@ -1788,6 +1907,362 @@ modsym_value(ulong syms, union kernel_symbol *modsym, int i) return 0; } +/* + * Linux 6.4 introduced module.mem memory layout + */ +void +store_module_symbols_6_4(ulong total, int mods_installed) +{ + int i, m; + ulong mod, mod_next; + char *mod_name; + uint nsyms, ngplsyms; + ulong syms, gpl_syms; + ulong nksyms; + long strbuflen; + ulong size; + int mcnt, lm_mcnt; + union kernel_symbol *modsym; + size_t kernel_symbol_size; + struct load_module *lm; + char buf1[BUFSIZE]; + char buf2[BUFSIZE]; + char *strbuf = NULL, *modbuf, *modsymbuf; + struct syment *sp; + ulong first, last; + + st->mods_installed = mods_installed; + + if (!st->mods_installed) { + st->flags &= ~MODULE_SYMS; + return; + } + + /* + * If we've been here before, free up everything and start over. + */ + if (st->flags & MODULE_SYMS) + error(FATAL, "re-initialization of module symbols not implemented yet!\n"); + + kernel_symbol_size = kernel_symbol_type_init(); + + if ((st->ext_module_symtable = (struct syment *) + calloc(total, sizeof(struct syment))) == NULL) + error(FATAL, "module syment space malloc (%ld symbols): %s\n", + total, strerror(errno)); + + if (!namespace_ctl(NAMESPACE_INIT, &st->ext_module_namespace, + (void *)total, NULL)) + error(FATAL, "module namespace malloc: %s\n", strerror(errno)); + + if ((st->load_modules = (struct load_module *)calloc + (st->mods_installed, sizeof(struct load_module))) == NULL) + error(FATAL, "load_module array malloc: %s\n", strerror(errno)); + + modbuf = GETBUF(SIZE(module)); + modsymbuf = NULL; + m = mcnt = mod_next = 0; + + for (mod = kt->module_list; mod != kt->kernel_module; mod = mod_next) { + + readmem(mod, KVADDR, modbuf, SIZE(module), + "module buffer", FAULT_ON_ERROR); + + syms = ULONG(modbuf + OFFSET(module_syms)); + gpl_syms = ULONG(modbuf + OFFSET(module_gpl_syms)); + nsyms = UINT(modbuf + OFFSET(module_num_syms)); + ngplsyms = UINT(modbuf + OFFSET(module_num_gpl_syms)); + + nksyms = UINT(modbuf + OFFSET(module_num_symtab)); + + mod_name = modbuf + OFFSET(module_name); + + lm = &st->load_modules[m++]; + BZERO(lm, sizeof(struct load_module)); + + size = 0; + for_each_mod_mem_type(t) { + lm->mem[t].base = ULONG(modbuf + OFFSET(module_mem) + + SIZE(module_memory) * t + OFFSET(module_memory_base)); + lm->mem[t].size = UINT(modbuf + OFFSET(module_mem) + + SIZE(module_memory) * t + OFFSET(module_memory_size)); + if (t < MOD_INIT_TEXT) + size += lm->mem[t].size; + } + lm->mod_base = lm->mem[MOD_TEXT].base; + /* module core size, init not included */ + lm->mod_size = size; + lm->module_struct = mod; + + if (strlen(mod_name) < MAX_MOD_NAME) + strcpy(lm->mod_name, mod_name); + else { + error(INFO, "module name greater than MAX_MOD_NAME: %s\n", mod_name); + strncpy(lm->mod_name, mod_name, MAX_MOD_NAME-1); + } + if (CRASHDEBUG(3)) + fprintf(fp, "%lx (%lx): %s syms: %d gplsyms: %d ksyms: %ld\n", + mod, lm->mod_base, lm->mod_name, nsyms, ngplsyms, nksyms); + + lm->mod_flags = MOD_EXT_SYMS; + lm->mod_ext_symcnt = mcnt; + lm->mod_text_start = lm->mod_base; + lm->mod_init_module_ptr = lm->mem[MOD_INIT_TEXT].base; + lm->mod_init_size = lm->mem[MOD_INIT_TEXT].size; + lm->mod_init_text_size = lm->mem[MOD_INIT_TEXT].size; + + if (VALID_MEMBER(module_percpu)) + lm->mod_percpu = ULONG(modbuf + OFFSET(module_percpu)); + + lm_mcnt = mcnt; + for_each_mod_mem_type(t) { + if (!lm->mem[t].size) + continue; + + st->ext_module_symtable[mcnt].value = lm->mem[t].base; + st->ext_module_symtable[mcnt].type = 'm'; + st->ext_module_symtable[mcnt].flags |= MODULE_SYMBOL; + sprintf(buf2, "%s%s", module_tag[t].start, mod_name); + namespace_ctl(NAMESPACE_INSTALL, &st->ext_module_namespace, + &st->ext_module_symtable[mcnt], buf2); + lm_mcnt = mcnt; + mcnt++; + + if (t >= MOD_INIT_TEXT) + lm->mod_flags |= MOD_INIT; + } + + if (nsyms && !IN_MODULE(syms, lm)) { + error(WARNING, + "[%s] module.syms outside of module " "address space (%lx)\n\n", + lm->mod_name, syms); + nsyms = 0; + } + + if (nsyms) { + modsymbuf = GETBUF(kernel_symbol_size*nsyms); + readmem((ulong)syms, KVADDR, modsymbuf, + nsyms * kernel_symbol_size, + "module symbols", FAULT_ON_ERROR); + } + + for (i = first = last = 0; i < nsyms; i++) { + modsym = (union kernel_symbol *) + (modsymbuf + (i * kernel_symbol_size)); + if (!first + || first > modsym_name(syms, modsym, i)) + first = modsym_name(syms, modsym, i); + if (modsym_name(syms, modsym, i) > last) + last = modsym_name(syms, modsym, i); + } + + if (last > first) { + /* The buffer should not go over the block. */ + ulong end = module_mem_end(first, lm); + + strbuflen = (last-first) + BUFSIZE; + if ((first + strbuflen) >= end) { + strbuflen = end - first; + + } + strbuf = GETBUF(strbuflen); + + if (!readmem(first, KVADDR, strbuf, strbuflen, + "module symbol strings", RETURN_ON_ERROR)) { + FREEBUF(strbuf); + strbuf = NULL; + } + } + + + for (i = 0; i < nsyms; i++) { + modsym = (union kernel_symbol *)(modsymbuf + (i * kernel_symbol_size)); + + BZERO(buf1, BUFSIZE); + + if (strbuf) + strcpy(buf1, &strbuf[modsym_name(syms, modsym, i) - first]); + else + read_string(modsym_name(syms, modsym, i), buf1, BUFSIZE-1); + + if (strlen(buf1)) { + st->ext_module_symtable[mcnt].value = + modsym_value(syms, modsym, i); + st->ext_module_symtable[mcnt].type = '?'; + st->ext_module_symtable[mcnt].flags |= MODULE_SYMBOL; + strip_module_symbol_end(buf1); + strip_symbol_end(buf1, NULL); + namespace_ctl(NAMESPACE_INSTALL, + &st->ext_module_namespace, + &st->ext_module_symtable[mcnt], buf1); + + mcnt++; + } + } + + if (modsymbuf) { + FREEBUF(modsymbuf); + modsymbuf = NULL; + } + + if (strbuf) + FREEBUF(strbuf); + + if (ngplsyms) { + modsymbuf = GETBUF(kernel_symbol_size * ngplsyms); + readmem((ulong)gpl_syms, KVADDR, modsymbuf, + ngplsyms * kernel_symbol_size, + "module gpl symbols", FAULT_ON_ERROR); + } + + for (i = first = last = 0; i < ngplsyms; i++) { + modsym = (union kernel_symbol *) + (modsymbuf + (i * kernel_symbol_size)); + if (!first + || first > modsym_name(gpl_syms, modsym, i)) + first = modsym_name(gpl_syms, modsym, i); + if (modsym_name(gpl_syms, modsym, i) > last) + last = modsym_name(gpl_syms, modsym, i); + } + + if (last > first) { + ulong end = module_mem_end(first, lm); + + strbuflen = (last-first) + BUFSIZE; + if ((first + strbuflen) >= end) { + strbuflen = end - first; + + } + strbuf = GETBUF(strbuflen); + + if (!readmem(first, KVADDR, strbuf, strbuflen, + "module gpl symbol strings", RETURN_ON_ERROR)) { + FREEBUF(strbuf); + strbuf = NULL; + } + } else + strbuf = NULL; + + for (i = 0; i < ngplsyms; i++) { + modsym = (union kernel_symbol *) (modsymbuf + (i * kernel_symbol_size)); + + BZERO(buf1, BUFSIZE); + + if (strbuf) + strcpy(buf1, &strbuf[modsym_name(gpl_syms, modsym, i) - first]); + else + read_string(modsym_name(gpl_syms, modsym, i), buf1, BUFSIZE-1); + + if (strlen(buf1)) { + st->ext_module_symtable[mcnt].value = + modsym_value(gpl_syms, modsym, i); + st->ext_module_symtable[mcnt].type = '?'; + st->ext_module_symtable[mcnt].flags |= MODULE_SYMBOL; + strip_module_symbol_end(buf1); + strip_symbol_end(buf1, NULL); + namespace_ctl(NAMESPACE_INSTALL, + &st->ext_module_namespace, + &st->ext_module_symtable[mcnt], buf1); + + mcnt++; + } + } + + if (modsymbuf) { + FREEBUF(modsymbuf); + modsymbuf = NULL; + } + + if (strbuf) + FREEBUF(strbuf); + + /* + * If the module was compiled with kallsyms, add them in. + */ + switch (kt->flags & (KALLSYMS_V1|KALLSYMS_V2)) + { + case KALLSYMS_V1: /* impossible, I hope... */ + mcnt += store_module_kallsyms_v1(lm, lm_mcnt, mcnt, modbuf); + break; + case KALLSYMS_V2: + mcnt += store_module_kallsyms_v2(lm, lm_mcnt, mcnt, modbuf); + break; + } + + for_each_mod_mem_type(t) { + if (!lm->mem[t].size) + continue; + + st->ext_module_symtable[mcnt].value = lm->mem[t].base + lm->mem[t].size; + st->ext_module_symtable[mcnt].type = 'm'; + st->ext_module_symtable[mcnt].flags |= MODULE_SYMBOL; + sprintf(buf2, "%s%s", module_tag[t].end, mod_name); + namespace_ctl(NAMESPACE_INSTALL, + &st->ext_module_namespace, + &st->ext_module_symtable[mcnt], buf2); + mcnt++; + } + + lm->mod_ext_symcnt = mcnt - lm->mod_ext_symcnt; + + NEXT_MODULE(mod_next, modbuf); + } + + FREEBUF(modbuf); + + st->ext_module_symcnt = mcnt; + st->ext_module_symend = &st->ext_module_symtable[mcnt]; + + namespace_ctl(NAMESPACE_COMPLETE, &st->ext_module_namespace, + st->ext_module_symtable, st->ext_module_symend); + + qsort(st->ext_module_symtable, mcnt, sizeof(struct syment), + compare_syms); + + /* sort by text base address */ + qsort(st->load_modules, m, sizeof(struct load_module), compare_mods); + + for (m = 0; m < st->mods_installed; m++) { + lm = &st->load_modules[m]; + + for_each_mod_mem_type(t) { + if (!lm->mem[t].size) + continue; + + sprintf(buf1, "%s%s", module_tag[t].start, lm->mod_name); + sprintf(buf2, "%s%s", module_tag[t].end, lm->mod_name); + + for (sp = st->ext_module_symtable; sp < st->ext_module_symend; sp++) { + if (STREQ(sp->name, buf1)) { + lm->ext_symtable[t] = sp; + break; + } + } + for ( ; sp < st->ext_module_symend; sp++) { + if (STREQ(sp->name, buf2)) { + lm->ext_symend[t] = sp; + break; + } + } + + if (lm->ext_symtable[t] && lm->ext_symend[t]) + mod_symtable_hash_install_range(lm->ext_symtable[t], lm->ext_symend[t]); + } + lm->symtable = lm->ext_symtable; + lm->symend = lm->ext_symend; + } + + st->flags |= MODULE_SYMS; + + if (CRASHDEBUG(2)) { + for (sp = st->ext_module_symtable; sp < st->ext_module_symend; sp++) + fprintf(fp, "%16lx %s\n", sp->value, sp->name); + } + + if (mcnt > total) + error(FATAL, "store_module_symbols_6_4: total: %ld mcnt: %d\n", total, mcnt); +} + void store_module_symbols_v2(ulong total, int mods_installed) { @@ -2384,6 +2859,7 @@ store_module_kallsyms_v2(struct load_module *lm, int start, int curr, int mcnt; int mcnt_idx; char *module_buf_init = NULL; + ulong base, base_init, size, size_init; if (!(kt->flags & KALLSYMS_V2)) return 0; @@ -2394,9 +2870,22 @@ store_module_kallsyms_v2(struct load_module *lm, int start, int curr, ns = &st->ext_module_namespace; ec = &elf_common; - module_buf = GETBUF(lm->mod_size); + /* kallsyms data looks to be in MOD_DATA region. */ + if (MODULE_MEMORY()) { + base = lm->mem[MOD_DATA].base; + size = lm->mem[MOD_DATA].size; + base_init = lm->mem[MOD_INIT_DATA].base; + size_init = lm->mem[MOD_INIT_DATA].size; + } else { + base = lm->mod_base; + size = lm->mod_size; + base_init = lm->mod_init_module_ptr; + size_init = lm->mod_init_size; + } - if (!readmem(lm->mod_base, KVADDR, module_buf, lm->mod_size, + module_buf = GETBUF(size); + + if (!readmem(base, KVADDR, module_buf, size, "module (kallsyms)", RETURN_ON_ERROR|QUIET)) { error(WARNING,"cannot access module kallsyms\n"); FREEBUF(module_buf); @@ -2404,10 +2893,10 @@ store_module_kallsyms_v2(struct load_module *lm, int start, int curr, } if (lm->mod_init_size > 0) { - module_buf_init = GETBUF(lm->mod_init_size); + module_buf_init = GETBUF(size_init); - if (!readmem(lm->mod_init_module_ptr, KVADDR, module_buf_init, lm->mod_init_size, - "module init (kallsyms)", RETURN_ON_ERROR|QUIET)) { + if (!readmem(base_init, KVADDR, module_buf_init, size_init, + "module init (kallsyms)", RETURN_ON_ERROR|QUIET)) { error(WARNING,"cannot access module init kallsyms\n"); FREEBUF(module_buf_init); } @@ -2429,9 +2918,9 @@ store_module_kallsyms_v2(struct load_module *lm, int start, int curr, return 0; } if (IN_MODULE(ksymtab, lm)) - locsymtab = module_buf + (ksymtab - lm->mod_base); + locsymtab = module_buf + (ksymtab - base); else - locsymtab = module_buf_init + (ksymtab - lm->mod_init_module_ptr); + locsymtab = module_buf_init + (ksymtab - base_init); kstrtab = ULONG(modbuf + OFFSET(module_strtab)); if (!IN_MODULE(kstrtab, lm) && !IN_MODULE_INIT(kstrtab, lm)) { @@ -2444,9 +2933,9 @@ store_module_kallsyms_v2(struct load_module *lm, int start, int curr, return 0; } if (IN_MODULE(kstrtab, lm)) - locstrtab = module_buf + (kstrtab - lm->mod_base); + locstrtab = module_buf + (kstrtab - base); else - locstrtab = module_buf_init + (kstrtab - lm->mod_init_module_ptr); + locstrtab = module_buf_init + (kstrtab - base_init); for (i = 1; i < nksyms; i++) { /* ELF starts real symbols at 1 */ switch (BITS()) @@ -2461,11 +2950,8 @@ store_module_kallsyms_v2(struct load_module *lm, int start, int curr, break; } - if (((ec->st_value < lm->mod_base) || - (ec->st_value > (lm->mod_base + lm->mod_size))) && - ((ec->st_value < lm->mod_init_module_ptr) || - (ec->st_value > (lm->mod_init_module_ptr + lm->mod_init_size)))) - continue; + if (!IN_MODULE(ec->st_value, lm) && !IN_MODULE_INIT(ec->st_value, lm)) + continue; if (ec->st_shndx == SHN_UNDEF) continue; @@ -2582,9 +3068,20 @@ lowest_module_address(void) lowest = (ulong)(-1); for (i = 0; i < st->mods_installed; i++) { lm = &st->load_modules[i]; - low = lm->mod_base; - if (low < lowest) - lowest = low; + if (MODULE_MEMORY()) + for_each_mod_mem_type(t) { + if (!lm->mem[t].size) + continue; + + low = lm->mem[t].base; + if (low < lowest) + lowest = low; + } + else { + low = lm->mod_base; + if (low < lowest) + lowest = low; + } } return lowest; @@ -2600,9 +3097,20 @@ highest_module_address(void) highest = 0; for (i = 0; i < st->mods_installed; i++) { lm = &st->load_modules[i]; - high = lm->mod_base + lm->mod_size; - if (high > highest) - highest = high; + if (MODULE_MEMORY()) { + for_each_mod_mem_type(t) { + if (!lm->mem[t].size) + continue; + + high = lm->mem[t].base + lm->mem[t].size; + if (high > highest) + highest = high; + } + } else { + high = lm->mod_base + lm->mod_size; + if (high > highest) + highest = high; + } } return highest; @@ -2853,7 +3361,8 @@ compare_syms(const void *v1, const void *v2) return -1; if (STRNEQ(s2->name, "__insmod")) return 1; - if (STRNEQ(s2->name, "_MODULE_START_")) + if (MODULE_MEM_START(s2, MOD_TEXT) || + STRNEQ(s2->name, "_MODULE_START_")) return 1; /* Get pseudo section name. */ if (MODULE_SECTION_START(s1)) @@ -2986,13 +3495,19 @@ is_kernel_text(ulong value) if (!(lm->mod_section_data[s].flags & SEC_CODE)) continue; - start = lm->mod_base + - lm->mod_section_data[s].offset; + if (MODULE_MEMORY()) + start = lm->mod_section_data[s].addr; + else + start = lm->mod_base + lm->mod_section_data[s].offset; + end = start + lm->mod_section_data[s].size; if ((value >= start) && (value < end)) return TRUE; } + } else if (MODULE_MEMORY()) { + if (IN_MODULE_TEXT(value, lm)) + return TRUE; } else { switch (kt->flags & (KMOD_V1|KMOD_V2)) { @@ -3531,22 +4046,41 @@ dump_symbol_table(void) (ulong)lm->mod_section_data, lm->mod_section_data ? "" : "(not allocated)"); + if (MODULE_MEMORY()) { + for_each_mod_mem_type(t) { + fprintf(fp, " mem[%d]: %lx (%x)\n", + t, lm->mem[t].base, lm->mem[t].size); + } + fprintf(fp, " symtable: %lx\n", (ulong)lm->symtable); + fprintf(fp, " ext_symtable: %lx\n", (ulong)lm->ext_symtable); + for_each_mod_mem_type(t) { + fprintf(fp, " ext_symtable[%d]: %lx - %lx\n", + t, (ulong)lm->ext_symtable[t], (ulong)lm->ext_symend[t]); + } + fprintf(fp, " load_symtable: %lx\n", (ulong)lm->load_symtable); + for_each_mod_mem_type(t) { + fprintf(fp, " load_symtable[%d]: %lx - %lx\n", + t, (ulong)lm->load_symtable[t], (ulong)lm->load_symend[t]); + } + } for (s = 0; s < lm->mod_sections; s++) { fprintf(fp, - " %12s prio: %x flags: %05x offset: %-8lx size: %lx\n", + " %20s prio: %x flags: %08x %s: %-16lx size: %lx\n", lm->mod_section_data[s].name, lm->mod_section_data[s].priority, lm->mod_section_data[s].flags, - lm->mod_section_data[s].offset, + MODULE_MEMORY() ? "addr" : "offset", + MODULE_MEMORY() ? lm->mod_section_data[s].addr : + lm->mod_section_data[s].offset, lm->mod_section_data[s].size); } fprintf(fp, " loaded_objfile: %lx\n", (ulong)lm->loaded_objfile); - if (CRASHDEBUG(1)) { + if (CRASHDEBUG(1) && lm->mod_load_symtable) { for (sp = lm->mod_load_symtable; - sp < lm->mod_load_symend; sp++) { + sp <= lm->mod_load_symend; sp++) { fprintf(fp, " %lx %s\n", sp->value, sp->name); } @@ -4458,8 +4992,11 @@ get_section(ulong vaddr, char *buf) if (module_symbol(vaddr, NULL, &lm, NULL, *gdb_output_radix)) { if (lm->mod_flags & MOD_LOAD_SYMS) { for (i = (lm->mod_sections-1); i >= 0; i--) { - start = lm->mod_base + - lm->mod_section_data[i].offset; + if (MODULE_MEMORY()) + start = lm->mod_section_data[i].addr; + else + start = lm->mod_base + + lm->mod_section_data[i].offset; end = start + lm->mod_section_data[i].size; if ((vaddr >= start) && (vaddr < end)) { @@ -4534,6 +5071,60 @@ symbol_query(char *s, char *print_pad, struct syment **spp) } } + if (!MODULE_MEMORY()) + goto old_module; + + for (i = 0; i < st->mods_installed; i++) { + lm = &st->load_modules[i]; + + if (lm->mod_flags & MOD_LOAD_SYMS) { + sp = lm->mod_load_symtable; + sp_end = lm->mod_load_symend; + + for (; sp < sp_end; sp++) { + if (MODULE_PSEUDO_SYMBOL(sp)) + continue; + + if (strstr(sp->name, s)) { + if (print_pad) { + if (strlen(print_pad)) + fprintf(fp, "%s", print_pad); + show_symbol(sp, 0, SHOW_RADIX()|SHOW_MODULE); + } + if (spp) + *spp = sp; + cnt++; + } + } + } else { + for_each_mod_mem_type(t) { + if (!lm->symtable[t]) + continue; + + sp = lm->symtable[t]; + sp_end = lm->symend[t]; + + for (; sp < sp_end; sp++) { + if (MODULE_PSEUDO_SYMBOL(sp)) + continue; + + if (strstr(sp->name, s)) { + if (print_pad) { + if (strlen(print_pad)) + fprintf(fp, "%s", print_pad); + show_symbol(sp, 0, SHOW_RADIX()|SHOW_MODULE); + } + if (spp) + *spp = sp; + cnt++; + } + } + } + } + } + return cnt; + +old_module: search_init = FALSE; for (i = 0; i < st->mods_installed; i++) { @@ -4653,6 +5244,37 @@ symbol_name_count(char *s) } } + if (!MODULE_MEMORY()) + goto old_module; + + for (i = 0; i < st->mods_installed; i++) { + lm = &st->load_modules[i]; + + if (lm->mod_flags & MOD_LOAD_SYMS) { + sp = lm->mod_load_symtable; + sp_end = lm->mod_load_symend; + + for (; sp < sp_end; sp++) { + if (STREQ(s, sp->name)) + count++; + } + } else { + for_each_mod_mem_type(t) { + if (!lm->symtable[t]) + continue; + + sp = lm->symtable[t]; + sp_end = lm->symend[t]; + for (; sp < sp_end; sp++) { + if (STREQ(s, sp->name)) + count++; + } + } + } + } + return count++; + +old_module: pseudos = (strstr(s, "_MODULE_START_") || strstr(s, "_MODULE_END_")); search_init = FALSE; @@ -4722,6 +5344,38 @@ symbol_search_next(char *s, struct syment *spstart) } } + if (!MODULE_MEMORY()) + goto old_module; + + for (i = 0; i < st->mods_installed; i++) { + lm = &st->load_modules[i]; + + for_each_mod_mem_type(t) { + if (!lm->symtable[t]) + continue; + + sp = lm->symtable[t]; + sp_end = lm->symend[t]; + + if (spstart < sp || spstart > sp_end) + continue; + + for ( ; sp < sp_end; sp++) { + if (sp == spstart) { + found_start = TRUE; + continue; + } else if (!found_start) + continue; + + if (STREQ(s, sp->name)) + return sp; + } + } + } + + return NULL; + +old_module: pseudos = (strstr(s, "_MODULE_START_") || strstr(s, "_MODULE_END_")); search_init = FALSE; @@ -4831,17 +5485,29 @@ module_symbol(ulong value, for (i = 0; i < st->mods_installed; i++) { lm = &st->load_modules[i]; - if (IN_MODULE(value, lm)) { - base = lm->mod_base; - end = lm->mod_base + lm->mod_size; - } else if (IN_MODULE_INIT(value, lm)) { - base = lm->mod_init_module_ptr; - end = lm->mod_init_module_ptr + lm->mod_init_size; - } else if (IN_MODULE_PERCPU(value, lm)) { - base = lm->mod_percpu; - end = lm->mod_percpu + lm->mod_percpu_size; - } else - continue; + if (MODULE_MEMORY()) { + if (IN_MODULE(value, lm) || IN_MODULE_INIT(value, lm)) { + int type = module_mem_type(value, lm); + base = lm->mem[type].base; + end = base + lm->mem[type].size; + } else if (IN_MODULE_PERCPU(value, lm)) { + base = lm->mod_percpu; + end = lm->mod_percpu + lm->mod_percpu_size; + } else + continue; + } else { + if (IN_MODULE(value, lm)) { + base = lm->mod_base; + end = lm->mod_base + lm->mod_size; + } else if (IN_MODULE_INIT(value, lm)) { + base = lm->mod_init_module_ptr; + end = lm->mod_init_module_ptr + lm->mod_init_size; + } else if (IN_MODULE_PERCPU(value, lm)) { + base = lm->mod_percpu; + end = lm->mod_percpu + lm->mod_percpu_size; + } else + continue; + } if ((value >= base) && (value < end)) { if (lmp) @@ -4877,6 +5543,71 @@ module_symbol(ulong value, return FALSE; } +struct syment * +value_search_module_6_4(ulong value, ulong *offset) +{ + int i; + struct syment *sp, *sp_end, *spnext, *splast; + struct load_module *lm; + + for (i = 0; i < st->mods_installed; i++) { + lm = &st->load_modules[i]; + + if (!IN_MODULE(value, lm) && !IN_MODULE_INIT(value, lm)) + continue; + + for_each_mod_mem_type(t) { + sp = lm->symtable[t]; + sp_end = lm->symend[t]; + + if (value < sp->value) + continue; + + splast = NULL; + for ( ; sp <= sp_end; sp++) { + if (machine_type("ARM64") && + IN_MODULE_PERCPU(sp->value, lm) && + !IN_MODULE_PERCPU(value, lm)) + continue; + + if (value == sp->value) { + if (MODULE_MEM_END(sp, t)) + break; + + if (MODULE_PSEUDO_SYMBOL(sp)) { + spnext = sp + 1; + if (MODULE_PSEUDO_SYMBOL(spnext)) + continue; + if (spnext->value == value) + sp = spnext; + } + if (sp->name[0] == '.') { + spnext = sp+1; + if (spnext->value == value) + sp = spnext; + } + if (offset) + *offset = 0; + return sp; + } + + if (sp->value > value) { + sp = splast ? splast : sp - 1; + if (offset) + *offset = value - sp->value; + return sp; + } + + if (!MODULE_PSEUDO_SYMBOL(sp)) { + splast = sp; + } + } + } + } + + return NULL; +} + struct syment * value_search_module(ulong value, ulong *offset) { @@ -4885,6 +5616,9 @@ value_search_module(ulong value, ulong *offset) struct load_module *lm; int search_init_sections, search_init; + if (MODULE_MEMORY()) + return value_search_module_6_4(value, offset); + search_init = FALSE; search_init_sections = 0; @@ -5203,6 +5937,99 @@ closest_symbol_value(ulong value) return(0); } +/* Only for 6.4 and later */ +struct syment * +next_symbol_by_symname(char *symbol) +{ + struct syment *sp; + + if ((sp = symbol_search(symbol))) { + sp++; + if (MODULE_PSEUDO_SYMBOL(sp) && strstr(sp->name, "_END")) + return next_module_symbol_by_value(sp->value); + + return sp; + } + + return NULL; +} + +/* val_in should be a pseudo module end symbol. */ +struct syment * +next_module_symbol_by_value(ulong val_in) +{ + struct load_module *lm; + struct syment *sp, *sp_end; + ulong start, min; + int i; + +retry: + sp = sp_end = NULL; + min = (ulong)-1; + for (i = 0; i < st->mods_installed; i++) { + lm = &st->load_modules[i]; + + /* Search for the next lowest symtable. */ + for_each_mod_mem_type(t) { + if (!lm->symtable[t]) + continue; + + start = lm->symtable[t]->value; + if (start > val_in && start < min) { + min = start; + sp = lm->symtable[t]; + sp_end = lm->symend[t]; + } + } + } + + if (!sp) + return NULL; + + for ( ; sp < sp_end; sp++) { + if (MODULE_PSEUDO_SYMBOL(sp)) + continue; + if (sp->value > val_in) + return sp; + } + + /* Found a table that has only pseudo symbols. */ + val_in = sp_end->value; + goto retry; </blockquote><div> </div><div>Is it possible for 'retry' to become an infinite loop? And there is also a similar 'retry' in the prev_module_symbol_by_value().</div><div> </div><div>Thanks.</div><div>Lianbo</div><div> </div><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"> +} + +/* Only for 6.4 and later */ +struct syment * +next_module_symbol_by_syment(struct syment *sp_in) +{ + struct load_module *lm; + struct syment *sp; + int i; + + for (i = 0; i < st->mods_installed; i++) { + lm = &st->load_modules[i]; + + for_each_mod_mem_type(t) { + if (!lm->symtable[t]) + continue; + + if (sp_in < lm->symtable[t] || sp_in > lm->symend[t]) + continue; + + if (sp_in == lm->symend[t]) + return next_module_symbol_by_value(sp_in->value); + + sp = sp_in + 1; + if (MODULE_PSEUDO_SYMBOL(sp)) + return next_module_symbol_by_value(sp->value); + + return sp; + } + } + + return NULL; +} + /* * For a given symbol, return a pointer to the next (higher) symbol's syment. * Either a symbol name or syment pointer may be passed as an argument. @@ -5230,6 +6057,9 @@ next_symbol(char *symbol, struct syment *sp_in) } } + if (MODULE_MEMORY()) + return next_module_symbol_by_syment(sp_in); + search_init = FALSE; for (i = 0; i < st->mods_installed; i++) { @@ -5270,46 +6100,148 @@ next_symbol(char *symbol, struct syment *sp_in) } } - return NULL; + return NULL; + } + + if (MODULE_MEMORY()) + return next_symbol_by_symname(symbol); + + /* + * Deal with a few special cases... + */ + if (strstr(symbol, " module)")) { + sprintf(buf, "_MODULE_START_"); + strcat(buf, &symbol[1]); + p1 = strstr(buf, " module)"); + *p1 = NULLCHAR; + symbol = buf; + } + + if (STREQ(symbol, "_end")) { + if (!st->mods_installed) + return NULL; + + lm = &st->load_modules[0]; + + return lm->mod_symtable; + } + + if ((sp = symbol_search(symbol))) { + sp++; + if (MODULE_END(sp)) { + sp--; + i = load_module_index(sp); + if ((i+1) == st->mods_installed) + return NULL; + + lm = &st->load_modules[i+1]; + + sp = lm->mod_symtable; + } + return sp; + } + + return NULL; +} + +/* Only for 6.4 and later */ +struct syment * +prev_symbol_by_symname(char *symbol) +{ + struct syment *sp; + + if ((sp = symbol_search(symbol))) { + if (sp == st->symtable) + return NULL; + + if (module_symbol(sp->value, NULL, NULL, NULL, 0)) { + if (MODULE_PSEUDO_SYMBOL(sp) && strstr(sp->name, "_START")) + return prev_module_symbol_by_value(sp->value); + else + sp--; + } else + sp--; + + return sp; + } + + return NULL; +} + +/* val_in should be a pseudo module start symbol. */ +struct syment * +prev_module_symbol_by_value(ulong val_in) +{ + struct load_module *lm; + struct syment *sp, *sp_end; + ulong end, max; + int i; + +retry: + sp = sp_end = NULL; + max = 0; + for (i = 0; i < st->mods_installed; i++) { + lm = &st->load_modules[i]; + + /* Search for the previous highest table. */ + for_each_mod_mem_type(t) { + if (!lm->symtable[t]) + continue; + + end = lm->symend[t]->value; + if (end < val_in && end > max) { + max = end; + sp = lm->symtable[t]; + sp_end = lm->symend[t]; + } + } } + if (!sp) + return NULL; - /* - * Deal with a few special cases... - */ - if (strstr(symbol, " module)")) { - sprintf(buf, "_MODULE_START_"); - strcat(buf, &symbol[1]); - p1 = strstr(buf, " module)"); - *p1 = NULLCHAR; - symbol = buf; + for ( ; sp_end > sp; sp_end--) { + if (MODULE_PSEUDO_SYMBOL(sp_end)) + continue; + if (sp_end->value < val_in) + return sp_end; } - if (STREQ(symbol, "_end")) { - if (!st->mods_installed) - return NULL; + /* Found a table that has only pseudo symbols. */ + val_in = sp->value; + goto retry; +} - lm = &st->load_modules[0]; +/* Only for 6.4 and later */ +struct syment * +prev_module_symbol_by_syment(struct syment *sp_in) +{ + struct load_module *lm; + struct syment *sp; + int i; - return lm->mod_symtable; - } + for (i = 0; i < st->mods_installed; i++) { + lm = &st->load_modules[i]; - if ((sp = symbol_search(symbol))) { - sp++; - if (MODULE_END(sp)) { - sp--; - i = load_module_index(sp); - if ((i+1) == st->mods_installed) - return NULL; + for_each_mod_mem_type(t) { + if (!lm->symtable[t]) + continue; - lm = &st->load_modules[i+1]; + if (sp_in < lm->symtable[t] || sp_in > lm->symend[t]) + continue; - sp = lm->mod_symtable; + if (sp_in == lm->symtable[t]) + return prev_module_symbol_by_value(sp_in->value); + + sp = sp_in - 1; + if (MODULE_PSEUDO_SYMBOL(sp)) + return prev_module_symbol_by_value(sp->value); + + return sp; } - return sp; } - return NULL; + return NULL; } /* @@ -5335,6 +6267,9 @@ prev_symbol(char *symbol, struct syment *sp_in) sp_prev = sp; } + if (MODULE_MEMORY()) + return prev_module_symbol_by_syment(sp_in); + search_init = FALSE; for (i = 0; i < st->mods_installed; i++) { @@ -5378,6 +6313,9 @@ prev_symbol(char *symbol, struct syment *sp_in) return NULL; } + if (MODULE_MEMORY()) + return prev_symbol_by_symname(symbol); + if (strstr(symbol, " module)")) { sprintf(buf, "_MODULE_START_"); strcat(buf, &symbol[1]); @@ -5625,6 +6563,31 @@ get_syment_array(char *symbol, struct syment **sp_array, int max) } } + if (!MODULE_MEMORY()) + goto old_module; + + for (i = 0; i < st->mods_installed; i++) { + lm = &st->load_modules[i]; + + for_each_mod_mem_type(t) { + if (!lm->symtable[t]) + continue; + + sp = lm->symtable[t]; + sp_end = lm->symend[t]; + for (; sp < sp_end; sp++) { + if (STREQ(symbol, sp->name)) { + if (max && (cnt < max)) + sp_array[cnt] = sp; + cnt++; + } + } + } + } + + return cnt; + +old_module: for (i = 0; i < st->mods_installed; i++) { lm = &st->load_modules[i]; sp = lm->mod_symtable; @@ -9229,6 +10192,9 @@ dump_offset_table(char *spec, ulong makestruct) OFFSET(module_strtab)); fprintf(fp, " module_percpu: %ld\n", OFFSET(module_percpu)); + fprintf(fp, " module_mem: %ld\n", OFFSET(module_mem)); + fprintf(fp, " module_memory_base: %ld\n", OFFSET(module_memory_base)); + fprintf(fp, " module_memory_size: %ld\n", OFFSET(module_memory_size)); fprintf(fp, " module_sect_attrs: %ld\n", OFFSET(module_sect_attrs)); @@ -10852,6 +11818,7 @@ dump_offset_table(char *spec, ulong makestruct) SIZE(super_block)); fprintf(fp, " irqdesc: %ld\n", SIZE(irqdesc)); fprintf(fp, " module: %ld\n", SIZE(module)); + fprintf(fp, " module_memory: %ld\n", SIZE(module_memory)); fprintf(fp, " module_sect_attr: %ld\n", SIZE(module_sect_attr)); fprintf(fp, " list_head: %ld\n", SIZE(list_head)); fprintf(fp, " hlist_head: %ld\n", SIZE(hlist_head)); @@ -11467,6 +12434,13 @@ store_section_data(struct load_module *lm, bfd *bfd, asection *section) lm->mod_section_data[i].section = section; lm->mod_section_data[i].priority = prio; lm->mod_section_data[i].flags = section->flags & ~SEC_FOUND; + lm->mod_section_data[i].size = bfd_section_size(section); + lm->mod_section_data[i].offset = 0; + lm->mod_section_data[i].addr = 0; + if (strlen(name) < MAX_MOD_SEC_NAME) + strcpy(lm->mod_section_data[i].name, name); + else + strncpy(lm->mod_section_data[i].name, name, MAX_MOD_SEC_NAME-1); /* * The percpu section isn't included in kallsyms or module_core area. */ @@ -11474,13 +12448,8 @@ store_section_data(struct load_module *lm, bfd *bfd, asection *section) (STREQ(name,".data.percpu") || STREQ(name, ".data..percpu"))) { lm->mod_percpu_size = bfd_section_size(section); lm->mod_section_data[i].flags |= SEC_FOUND; + lm->mod_section_data[i].addr = lm->mod_percpu; } - lm->mod_section_data[i].size = bfd_section_size(section); - lm->mod_section_data[i].offset = 0; - if (strlen(name) < MAX_MOD_SEC_NAME) - strcpy(lm->mod_section_data[i].name, name); - else - strncpy(lm->mod_section_data[i].name, name, MAX_MOD_SEC_NAME-1); lm->mod_sections += 1; } @@ -11722,6 +12691,124 @@ calculate_load_order_v2(struct load_module *lm, bfd *bfd, int dynamic, } } +/* Linux 6.4 and later */ +static void +calculate_load_order_6_4(struct load_module *lm, bfd *bfd, int dynamic, + void *minisyms, long symcount, unsigned int size) +{ + struct syment *s1, *s2; + ulong sec_start; + bfd_byte *from, *fromend; + asymbol *store; + asymbol *sym; + symbol_info syminfo; + char *secname; + int i; + + if ((store = bfd_make_empty_symbol(bfd)) == NULL) + error(FATAL, "bfd_make_empty_symbol() failed\n"); + + for_each_mod_mem_type(t) { + s1 = lm->symtable[t]; + s2 = lm->symend[t]; + while (s1 < s2) { + + if (MODULE_PSEUDO_SYMBOL(s1)) { + s1++; + continue; + } + + /* Skip over symbols whose sections have been identified. */ + for (i = 0; i < lm->mod_sections; i++) { + if ((lm->mod_section_data[i].flags & SEC_FOUND) == 0) + continue; + + if (s1->value >= lm->mod_section_data[i].addr && + s1->value < lm->mod_section_data[i].addr + + lm->mod_section_data[i].size) + break; + } + + /* Matched one of the sections. Skip symbol. */ + if (i < lm->mod_sections) { + if (CRASHDEBUG(2)) + fprintf(fp, "skip %lx %s %s\n", s1->value, s1->name, + lm->mod_section_data[i].name); + s1++; + continue; + } + + /* Find the symbol in the object file. */ + from = (bfd_byte *) minisyms; + fromend = from + symcount * size; + secname = NULL; + for (; from < fromend; from += size) { + if (!(sym = bfd_minisymbol_to_symbol(bfd, dynamic, from, store))) + error(FATAL, "bfd_minisymbol_to_symbol() failed\n"); + + bfd_get_symbol_info(bfd, sym, &syminfo); + if (CRASHDEBUG(3)) { + fprintf(fp,"matching sym %s %lx against bfd %s %lx\n", + s1->name, (long) s1->value, <a href="http://syminfo.name" rel="noreferrer" target="_blank">syminfo.name</a>, + (long) syminfo.value); + } + if (strcmp(<a href="http://syminfo.name" rel="noreferrer" target="_blank">syminfo.name</a>, s1->name) == 0) { + secname = (char *)bfd_section_name(sym->section); + break; + } + + } + if (secname == NULL) { + if (CRASHDEBUG(1)) + fprintf(fp, "symbol %s not found in module\n", s1->name); + s1++; + continue; + } + + /* Match the section it came in. */ + for (i = 0; i < lm->mod_sections; i++) { + if (STREQ(lm->mod_section_data[i].name, secname)) + break; + } + + if (i == lm->mod_sections) { + fprintf(fp, "?? Section %s not found for symbol %s\n", + secname, s1->name); + s1++; + continue; + } + + if (lm->mod_section_data[i].flags & SEC_FOUND) { + s1++; + continue; + } + + /* Update the offset information for the section */ + sec_start = s1->value - syminfo.value; + /* keep the address instead of offset */ + lm->mod_section_data[i].addr = sec_start; + lm->mod_section_data[i].flags |= SEC_FOUND; + + if (CRASHDEBUG(2)) + fprintf(fp, "update sec offset sym %s @ %lx val %lx section %s\n", + s1->name, s1->value, (ulong)syminfo.value, secname); + + if (strcmp(secname, ".text") == 0) + lm->mod_text_start = sec_start; + + if (strcmp(secname, ".bss") == 0) + lm->mod_bss_start = sec_start; + + if (strcmp(secname, ".data") == 0) + lm->mod_data_start = sec_start; + + if (strcmp(secname, ".rodata") == 0) + lm->mod_rodata_start = sec_start; + s1++; + } + } +} + /* * Later versons of insmod store basic address information of each * module in a format that looks like the following example of the @@ -11927,8 +13014,11 @@ add_symbol_file(struct load_module *lm) (!STREQ(secname, ".text") && !STREQ(secname, ".data.percpu") && !STREQ(secname, ".data..percpu"))) { - sprintf(buf, " -s %s 0x%lx", secname, - lm->mod_section_data[i].offset + lm->mod_base); + if (MODULE_MEMORY()) + sprintf(buf, " -s %s 0x%lx", secname, lm->mod_section_data[i].addr); + else + sprintf(buf, " -s %s 0x%lx", secname, + lm->mod_section_data[i].offset + lm->mod_base); len += strlen(buf); } } @@ -12276,17 +13366,36 @@ kallsyms_module_symbol(struct load_module *lm, symbol_info *syminfo) sp = NULL; cnt = 0; - for (spx = lm->mod_ext_symtable; spx <= lm->mod_ext_symend; spx++) { - if (!STREQ(spx->name, syminfo->name)) - continue; - if (spx->cnt) { - cnt++; - continue; - } + if (MODULE_MEMORY()) { + for_each_mod_mem_type(t) { + if (!lm->ext_symtable[t]) + continue; + for (spx = lm->ext_symtable[t]; spx <= lm->ext_symend[t]; spx++) { + if (!STREQ(spx->name, syminfo->name)) + continue; + if (spx->cnt) { + cnt++; + continue; + } - spx->cnt++; - sp = spx; - break; + spx->cnt++; + sp = spx; + break; + } + } + } else { + for (spx = lm->mod_ext_symtable; spx <= lm->mod_ext_symend; spx++) { + if (!STREQ(spx->name, syminfo->name)) + continue; + if (spx->cnt) { + cnt++; + continue; + } + + spx->cnt++; + sp = spx; + break; + } } if (CRASHDEBUG(2)) { @@ -12323,7 +13432,7 @@ store_load_module_symbols(bfd *bfd, int dynamic, void *minisyms, char *nameptr, *secname; long index; long symalloc; - int found; + int found = FALSE; if ((store = bfd_make_empty_symbol(bfd)) == NULL) error(FATAL, "bfd_make_empty_symbol() failed\n"); @@ -12380,8 +13489,17 @@ store_load_module_symbols(bfd *bfd, int dynamic, void *minisyms, lm->mod_rodata_start = lm->mod_bss_start = 0; lm->mod_load_symcnt = 0; lm->mod_sections = 0; - for (spx = lm->mod_ext_symtable; spx <= lm->mod_ext_symend; spx++) - spx->cnt = 0; + if (MODULE_MEMORY()) { + for_each_mod_mem_type(t) { + if (!lm->ext_symtable[t]) + continue; + for (spx = lm->ext_symtable[t]; spx <= lm->ext_symend[t]; spx++) + spx->cnt = 0; + } + } else { + for (spx = lm->mod_ext_symtable; spx <= lm->mod_ext_symend; spx++) + spx->cnt = 0; + } sp = lm->mod_load_symtable; if (!(lm->mod_section_data = (struct mod_section_data *) @@ -12392,13 +13510,14 @@ store_load_module_symbols(bfd *bfd, int dynamic, void *minisyms, bfd_map_over_sections(bfd, section_header_info, MODULE_SECTIONS); - if (kt->flags & KMOD_V1) + if (MODULE_MEMORY()) + calculate_load_order_6_4(lm, bfd, dynamic, minisyms, symcount, size); + else if (kt->flags & KMOD_V1) calculate_load_order_v1(lm, bfd); else calculate_load_order_v2(lm, bfd, dynamic, minisyms, symcount, size); - from = (bfd_byte *) minisyms; fromend = from + symcount * size; for (; from < fromend; from += size) @@ -12501,7 +13620,10 @@ store_load_module_symbols(bfd *bfd, int dynamic, void *minisyms, syminfo.value += lm->mod_percpu; found = TRUE; } else { - syminfo.value += lm->mod_section_data[i].offset + lm->mod_base; + if (MODULE_MEMORY()) + syminfo.value += lm->mod_section_data[i].addr; + else + syminfo.value += lm->mod_section_data[i].offset + lm->mod_base; found = TRUE; } } @@ -12536,6 +13658,53 @@ store_load_module_symbols(bfd *bfd, int dynamic, void *minisyms, * syminfo data types accepted above, plus the two pseudo symbols. * Note that the new syment name pointers haven't been resolved yet. */ + if (!MODULE_MEMORY()) + goto old_module; + + for_each_mod_mem_type(t) { + if (!lm->ext_symtable[t]) + continue; + for (spx = lm->ext_symtable[t]; spx <= lm->ext_symend[t]; spx++) { + found = FALSE; + for (sp = lm->mod_load_symtable; sp < lm->mod_load_symend; sp++) { + index = (long)sp->name; + nameptr = &lm->mod_load_namespace.address[index]; + if (STREQ(spx->name, nameptr)) { + found = TRUE; + if (spx->value == sp->value) { + if (CRASHDEBUG(2)) + fprintf(fp, "%s: %s matches!\n", + lm->mod_name, nameptr); + } else { + if (CRASHDEBUG(2)) + fprintf(fp, + "[%s] %s: %lx != extern'd value: %lx\n", + lm->mod_name, + nameptr, sp->value, + spx->value); + } + break; + } + } + if (!found) { + if (CRASHDEBUG(2)) + fprintf(fp, "append ext %s (%lx)\n", spx->name, spx->value); + /* append it here... */ + namespace_ctl(NAMESPACE_INSTALL, + &lm->mod_load_namespace, + lm->mod_load_symend, spx->name); + + lm->mod_load_symend->value = spx->value; + lm->mod_load_symend->type = spx->type; + lm->mod_load_symend->flags |= MODULE_SYMBOL; + lm->mod_load_symend++; + lm->mod_load_symcnt++; + } + } + } + goto append_section_symbols; + +old_module: for (spx = lm->mod_ext_symtable; spx <= lm->mod_ext_symend; spx++) { found = FALSE; for (sp = lm->mod_load_symtable; @@ -12578,6 +13747,7 @@ store_load_module_symbols(bfd *bfd, int dynamic, void *minisyms, } } +append_section_symbols: /* * Append helpful pseudo symbols about found out sections. * Use 'S' as its type which is never seen in existing symbols. @@ -12587,8 +13757,11 @@ store_load_module_symbols(bfd *bfd, int dynamic, void *minisyms, if (!(lm->mod_section_data[i].flags & SEC_FOUND)) continue; /* Section start */ - lm->mod_load_symend->value = lm->mod_base + - lm->mod_section_data[i].offset; + if (MODULE_MEMORY()) + lm->mod_load_symend->value = lm->mod_section_data[i].addr; + else + lm->mod_load_symend->value = lm->mod_base + + lm->mod_section_data[i].offset; lm->mod_load_symend->type = 'S'; lm->mod_load_symend->flags |= MODULE_SYMBOL; sprintf(name, "_MODULE_SECTION_START [%s]", @@ -12599,9 +13772,12 @@ store_load_module_symbols(bfd *bfd, int dynamic, void *minisyms, lm->mod_load_symcnt++; /* Section end */ - lm->mod_load_symend->value = lm->mod_base + - lm->mod_section_data[i].offset + - lm->mod_section_data[i].size; + if (MODULE_MEMORY()) + lm->mod_load_symend->value = lm->mod_section_data[i].addr; + else + lm->mod_load_symend->value = lm->mod_base + + lm->mod_section_data[i].offset; + lm->mod_load_symend->value += lm->mod_section_data[i].size; lm->mod_load_symend->type = 'S'; lm->mod_load_symend->flags |= MODULE_SYMBOL; sprintf(name, "_MODULE_SECTION_END [%s]", @@ -12618,16 +13794,57 @@ store_load_module_symbols(bfd *bfd, int dynamic, void *minisyms, qsort(lm->mod_load_symtable, lm->mod_load_symcnt, sizeof(struct syment), compare_syms); + if (MODULE_MEMORY()) { + /* keep load symtable addresses to lm->load_symtable[] */ + /* TODO: make more efficient */ + for (sp = lm->mod_load_symtable; sp < lm->mod_load_symend; sp++) { + char buf1[BUFSIZE], buf2[BUFSIZE]; + + if (CRASHDEBUG(2)) + fprintf(fp, "DEBUG: value %16lx name %s\n", sp->value, sp->name); + + if (!MODULE_PSEUDO_SYMBOL(sp)) + continue; + + for_each_mod_mem_type(t) { + if (!lm->mem[t].size) + continue; + + sprintf(buf1, "%s%s", module_tag[t].start, lm->mod_name); + sprintf(buf2, "%s%s", module_tag[t].end, lm->mod_name); + + if (STREQ(sp->name, buf1)) { + lm->load_symtable[t] = sp; + break; + } else if (STREQ(sp->name, buf2)) { + lm->load_symend[t] = sp; + break; + } + } + } + } + lm->mod_load_symend--; - if (!MODULE_END(lm->mod_load_symend) && + if (!MODULE_MEMORY() && !MODULE_END(lm->mod_load_symend) && !IN_MODULE_PERCPU(lm->mod_load_symend->value, lm)) error(INFO, "%s: last symbol: %s is not _MODULE_END_%s?\n", lm->mod_name, lm->mod_load_symend->name, lm->mod_name); - mod_symtable_hash_remove_range(lm->mod_symtable, lm->mod_symend); - lm->mod_symtable = lm->mod_load_symtable; - lm->mod_symend = lm->mod_load_symend; - mod_symtable_hash_install_range(lm->mod_symtable, lm->mod_symend); + if (MODULE_MEMORY()) { + for_each_mod_mem_type(t) { + if (!lm->symtable[t]) + continue; + mod_symtable_hash_remove_range(lm->symtable[t], lm->symend[t]); + } + lm->symtable = lm->load_symtable; + lm->symend = lm->load_symend; + mod_symtable_hash_install_range(lm->mod_load_symtable, lm->mod_load_symend); + } else { + mod_symtable_hash_remove_range(lm->mod_symtable, lm->mod_symend); + lm->mod_symtable = lm->mod_load_symtable; + lm->mod_symend = lm->mod_load_symend; + mod_symtable_hash_install_range(lm->mod_symtable, lm->mod_symend); + } lm->mod_flags &= ~MOD_EXT_SYMS; lm->mod_flags |= MOD_LOAD_SYMS; @@ -12657,7 +13874,18 @@ delete_load_module(ulong base_addr) req->name = lm->mod_namelist; gdb_interface(req); } - mod_symtable_hash_remove_range(lm->mod_symtable, lm->mod_symend); + if (MODULE_MEMORY()) { + if (lm->mod_load_symtable) { + mod_symtable_hash_remove_range(lm->mod_load_symtable, + lm->mod_load_symend); + for_each_mod_mem_type(t) { + lm->load_symtable[t] = NULL; + lm->load_symend[t] = NULL; + } + } + } else + mod_symtable_hash_remove_range(lm->mod_symtable, lm->mod_symend); + if (lm->mod_load_symtable) { free(lm->mod_load_symtable); namespace_ctl(NAMESPACE_FREE, @@ -12665,9 +13893,23 @@ delete_load_module(ulong base_addr) } if (lm->mod_flags & MOD_REMOTE) unlink_module(lm); - lm->mod_symtable = lm->mod_ext_symtable; - lm->mod_symend = lm->mod_ext_symend; - mod_symtable_hash_install_range(lm->mod_symtable, lm->mod_symend); + + if (MODULE_MEMORY()) { + if (lm->mod_load_symtable) { /* still non-NULL */ + lm->symtable = lm->ext_symtable; + lm->symend = lm->ext_symend; + for_each_mod_mem_type(t) { + if (!lm->symtable[t]) + continue; + mod_symtable_hash_install_range(lm->symtable[t], + lm->symend[t]); + } + } + } else { + lm->mod_symtable = lm->mod_ext_symtable; + lm->mod_symend = lm->mod_ext_symend; + mod_symtable_hash_install_range(lm->mod_symtable, lm->mod_symend); + } lm->mod_flags &= ~(MOD_LOAD_SYMS|MOD_REMOTE|MOD_NOPATCH); lm->mod_flags |= MOD_EXT_SYMS; lm->mod_load_symtable = NULL; @@ -12696,7 +13938,18 @@ delete_load_module(ulong base_addr) req->name = lm->mod_namelist; gdb_interface(req); } - mod_symtable_hash_remove_range(lm->mod_symtable, lm->mod_symend); + if (MODULE_MEMORY()) { + if (lm->mod_load_symtable) { + mod_symtable_hash_remove_range(lm->mod_load_symtable, + lm->mod_load_symend); + for_each_mod_mem_type(t) { + lm->load_symtable[t] = NULL; + lm->load_symend[t] = NULL; + } + } + } else + mod_symtable_hash_remove_range(lm->mod_symtable, lm->mod_symend); + if (lm->mod_load_symtable) { free(lm->mod_load_symtable); namespace_ctl(NAMESPACE_FREE, @@ -12704,9 +13957,23 @@ delete_load_module(ulong base_addr) } if (lm->mod_flags & MOD_REMOTE) unlink_module(lm); - lm->mod_symtable = lm->mod_ext_symtable; - lm->mod_symend = lm->mod_ext_symend; - mod_symtable_hash_install_range(lm->mod_symtable, lm->mod_symend); + + if (MODULE_MEMORY()) { + if (lm->mod_load_symtable) { + lm->symtable = lm->ext_symtable; + lm->symend = lm->ext_symend; + for_each_mod_mem_type(t) { + if (!lm->symtable[t]) + continue; + mod_symtable_hash_install_range(lm->symtable[t], + lm->symend[t]); + } + } + } else { + lm->mod_symtable = lm->mod_ext_symtable; + lm->mod_symend = lm->mod_ext_symend; + mod_symtable_hash_install_range(lm->mod_symtable, lm->mod_symend); + } lm->mod_flags &= ~(MOD_LOAD_SYMS|MOD_REMOTE|MOD_NOPATCH); lm->mod_flags |= MOD_EXT_SYMS; lm->mod_load_symtable = NULL; @@ -13475,6 +14742,34 @@ symbol_complete_match(const char *match, struct syment *sp_last) sp_start = NULL; } + if (!MODULE_MEMORY()) + goto old_module; + + for (i = 0; i < st->mods_installed; i++) { + lm = &st->load_modules[i]; + + for_each_mod_mem_type(t) { + sp_end = lm->symend[t]; + if (!sp_start) + sp_start = lm->symtable[t]; + + if (sp_start < lm->symtable[t] || sp_start > sp_end) + continue; + + for (sp = sp_start; sp < sp_end; sp++) { + if (MODULE_PSEUDO_SYMBOL(sp)) + continue; + + if (STRNEQ(sp->name, match)) + return sp; + } + sp_start = NULL; + } + } + + return NULL; + +old_module: search_init = FALSE; for (i = 0; i < st->mods_installed; i++) { @@ -13521,3 +14816,58 @@ symbol_complete_match(const char *match, struct syment *sp_last) return NULL; } + +/* Returns module memory type if addr is in range, otherwise MOD_INVALID(-1) */ +static int +in_module_range(ulong addr, struct load_module *lm, int start, int end) +{ + ulong base = 0, size = 0; + int i; + + if (!MODULE_MEMORY()) + goto old_module; + + for (i = start ; i <= end; i++) { + base = lm->mem[i].base; + size = lm->mem[i].size; + if (!size) + continue; + if ((addr >= base) && (addr < (base + size))) + return i; + } + return MOD_INVALID; + +old_module: + if (start == MOD_TEXT) { + base = lm->mod_base; + size = lm->mod_size; + } else if (start == MOD_INIT_TEXT) { + base = lm->mod_init_module_ptr; + size = lm->mod_init_size; + } else + error(FATAL, "invalid module memory type!"); + + if ((addr >= base) && (addr < (base + size))) + return start; + + return MOD_INVALID; +} + +/* Returns module memory type, otherwise MOD_INVALID(-1) */ +static int +module_mem_type(ulong addr, struct load_module *lm) +{ + return in_module_range(addr, lm, MOD_TEXT, MOD_INIT_RODATA); +} + +/* Returns the end address of the module memory region. */ +static ulong +module_mem_end(ulong addr, struct load_module *lm) +{ + int type = module_mem_type(addr, lm); + + if (type == MOD_INVALID) + return 0; + + return lm->mem[type].base + lm->mem[type].size; +} -- 2.31.1 </blockquote></div></div> </blockquote></div></div>