rpms/crash
7
0
Fork 0
Code Issues Pull Requests Releases Activity
c8s
crash/0013-Support-module-memory-layout-change-on-Linux-6.4.patch
Lianbo Jiang f978ba53f7 Rebase to 8.0.3 
Release: crash-8.0.3-1

Changes:
[1] rebase to 8.0.3
[2] backport the latest patches from upstream

Resolves: rhbz#2231768

Signed-off-by: Lianbo Jiang <lijiang@redhat.com>
2023-09-11 17:02:49 +08:00

2444 lines
69 KiB
Diff
Raw Permalink Blame History

From 7750e61fdb2a083f26156a5338aa2ebe26447f3f Mon Sep 17 00:00:00 2001
From: Kazuhito Hagio <k-hagio-ab@nec.com>
Date: Thu, 22 Jun 2023 16:09:07 +0900
Subject: [PATCH 13/30] Support module memory layout change on Linux 6.4
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] https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=ac3b43283923
Signed-off-by: Kazuhito Hagio <k-hagio-ab@nec.com>
Signed-off-by: Lianbo Jiang <lijiang@redhat.com>
---
defs.h | 46 +-
gdb-10.2.patch | 25 +
kernel.c | 56 +-
memory.c | 38 +-
symbols.c | 1609 ++++++++++++++++++++++++++++++++++++++++++++----
5 files changed, 1629 insertions(+), 145 deletions(-)
diff --git a/defs.h b/defs.h
index 3e7d6cfbc6a8..414853660dc1 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())
@@ -2217,6 +2219,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 */
@@ -2390,6 +2395,7 @@ struct size_table { /* stash of commonly-used sizes */
long percpu_counter;
long maple_tree;
long maple_node;
+ long module_memory;
};
struct array_table {
@@ -2922,6 +2928,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 {
@@ -2957,19 +2980,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 ((type) = MOD_TEXT; (type) < MOD_MEM_NUM_TYPES; (type)++)
+
#ifndef GDB_COMMON
#define KVADDR (0x1)
@@ -5588,6 +5621,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..16228b1dbf73 100644
--- a/gdb-10.2.patch
+++ b/gdb-10.2.patch
@@ -3120,3 +3120,28 @@ exit 0
return result;
}
+--- gdb-10.2/gdb/symtab.c.orig
++++ gdb-10.2/gdb/symtab.c
+@@ -7476,7 +7476,7 @@ gdb_add_symbol_file(struct gnu_request *
+ int i;
+ int allsect = 0;
+ char *secname;
+- char buf[80];
++ char buf[96];
+
+ gdb_current_load_module = lm = (struct load_module *)req->addr;
+
+@@ -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);
+ }
+ }
diff --git a/kernel.c b/kernel.c
index 6e98f5f6f6b1..639ed64f306a 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;
}
@@ -3836,7 +3859,7 @@ module_init(void)
static int
verify_modules(void)
{
- int i;
+ int i, t;
int found, irregularities;
ulong mod, mod_next, mod_base;
long mod_size;
@@ -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..acbee6389472 100644
--- a/memory.c
+++ b/memory.c
@@ -15712,10 +15712,44 @@ in_vmlist_segment(ulong vaddr)
static int
next_module_vaddr(ulong vaddr, ulong *nextvaddr)
{
- int i;
- ulong start, end;
+ int i, t;
+ 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..f161ee99e90a 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);
+static struct syment *value_search_module_6_4(ulong, ulong *);
+static struct syment *next_symbol_by_symname(char *);
+static struct syment *prev_symbol_by_symname(char *);
+static struct syment *next_module_symbol_by_value(ulong);
+static struct syment *prev_module_symbol_by_value(ulong);
+static struct syment *next_module_symbol_by_syment(struct syment *);
+static struct syment *prev_module_symbol_by_syment(struct syment *);
+
+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, t;
+ 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, t;
+ 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;
@@ -2572,7 +3058,7 @@ strip_module_symbol_end(char *buf)
ulong
lowest_module_address(void)
{
- int i;
+ int i, t;
struct load_module *lm;
ulong low, lowest;
@@ -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;
@@ -2593,16 +3090,27 @@ lowest_module_address(void)
ulong
highest_module_address(void)
{
- int i;
+ int i, t;
struct load_module *lm;
ulong high, highest;
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,42 @@ dump_symbol_table(void)
(ulong)lm->mod_section_data,
lm->mod_section_data ? "" : "(not allocated)");
+ if (MODULE_MEMORY()) {
+ int t;
+ 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 +4993,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)) {
@@ -4514,7 +5052,7 @@ get_build_directory(char *buf)
int
symbol_query(char *s, char *print_pad, struct syment **spp)
{
- int i;
+ int i, t;
struct syment *sp, *sp_end;
struct load_module *lm;
int cnt, search_init;
@@ -4534,6 +5072,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++) {
@@ -4639,7 +5231,7 @@ symbol_search(char *s)
int
symbol_name_count(char *s)
{
- int i;
+ int i, t;
struct syment *sp, *sp_end;
struct load_module *lm;
int count, pseudos, search_init;
@@ -4653,6 +5245,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;
@@ -4702,7 +5325,7 @@ symbol_name_count(char *s)
struct syment *
symbol_search_next(char *s, struct syment *spstart)
{
- int i;
+ int i, t;
struct syment *sp, *sp_end;
struct load_module *lm;
int found_start;
@@ -4722,6 +5345,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 (!found_start && (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 +5486,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 +5544,71 @@ module_symbol(ulong value,
return FALSE;
}
+static struct syment *
+value_search_module_6_4(ulong value, ulong *offset)
+{
+ int i, t;
+ 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 +5617,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 +5938,99 @@ closest_symbol_value(ulong value)
return(0);
}
+/* Only for 6.4 and later */
+static 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. */
+static struct syment *
+next_module_symbol_by_value(ulong val_in)
+{
+ struct load_module *lm;
+ struct syment *sp, *sp_end;
+ ulong start, min;
+ int i, t;
+
+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;
+}
+
+/* Only for 6.4 and later */
+static struct syment *
+next_module_symbol_by_syment(struct syment *sp_in)
+{
+ struct load_module *lm;
+ struct syment *sp;
+ int i, t;
+
+ 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 +6058,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 +6101,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 */
+static 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. */
+static struct syment *
+prev_module_symbol_by_value(ulong val_in)
+{
+ struct load_module *lm;
+ struct syment *sp, *sp_end;
+ ulong end, max;
+ int i, t;
+
+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 */
+static struct syment *
+prev_module_symbol_by_syment(struct syment *sp_in)
+{
+ struct load_module *lm;
+ struct syment *sp;
+ int i, t;
- 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 +6268,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 +6314,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]);
@@ -5600,7 +6539,7 @@ kernel_symbol_search(char *symbol)
int
get_syment_array(char *symbol, struct syment **sp_array, int max)
{
- int i, cnt;
+ int i, cnt, t;
struct syment *sp, *sp_end;
struct load_module *lm;
@@ -5625,6 +6564,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 +10193,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 +11819,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 +12435,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 +12449,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 +12692,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, t;
+
+ 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, syminfo.name,
+ (long) syminfo.value);
+ }
+ if (strcmp(syminfo.name, 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 +13015,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);
}
}
@@ -12269,24 +13360,43 @@ static struct syment *
kallsyms_module_symbol(struct load_module *lm, symbol_info *syminfo)
{
struct syment *sp, *spx;
- int cnt;
+ int cnt, t;
if (!(lm->mod_flags & MOD_KALLSYMS))
return NULL;
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)) {
@@ -12312,7 +13422,7 @@ static void
store_load_module_symbols(bfd *bfd, int dynamic, void *minisyms,
long symcount, unsigned int size, ulong base_addr, char *namelist)
{
- int i;
+ int i, t;
asymbol *store;
asymbol *sym;
bfd_byte *from, *fromend;
@@ -12323,7 +13433,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 +13490,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 +13511,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 +13621,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 +13659,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 +13748,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 +13758,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 +13773,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 +13795,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;
@@ -12642,7 +13860,7 @@ store_load_module_symbols(bfd *bfd, int dynamic, void *minisyms,
void
delete_load_module(ulong base_addr)
{
- int i;
+ int i, t;
struct load_module *lm;
struct gnu_request request, *req;
@@ -12657,7 +13875,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 +13894,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 +13939,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 +13958,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;
@@ -13455,7 +14723,7 @@ is_downsized(char *name)
struct syment *
symbol_complete_match(const char *match, struct syment *sp_last)
{
- int i;
+ int i, t;
struct syment *sp, *sp_end, *sp_start;
struct load_module *lm;
int search_init;
@@ -13475,6 +14743,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 +14817,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.37.1
Reference in New Issue View Git Blame Copy Permalink