crash/0013-Support-module-memory-layout-change-on-Linux-6.4.patch

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