use modutils for non Intel arch's

67 files changed, 13421 insertions, 9 deletions

diff --git a/mdk-stage1/Makefile b/mdk-stage1/Makefile
index c230d4b39..530c8b9b2 100644
--- a/mdk-stage1/Makefile
+++ b/mdk-stage1/Makefile
@@ -26,9 +26,6 @@ top_dir = .
 include $(top_dir)/Makefile.common
 
 
-ARCH := $(patsubst i%86,i386,$(shell uname -m))
-ARCH := $(patsubst sparc%,sparc,$(ARCH))
-
 CFLAGS = -Os -pipe -Wall -Werror -fomit-frame-pointer
 
 DEFS = -DVERSION=\"$(VERSION)\"
@@ -73,9 +70,14 @@ MEDIAS_FRONTEND_LINK = $(FRONTEND_LINK)
 endif
 endif
 
+ifeq (i386, $(ARCH))
+INSMOD = insmod-busybox
+else
+INSMOD = insmod-modutils
+endif
 
-GLIBC_STAGE1_OWN_LIBS = insmod-busybox/libinsmod.a mar/libmar.a bzlib/libbzlib.a
-DIETLIBC_STAGE1_OWN_LIBS = insmod-busybox/libinsmod-DIET.a mar/libmar-DIET.a bzlib/libbzlib-DIET.a
+GLIBC_STAGE1_OWN_LIBS = $(INSMOD)/libinsmod.a mar/libmar.a bzlib/libbzlib.a
+DIETLIBC_STAGE1_OWN_LIBS = $(INSMOD)/libinsmod-DIET.a mar/libmar-DIET.a bzlib/libbzlib-DIET.a
 STAGE1_OWN_LIBS = $($(L)_STAGE1_OWN_LIBS)
 
 
@@ -116,10 +118,14 @@ INIT_LIBC = $(DIETLIBC_LIBC)
 endif
 
 
-BINS = init stage1-cdrom stage1-disk stage1-network stage1-full
+BINS = init stage1-full
+
+ifeq (i386, $(ARCH))
+BINS += stage1-cdrom stage1-disk stage1-network
+endif
 
 
-DIRS = dietlibc mar insmod-busybox pci-resource bzlib
+DIRS = dietlibc mar pci-resource bzlib $(INSMOD)
 ifeq (i386,$(ARCH))
 DIRS += pcmcia
 endif
diff --git a/mdk-stage1/Makefile.common b/mdk-stage1/Makefile.common
index 9d2d3f9f3..ec8441978 100644
--- a/mdk-stage1/Makefile.common
+++ b/mdk-stage1/Makefile.common
@@ -14,6 +14,8 @@
  #
  #*****************************************************************************
 
+ARCH := $(patsubst i%86,i386,$(shell uname -m))
+ARCH := $(patsubst sparc%,sparc,$(ARCH))
 
  #- default lib is dietlibc (honoured by main Makefile whenever possible)
 L = DIETLIBC
diff --git a/mdk-stage1/insmod-busybox/insmod.c b/mdk-stage1/insmod-busybox/insmod.c
index 95dee8855..d1027004c 100644
--- a/mdk-stage1/insmod-busybox/insmod.c
+++ b/mdk-stage1/insmod-busybox/insmod.c
@@ -36,6 +36,7 @@
  *
  */
 
+#include "../insmod.h"
 #include "busybox.h"
 #include <stdlib.h>
 #include <stdio.h>
diff --git a/mdk-stage1/insmod-modutils/Makefile b/mdk-stage1/insmod-modutils/Makefile
new file mode 100644
index 000000000..74ebdeafb
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/Makefile
@@ -0,0 +1,61 @@
+ #******************************************************************************
+ #
+ #    insmod from modutils (generic)
+ #
+ # $Id$
+ #
+ # Copyright 1996, 1997 Linux International.
+ #
+ #*****************************************************************************
+
+top_dir = ..
+
+include $(top_dir)/Makefile.common
+
+
+FLAGS = -c -Wall -Os -fomit-frame-pointer -I./include -D_GNU_SOURCE -DELF_MACHINE_H='"elf_$(ARCH).h"' -DARCH_$(ARCH)
+
+
+DIRS = util obj
+
+all: dirs insmod libinsmod.a #libinsmod-DIET.a
+
+dirs:
+	@for n in . $(DIRS); do \
+		[ "$$n" = "." ] || make -C $$n ;\
+	done
+
+clean:
+	@for n in $(DIRS); do \
+		(cd $$n; make clean) \
+	done
+	rm -rf t *.o insmod libinsmod.a libinsmod-DIET.a
+
+
+insmod: insmod-frontend.o insmod.o ./util/libutil-STANDALONE.a ./obj/libobj.a
+	gcc -o $@ $^
+	$(STRIPCMD) $@
+
+t/.create_stuff: util/libutil.a obj/libobj.a
+	rm -rf t
+	mkdir t
+	cd t &&	for e in $^; do ar -x ../$$e; done
+	touch t/.create_stuff
+
+libinsmod.a: insmod.o t/.create_stuff
+	ar cru $@ insmod.o t/*
+	ranlib $@
+
+libinsmod-DIET.a: insmod-DIET.o ./util/libutil-DIET.a ./obj/libobj-DIET.a
+	ar cru $@ $^
+	ranlib $@
+
+insmod-frontend.o: insmod-frontend.c insmod.c
+	gcc $(FLAGS) $(GLIBC_INCLUDES) insmod-frontend.c
+
+insmod.o: insmod.c
+	gcc $(FLAGS) $(GLIBC_INCLUDES) insmod.c
+
+insmod-DIET.o: insmod.c
+	gcc $(FLAGS) $(DIETLIBC_INCLUDES) -o $@ insmod.c
+
diff --git a/mdk-stage1/insmod-modutils/include/config.h b/mdk-stage1/insmod-modutils/include/config.h
new file mode 100644
index 000000000..11da6a523
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/config.h
@@ -0,0 +1,105 @@
+/*
+ * Configuration file management
+ *
+ * Copyright 1994, 1995, 1996, 1997:
+ *	Jacques Gelinas <jack@solucorp.qc.ca>
+ *	Björn Ekwall <bj0rn@blox.se> February, March 1999
+ *
+ * This file is part of the Linux modutils.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifndef _CONFIG_H
+#define _CONFIG_H
+
+#include <stdio.h>
+#include <sys/utsname.h>
+
+#define ETC_MODULES_CONF	"/etc/modules.conf"
+
+#define EXEC_PRE_INSTALL 0
+#define EXEC_POST_INSTALL 1
+#define EXEC_PRE_REMOVE 2
+#define EXEC_POST_REMOVE 3
+#define EXEC_INSTALL 4
+#define EXEC_REMOVE 5
+
+struct PATH_TYPE {
+	char *type;
+	char *path;
+};
+
+struct EXEC_TYPE {
+	int when;
+	char *module;
+	char *cmd;
+};
+
+typedef struct {
+	char *name;
+	GLOB_LIST *opts;
+	int autoclean;
+} OPT_LIST;
+
+/* config.c */
+extern int flag_autoclean;
+extern struct utsname uts_info;
+extern char *aliaslist[];
+extern struct PATH_TYPE *modpath;
+extern int nmodpath;
+extern struct EXEC_TYPE *execs;
+extern int nexecs;
+extern char *insmod_opt;
+extern char *config_file;
+extern char *optlist[];
+extern char *prune[];
+extern OPT_LIST *opt_list;
+extern OPT_LIST *abovelist;
+extern OPT_LIST *belowlist;
+extern OPT_LIST *prunelist;
+extern OPT_LIST *probe_list;
+extern OPT_LIST *probeall_list;
+extern OPT_LIST *aliases;
+extern time_t config_mtime;
+extern int root_check_off;	/* Check modules are owned by root? */
+
+/* Information about generated files */
+struct gen_files {
+	char *base;		/* xxx in /lib/modules/`uname -r`/modules.xxx */
+	char *name;             /* name actually used */
+	time_t mtime;
+};
+
+extern struct gen_files gen_file[];
+extern const int gen_file_count;
+/* The enum order must match the gen_file initialization order in config.c */
+enum gen_file_enum {
+	GEN_GENERIC_STRINGFILE,
+	GEN_PCIMAPFILE,
+	GEN_ISAPNPMAPFILE,
+	GEN_USBMAPFILE,
+	GEN_PARPORTMAPFILE,
+	GEN_DEPFILE,
+};
+
+extern char *persistdir;
+
+char *fgets_strip(char *buf, int sizebuf, FILE * fin, int *lineno);
+int config_read(int all, char *force_ver, char *base_dir, char *conf_file);
+GLOB_LIST *config_lstmod(const char *match, const char *type, int first_only);
+char *search_module_path(const char *base);
+
+#endif /* _CONFIG_H */
diff --git a/mdk-stage1/insmod-modutils/include/elf_alpha.h b/mdk-stage1/insmod-modutils/include/elf_alpha.h
new file mode 100644
index 000000000..f1ec66f1c
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/elf_alpha.h
@@ -0,0 +1,10 @@
+/* Machine-specific elf macros for the Alpha.  */
+#ident "$Id$"
+
+#define ELFCLASSM	ELFCLASS64
+#define ELFDATAM	ELFDATA2LSB
+
+#define MATCH_MACHINE(x)  (x == EM_ALPHA)
+
+#define SHT_RELM	SHT_RELA
+#define Elf64_RelM	Elf64_Rela
diff --git a/mdk-stage1/insmod-modutils/include/elf_arm.h b/mdk-stage1/insmod-modutils/include/elf_arm.h
new file mode 100644
index 000000000..f6b531e88
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/elf_arm.h
@@ -0,0 +1,10 @@
+/* Machine-specific elf macros for ARM.  */
+#ident "$Id$"
+
+#define ELFCLASSM	ELFCLASS32
+#define ELFDATAM	ELFDATA2LSB
+
+#define MATCH_MACHINE(x)  (x == EM_ARM)
+
+#define SHT_RELM	SHT_REL
+#define Elf32_RelM	Elf32_Rel
diff --git a/mdk-stage1/insmod-modutils/include/elf_hppa.h b/mdk-stage1/insmod-modutils/include/elf_hppa.h
new file mode 100644
index 000000000..9a1bd34ce
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/elf_hppa.h
@@ -0,0 +1,9 @@
+/* Machine-specific elf macros for HP-PA.  */
+
+#define ELFCLASSM	ELFCLASS32
+#define ELFDATAM	ELFDATA2MSB
+
+#define MATCH_MACHINE(x)  (x == EM_PARISC)
+
+#define SHT_RELM	SHT_RELA
+#define Elf32_RelM	Elf32_Rela
diff --git a/mdk-stage1/insmod-modutils/include/elf_hppa64.h b/mdk-stage1/insmod-modutils/include/elf_hppa64.h
new file mode 100644
index 000000000..05b201aef
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/elf_hppa64.h
@@ -0,0 +1,9 @@
+/* Machine-specific elf macros for HP-PA64.  */
+
+#define ELFCLASSM	ELFCLASS64
+#define ELFDATAM	ELFDATA2MSB
+
+#define MATCH_MACHINE(x)  (x == EM_PARISC)
+
+#define SHT_RELM	SHT_RELA
+#define Elf64_RelM	Elf64_Rela
diff --git a/mdk-stage1/insmod-modutils/include/elf_i386.h b/mdk-stage1/insmod-modutils/include/elf_i386.h
new file mode 100644
index 000000000..c6c2d326e
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/elf_i386.h
@@ -0,0 +1,10 @@
+/* Machine-specific elf macros for i386 et al.  */
+#ident "$Id$"
+
+#define ELFCLASSM	ELFCLASS32
+#define ELFDATAM	ELFDATA2LSB
+
+#define MATCH_MACHINE(x)  (x == EM_386)
+
+#define SHT_RELM	SHT_REL
+#define Elf32_RelM	Elf32_Rel
diff --git a/mdk-stage1/insmod-modutils/include/elf_ia64.h b/mdk-stage1/insmod-modutils/include/elf_ia64.h
new file mode 100644
index 000000000..b4d902956
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/elf_ia64.h
@@ -0,0 +1,9 @@
+/* Machine-specific elf macros for ia64.  */
+
+#define ELFCLASSM	ELFCLASS64
+#define ELFDATAM	ELFDATA2LSB
+
+#define MATCH_MACHINE(x)  (x == EM_IA_64)
+
+#define SHT_RELM	SHT_RELA
+#define Elf64_RelM	Elf64_Rela
diff --git a/mdk-stage1/insmod-modutils/include/elf_m68k.h b/mdk-stage1/insmod-modutils/include/elf_m68k.h
new file mode 100644
index 000000000..817fc8f2c
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/elf_m68k.h
@@ -0,0 +1,10 @@
+/* Machine-specific elf macros for m68k.  */
+#ident "$Id$"
+
+#define ELFCLASSM	ELFCLASS32
+#define ELFDATAM	ELFDATA2MSB
+
+#define MATCH_MACHINE(x)  (x == EM_68K)
+
+#define SHT_RELM	SHT_RELA
+#define Elf32_RelM	Elf32_Rela
diff --git a/mdk-stage1/insmod-modutils/include/elf_mips.h b/mdk-stage1/insmod-modutils/include/elf_mips.h
new file mode 100644
index 000000000..8a0430216
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/elf_mips.h
@@ -0,0 +1,24 @@
+/* Machine-specific elf macros for MIPS.  */
+#ident "$Id$"
+
+#define ELFCLASSM	ELFCLASS32
+#ifdef __MIPSEB__
+#define ELFDATAM	ELFDATA2MSB
+#endif
+#ifdef __MIPSEL__
+#define ELFDATAM	ELFDATA2LSB
+#endif
+
+/* Account for ELF spec changes.  */
+#ifndef EM_MIPS_RS3_LE
+#ifdef EM_MIPS_RS4_BE
+#define EM_MIPS_RS3_LE	EM_MIPS_RS4_BE
+#else
+#define EM_MIPS_RS3_LE	10
+#endif
+#endif /* !EM_MIPS_RS3_LE */
+
+#define MATCH_MACHINE(x)  (x == EM_MIPS || x == EM_MIPS_RS3_LE)
+
+#define SHT_RELM	SHT_REL
+#define Elf32_RelM	Elf32_Rel
diff --git a/mdk-stage1/insmod-modutils/include/elf_ppc.h b/mdk-stage1/insmod-modutils/include/elf_ppc.h
new file mode 100644
index 000000000..71596de8c
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/elf_ppc.h
@@ -0,0 +1,10 @@
+/* Machine-specific elf macros for the PowerPC.  */
+#ident "$Id$"
+
+#define ELFCLASSM	ELFCLASS32
+#define ELFDATAM	ELFDATA2MSB
+
+#define MATCH_MACHINE(x)  (x == EM_PPC)
+
+#define SHT_RELM	SHT_RELA
+#define Elf32_RelM	Elf32_Rela
diff --git a/mdk-stage1/insmod-modutils/include/elf_s390.h b/mdk-stage1/insmod-modutils/include/elf_s390.h
new file mode 100644
index 000000000..547d66b83
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/elf_s390.h
@@ -0,0 +1,10 @@
+/* Machine-specific elf macros for i386 et al.  */
+#ident "$Id$"
+
+#define ELFCLASSM	ELFCLASS32
+#define ELFDATAM	ELFDATA2MSB
+
+#define MATCH_MACHINE(x)  (x == EM_S390)
+
+#define SHT_RELM	SHT_RELA
+#define Elf32_RelM	Elf32_Rela
diff --git a/mdk-stage1/insmod-modutils/include/elf_sparc.h b/mdk-stage1/insmod-modutils/include/elf_sparc.h
new file mode 100644
index 000000000..9b5c348d9
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/elf_sparc.h
@@ -0,0 +1,10 @@
+/* Machine-specific elf macros for the Sparc.  */
+#ident "$Id$"
+
+#define ELFCLASSM	ELFCLASS32
+#define ELFDATAM	ELFDATA2MSB
+
+#define MATCH_MACHINE(x)  (x == EM_SPARC)
+
+#define SHT_RELM	SHT_RELA
+#define Elf32_RelM	Elf32_Rela
diff --git a/mdk-stage1/insmod-modutils/include/elf_sparc64.h b/mdk-stage1/insmod-modutils/include/elf_sparc64.h
new file mode 100644
index 000000000..158edd7e1
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/elf_sparc64.h
@@ -0,0 +1,27 @@
+/* Machine-specific elf macros for the Sparc.  */
+#ident "$Id$"
+
+#define ELFCLASSM	ELFCLASS64
+#define ELFDATAM	ELFDATA2MSB
+
+#ifndef EM_SPARCV9
+#define EM_SPARCV9 43
+#endif
+#ifndef EM_SPARC64
+#define EM_SPARC64 11
+#endif
+#define MATCH_MACHINE(x)  ((x) == EM_SPARCV9 || (x) == EM_SPARC64)
+
+#define SHT_RELM	SHT_RELA
+#define Elf64_RelM	Elf64_Rela
+
+#ifndef ELF64_R_SYM
+#define ELF64_R_SYM(x)	((x) >> 32)
+#define ELF64_R_TYPE(x)	((unsigned)(x))
+#endif
+
+#ifndef ELF64_ST_BIND
+#define ELF64_ST_BIND(x)	((x) >> 4)
+#define ELF64_ST_TYPE(x)	((x) & 0xf)
+#endif
+
diff --git a/mdk-stage1/insmod-modutils/include/kallsyms.h b/mdk-stage1/insmod-modutils/include/kallsyms.h
new file mode 100644
index 000000000..9748873cf
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/kallsyms.h
@@ -0,0 +1,131 @@
+/* kallsyms headers
+   Copyright 2000 Keith Owens <kaos@ocs.com.au>
+
+   This file is part of the Linux modutils.  It is exported to kernel
+   space so debuggers can access the kallsyms data.
+
+   The kallsyms data contains all the non-stack symbols from a kernel
+   or a module.  The kernel symbols are held between __start___kallsyms
+   and __stop___kallsyms.  The symbols for a module are accessed via
+   the struct module chain which is based at module_list.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ident "$Id$"
+
+#ifndef MODUTILS_KALLSYMS_H
+#define MODUTILS_KALLSYMS_H 1
+
+/* Have to (re)define these ElfW entries here because external kallsyms
+ * code does not have access to modutils/include/obj.h.  This code is
+ * included from user spaces tools (modutils) and kernel, they need
+ * different includes.
+ */
+
+#ifndef ELFCLASS32
+#ifdef __KERNEL__
+#include <linux/elf.h>
+#else	/* __KERNEL__ */
+#include <elf.h>
+#endif	/* __KERNEL__ */
+#endif	/* ELFCLASS32 */
+
+#ifndef ELFCLASSM
+#define ELFCLASSM ELF_CLASS
+#endif
+
+#ifndef ElfW
+# if ELFCLASSM == ELFCLASS32
+#  define ElfW(x)  Elf32_ ## x
+#  define ELFW(x)  ELF32_ ## x
+# else
+#  define ElfW(x)  Elf64_ ## x
+#  define ELFW(x)  ELF64_ ## x
+# endif
+#endif
+
+/* Format of data in the kallsyms section.
+ * Most of the fields are small numbers but the total size and all
+ * offsets can be large so use the 32/64 bit types for these fields.
+ *
+ * Do not use sizeof() on these structures, modutils may be using extra
+ * fields.  Instead use the size fields in the header to access the
+ * other bits of data.
+ */  
+
+struct kallsyms_header {
+	int		size;		/* Size of this header */
+	ElfW(Word)	total_size;	/* Total size of kallsyms data */
+	int		sections;	/* Number of section entries */
+	ElfW(Off)	section_off;	/* Offset to first section entry */
+	int		section_size;	/* Size of one section entry */
+	int		symbols;	/* Number of symbol entries */
+	ElfW(Off)	symbol_off;	/* Offset to first symbol entry */
+	int		symbol_size;	/* Size of one symbol entry */
+	ElfW(Off)	string_off;	/* Offset to first string */
+	ElfW(Addr)	start;		/* Start address of first section */
+	ElfW(Addr)	end;		/* End address of last section */
+};
+
+struct kallsyms_section {
+	ElfW(Addr)	start;		/* Start address of section */
+	ElfW(Word)	size;		/* Size of this section */
+	ElfW(Off)	name_off;	/* Offset to section name */
+	ElfW(Word)	flags;		/* Flags from section */
+};
+
+struct kallsyms_symbol {
+	ElfW(Off)	section_off;	/* Offset to section that owns this symbol */
+	ElfW(Addr)	symbol_addr;	/* Address of symbol */
+	ElfW(Off)	name_off;	/* Offset to symbol name */
+};
+
+#define KALLSYMS_SEC_NAME "__kallsyms"
+#define KALLSYMS_IDX 2			/* obj_kallsyms creates kallsyms as section 2 */
+
+#define kallsyms_next_sec(h,s) \
+	((s) = (struct kallsyms_section *)((char *)(s) + (h)->section_size))
+#define kallsyms_next_sym(h,s) \
+	((s) = (struct kallsyms_symbol *)((char *)(s) + (h)->symbol_size))
+
+int kallsyms_symbol_to_address(
+	const char       *name,			/* Name to lookup */
+	unsigned long    *token,		/* Which module to start with */
+	const char      **mod_name,		/* Set to module name or "kernel" */
+	unsigned long    *mod_start,		/* Set to start address of module */
+	unsigned long    *mod_end,		/* Set to end address of module */
+	const char      **sec_name,		/* Set to section name */
+	unsigned long    *sec_start,		/* Set to start address of section */
+	unsigned long    *sec_end,		/* Set to end address of section */
+	const char      **sym_name,		/* Set to full symbol name */
+	unsigned long    *sym_start,		/* Set to start address of symbol */
+	unsigned long    *sym_end		/* Set to end address of symbol */
+	);
+
+int kallsyms_address_to_symbol(
+	unsigned long     address,		/* Address to lookup */
+	const char      **mod_name,		/* Set to module name */
+	unsigned long    *mod_start,		/* Set to start address of module */
+	unsigned long    *mod_end,		/* Set to end address of module */
+	const char      **sec_name,		/* Set to section name */
+	unsigned long    *sec_start,		/* Set to start address of section */
+	unsigned long    *sec_end,		/* Set to end address of section */
+	const char      **sym_name,		/* Set to full symbol name */
+	unsigned long    *sym_start,		/* Set to start address of symbol */
+	unsigned long    *sym_end		/* Set to end address of symbol */
+	);
+
+#endif /* kallsyms.h */
diff --git a/mdk-stage1/insmod-modutils/include/kerneld.h b/mdk-stage1/insmod-modutils/include/kerneld.h
new file mode 100644
index 000000000..3bc2c9d42
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/kerneld.h
@@ -0,0 +1,46 @@
+/* Definitions for the Linux kerneld SYSV IPC interface.
+   This file was part of the Linux kernel, and so is covered by the GPL.  */
+
+#ifndef MODUTILS_KERNELD_H
+#define MODUTILS_KERNELD_H
+
+#ident "$Id$"
+
+#define KERNELD_SYSTEM 1
+#define KERNELD_REQUEST_MODULE 2		/* "insmod" */
+#define KERNELD_RELEASE_MODULE 3		/* "rmmod" */
+#define KERNELD_DELAYED_RELEASE_MODULE 4	/* "rmmod" */
+#define KERNELD_CANCEL_RELEASE_MODULE 5		/* "rmmod" */
+#define KERNELD_REQUEST_ROUTE 6			/* net/ipv4/route.c */
+#define KERNELD_BLANKER 7			/* drivers/char/console.c */
+#define KERNELD_PNP 8				/* drivers/pnp/kerneld.c */
+#define KERNELD_ARP 256				/* net/ipv4/arp.c */
+
+#ifdef NEW_KERNELD_PROTOCOL
+# define OLDIPC_KERNELD 00040000	/* old kerneld message channel */
+# define IPC_KERNELD 00140000		/* new kerneld message channel */
+# define KDHDR (sizeof(long) + sizeof(short) + sizeof(short))
+# define NULL_KDHDR 0, 2, 0
+#else /* NEW_KERNELD_PROTOCOL */
+# define IPC_KERNELD 00040000
+# define KDHDR (sizeof(long))
+# define NULL_KDHDR 0
+#endif /* NEW_KERNELD_PROTOCOL */
+
+#define KERNELD_MAXCMD 0x7ffeffff
+#define KERNELD_MINSEQ 0x7fff0000 /* "commands" legal up to 0x7ffeffff */
+#define KERNELD_WAIT 0x80000000
+#define KERNELD_NOWAIT 0
+
+struct kerneld_msg
+  {
+    long mtype;
+    long id;
+#ifdef NEW_KERNELD_PROTOCOL
+    short version;
+    short pid;
+#endif /* NEW_KERNELD_PROTOCOL */
+    char text[1];
+  };
+
+#endif /* kerneld.h */
diff --git a/mdk-stage1/insmod-modutils/include/modstat.h b/mdk-stage1/insmod-modutils/include/modstat.h
new file mode 100644
index 000000000..b8a58eeae
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/modstat.h
@@ -0,0 +1,55 @@
+/*
+ * For kernel module status and information
+ *
+ * Add module_name_list and l_module_name_list.
+ *   Keith Owens <kaos@ocs.com.au> November 1999.
+ * Björn Ekwall <bj0rn@blox.se> February 1999.
+ *
+ * This file is part of the Linux modutils.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+#ifndef _KERNEL_H
+#define _KERNEL_H
+
+#define K_SYMBOLS 1 /* Want info about symbols */
+#define K_INFO 2 /* Want extended module info */
+#define K_REFS 4 /* Want info about references */
+
+struct module_stat {
+	char *name;
+	unsigned long addr;
+	unsigned long modstruct; /* COMPAT_2_0! *//* depends on architecture? */
+	unsigned long size;
+	unsigned long flags;
+	long usecount;
+	size_t nsyms;
+	struct module_symbol *syms;
+	size_t nrefs;
+	struct module_stat **refs;
+	unsigned long status;
+};
+
+extern struct module_stat *module_stat;
+extern size_t n_module_stat;
+extern char *module_name_list;
+extern size_t l_module_name_list;
+extern struct module_symbol *ksyms;
+extern size_t nksyms;
+extern int k_new_syscalls;
+
+int get_kernel_info(int type);
+
+#endif /* _KERNEL_H */
diff --git a/mdk-stage1/insmod-modutils/include/module.h b/mdk-stage1/insmod-modutils/include/module.h
new file mode 100644
index 000000000..db49ab2b2
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/module.h
@@ -0,0 +1,210 @@
+/* Definitions for the Linux module syscall interface.
+   Copyright 1996, 1997 Linux International.
+
+   Contributed by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+
+#ifndef MODUTILS_MODULE_H
+#define MODUTILS_MODULE_H 1
+
+#ident "$Id$"
+
+/* This file contains the structures used by the 2.0 and 2.1 kernels.
+   We do not use the kernel headers directly because we do not wish
+   to be dependant on a particular kernel version to compile insmod.  */
+
+
+/*======================================================================*/
+/* The structures used by Linux 2.0.  */
+
+/* The symbol format used by get_kernel_syms(2).  */
+struct old_kernel_sym
+{
+  unsigned long value;
+  char name[60];
+};
+
+struct old_module_ref
+{
+  unsigned long module;		/* kernel addresses */
+  unsigned long next;
+};
+
+struct old_module_symbol
+{
+  unsigned long addr;
+  unsigned long name;
+};
+
+struct old_symbol_table
+{
+  int size;			/* total, including string table!!! */
+  int n_symbols;
+  int n_refs;
+  struct old_module_symbol symbol[0]; /* actual size defined by n_symbols */
+  struct old_module_ref ref[0];	/* actual size defined by n_refs */
+};
+
+struct old_mod_routines
+{
+  unsigned long init;
+  unsigned long cleanup;
+};
+
+struct old_module
+{
+  unsigned long next;
+  unsigned long ref;		/* the list of modules that refer to me */
+  unsigned long symtab;
+  unsigned long name;
+  int size;			/* size of module in pages */
+  unsigned long addr;		/* address of module */
+  int state;
+  unsigned long cleanup;	/* cleanup routine */
+};
+
+/* Sent to init_module(2) or'ed into the code size parameter.  */
+#define OLD_MOD_AUTOCLEAN 0x40000000 /* big enough, but no sign problems... */
+
+int get_kernel_syms(struct old_kernel_sym *);
+int old_sys_init_module(const char *name, char *code, unsigned codesize,
+			struct old_mod_routines *, struct old_symbol_table *);
+
+/*======================================================================*/
+/* For sizeof() which are related to the module platform and not to the
+   environment isnmod is running in, use sizeof_xx instead of sizeof(xx).  */
+
+#define tgt_sizeof_char		sizeof(char)
+#define tgt_sizeof_short	sizeof(short)
+#define tgt_sizeof_int		sizeof(int)
+#define tgt_sizeof_long		sizeof(long)
+#define tgt_sizeof_char_p	sizeof(char *)
+#define tgt_sizeof_void_p	sizeof(void *)
+#define tgt_long		long
+#define tgt_long_fmt		"l"
+
+/* This assumes that long long on a 32 bit system is equivalent to long on the
+ * equivalent 64 bit system.  Also that void and char pointers are 8 bytes on
+ * all 64 bit systems.  Add per system tweaks if it ever becomes necessary.
+ */
+#if defined(COMMON_3264) && defined(ONLY_64)
+#undef tgt_long
+#undef tgt_long_fmt
+#undef tgt_sizeof_long
+#undef tgt_sizeof_char_p
+#undef tgt_sizeof_void_p
+#define tgt_long                long long
+#define tgt_long_fmt		"ll"
+#define tgt_sizeof_long         8
+#define tgt_sizeof_char_p       8
+#define tgt_sizeof_void_p       8
+#endif
+
+/*======================================================================*/
+/* The structures used in Linux 2.1 onwards.  */
+
+/* Note: module_symbol does not use tgt_long intentionally */
+struct module_symbol
+{
+  unsigned long value;
+  unsigned long name;
+};
+
+struct module_ref
+{
+  unsigned tgt_long dep;		/* kernel addresses */
+  unsigned tgt_long ref;
+  unsigned tgt_long next_ref;
+};
+
+struct module
+{
+  unsigned tgt_long size_of_struct;	/* == sizeof(module) */
+  unsigned tgt_long next;
+  unsigned tgt_long name;
+  unsigned tgt_long size;
+
+  tgt_long usecount;
+  unsigned tgt_long flags;		/* AUTOCLEAN et al */
+
+  unsigned nsyms;
+  unsigned ndeps;
+
+  unsigned tgt_long syms;
+  unsigned tgt_long deps;
+  unsigned tgt_long refs;
+  unsigned tgt_long init;
+  unsigned tgt_long cleanup;
+  unsigned tgt_long ex_table_start;
+  unsigned tgt_long ex_table_end;
+#ifdef __alpha__
+  unsigned tgt_long gp;
+#endif
+  /* Everything after here is extension.  */
+  unsigned tgt_long read_start;		/* Read data from existing module */
+  unsigned tgt_long read_end;
+  unsigned tgt_long can_unload;
+  unsigned tgt_long runsize;
+  unsigned tgt_long kallsyms_start;
+  unsigned tgt_long kallsyms_end;
+  unsigned tgt_long archdata_start;
+  unsigned tgt_long archdata_end;
+  unsigned tgt_long kernel_data;
+};
+
+struct module_info
+{
+  unsigned long addr;
+  unsigned long size;
+  unsigned long flags;
+	   long usecount;
+};
+
+/* Bits of module.flags.  */
+#define NEW_MOD_RUNNING		1
+#define NEW_MOD_DELETED		2
+#define NEW_MOD_AUTOCLEAN	4
+#define NEW_MOD_VISITED		8
+#define NEW_MOD_USED_ONCE	16
+#define NEW_MOD_INITIALIZING	64
+
+int sys_init_module(const char *name, const struct module *);
+int query_module(const char *name, int which, void *buf, size_t bufsize,
+		 size_t *ret);
+
+/* Values for query_module's which.  */
+
+#define QM_MODULES	1
+#define QM_DEPS		2
+#define QM_REFS		3
+#define QM_SYMBOLS	4
+#define QM_INFO		5
+
+/*======================================================================*/
+/* The system calls unchanged between 2.0 and 2.1.  */
+
+unsigned long create_module(const char *, size_t);
+int delete_module(const char *);
+
+/* In safe mode the last parameter is forced to be a module name and meta
+ * expansion is not allowed on that name.
+ */
+extern unsigned int safemode;
+
+#endif /* module.h */
diff --git a/mdk-stage1/insmod-modutils/include/obj.h b/mdk-stage1/insmod-modutils/include/obj.h
new file mode 100644
index 000000000..b140c65c3
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/obj.h
@@ -0,0 +1,275 @@
+/* Elf object file loading and relocation routines.
+   Copyright 1996, 1997 Linux International.
+
+   Contributed by Richard Henderson <rth@tamu.edu>
+   obj_free() added by Björn Ekwall <bj0rn@blox.se> March 1999
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+
+#ifndef MODUTILS_OBJ_H
+#define MODUTILS_OBJ_H 1
+
+#ident "$Id$"
+
+/* The relocatable object is manipulated using elfin types.  */
+
+#include <stdio.h>
+#include <elf.h>
+#include ELF_MACHINE_H
+
+#ifndef ElfW
+# if ELFCLASSM == ELFCLASS32
+#  define ElfW(x)  Elf32_ ## x
+#  define ELFW(x)  ELF32_ ## x
+# else
+#  define ElfW(x)  Elf64_ ## x
+#  define ELFW(x)  ELF64_ ## x
+# endif
+#endif
+
+#if defined(COMMON_3264) && defined(ONLY_32)
+#  define ObjW(x)  obj32_ ## x
+#else
+#  if defined(COMMON_3264) && defined(ONLY_64)
+#    define ObjW(x)  obj64_ ## x
+#  else
+#    define ObjW(x)    obj_ ## x
+#  endif
+#endif
+
+/* For some reason this is missing from lib5.  */
+#ifndef ELF32_ST_INFO
+# define ELF32_ST_INFO(bind, type)       (((bind) << 4) + ((type) & 0xf))
+#endif
+
+#ifndef ELF64_ST_INFO
+# define ELF64_ST_INFO(bind, type)       (((bind) << 4) + ((type) & 0xf))
+#endif
+
+struct obj_string_patch_struct;
+struct obj_symbol_patch_struct;
+
+struct obj_section
+{
+  ElfW(Shdr) header;
+  const char *name;
+  char *contents;
+  struct obj_section *load_next;
+  int idx;
+};
+
+struct obj_symbol
+{
+  struct obj_symbol *next;	/* hash table link */
+  const char *name;
+  unsigned long value;
+  unsigned long size;
+  int secidx;			/* the defining section index/module */
+  int info;
+  int ksymidx;			/* for export to the kernel symtab */
+  int r_type;			/* relocation type */
+};
+
+/* Hardcode the hash table size.  We shouldn't be needing so many
+   symbols that we begin to degrade performance, and we get a big win
+   by giving the compiler a constant divisor.  */
+
+#define HASH_BUCKETS  521
+
+struct obj_file
+{
+  ElfW(Ehdr) header;
+  ElfW(Addr) baseaddr;
+  struct obj_section **sections;
+  struct obj_section *load_order;
+  struct obj_section **load_order_search_start;
+  struct obj_string_patch_struct *string_patches;
+  struct obj_symbol_patch_struct *symbol_patches;
+  int (*symbol_cmp)(const char *, const char *);
+  unsigned long (*symbol_hash)(const char *);
+  unsigned long local_symtab_size;
+  struct obj_symbol **local_symtab;
+  struct obj_symbol *symtab[HASH_BUCKETS];
+  const char *filename;
+  char *persist;
+};
+
+enum obj_reloc
+{
+  obj_reloc_ok,
+  obj_reloc_overflow,
+  obj_reloc_dangerous,
+  obj_reloc_unhandled,
+  obj_reloc_constant_gp
+};
+
+struct obj_string_patch_struct
+{
+  struct obj_string_patch_struct *next;
+  int reloc_secidx;
+  ElfW(Addr) reloc_offset;
+  ElfW(Addr) string_offset;
+};
+
+struct obj_symbol_patch_struct
+{
+  struct obj_symbol_patch_struct *next;
+  int reloc_secidx;
+  ElfW(Addr) reloc_offset;
+  struct obj_symbol *sym;
+};
+
+
+/* Generic object manipulation routines.  */
+
+#define obj_elf_hash			ObjW(elf_hash)
+#define obj_elf_hash_n			ObjW(elf_hash_n)
+#define obj_add_symbol			ObjW(add_symbol)
+#define obj_find_symbol			ObjW(find_symbol)
+#define obj_symbol_final_value		ObjW(symbol_final_value)
+#define obj_set_symbol_compare		ObjW(set_symbol_compare)
+#define obj_find_section		ObjW(find_section)
+#define obj_insert_section_load_order	ObjW(insert_section_load_order)
+#define obj_create_alloced_section	ObjW(create_alloced_section)
+#define obj_create_alloced_section_first \
+					ObjW(create_alloced_section_first)
+#define obj_extend_section		ObjW(extend_section)
+#define obj_string_patch		ObjW(string_patch)
+#define obj_symbol_patch		ObjW(symbol_patch)
+#define obj_check_undefineds		ObjW(check_undefineds)
+#define obj_clear_undefineds		ObjW(clear_undefineds)
+#define obj_allocate_commons		ObjW(allocate_commons)
+#define obj_load_size			ObjW(load_size)
+#define obj_relocate			ObjW(relocate)
+#define obj_load			ObjW(load)
+#define obj_free			ObjW(free)
+#define obj_create_image		ObjW(create_image)
+#define obj_addr_to_native_ptr		ObjW(addr_to_native_ptr)
+#define obj_native_ptr_to_addr		ObjW(native_ptr_to_addr)
+#define arch_new_file			ObjW(arch_new_file)
+#define arch_new_section		ObjW(arch_new_section)
+#define arch_new_symbol			ObjW(arch_new_symbol)
+#define arch_apply_relocation		ObjW(arch_apply_relocation)
+#define arch_create_got			ObjW(arch_create_got)
+#define arch_init_module		ObjW(arch_init_module)
+#define arch_load_proc_section		ObjW(arch_load_proc_section)
+#define arch_finalize_section_address	ObjW(arch_finalize_section_address)
+#define arch_archdata			ObjW(arch_archdata)
+
+unsigned long obj_elf_hash (const char *);
+
+unsigned long obj_elf_hash_n (const char *, unsigned long len);
+
+struct obj_symbol *obj_add_symbol (struct obj_file *f, const char *name,
+				   unsigned long symidx, int info, int secidx,
+				   ElfW(Addr) value, unsigned long size);
+
+struct obj_symbol *obj_find_symbol (struct obj_file *f,
+					 const char *name);
+
+ElfW(Addr) obj_symbol_final_value (struct obj_file *f,
+				  struct obj_symbol *sym);
+
+void obj_set_symbol_compare (struct obj_file *f,
+			    int (*cmp)(const char *, const char *),
+			    unsigned long (*hash)(const char *));
+
+struct obj_section *obj_find_section (struct obj_file *f,
+					   const char *name);
+
+void obj_insert_section_load_order (struct obj_file *f,
+				    struct obj_section *sec);
+
+struct obj_section *obj_create_alloced_section (struct obj_file *f,
+						const char *name,
+						unsigned long align,
+						unsigned long size);
+
+struct obj_section *obj_create_alloced_section_first (struct obj_file *f,
+						      const char *name,
+						      unsigned long align,
+						      unsigned long size);
+
+void *obj_extend_section (struct obj_section *sec, unsigned long more);
+
+int obj_string_patch (struct obj_file *f, int secidx, ElfW(Addr) offset,
+		     const char *string);
+
+int obj_symbol_patch (struct obj_file *f, int secidx, ElfW(Addr) offset,
+		     struct obj_symbol *sym);
+
+int obj_check_undefineds (struct obj_file *f, int quiet);
+
+void obj_clear_undefineds (struct obj_file *f);
+
+void obj_allocate_commons (struct obj_file *f);
+
+unsigned long obj_load_size (struct obj_file *f);
+
+int obj_relocate (struct obj_file *f, ElfW(Addr) base);
+
+struct obj_file *obj_load (int f, Elf32_Half e_type, const char *filename);
+
+void obj_free (struct obj_file *f);
+
+int obj_create_image (struct obj_file *f, char *image);
+
+int obj_kallsyms (struct obj_file *fin, struct obj_file **fout);
+
+/* Architecture specific manipulation routines.  */
+
+struct obj_file *arch_new_file (void);
+
+struct obj_section *arch_new_section (void);
+
+struct obj_symbol *arch_new_symbol (void);
+
+enum obj_reloc arch_apply_relocation (struct obj_file *f,
+				      struct obj_section *targsec,
+				      struct obj_section *symsec,
+				      struct obj_symbol *sym,
+				      ElfW(RelM) *rel, ElfW(Addr) value);
+
+int arch_create_got (struct obj_file *f);
+
+struct module;
+int arch_init_module (struct obj_file *f, struct module *);
+
+int arch_load_proc_section (struct obj_section *sec, int fp);
+
+int arch_finalize_section_address (struct obj_file *f, ElfW(Addr) base);
+
+int arch_archdata (struct obj_file *fin, struct obj_section *sec);
+
+#define ARCHDATA_SEC_NAME "__archdata"
+
+/* Pointers in objects can be 32 or 64 bit */
+union obj_ptr_4 {
+	Elf32_Word addr;
+	void *ptr;
+};
+union obj_ptr_8 {
+	Elf64_Xword addr;
+	void *ptr;
+};
+
+void *obj_addr_to_native_ptr(ElfW(Addr));
+
+ElfW(Addr) obj_native_ptr_to_addr(void *);
+
+#endif /* obj.h */
diff --git a/mdk-stage1/insmod-modutils/include/util.h b/mdk-stage1/insmod-modutils/include/util.h
new file mode 100644
index 000000000..b2e4a67c3
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/util.h
@@ -0,0 +1,101 @@
+/* Miscelaneous utility functions.
+   Copyright 1996, 1997 Linux International.
+
+   Contributed by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+
+#ifndef MODUTILS_UTIL_H
+#define MODUTILS_UTIL_H 1
+
+#ident "$Id$"
+
+#include <stdio.h>
+#include <sys/stat.h>
+
+#define SHELL_META "&();|<>$`\"'\\!{}[]~=+:?*" /* Sum of bj0rn and Debian */
+
+void *xmalloc(size_t);
+void *xrealloc(void *, size_t);
+char *xstrdup(const char *);
+char *xstrcat(char *, const char *, size_t);
+int   xsystem(const char *, char *const[]);
+int   arch64(void);
+
+typedef int (*xftw_func_t)(const char *, const struct stat *);
+extern int xftw(const char *directory, xftw_func_t);
+
+/* Error logging */
+extern int log;
+extern int errors;
+extern const char *error_file;
+
+extern int flag_verbose;
+extern void verbose(const char *ctl,...);
+
+void error(const char *fmt, ...)
+#ifdef __GNUC__
+  __attribute__((format(printf, 1, 2)))
+#endif
+  ;
+
+void lprintf(const char *fmt, ...)
+#ifdef __GNUC__
+  __attribute__((format(printf, 1, 2)))
+#endif
+  ;
+
+void setsyslog(const char *program);
+
+/*
+ * Generic globlist <bj0rn@blox.se>
+ */
+typedef struct {
+	int pathc;       /* Count of paths matched so far  */
+	char **pathv;    /* List of matched pathnames.  */
+} GLOB_LIST;
+int meta_expand(char *pt, GLOB_LIST *g, char *base_dir, char *version, int type);
+#define ME_BUILTIN_COMMAND	1
+#define ME_SHELL_COMMAND	2
+#define ME_GLOB			4
+#define ME_ALL			(ME_GLOB|ME_SHELL_COMMAND|ME_BUILTIN_COMMAND)
+
+extern void snap_shot(const char *module_name, int number);
+extern void snap_shot_log(const char *fmt,...);
+
+#ifdef CONFIG_USE_ZLIB
+int gzf_open(const char *name, int mode);
+int gzf_read(int fd, void *buf, size_t count);
+off_t gzf_lseek(int fd, off_t offset, int whence);
+void gzf_close(int fd);
+
+#else /* ! CONFIG_USE_ZLIB */
+
+#include <unistd.h>
+
+#define gzf_open	open
+#define gzf_read	read
+#define gzf_lseek	lseek
+#define gzf_close	close
+
+#endif /* CONFIG_USE_ZLIB */
+
+#define SYMPREFIX "__insmod_";
+extern const char symprefix[10];	/* Must be sizeof(SYMPREFIX), including nul */
+
+#endif /* util.h */
diff --git a/mdk-stage1/insmod-modutils/include/version.h b/mdk-stage1/insmod-modutils/include/version.h
new file mode 100644
index 000000000..51ca0eb29
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/include/version.h
@@ -0,0 +1 @@
+#define MODUTILS_VERSION "2.4.2"
diff --git a/mdk-stage1/insmod-modutils/insmod-frontend.c b/mdk-stage1/insmod-modutils/insmod-frontend.c
new file mode 100644
index 000000000..2b3aa1acb
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/insmod-frontend.c
@@ -0,0 +1,24 @@
+/*
+ * Guillaume Cottenceau (gc@mandrakesoft.com)
+ *
+ * Copyright 2000 MandrakeSoft
+ *
+ * This software may be freely redistributed under the terms of the GNU
+ * public license.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <stdio.h>
+
+
+int insmod_main( int argc, char **argv);
+
+int main( int argc, char **argv)
+{
+	printf("Using insmod provided by modutils.\n");
+	return insmod_main(argc, argv);
+}
diff --git a/mdk-stage1/insmod-modutils/insmod.c b/mdk-stage1/insmod-modutils/insmod.c
new file mode 100644
index 000000000..359b28837
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/insmod.c
@@ -0,0 +1,1964 @@
+/* Insert a module into a running kernel.
+   Copyright 1996, 1997 Linux International.
+
+   New implementation contributed by Richard Henderson <rth@tamu.edu>
+   Based on original work by Bjorn Ekwall <bj0rn@blox.se>
+   Restructured (and partly rewritten) by:
+	Björn Ekwall <bj0rn@blox.se> February 1999
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+  */
+
+  /*
+     Fixes:
+
+     Adjust module size for mod_use_count in old_init_module:
+     B. James Phillippe <bryan@terran.org>
+
+     Merged modprobe + many fixes: Björn Ekwall <bj0rn@blox.se> February 1999
+     SMP "friendliness" (and -P): Bill Zumach <zumach+@transarc.com>
+
+     Ksymoops support: Keith Owens <kaos@ocs.com.au> August 1999.
+
+     Add -r flag: Keith Owens <kaos@ocs.com.au> October 1999.
+
+     More flexible recognition of the way the utility was called.
+     Suggested by Stepan Kasal, implemented in a different way by Keith
+     Owens <kaos@ocs.com.au> December 1999.
+
+     Rationalize common code for 32/64 bit architectures.
+       Keith Owens <kaos@ocs.com.au> December 1999.
+     Add arch64().
+       Keith Owens <kaos@ocs.com.au> December 1999.
+     kallsyms support
+       Keith Owens <kaos@ocs.com.au> April 2000.
+     archdata support
+       Keith Owens <kaos@ocs.com.au> August 2000.
+     Add insmod -O, move print map before sys_init_module.
+       Keith Owens <kaos@ocs.com.au> October 2000.
+     Add insmod -S.
+       Keith Owens <kaos@ocs.com.au> November 2000.
+     Add persistent data support.
+       Keith Owens <kaos@ocs.com.au> November 2000.
+   */
+
+#ident "$Id$"
+
+#include "../insmod.h"
+#include <sys/types.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+//#include <alloca.h>  provided by stdlib
+#include <limits.h>
+#include <ctype.h>
+#include <errno.h>
+#include <stddef.h>
+#include <getopt.h>
+#include <sys/stat.h>
+#include <sys/file.h>
+
+#include "module.h"
+#include "obj.h"
+#include "kallsyms.h"
+#include "util.h"
+#include "version.h"
+
+#include "modstat.h"
+#include "config.h"
+
+#define STRVERSIONLEN	32
+
+/*======================================================================*/
+
+static int flag_force_load = 0;
+static int flag_silent_probe = 0;
+static int flag_export = 1;
+static int flag_load_map = 0;
+static int flag_ksymoops = 1;
+
+static int n_ext_modules_used;
+static int m_has_modinfo;
+
+extern int insmod_main(int argc, char **argv);
+extern int insmod_main_32(int argc, char **argv);
+extern int insmod_main_64(int argc, char **argv);
+extern int modprobe_main(int argc, char **argv);
+extern int rmmod_main(int argc, char **argv);
+extern int ksyms_main(int argc, char **argv);
+extern int lsmod_main(int argc, char **argv);
+extern int kallsyms_main(int argc, char **argv);
+
+/*======================================================================*/
+
+/* Get the kernel version in the canonical integer form.  */
+
+static int get_kernel_version(char str[STRVERSIONLEN])
+{
+	char *p, *q;
+	int a, b, c;
+
+	strncpy(str, uts_info.release, STRVERSIONLEN);
+	p = uts_info.release;
+
+	a = strtoul(p, &p, 10);
+	if (*p != '.')
+		return -1;
+	b = strtoul(p + 1, &p, 10);
+	if (*p != '.')
+		return -1;
+	c = strtoul(p + 1, &q, 10);
+	if (p + 1 == q)
+		return -1;
+
+	return a << 16 | b << 8 | c;
+}
+
+/* String comparison for non-co-versioned kernel and module.
+ * prefix should be the same as used by genksyms for this kernel.
+ */
+static char *ncv_prefix = NULL;	/* Overridden by --prefix option */
+static int ncv_plen = 0;
+
+/* Only set prefix once. If set by the user, use it.  If not set by the
+ * user, look for a well known kernel symbol and derive the prefix from
+ * there.  Otherwise set the prefix depending on whether uts_info
+ * includes SMP or not for backwards compatibility.
+ */
+static void set_ncv_prefix(char *prefix)
+{
+	static char derived_prefix[256];
+	static const char *well_known_symbol[] = { "get_module_symbol_R",
+						   "inter_module_get_R",
+						 };
+	struct module_symbol *s;
+	int i, j, l, m, pl;
+	const char *name;
+	char *p;
+
+	if (ncv_prefix)
+		return;
+
+	if (prefix)
+		ncv_prefix = prefix;
+	else {
+		/* Extract the prefix (if any) from well known symbols */
+		for (i = 0, s = ksyms; i < nksyms; ++i, ++s) {
+			name = (char *) s->name;
+			l = strlen(name);
+			for (j = 0; j < sizeof(well_known_symbol)/sizeof(well_known_symbol[0]); ++j) {
+				m = strlen(well_known_symbol[j]);
+				if (m + 8 > l ||
+				    strncmp(name, well_known_symbol[j], m))
+					continue;
+				pl = l - m - 8;
+				if (pl > sizeof(derived_prefix)-1)
+					continue;	/* Prefix is wrong length */
+				/* Must end with 8 hex digits */
+				(void) strtoul(name+l-8, &p, 16);
+				if (*p == 0) {
+					strncpy(derived_prefix, name+m, pl);
+					*(derived_prefix+pl) = '\0';
+					ncv_prefix = derived_prefix;
+					break;
+				}
+			}
+		}
+	}
+	if (!ncv_prefix) {
+		p = strchr(uts_info.version, ' ');
+		if (p && *(++p) && !strncmp(p, "SMP ", 4))
+			ncv_prefix = "smp_";
+		else
+			ncv_prefix = "";
+	}
+	ncv_plen = strlen(ncv_prefix);
+	if (flag_verbose)
+		lprintf("Symbol version prefix '%s'", ncv_prefix);
+}
+
+static int ncv_strcmp(const char *a, const char *b)
+{
+	size_t alen = strlen(a), blen = strlen(b);
+
+	if (blen == alen + 10 + ncv_plen &&
+	    b[alen] == '_' &&
+	    b[alen + 1] == 'R' &&
+	    !(ncv_plen && strncmp(b + alen + 2, ncv_prefix, ncv_plen))) {
+		return strncmp(a, b, alen);
+	} else if (alen == blen + 10 + ncv_plen &&
+		   a[blen] == '_' && a[blen + 1] == 'R' &&
+		   !(ncv_plen && strncmp(a + blen + 2, ncv_prefix, ncv_plen))) {
+		return strncmp(a, b, blen);
+	} else
+		return strcmp(a, b);
+}
+
+/*
+ * String hashing for non-co-versioned kernel and module.
+ * Here we are simply forced to drop the crc from the hash.
+ */
+static unsigned long ncv_symbol_hash(const char *str)
+{
+	size_t len = strlen(str);
+
+	if (len > 10 + ncv_plen &&
+	    str[len - 10 - ncv_plen] == '_' &&
+	    str[len - 9 - ncv_plen] == 'R' &&
+	    !(
+	      ncv_plen &&
+	      strncmp(str + len - (8 + ncv_plen), ncv_prefix, ncv_plen)
+	     ))
+		len -= 10 + ncv_plen;
+	return obj_elf_hash_n(str, len);
+}
+
+/*
+ * Conditionally add the symbols from the given symbol set
+ * to the new module.
+ */
+static int add_symbols_from(struct obj_file *f, int idx,
+			    struct module_symbol *syms, size_t nsyms)
+{
+	struct module_symbol *s;
+	size_t i;
+	int used = 0;
+
+	for (i = 0, s = syms; i < nsyms; ++i, ++s) {
+		/*
+		 * Only add symbols that are already marked external.
+		 * If we override locals we may cause problems for
+		 * argument initialization.
+		 * We will also create a false dependency on the module.
+		 */
+		struct obj_symbol *sym;
+
+		sym = obj_find_symbol(f, (char *) s->name);
+		if (sym && !ELFW(ST_BIND) (sym->info) == STB_LOCAL) {
+			sym = obj_add_symbol(f, (char *) s->name, -1,
+				  ELFW(ST_INFO) (STB_GLOBAL, STT_NOTYPE),
+					     idx, s->value, 0);
+			/*
+			 * Did our symbol just get installed?
+			 * If so, mark the module as "used".
+			 */
+			if (sym->secidx == idx)
+				used = 1;
+		}
+	}
+
+	return used;
+}
+
+static void add_kernel_symbols(struct obj_file *f)
+{
+	struct module_stat *m;
+	size_t i, nused = 0;
+
+	/* Add module symbols first.  */
+	for (i = 0, m = module_stat; i < n_module_stat; ++i, ++m)
+		if (m->nsyms &&
+		    add_symbols_from(f, SHN_HIRESERVE + 2 + i, m->syms, m->nsyms))
+			m->status = 1 /* used */, ++nused;
+	n_ext_modules_used = nused;
+
+	/* And finally the symbols from the kernel proper.  */
+	if (nksyms)
+		add_symbols_from(f, SHN_HIRESERVE + 1, ksyms, nksyms);
+}
+
+static void hide_special_symbols(struct obj_file *f)
+{
+	struct obj_symbol *sym;
+	const char *const *p;
+	static const char *const specials[] =
+	{
+		"cleanup_module",
+		"init_module",
+		"kernel_version",
+		NULL
+	};
+
+	for (p = specials; *p; ++p)
+		if ((sym = obj_find_symbol(f, *p)) != NULL)
+			sym->info = ELFW(ST_INFO) (STB_LOCAL, ELFW(ST_TYPE) (sym->info));
+}
+
+static void print_load_map(struct obj_file *f)
+{
+	struct obj_symbol *sym;
+	struct obj_symbol **all, **p;
+	struct obj_section *sec;
+	int load_map_cmp(const void *a, const void *b) {
+		struct obj_symbol **as = (struct obj_symbol **) a;
+		struct obj_symbol **bs = (struct obj_symbol **) b;
+		unsigned long aa = obj_symbol_final_value(f, *as);
+		unsigned long ba = obj_symbol_final_value(f, *bs);
+		 return aa < ba ? -1 : aa > ba ? 1 : 0;
+	}
+	int i, nsyms, *loaded;
+
+	/* Report on the section layout.  */
+
+	lprintf("Sections:       Size      %-*s  Align",
+		(int) (2 * sizeof(void *)), "Address");
+
+	for (sec = f->load_order; sec; sec = sec->load_next) {
+		int a;
+		unsigned long tmp;
+
+		for (a = -1, tmp = sec->header.sh_addralign; tmp; ++a)
+			tmp >>= 1;
+		if (a == -1)
+			a = 0;
+
+		lprintf("%-16s%08lx  %0*lx  2**%d",
+			sec->name,
+			(long)sec->header.sh_size,
+			(int) (2 * sizeof(void *)),
+			(long)sec->header.sh_addr,
+			a);
+	}
+
+	/* Quick reference which section indicies are loaded.  */
+
+	loaded = alloca(sizeof(int) * (i = f->header.e_shnum));
+	while (--i >= 0)
+		loaded[i] = (f->sections[i]->header.sh_flags & SHF_ALLOC) != 0;
+
+	/* Collect the symbols we'll be listing.  */
+
+	for (nsyms = i = 0; i < HASH_BUCKETS; ++i)
+		for (sym = f->symtab[i]; sym; sym = sym->next)
+			if (sym->secidx <= SHN_HIRESERVE
+			    && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx]))
+				++nsyms;
+
+	all = alloca(nsyms * sizeof(struct obj_symbol *));
+
+	for (i = 0, p = all; i < HASH_BUCKETS; ++i)
+		for (sym = f->symtab[i]; sym; sym = sym->next)
+			if (sym->secidx <= SHN_HIRESERVE
+			    && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx]))
+				*p++ = sym;
+
+	/* Sort them by final value.  */
+	qsort(all, nsyms, sizeof(struct obj_file *), load_map_cmp);
+
+	/* And list them.  */
+	lprintf("\nSymbols:");
+	for (p = all; p < all + nsyms; ++p) {
+		char type = '?';
+		unsigned long value;
+
+		sym = *p;
+		if (sym->secidx == SHN_ABS) {
+			type = 'A';
+			value = sym->value;
+		} else if (sym->secidx == SHN_UNDEF) {
+			type = 'U';
+			value = 0;
+		} else {
+			struct obj_section *sec = f->sections[sym->secidx];
+
+			if (sec->header.sh_type == SHT_NOBITS)
+				type = 'B';
+			else if (sec->header.sh_flags & SHF_ALLOC) {
+				if (sec->header.sh_flags & SHF_EXECINSTR)
+					type = 'T';
+				else if (sec->header.sh_flags & SHF_WRITE)
+					type = 'D';
+				else
+					type = 'R';
+			}
+			value = sym->value + sec->header.sh_addr;
+		}
+
+		if (ELFW(ST_BIND) (sym->info) == STB_LOCAL)
+			type = tolower(type);
+
+		lprintf("%0*lx %c %s", (int) (2 * sizeof(void *)), value,
+			type, sym->name);
+	}
+}
+
+/************************************************************************/
+/* begin compat */
+
+static char * get_modinfo_value(struct obj_file *f, const char *key)
+{
+	struct obj_section *sec;
+	char *p, *v, *n, *ep;
+	size_t klen = strlen(key);
+
+	sec = obj_find_section(f, ".modinfo");
+	if (sec == NULL)
+		return NULL;
+
+	p = sec->contents;
+	ep = p + sec->header.sh_size;
+	while (p < ep) {
+		v = strchr(p, '=');
+		n = strchr(p, '\0');
+		if (v) {
+			if (v - p == klen && strncmp(p, key, klen) == 0)
+				return v + 1;
+		} else {
+			if (n - p == klen && strcmp(p, key) == 0)
+				return n;
+		}
+		p = n + 1;
+	}
+
+	return NULL;
+}
+
+static int create_this_module(struct obj_file *f, const char *m_name)
+{
+	struct obj_section *sec;
+
+	sec = obj_create_alloced_section_first(f, ".this", tgt_sizeof_long,
+					       sizeof(struct module));
+	memset(sec->contents, 0, sizeof(struct module));
+
+	obj_add_symbol(f, "__this_module", -1, ELFW(ST_INFO) (STB_LOCAL, STT_OBJECT),
+		       sec->idx, 0, sizeof(struct module));
+
+	obj_string_patch(f, sec->idx, offsetof(struct module, name), m_name);
+
+	return 1;
+}
+
+#ifdef COMPAT_2_0
+static int old_create_mod_use_count(struct obj_file *f)
+{
+	struct obj_section *sec;
+	struct obj_symbol  *got;
+
+	sec = obj_create_alloced_section_first(f, ".moduse",
+					       sizeof(long), sizeof(long));
+
+	obj_add_symbol(f, "mod_use_count_",
+		       -1, ELFW(ST_INFO)(STB_LOCAL, STT_OBJECT),
+		       sec->idx, 0, sizeof(long));
+
+	/*
+	 * patb: if there is a _GLOBAL_OFFSET_TABLE_,
+	 * add .got section for PIC type modules;
+	 * we have to do this here, because obj_* calls are not made until
+	 * after obj_check_undefined
+	 * is there a better place for this exception?
+	 */
+	got = obj_find_symbol(f, "_GLOBAL_OFFSET_TABLE_");
+	if (got)
+{
+		sec = obj_create_alloced_section(f, ".got",
+						 sizeof(long), sizeof(long));
+		got->secidx = sec->idx; /* mark the symbol as defined */
+	}
+	return 1;
+}
+#endif
+
+/* add an entry to the __ksymtab section, creating it if necessary */
+static void add_ksymtab(struct obj_file *f, struct obj_symbol *sym)
+{
+	struct obj_section *sec;
+	ElfW(Addr) ofs;
+
+	/* ensure __ksymtab is allocated, EXPORT_NOSYMBOLS creates a non-alloc section.
+	 * If __ksymtab is defined but not marked alloc, x out the first character
+	 * (no obj_delete routine) and create a new __ksymtab with the correct
+	 * characteristics.
+	 */
+	sec = obj_find_section(f, "__ksymtab");
+	if (sec && !(sec->header.sh_flags & SHF_ALLOC)) {
+		*((char *)(sec->name)) = 'x';	/* override const */
+		sec = NULL;
+	}
+	if (!sec)
+		sec = obj_create_alloced_section(f, "__ksymtab", tgt_sizeof_void_p, 0);
+	if (!sec)
+		return;
+	sec->header.sh_flags |= SHF_ALLOC;
+
+	ofs = sec->header.sh_size;
+	obj_symbol_patch(f, sec->idx, ofs, sym);
+	obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p, sym->name);
+	obj_extend_section(sec, 2 * tgt_sizeof_char_p);
+}
+
+static int create_module_ksymtab(struct obj_file *f)
+{
+	struct obj_section *sec;
+	int i;
+
+	/* We must always add the module references.  */
+
+	if (n_ext_modules_used) {
+		struct module_ref *dep;
+		struct obj_symbol *tm;
+
+		sec = obj_create_alloced_section(f, ".kmodtab", tgt_sizeof_void_p,
+					   (sizeof(struct module_ref)
+					    * n_ext_modules_used));
+		if (!sec)
+			return 0;
+
+		tm = obj_find_symbol(f, "__this_module");
+		dep = (struct module_ref *) sec->contents;
+		for (i = 0; i < n_module_stat; ++i)
+			if (module_stat[i].status /* used */) {
+				dep->dep = module_stat[i].addr;
+				obj_symbol_patch(f, sec->idx, (char *) &dep->ref - sec->contents, tm);
+				dep->next_ref = 0;
+				++dep;
+			}
+	}
+	if (flag_export && !obj_find_section(f, "__ksymtab")) {
+		int *loaded;
+
+		/* We don't want to export symbols residing in sections that
+		   aren't loaded.  There are a number of these created so that
+		   we make sure certain module options don't appear twice.  */
+
+		loaded = alloca(sizeof(int) * (i = f->header.e_shnum));
+		while (--i >= 0)
+			loaded[i] = (f->sections[i]->header.sh_flags & SHF_ALLOC) != 0;
+
+		for (i = 0; i < HASH_BUCKETS; ++i) {
+			struct obj_symbol *sym;
+			for (sym = f->symtab[i]; sym; sym = sym->next) {
+				if (ELFW(ST_BIND) (sym->info) != STB_LOCAL
+				    && sym->secidx <= SHN_HIRESERVE
+				    && (sym->secidx >= SHN_LORESERVE
+					|| loaded[sym->secidx])) {
+					add_ksymtab(f, sym);
+				}
+			}
+		}
+	}
+	return 1;
+}
+
+/* Get the module's kernel version in the canonical integer form.  */
+static int get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
+{
+	int a, b, c;
+	char *p, *q;
+
+	if ((p = get_modinfo_value(f, "kernel_version")) == NULL) {
+		struct obj_symbol *sym;
+
+		m_has_modinfo = 0;
+		if ((sym = obj_find_symbol(f, "kernel_version")) == NULL)
+			sym = obj_find_symbol(f, "__module_kernel_version");
+		if (sym == NULL)
+			return -1;
+		p = f->sections[sym->secidx]->contents + sym->value;
+	} else
+		m_has_modinfo = 1;
+
+	strncpy(str, p, STRVERSIONLEN);
+
+	a = strtoul(p, &p, 10);
+	if (*p != '.')
+		return -1;
+	b = strtoul(p + 1, &p, 10);
+	if (*p != '.')
+		return -1;
+	c = strtoul(p + 1, &q, 10);
+	if (p + 1 == q)
+		return -1;
+
+	return a << 16 | b << 8 | c;
+}
+
+/* Return the kernel symbol checksum version, or zero if not used. */
+static int is_kernel_checksummed(void)
+{
+	struct module_symbol *s;
+	size_t i;
+
+	/*
+	 * Using_Versions might not be the first symbol,
+	 * but it should be in there.
+	 */
+	for (i = 0, s = ksyms; i < nksyms; ++i, ++s)
+		if (strcmp((char *) s->name, "Using_Versions") == 0)
+			return s->value;
+
+	return 0;
+}
+
+static int is_module_checksummed(struct obj_file *f)
+{
+	if (m_has_modinfo) {
+		const char *p = get_modinfo_value(f, "using_checksums");
+		if (p)
+			return atoi(p);
+		else
+			return 0;
+	} else
+		return obj_find_symbol(f, "Using_Versions") != NULL;
+}
+
+/* add module source, timestamp, kernel version and a symbol for the
+ * start of some sections.  this info is used by ksymoops to do better
+ * debugging.
+ */
+static void add_ksymoops_symbols(struct obj_file *f, const char *filename,
+				 const char *m_name)
+{
+	struct obj_section *sec;
+	struct obj_symbol *sym;
+	char *name, *absolute_filename;
+	char str[STRVERSIONLEN], real[PATH_MAX];
+	int i, l, lm_name, lfilename, use_ksymtab, version;
+	struct stat statbuf;
+
+	static const char *section_names[] = {
+		".text",
+		".rodata",
+		".data",
+		".bss"
+	};
+
+	if (realpath(filename, real)) {
+		absolute_filename = xstrdup(real);
+	}
+	else {
+		int save_errno = errno;
+		error("cannot get realpath for %s", filename);
+		errno = save_errno;
+		absolute_filename = xstrdup(filename);
+	}
+
+	lm_name = strlen(m_name);
+	lfilename = strlen(absolute_filename);
+
+	/* add to ksymtab if it already exists or there is no ksymtab and other symbols
+	 * are not to be exported.  otherwise leave ksymtab alone for now, the
+	 * "export all symbols" compatibility code will export these symbols later.
+	 */
+
+	use_ksymtab =  obj_find_section(f, "__ksymtab") || !flag_export;
+
+	if ((sec = obj_find_section(f, ".this"))) {
+		/* tag the module header with the object name, last modified
+		 * timestamp and module version.  worst case for module version
+		 * is 0xffffff, decimal 16777215.  putting all three fields in
+		 * one symbol is less readable but saves kernel space.
+		 */
+		l = sizeof(symprefix)+			/* "__insmod_" */
+		    lm_name+				/* module name */
+		    2+					/* "_O" */
+		    lfilename+				/* object filename */
+		    2+					/* "_M" */
+		    2*sizeof(statbuf.st_mtime)+		/* mtime in hex */
+		    2+					/* "_V" */
+		    8+					/* version in dec */
+		    1;					/* nul */
+		name = xmalloc(l);
+		if (stat(absolute_filename, &statbuf) != 0)
+			statbuf.st_mtime = 0;
+		version = get_module_version(f, str);	/* -1 if not found */
+		snprintf(name, l, "%s%s_O%s_M%0*lX_V%d",
+			 symprefix, m_name, absolute_filename,
+			 2*sizeof(statbuf.st_mtime), statbuf.st_mtime,
+			 version);
+		sym = obj_add_symbol(f, name, -1,
+				     ELFW(ST_INFO) (STB_GLOBAL, STT_NOTYPE),
+				     sec->idx, sec->header.sh_addr, 0);
+		if (use_ksymtab)
+			add_ksymtab(f, sym);
+	}
+	free(absolute_filename);
+
+	/* record where the persistent data is going, same address as previous symbol */
+
+	if (f->persist) {
+		l = sizeof(symprefix)+		/* "__insmod_" */
+			lm_name+		/* module name */
+			2+			/* "_P" */
+			strlen(f->persist)+	/* data store */
+			1;			/* nul */
+		name = xmalloc(l);
+		snprintf(name, l, "%s%s_P%s",
+			 symprefix, m_name, f->persist);
+		sym = obj_add_symbol(f, name, -1, ELFW(ST_INFO) (STB_GLOBAL, STT_NOTYPE),
+				     sec->idx, sec->header.sh_addr, 0);
+		if (use_ksymtab)
+			add_ksymtab(f, sym);
+	}
+
+	/* tag the desired sections if size is non-zero */
+
+	for (i = 0; i < sizeof(section_names)/sizeof(section_names[0]); ++i) {
+		if ((sec = obj_find_section(f, section_names[i])) &&
+		    sec->header.sh_size) {
+			l = sizeof(symprefix)+		/* "__insmod_" */
+				lm_name+		/* module name */
+				2+			/* "_S" */
+				strlen(sec->name)+	/* section name */
+				2+			/* "_L" */
+				8+			/* length in dec */
+				1;			/* nul */
+			name = xmalloc(l);
+			snprintf(name, l, "%s%s_S%s_L%ld",
+				 symprefix, m_name, sec->name,
+				 (long)sec->header.sh_size);
+			sym = obj_add_symbol(f, name, -1, ELFW(ST_INFO) (STB_GLOBAL, STT_NOTYPE),
+					     sec->idx, sec->header.sh_addr, 0);
+			if (use_ksymtab)
+				add_ksymtab(f, sym);
+		}
+	}
+}
+
+static int process_module_arguments(struct obj_file *f, int argc, char **argv, int required)
+{
+	for (; argc > 0; ++argv, --argc) {
+		struct obj_symbol *sym;
+		int c;
+		int min, max;
+		int n;
+		char *contents;
+		char *input;
+		char *fmt;
+		char *key;
+		char *loc;
+
+		if ((input = strchr(*argv, '=')) == NULL)
+			continue;
+
+		n = input - *argv;
+		input += 1; /* skip '=' */
+
+		key = alloca(n + 6);
+
+		if (m_has_modinfo) {
+			memcpy(key, "parm_", 5);
+			memcpy(key + 5, *argv, n);
+			key[n + 5] = '\0';
+			if ((fmt = get_modinfo_value(f, key)) == NULL) {
+				if (required) {
+					error("invalid parameter %s", key);
+					return 0;
+				}
+				else {
+					if (flag_verbose)
+						lprintf("ignoring %s", *argv);
+					continue;	/* silently ignore optional parameters */
+				}
+			}
+			key += 5;
+
+			if (isdigit(*fmt)) {
+				min = strtoul(fmt, &fmt, 10);
+				if (*fmt == '-')
+					max = strtoul(fmt + 1, &fmt, 10);
+				else
+					max = min;
+			} else
+				min = max = 1;
+		} else { /* not m_has_modinfo */
+			memcpy(key, *argv, n);
+			key[n] = '\0';
+
+			if (isdigit(*input))
+				fmt = "i";
+			else
+				fmt = "s";
+			min = max = 0;
+		}
+
+		sym = obj_find_symbol(f, key);
+
+		/*
+		 * Also check that the parameter was not
+		 * resolved from the kernel.
+		 */
+		if (sym == NULL || sym->secidx > SHN_HIRESERVE) {
+			error("symbol for parameter %s not found", key);
+			return 0;
+		}
+
+		contents = f->sections[sym->secidx]->contents;
+		loc = contents + sym->value;
+		n = 1;
+
+		while (*input) {
+			char *str;
+
+			switch (*fmt) {
+			case 's':
+			case 'c':
+				/*
+				 * Do C quoting if we begin with a ",
+				 * else slurp the lot.
+				 */
+				if (*input == '"') {
+					char *r;
+
+					str = alloca(strlen(input));
+					for (r = str, input++; *input != '"'; ++input, ++r) {
+						if (*input == '\0') {
+							error("improperly terminated string argument for %s", key);
+							return 0;
+						}
+						/* else */
+						if (*input != '\\') {
+							*r = *input;
+							continue;
+						}
+						/* else  handle \ */
+						switch (*++input) {
+						case 'a': *r = '\a'; break;
+						case 'b': *r = '\b'; break;
+						case 'e': *r = '\033'; break;
+						case 'f': *r = '\f'; break;
+						case 'n': *r = '\n'; break;
+						case 'r': *r = '\r'; break;
+						case 't': *r = '\t'; break;
+
+						case '0':
+						case '1':
+						case '2':
+						case '3':
+						case '4':
+						case '5':
+						case '6':
+						case '7':
+							c = *input - '0';
+							if ('0' <= input[1] && input[1] <= '7') {
+								c = (c * 8) + *++input - '0';
+								if ('0' <= input[1] && input[1] <= '7')
+									c = (c * 8) + *++input - '0';
+							}
+							*r = c;
+							break;
+
+						default: *r = *input; break;
+						}
+					}
+					*r = '\0';
+					++input;
+				} else {
+					/*
+					 * The string is not quoted.
+					 * We will break it using the comma
+					 * (like for ints).
+					 * If the user wants to include commas
+					 * in a string, he just has to quote it
+					 */
+					char *r;
+
+					/* Search the next comma */
+					if ((r = strchr(input, ',')) != NULL) {
+						/*
+						 * Found a comma
+						 * Recopy the current field
+						 */
+						str = alloca(r - input + 1);
+						memcpy(str, input, r - input);
+						str[r - input] = '\0';
+						/* Keep next fields */
+						input = r;
+					} else {
+						/* last string */
+						str = input;
+						input = "";
+					}
+				}
+
+				if (*fmt == 's') {
+					/* Normal string */
+					obj_string_patch(f, sym->secidx, loc - contents, str);
+					loc += tgt_sizeof_char_p;
+				} else {
+					/* Array of chars (in fact, matrix !) */
+					long charssize;	/* size of each member */
+
+					/* Get the size of each member */
+					/* Probably we should do that outside the loop ? */
+					if (!isdigit(*(fmt + 1))) {
+						error("parameter type 'c' for %s must be followed by"
+						" the maximum size", key);
+						return 0;
+					}
+					charssize = strtoul(fmt + 1, (char **) NULL, 10);
+
+					/* Check length */
+					if (strlen(str) >= charssize-1) {
+						error("string too long for %s (max %ld)",
+						      key, charssize - 1);
+						return 0;
+					}
+					/* Copy to location */
+					strcpy((char *) loc, str);	/* safe, see check above */
+					loc += charssize;
+				}
+				/*
+				 * End of 's' and 'c'
+				 */
+				break;
+
+			case 'b':
+				*loc++ = strtoul(input, &input, 0);
+				break;
+
+			case 'h':
+				*(short *) loc = strtoul(input, &input, 0);
+				loc += tgt_sizeof_short;
+				break;
+
+			case 'i':
+				*(int *) loc = strtoul(input, &input, 0);
+				loc += tgt_sizeof_int;
+				break;
+
+			case 'l':
+				*(long *) loc = strtoul(input, &input, 0);
+				loc += tgt_sizeof_long;
+				break;
+
+			default:
+				error("unknown parameter type '%c' for %s",
+				      *fmt, key);
+				return 0;
+			}
+			/*
+			 * end of switch (*fmt)
+			 */
+
+			while (*input && isspace(*input))
+				++input;
+			if (*input == '\0')
+				break; /* while (*input) */
+			/* else */
+
+			if (*input == ',') {
+				if (max && (++n > max)) {
+					error("too many values for %s (max %d)", key, max);
+					return 0;
+				}
+				++input;
+				/* continue with while (*input) */
+			} else {
+				error("invalid argument syntax for %s: '%c'",
+				      key, *input);
+				return 0;
+			}
+		} /* end of while (*input) */
+
+		if (min && (n < min)) {
+			error("too few values for %s (min %d)", key, min);
+			return 0;
+		}
+	} /* end of for (;argc > 0;) */
+
+	return 1;
+}
+
+
+/* Add a kallsyms section if the kernel supports all symbols. */
+static int add_kallsyms(struct obj_file *f,
+			struct obj_section **module_kallsyms, int force_kallsyms)
+{
+	struct module_symbol *s;
+	struct obj_file *f_kallsyms;
+	struct obj_section *sec_kallsyms;
+	size_t i;
+	int l;
+	const char *p, *pt_R;
+	unsigned long start = 0, stop = 0;
+
+	for (i = 0, s = ksyms; i < nksyms; ++i, ++s) {
+		p = (char *)s->name;
+		pt_R = strstr(p, "_R");
+		if (pt_R)
+			l = pt_R - p;
+		else
+			l = strlen(p);
+		if (strncmp(p, "__start_" KALLSYMS_SEC_NAME, l) == 0)
+			start = s->value;
+		else if (strncmp(p, "__stop_" KALLSYMS_SEC_NAME, l) == 0)
+			stop = s->value;
+	}
+
+	if (start >= stop && !force_kallsyms)
+		return(0);
+
+	/* The kernel contains all symbols, do the same for this module. */
+
+	/* Add an empty kallsyms section to the module if necessary */
+	for (i = 0; i < f->header.e_shnum; ++i) {
+		if (strcmp(f->sections[i]->name, KALLSYMS_SEC_NAME) == 0) {
+			*module_kallsyms = f->sections[i];
+			break;
+		}
+	    }
+	if (!*module_kallsyms)
+		*module_kallsyms = obj_create_alloced_section(f, KALLSYMS_SEC_NAME, 0, 0);
+
+	/* Size and populate kallsyms */
+	if (obj_kallsyms(f, &f_kallsyms))
+		return(1);
+	sec_kallsyms = f_kallsyms->sections[KALLSYMS_IDX];
+	(*module_kallsyms)->header.sh_addralign = sec_kallsyms->header.sh_addralign;
+	(*module_kallsyms)->header.sh_size = sec_kallsyms->header.sh_size;
+	free((*module_kallsyms)->contents);
+	(*module_kallsyms)->contents = sec_kallsyms->contents;
+	sec_kallsyms->contents = NULL;
+	obj_free(f_kallsyms);
+
+	return 0;
+}
+
+
+/* Add an arch data section if the arch wants it. */
+static int add_archdata(struct obj_file *f,
+			struct obj_section **sec)
+{
+	size_t i;
+
+	*sec = NULL;
+	/* Add an empty archdata section to the module if necessary */
+	for (i = 0; i < f->header.e_shnum; ++i) {
+		if (strcmp(f->sections[i]->name, ARCHDATA_SEC_NAME) == 0) {
+			*sec = f->sections[i];
+			break;
+		}
+	    }
+	if (!*sec)
+		*sec = obj_create_alloced_section(f, ARCHDATA_SEC_NAME, 16, 0);
+
+	/* Size and populate archdata */
+	if (arch_archdata(f, *sec))
+		return(1);
+	return 0;
+}
+
+
+static int init_module(const char *m_name, struct obj_file *f,
+		       unsigned long m_size, const char *blob_name,
+		       unsigned int noload, unsigned int flag_load_map)
+{
+	struct module *module;
+	struct obj_section *sec;
+	void *image;
+	int ret = 0;
+	tgt_long m_addr;
+
+	sec = obj_find_section(f, ".this");
+	module = (struct module *) sec->contents;
+	m_addr = sec->header.sh_addr;
+
+	module->size_of_struct = sizeof(*module);
+	module->size = m_size;
+	module->flags = flag_autoclean ? NEW_MOD_AUTOCLEAN : 0;
+
+	sec = obj_find_section(f, "__ksymtab");
+	if (sec && sec->header.sh_size) {
+		module->syms = sec->header.sh_addr;
+		module->nsyms = sec->header.sh_size / (2 * tgt_sizeof_char_p);
+	}
+	if (n_ext_modules_used) {
+		sec = obj_find_section(f, ".kmodtab");
+		module->deps = sec->header.sh_addr;
+		module->ndeps = n_ext_modules_used;
+	}
+	module->init = obj_symbol_final_value(f, obj_find_symbol(f, "init_module"));
+	module->cleanup = obj_symbol_final_value(f,
+		obj_find_symbol(f, "cleanup_module"));
+
+	sec = obj_find_section(f, "__ex_table");
+	if (sec) {
+		module->ex_table_start = sec->header.sh_addr;
+		module->ex_table_end = sec->header.sh_addr + sec->header.sh_size;
+	}
+	sec = obj_find_section(f, ".text.init");
+	if (sec) {
+		module->runsize = sec->header.sh_addr - m_addr;
+	}
+	sec = obj_find_section(f, ".data.init");
+	if (sec) {
+		if (!module->runsize ||
+		    module->runsize > sec->header.sh_addr - m_addr)
+			module->runsize = sec->header.sh_addr - m_addr;
+	}
+	sec = obj_find_section(f, ARCHDATA_SEC_NAME);
+	if (sec && sec->header.sh_size) {
+		module->archdata_start = sec->header.sh_addr;
+		module->archdata_end = module->archdata_start + sec->header.sh_size;
+	}
+	sec = obj_find_section(f, KALLSYMS_SEC_NAME);
+	if (sec && sec->header.sh_size) {
+		module->kallsyms_start = sec->header.sh_addr;
+		module->kallsyms_end = module->kallsyms_start + sec->header.sh_size;
+	}
+	if (!arch_init_module(f, module))
+		return 0;
+
+	/*
+	 * Whew!  All of the initialization is complete.
+	 * Collect the final module image and give it to the kernel.
+	 */
+	image = xmalloc(m_size);
+	obj_create_image(f, image);
+
+	if (flag_load_map)
+		print_load_map(f);
+
+	if (blob_name) {
+		int fd, l;
+		fd = open(blob_name, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
+		if (fd < 0) {
+			error("open %s failed %m", blob_name);
+			ret = -1;
+		}
+		else {
+			if ((l = write(fd, image, m_size)) != m_size) {
+				error("write %s failed %m", blob_name);
+				ret = -1;
+			}
+			close(fd);
+		}
+	}
+
+	if (ret == 0 && !noload) {
+		fflush(stdout);		/* Flush any debugging output */
+		ret = sys_init_module(m_name, (struct module *) image);
+		if (ret) {
+			error("init_module: %m");
+			lprintf("Hint: insmod errors can be caused by incorrect module parameters, "
+				"including invalid IO or IRQ parameters");
+		}
+	}
+
+	free(image);
+
+	return ret == 0;
+}
+
+#ifdef COMPAT_2_0
+static int old_init_module(const char *m_name, struct obj_file *f,
+			   unsigned long m_size)
+{
+	char *image;
+	struct old_mod_routines routines;
+	struct old_symbol_table *symtab;
+	int ret;
+	int nsyms = 0, strsize = 0, total;
+
+	/* Create the symbol table */
+	/* Size things first... */
+	if (flag_export) {
+		int i;
+		for (i = 0; i < HASH_BUCKETS; ++i) {
+			struct obj_symbol *sym;
+
+			for (sym = f->symtab[i]; sym; sym = sym->next)
+				if (ELFW(ST_BIND) (sym->info) != STB_LOCAL &&
+				    sym->secidx <= SHN_HIRESERVE) {
+					sym->ksymidx = nsyms++;
+					strsize += strlen(sym->name) + 1;
+				}
+		}
+	}
+	total = (sizeof(struct old_symbol_table) +
+		 nsyms * sizeof(struct old_module_symbol) +
+		 n_ext_modules_used * sizeof(struct old_module_ref) +
+		 strsize);
+	symtab = xmalloc(total);
+	symtab->size = total;
+	symtab->n_symbols = nsyms;
+	symtab->n_refs = n_ext_modules_used;
+
+	if (flag_export && nsyms) {
+		struct old_module_symbol *ksym;
+		char *str;
+		int i;
+
+		ksym = symtab->symbol;
+		str = ((char *) ksym +
+		       nsyms * sizeof(struct old_module_symbol) +
+		       n_ext_modules_used * sizeof(struct old_module_ref));
+
+		for (i = 0; i < HASH_BUCKETS; ++i) {
+			struct obj_symbol *sym;
+			for (sym = f->symtab[i]; sym; sym = sym->next)
+				if (sym->ksymidx >= 0) {
+					ksym->addr = obj_symbol_final_value(f, sym);
+					ksym->name = (unsigned long) str - (unsigned long) symtab;
+
+					str = stpcpy(str, sym->name) + 1;
+					ksym++;
+				}
+		}
+	}
+
+	if (n_ext_modules_used) {
+		struct old_module_ref *ref;
+		int i;
+
+		ref = (struct old_module_ref *)
+		    ((char *) symtab->symbol + nsyms * sizeof(struct old_module_symbol));
+
+		for (i = 0; i < n_module_stat; ++i) {
+			if (module_stat[i].status /* used */) {
+				ref++->module = module_stat[i].modstruct;
+			}
+		}
+	}
+
+	/* Fill in routines.  */
+
+	routines.init = obj_symbol_final_value(f, obj_find_symbol(f, "init_module"));
+	routines.cleanup = obj_symbol_final_value(f,
+		obj_find_symbol(f, "cleanup_module"));
+
+	/*
+	 * Whew!  All of the initialization is complete.
+	 * Collect the final module image and give it to the kernel.
+	 */
+	image = xmalloc(m_size);
+	obj_create_image(f, image);
+
+	/*
+	 * image holds the complete relocated module,
+	 * accounting correctly for mod_use_count.
+	 * However the old module kernel support assume that it
+	 * is receiving something which does not contain mod_use_count.
+	 */
+	ret = old_sys_init_module(m_name, image + sizeof(long),
+				  (m_size - sizeof(long)) |
+				  (flag_autoclean ? OLD_MOD_AUTOCLEAN : 0),
+				  &routines,
+				  symtab);
+	if (ret)
+		error("init_module: %m");
+
+	free(image);
+	free(symtab);
+
+	return ret == 0;
+}
+#endif
+/* end compat */
+/************************************************************************/
+
+/* Check that a module parameter has a reasonable definition */
+static int check_module_parameter(struct obj_file *f, char *key, char *value, int *persist_flag)
+{
+	struct obj_symbol *sym;
+	int min, max;
+	char *p = value;
+
+	sym = obj_find_symbol(f, key);
+	if (sym == NULL) {
+		/* FIXME: For 2.2 kernel compatibility, only issue warnings for
+		 *        most error conditions.  Make these all errors in 2.5.
+		 */
+		lprintf("Warning: %s symbol for parameter %s not found", error_file, key);
+		return(1);
+	}
+
+	if (isdigit(*p)) {
+		min = strtoul(p, &p, 10);
+		if (*p == '-')
+			max = strtoul(p + 1, &p, 10);
+		else
+			max = min;
+	} else
+		min = max = 1;
+
+	if (max < min) {
+		lprintf("Warning: %s parameter %s has max < min!", error_file, key);
+		return(1);
+	}
+
+	switch (*p) {
+	case 'c':
+		if (!isdigit(p[1])) {
+			lprintf("%s parameter %s has no size after 'c'!", error_file, key);
+			return(1);
+		}
+		while (isdigit(p[1]))
+			++p;	/* swallow c array size */
+		break;
+	case 'b':	/* drop through */
+	case 'h':	/* drop through */
+	case 'i':	/* drop through */
+	case 'l':	/* drop through */
+	case 's':
+		break;
+	case '\0':
+		lprintf("%s parameter %s has no format character!", error_file, key);
+		return(1);
+	default:
+		lprintf("%s parameter %s has unknown format character '%c'", error_file, key, *p);
+		return(1);
+	}
+	switch (*++p) {
+	case 'p':
+		if (*(p-1) == 's') {
+			error("parameter %s is invalid persistent string", key);
+			return(1);
+		}
+		*persist_flag = 1;
+		break;
+	case '\0':
+		break;
+	default:
+		lprintf("%s parameter %s has unknown format modifier '%c'", error_file, key, *p);
+		return(1);
+	}
+	return(0);
+}
+
+/* Check that all module parameters have reasonable definitions */
+static void check_module_parameters(struct obj_file *f, int *persist_flag)
+{
+	struct obj_section *sec;
+	char *ptr, *value, *n, *endptr;
+	int namelen, err = 0;
+
+	sec = obj_find_section(f, ".modinfo");
+	if (sec == NULL) {
+		/* module does not support typed parameters */
+		return;
+	}
+
+	ptr = sec->contents;
+	endptr = ptr + sec->header.sh_size;
+	while (ptr < endptr && !err) {
+		value = strchr(ptr, '=');
+		n = strchr(ptr, '\0');
+		if (value) {
+			namelen = value - ptr;
+			if (namelen >= 5 && strncmp(ptr, "parm_", 5) == 0
+			    && !(namelen > 10 && strncmp(ptr, "parm_desc_", 10) == 0)) {
+				char *pname = xmalloc(namelen + 1);
+				strncpy(pname, ptr + 5, namelen - 5);
+				pname[namelen - 5] = '\0';
+				err = check_module_parameter(f, pname, value+1, persist_flag);
+				free(pname);
+			}
+		} else {
+			if (n - ptr >= 5 && strncmp(ptr, "parm_", 5) == 0) {
+				error("parameter %s found with no value", ptr);
+				err = 1;
+			}
+		}
+		ptr = n + 1;
+	}
+
+	if (err)
+		*persist_flag = 0;
+	return;
+}
+
+
+/* For common 3264 code, only compile the usage message once, in the 64 bit version */
+#if defined(COMMON_3264) && defined(ONLY_32)
+extern void insmod_usage(void);		/* Use the copy in the 64 bit version */
+#else	/* Common 64 bit version or any non common code - compile usage routine */
+void insmod_usage(void)
+{
+	fputs("Usage:\n"
+	      "insmod [-fhkLmnpqrsSvVxXyY] [-e persist_name] [-o module_name] [-O blob_name] [-P prefix] module [ symbol=value ... ]\n"
+	      "\n"
+	      "  module                Name of a loadable kernel module ('.o' can be omitted)\n"
+	      "  -f, --force           Force loading under wrong kernel version\n"
+	      "  -h, --help            Print this message\n"
+	      "  -k, --autoclean       Make module autoclean-able\n"
+	      "  -L, --lock            Prevent simultaneous loads of the same module\n"
+	      "  -m, --map             Generate load map (so crashes can be traced)\n"
+	      "  -n, --noload          Don't load, just show\n"
+	      "  -p, --probe           Probe mode; check if the module matches the kernel\n"
+	      "  -q, --quiet           Don't print unresolved symbols\n"
+	      "  -r, --root            Allow root to load modules not owned by root\n"
+	      "  -s, --syslog          Report errors via syslog\n"
+	      "  -S, --kallsyms        Force kallsyms on module\n"
+	      "  -v, --verbose         Verbose output\n"
+	      "  -V, --version         Show version\n"
+	      "  -x, --noexport        Do not export externs\n"
+	      "  -X, --export          Do export externs (default)\n"
+	      "  -y, --noksymoops      Do not add ksymoops symbols\n"
+	      "  -Y, --ksymoops        Do add ksymoops symbols (default)\n"
+	      "  -e persist_name\n"
+	      "      --persist=persist_name Filename to hold any persistent data from the module\n"
+	      "  -o NAME, --name=NAME  Set internal module name to NAME\n"
+	      "  -O NAME, --blob=NAME  Save the object as a binary blob in NAME\n"
+	      "  -P PREFIX\n"
+	      "      --prefix=PREFIX   Prefix for kernel or module symbols\n"
+	      ,stderr);
+	exit(1);
+}
+#endif	/* defined(COMMON_3264) && defined(ONLY_32) */
+
+#if defined(COMMON_3264) && defined(ONLY_32)
+#define INSMOD_MAIN insmod_main_32	/* 32 bit version */
+#elif defined(COMMON_3264) && defined(ONLY_64)
+#define INSMOD_MAIN insmod_main_64	/* 64 bit version */
+#else
+#define INSMOD_MAIN insmod_main		/* Not common code */
+#endif
+
+int INSMOD_MAIN(int argc, char **argv)
+{
+	int k_version;
+	int k_crcs;
+	char k_strversion[STRVERSIONLEN];
+	struct option long_opts[] = {
+		{"force", 0, 0, 'f'},
+		{"help", 0, 0, 'h'},
+		{"autoclean", 0, 0, 'k'},
+		{"lock", 0, 0, 'L'},
+		{"map", 0, 0, 'm'},
+		{"noload", 0, 0, 'n'},
+		{"probe", 0, 0, 'p'},
+		{"poll", 0, 0, 'p'},	/* poll is deprecated, remove in 2.5 */
+		{"quiet", 0, 0, 'q'},
+		{"root", 0, 0, 'r'},
+		{"syslog", 0, 0, 's'},
+		{"kallsyms", 0, 0, 'S'},
+		{"verbose", 0, 0, 'v'},
+		{"version", 0, 0, 'V'},
+		{"noexport", 0, 0, 'x'},
+		{"export", 0, 0, 'X'},
+		{"noksymoops", 0, 0, 'y'},
+		{"ksymoops", 0, 0, 'Y'},
+
+		{"persist", 1, 0, 'e'},
+		{"name", 1, 0, 'o'},
+		{"blob", 1, 0, 'O'},
+		{"prefix", 1, 0, 'P'},
+		{0, 0, 0, 0}
+	};
+	char *m_name = NULL;
+	char *blob_name = NULL;		/* Save object as binary blob */
+	int m_version;
+	ElfW(Addr) m_addr;
+	unsigned long m_size;
+	int m_crcs;
+	char m_strversion[STRVERSIONLEN];
+	char *filename;
+	char *persist_name = NULL;	/* filename to hold any persistent data */
+	int fp;
+	struct obj_file *f;
+	struct obj_section *kallsyms = NULL, *archdata = NULL;
+	int o;
+	int noload = 0;
+	int dolock = 1; /*Note: was: 0; */
+	int quiet = 0;
+	int exit_status = 1;
+	int force_kallsyms = 0;
+	int persist_parms = 0;	/* does module have persistent parms? */
+	int i;
+
+	error_file = "insmod";
+
+	/* To handle repeated calls from combined modprobe */
+	errors = optind = 0;
+
+	/* Process the command line.  */
+	while ((o = getopt_long(argc, argv, "fhkLmnpqrsSvVxXyYe:o:O:P:R:",
+				&long_opts[0], NULL)) != EOF)
+		switch (o) {
+		case 'f':	/* force loading */
+			flag_force_load = 1;
+			break;
+		case 'h':       /* Print the usage message. */
+			insmod_usage();
+			break;
+		case 'k':	/* module loaded by kerneld, auto-cleanable */
+			flag_autoclean = 1;
+			break;
+		case 'L':	/* protect against recursion.  */
+			dolock = 1;
+			break;
+		case 'm':	/* generate load map */
+			flag_load_map = 1;
+			break;
+		case 'n':	/* don't load, just check */
+			noload = 1;
+			break;
+		case 'p':	/* silent probe mode */
+			flag_silent_probe = 1;
+			break;
+		case 'q':	/* Don't print unresolved symbols */
+			quiet = 1;
+			break;
+		case 'r':	/* allow root to load non-root modules */
+			root_check_off = !root_check_off;
+			break;
+		case 's':	/* start syslog */
+			setsyslog("insmod");
+			break;
+		case 'S':	/* Force kallsyms */
+			force_kallsyms = 1;
+			break;
+		case 'v':	/* verbose output */
+			flag_verbose = 1;
+			break;
+		case 'V':
+			fputs("insmod version " MODUTILS_VERSION "\n", stderr);
+			break;
+		case 'x':	/* do not export externs */
+			flag_export = 0;
+			break;
+		case 'X':	/* do export externs */
+			flag_export = 1;
+			break;
+		case 'y':	/* do not define ksymoops symbols */
+			flag_ksymoops = 0;
+			break;
+		case 'Y':	/* do define ksymoops symbols */
+			flag_ksymoops = 1;
+			break;
+
+		case 'e':	/* persistent data filename */
+			free(persist_name);
+			persist_name = xstrdup(optarg);
+			break;
+		case 'o':	/* name the output module */
+			m_name = optarg;
+			break;
+		case 'O':	/* save the output module object */
+			blob_name = optarg;
+			break;
+		case 'P':	/* use prefix on crc */
+			set_ncv_prefix(optarg);
+			break;
+
+		default:
+			insmod_usage();
+			break;
+		}
+
+	if (optind >= argc) {
+		insmod_usage();
+	}
+	filename = argv[optind++];
+
+	if (config_read(0, NULL, "", NULL) < 0) {
+		error("Failed handle configuration");
+	}
+
+	if (persist_name && !*persist_name &&
+	    (!persistdir || !*persistdir)) {
+		free(persist_name);
+		persist_name = NULL;
+		if (flag_verbose)
+			lprintf("insmod: -e \"\" ignored, no persistdir");
+	}
+
+	if (m_name == NULL) {
+		size_t len;
+		char *p;
+
+		if ((p = strrchr(filename, '/')) != NULL)
+			p++;
+		else
+			p = filename;
+		len = strlen(p);
+		if (len > 2 && p[len - 2] == '.' && p[len - 1] == 'o')
+			len -= 2;
+		else if (len > 4 && p[len - 4] == '.' && p[len - 3] == 'm'
+			 && p[len - 2] == 'o' && p[len - 1] == 'd')
+			len -= 4;
+#ifdef CONFIG_USE_ZLIB
+		else if (len > 5 && !strcmp(p + len - 5, ".o.gz"))
+			len -= 5;
+#endif
+
+		m_name = xmalloc(len + 1);
+		memcpy(m_name, p, len);
+		m_name[len] = '\0';
+	}
+
+	/* Locate the file to be loaded.  */
+	if (!strchr(filename, '/') && !strchr(filename, '.')) {
+		char *tmp = search_module_path(filename);
+		if (tmp == NULL) {
+			error("%s: no module by that name found", filename);
+			return 1;
+		}
+		filename = tmp;
+		lprintf("Using %s", filename);
+	} else if (flag_verbose)
+		lprintf("Using %s", filename);
+
+	/* And open it.  */
+	if ((fp = gzf_open(filename, O_RDONLY)) == -1) {
+		error("%s: %m", filename);
+		return 1;
+	}
+	/* Try to prevent multiple simultaneous loads.  */
+	if (dolock)
+		flock(fp, LOCK_EX);
+
+	if (!get_kernel_info(K_SYMBOLS))
+		goto out;
+
+	/*
+	 * Set the genksyms prefix if this is a versioned kernel
+	 * and it's not already set.
+	 */
+	set_ncv_prefix(NULL);
+
+	for (i = 0; i < n_module_stat; ++i) {
+		if (strcmp(module_stat[i].name, m_name) == 0) {
+			error("a module named %s already exists", m_name);
+			goto out;
+		}
+	}
+
+	error_file = filename;
+	if ((f = obj_load(fp, ET_REL, filename)) == NULL)
+		goto out;
+
+	/* Version correspondence?  */
+	k_version = get_kernel_version(k_strversion);
+	m_version = get_module_version(f, m_strversion);
+	if (m_version == -1) {
+		error("couldn't find the kernel version the module was compiled for");
+		goto out;
+	}
+
+	k_crcs = is_kernel_checksummed();
+	m_crcs = is_module_checksummed(f);
+	if ((m_crcs == 0 || k_crcs == 0) &&
+	    strncmp(k_strversion, m_strversion, STRVERSIONLEN) != 0) {
+		if (flag_force_load) {
+			lprintf("Warning: kernel-module version mismatch\n"
+			      "\t%s was compiled for kernel version %s\n"
+				"\twhile this kernel is version %s",
+				filename, m_strversion, k_strversion);
+		} else {
+			if (!quiet)
+				error("kernel-module version mismatch\n"
+				      "\t%s was compiled for kernel version %s\n"
+				      "\twhile this kernel is version %s.",
+				      filename, m_strversion, k_strversion);
+			goto out;
+		}
+	}
+	if (m_crcs != k_crcs)
+		obj_set_symbol_compare(f, ncv_strcmp, ncv_symbol_hash);
+
+	/* Let the module know about the kernel symbols.  */
+	add_kernel_symbols(f);
+
+	/* Allocate common symbols, symbol tables, and string tables.
+	 *
+	 * The calls marked DEPMOD indicate the bits of code that depmod
+	 * uses to do a pseudo relocation, ignoring undefined symbols.
+	 * Any changes made to the relocation sequence here should be
+	 * checked against depmod.
+	 */
+#ifdef COMPAT_2_0
+	if (k_new_syscalls
+	    ? !create_this_module(f, m_name)
+	    : !old_create_mod_use_count(f))
+		goto out;
+#else
+	if (!create_this_module(f, m_name))
+		goto out;
+#endif
+
+	if (!obj_check_undefineds(f, quiet))	/* DEPMOD, obj_clear_undefineds */
+		goto out;
+	obj_allocate_commons(f);	/* DEPMOD */
+
+	check_module_parameters(f, &persist_parms);
+
+	if (optind < argc) {
+		if (!process_module_arguments(f, argc - optind, argv + optind, 1))
+			goto out;
+	}
+	arch_create_got(f);	/* DEPMOD */
+	hide_special_symbols(f);
+
+	if (persist_parms && persist_name && *persist_name) {
+		f->persist = persist_name;
+		persist_name = NULL;
+	}
+
+	if (persist_parms &&
+	    persist_name && !*persist_name) {
+		/* -e "".  This is ugly.  Take the filename, compare it against
+		 * each of the module paths until we find a match on the start
+		 * of the filename, assume the rest is the relative path.  Have
+		 * to do it this way because modprobe uses absolute filenames
+		 * for module names in modules.dep and the format of modules.dep
+		 * does not allow for any backwards compatible changes, so there
+		 * is nowhere to store the relative filename.  The only way this
+		 * should fail to calculate a relative path is "insmod ./xxx", for
+		 * that case the user has to specify -e filename.
+		 */
+		int j, l = strlen(filename);
+		char *relative = NULL;
+		char *p;
+		for (i = 0; i < nmodpath; ++i) {
+			p = modpath[i].path;
+			j = strlen(p);
+			while (j && p[j] == '/')
+				--j;
+			if (j < l && strncmp(filename, p, j) == 0 && filename[j] == '/') {
+				while (filename[j] == '/')
+					++j;
+				relative = xstrdup(filename+j);
+				break;
+			}
+		}
+		if (relative) {
+			i = strlen(relative);
+			if (i > 3 && strcmp(relative+i-3, ".gz") == 0)
+				relative[i -= 3] = '\0';
+			if (i > 2 && strcmp(relative+i-2, ".o") == 0)
+				relative[i -= 2] = '\0';
+			else if (i > 4 && strcmp(relative+i-4, ".mod") == 0)
+				relative[i -= 4] = '\0';
+			f->persist = xmalloc(strlen(persistdir) + 1 + i + 1);
+			strcpy(f->persist, persistdir);	/* safe, xmalloc */
+			strcat(f->persist, "/");	/* safe, xmalloc */
+			strcat(f->persist, relative);	/* safe, xmalloc */
+			free(relative);
+		}
+		else
+			error("Cannot calculate persistent filename");
+	}
+
+	if (f->persist && *(f->persist) != '/') {
+		error("Persistent filenames must be absolute, ignoring '%s'",
+			f->persist);
+		free(f->persist);
+		f->persist = NULL;
+	}
+
+	if (f->persist && !flag_ksymoops) {
+		error("has persistent data but ksymoops symbols are not available");
+		free(f->persist);
+		f->persist = NULL;
+	}
+
+	if (f->persist && !k_new_syscalls) {
+		error("has persistent data but the kernel is too old to support it");
+		free(f->persist);
+		f->persist = NULL;
+	}
+
+	if (persist_parms && flag_verbose) {
+		if (f->persist)
+			lprintf("Persist filename '%s'", f->persist);
+		else
+			lprintf("No persistent filename available");
+	}
+
+	if (f->persist) {
+		FILE *fp = fopen(f->persist, "r");
+		if (!fp) {
+			if (flag_verbose)
+				lprintf("Cannot open persist file '%s' %m", f->persist);
+		}
+		else {
+			int pargc = 0;
+			char *pargv[1000];	/* hard coded but big enough */
+			char line[3000];	/* hard coded but big enough */
+			char *p;
+			while (fgets(line, sizeof(line), fp)) {
+				p = strchr(line, '\n');
+				if (!p) {
+					error("Persistent data line is too long\n%s", line);
+					break;
+				}
+				*p = '\0';
+				p = line;
+				while (isspace(*p))
+					++p;
+				if (!*p || *p == '#')
+					continue;
+				if (pargc == sizeof(pargv)/sizeof(pargv[0])) {
+					error("More than %d persistent parameters", pargc);
+					break;
+				}
+				pargv[pargc++] = xstrdup(p);
+			}
+			fclose(fp);
+			if (!process_module_arguments(f, pargc, pargv, 0))
+				goto out;
+			while (pargc--)
+				free(pargv[pargc]);
+		}
+	}
+
+	if (flag_ksymoops)
+		add_ksymoops_symbols(f, filename, m_name);
+
+	if (k_new_syscalls)
+		create_module_ksymtab(f);
+
+	/* archdata based on relocatable addresses */
+	if (add_archdata(f, &archdata))
+		goto out;
+
+	/* kallsyms based on relocatable addresses */
+	if (add_kallsyms(f, &kallsyms, force_kallsyms))
+		goto out;
+	/**** No symbols or sections to be changed after kallsyms above ***/
+
+	if (errors)
+		goto out;
+
+	/* If we were just checking, we made it.  */
+	if (flag_silent_probe) {
+		exit_status = 0;
+		goto out;
+	}
+	/* Module has now finished growing; find its size and install it.  */
+	m_size = obj_load_size(f);	/* DEPMOD */
+
+	if (noload) {
+		/* Don't bother actually touching the kernel.  */
+		m_addr = 0x12340000;
+	} else {
+		errno = 0;
+		m_addr = create_module(m_name, m_size);
+		switch (errno) {
+		case 0:
+			break;
+		case EEXIST:
+			if (dolock) {
+				/*
+				 * Assume that we were just invoked
+				 * simultaneous with another insmod
+				 * and return success.
+				 */
+				exit_status = 0;
+				goto out;
+			}
+			error("a module named %s already exists", m_name);
+			goto out;
+		case ENOMEM:
+			error("can't allocate kernel memory for module; needed %lu bytes",
+			      m_size);
+			goto out;
+		default:
+			error("create_module: %m");
+			goto out;
+		}
+	}
+
+	/* module is already built, complete with ksymoops symbols for the
+	 * persistent filename.  If the kernel does not support persistent data
+	 * then give an error but continue.  It is too difficult to clean up at
+	 * this stage and this error will only occur on backported modules.
+	 * rmmod will also get an error so warn the user now.
+	 */
+	if (f->persist && !noload) {
+		struct {
+			struct module m;
+			int data;
+		} test_read;
+		memset(&test_read, 0, sizeof(test_read));
+		test_read.m.size_of_struct = -sizeof(test_read.m);      /* -ve size => read, not write */
+		test_read.m.read_start = m_addr + sizeof(struct module);
+		test_read.m.read_end = test_read.m.read_start + sizeof(test_read.data);
+		if (sys_init_module(m_name, (struct module *) &test_read)) {
+			int old_errors = errors;
+			error("has persistent data but the kernel is too old to support it."
+				"  Expect errors during rmmod as well");
+			errors = old_errors;
+		}
+	}
+
+	if (!obj_relocate(f, m_addr)) {	/* DEPMOD */
+		if (!noload)
+			delete_module(m_name);
+		goto out;
+	}
+
+	/* Do archdata again, this time we have the final addresses */
+	if (add_archdata(f, &archdata))
+		goto out;
+
+	/* Do kallsyms again, this time we have the final addresses */
+	if (add_kallsyms(f, &kallsyms, force_kallsyms))
+		goto out;
+
+#ifdef COMPAT_2_0
+	if (k_new_syscalls)
+		init_module(m_name, f, m_size, blob_name, noload, flag_load_map);
+	else if (!noload)
+		old_init_module(m_name, f, m_size);
+#else
+	init_module(m_name, f, m_size, blob_name, noload, flag_load_map);
+#endif
+	if (errors) {
+		if (!noload)
+			delete_module(m_name);
+		goto out;
+	}
+	exit_status = 0;
+
+      out:
+	if (dolock)
+		flock(fp, LOCK_UN);
+	close(fp);
+	if (!noload)
+		snap_shot(NULL, 0);
+
+	return exit_status;
+}
+
+/* For common 3264 code, add an overall insmod_main, in the 64 bit version. */
+#if defined(COMMON_3264) && defined(ONLY_64)
+int insmod_main(int argc, char **argv)
+{
+	if (arch64())
+		return insmod_main_64(argc, argv);
+	else
+		return insmod_main_32(argc, argv);
+}
+#endif	/* defined(COMMON_3264) && defined(ONLY_64) */
+
+
+
+int insmod_call(char * full_filename, char * params)
+{
+	int argc = 2;
+	char *argv[50];
+	char * ptr = params;
+	argv[0] = "stage1";
+	argv[1] = full_filename;
+
+	while (ptr != NULL) {
+		argv[argc] = ptr;
+		argc++;
+		ptr = strchr(ptr, ' ');
+		if (ptr) {
+			ptr[0] = '\0';
+			ptr++;
+		}
+	}
+
+	return insmod_main(argc, argv);
+}
diff --git a/mdk-stage1/insmod-modutils/obj/Makefile b/mdk-stage1/insmod-modutils/obj/Makefile
new file mode 100644
index 000000000..9bcf8bac8
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/obj/Makefile
@@ -0,0 +1,31 @@
+ #******************************************************************************
+ #
+ #    insmod from modutils (generic)
+ #
+ # $Id$
+ #
+ # Copyright 1996, 1997 Linux International.
+ #
+ #*****************************************************************************
+
+top_dir = ../..
+
+include $(top_dir)/Makefile.common
+
+
+all: libobj.a
+
+clean:
+	rm -f *.o *.a
+
+
+FLAGS = -c -Wall -Os -fomit-frame-pointer -I./../include -D_GNU_SOURCE -DELF_MACHINE_H='"elf_$(ARCH).h"' -DARCH_$(ARCH) -DCONFIG_ROOT_CHECK_OFF=0
+
+OBJS = obj_kallsyms.o obj_common.o obj_load.o obj_reloc.o obj_$(ARCH).o
+
+libobj.a: $(OBJS)
+	ar cru $@ $^
+	ranlib $@
+
+.c.o:
+	gcc $(FLAGS) $(GLIBC_INCLUDES) -c $<
diff --git a/mdk-stage1/insmod-modutils/obj/obj_alpha.c b/mdk-stage1/insmod-modutils/obj/obj_alpha.c
new file mode 100644
index 000000000..4006b3442
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/obj/obj_alpha.c
@@ -0,0 +1,305 @@
+/* Alpha specific support for Elf loading and relocation.
+   Copyright 1996, 1997 Linux International.
+
+   Contributed by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <string.h>
+#include <assert.h>
+
+#include <module.h>
+#include <obj.h>
+#include <util.h>
+
+/*======================================================================*/
+
+struct alpha_got_entry
+{
+  struct alpha_got_entry *next;
+  ElfW(Addr) addend;
+  int offset;
+  int reloc_done;
+};
+
+struct alpha_file
+{
+  struct obj_file root;
+  struct obj_section *got;
+};
+
+struct alpha_symbol
+{
+  struct obj_symbol root;
+  struct alpha_got_entry *got_entries;
+};
+
+
+/*======================================================================*/
+
+struct obj_file *
+arch_new_file (void)
+{
+  struct alpha_file *f;
+  f = xmalloc(sizeof(*f));
+  f->got = NULL;
+  return &f->root;
+}
+
+struct obj_section *
+arch_new_section (void)
+{
+  return xmalloc(sizeof(struct obj_section));
+}
+
+struct obj_symbol *
+arch_new_symbol (void)
+{
+  struct alpha_symbol *sym;
+  sym = xmalloc(sizeof(*sym));
+  sym->got_entries = NULL;
+  return &sym->root;
+}
+
+int
+arch_load_proc_section(struct obj_section *sec, int fp)
+{
+    /* Assume it's just a debugging section that we can safely
+       ignore ...  */
+    sec->contents = NULL;
+
+    return 0;
+}
+
+enum obj_reloc
+arch_apply_relocation (struct obj_file *f,
+		       struct obj_section *targsec,
+		       struct obj_section *symsec,
+		       struct obj_symbol *sym,
+		       Elf64_Rela *rel,
+		       Elf64_Addr v)
+{
+  struct alpha_file *af = (struct alpha_file *)f;
+  struct alpha_symbol *asym = (struct alpha_symbol *)sym;
+
+  unsigned long *lloc = (unsigned long *)(targsec->contents + rel->r_offset);
+  unsigned int *iloc = (unsigned int *)lloc;
+  Elf64_Addr dot = targsec->header.sh_addr + rel->r_offset;
+  Elf64_Addr gp = af->got->header.sh_addr + 0x8000;
+
+  enum obj_reloc ret = obj_reloc_ok;
+
+  switch (ELF64_R_TYPE(rel->r_info))
+    {
+    case R_ALPHA_NONE:
+    case R_ALPHA_LITUSE:
+      break;
+
+    case R_ALPHA_REFQUAD:
+      *lloc += v;
+      break;
+
+    case R_ALPHA_GPREL32:
+      v -= gp;
+      if ((Elf64_Sxword)v > 0x7fffffff
+	  || (Elf64_Sxword)v < -(Elf64_Sxword)0x80000000)
+	ret = obj_reloc_overflow;
+      *iloc = v;
+      break;
+
+    case R_ALPHA_LITERAL:
+      {
+	struct alpha_got_entry *gotent;
+
+	assert(asym != NULL);
+	gotent = asym->got_entries;
+	while (gotent->addend != rel->r_addend)
+	  gotent = gotent->next;
+
+	if (!gotent->reloc_done)
+	  {
+	    *(unsigned long *)(af->got->contents + gotent->offset) = v;
+	    gotent->reloc_done = 1;
+	  }
+
+	*iloc = (*iloc & ~0xffff) | ((gotent->offset - 0x8000) & 0xffff);
+      }
+    break;
+
+    case R_ALPHA_GPDISP:
+      {
+	unsigned int *p_ldah, *p_lda;
+	unsigned int i_ldah, i_lda, hi, lo;
+
+	p_ldah = iloc;
+	p_lda = (unsigned int *)((char *)iloc + rel->r_addend);
+	i_ldah = *p_ldah;
+	i_lda = *p_lda;
+
+	/* Make sure the instructions are righteous.  */
+	if ((i_ldah >> 26) != 9 || (i_lda >> 26) != 8)
+	  ret = obj_reloc_dangerous;
+
+	/* Extract the existing addend.  */
+	v = (i_ldah & 0xffff) << 16 | (i_lda & 0xffff);
+	v = (v ^ 0x80008000) - 0x80008000;
+
+	v += gp - dot;
+
+	if ((Elf64_Sxword)v >= 0x7fff8000
+	    || (Elf64_Sxword)v < -(Elf64_Sxword)0x80000000)
+	  ret = obj_reloc_overflow;
+
+	/* Modify the instructions and finish up.  */
+	lo = v & 0xffff;
+	hi = ((v >> 16) + ((v >> 15) & 1)) & 0xffff;
+
+	*p_ldah = (i_ldah & 0xffff0000) | hi;
+	*p_lda = (i_lda & 0xffff0000) | lo;
+      }
+    break;
+
+    case R_ALPHA_BRADDR:
+      v -= dot + 4;
+      if (v % 4)
+	ret = obj_reloc_dangerous;
+      else if ((Elf64_Sxword)v > 0x3fffff
+	       || (Elf64_Sxword)v < -(Elf64_Sxword)0x400000)
+	ret = obj_reloc_overflow;
+      v /= 4;
+
+      *iloc = (*iloc & ~0x1fffff) | (v & 0x1fffff);
+      break;
+
+    case R_ALPHA_HINT:
+      v -= dot + 4;
+      if (v % 4)
+	ret = obj_reloc_dangerous;
+      v /= 4;
+
+      *iloc = (*iloc & ~0x3fff) | (v & 0x3fff);
+      break;
+
+    default:
+      ret = obj_reloc_unhandled;
+      break;
+    }
+
+  return ret;
+}
+
+int
+arch_create_got (struct obj_file *f)
+{
+  struct alpha_file *af = (struct alpha_file *)f;
+  int i, n, offset = 0;
+
+  n = af->root.header.e_shnum;
+  for (i = 0; i < n; ++i)
+    {
+      struct obj_section *relsec, *symsec, *strsec;
+      Elf64_Rela *rel, *relend;
+      Elf64_Sym *symtab;
+      const char *strtab;
+
+      relsec = af->root.sections[i];
+      if (relsec->header.sh_type != SHT_RELA)
+	continue;
+
+      symsec = af->root.sections[relsec->header.sh_link];
+      strsec = af->root.sections[symsec->header.sh_link];
+
+      rel = (Elf64_Rela *)relsec->contents;
+      relend = rel + (relsec->header.sh_size / sizeof(Elf64_Rela));
+      symtab = (Elf64_Sym *)symsec->contents;
+      strtab = (const char *)strsec->contents;
+
+      for (; rel < relend; ++rel)
+	{
+	  struct alpha_got_entry *ent;
+	  Elf64_Sym *extsym;
+	  struct alpha_symbol *intsym;
+	  const char *name;
+
+	  if (ELF64_R_TYPE(rel->r_info) != R_ALPHA_LITERAL)
+	    continue;
+
+	  extsym = &symtab[ELF64_R_SYM(rel->r_info)];
+	  if (extsym->st_name)
+	    name = strtab + extsym->st_name;
+	  else
+	    name = f->sections[extsym->st_shndx]->name;
+	  intsym = (struct alpha_symbol *)obj_find_symbol(&af->root, name);
+
+	  for (ent = intsym->got_entries; ent ; ent = ent->next)
+	    if (ent->addend == rel->r_addend)
+	      goto found;
+
+	  ent = xmalloc(sizeof(*ent));
+	  ent->addend = rel->r_addend;
+	  ent->offset = offset;
+	  ent->reloc_done = 0;
+	  ent->next = intsym->got_entries;
+	  intsym->got_entries = ent;
+	  offset += 8;
+
+	found:;
+	}
+    }
+
+  if (offset > 0x10000)
+    {
+      error(".got section overflow: %#x > 0x10000", offset);
+      return 0;
+    }
+
+  /* We always want a .got section so that we always have a GP for
+     use with GPDISP and GPREL32 relocs.  Besides, if the section
+     is empty we don't use up space anyway.  */
+  af->got = obj_create_alloced_section(&af->root, ".got", 8, offset);
+
+  return 1;
+}
+
+int
+arch_init_module (struct obj_file *f, struct module *mod)
+{
+  struct alpha_file *af = (struct alpha_file *)f;
+
+  mod->gp = af->got->header.sh_addr + 0x8000;
+
+  return 1;
+}
+
+int
+arch_finalize_section_address(struct obj_file *f, Elf64_Addr base)
+{
+  int  i, n = f->header.e_shnum;
+
+  f->baseaddr = base;
+  for (i = 0; i < n; ++i)
+    f->sections[i]->header.sh_addr += base;
+  return 1;
+}
+
+int
+arch_archdata (struct obj_file *fin, struct obj_section *sec)
+{
+  return 0;
+}
diff --git a/mdk-stage1/insmod-modutils/obj/obj_arm.c b/mdk-stage1/insmod-modutils/obj/obj_arm.c
new file mode 100644
index 000000000..7a843f947
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/obj/obj_arm.c
@@ -0,0 +1,318 @@
+/* ARM specific support for Elf loading and relocation.
+   Copyright 1996, 1997, 1998 Linux International.
+
+   Contributed by Phil Blundell <philb@gnu.org>
+   and wms <woody@corelcomputer.com>
+   based on the i386 code by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <string.h>
+#include <assert.h>
+
+#include <module.h>
+#include <obj.h>
+#include <util.h>
+
+
+/*======================================================================*/
+
+struct arm_plt_entry
+{
+  int offset;
+  int allocated:1;
+  int inited:1;                // has been set up
+};
+
+struct arm_got_entry
+{
+  int offset;
+  int allocated : 1;
+  unsigned reloc_done : 1;
+};
+
+struct arm_file
+{
+  struct obj_file root;
+  struct obj_section *plt;
+  struct obj_section *got;
+};
+
+struct arm_symbol
+{
+  struct obj_symbol root;
+  struct arm_plt_entry pltent;
+  struct arm_got_entry gotent;
+};
+
+
+/*======================================================================*/
+
+struct obj_file *
+arch_new_file (void)
+{
+  struct arm_file *f;
+  f = xmalloc(sizeof(*f));
+  f->got = NULL;
+  return &f->root;
+}
+
+struct obj_section *
+arch_new_section (void)
+{
+  return xmalloc(sizeof(struct obj_section));
+}
+
+struct obj_symbol *
+arch_new_symbol (void)
+{
+  struct arm_symbol *sym;
+  sym = xmalloc(sizeof(*sym));
+  memset(&sym->gotent, 0, sizeof(sym->gotent));
+  memset(&sym->pltent, 0, sizeof(sym->pltent));
+  return &sym->root;
+}
+
+int
+arch_load_proc_section(struct obj_section *sec, int fp)
+{
+    /* Assume it's just a debugging section that we can safely
+       ignore ...  */
+    sec->contents = NULL;
+
+    return 0;
+}
+
+enum obj_reloc
+arch_apply_relocation (struct obj_file *f,
+		       struct obj_section *targsec,
+		       struct obj_section *symsec,
+		       struct obj_symbol *sym,
+		       Elf32_Rel *rel,
+		       Elf32_Addr v)
+{
+  struct arm_file *afile = (struct arm_file *)f;
+  struct arm_symbol *asym  = (struct arm_symbol *)sym;
+
+  Elf32_Addr *loc = (Elf32_Addr *)(targsec->contents + rel->r_offset);
+  Elf32_Addr dot = targsec->header.sh_addr + rel->r_offset;
+  Elf32_Addr got = afile->got ? afile->got->header.sh_addr : 0;
+  Elf32_Addr plt = afile->plt ? afile->plt->header.sh_addr : 0;
+
+  struct arm_plt_entry *pe;
+  unsigned long *ip;
+
+  enum obj_reloc ret = obj_reloc_ok;
+
+  switch (ELF32_R_TYPE(rel->r_info))
+    {
+    case R_ARM_NONE:
+      break;
+
+    case R_ARM_ABS32:
+      *loc += v;
+      break;
+
+    case R_ARM_GOT32:
+      /* needs an entry in the .got: set it, once */
+      if (! asym->gotent.reloc_done)
+	{
+	  asym->gotent.reloc_done = 1;
+	  *(Elf32_Addr *)(afile->got->contents + asym->gotent.offset) = v;
+	}
+      /* make the reloc with_respect_to_.got */
+      *loc += asym->gotent.offset;
+      break;
+
+      /* relative reloc, always to _GLOBAL_OFFSET_TABLE_ (which is .got)
+	 similar to branch, but is full 32 bits relative */
+    case R_ARM_GOTPC:
+      assert(got);
+      *loc += got - dot;
+      break;
+
+    case R_ARM_PC24:
+    case R_ARM_PLT32:
+      /* find the plt entry and initialize it if necessary */
+      assert(asym != NULL);
+      pe = (struct arm_plt_entry*) &asym->pltent;
+      if (! pe->inited)
+	{
+	  ip = (unsigned long *) (afile->plt->contents + pe->offset);
+	  ip[0] = 0xe51ff004;			/* ldr pc,[pc,#-4] */
+	  ip[1] = v;				/* sym@ */
+	  pe->inited = 1;
+	}
+
+      /* relative distance to target */
+      v -= dot;
+      /* if the target is too far away.... */
+      if ((int)v < -0x02000000 || (int)v >= 0x02000000)
+	{
+	  /* go via the plt */
+	  v = plt + pe->offset - dot;
+	}
+      if (v & 3)
+	ret = obj_reloc_dangerous;
+
+      /* Convert to words. */
+      v >>= 2;
+
+      /* merge the offset into the instruction. */
+      *loc = (*loc & ~0x00ffffff) | ((v + *loc) & 0x00ffffff);
+      break;
+
+      /* address relative to the got */
+    case R_ARM_GOTOFF:
+      assert(got);
+      *loc += v - got;
+      break;
+
+    default:
+      printf("Warning: unhandled reloc %d\n",ELF32_R_TYPE(rel->r_info));
+      ret = obj_reloc_unhandled;
+      break;
+    }
+
+  return ret;
+}
+
+int
+arch_create_got (struct obj_file *f)
+{
+  struct arm_file *afile = (struct arm_file *) f;
+  int i;
+  struct obj_section *sec, *syms, *strs;
+  ElfW(Rel) *rel, *relend;
+  ElfW(Sym) *symtab, *extsym;
+  const char *strtab, *name;
+  struct arm_symbol *intsym;
+  struct arm_plt_entry *pe;
+  struct arm_got_entry *ge;
+  int got_offset = 0, plt_offset = 0;
+
+  for (i = 0; i < f->header.e_shnum; ++i)
+    {
+      sec = f->sections[i];
+      if (sec->header.sh_type != SHT_RELM)
+	continue;
+      syms = f->sections[sec->header.sh_link];
+      strs = f->sections[syms->header.sh_link];
+
+      rel = (ElfW(RelM) *) sec->contents;
+      relend = rel + (sec->header.sh_size / sizeof(ElfW(RelM)));
+      symtab = (ElfW(Sym) *) syms->contents;
+      strtab = (const char *) strs->contents;
+
+      for (; rel < relend; ++rel)
+	{
+	  extsym = &symtab[ELF32_R_SYM(rel->r_info)];
+
+	  switch(ELF32_R_TYPE(rel->r_info)) {
+	  case R_ARM_PC24:
+	  case R_ARM_PLT32:
+	    if (extsym->st_name)
+	      name = strtab + extsym->st_name;
+	    else
+	      name = f->sections[extsym->st_shndx]->name;
+	    intsym = (struct arm_symbol *) obj_find_symbol(f, name);
+
+	    pe = &intsym->pltent;
+
+	    if (! pe->allocated)
+	      {
+		pe->allocated = 1;
+		pe->offset = plt_offset;
+		plt_offset += 8;
+		pe->inited = 0;
+	      }
+	    break;
+
+	    /* these two don_t need got entries, but they need
+	       the .got to exist */
+	  case R_ARM_GOTOFF:
+	  case R_ARM_GOTPC:
+	    if (got_offset==0) got_offset = 4;
+	    break;
+
+	  case R_ARM_GOT32:
+	    if (extsym->st_name)
+	      name = strtab + extsym->st_name;
+	    else
+	      name = f->sections[extsym->st_shndx]->name;
+	    intsym = (struct arm_symbol *) obj_find_symbol(f, name);
+
+	    ge = (struct arm_got_entry *) &intsym->gotent;
+	    if (! ge->allocated)
+	      {
+		ge->allocated = 1;
+		ge->offset = got_offset;
+		got_offset += sizeof(void*);
+	      }
+	    break;
+
+	  default:
+	    continue;
+	  }
+	}
+    }
+
+  /* if there was a _GLOBAL_OFFSET_TABLE_, then the .got section
+   exists already; find it and use it */
+  if (got_offset)
+  {
+      struct obj_section* sec = obj_find_section(f, ".got");
+      if (sec)
+	obj_extend_section(sec, got_offset);
+      else
+	{
+	  sec = obj_create_alloced_section(f, ".got", 8, got_offset);
+	  assert(sec);
+	}
+      afile->got = sec;
+  }
+
+  if (plt_offset)
+    afile->plt = obj_create_alloced_section(f, ".plt", 8, plt_offset);
+
+  return 1;
+}
+
+int
+arch_init_module (struct obj_file *f, struct module *mod)
+{
+  return 1;
+}
+
+int
+arch_finalize_section_address(struct obj_file *f, Elf32_Addr base)
+{
+  int  i, n = f->header.e_shnum;
+
+  f->baseaddr = base;
+  for (i = 0; i < n; ++i)
+    f->sections[i]->header.sh_addr += base;
+  return 1;
+}
+
+int
+arch_archdata (struct obj_file *fin, struct obj_section *sec)
+{
+  return 0;
+}
diff --git a/mdk-stage1/insmod-modutils/obj/obj_common.c b/mdk-stage1/insmod-modutils/obj/obj_common.c
new file mode 100644
index 000000000..2a6606c94
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/obj/obj_common.c
@@ -0,0 +1,399 @@
+/* Elf file, section, and symbol manipulation routines.
+   Copyright 1996, 1997 Linux International.
+
+   Contributed by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include <obj.h>
+#include <util.h>
+#include <module.h>
+
+/*======================================================================*/
+
+/* Standard ELF hash function.  */
+inline unsigned long
+obj_elf_hash_n(const char *name, unsigned long n)
+{
+  unsigned long h = 0;
+  unsigned long g;
+  unsigned char ch;
+
+  while (n > 0)
+    {
+      ch = *name++;
+      h = (h << 4) + ch;
+      if ((g = (h & 0xf0000000)) != 0)
+	{
+	  h ^= g >> 24;
+	  h &= ~g;
+	}
+      n--;
+    }
+  return h;
+}
+
+unsigned long
+obj_elf_hash (const char *name)
+{
+  return obj_elf_hash_n(name, strlen(name));
+}
+
+void
+obj_set_symbol_compare (struct obj_file *f,
+			int (*cmp)(const char *, const char *),
+			unsigned long (*hash)(const char *))
+{
+  if (cmp)
+    f->symbol_cmp = cmp;
+  if (hash)
+    {
+      struct obj_symbol *tmptab[HASH_BUCKETS], *sym, *next;
+      int i;
+
+      f->symbol_hash = hash;
+
+      memcpy(tmptab, f->symtab, sizeof(tmptab));
+      memset(f->symtab, 0, sizeof(f->symtab));
+
+      for (i = 0; i < HASH_BUCKETS; ++i)
+	for (sym = tmptab[i]; sym ; sym = next)
+	  {
+	    unsigned long h = hash(sym->name) % HASH_BUCKETS;
+	    next = sym->next;
+	    sym->next = f->symtab[h];
+	    f->symtab[h] = sym;
+	  }
+    }
+}
+
+struct obj_symbol *
+obj_add_symbol (struct obj_file *f, const char *name, unsigned long symidx,
+		int info, int secidx, ElfW(Addr) value, unsigned long size)
+{
+  struct obj_symbol *sym;
+  unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
+  int n_type = ELFW(ST_TYPE)(info);
+  int n_binding = ELFW(ST_BIND)(info);
+
+  for (sym = f->symtab[hash]; sym; sym = sym->next)
+    if (f->symbol_cmp(sym->name, name) == 0)
+      {
+	int o_secidx = sym->secidx;
+	int o_info = sym->info;
+	int o_type = ELFW(ST_TYPE)(o_info);
+	int o_binding = ELFW(ST_BIND)(o_info);
+
+	/* A redefinition!  Is it legal?  */
+
+	if (secidx == SHN_UNDEF)
+	  return sym;
+	else if (o_secidx == SHN_UNDEF)
+	  goto found;
+	else if (n_binding == STB_GLOBAL && o_binding == STB_LOCAL)
+	  {
+	    /* Cope with local and global symbols of the same name
+	       in the same object file, as might have been created
+	       by ld -r.  The only reason locals are now seen at this
+	       level at all is so that we can do semi-sensible things
+	       with parameters.  */
+
+	    struct obj_symbol *nsym, **p;
+
+	    nsym = arch_new_symbol();
+	    nsym->next = sym->next;
+	    nsym->ksymidx = -1;
+
+	    /* Excise the old (local) symbol from the hash chain.  */
+	    for (p = &f->symtab[hash]; *p != sym; p = &(*p)->next)
+	      continue;
+	    *p = sym = nsym;
+	    goto found;
+	  }
+	else if (n_binding == STB_LOCAL)
+	  {
+	    /* Another symbol of the same name has already been defined.
+	       Just add this to the local table.  */
+	    sym = arch_new_symbol();
+	    sym->next = NULL;
+	    sym->ksymidx = -1;
+	    f->local_symtab[symidx] = sym;
+	    goto found;
+	  }
+	else if (n_binding == STB_WEAK)
+	  return sym;
+	else if (o_binding == STB_WEAK)
+	  goto found;
+	/* Don't unify COMMON symbols with object types the programmer
+	   doesn't expect.  */
+	else if (secidx == SHN_COMMON
+		 && (o_type == STT_NOTYPE || o_type == STT_OBJECT))
+	  return sym;
+	else if (o_secidx == SHN_COMMON
+		 && (n_type == STT_NOTYPE || n_type == STT_OBJECT))
+	  goto found;
+	else
+	  {
+	    /* Don't report an error if the symbol is coming from
+	       the kernel or some external module.  */
+	    if (secidx <= SHN_HIRESERVE)
+	      error("%s multiply defined", name);
+	    return sym;
+	  }
+      }
+
+  /* Completely new symbol.  */
+  sym = arch_new_symbol();
+  sym->next = f->symtab[hash];
+  f->symtab[hash] = sym;
+  sym->ksymidx = -1;
+
+  if (ELFW(ST_BIND)(info) == STB_LOCAL && symidx != -1) {
+    if (symidx >= f->local_symtab_size)
+      error("local symbol %s with index %ld exceeds local_symtab_size %ld",
+        name, (long) symidx, (long) f->local_symtab_size);
+    else
+      f->local_symtab[symidx] = sym;
+  }
+
+found:
+  sym->name = name;
+  sym->value = value;
+  sym->size = size;
+  sym->secidx = secidx;
+  sym->info = info;
+  sym->r_type = 0;	/* should be R_arch_NONE for all arch */
+
+  return sym;
+}
+
+struct obj_symbol *
+obj_find_symbol (struct obj_file *f, const char *name)
+{
+  struct obj_symbol *sym;
+  unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
+
+  for (sym = f->symtab[hash]; sym; sym = sym->next)
+    if (f->symbol_cmp(sym->name, name) == 0)
+      return sym;
+
+  return NULL;
+}
+
+ElfW(Addr)
+obj_symbol_final_value (struct obj_file *f, struct obj_symbol *sym)
+{
+  if (sym)
+    {
+      if (sym->secidx >= SHN_LORESERVE)
+	return sym->value;
+
+      return sym->value + f->sections[sym->secidx]->header.sh_addr;
+    }
+  else
+    {
+      /* As a special case, a NULL sym has value zero.  */
+      return 0;
+    }
+}
+
+struct obj_section *
+obj_find_section (struct obj_file *f, const char *name)
+{
+  int i, n = f->header.e_shnum;
+
+  for (i = 0; i < n; ++i)
+    if (strcmp(f->sections[i]->name, name) == 0)
+      return f->sections[i];
+
+  return NULL;
+}
+
+static int
+obj_load_order_prio(struct obj_section *a)
+{
+  unsigned long af, ac;
+
+  af = a->header.sh_flags;
+
+  ac = 0;
+  if (a->name[0] != '.' || strlen(a->name) != 10 ||
+      strcmp(a->name + 5, ".init")) ac |= 32;
+  if (af & SHF_ALLOC) ac |= 16;
+  if (!(af & SHF_WRITE)) ac |= 8;
+  if (af & SHF_EXECINSTR) ac |= 4;
+  if (a->header.sh_type != SHT_NOBITS) ac |= 2;
+#if defined(ARCH_ia64)
+  if (af & SHF_IA_64_SHORT) ac -= 1;
+#endif
+
+  return ac;
+}
+
+void
+obj_insert_section_load_order (struct obj_file *f, struct obj_section *sec)
+{
+  struct obj_section **p;
+  int prio = obj_load_order_prio(sec);
+  for (p = f->load_order_search_start; *p ; p = &(*p)->load_next)
+    if (obj_load_order_prio(*p) < prio)
+      break;
+  sec->load_next = *p;
+  *p = sec;
+}
+
+struct obj_section *
+obj_create_alloced_section (struct obj_file *f, const char *name,
+			    unsigned long align, unsigned long size)
+{
+  int newidx = f->header.e_shnum++;
+  struct obj_section *sec;
+
+  f->sections = xrealloc(f->sections, (newidx+1) * sizeof(sec));
+  f->sections[newidx] = sec = arch_new_section();
+
+  memset(sec, 0, sizeof(*sec));
+  sec->header.sh_type = SHT_PROGBITS;
+  sec->header.sh_flags = SHF_WRITE|SHF_ALLOC;
+  sec->header.sh_size = size;
+  sec->header.sh_addralign = align;
+  sec->name = name;
+  sec->idx = newidx;
+  if (size)
+    sec->contents = xmalloc(size);
+
+  obj_insert_section_load_order(f, sec);
+
+  return sec;
+}
+
+struct obj_section *
+obj_create_alloced_section_first (struct obj_file *f, const char *name,
+				  unsigned long align, unsigned long size)
+{
+  int newidx = f->header.e_shnum++;
+  struct obj_section *sec;
+
+  f->sections = xrealloc(f->sections, (newidx+1) * sizeof(sec));
+  f->sections[newidx] = sec = arch_new_section();
+
+  memset(sec, 0, sizeof(*sec));
+  sec->header.sh_type = SHT_PROGBITS;
+  sec->header.sh_flags = SHF_WRITE|SHF_ALLOC;
+  sec->header.sh_size = size;
+  sec->header.sh_addralign = align;
+  sec->name = name;
+  sec->idx = newidx;
+  if (size)
+    sec->contents = xmalloc(size);
+
+  sec->load_next = f->load_order;
+  f->load_order = sec;
+  if (f->load_order_search_start == &f->load_order)
+    f->load_order_search_start = &sec->load_next;
+
+  return sec;
+}
+
+void *
+obj_extend_section (struct obj_section *sec, unsigned long more)
+{
+  unsigned long oldsize = sec->header.sh_size;
+  sec->contents = xrealloc(sec->contents, sec->header.sh_size += more);
+  return sec->contents + oldsize;
+}
+
+/* Convert an object pointer (address) to a native pointer and vice versa.
+ * It gets interesting when the object has 64 bit pointers but modutils
+ * is running 32 bit.  This is nasty code but it stops the compiler giving
+ * spurious warning messages.  "I know what I am doing" ...
+ */
+
+void *
+obj_addr_to_native_ptr (ElfW(Addr) addr)
+{
+	unsigned int convert = (sizeof(void *) << 8) + sizeof(addr);	/* to, from */
+	union obj_ptr_4 p4;
+	union obj_ptr_8 p8;
+	switch (convert) {
+	case 0x0404:
+		p4.addr = addr;
+		return(p4.ptr);
+		break;
+	case 0x0408:
+		p4.addr = addr;
+		if (p4.addr != addr) {
+			error("obj_addr_to_native_ptr truncation %" tgt_long_fmt "x",
+				(tgt_long) addr);
+			exit(1);
+		}
+		return(p4.ptr);
+		break;
+	case 0x0804:
+		p8.addr = addr;
+		return(p8.ptr);
+		break;
+	case 0x0808:
+		p8.addr = addr;
+		return(p8.ptr);
+		break;
+	default:
+		error("obj_addr_to_native_ptr unknown conversion 0x%04x", convert);
+		exit(1);
+	}
+}
+
+ElfW(Addr)
+obj_native_ptr_to_addr (void *ptr)
+{
+	unsigned int convert = (sizeof(ElfW(Addr)) << 8) + sizeof(ptr);	/* to, from */
+	union obj_ptr_4 p4;
+	union obj_ptr_8 p8;
+	switch (convert) {
+	case 0x0404:
+		p4.ptr = ptr;
+		return(p4.addr);
+		break;
+	case 0x0408:
+		p8.ptr = ptr;
+		p4.addr = p8.addr;
+		if (p4.addr != p8.addr) {
+			error("obj_native_ptr_to_addr truncation %" tgt_long_fmt "x",
+				(tgt_long) p8.addr);
+			exit(1);
+		}
+		return(p4.addr);
+		break;
+	case 0x0804:
+		p4.ptr = ptr;
+		return(p4.addr);	/* compiler expands to 8 */
+		break;
+	case 0x0808:
+		p8.ptr = ptr;
+		return(p8.addr);
+		break;
+	default:
+		error("obj_native_ptr_to_addr unknown conversion 0x%04x", convert);
+		exit(1);
+	}
+}
diff --git a/mdk-stage1/insmod-modutils/obj/obj_hppa.c b/mdk-stage1/insmod-modutils/obj/obj_hppa.c
new file mode 100644
index 000000000..4207e692e
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/obj/obj_hppa.c
@@ -0,0 +1,668 @@
+/*
+ * PA-RISC specific support for Elf loading and relocation.
+ * Copyright 2000 David Huggins-Daines <dhd@linuxcare.com>, Linuxcare Inc.
+ * Copyright 2000 Richard Hirst <rhirst@linuxcare.com>, Linuxcare Inc.
+ *
+ * Based on the IA-64 support, which is:
+ * Copyright 2000 Mike Stephens <mike.stephens@intel.com>
+ *
+ * This file is part of the Linux modutils.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include <module.h>
+#include <obj.h>
+#include <util.h>
+#include <modstat.h>	/* For ksyms */
+
+
+typedef struct _hppa_stub_t
+{
+  struct _hppa_stub_t *next;
+  int offset;
+  int reloc_done;
+} hppa_stub_t;
+
+typedef struct _hppa_symbol_t
+{
+  struct obj_symbol root;
+  hppa_stub_t *stub;
+} hppa_symbol_t;
+
+typedef struct _hppa_file_t
+{
+  struct obj_file root;
+  struct obj_section *stub;
+  Elf32_Addr dp;
+} hppa_file_t;
+
+/* The ABI defines various more esoteric types, but these are the only
+   ones we actually need. */
+enum hppa_fsel
+{
+  e_fsel,
+  e_lsel,
+  e_rsel,
+  e_lrsel,
+  e_rrsel
+};
+
+/* This could be a call to obj_create_alloced_section() followed
+ * by an overwrite of sec->header.sh_flags.
+ */
+
+struct obj_section *
+obj_hppa_create_alloced_section (struct obj_file *f, const char *name,
+				 unsigned long align, unsigned long size,
+				 unsigned long sh_flags)
+{
+  int newidx = f->header.e_shnum++;
+  struct obj_section *sec;
+
+  f->sections = xrealloc(f->sections, (newidx+1) * sizeof(sec));
+  f->sections[newidx] = sec = arch_new_section();
+
+  memset(sec, 0, sizeof(*sec));
+  sec->header.sh_type = SHT_PROGBITS;
+  sec->header.sh_flags = sh_flags;
+  sec->header.sh_size = size;
+  sec->header.sh_addralign = align;
+  sec->name = name;
+  sec->idx = newidx;
+  if (size)
+    sec->contents = xmalloc(size);
+
+  obj_insert_section_load_order(f, sec);
+
+  return sec;
+}
+
+struct obj_file *
+arch_new_file (void)
+{
+  hppa_file_t *f;
+  f = xmalloc(sizeof(*f));
+  f->stub = NULL;
+  return &f->root;
+}
+
+struct obj_section *
+arch_new_section (void)
+{
+  return xmalloc(sizeof(struct obj_section));
+}
+
+struct obj_symbol *
+arch_new_symbol (void)
+{
+  hppa_symbol_t *sym;
+  sym = xmalloc(sizeof(*sym));
+  sym->stub = NULL;
+  return &sym->root;
+}
+
+/* This is called for architecture specific sections we might need to
+   do special things to. */
+int
+arch_load_proc_section(struct obj_section *sec, int fp)
+{
+  /* Assume it's just a debugging section that we can safely
+     ignore ...  */
+  sec->contents = NULL;
+
+  return 0;
+}
+
+/* =================================================================
+
+   These functions are from libhppa.h in the GNU BFD library.
+   (c) 1990, 91, 92, 93, 94, 95, 96, 98, 99, 2000
+   Free Software Foundation, Inc.
+
+   ================================================================= */
+
+/* The *sign_extend functions are used to assemble various bitfields
+   taken from an instruction and return the resulting immediate
+   value.  */
+
+static inline int
+sign_extend (x, len)
+     int x, len;
+{
+  int signbit = (1 << (len - 1));
+  int mask = (signbit << 1) - 1;
+  return ((x & mask) ^ signbit) - signbit;
+}
+
+static inline int
+low_sign_extend (x, len)
+     int x, len;
+{
+  return (x >> 1) - ((x & 1) << (len - 1));
+}
+
+
+/* The re_assemble_* functions prepare an immediate value for
+   insertion into an opcode. pa-risc uses all sorts of weird bitfields
+   in the instruction to hold the value.  */
+
+static inline int
+sign_unext (x, len)
+     int x, len;
+{
+  int len_ones;
+
+  len_ones = (1 << len) - 1;
+
+  return x & len_ones;
+}
+
+static inline int
+low_sign_unext (x, len)
+     int x, len;
+{
+  int temp;
+  int sign;
+
+  sign = (x >> (len-1)) & 1;
+
+  temp = sign_unext (x, len-1);
+
+  return (temp << 1) | sign;
+}
+
+static inline int
+re_assemble_3 (as3)
+     int as3;
+{
+  return ((  (as3 & 4) << (13-2))
+	  | ((as3 & 3) << (13+1)));
+}
+
+static inline int
+re_assemble_12 (as12)
+     int as12;
+{
+  return ((  (as12 & 0x800) >> 11)
+	  | ((as12 & 0x400) >> (10 - 2))
+	  | ((as12 & 0x3ff) << (1 + 2)));
+}
+
+static inline int
+re_assemble_14 (as14)
+     int as14;
+{
+  return ((  (as14 & 0x1fff) << 1)
+	  | ((as14 & 0x2000) >> 13));
+}
+
+static inline int
+re_assemble_16 (as16)
+     int as16;
+{
+  int s, t;
+
+  /* Unusual 16-bit encoding, for wide mode only.  */
+  t = (as16 << 1) & 0xffff;
+  s = (as16 & 0x8000);
+  return (t ^ s ^ (s >> 1)) | (s >> 15);
+}
+
+static inline int
+re_assemble_17 (as17)
+     int as17;
+{
+  return ((  (as17 & 0x10000) >> 16)
+	  | ((as17 & 0x0f800) << (16 - 11))
+	  | ((as17 & 0x00400) >> (10 - 2))
+	  | ((as17 & 0x003ff) << (1 + 2)));
+}
+
+static inline int
+re_assemble_21 (as21)
+     int as21;
+{
+  return ((  (as21 & 0x100000) >> 20)
+	  | ((as21 & 0x0ffe00) >> 8)
+	  | ((as21 & 0x000180) << 7)
+	  | ((as21 & 0x00007c) << 14)
+	  | ((as21 & 0x000003) << 12));
+}
+
+static inline int
+re_assemble_22 (as22)
+     int as22;
+{
+  return ((  (as22 & 0x200000) >> 21)
+	  | ((as22 & 0x1f0000) << (21 - 16))
+	  | ((as22 & 0x00f800) << (16 - 11))
+	  | ((as22 & 0x000400) >> (10 - 2))
+	  | ((as22 & 0x0003ff) << (1 + 2)));
+}
+
+
+/* Handle field selectors for PA instructions.
+   The L and R (and LS, RS etc.) selectors are used in pairs to form a
+   full 32 bit address.  eg.
+
+   LDIL	L'start,%r1		; put left part into r1
+   LDW	R'start(%r1),%r2	; add r1 and right part to form address
+
+   This function returns sign extended values in all cases.
+*/
+
+static inline unsigned int
+hppa_field_adjust (value, addend, r_field)
+     unsigned int value;
+     int addend;
+     enum hppa_fsel r_field;
+{
+  unsigned int sym_val;
+
+  sym_val = value - addend;
+  switch (r_field)
+    {
+    case e_fsel:
+      /* F: No change.  */
+      break;
+
+    case e_lsel:
+      /* L:  Select top 21 bits.  */
+      value = value >> 11;
+      break;
+
+    case e_rsel:
+      /* R:  Select bottom 11 bits.  */
+      value = value & 0x7ff;
+      break;
+
+    case e_lrsel:
+      /* LR:  L with rounding of the addend to nearest 8k.  */
+      value = sym_val + ((addend + 0x1000) & -0x2000);
+      value = value >> 11;
+      break;
+
+    case e_rrsel:
+      /* RR:  R with rounding of the addend to nearest 8k.
+	 We need to return a value such that 2048 * LR'x + RR'x == x
+	 ie. RR'x = s+a - (s + (((a + 0x1000) & -0x2000) & -0x800))
+	 .	  = s+a - ((s & -0x800) + ((a + 0x1000) & -0x2000))
+	 .	  = (s & 0x7ff) + a - ((a + 0x1000) & -0x2000)  */
+      value = (sym_val & 0x7ff) + (((addend & 0x1fff) ^ 0x1000) - 0x1000);
+      break;
+
+    default:
+      abort();
+    }
+  return value;
+}
+
+/* Insert VALUE into INSN using R_FORMAT to determine exactly what
+   bits to change.  */
+
+static inline int
+hppa_rebuild_insn (insn, value, r_format)
+     int insn;
+     int value;
+     int r_format;
+{
+  switch (r_format)
+    {
+    case 11:
+      return (insn & ~ 0x7ff) | low_sign_unext (value, 11);
+
+    case 12:
+      return (insn & ~ 0x1ffd) | re_assemble_12 (value);
+
+
+    case 10:
+      return (insn & ~ 0x3ff1) | re_assemble_14 (value & -8);
+
+    case -11:
+      return (insn & ~ 0x3ff9) | re_assemble_14 (value & -4);
+
+    case 14:
+      return (insn & ~ 0x3fff) | re_assemble_14 (value);
+
+
+    case -10:
+      return (insn & ~ 0xfff1) | re_assemble_16 (value & -8);
+
+    case -16:
+      return (insn & ~ 0xfff9) | re_assemble_16 (value & -4);
+
+    case 16:
+      return (insn & ~ 0xffff) | re_assemble_16 (value);
+
+
+    case 17:
+      return (insn & ~ 0x1f1ffd) | re_assemble_17 (value);
+
+    case 21:
+      return (insn & ~ 0x1fffff) | re_assemble_21 (value);
+
+    case 22:
+      return (insn & ~ 0x3ff1ffd) | re_assemble_22 (value);
+
+    case 32:
+      return value;
+
+    default:
+      abort ();
+    }
+  return insn;
+}
+
+/* ====================================================================
+
+   End of functions from GNU BFD. 
+
+   ==================================================================== */
+
+/* This is where we get the opportunity to create any extra dynamic
+   sections we might need.  In our case we do not need a GOT because
+   our code is not PIC, but we do need to create a stub section.
+
+   This is significantly less complex than what we do for shared
+   libraries because, obviously, modules are not shared.  Also we have
+   no issues related to symbol visibility, lazy linking, etc.
+   The kernels dp is fixed (at symbol data_start), and we can fix up any
+   DPREL refs in the module to use that same dp value.
+   All PCREL17F refs result in a stub with the following format:
+
+  	ldil L'func_addr,%r1
+        be,n R'func_addr(%sr4,%r1)
+
+  Note, all PCREL17F get a stub, regardless of whether they are
+  local or external.  With local ones, and external ones to other
+  modules, there is a good chance we could manage without the stub.
+  I'll leave that for a future optimisation.
+ */
+
+#define LDIL_R1		0x20200000	/* ldil  L'XXX,%r1		*/
+#define BE_N_SR4_R1	0xe0202002	/* be,n  R'XXX(%sr4,%r1)	*/
+
+#define STUB_SIZE 8
+
+int
+arch_create_got(struct obj_file *f)
+{
+  hppa_file_t *hfile = (hppa_file_t *)f;
+  int i, n;
+  int stub_offset = 0;
+
+  /* Create stub section.
+   * XXX set flags, see obj_ia64.c
+   */
+  hfile->stub = obj_create_alloced_section(f, ".stub", STUB_SIZE, 0);
+
+  /* Actually this is a lot like check_relocs() in a BFD backend.  We
+     walk all sections and all their relocations and look for ones
+     that need special treatment. */
+  n = hfile->root.header.e_shnum;
+  for (i = 0; i < n; ++i)
+    {
+      struct obj_section *relsec, *symsec, *strsec;
+      Elf32_Rela *rel, *relend;
+      Elf32_Sym *symtab;
+      char const *strtab;
+
+      relsec = hfile->root.sections[i];
+      if (relsec->header.sh_type != SHT_RELA)
+	continue;
+
+      symsec = hfile->root.sections[relsec->header.sh_link];
+      strsec = hfile->root.sections[symsec->header.sh_link];
+
+      rel = (Elf32_Rela *)relsec->contents;
+      relend = rel + (relsec->header.sh_size / sizeof(Elf32_Rela));
+      symtab = (Elf32_Sym *)symsec->contents;
+      strtab = (char const *)strsec->contents;
+
+      for (; rel < relend; rel++)
+	{
+	  int need_stub = 0;
+
+	  switch (ELF32_R_TYPE(rel->r_info))
+	    {
+	    default:
+	      continue;
+
+	    case R_PARISC_PCREL17F:
+	      need_stub = 1;
+	      break;
+	    }
+
+	  if (need_stub)
+	    {
+	      Elf32_Sym *extsym;
+	      hppa_symbol_t *hsym;
+	      char const *name;
+	      int local;
+	      unsigned long symndx;
+
+	      symndx = ELF32_R_SYM(rel->r_info);
+	      extsym = symtab + symndx;
+	      if (ELF32_ST_BIND(extsym->st_info) == STB_LOCAL)
+		hsym = (hppa_symbol_t *) f->local_symtab[symndx];
+	      else
+		{
+		  if (extsym->st_name)
+		    name = strtab + extsym->st_name;
+		  else
+		    name = f->sections[extsym->st_shndx]->name;
+		  hsym = (hppa_symbol_t *)obj_find_symbol(f, name);
+		}
+	      local = hsym->root.secidx <= SHN_HIRESERVE;
+
+	      if (need_stub)
+		{
+		  hppa_stub_t *stub;
+
+		  if (hsym->stub == NULL)
+		    {
+		      stub = (hppa_stub_t *) xmalloc(sizeof(hppa_stub_t));
+		      stub->offset = stub_offset;
+		      stub->reloc_done = 0;
+		      hsym->stub = stub;
+		      stub_offset += STUB_SIZE;
+		      need_stub = 0;
+		    }
+		}
+	    }
+        }
+    }
+  if (stub_offset)
+    {
+      hfile->stub->contents = xmalloc(stub_offset);
+      hfile->stub->header.sh_size = stub_offset;
+    }
+  return 1;
+}
+
+
+enum obj_reloc
+arch_apply_relocation(struct obj_file *f,
+		      struct obj_section *targsec,
+		      struct obj_section *symsec,
+		      struct obj_symbol *sym,
+		      Elf32_Rela *rel,
+		      Elf32_Addr v)
+{
+  hppa_file_t *hfile = (hppa_file_t *) f;
+  hppa_symbol_t *hsym  = (hppa_symbol_t *) sym;
+
+  Elf32_Addr *loc = (Elf32_Addr *)(targsec->contents + rel->r_offset);
+  Elf32_Addr dot = (targsec->header.sh_addr + rel->r_offset) & ~0x03;
+  Elf32_Addr dp = hfile->dp;
+  Elf32_Word r_info = ELF32_R_TYPE(rel->r_info);
+
+  enum obj_reloc ret = obj_reloc_ok;
+  enum hppa_fsel fsel = e_fsel;	/* Avoid compiler warning */
+  unsigned int r_format;
+
+  /* Fix up the value, and determine whether we can handle this
+     relocation. */
+  switch (r_info)
+  {
+  case R_PARISC_PLABEL32:
+  case R_PARISC_DIR32:
+  case R_PARISC_DIR21L:
+  case R_PARISC_DIR14R:
+    /* Easy. */
+    break;
+
+  case R_PARISC_DPREL21L:
+  case R_PARISC_DPREL14R:
+    v -= dp;
+    break;
+
+  case R_PARISC_PCREL17F:
+    /* Find an import stub. */
+    assert(hsym->stub != NULL);
+    assert(hfile->stub != NULL);
+    /* XXX Optimise.  We may not need a stub for short branches */
+    if (!hsym->stub->reloc_done) {
+      /* Need to create the .stub entry */
+      Elf32_Addr *pstub, stubv;
+
+      pstub = (Elf32_Addr *)(hfile->stub->contents + hsym->stub->offset);
+      pstub[0] = LDIL_R1;
+      pstub[1] = BE_N_SR4_R1;
+      stubv = hppa_field_adjust(v, rel->r_addend, e_lrsel);
+      pstub[0] = hppa_rebuild_insn(pstub[0], stubv, 21);
+      stubv = hppa_field_adjust(v, rel->r_addend, e_rrsel);
+      stubv >>= 2;	/* Branch; divide by 4 */
+      pstub[1] = hppa_rebuild_insn(pstub[1], stubv, 17);
+      hsym->stub->reloc_done = 1;
+    }
+    v = hsym->stub->offset + hfile->stub->header.sh_addr;
+    break;
+
+  default:
+    return obj_reloc_unhandled;
+  }
+
+  /* Find the field selector. */
+  switch (r_info)
+    {
+    case R_PARISC_DIR32:
+    case R_PARISC_PLABEL32:
+    case R_PARISC_PCREL17F:
+      fsel = e_fsel;
+      break;
+	
+    case R_PARISC_DPREL21L:
+    case R_PARISC_DIR21L:
+      fsel = e_lrsel;
+      break;
+
+    case R_PARISC_DPREL14R:
+    case R_PARISC_DIR14R:
+      fsel = e_rrsel;
+      break;
+    }
+
+  v = hppa_field_adjust(v, rel->r_addend, fsel);
+
+  switch (r_info)
+    {
+    case R_PARISC_PCREL17F:
+    case R_PARISC_PCREL17R:
+    case R_PARISC_PCREL22F:
+      v = v - dot - 8;
+    case R_PARISC_DIR17F:
+    case R_PARISC_DIR17R:
+      /* This is a branch.  Divide the offset by four. */
+      v >>= 2;
+      break;
+    default:
+      break;
+    }
+
+  /* Find the format. */
+  switch (r_info)
+    {
+    case R_PARISC_DIR32:
+    case R_PARISC_PLABEL32:
+      r_format = 32;
+      break;
+
+    case R_PARISC_DPREL21L:
+    case R_PARISC_DIR21L:
+      r_format = 21;
+      break;
+
+    case R_PARISC_PCREL17F:
+      r_format = 17;
+      break;
+	
+    case R_PARISC_DPREL14R:
+    case R_PARISC_DIR14R:
+      r_format = 14;
+      break;
+
+    default:
+      abort();
+    }
+
+  *loc = hppa_rebuild_insn(*loc, v, r_format);
+
+  return ret;
+}
+
+int
+arch_init_module (struct obj_file *f, struct module *mod)
+{
+  return 1;
+}
+
+int
+arch_finalize_section_address(struct obj_file *f, Elf32_Addr base)
+{
+  int  i, n = f->header.e_shnum;
+
+  f->baseaddr = base;
+  for (i = 0; i < n; ++i)
+    f->sections[i]->header.sh_addr += base;
+  return 1;
+}
+
+int
+arch_archdata (struct obj_file *f, struct obj_section *sec)
+{
+  struct module_symbol *s;
+  int i;
+  hppa_file_t *hfile = (hppa_file_t *)f;
+
+  /* Initialise dp to the kernels dp (symbol data_start)
+   */
+  for (i = 0, s = ksyms; i < nksyms; i++, s++)
+    if (!strcmp((char *)s->name, "data_start"))
+      break;
+  if (i >= nksyms) {
+    error("Cannot initialise dp, 'data_start' not found\n");
+    return 1;
+  }
+  hfile->dp = s->value;
+  
+  return 0;
+}
+
diff --git a/mdk-stage1/insmod-modutils/obj/obj_hppa64.c b/mdk-stage1/insmod-modutils/obj/obj_hppa64.c
new file mode 100644
index 000000000..fe32911ff
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/obj/obj_hppa64.c
@@ -0,0 +1,686 @@
+/*
+ * hppa parisc64 specific support for Elf loading and relocation.
+ * Copyright 2000 Richard Hirst <rhirst@linuxcare.com>, Linuxcare Inc.
+ *
+ * Based on ia64 specific support which was
+ *   Copyright 2000 Mike Stephens <mike.stephens@intel.com>
+ *
+ * This file is part of the Linux modutils.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ident "$Id$"
+
+#include <string.h>
+#include <assert.h>
+#include <stdlib.h>
+
+#include <module.h>
+#include <obj.h>
+#include <util.h>
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+#ifndef TRUE
+#define TRUE  ~FALSE
+#endif
+
+/*======================================================================*/
+
+typedef struct _hppa64_opd_t
+{
+    int offset;
+    int reloc_done;
+} hppa64_opd_t;
+
+typedef struct _hppa64_stub_t
+{
+    struct _hppa64_stub_t *next;
+    Elf64_Addr addend;
+    int offset;
+    int reloc_done;
+} hppa64_stub_t;
+
+typedef struct _hppa64_got_t
+{
+    struct _hppa64_got_t *next;
+    Elf64_Addr addend;
+    int offset;
+    int reloc_done;
+} hppa64_got_t;
+
+typedef struct _hppa64_symbol_t
+{
+    struct obj_symbol root;
+    hppa64_got_t *gotent;
+    hppa64_opd_t *opdent;
+    hppa64_stub_t *stubent;
+} hppa64_symbol_t;
+
+typedef struct _hppa64_file_t
+{
+    struct obj_file root;
+    struct obj_section *got;
+    struct obj_section *opd;
+    struct obj_section *stub;
+    Elf64_Addr gp;
+    Elf64_Addr text;
+    Elf64_Addr data;
+    Elf64_Addr bss;
+} hppa64_file_t;
+
+/*
+ * XXX This stub assumes it can reach the .got entry with a +/- 8K offset
+ * from dp.  Perhaps we should use a .plt for these entries to give a
+ * greater chance of that being true.
+ *
+ *     53 7b 00 00     ldd 0(dp),dp
+ *     			R_PARISC_LTOFF14R <.got entry offset from dp>
+ *     53 61 00 20     ldd 10(dp),r1
+ *     e8 20 d0 00     bve (r1)
+ *     53 7b 00 30     ldd 18(dp),dp
+ *
+ * We need a different stub for millicode calls, which doesn't screw
+ * dp:
+ *
+ *     53 61 00 00     ldd 0(dp),r1
+ *     			R_PARISC_LTOFF14R <.got entry offset from dp>
+ *     50 21 00 20     ldd 10(r1),r1
+ *     e8 20 d0 00     bve (r1)
+ *     08 00 02 40     nop
+ *
+ */
+
+/* NOTE: to keep the code cleaner we make all stubs the same size.
+ */
+
+#define SIZEOF_STUB	16
+
+unsigned char hppa64_stub_extern[] =
+{
+       0x53, 0x7b, 0x00, 0x00,
+       0x53, 0x61, 0x00, 0x20,
+       0xe8, 0x20, 0xd0, 0x00,
+       0x53, 0x7b, 0x00, 0x30,
+};
+
+unsigned char hppa64_stub_millicode[] =
+{
+       0x53, 0x61, 0x00, 0x00,
+       0x50, 0x21, 0x00, 0x20,
+       0xe8, 0x20, 0xd0, 0x00,
+       0x08, 0x00, 0x02, 0x40,
+};
+
+/*======================================================================*/
+
+enum obj_reloc
+patch_14r(Elf64_Xword v64, Elf64_Word *p)
+{
+	Elf64_Word i = *p;
+	Elf64_Word v = (Elf64_Word)v64;
+
+	if (v & 0x80000000)
+		v |= ~0x7ff;
+	else
+		v &= 0x7ff;
+	i &= ~ 0x3fff;
+	i |=    (v & 0x1fff) << 1 |
+		(v & 0x2000) >> 13;
+	*p = i;
+
+    return obj_reloc_ok;
+}
+
+enum obj_reloc
+patch_21l(Elf64_Xword v64, Elf64_Word *p)
+{
+	Elf64_Word i = *p;
+	Elf64_Word v = (Elf64_Word)v64;
+
+	v &= 0xfffff800;
+	if (v & 0x80000000)
+		v += 0x800;
+	i &= ~ 0x1fffff;
+	i |=    (v & 0x80000000) >> 31 |
+		(v & 0x7ff00000) >> 19 |
+		(v & 0x000c0000) >> 4 |
+		(v & 0x0003e000) << 3 |
+		(v & 0x00001800) << 1;
+	*p = i;
+
+    return obj_reloc_ok;
+}
+
+
+/* All 14 bits this time...  This is used to patch the .got offset in
+ * a stub for PCREL22F.
+ */
+
+enum obj_reloc
+patch_14r2(Elf64_Xword v64, Elf64_Word *p)
+{
+	Elf64_Word i = *p;
+	Elf64_Word v = (Elf64_Word)v64;
+
+	if ((Elf64_Sxword)v64 > 0x1fffL ||
+			(Elf64_Sxword)v64 < -0x2000L)
+		return obj_reloc_overflow;
+	i &= ~ 0x3fff;
+	i |=    (v & 0x2000) >> 13 |
+		(v & 0x1fff) << 1;
+	*p = i;
+
+    return obj_reloc_ok;
+}
+
+
+enum obj_reloc
+patch_22f(Elf64_Xword v64, Elf64_Word *p)
+{
+	Elf64_Word i = *p;
+	Elf64_Word v = (Elf64_Word)v64;
+
+	if ((Elf64_Sxword)v64 > 0x800000-1 ||
+	    (Elf64_Sxword)v64 < -0x800000)
+		return obj_reloc_overflow;
+
+	i &= ~ 0x03ff1ffd;
+	i |=    (v & 0x00800000) >> 23 |
+		(v & 0x007c0000) << 3 |
+		(v & 0x0003e000) << 3 |
+		(v & 0x00001000) >> 10 |
+		(v & 0x00000ffc) << 1;
+	*p = i;
+
+    return obj_reloc_ok;
+}
+
+
+struct obj_section *
+obj_hppa64_create_alloced_section (struct obj_file *f, const char *name,
+    unsigned long align, unsigned long size, unsigned long sh_flags)
+{
+    int newidx = f->header.e_shnum++;
+    struct obj_section *sec;
+
+    f->sections = xrealloc(f->sections, (newidx+1) * sizeof(sec));
+    f->sections[newidx] = sec = arch_new_section();
+
+    memset(sec, 0, sizeof(*sec));
+    sec->header.sh_type = SHT_PROGBITS;
+    sec->header.sh_flags = sh_flags;
+    sec->header.sh_size = size;
+    sec->header.sh_addralign = align;
+    sec->name = name;
+    sec->idx = newidx;
+    if (size)
+	sec->contents = xmalloc(size);
+
+    obj_insert_section_load_order(f, sec);
+
+    return sec;
+}
+
+/*======================================================================*/
+
+struct obj_file *
+arch_new_file (void)
+{
+    hppa64_file_t *f;
+    f = xmalloc(sizeof(*f));
+    f->got = NULL;
+    f->opd = NULL;
+    f->stub = NULL;
+    return &f->root;
+}
+
+struct obj_section *
+arch_new_section (void)
+{
+    return xmalloc(sizeof(struct obj_section));
+}
+
+struct obj_symbol *
+arch_new_symbol (void)
+{
+    hppa64_symbol_t *sym;
+    sym = xmalloc(sizeof(*sym));
+    sym->gotent = NULL;
+    sym->opdent = NULL;
+    sym->stubent = NULL;
+    return &sym->root;
+}
+
+/* This may not be needed, but does no harm (copied from ia64).
+ */
+
+int
+arch_load_proc_section(struct obj_section *sec, int fp)
+{
+    switch (sec->header.sh_type)
+    {
+    case SHT_PARISC_EXT :
+	sec->contents = NULL;
+	break;
+
+    case SHT_PARISC_UNWIND :
+	if (sec->header.sh_size > 0)
+	{
+	    sec->contents = xmalloc(sec->header.sh_size);
+	    gzf_lseek(fp, sec->header.sh_offset, SEEK_SET);
+	    if (gzf_read(fp, sec->contents, sec->header.sh_size) != sec->header.sh_size)
+	    {
+		error("error reading ELF section data: %m");
+		return -1;
+	    }
+	}
+	else
+	    sec->contents = NULL;
+	break;
+    default:
+      error("Unknown section header type: %08x", sec->header.sh_type);
+      return -1;
+    }
+    return 0;
+}
+
+int
+arch_create_got(struct obj_file *f)
+{
+    hppa64_file_t *hfile = (hppa64_file_t *)f;
+    int i;
+    int n;
+    int got_offset = 0;
+    int opd_offset = 64;
+    int stub_offset = 0;
+
+    n = hfile->root.header.e_shnum;
+    for (i = 0; i < n; ++i)
+    {
+	struct obj_section *relsec, *symsec, *strsec;
+	Elf64_Rela *rel, *relend;
+	Elf64_Sym *symtab;
+	const char *strtab;
+
+	relsec = hfile->root.sections[i];
+	if (relsec->header.sh_type != SHT_RELA)
+	    continue;
+
+	symsec = hfile->root.sections[relsec->header.sh_link];
+	strsec = hfile->root.sections[symsec->header.sh_link];
+
+	rel = (Elf64_Rela *)relsec->contents;
+	relend = rel + (relsec->header.sh_size / sizeof(Elf64_Rela));
+	symtab = (Elf64_Sym *)symsec->contents;
+	strtab = (const char *)strsec->contents;
+
+	for (; rel < relend; ++rel)
+	{
+	    int need_got = FALSE;
+	    int need_opd = FALSE;
+	    int need_stub = FALSE;
+
+	    switch (ELF64_R_TYPE(rel->r_info))
+	    {
+	    default:
+		{
+		    unsigned r_info = ELF64_R_TYPE(rel->r_info);
+		    printf("r_info 0x%x not handled\n", r_info);
+		}
+		continue;
+	    case R_PARISC_LTOFF14R:
+	    case R_PARISC_LTOFF21L:
+	        /* These are simple indirect references to symbols through the
+                 * DLT.  We need to create a DLT entry for any symbols which
+                 * appears in a DLTIND relocation.
+		 */
+		need_got = TRUE;
+		break;
+	    case R_PARISC_PCREL22F:
+		/* These are function calls.  Depending on their precise
+		 * target we may need to make a stub for them.  The stub
+		 * uses the dlt, so we need to create dlt entries for
+		 * these symbols too.
+		 */
+		need_got = TRUE;
+		need_stub = TRUE;
+		break;
+	    case R_PARISC_DIR64:
+		break;
+	    case R_PARISC_FPTR64:
+		/* This is a simple OPD entry (only created for local symbols,
+		 * see below).
+		 */
+		need_opd = TRUE;
+		break;
+	    }
+
+	    if (need_got || need_opd || need_stub)
+	    {
+		Elf64_Sym     *extsym;
+		hppa64_symbol_t *isym;
+		const char    *name;
+		int            local;
+		unsigned long  symndx;
+
+		symndx = ELF64_R_SYM(rel->r_info);
+		extsym = &symtab[symndx];
+		if (ELF64_ST_BIND(extsym->st_info) == STB_LOCAL)
+		{
+		    isym = (hppa64_symbol_t *) f->local_symtab[symndx];
+		}
+		else
+		{
+		    if (extsym->st_name)
+			name = strtab + extsym->st_name;
+		    else
+			name = f->sections[extsym->st_shndx]->name;
+		    isym = (hppa64_symbol_t *)obj_find_symbol(f, name);
+		}
+		local = isym->root.secidx <= SHN_HIRESERVE;
+
+		if (need_stub)
+		{
+		    hppa64_stub_t *stub;
+
+		    for (stub = isym->stubent; stub != NULL; stub = stub->next)
+			if (stub->addend == rel->r_addend)
+			    break;
+		    if (stub == NULL)
+		    {
+			stub = (hppa64_stub_t *) xmalloc(sizeof(hppa64_stub_t));
+			stub->next = isym->stubent;
+			stub->addend = rel->r_addend;
+			stub->offset = stub_offset;
+			stub->reloc_done = FALSE;
+			isym->stubent = stub;
+			{
+			    stub_offset += SIZEOF_STUB;
+			}
+			need_stub = FALSE;
+		    }
+		}
+		if (need_got)
+		{
+		    hppa64_got_t *got;
+
+		    for (got = isym->gotent; got != NULL; got = got->next)
+			if (got->addend == rel->r_addend)
+			    break;
+		    if (got == NULL)
+		    {
+			got = (hppa64_got_t *) xmalloc(sizeof(hppa64_got_t));
+			got->next = isym->gotent;
+			got->addend = rel->r_addend;
+			got->offset = got_offset;
+			got->reloc_done = FALSE;
+			isym->gotent = got;
+			got_offset += 8;
+			need_got = FALSE;
+		    }
+		}
+		if (need_opd && local)
+		{
+		    hppa64_opd_t *opd;
+
+		    if (isym->opdent == NULL)
+		    {
+			opd = (hppa64_opd_t *) xmalloc(sizeof(hppa64_opd_t));
+			opd->offset = opd_offset;
+			opd->reloc_done = FALSE;
+			isym->opdent = opd;
+			opd_offset += 32;
+			need_opd = FALSE;
+		    }
+		}
+	    }
+	}
+    }
+
+    hfile->got = obj_hppa64_create_alloced_section(f, ".got", 8, got_offset,
+	(SHF_ALLOC | SHF_WRITE | SHF_PARISC_SHORT));
+    assert(hfile->got != NULL);
+
+    hfile->opd = obj_hppa64_create_alloced_section(f, ".opd", 16, opd_offset,
+	(SHF_ALLOC | SHF_WRITE | SHF_PARISC_SHORT));
+    assert(hfile->opd != NULL);
+
+    if (stub_offset > 0)
+    {
+	hfile->stub = obj_hppa64_create_alloced_section(f, ".stub", 16,
+	    stub_offset, (SHF_ALLOC | SHF_EXECINSTR | SHF_PARISC_SHORT));
+	assert(hfile->stub != NULL);
+    }
+
+    return 1;
+}
+
+
+/* This is a small simple version which seems to work fine.  ia64 has
+ * a much more complex algorithm.  We point dp at the end of the .got,
+ * which is the start of the .opd.
+ */
+
+int
+arch_finalize_section_address(struct obj_file *f, Elf64_Addr base)
+{
+    hppa64_file_t *hfile = (hppa64_file_t *)f;
+    int        n = f->header.e_shnum;
+    int        i;
+
+    f->baseaddr = base;
+    for (i = 0; i < n; ++i)
+	f->sections[i]->header.sh_addr += base;
+
+    /* Pick a sensible value for gp */
+    hfile->gp = hfile->got->header.sh_addr + hfile->got->header.sh_size;
+
+    return 1;
+}
+
+
+enum obj_reloc
+arch_apply_relocation(struct obj_file *f,
+		       struct obj_section *targsec,
+		       struct obj_section *symsec,
+		       struct obj_symbol *sym,
+		       Elf64_Rela *rel,
+		       Elf64_Addr v)
+{
+    hppa64_file_t *hfile = (hppa64_file_t *) f;
+    hppa64_symbol_t *isym  = (hppa64_symbol_t *) sym;
+
+    Elf64_Word  *loc = (Elf64_Word *)(targsec->contents + rel->r_offset);
+    Elf64_Addr  dot = (targsec->header.sh_addr + rel->r_offset) & ~0x03;
+
+    Elf64_Addr  got = hfile->got->header.sh_addr;
+    Elf64_Addr  gp = hfile->gp;
+
+    Elf64_Xword r_info = ELF64_R_TYPE(rel->r_info);
+
+    enum obj_reloc ret = obj_reloc_ok;
+
+    switch (r_info)
+    {
+    default:
+	ret = obj_reloc_unhandled;
+	break;
+    case R_PARISC_LTOFF14R:
+    case R_PARISC_LTOFF21L:
+	{
+	    hppa64_got_t *ge;
+
+	    assert(isym != NULL);
+	    for (ge = isym->gotent; ge != NULL && ge->addend != rel->r_addend; )
+		ge = ge->next;
+	    assert(ge != NULL);
+	    if (!ge->reloc_done)
+	    {
+		ge->reloc_done = TRUE;
+		*(Elf64_Addr *)(hfile->got->contents + ge->offset) = v;
+	    }
+	    v = got + ge->offset - gp;
+	    if (r_info == R_PARISC_LTOFF14R)
+		ret = patch_14r(v, loc);
+	    else
+		ret = patch_21l(v, loc);
+	}
+	break;
+    case R_PARISC_PCREL22F:
+	{
+	    hppa64_got_t *ge;
+
+	    assert(isym != NULL);
+	    for (ge = isym->gotent; ge != NULL && ge->addend != rel->r_addend; )
+		ge = ge->next;
+	    assert(ge != NULL);
+	    if (!ge->reloc_done)
+	    {
+		ge->reloc_done = TRUE;
+		*(Elf64_Addr *)(hfile->got->contents + ge->offset) = v;
+	    }
+	    if ((isym->root.secidx > SHN_HIRESERVE) ||
+		((Elf64_Sxword) (v - dot - 8) > 0x800000-1) ||
+		((Elf64_Sxword) (v - dot - 8) < -0x800000))
+	    {
+		hppa64_stub_t *se;
+
+		for (se = isym->stubent; se != NULL && se->addend != rel->r_addend; )
+		    se = se->next;
+		assert(se != NULL);
+		if (!se->reloc_done)
+		{
+		    /* This requires that we can get from dp to the entry in +/- 8K,
+		     * or +/- 1000 entries.  patch_14r2() will check that.
+		     * Only need these dlt entries for calls to external/far
+		     * functions, so should probably put them in a seperate section
+		     * before dlt and point dp at the section.  Change to that
+		     * scheme if we hit problems with big modules.
+		     */
+		    unsigned char *stub;
+
+		    if (!strncmp(isym->root.name, "$$", 2))
+			stub = hppa64_stub_millicode;
+		    else
+			stub = hppa64_stub_extern;
+		    se->reloc_done = TRUE;
+		    memcpy((Elf64_Addr *)(hfile->stub->contents + se->offset),
+	    			stub, SIZEOF_STUB);
+		    v = (Elf64_Addr)(hfile->got->header.sh_addr + ge->offset) - gp;
+		    ret = patch_14r2(v, (Elf64_Word *)(hfile->stub->contents + se->offset));
+		}
+		v = hfile->stub->header.sh_addr + se->offset;
+	    }
+	    v = v - dot - 8;
+	    if (ret == obj_reloc_ok)
+	        ret = patch_22f(v, loc);
+	}
+	break;
+    case R_PARISC_DIR64:
+	{
+	    loc[0] = v >> 32;
+	    loc[1] = v;
+	}
+	break;
+    case R_PARISC_FPTR64:
+	{
+	    assert(isym != NULL);
+	    if (isym->root.secidx <= SHN_HIRESERVE) /* local */
+	    {
+		assert(isym->opdent != NULL);
+		if (!isym->opdent->reloc_done)
+		{
+		    isym->opdent->reloc_done = TRUE;
+		    *(Elf64_Addr *)(hfile->opd->contents + isym->opdent->offset + 16) = v;
+		    *(Elf64_Addr *)(hfile->opd->contents + isym->opdent->offset + 24) = gp;
+		}
+		v = hfile->opd->header.sh_addr + isym->opdent->offset;
+	    }
+	    loc[0] = v >> 32;
+	    loc[1] = v;
+	}
+	break;
+    }
+    return ret;
+}
+
+int
+arch_init_module (struct obj_file *f, struct module *mod)
+{
+    hppa64_file_t *hfile = (hppa64_file_t *)f;
+    Elf64_Addr *opd = (Elf64_Addr *)(hfile->opd->contents);
+
+    opd[0] = 0;
+    opd[1] = 0;
+    if ((opd[2] = mod->init) != 0)
+    {
+	opd[3] = hfile->gp;
+	mod->init = hfile->opd->header.sh_addr;
+    }
+
+    opd[4] = 0;
+    opd[5] = 0;
+    if ((opd[6] = mod->cleanup) != 0)
+    {
+	opd[7] = hfile->gp;
+	mod->cleanup = hfile->opd->header.sh_addr + 32;
+    }
+
+    return 1;
+}
+
+/* XXX Is this relevant to parisc? */
+
+int
+arch_archdata (struct obj_file *f, struct obj_section *archdata_sec)
+{
+    hppa64_file_t *hfile = (hppa64_file_t *)f;
+    struct archdata {
+	unsigned tgt_long unw_table;
+	unsigned tgt_long segment_base;
+	unsigned tgt_long unw_start;
+	unsigned tgt_long unw_end;
+	unsigned tgt_long gp;
+    } *ad;
+    int i;
+    struct obj_section *sec;
+
+    free(archdata_sec->contents);
+    archdata_sec->contents = xmalloc(sizeof(struct archdata));
+    memset(archdata_sec->contents, 0, sizeof(struct archdata));
+    archdata_sec->header.sh_size = sizeof(struct archdata);
+
+    ad = (struct archdata *)(archdata_sec->contents);
+    ad->gp = hfile->gp;
+    ad->unw_start = 0;
+    ad->unw_end = 0;
+    ad->unw_table = 0;
+    ad->segment_base = f->sections[1]->header.sh_addr;
+    for (i = 0; i < f->header.e_shnum; ++i)
+    {
+	sec = f->sections[i];
+	if (sec->header.sh_type == SHT_PARISC_UNWIND)
+	{
+	    ad->unw_start = sec->header.sh_addr;
+	    ad->unw_end = sec->header.sh_addr + sec->header.sh_size;
+	    break;
+	}
+    }
+
+    return 0;
+}
diff --git a/mdk-stage1/insmod-modutils/obj/obj_i386.c b/mdk-stage1/insmod-modutils/obj/obj_i386.c
new file mode 100644
index 000000000..28df3448c
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/obj/obj_i386.c
@@ -0,0 +1,245 @@
+/* i386 specific support for Elf loading and relocation.
+   Copyright 1996, 1997 Linux International.
+
+   Contributed by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <string.h>
+#include <assert.h>
+
+#include <module.h>
+#include <obj.h>
+#include <util.h>
+
+
+/*======================================================================*/
+
+struct i386_got_entry
+{
+  int offset;
+  unsigned offset_done : 1;
+  unsigned reloc_done : 1;
+};
+
+struct i386_file
+{
+  struct obj_file root;
+  struct obj_section *got;
+};
+
+struct i386_symbol
+{
+  struct obj_symbol root;
+  struct i386_got_entry gotent;
+};
+
+
+/*======================================================================*/
+
+struct obj_file *
+arch_new_file (void)
+{
+  struct i386_file *f;
+  f = xmalloc(sizeof(*f));
+  f->got = NULL;
+  return &f->root;
+}
+
+struct obj_section *
+arch_new_section (void)
+{
+  return xmalloc(sizeof(struct obj_section));
+}
+
+struct obj_symbol *
+arch_new_symbol (void)
+{
+  struct i386_symbol *sym;
+  sym = xmalloc(sizeof(*sym));
+  memset(&sym->gotent, 0, sizeof(sym->gotent));
+  return &sym->root;
+}
+
+int
+arch_load_proc_section(struct obj_section *sec, int fp)
+{
+    /* Assume it's just a debugging section that we can safely
+       ignore ...  */
+    sec->contents = NULL;
+
+    return 0;
+}
+
+enum obj_reloc
+arch_apply_relocation (struct obj_file *f,
+		       struct obj_section *targsec,
+		       struct obj_section *symsec,
+		       struct obj_symbol *sym,
+		       Elf32_Rel *rel,
+		       Elf32_Addr v)
+{
+  struct i386_file *ifile = (struct i386_file *)f;
+  struct i386_symbol *isym  = (struct i386_symbol *)sym;
+
+  Elf32_Addr *loc = (Elf32_Addr *)(targsec->contents + rel->r_offset);
+  Elf32_Addr dot = targsec->header.sh_addr + rel->r_offset;
+  Elf32_Addr got = ifile->got ? ifile->got->header.sh_addr : 0;
+
+  enum obj_reloc ret = obj_reloc_ok;
+
+  switch (ELF32_R_TYPE(rel->r_info))
+    {
+    case R_386_NONE:
+      break;
+
+    case R_386_32:
+      *loc += v;
+      break;
+
+    case R_386_PLT32:
+    case R_386_PC32:
+      *loc += v - dot;
+      break;
+
+    case R_386_GLOB_DAT:
+    case R_386_JMP_SLOT:
+      *loc = v;
+      break;
+
+    case R_386_RELATIVE:
+      *loc += f->baseaddr;
+      break;
+
+    case R_386_GOTPC:
+      assert(got != 0);
+      *loc += got - dot;
+      break;
+
+    case R_386_GOT32:
+      assert(isym != NULL);
+      if (!isym->gotent.reloc_done)
+	{
+	  isym->gotent.reloc_done = 1;
+	  *(Elf32_Addr *)(ifile->got->contents + isym->gotent.offset) = v;
+	}
+      *loc += isym->gotent.offset;
+      break;
+
+    case R_386_GOTOFF:
+      assert(got != 0);
+      *loc += v - got;
+      break;
+
+    default:
+      ret = obj_reloc_unhandled;
+      break;
+    }
+
+  return ret;
+}
+
+int
+arch_create_got (struct obj_file *f)
+{
+  struct i386_file *ifile = (struct i386_file *)f;
+  int i, n, offset = 0, gotneeded = 0;
+
+  n = ifile->root.header.e_shnum;
+  for (i = 0; i < n; ++i)
+    {
+      struct obj_section *relsec, *symsec, *strsec;
+      Elf32_Rel *rel, *relend;
+      Elf32_Sym *symtab;
+      const char *strtab;
+
+      relsec = ifile->root.sections[i];
+      if (relsec->header.sh_type != SHT_REL)
+	continue;
+
+      symsec = ifile->root.sections[relsec->header.sh_link];
+      strsec = ifile->root.sections[symsec->header.sh_link];
+
+      rel = (Elf32_Rel *)relsec->contents;
+      relend = rel + (relsec->header.sh_size / sizeof(Elf32_Rel));
+      symtab = (Elf32_Sym *)symsec->contents;
+      strtab = (const char *)strsec->contents;
+
+      for (; rel < relend; ++rel)
+	{
+	  Elf32_Sym *extsym;
+	  struct i386_symbol *intsym;
+	  const char *name;
+
+	  switch (ELF32_R_TYPE(rel->r_info))
+	    {
+	    case R_386_GOTPC:
+	    case R_386_GOTOFF:
+	      gotneeded = 1;
+	    default:
+	      continue;
+
+	    case R_386_GOT32:
+	      break;
+	    }
+
+	  extsym = &symtab[ELF32_R_SYM(rel->r_info)];
+	  if (extsym->st_name)
+	    name = strtab + extsym->st_name;
+	  else
+	    name = f->sections[extsym->st_shndx]->name;
+	  intsym = (struct i386_symbol *)obj_find_symbol(&ifile->root, name);
+
+	  if (!intsym->gotent.offset_done)
+	    {
+	      intsym->gotent.offset_done = 1;
+	      intsym->gotent.offset = offset;
+	      offset += 4;
+	    }
+	}
+    }
+
+  if (offset > 0 || gotneeded)
+    ifile->got = obj_create_alloced_section(&ifile->root, ".got", 4, offset);
+
+  return 1;
+}
+
+int
+arch_init_module (struct obj_file *f, struct module *mod)
+{
+  return 1;
+}
+
+int
+arch_finalize_section_address(struct obj_file *f, Elf32_Addr base)
+{
+  int  i, n = f->header.e_shnum;
+
+  f->baseaddr = base;
+  for (i = 0; i < n; ++i)
+    f->sections[i]->header.sh_addr += base;
+  return 1;
+}
+
+int
+arch_archdata (struct obj_file *fin, struct obj_section *sec)
+{
+  return 0;
+}
diff --git a/mdk-stage1/insmod-modutils/obj/obj_ia64.c b/mdk-stage1/insmod-modutils/obj/obj_ia64.c
new file mode 100644
index 000000000..4f92c5d27
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/obj/obj_ia64.c
@@ -0,0 +1,1065 @@
+/*
+ * ia64 specific support for Elf loading and relocation.
+ * Copyright 2000 Mike Stephens <mike.stephens@intel.com>
+ *
+ * This file is part of the Linux modutils.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ident "$Id$"
+
+#include <string.h>
+#include <assert.h>
+#include <stdlib.h>
+
+#include <module.h>
+#include <obj.h>
+#include <util.h>
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+#ifndef TRUE
+#define TRUE  ~FALSE
+#endif
+
+/*======================================================================*/
+
+typedef struct _ia64_opd_t
+{
+    int offset;
+    int reloc_done;
+} ia64_opd_t;
+
+typedef struct _ia64_plt_t
+{
+    struct _ia64_plt_t *next;
+    Elf64_Addr addend;
+    int text_offset;
+    int data_offset;
+    int reloc_done;
+} ia64_plt_t;
+
+typedef struct _ia64_got_t
+{
+    struct _ia64_got_t *next;
+    Elf64_Addr addend;
+    int offset;
+    int reloc_done;
+} ia64_got_t;
+
+typedef struct _ia64_symbol_t
+{
+    struct obj_symbol root;
+    ia64_got_t *gotent;
+    ia64_opd_t *opdent;
+    ia64_plt_t *pltent;
+} ia64_symbol_t;
+
+typedef struct _ia64_file_t
+{
+    struct obj_file root;
+    struct obj_section *got;
+    struct obj_section *opd;
+    struct obj_section *pltt;
+    struct obj_section *pltd;
+    Elf64_Addr gp;
+    Elf64_Addr text;
+    Elf64_Addr data;
+    Elf64_Addr bss;
+} ia64_file_t;
+
+/*
+ * aa=gp rel address of the function descriptor in the .IA_64.pltoff section
+ */
+unsigned char ia64_plt_local[] =
+{
+    0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=aa,gp;;   */
+    0x00, 0x41, 0x3c, 0x30, 0x28, 0xc0, /*       ld8 r16=[r15],8    */
+    0x01, 0x08, 0x00, 0x84,             /*       mov r14=gp;;       */
+    0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 gp=[r15]       */
+    0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /*       mov b6=r16         */
+    0x60, 0x00, 0x80, 0x00              /*       br.few b6;;        */
+};
+
+unsigned char ia64_plt_extern[] =
+{
+    0x0b, 0x80, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r16=aa,gp;;   */
+    0xf0, 0x00, 0x40, 0x30, 0x20, 0x00, /*       ld8 r15=[r16]      */
+    0x00, 0x00, 0x04, 0x00,             /*       nop.i 0x0;;        */
+    0x0b, 0x80, 0x20, 0x1e, 0x18, 0x14, /* [MMI] ld8 r16=[r15],8;;  */
+    0x10, 0x00, 0x3c, 0x30, 0x20, 0xc0, /*       ld8 gp=[r15]       */
+    0x00, 0x09, 0x00, 0x07,             /*       mov b6=r16;;       */
+    0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0x0          */
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /*       nop.i 0x0          */
+    0x60, 0x00, 0x80, 0x00              /*       br.few b6;;        */
+};
+
+/*======================================================================*/
+
+/*
+ * return the instruction at slot in bundle
+ */
+Elf64_Xword
+obj_ia64_ins_extract_from_bundle(Elf64_Addr *bundle, Elf64_Xword slot)
+{
+    switch (slot)
+    {
+    case 0 :
+	return (*bundle >> 5) & 0x1ffffffffff;
+
+    case 1 :
+	return (((*bundle >> 46) & 0x3ffff) |
+	    (*(bundle + 1) << 18)) & 0x1ffffffffff;
+
+    case 2 :
+	return (*(bundle + 1) >> 23) & 0x1ffffffffff;
+
+    default:
+    }
+    return (-1);
+}
+
+/*
+ * insert a instruction at slot in bundle
+ */
+void
+obj_ia64_ins_insert_in_bundle(Elf64_Addr *bundle, Elf64_Xword slot, Elf64_Xword ins)
+{
+    Elf64_Xword i;
+    Elf64_Xword in = ins & 0x1ffffffffff;
+
+    switch (slot)
+    {
+    case 0 :
+	i = *bundle & 0xffffc0000000001f;
+       *bundle = i | (in << 5);
+	break;
+
+    case 1 :
+	i = *bundle & 0x00003fffffffffff;
+	*bundle = i | (in << 46);
+
+	++bundle;
+	i = *bundle & 0xffffffffff800000;
+	*bundle = i | (in >> 18);
+	break;
+
+    case 2 :
+	++bundle;
+	i = *bundle & 0x00000000007fffff;
+	*bundle = i | (in << 23);
+	break;
+    }
+}
+
+/*
+ * add a immediate 14 value to the instruction at slot in bundle
+ */
+enum obj_reloc
+obj_ia64_ins_imm14(Elf64_Xword v, Elf64_Addr *bundle, Elf64_Xword slot)
+{
+    Elf64_Xword ins;
+
+    ins = obj_ia64_ins_extract_from_bundle(bundle, slot);
+    ins &= 0xffffffee07f01fff;
+    ins |= ((v & 0x2000) << 23) | ((v & 0x1f80) << 20) | ((v & 0x007f) << 13);
+    obj_ia64_ins_insert_in_bundle(bundle, slot, ins);
+    if (((Elf64_Sxword) v > 8191) || ((Elf64_Sxword) v < -8192))
+	return obj_reloc_overflow;
+    return obj_reloc_ok;
+}
+
+/*
+ * add a immediate 22 value to the instruction at slot in bundle
+ */
+enum obj_reloc
+obj_ia64_ins_imm22(Elf64_Xword v, Elf64_Addr *bundle, Elf64_Xword slot)
+{
+    Elf64_Xword ins;
+
+    ins = obj_ia64_ins_extract_from_bundle(bundle, slot);
+    ins &= 0xffffffe000301fff;
+    ins |= ((v & 0x200000) << 15) | ((v & 0x1f0000) << 6) |
+	   ((v & 0x00ff80) << 20) | ((v & 0x00007f) << 13);
+    obj_ia64_ins_insert_in_bundle(bundle, slot, ins);
+    if (((Elf64_Sxword) v > 2097151) || ((Elf64_Sxword) v < -2097152))
+	return obj_reloc_overflow;
+    return obj_reloc_ok;
+}
+
+/*
+ * add a immediate 21 value (form 1) to the instruction at slot in bundle
+ */
+enum obj_reloc
+obj_ia64_ins_pcrel21b(Elf64_Xword v, Elf64_Addr *bundle, Elf64_Xword slot)
+{
+    Elf64_Xword ins;
+
+    ins = obj_ia64_ins_extract_from_bundle(bundle, slot);
+    ins &= 0xffffffee00001fff;
+    ins |= ((v & 0x1000000) << 12) | ((v & 0x0fffff0) << 9);
+    obj_ia64_ins_insert_in_bundle(bundle, slot, ins);
+    return obj_reloc_ok;
+}
+
+/*
+ * add a immediate 21 value (form 2) to the instruction at slot in bundle
+ */
+enum obj_reloc
+obj_ia64_ins_pcrel21m(Elf64_Xword v, Elf64_Addr *bundle, Elf64_Xword slot)
+{
+    Elf64_Xword ins;
+
+    ins = obj_ia64_ins_extract_from_bundle(bundle, slot);
+    ins &= 0xffffffee000fe03f;
+    ins |= ((v & 0x1000000) << 12) | ((v & 0x0fff800) << 9) |
+	   ((v & 0x00007f0) << 2);
+    obj_ia64_ins_insert_in_bundle(bundle, slot, ins);
+    return obj_reloc_ok;
+}
+
+/*
+ * add a immediate 21 value (form 3) to the instruction at slot in bundle
+ */
+enum obj_reloc
+obj_ia64_ins_pcrel21f(Elf64_Xword v, Elf64_Addr *bundle, Elf64_Xword slot)
+{
+    Elf64_Xword ins;
+
+    ins = obj_ia64_ins_extract_from_bundle(bundle, slot);
+    ins &= 0xffffffeffc00003f;
+    ins |= ((v & 0x1000000) << 12) | ((v & 0x0fffff0) << 2);
+    obj_ia64_ins_insert_in_bundle(bundle, slot, ins);
+    return obj_reloc_ok;
+}
+
+/*
+ * add a immediate 64 value to the instruction at slot in bundle
+ */
+enum obj_reloc
+obj_ia64_ins_imm64(Elf64_Xword v, Elf64_Addr *bundle, Elf64_Xword slot)
+{
+    Elf64_Xword ins;
+
+    assert(slot == 1);
+    ins = obj_ia64_ins_extract_from_bundle(bundle, slot);
+    ins &= 0xffffffee000101ff;
+    ins |= ((v & 0x8000000000000000) >> 28) | ((v & 0x0000000000200000)) |
+	   ((v & 0x00000000001f0000) <<  6) | ((v & 0x000000000000ff80) << 20) |
+	   ((v & 0x000000000000007f) << 13);
+    obj_ia64_ins_insert_in_bundle(bundle, slot, ins);
+    obj_ia64_ins_insert_in_bundle(bundle, ++slot, ((v & 0x7fffffffffc00000) >> 22));
+    return obj_reloc_ok;
+}
+
+/*
+ * create a plt entry
+ */
+enum obj_reloc
+obj_ia64_generate_plt(Elf64_Addr v,
+		       Elf64_Addr gp,
+		       ia64_file_t *ifile,
+		       ia64_symbol_t *isym,
+		       ia64_plt_t *pltent)
+{
+    *(Elf64_Addr *)(ifile->pltd->contents + pltent->data_offset) = v;
+    if (isym->root.secidx <= SHN_HIRESERVE)
+    {
+	/* local entry */
+	*(Elf64_Addr *)(ifile->pltd->contents + pltent->data_offset + 8) = gp;
+	memcpy((Elf64_Addr *)(ifile->pltt->contents + pltent->text_offset),
+	    ia64_plt_local, sizeof(ia64_plt_local));
+    }
+    else
+    {
+	/* external entry */
+	memcpy((Elf64_Addr *)(ifile->pltt->contents + pltent->text_offset),
+	    ia64_plt_extern, sizeof(ia64_plt_extern));
+    }
+    return obj_ia64_ins_imm22(
+	(ifile->pltd->header.sh_addr + pltent->data_offset - gp),
+	(Elf64_Addr *)(ifile->pltt->contents + pltent->text_offset), 0);
+}
+
+struct obj_section *
+obj_ia64_create_alloced_section (struct obj_file *f, const char *name,
+    unsigned long align, unsigned long size, unsigned long sh_flags)
+{
+    int newidx = f->header.e_shnum++;
+    struct obj_section *sec;
+
+    f->sections = xrealloc(f->sections, (newidx+1) * sizeof(sec));
+    f->sections[newidx] = sec = arch_new_section();
+
+    memset(sec, 0, sizeof(*sec));
+    sec->header.sh_type = SHT_PROGBITS;
+    sec->header.sh_flags = sh_flags;
+    sec->header.sh_size = size;
+    sec->header.sh_addralign = align;
+    sec->name = name;
+    sec->idx = newidx;
+    if (size)
+	sec->contents = xmalloc(size);
+
+    obj_insert_section_load_order(f, sec);
+
+    return sec;
+}
+
+/*======================================================================*/
+
+struct obj_file *
+arch_new_file (void)
+{
+    ia64_file_t *f;
+    f = xmalloc(sizeof(*f));
+    f->got = NULL;
+    f->opd = NULL;
+    f->pltt = NULL;
+    f->pltd = NULL;
+    return &f->root;
+}
+
+struct obj_section *
+arch_new_section (void)
+{
+    return xmalloc(sizeof(struct obj_section));
+}
+
+struct obj_symbol *
+arch_new_symbol (void)
+{
+    ia64_symbol_t *sym;
+    sym = xmalloc(sizeof(*sym));
+    sym->gotent = NULL;
+    sym->opdent = NULL;
+    sym->pltent = NULL;
+    return &sym->root;
+}
+
+int
+arch_load_proc_section(struct obj_section *sec, int fp)
+{
+    switch (sec->header.sh_type)
+    {
+    case SHT_IA_64_EXT :
+	sec->contents = NULL;
+	break;
+
+    case SHT_IA_64_UNWIND :
+	if (sec->header.sh_size > 0)
+	{
+	    sec->contents = xmalloc(sec->header.sh_size);
+	    gzf_lseek(fp, sec->header.sh_offset, SEEK_SET);
+	    if (gzf_read(fp, sec->contents, sec->header.sh_size) != sec->header.sh_size)
+	    {
+		error("error reading ELF section data: %m");
+		return -1;
+	    }
+	}
+	else
+	    sec->contents = NULL;
+	break;
+
+    default:
+      error("Unknown section header type: %08x", sec->header.sh_type);
+      return -1;
+    }
+    return 0;
+}
+
+int
+arch_create_got(struct obj_file *f)
+{
+    ia64_file_t *ifile = (ia64_file_t *)f;
+    int i;
+    int n;
+    int got_offset = 0;
+    int opd_offset = 32;
+    int plt_text_offset = 0;
+    int plt_data_offset = 0;
+
+    n = ifile->root.header.e_shnum;
+    for (i = 0; i < n; ++i)
+    {
+	struct obj_section *relsec, *symsec, *strsec;
+	Elf64_Rela *rel, *relend;
+	Elf64_Sym *symtab;
+	const char *strtab;
+
+	relsec = ifile->root.sections[i];
+	if (relsec->header.sh_type != SHT_RELA)
+	    continue;
+
+	symsec = ifile->root.sections[relsec->header.sh_link];
+	strsec = ifile->root.sections[symsec->header.sh_link];
+
+	rel = (Elf64_Rela *)relsec->contents;
+	relend = rel + (relsec->header.sh_size / sizeof(Elf64_Rela));
+	symtab = (Elf64_Sym *)symsec->contents;
+	strtab = (const char *)strsec->contents;
+
+	for (; rel < relend; ++rel)
+	{
+	    int need_got = FALSE;
+	    int need_opd = FALSE;
+	    int need_plt = FALSE;
+
+	    switch (ELF64_R_TYPE(rel->r_info))
+	    {
+	    default:
+		continue;
+
+	    case R_IA64_FPTR64I :       /* @fptr(sym + add), mov imm64 */
+	    case R_IA64_FPTR32LSB :     /* @fptr(sym + add), data4 LSB */
+	    case R_IA64_FPTR64LSB :     /* @fptr(sym + add), data8 LSB */
+		need_opd = TRUE;
+		break;
+
+	    case R_IA64_LTOFF22 :       /* @ltoff(sym + add), add imm22 */
+	    case R_IA64_LTOFF22X :
+	    case R_IA64_LTOFF64I :      /* @ltoff(sym + add), mov imm64 */
+		need_got = TRUE;
+		break;
+
+	    case R_IA64_LTOFF_FPTR22 :  /* @ltoff(@fptr(s+a)), imm22 */
+	    case R_IA64_LTOFF_FPTR64I : /* @ltoff(@fptr(s+a)), imm64 */
+	    case R_IA64_LTOFF_FPTR32LSB :
+	    case R_IA64_LTOFF_FPTR64LSB :
+		need_got = TRUE;
+		need_opd = TRUE;
+		break;
+
+	    case R_IA64_PLTOFF22 :      /* @pltoff(sym + add), add imm22 */
+	    case R_IA64_PLTOFF64I :     /* @pltoff(sym + add), mov imm64 */
+	    case R_IA64_PLTOFF64LSB :   /* @pltoff(sym + add), data8 LSB */
+
+	    case R_IA64_PCREL21B :      /* @pcrel(sym + add), ptb, call */
+	    case R_IA64_PCREL21M :      /* @pcrel(sym + add), chk.s */
+	    case R_IA64_PCREL21F :      /* @pcrel(sym + add), fchkf */
+		need_plt = TRUE;
+		break;
+	    }
+
+	    if (need_got || need_opd || need_plt)
+	    {
+		Elf64_Sym     *extsym;
+		ia64_symbol_t *isym;
+		const char    *name;
+		int            local;
+		unsigned long  symndx;
+
+		symndx = ELF64_R_SYM(rel->r_info);
+		extsym = &symtab[symndx];
+		if (ELF64_ST_BIND(extsym->st_info) == STB_LOCAL)
+		{
+		    isym = (ia64_symbol_t *) f->local_symtab[symndx];
+		}
+		else
+		{
+		    if (extsym->st_name)
+			name = strtab + extsym->st_name;
+		    else
+			name = f->sections[extsym->st_shndx]->name;
+		    isym = (ia64_symbol_t *)obj_find_symbol(f, name);
+		}
+		local = isym->root.secidx <= SHN_HIRESERVE;
+
+		if (need_plt)
+		{
+		    ia64_plt_t *plt;
+
+		    for (plt = isym->pltent; plt != NULL; plt = plt->next)
+			if (plt->addend == rel->r_addend)
+			    break;
+		    if (plt == NULL)
+		    {
+			plt = (ia64_plt_t *) xmalloc(sizeof(ia64_plt_t));
+			plt->next = isym->pltent;
+			plt->addend = rel->r_addend;
+			plt->text_offset = plt_text_offset;
+			plt->data_offset = plt_data_offset;
+			plt->reloc_done = FALSE;
+			isym->pltent = plt;
+			if (local)
+			{
+			    plt_text_offset += sizeof(ia64_plt_local);
+			    plt_data_offset += 16;
+			}
+			else
+			{
+			    plt_text_offset += sizeof(ia64_plt_extern);
+			    plt_data_offset += 8;
+			}
+			need_plt = FALSE;
+		    }
+		}
+		if (need_got)
+		{
+		    ia64_got_t *got;
+
+		    for (got = isym->gotent; got != NULL; got = got->next)
+			if (got->addend == rel->r_addend)
+			    break;
+		    if (got == NULL)
+		    {
+			got = (ia64_got_t *) xmalloc(sizeof(ia64_got_t));
+			got->next = isym->gotent;
+			got->addend = rel->r_addend;
+			got->offset = got_offset;
+			got->reloc_done = FALSE;
+			isym->gotent = got;
+			got_offset += 8;
+			need_got = FALSE;
+		    }
+		}
+		if (need_opd && local)
+		{
+		    ia64_opd_t *opd;
+
+		    if (isym->opdent == NULL)
+		    {
+			opd = (ia64_opd_t *) xmalloc(sizeof(ia64_opd_t));
+			opd->offset = opd_offset;
+			opd->reloc_done = FALSE;
+			isym->opdent = opd;
+			opd_offset += 16;
+			need_opd = FALSE;
+		    }
+		}
+	    }
+	}
+    }
+
+    ifile->got = obj_ia64_create_alloced_section(f, ".got", 8, got_offset,
+	(SHF_ALLOC | SHF_WRITE | SHF_IA_64_SHORT));
+    assert(ifile->got != NULL);
+
+    ifile->opd = obj_ia64_create_alloced_section(f, ".opd", 16, opd_offset,
+	(SHF_ALLOC | SHF_WRITE | SHF_IA_64_SHORT));
+    assert(ifile->opd != NULL);
+
+    if (plt_text_offset > 0)
+    {
+	ifile->pltt = obj_ia64_create_alloced_section(f, ".plt", 16,
+	    plt_text_offset, (SHF_ALLOC | SHF_EXECINSTR | SHF_IA_64_SHORT));
+	ifile->pltd = obj_ia64_create_alloced_section(f, ".IA_64.pltoff",
+	    16, plt_data_offset, (SHF_ALLOC | SHF_WRITE | SHF_IA_64_SHORT));
+	assert(ifile->pltt != NULL);
+	assert(ifile->pltd != NULL);
+    }
+
+    return 1;
+}
+
+int
+arch_finalize_section_address(struct obj_file *f, Elf64_Addr base)
+{
+    ia64_file_t *ifile = (ia64_file_t *)f;
+    Elf64_Addr min_addr = (Elf64_Addr) -1;
+    Elf64_Addr max_addr = 0;
+    Elf64_Addr min_short_addr = (Elf64_Addr) -1;
+    Elf64_Addr max_short_addr = 0;
+    Elf64_Addr gp;
+    Elf64_Addr text = (Elf64_Addr) -1;
+    Elf64_Addr data = (Elf64_Addr) -1;
+    Elf64_Addr bss = (Elf64_Addr) -1;
+    int        n = f->header.e_shnum;
+    int        i;
+
+    /*
+     * Finalize the addresses of the sections, find the min and max
+     * address of all sections marked short, and collect min and max
+     * address of any type, for use in selecting a nice gp.
+     *
+     * The algorithm used for selecting set the GP value was taken from
+     * the ld/bfd code contributed by David Mosberger-Tang <davidm@hpl.hp.com>
+     */
+    f->baseaddr = base;
+    for (i = 0; i < n; ++i)
+    {
+	Elf64_Shdr *header = &f->sections[i]->header;
+	Elf64_Addr lo;
+	Elf64_Addr hi;
+
+	header->sh_addr += base;
+	if (header->sh_flags & SHF_ALLOC)
+	{
+	    lo = header->sh_addr;
+	    hi = header->sh_addr + header->sh_size;
+	    if (hi < lo)
+		hi = (Elf64_Addr) -1;
+
+	    if (min_addr > lo)
+		min_addr = lo;
+	    if (max_addr < hi)
+		max_addr = hi;
+	    if (header->sh_flags & SHF_IA_64_SHORT)
+	    {
+		if (min_short_addr > lo)
+		    min_short_addr = lo;
+		if (max_short_addr < hi)
+		    max_short_addr = hi;
+	    }
+	    if ((header->sh_type & SHT_NOBITS) && (lo < bss))
+		bss = lo;
+	    else if ((header->sh_flags & SHF_EXECINSTR) && (lo < text))
+		text = lo;
+	    else if (lo < data)
+		data = lo;
+	}
+    }
+    /* Pick a sensible value for gp */
+
+    /* Start with just the address of the .got */
+    gp = ifile->got->header.sh_addr;
+
+    /*
+     * If it is possible to address the entire image, but we
+     * don't with the choice above, adjust.
+     */
+    if ((max_addr - min_addr < 0x400000) && (max_addr - gp <= 0x200000) &&
+	(gp - min_addr > 0x200000))
+    {
+	gp = min_addr + 0x200000;
+    }
+    else if (max_short_addr != 0)
+    {
+	/* If we don't cover all the short data, adjust */
+	if (max_short_addr - gp >= 0x200000)
+	    gp = min_short_addr + 0x200000;
+
+	/* If we're addressing stuff past the end, adjust back */
+	if (gp > max_addr)
+	    gp = max_addr - 0x200000 + 8;
+    }
+
+    /*
+     * Validate whether all SHF_IA_64_SHORT sections are within
+     * range of the chosen GP.
+     */
+    if (max_short_addr != 0)
+    {
+	if (max_short_addr - min_short_addr >= 0x400000)
+	{
+	    error("short data segment overflowed (0x%lx >= 0x400000)",
+		(unsigned long)(max_short_addr - min_short_addr));
+	    return 0;
+	}
+	else if (((gp > min_short_addr) && (gp - min_short_addr > 0x200000)) ||
+	    ((gp < max_short_addr) && (max_short_addr - gp >= 0x200000)))
+	{
+	    error("GP does not cover short data segment");
+	    return 0;
+	}
+    }
+    ifile->gp = gp;
+    ifile->text = text;
+    ifile->data = data;
+    ifile->bss = bss;
+    return 1;
+}
+
+/* Targets can be unaligned, use memcpy instead of assignment */
+#define COPY_64LSB(loc, v) \
+    do { \
+    Elf64_Xword reloc = (v); \
+    memcpy((void *)(loc), &reloc, 8); \
+    } while(0)
+#define COPY_32LSB(loc, v) \
+    do { \
+    Elf32_Xword reloc = (v); \
+    memcpy((void *)(loc), &reloc, 4); \
+    if ((v) != reloc) \
+	ret = obj_reloc_overflow; \
+    } while(0)
+
+enum obj_reloc
+arch_apply_relocation(struct obj_file *f,
+		       struct obj_section *targsec,
+		       struct obj_section *symsec,
+		       struct obj_symbol *sym,
+		       Elf64_Rela *rel,
+		       Elf64_Addr v)
+{
+    ia64_file_t *ifile = (ia64_file_t *) f;
+    ia64_symbol_t *isym  = (ia64_symbol_t *) sym;
+
+    Elf64_Addr  loc = (Elf64_Addr)(targsec->contents + rel->r_offset);
+    Elf64_Addr  dot = (targsec->header.sh_addr + rel->r_offset) & ~0x03;
+
+    Elf64_Addr  got = ifile->got->header.sh_addr;
+    Elf64_Addr  gp = ifile->gp;
+
+    Elf64_Addr *bundle = (Elf64_Addr *)(loc & ~0x03);
+    Elf64_Xword slot = loc & 0x03;
+
+    Elf64_Xword r_info = ELF64_R_TYPE(rel->r_info);
+
+    enum obj_reloc ret = obj_reloc_ok;
+
+    /* We cannot load modules compiled with -mconstant-gp */
+#ifndef EF_IA_64_CONS_GP
+#define EF_IA_64_CONS_GP 0x00000040
+#endif
+#ifndef EF_IA_64_NOFUNCDESC_CONS_GP
+#define EF_IA_64_NOFUNCDESC_CONS_GP 0x00000080
+#endif
+    if (f->header.e_flags & (EF_IA_64_CONS_GP | EF_IA_64_NOFUNCDESC_CONS_GP))
+	return obj_reloc_constant_gp;
+
+    switch (r_info)
+    {
+    case R_IA64_NONE :          /* none */
+    case R_IA64_LDXMOV :        /* Use of LTOFF22X.  */
+	break;
+
+    case R_IA64_IMM14 :         /* symbol + addend, add imm14 */
+	ret = obj_ia64_ins_imm14(v, bundle, slot);
+	break;
+
+    case R_IA64_IMM22 :         /* symbol + addend, add imm22 */
+	ret = obj_ia64_ins_imm22(v, bundle, slot);
+	break;
+
+    case R_IA64_IMM64 :         /* symbol + addend, movl imm64 */
+	ret = obj_ia64_ins_imm64(v, bundle, slot);
+	break;
+
+    case R_IA64_DIR32LSB :      /* symbol + addend, data4 LSB */
+	COPY_32LSB(loc, v);
+	break;
+
+    case R_IA64_DIR64LSB :      /* symbol + addend, data8 LSB */
+	COPY_64LSB(loc, v);
+	break;
+
+    case R_IA64_GPREL22 :       /* @gprel(sym + add), add imm22 */
+	v -= gp;
+	ret = obj_ia64_ins_imm22(v, bundle, slot);
+	break;
+
+    case R_IA64_GPREL64I :      /* @gprel(sym + add), mov imm64 */
+	v -= gp;
+	ret = obj_ia64_ins_imm64(v, bundle, slot);
+	break;
+
+    case R_IA64_GPREL32LSB :    /* @gprel(sym + add), data4 LSB */
+	COPY_32LSB(loc, v-gp);
+	break;
+
+    case R_IA64_GPREL64LSB :    /* @gprel(sym + add), data8 LSB */
+	COPY_64LSB(loc, v-gp);
+	break;
+
+    case R_IA64_LTOFF22 :       /* @ltoff(sym + add), add imm22 */
+    case R_IA64_LTOFF22X :      /* LTOFF22, relaxable.  */
+    case R_IA64_LTOFF64I :      /* @ltoff(sym + add), mov imm64 */
+	{
+	    ia64_got_t *ge;
+
+	    assert(isym != NULL);
+	    for (ge = isym->gotent; ge != NULL && ge->addend != rel->r_addend; )
+		ge = ge->next;
+	    assert(ge != NULL);
+	    if (!ge->reloc_done)
+	    {
+		ge->reloc_done = TRUE;
+		*(Elf64_Addr *)(ifile->got->contents + ge->offset) = v;
+	    }
+	    v = got + ge->offset - gp;
+	    if (r_info == R_IA64_LTOFF64I)
+		ret = obj_ia64_ins_imm64(v, bundle, slot);
+	    else
+		ret = obj_ia64_ins_imm22(v, bundle, slot);
+	}
+	break;
+
+    case R_IA64_PLTOFF22 :      /* @pltoff(sym + add), add imm22 */
+    case R_IA64_PLTOFF64I :     /* @pltoff(sym + add), mov imm64 */
+    case R_IA64_PLTOFF64LSB :   /* @pltoff(sym + add), data8 LSB */
+	{
+	    ia64_plt_t *pe;
+
+	    assert(isym != NULL);
+	    for (pe = isym->pltent; pe != NULL && pe->addend != rel->r_addend; )
+		pe = pe->next;
+	    assert(pe != NULL);
+	    if (!pe->reloc_done)
+	    {
+		pe->reloc_done = TRUE;
+		ret = obj_ia64_generate_plt(v, gp, ifile, isym, pe);
+	    }
+	    v = ifile->pltt->header.sh_addr + pe->text_offset - gp;
+	    switch (r_info)
+	    {
+	    case R_IA64_PLTOFF22 :
+		ret = obj_ia64_ins_imm22(v, bundle, slot);
+		break;
+
+	    case R_IA64_PLTOFF64I :
+		ret = obj_ia64_ins_imm64(v, bundle, slot);
+		break;
+
+	    case R_IA64_PLTOFF64LSB :
+		COPY_64LSB(loc, v);
+		break;
+	    }
+	}
+	break;
+
+    case R_IA64_FPTR64I :       /* @fptr(sym + add), mov imm64 */
+    case R_IA64_FPTR32LSB :     /* @fptr(sym + add), data4 LSB */
+    case R_IA64_FPTR64LSB :     /* @fptr(sym + add), data8 LSB */
+	assert(isym != NULL);
+	if (isym->root.secidx <= SHN_HIRESERVE)
+	{
+	    assert(isym->opdent != NULL);
+	    if (!isym->opdent->reloc_done)
+	    {
+		isym->opdent->reloc_done = TRUE;
+		*(Elf64_Addr *)(ifile->opd->contents + isym->opdent->offset) = v;
+		*(Elf64_Addr *)(ifile->opd->contents + isym->opdent->offset + 8) = gp;
+	    }
+	    v = ifile->opd->header.sh_addr + isym->opdent->offset;
+	}
+	switch (r_info)
+	{
+	case R_IA64_FPTR64I :
+	    ret = obj_ia64_ins_imm64(v, bundle, slot);
+	    break;
+
+	case R_IA64_FPTR32LSB :
+	    COPY_32LSB(loc, v);
+	    break;
+
+	case R_IA64_FPTR64LSB :     /* @fptr(sym + add), data8 LSB */
+	    /* Target can be unaligned */
+	    COPY_64LSB(loc, v);
+	    break;
+	}
+	break;
+
+    case R_IA64_PCREL21B :      /* @pcrel(sym + add), ptb, call */
+    case R_IA64_PCREL21M :      /* @pcrel(sym + add), chk.s */
+    case R_IA64_PCREL21F :      /* @pcrel(sym + add), fchkf */
+	assert(isym != NULL);
+	if ((isym->root.secidx > SHN_HIRESERVE) ||
+	   ((Elf64_Sxword) (v - dot) > 16777215) ||
+	   ((Elf64_Sxword) (v - dot) < -16777216))
+	{
+	    ia64_plt_t *pe;
+
+	    for (pe = isym->pltent; pe != NULL && pe->addend != rel->r_addend; )
+		pe = pe->next;
+	    assert(pe != NULL);
+	    if (!pe->reloc_done)
+	    {
+		pe->reloc_done = TRUE;
+		ret = obj_ia64_generate_plt(v, gp, ifile, isym, pe);
+	    }
+	    v = ifile->pltt->header.sh_addr + pe->text_offset;
+	}
+	v -= dot;
+	switch (r_info)
+	{
+	case R_IA64_PCREL21B :
+	    ret = obj_ia64_ins_pcrel21b(v, bundle, slot);
+	    break;
+
+	case R_IA64_PCREL21M :
+	    ret = obj_ia64_ins_pcrel21m(v, bundle, slot);
+	    break;
+
+	case R_IA64_PCREL21F :
+	    ret = obj_ia64_ins_pcrel21f(v, bundle, slot);
+	    break;
+	}
+	break;
+
+    case R_IA64_PCREL32LSB :    /* @pcrel(sym + add), data4 LSB */
+	COPY_32LSB(loc, v-dot);
+	break;
+
+    case R_IA64_PCREL64LSB :    /* @pcrel(sym + add), data8 LSB */
+	COPY_64LSB(loc, v-dot);
+	break;
+
+    case R_IA64_LTOFF_FPTR22 :  /* @ltoff(@fptr(s+a)), imm22 */
+    case R_IA64_LTOFF_FPTR64I : /* @ltoff(@fptr(s+a)), imm64 */
+    case R_IA64_LTOFF_FPTR32LSB : /* @ltoff(@fptr(s+a)), data4 */
+    case R_IA64_LTOFF_FPTR64LSB : /* @ltoff(@fptr(s+a)), data8 */
+	{
+	    ia64_got_t *ge;
+
+	    assert(isym != NULL);
+	    if (isym->root.secidx <= SHN_HIRESERVE)
+	    {
+		assert(isym->opdent != NULL);
+		if (!isym->opdent->reloc_done)
+		{
+		    isym->opdent->reloc_done = TRUE;
+		    *(Elf64_Addr *)(ifile->opd->contents + isym->opdent->offset) = v;
+		    *(Elf64_Addr *)(ifile->opd->contents + isym->opdent->offset + 8) = gp;
+		}
+		v = ifile->opd->header.sh_addr + isym->opdent->offset;
+	    }
+	    for (ge = isym->gotent; ge != NULL && ge->addend != rel->r_addend; )
+		ge = ge->next;
+	    assert(ge != NULL);
+	    if (!ge->reloc_done)
+	    {
+		ge->reloc_done = TRUE;
+		*(Elf64_Addr *)(ifile->got->contents + ge->offset) =  v;
+	    }
+	    v = got + ge->offset - gp;
+	    switch (r_info)
+	    {
+	    case R_IA64_LTOFF_FPTR22 :
+		ret = obj_ia64_ins_imm22(v, bundle, slot);
+		break;
+
+	    case R_IA64_LTOFF_FPTR64I :
+		ret = obj_ia64_ins_imm64(v, bundle, slot);
+		break;
+
+	    case R_IA64_LTOFF_FPTR32LSB :
+		COPY_32LSB(loc, v);
+		break;
+
+	    case R_IA64_LTOFF_FPTR64LSB :
+		COPY_64LSB(loc, v);
+		break;
+	    }
+	}
+	break;
+
+    case R_IA64_SEGREL32LSB :   /* @segrel(sym + add), data4 LSB */
+    case R_IA64_SEGREL64LSB :   /* @segrel(sym + add), data8 LSB */
+	if (targsec->header.sh_type & SHT_NOBITS)
+	    v = ifile->bss - v;
+	else if (targsec->header.sh_flags & SHF_EXECINSTR)
+	    v = ifile->text - v;
+	else
+	    v = ifile->data - v;
+	if (r_info == R_IA64_SEGREL32LSB)
+	    COPY_32LSB(loc, v);
+	else
+	    COPY_64LSB(loc, v);
+	break;
+
+    case R_IA64_SECREL32LSB :   /* @secrel(sym + add), data4 LSB */
+	COPY_32LSB(loc, targsec->header.sh_addr - v);
+	break;
+
+    case R_IA64_SECREL64LSB :   /* @secrel(sym + add), data8 LSB */
+	COPY_64LSB(loc, targsec->header.sh_addr - v);
+	break;
+
+    /*
+     * We don't handle the big-endian relocates
+     *
+     * R_IA64_DIR32MSB        symbol + addend, data4 MSB
+     * R_IA64_DIR64MSB        symbol + addend, data8 MSB
+     * R_IA64_GPREL32MSB      @gprel(sym + add), data4 MSB
+     * R_IA64_GPREL64MSB      @gprel(sym + add), data8 MSB
+     * R_IA64_PLTOFF64MSB     @pltoff(sym + add), data8 MSB
+     * R_IA64_FPTR32MSB       @fptr(sym + add), data4 MSB
+     * R_IA64_FPTR64MSB       @fptr(sym + add), data8 MSB
+     * R_IA64_PCREL32MSB      @pcrel(sym + add), data4 MSB
+     * R_IA64_PCREL64MSB      @pcrel(sym + add), data8 MSB
+     * R_IA64_SEGREL32MSB     @segrel(sym + add), data4 MSB
+     * R_IA64_SEGREL64MSB     @segrel(sym + add), data8 MSB
+     * R_IA64_SECREL32MSB     @secrel(sym + add), data4 MSB
+     * R_IA64_SECREL64MSB     @secrel(sym + add), data8 MSB
+     * R_IA64_REL32MSB        data 4 + REL
+     * R_IA64_REL64MSB        data 8 + REL
+     * R_IA64_LTV32MSB        symbol + addend, data4 MSB
+     * R_IA64_LTV64MSB        symbol + addend, data8 MSB
+     * R_IA64_IPLTMSB         dynamic reloc, imported PLT, MSB
+     */
+    default:
+    case R_IA64_REL32LSB :      /* data 4 + REL */
+    case R_IA64_REL64LSB :      /* data 8 + REL */
+    case R_IA64_LTV32LSB :      /* symbol + addend, data4 LSB */
+    case R_IA64_LTV64LSB :      /* symbol + addend, data8 LSB */
+    case R_IA64_IPLTLSB :       /* dynamic reloc, imported PLT, LSB */
+	ret = obj_reloc_unhandled;
+	break;
+    }
+    return ret;
+}
+
+int
+arch_init_module (struct obj_file *f, struct module *mod)
+{
+    ia64_file_t *ifile = (ia64_file_t *)f;
+    Elf64_Addr *opd = (Elf64_Addr *)(ifile->opd->contents);
+
+    if ((opd[0] = mod->init) != 0)
+    {
+	opd[1] = ifile->gp;
+	mod->init = ifile->opd->header.sh_addr;
+    }
+
+    if ((opd[2] = mod->cleanup) != 0)
+    {
+	opd[3] = ifile->gp;
+	mod->cleanup = ifile->opd->header.sh_addr + 16;
+    }
+
+    return 1;
+}
+
+int
+arch_archdata (struct obj_file *f, struct obj_section *archdata_sec)
+{
+    ia64_file_t *ifile = (ia64_file_t *)f;
+    struct archdata {
+	unsigned tgt_long unw_table;
+	unsigned tgt_long segment_base;
+	unsigned tgt_long unw_start;
+	unsigned tgt_long unw_end;
+	unsigned tgt_long gp;
+    } *ad;
+    int i;
+    struct obj_section *sec;
+
+    free(archdata_sec->contents);
+    archdata_sec->contents = xmalloc(sizeof(struct archdata));
+    memset(archdata_sec->contents, 0, sizeof(struct archdata));
+    archdata_sec->header.sh_size = sizeof(struct archdata);
+
+    ad = (struct archdata *)(archdata_sec->contents);
+    ad->gp = ifile->gp;
+    ad->unw_start = 0;
+    ad->unw_end = 0;
+    ad->unw_table = 0;
+    ad->segment_base = f->sections[1]->header.sh_addr;
+    for (i = 0; i < f->header.e_shnum; ++i)
+    {
+	sec = f->sections[i];
+	if (sec->header.sh_type == SHT_IA_64_UNWIND)
+	{
+	    ad->unw_start = sec->header.sh_addr;
+	    ad->unw_end = sec->header.sh_addr + sec->header.sh_size;
+	    break;
+	}
+    }
+
+    return 0;
+}
diff --git a/mdk-stage1/insmod-modutils/obj/obj_kallsyms.c b/mdk-stage1/insmod-modutils/obj/obj_kallsyms.c
new file mode 100644
index 000000000..8385fb892
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/obj/obj_kallsyms.c
@@ -0,0 +1,292 @@
+/* Build a section containing all non-stack symbols.
+   Copyright 2000 Keith Owens <kaos@ocs.com.au>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <stdlib.h>
+#include <string.h>
+#include <malloc.h>
+
+#include "obj.h"
+#include "kallsyms.h"
+#include "util.h"
+
+/*======================================================================*/
+
+#define EXPAND_BY 4096  /* Arbitrary */
+
+/* Append a string to the big list of strings */
+
+static void
+append_string (const char *s, char **strings,
+	       ElfW(Word) *strings_size, ElfW(Word) *strings_left)
+{
+    int l = strlen(s) + 1;
+    while (l > *strings_left) {
+	*strings = xrealloc(*strings, *strings_size += EXPAND_BY);
+	*strings_left += EXPAND_BY;
+    }
+    memcpy((char *)*strings+*strings_size-*strings_left, s, l);
+    *strings_left -= l;
+}
+
+
+/* Append a symbol to the big list of symbols */
+
+static void
+append_symbol (const struct kallsyms_symbol *s,
+	       struct kallsyms_symbol **symbols,
+	       ElfW(Word) *symbols_size, ElfW(Word) *symbols_left)
+{
+    int l = sizeof(*s);
+    while (l > *symbols_left) {
+	*symbols = xrealloc(*symbols, *symbols_size += EXPAND_BY);
+	*symbols_left += EXPAND_BY;
+    }
+    memcpy((char *)*symbols+*symbols_size-*symbols_left, s, l);
+    *symbols_left -= l;
+}
+
+/* qsort compare routine to sort symbols */
+
+static const char *sym_strings;
+
+static int
+symbol_compare (const void *a, const void *b)
+{
+    struct kallsyms_symbol *c = (struct kallsyms_symbol *) a;
+    struct kallsyms_symbol *d = (struct kallsyms_symbol *) b;
+
+    if (c->symbol_addr > d->symbol_addr)
+	return(1);
+    if (c->symbol_addr < d->symbol_addr)
+	return(-1);
+    return(strcmp(sym_strings+c->name_off, sym_strings+d->name_off));
+}
+
+
+/* Extract all symbols from the input obj_file, ignore ones that are
+ * no use for debugging, build an output obj_file containing only the
+ * kallsyms section.
+ *
+ * The kallsyms section is a bit unusual.  It deliberately has no
+ * relocatable data, all "pointers" are represented as byte offsets
+ * into the the section.  This means it can be stored anywhere without
+ * relocation problems.  In particular it can be stored within a kernel
+ * image, it can be stored separately from the kernel image, it can be
+ * appended to a module just before loading, it can be stored in a
+ * separate area etc.
+ *
+ * Format of the kallsyms section.
+ *
+ * Header:
+ *   Size of header.
+ *   Total size of kallsyms data, including strings.
+ *   Number of loaded sections.
+ *   Offset to first section entry from start of header.
+ *   Size of each section entry, excluding the name string.
+ *   Number of symbols.
+ *   Offset to first symbol entry from start of header.
+ *   Size of each symbol entry, excluding the name string.
+ *
+ * Section entry - one per loaded section.
+ *   Start of section[1].
+ *   Size of section.
+ *   Offset to name of section, from start of strings.
+ *   Section flags.
+ *
+ * Symbol entry - one per symbol in the input file[2].
+ *   Offset of section that owns this symbol, from start of section data.
+ *   Address of symbol within the real section[1].
+ *   Offset to name of symbol, from start of strings.
+ *
+ * Notes: [1] This is an exception to the "represent pointers as
+ *            offsets" rule, it is a value, not an offset.  The start
+ *            address of a section or a symbol is extracted from the
+ *            obj_file data which may contain absolute or relocatable
+ *            addresses.  If the addresses are relocatable then the
+ *            caller must adjust the section and/or symbol entries in
+ *            kallsyms after relocation.
+ *        [2] Only symbols that fall within loaded sections are stored.
+ */
+
+int
+obj_kallsyms (struct obj_file *fin, struct obj_file **fout_result)
+{
+    struct obj_file *fout;
+    int i, loaded = 0, *fin_to_allsym_map;
+    struct obj_section *isec, *osec;
+    struct kallsyms_header *a_hdr;
+    struct kallsyms_section *a_sec;
+    ElfW(Off) sec_off;
+    struct kallsyms_symbol *symbols = NULL, a_sym;
+    ElfW(Word) symbols_size = 0, symbols_left = 0;
+    char *strings = NULL, *p;
+    ElfW(Word) strings_size = 0, strings_left = 0;
+    ElfW(Off) file_offset;
+    static char strtab[] = "\000" KALLSYMS_SEC_NAME;
+
+    /* Create the kallsyms section.  */
+    fout = arch_new_file();
+    memset(fout, 0, sizeof(*fout));
+    fout->symbol_cmp = strcmp;
+    fout->symbol_hash = obj_elf_hash;
+    fout->load_order_search_start = &fout->load_order;
+
+    /* Copy file characteristics from input file and modify to suit */
+    memcpy(&fout->header, &fin->header, sizeof(fout->header));
+    fout->header.e_type = ET_REL;		/* Output is relocatable */
+    fout->header.e_entry = 0;			/* No entry point */
+    fout->header.e_phoff = 0;			/* No program header */
+    file_offset = sizeof(fout->header);		/* Step over Elf header */
+    fout->header.e_shoff = file_offset;		/* Section headers next */
+    fout->header.e_phentsize = 0;		/* No program header */
+    fout->header.e_phnum = 0;			/* No program header */
+    fout->header.e_shnum = KALLSYMS_IDX+1;	/* Initial, strtab, kallsyms */
+    fout->header.e_shstrndx = KALLSYMS_IDX-1;	/* strtab */
+    file_offset += fout->header.e_shentsize * fout->header.e_shnum;
+
+    /* Populate the section data for kallsyms itself */
+    fout->sections = xmalloc(sizeof(*(fout->sections))*fout->header.e_shnum);
+    memset(fout->sections, 0, sizeof(*(fout->sections))*fout->header.e_shnum);
+
+    fout->sections[0] = osec = arch_new_section();
+    memset(osec, 0, sizeof(*osec));
+    osec->header.sh_type = SHT_NULL;
+    osec->header.sh_link = SHN_UNDEF;
+
+    fout->sections[KALLSYMS_IDX-1] = osec = arch_new_section();
+    memset(osec, 0, sizeof(*osec));
+    osec->name = ".strtab";
+    osec->header.sh_type = SHT_STRTAB;
+    osec->header.sh_link = SHN_UNDEF;
+    osec->header.sh_offset = file_offset;
+    osec->header.sh_size = sizeof(strtab);
+    osec->contents = xmalloc(sizeof(strtab));
+    memcpy(osec->contents, strtab, sizeof(strtab));
+    file_offset += osec->header.sh_size;
+
+    fout->sections[KALLSYMS_IDX] = osec = arch_new_section();
+    memset(osec, 0, sizeof(*osec));
+    osec->name = KALLSYMS_SEC_NAME;
+    osec->header.sh_name = 1;			/* Offset in strtab */
+    osec->header.sh_type = SHT_PROGBITS;	/* Load it */
+    osec->header.sh_flags = SHF_ALLOC;		/* Read only data */
+    osec->header.sh_link = SHN_UNDEF;
+    osec->header.sh_addralign = sizeof(ElfW(Word));
+    file_offset = (file_offset + osec->header.sh_addralign - 1)
+	& -(osec->header.sh_addralign);
+    osec->header.sh_offset = file_offset;
+
+    /* How many loaded sections are there? */
+    for (i = 0; i < fin->header.e_shnum; ++i) {
+	if (fin->sections[i]->header.sh_flags & SHF_ALLOC)
+	    ++loaded;
+    }
+
+    /* Initial contents, header + one entry per input section.  No strings. */
+    osec->header.sh_size = sizeof(*a_hdr) + loaded*sizeof(*a_sec);
+    a_hdr = (struct kallsyms_header *) osec->contents =
+    	xmalloc(osec->header.sh_size);
+    memset(osec->contents, 0, osec->header.sh_size);
+    a_hdr->size = sizeof(*a_hdr);
+    a_hdr->sections = loaded;
+    a_hdr->section_off = a_hdr->size;
+    a_hdr->section_size = sizeof(*a_sec);
+    a_hdr->symbol_off = osec->header.sh_size;
+    a_hdr->symbol_size = sizeof(a_sym);
+    a_hdr->start = (ElfW(Addr))(~0);
+
+    /* Map input section numbers to kallsyms section offsets. */
+    sec_off = 0;	/* Offset to first kallsyms section entry */
+    fin_to_allsym_map = xmalloc(sizeof(*fin_to_allsym_map)*fin->header.e_shnum);
+    for (i = 0; i < fin->header.e_shnum; ++i) {
+	isec = fin->sections[i];
+	if (isec->header.sh_flags & SHF_ALLOC) {
+	    fin_to_allsym_map[isec->idx] = sec_off;
+	    sec_off += a_hdr->section_size;
+	}
+	else
+	    fin_to_allsym_map[isec->idx] = -1;	/* Ignore this section */
+    }
+
+    /* Copy the loaded section data. */
+    a_sec = (struct kallsyms_section *) ((char *) a_hdr + a_hdr->section_off);
+    for (i = 0; i < fin->header.e_shnum; ++i) {
+	isec = fin->sections[i];
+	if (!(isec->header.sh_flags & SHF_ALLOC))
+	    continue;
+	a_sec->start = isec->header.sh_addr;
+	a_sec->size = isec->header.sh_size;
+	a_sec->flags = isec->header.sh_flags;
+	a_sec->name_off = strings_size - strings_left;
+	append_string(isec->name, &strings, &strings_size, &strings_left);
+	if (a_sec->start < a_hdr->start)
+	    a_hdr->start = a_sec->start;
+	if (a_sec->start+a_sec->size > a_hdr->end)
+	    a_hdr->end = a_sec->start+a_sec->size;
+	++a_sec;
+    }
+
+    /* Build the kallsyms symbol table from the symbol hashes. */
+    for (i = 0; i < HASH_BUCKETS; ++i) {
+	struct obj_symbol *sym = fin->symtab[i];
+	for (sym = fin->symtab[i]; sym ; sym = sym->next) {
+	    if (!sym || sym->secidx >= fin->header.e_shnum)
+		continue;
+	    if ((a_sym.section_off = fin_to_allsym_map[sym->secidx]) == -1)
+		continue;
+	    if (strcmp(sym->name, "gcc2_compiled.") == 0 ||
+		strncmp(sym->name, "__insmod_", 9) == 0)
+		continue;
+	    a_sym.symbol_addr = sym->value;
+	    if (fin->header.e_type == ET_REL)
+		a_sym.symbol_addr += fin->sections[sym->secidx]->header.sh_addr;
+	    a_sym.name_off = strings_size - strings_left;
+	    append_symbol(&a_sym, &symbols, &symbols_size, &symbols_left);
+	    append_string(sym->name, &strings, &strings_size, &strings_left);
+	    ++a_hdr->symbols;
+	}
+    }
+    free(fin_to_allsym_map);
+
+    /* Sort the symbols into ascending order by address and name */
+    sym_strings = strings;	/* For symbol_compare */
+    qsort((char *) symbols, (unsigned) a_hdr->symbols,
+	sizeof(* symbols), symbol_compare);
+    sym_strings = NULL;
+
+    /* Put the lot together */
+    osec->header.sh_size = a_hdr->total_size =
+	a_hdr->symbol_off +
+	a_hdr->symbols*a_hdr->symbol_size +
+	strings_size - strings_left;
+    a_hdr = (struct kallsyms_header *) osec->contents =
+	xrealloc(a_hdr, a_hdr->total_size);
+    p = (char *)a_hdr + a_hdr->symbol_off;
+    memcpy(p, symbols, a_hdr->symbols*a_hdr->symbol_size);
+    free(symbols);
+    p += a_hdr->symbols*a_hdr->symbol_size;
+    a_hdr->string_off = p - (char *)a_hdr;
+    memcpy(p, strings, strings_size - strings_left);
+    free(strings);
+
+    *fout_result = fout;
+    return 0;
+}
diff --git a/mdk-stage1/insmod-modutils/obj/obj_load.c b/mdk-stage1/insmod-modutils/obj/obj_load.c
new file mode 100644
index 000000000..4db20a998
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/obj/obj_load.c
@@ -0,0 +1,354 @@
+/* Elf file reader.
+   Copyright 1996, 1997 Linux International.
+
+   Contributed by Richard Henderson <rth@tamu.edu>
+   obj_free() added by Björn Ekwall <bj0rn@blox.se> March 1999
+   Support for kallsyms Keith Owens <kaos@ocs.com.au> April 2000
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <alloca.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "obj.h"
+#include "util.h"
+
+/*======================================================================*/
+
+struct obj_file *
+obj_load (int fp, Elf32_Half e_type, const char *filename)
+{
+  struct obj_file *f;
+  ElfW(Shdr) *section_headers;
+  int shnum, i;
+  char *shstrtab;
+
+  /* Read the file header.  */
+
+  f = arch_new_file();
+  memset(f, 0, sizeof(*f));
+  f->symbol_cmp = strcmp;
+  f->symbol_hash = obj_elf_hash;
+  f->load_order_search_start = &f->load_order;
+
+  gzf_lseek(fp, 0, SEEK_SET);
+  if (gzf_read(fp, &f->header, sizeof(f->header)) != sizeof(f->header))
+    {
+      error("error reading ELF header %s: %m", filename);
+      return NULL;
+    }
+
+  if (f->header.e_ident[EI_MAG0] != ELFMAG0
+      || f->header.e_ident[EI_MAG1] != ELFMAG1
+      || f->header.e_ident[EI_MAG2] != ELFMAG2
+      || f->header.e_ident[EI_MAG3] != ELFMAG3)
+    {
+      error("%s is not an ELF file", filename);
+      return NULL;
+    }
+  if (f->header.e_ident[EI_CLASS] != ELFCLASSM
+      || f->header.e_ident[EI_DATA] != ELFDATAM
+      || f->header.e_ident[EI_VERSION] != EV_CURRENT
+      || !MATCH_MACHINE(f->header.e_machine))
+    {
+      error("ELF file %s not for this architecture", filename);
+      return NULL;
+    }
+  if (f->header.e_type != e_type && e_type != ET_NONE)
+    {
+      switch (e_type) {
+      case ET_REL:
+	error("ELF file %s not a relocatable object", filename);
+	break;
+      case ET_EXEC:
+	error("ELF file %s not an executable object", filename);
+	break;
+      default:
+	error("ELF file %s has wrong type, expecting %d got %d",
+		filename, e_type, f->header.e_type);
+	break;
+      }
+      return NULL;
+    }
+
+  /* Read the section headers.  */
+
+  if (f->header.e_shentsize != sizeof(ElfW(Shdr)))
+    {
+      error("section header size mismatch %s: %lu != %lu",
+	    filename,
+	    (unsigned long)f->header.e_shentsize,
+	    (unsigned long)sizeof(ElfW(Shdr)));
+      return NULL;
+    }
+
+  shnum = f->header.e_shnum;
+  f->sections = xmalloc(sizeof(struct obj_section *) * shnum);
+  memset(f->sections, 0, sizeof(struct obj_section *) * shnum);
+
+  section_headers = alloca(sizeof(ElfW(Shdr)) * shnum);
+  gzf_lseek(fp, f->header.e_shoff, SEEK_SET);
+  if (gzf_read(fp, section_headers, sizeof(ElfW(Shdr))*shnum) != sizeof(ElfW(Shdr))*shnum)
+    {
+      error("error reading ELF section headers %s: %m", filename);
+      return NULL;
+    }
+
+  /* Read the section data.  */
+
+  for (i = 0; i < shnum; ++i)
+    {
+      struct obj_section *sec;
+
+      f->sections[i] = sec = arch_new_section();
+      memset(sec, 0, sizeof(*sec));
+
+      sec->header = section_headers[i];
+      sec->idx = i;
+
+      switch (sec->header.sh_type)
+	{
+	case SHT_NULL:
+	case SHT_NOTE:
+	case SHT_NOBITS:
+	  /* ignore */
+	  break;
+
+	case SHT_PROGBITS:
+	case SHT_SYMTAB:
+	case SHT_STRTAB:
+	case SHT_RELM:
+	  if (sec->header.sh_size > 0)
+	    {
+	      sec->contents = xmalloc(sec->header.sh_size);
+	      gzf_lseek(fp, sec->header.sh_offset, SEEK_SET);
+	      if (gzf_read(fp, sec->contents, sec->header.sh_size) != sec->header.sh_size)
+		{
+		  error("error reading ELF section data %s: %m", filename);
+		  return NULL;
+		}
+	    }
+	  else
+	    sec->contents = NULL;
+	  break;
+
+#if SHT_RELM == SHT_REL
+	case SHT_RELA:
+	  if (sec->header.sh_size) {
+	    error("RELA relocations not supported on this architecture %s", filename);
+	    return NULL;
+	  }
+	  break;
+#else
+	case SHT_REL:
+	  if (sec->header.sh_size) {
+	    error("REL relocations not supported on this architecture %s", filename);
+	    return NULL;
+	  }
+	  break;
+#endif
+
+	default:
+	  if (sec->header.sh_type >= SHT_LOPROC)
+	    {
+	      if (arch_load_proc_section(sec, fp) < 0)
+		return NULL;
+	      break;
+	    }
+
+	  error("can't handle sections of type %ld %s",
+		(long)sec->header.sh_type, filename);
+	  return NULL;
+	}
+    }
+
+  /* Do what sort of interpretation as needed by each section.  */
+
+  shstrtab = f->sections[f->header.e_shstrndx]->contents;
+
+  for (i = 0; i < shnum; ++i)
+    {
+      struct obj_section *sec = f->sections[i];
+      sec->name = shstrtab + sec->header.sh_name;
+    }
+
+  for (i = 0; i < shnum; ++i)
+    {
+      struct obj_section *sec = f->sections[i];
+
+      /* .modinfo and .modstring should be contents only but gcc has no
+       *  attribute for that.  The kernel may have marked these sections as
+       *  ALLOC, ignore the allocate bit.
+       */
+      if (strcmp(sec->name, ".modinfo") == 0 ||
+	  strcmp(sec->name, ".modstring") == 0)
+	sec->header.sh_flags &= ~SHF_ALLOC;
+
+      if (sec->header.sh_flags & SHF_ALLOC)
+	obj_insert_section_load_order(f, sec);
+
+      switch (sec->header.sh_type)
+	{
+	case SHT_SYMTAB:
+	  {
+	    unsigned long nsym, j;
+	    char *strtab;
+	    ElfW(Sym) *sym;
+
+	    if (sec->header.sh_entsize != sizeof(ElfW(Sym)))
+	      {
+		error("symbol size mismatch %s: %lu != %lu",
+		      filename,
+		      (unsigned long)sec->header.sh_entsize,
+		      (unsigned long)sizeof(ElfW(Sym)));
+		return NULL;
+	      }
+
+	    nsym = sec->header.sh_size / sizeof(ElfW(Sym));
+	    strtab = f->sections[sec->header.sh_link]->contents;
+	    sym = (ElfW(Sym) *) sec->contents;
+
+	    /* Allocate space for a table of local symbols.  */
+	    j = f->local_symtab_size = sec->header.sh_info;
+	    f->local_symtab = xmalloc(j *= sizeof(struct obj_symbol *));
+	    memset(f->local_symtab, 0, j);
+
+	    /* Insert all symbols into the hash table.  */
+	    for (j = 1, ++sym; j < nsym; ++j, ++sym)
+	      {
+		const char *name;
+		if (sym->st_name)
+		  name = strtab+sym->st_name;
+		else
+		  name = f->sections[sym->st_shndx]->name;
+
+		obj_add_symbol(f, name, j, sym->st_info, sym->st_shndx,
+			       sym->st_value, sym->st_size);
+
+	      }
+	  }
+	break;
+	}
+    }
+
+  /* second pass to add relocation data to symbols */
+  for (i = 0; i < shnum; ++i)
+    {
+      struct obj_section *sec = f->sections[i];
+      switch (sec->header.sh_type)
+	{
+	case SHT_RELM:
+	  {
+	    unsigned long nrel, j;
+	    ElfW(RelM) *rel;
+	    struct obj_section *symtab;
+	    char *strtab;
+	    if (sec->header.sh_entsize != sizeof(ElfW(RelM)))
+	      {
+		error("relocation entry size mismatch %s: %lu != %lu",
+		      filename,
+		      (unsigned long)sec->header.sh_entsize,
+		      (unsigned long)sizeof(ElfW(RelM)));
+		return NULL;
+	      }
+
+	    nrel = sec->header.sh_size / sizeof(ElfW(RelM));
+	    rel = (ElfW(RelM) *) sec->contents;
+	    symtab = f->sections[sec->header.sh_link];
+	    strtab = f->sections[symtab->header.sh_link]->contents;
+
+	    /* Save the relocate type in each symbol entry.  */
+	    for (j = 0; j < nrel; ++j, ++rel)
+	      {
+		ElfW(Sym) *extsym;
+		struct obj_symbol *intsym;
+		unsigned long symndx;
+		symndx = ELFW(R_SYM)(rel->r_info);
+		if (symndx)
+		  {
+		    extsym = ((ElfW(Sym) *) symtab->contents) + symndx;
+		    if (ELFW(ST_BIND)(extsym->st_info) == STB_LOCAL)
+		      {
+			/* Local symbols we look up in the local table to be sure
+			   we get the one that is really intended.  */
+			intsym = f->local_symtab[symndx];
+		      }
+		    else
+		      {
+			/* Others we look up in the hash table.  */
+			const char *name;
+			if (extsym->st_name)
+			  name = strtab + extsym->st_name;
+			else
+			  name = f->sections[extsym->st_shndx]->name;
+			intsym = obj_find_symbol(f, name);
+		      }
+		    intsym->r_type = ELFW(R_TYPE)(rel->r_info);
+		  }
+	      }
+	  }
+	  break;
+	}
+    }
+
+  f->filename = xstrdup(filename);
+
+  return f;
+}
+
+void obj_free(struct obj_file *f)
+{
+	struct obj_section *sec;
+	struct obj_symbol *sym;
+	struct obj_symbol *next;
+	int i;
+	int n;
+
+	if (f->sections) {
+		n = f->header.e_shnum;
+		for (i = 0; i < n; ++i) {
+			if ((sec = f->sections[i]) != NULL) {
+				if (sec->contents)
+					free(sec->contents);
+				free(sec);
+			}
+		}
+		free(f->sections);
+	}
+
+	for (i = 0; i < HASH_BUCKETS; ++i) {
+		for (sym = f->symtab[i]; sym; sym = next) {
+			next = sym->next;
+			free(sym);
+		}
+	}
+
+	if (f->local_symtab)
+		free(f->local_symtab);
+
+	if (f->filename)
+		free((char *)(f->filename));
+
+	if (f->persist)
+		free((char *)(f->persist));
+
+	free(f);
+}
diff --git a/mdk-stage1/insmod-modutils/obj/obj_m68k.c b/mdk-stage1/insmod-modutils/obj/obj_m68k.c
new file mode 100644
index 000000000..cb485aed7
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/obj/obj_m68k.c
@@ -0,0 +1,147 @@
+/* m68k specific support for Elf loading and relocation.
+   Copyright 1996, 1997 Linux International.
+
+   Contributed by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <stddef.h>
+#include <module.h>
+#include <obj.h>
+#include <util.h>
+
+
+/*======================================================================*/
+
+struct obj_file *
+arch_new_file (void)
+{
+  return xmalloc(sizeof(struct obj_file));
+}
+
+struct obj_section *
+arch_new_section (void)
+{
+  return xmalloc(sizeof(struct obj_section));
+}
+
+struct obj_symbol *
+arch_new_symbol (void)
+{
+  return xmalloc(sizeof(struct obj_symbol));
+}
+
+int
+arch_load_proc_section(struct obj_section *sec, int fp)
+{
+    /* Assume it's just a debugging section that we can safely
+       ignore ...  */
+    sec->contents = NULL;
+
+    return 0;
+}
+
+enum obj_reloc
+arch_apply_relocation (struct obj_file *ef,
+		       struct obj_section *targsec,
+		       struct obj_section *symsec,
+		       struct obj_symbol *sym,
+		       Elf32_Rela *rel,
+		       Elf32_Addr v)
+{
+  char *loc = targsec->contents + rel->r_offset;
+  Elf32_Addr dot = targsec->header.sh_addr + rel->r_offset;
+
+  enum obj_reloc ret = obj_reloc_ok;
+
+  switch (ELF32_R_TYPE(rel->r_info))
+    {
+    case R_68K_NONE:
+      break;
+
+    case R_68K_8:
+      if (v > 0xff)
+	ret = obj_reloc_overflow;
+      *(char *)loc = v;
+      break;
+    case R_68K_16:
+      if (v > 0xffff)
+	ret = obj_reloc_overflow;
+      *(short *)loc = v;
+      break;
+    case R_68K_32:
+      *(int *)loc = v;
+      break;
+
+    case R_68K_PC8:
+      v -= dot;
+      if ((Elf32_Sword)v > 0x7f || (Elf32_Sword)v < -(Elf32_Sword)0x80)
+	ret = obj_reloc_overflow;
+      *(char *)loc = v;
+      break;
+    case R_68K_PC16:
+      v -= dot;
+      if ((Elf32_Sword)v > 0x7fff || (Elf32_Sword)v < -(Elf32_Sword)0x8000)
+	ret = obj_reloc_overflow;
+      *(short *)loc = v;
+      break;
+    case R_68K_PC32:
+      *(int *)loc = v - dot;
+      break;
+
+    case R_68K_RELATIVE:
+      *(int *)loc += ef->baseaddr;
+      break;
+
+    default:
+      ret = obj_reloc_unhandled;
+      break;
+    }
+
+  return ret;
+}
+
+int
+arch_create_got (struct obj_file *ef)
+{
+  return 1;
+}
+
+int
+arch_init_module (struct obj_file *f, struct module *mod)
+{
+  return 1;
+}
+
+int
+arch_finalize_section_address(struct obj_file *f, Elf32_Addr base)
+{
+  int  i, n = f->header.e_shnum;
+
+  f->baseaddr = base;
+  for (i = 0; i < n; ++i)
+    f->sections[i]->header.sh_addr += base;
+  return 1;
+}
+
+int
+arch_archdata (struct obj_file *fin, struct obj_section *sec)
+{
+  return 0;
+}
diff --git a/mdk-stage1/insmod-modutils/obj/obj_mips.c b/mdk-stage1/insmod-modutils/obj/obj_mips.c
new file mode 100644
index 000000000..c2315b659
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/obj/obj_mips.c
@@ -0,0 +1,238 @@
+/* MIPS specific support for Elf loading and relocation.
+   Copyright 1997, 1998 Linux International.
+   Contributed by Ralf Baechle <ralf@gnu.ai.mit.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#include <module.h>
+#include <obj.h>
+#include <util.h>
+
+
+/*======================================================================*/
+
+struct mips_hi16
+{
+  struct mips_hi16 *next;
+  Elf32_Addr *addr;
+  Elf32_Addr value;
+};
+
+struct mips_file
+{
+  struct obj_file root;
+  struct mips_hi16 *mips_hi16_list;
+};
+
+/*======================================================================*/
+
+struct obj_file *
+arch_new_file (void)
+{
+  struct mips_file *mf;
+
+  mf = xmalloc(sizeof(*mf));
+  mf->mips_hi16_list = NULL;
+
+  return (struct obj_file *) mf;
+}
+
+struct obj_section *
+arch_new_section (void)
+{
+  return xmalloc(sizeof(struct obj_section));
+}
+
+struct obj_symbol *
+arch_new_symbol (void)
+{
+  return xmalloc(sizeof(struct obj_symbol));
+}
+
+int
+arch_load_proc_section(struct obj_section *sec, int fp)
+{
+  switch (sec->header.sh_type)
+    {
+    case SHT_MIPS_DEBUG:
+    case SHT_MIPS_REGINFO:
+      /* Actually these two sections are as useless as something can be ...  */
+      sec->contents = NULL;
+      break;
+
+    case SHT_MIPS_LIBLIST:
+    case SHT_MIPS_CONFLICT:
+    case SHT_MIPS_GPTAB:
+    case SHT_MIPS_UCODE:
+    case SHT_MIPS_OPTIONS:
+    case SHT_MIPS_DWARF:
+    case SHT_MIPS_EVENTS:
+      /* These shouldn't ever be in a module file.  */
+      error("Unhandled section header type: %08x", sec->header.sh_type);
+
+    default:
+      /* We don't even know the type.  This time it might as well be a
+	 supernova.  */
+      error("Unknown section header type: %08x", sec->header.sh_type);
+      return -1;
+    }
+
+    return 0;
+}
+
+enum obj_reloc
+arch_apply_relocation (struct obj_file *f,
+		       struct obj_section *targsec,
+		       struct obj_section *symsec,
+		       struct obj_symbol *sym,
+		       Elf32_Rel *rel,
+		       Elf32_Addr v)
+{
+  struct mips_file *mf = (struct mips_file *)f;
+  Elf32_Addr *loc = (Elf32_Addr *)(targsec->contents + rel->r_offset);
+  Elf32_Addr dot = targsec->header.sh_addr + rel->r_offset;
+  enum obj_reloc ret = obj_reloc_ok;
+
+  /* _gp_disp is a magic symbol for PIC which is not supported for
+     the kernel and loadable modules.  */
+  if (strcmp(sym->name, "_gp_disp") == 0)
+	ret = obj_reloc_unhandled;
+
+  switch (ELF32_R_TYPE(rel->r_info))
+    {
+    case R_MIPS_NONE:
+      break;
+
+    case R_MIPS_32:
+      *loc += v;
+      break;
+
+    case R_MIPS_26:
+      if (v % 4)
+	ret = obj_reloc_dangerous;
+      if ((v & 0xf0000000) != ((dot + 4) & 0xf0000000))
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0x03ffffff) | ((*loc + (v >> 2)) & 0x03ffffff);
+      break;
+
+    case R_MIPS_HI16:
+      {
+	struct mips_hi16 *n;
+
+	/* We cannot relocate this one now because we don't know the value
+	   of the carry we need to add.  Save the information, and let LO16
+	   do the actual relocation.  */
+	n = (struct mips_hi16 *) xmalloc (sizeof *n);
+	n->addr = loc;
+	n->value = v;
+	n->next = mf->mips_hi16_list;
+	mf->mips_hi16_list = n;
+	break;
+      }
+
+    case R_MIPS_LO16:
+      {
+	unsigned long insnlo = *loc;
+	Elf32_Addr val, vallo;
+
+	/* Sign extend the addend we extract from the lo insn.  */
+	vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
+
+	if (mf->mips_hi16_list != NULL)
+	  {
+	    struct mips_hi16 *l;
+
+	    l = mf->mips_hi16_list;
+	    while (l != NULL)
+	      {
+		struct mips_hi16 *next;
+		unsigned long insn;
+
+		/* The value for the HI16 had best be the same. */
+		assert(v == l->value);
+
+		/* Do the HI16 relocation.  Note that we actually don't
+		   need to know anything about the LO16 itself, except where
+		   to find the low 16 bits of the addend needed by the LO16.  */
+		insn = *l->addr;
+		val = ((insn & 0xffff) << 16) + vallo;
+		val += v;
+
+		/* Account for the sign extension that will happen in the
+		   low bits.  */
+		val = ((val >> 16) + ((val & 0x8000) != 0)) & 0xffff;
+
+		insn = (insn &~ 0xffff) | val;
+		*l->addr = insn;
+
+		next = l->next;
+		free(l);
+		l = next;
+	      }
+
+	    mf->mips_hi16_list = NULL;
+	  }
+
+	/* Ok, we're done with the HI16 relocs.  Now deal with the LO16.  */
+	val = v + vallo;
+	insnlo = (insnlo & ~0xffff) | (val & 0xffff);
+	*loc = insnlo;
+	break;
+      }
+
+    default:
+      ret = obj_reloc_unhandled;
+      break;
+    }
+
+  return ret;
+}
+
+int
+arch_create_got (struct obj_file *f)
+{
+  return 1;
+}
+
+int
+arch_init_module (struct obj_file *f, struct module *mod)
+{
+  return 1;
+}
+
+int
+arch_finalize_section_address(struct obj_file *f, Elf32_Addr base)
+{
+  int  i, n = f->header.e_shnum;
+
+  f->baseaddr = base;
+  for (i = 0; i < n; ++i)
+    f->sections[i]->header.sh_addr += base;
+  return 1;
+}
+
+int
+arch_archdata (struct obj_file *fin, struct obj_section *sec)
+{
+  return 0;
+}
diff --git a/mdk-stage1/insmod-modutils/obj/obj_ppc.c b/mdk-stage1/insmod-modutils/obj/obj_ppc.c
new file mode 100644
index 000000000..89bb8e46b
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/obj/obj_ppc.c
@@ -0,0 +1,255 @@
+/* PowerPC specific support for Elf loading and relocation.
+   Copyright 1996, 1997 Linux International.
+
+   Adapted by Paul Mackerras <paulus@cs.anu.edu.au> from the
+   obj-sparc.c and obj-alpha.c files.
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <stddef.h>
+#include <module.h>
+#include <obj.h>
+#include <util.h>
+#include <assert.h>
+
+
+/*======================================================================*/
+
+/*
+ * Unfortunately, the bl (branch-and-link) instruction used for
+ * procedure calls on the PowerPC can only reach +/- 32MB from the
+ * current instruction.  If the module is loaded far enough away from
+ * the main kernel text (or other modules) that this limit is
+ * exceeded, we have to redirect procedure calls via a procedure
+ * linkage table (PLT).  Each entry in the PLT contains instructions
+ * to put the address of the procedure in a register and jump to it.
+ */
+
+typedef unsigned int instruction;	/* a powerpc instruction (4 bytes) */
+
+struct ppc_plt_entry
+{
+  struct ppc_plt_entry *next;
+  ElfW(Addr) addend;
+  int offset;
+  int inited;
+};
+
+struct ppc_file
+{
+  struct obj_file file;
+  struct obj_section *plt;
+};
+
+struct ppc_symbol
+{
+  struct obj_symbol sym;
+  struct ppc_plt_entry *plt_entries;
+};
+
+struct obj_file *
+arch_new_file (void)
+{
+  struct ppc_file *f;
+
+  f = xmalloc(sizeof(struct ppc_file));
+  f->plt = NULL;
+  return &f->file;
+}
+
+struct obj_section *
+arch_new_section (void)
+{
+  return xmalloc(sizeof(struct obj_section));
+}
+
+struct obj_symbol *
+arch_new_symbol (void)
+{
+  struct ppc_symbol *p;
+
+  p = xmalloc(sizeof(struct ppc_symbol));
+  p->plt_entries = NULL;
+  return &p->sym;
+}
+
+int
+arch_load_proc_section(struct obj_section *sec, int fp)
+{
+    /* Assume it's just a debugging section that we can safely
+       ignore ...  */
+    sec->contents = NULL;
+
+    return 0;
+}
+
+enum obj_reloc
+arch_apply_relocation (struct obj_file *ef,
+		       struct obj_section *targsec,
+		       struct obj_section *symsec,
+		       struct obj_symbol *sym,
+		       Elf32_Rela *rel,
+		       Elf32_Addr v)
+{
+  Elf32_Addr *loc = (Elf32_Addr *)(targsec->contents + rel->r_offset);
+  Elf32_Addr dot = targsec->header.sh_addr + rel->r_offset;
+  struct ppc_file *pf = (struct ppc_file *) ef;
+  struct ppc_symbol *psym = (struct ppc_symbol *) sym;
+  struct ppc_plt_entry *pe;
+  instruction *ip;
+
+  enum obj_reloc ret = obj_reloc_ok;
+
+  switch (ELF32_R_TYPE(rel->r_info))
+    {
+    case R_PPC_ADDR16_HA:
+      *(unsigned short *)loc = (v + 0x8000) >> 16;
+      break;
+
+    case R_PPC_ADDR16_HI:
+      *(unsigned short *)loc = v >> 16;
+      break;
+
+    case R_PPC_ADDR16_LO:
+      *(unsigned short *)loc = v;
+      break;
+
+    case R_PPC_REL24:
+      /* find the plt entry and initialize it if necessary */
+      assert(psym != NULL);
+      for (pe = psym->plt_entries; pe != NULL && pe->addend != rel->r_addend; )
+	pe = pe->next;
+      assert(pe != NULL);
+      if (!pe->inited)
+	{
+	  ip = (instruction *) (pf->plt->contents + pe->offset);
+	  ip[0] = 0x3d600000 + ((v + 0x8000) >> 16);  /* lis r11,sym@ha */
+	  ip[1] = 0x396b0000 + (v & 0xffff);	      /* addi r11,r11,sym@l */
+	  ip[2] = 0x7d6903a6;			      /* mtctr r11 */
+	  ip[3] = 0x4e800420;			      /* bctr */
+	  pe->inited = 1;
+	}
+
+      v -= dot;
+      if ((int)v < -0x02000000 || (int)v >= 0x02000000)
+	{
+	  /* go via the plt */
+	  v = pf->plt->header.sh_addr + pe->offset - dot;
+	}
+      if (v & 3)
+	ret = obj_reloc_dangerous;
+      *loc = (*loc & ~0x03fffffc) | (v & 0x03fffffc);
+      break;
+
+    case R_PPC_REL32:
+      *loc = v - dot;
+      break;
+
+    case R_PPC_ADDR32:
+      *loc = v;
+      break;
+
+    default:
+      ret = obj_reloc_unhandled;
+      break;
+    }
+
+  return ret;
+}
+
+int
+arch_create_got (struct obj_file *f)
+{
+  struct ppc_file *pf = (struct ppc_file *) f;
+  int i, offset;
+  struct obj_section *sec, *syms, *strs;
+  ElfW(Rela) *rel, *relend;
+  ElfW(Sym) *symtab, *extsym;
+  const char *strtab, *name;
+  struct ppc_symbol *intsym;
+  struct ppc_plt_entry *pe;
+
+  offset = 0;
+  for (i = 0; i < f->header.e_shnum; ++i)
+    {
+      sec = f->sections[i];
+      if (sec->header.sh_type != SHT_RELM)
+	continue;
+      syms = f->sections[sec->header.sh_link];
+      strs = f->sections[syms->header.sh_link];
+
+      rel = (ElfW(RelM) *) sec->contents;
+      relend = rel + (sec->header.sh_size / sizeof(ElfW(RelM)));
+      symtab = (ElfW(Sym) *) syms->contents;
+      strtab = (const char *) strs->contents;
+
+      for (; rel < relend; ++rel)
+	{
+	  if (ELF32_R_TYPE(rel->r_info) != R_PPC_REL24)
+	    continue;
+	  extsym = &symtab[ELF32_R_SYM(rel->r_info)];
+	  if (extsym->st_name)
+	    name = strtab + extsym->st_name;
+	  else
+	    name = f->sections[extsym->st_shndx]->name;
+	  intsym = (struct ppc_symbol *) obj_find_symbol(f, name);
+
+	  for (pe = intsym->plt_entries; pe != NULL; pe = pe->next)
+	    if (pe->addend == rel->r_addend)
+	      break;
+	  if (pe == NULL)
+	    {
+	      pe = xmalloc(sizeof(struct ppc_plt_entry));
+	      pe->next = intsym->plt_entries;
+	      pe->addend = rel->r_addend;
+	      pe->offset = offset;
+	      pe->inited = 0;
+	      intsym->plt_entries = pe;
+	      offset += 16;
+	    }
+	}
+    }
+
+  pf->plt = obj_create_alloced_section(f, ".plt", 16, offset);
+
+  return 1;
+}
+
+int
+arch_init_module (struct obj_file *f, struct module *mod)
+{
+  return 1;
+}
+
+int
+arch_finalize_section_address(struct obj_file *f, Elf32_Addr base)
+{
+  int  i, n = f->header.e_shnum;
+
+  f->baseaddr = base;
+  for (i = 0; i < n; ++i)
+    f->sections[i]->header.sh_addr += base;
+  return 1;
+}
+
+int
+arch_archdata (struct obj_file *fin, struct obj_section *sec)
+{
+  return 0;
+}
diff --git a/mdk-stage1/insmod-modutils/obj/obj_reloc.c b/mdk-stage1/insmod-modutils/obj/obj_reloc.c
new file mode 100644
index 000000000..f5f2de90d
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/obj/obj_reloc.c
@@ -0,0 +1,435 @@
+/* Elf relocation routines.
+   Copyright 1996, 1997 Linux International.
+
+   Contributed by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <string.h>
+#include <assert.h>
+#include <alloca.h>
+
+#include <obj.h>
+#include <util.h>
+
+/*======================================================================*/
+
+int
+obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
+		 const char *string)
+{
+  struct obj_string_patch_struct *p;
+  struct obj_section *strsec;
+  size_t len = strlen(string)+1;
+  char *loc;
+
+  p = xmalloc(sizeof(*p));
+  p->next = f->string_patches;
+  p->reloc_secidx = secidx;
+  p->reloc_offset = offset;
+  f->string_patches = p;
+
+  strsec = obj_find_section(f, ".kstrtab");
+  if (strsec == NULL)
+    {
+      strsec = obj_create_alloced_section(f, ".kstrtab", 1, len);
+      p->string_offset = 0;
+      loc = strsec->contents;
+    }
+  else
+    {
+      p->string_offset = strsec->header.sh_size;
+      loc = obj_extend_section(strsec, len);
+    }
+  memcpy(loc, string, len);
+
+  return 1;
+}
+
+int
+obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
+		 struct obj_symbol *sym)
+{
+  struct obj_symbol_patch_struct *p;
+
+  p = xmalloc(sizeof(*p));
+  p->next = f->symbol_patches;
+  p->reloc_secidx = secidx;
+  p->reloc_offset = offset;
+  p->sym = sym;
+  f->symbol_patches = p;
+
+  return 1;
+}
+
+int
+obj_check_undefineds(struct obj_file *f, int quiet)
+{
+  unsigned long i;
+  int ret = 1;
+
+  for (i = 0; i < HASH_BUCKETS; ++i)
+    {
+      struct obj_symbol *sym;
+      for (sym = f->symtab[i]; sym ; sym = sym->next)
+	if (sym->secidx == SHN_UNDEF)
+	  {
+	    if (ELFW(ST_BIND)(sym->info) == STB_WEAK)
+	      {
+		sym->secidx = SHN_ABS;
+		sym->value = 0;
+	      }
+	    else if (sym->r_type) /* assumes R_arch_NONE is 0 on all arch */
+	      {
+		if (!quiet)
+			error("unresolved symbol %s", sym->name);
+		ret = 0;
+	      }
+	  }
+    }
+
+  return ret;
+}
+
+void
+obj_clear_undefineds(struct obj_file *f)
+{
+  unsigned long i;
+  struct obj_symbol *sym;
+  for (i = 0; i < HASH_BUCKETS; ++i)
+    {
+      for (sym = f->symtab[i]; sym ; sym = sym->next)
+	if (sym->secidx == SHN_UNDEF)
+	  {
+	    sym->secidx = SHN_ABS;
+	    sym->value = 0;
+	  }
+    }
+}
+
+void
+obj_allocate_commons(struct obj_file *f)
+{
+  struct common_entry
+  {
+    struct common_entry *next;
+    struct obj_symbol *sym;
+  } *common_head = NULL;
+
+  unsigned long i;
+
+  for (i = 0; i < HASH_BUCKETS; ++i)
+    {
+      struct obj_symbol *sym;
+      for (sym = f->symtab[i]; sym ; sym = sym->next)
+	if (sym->secidx == SHN_COMMON)
+	  {
+	    /* Collect all COMMON symbols and sort them by size so as to
+	       minimize space wasted by alignment requirements.  */
+	    {
+	      struct common_entry **p, *n;
+	      for (p = &common_head; *p ; p = &(*p)->next)
+		if (sym->size <= (*p)->sym->size)
+		  break;
+
+	      n = alloca(sizeof(*n));
+	      n->next = *p;
+	      n->sym = sym;
+	      *p = n;
+	    }
+	  }
+    }
+
+  for (i = 1; i < f->local_symtab_size; ++i)
+    {
+      struct obj_symbol *sym = f->local_symtab[i];
+      if (sym && sym->secidx == SHN_COMMON)
+	{
+	  struct common_entry **p, *n;
+	  for (p = &common_head; *p ; p = &(*p)->next)
+	    if (sym == (*p)->sym)
+	      break;
+	    else if (sym->size < (*p)->sym->size)
+	      {
+		n = alloca(sizeof(*n));
+		n->next = *p;
+		n->sym = sym;
+		*p = n;
+		break;
+	      }
+	}
+    }
+
+  if (common_head)
+    {
+      /* Find the bss section.  */
+      for (i = 0; i < f->header.e_shnum; ++i)
+	if (f->sections[i]->header.sh_type == SHT_NOBITS)
+	  break;
+
+      /* If for some reason there hadn't been one, create one.  */
+      if (i == f->header.e_shnum)
+	{
+	  struct obj_section *sec;
+
+	  f->sections = xrealloc(f->sections, (i+1) * sizeof(sec));
+	  f->sections[i] = sec = arch_new_section();
+	  f->header.e_shnum = i+1;
+
+	  memset(sec, 0, sizeof(*sec));
+	  sec->header.sh_type = SHT_PROGBITS;
+	  sec->header.sh_flags = SHF_WRITE|SHF_ALLOC;
+	  sec->name = ".bss";
+	  sec->idx = i;
+	}
+
+      /* Allocate the COMMONS.  */
+      {
+	ElfW(Addr) bss_size = f->sections[i]->header.sh_size;
+	ElfW(Addr) max_align = f->sections[i]->header.sh_addralign;
+	struct common_entry *c;
+
+	for (c = common_head; c ; c = c->next)
+	  {
+	    ElfW(Addr) align = c->sym->value;
+
+	    if (align > max_align)
+	      max_align = align;
+	    if (bss_size & (align - 1))
+	      bss_size = (bss_size | (align - 1)) + 1;
+
+	    c->sym->secidx = i;
+	    c->sym->value = bss_size;
+
+	    bss_size += c->sym->size;
+	  }
+
+	f->sections[i]->header.sh_size = bss_size;
+	f->sections[i]->header.sh_addralign = max_align;
+      }
+    }
+
+  /* For the sake of patch relocation and parameter initialization,
+     allocate zeroed data for NOBITS sections now.  Note that after
+     this we cannot assume NOBITS are really empty.  */
+  for (i = 0; i < f->header.e_shnum; ++i)
+    {
+      struct obj_section *s = f->sections[i];
+      if (s->header.sh_type == SHT_NOBITS)
+	{
+	  if (s->header.sh_size)
+	    s->contents = memset(xmalloc(s->header.sh_size),
+				 0, s->header.sh_size);
+	  else
+	    s->contents = NULL;
+	  s->header.sh_type = SHT_PROGBITS;
+	}
+    }
+}
+
+unsigned long
+obj_load_size (struct obj_file *f)
+{
+  unsigned long dot = 0;
+  struct obj_section *sec;
+
+  /* Finalize the positions of the sections relative to one another.  */
+
+  for (sec = f->load_order; sec ; sec = sec->load_next)
+    {
+      ElfW(Addr) align;
+
+      align = sec->header.sh_addralign;
+      if (align && (dot & (align - 1)))
+	dot = (dot | (align - 1)) + 1;
+
+      sec->header.sh_addr = dot;
+      dot += sec->header.sh_size;
+    }
+
+  return dot;
+}
+
+int
+obj_relocate (struct obj_file *f, ElfW(Addr) base)
+{
+  int i, n = f->header.e_shnum;
+  int ret = 1;
+
+  /* Finalize the addresses of the sections.  */
+
+  arch_finalize_section_address(f, base);
+
+  /* And iterate over all of the relocations.  */
+
+  for (i = 0; i < n; ++i)
+    {
+      struct obj_section *relsec, *symsec, *targsec, *strsec;
+      ElfW(RelM) *rel, *relend;
+      ElfW(Sym) *symtab;
+      const char *strtab;
+
+      relsec = f->sections[i];
+      if (relsec->header.sh_type != SHT_RELM)
+	continue;
+
+      symsec = f->sections[relsec->header.sh_link];
+      targsec = f->sections[relsec->header.sh_info];
+      strsec = f->sections[symsec->header.sh_link];
+
+      rel = (ElfW(RelM) *)relsec->contents;
+      relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
+      symtab = (ElfW(Sym) *)symsec->contents;
+      strtab = (const char *)strsec->contents;
+
+      for (; rel < relend; ++rel)
+	{
+	  ElfW(Addr) value = 0;
+	  struct obj_symbol *intsym = NULL;
+	  unsigned long symndx;
+	  ElfW(Sym) *extsym = 0;
+	  const char *errmsg;
+
+	  /* Attempt to find a value to use for this relocation.  */
+
+	  symndx = ELFW(R_SYM)(rel->r_info);
+	  if (symndx)
+	    {
+	      /* Note we've already checked for undefined symbols.  */
+
+	      extsym = &symtab[symndx];
+	      if (ELFW(ST_BIND)(extsym->st_info) == STB_LOCAL)
+		{
+		  /* Local symbols we look up in the local table to be sure
+		     we get the one that is really intended.  */
+		  intsym = f->local_symtab[symndx];
+		}
+	      else
+		{
+		  /* Others we look up in the hash table.  */
+		  const char *name;
+		  if (extsym->st_name)
+		    name = strtab + extsym->st_name;
+		  else
+		    name = f->sections[extsym->st_shndx]->name;
+		  intsym = obj_find_symbol(f, name);
+		}
+
+	      value = obj_symbol_final_value(f, intsym);
+	    }
+
+#if SHT_RELM == SHT_RELA
+#if defined(__alpha__) && defined(AXP_BROKEN_GAS)
+	  /* Work around a nasty GAS bug, that is fixed as of 2.7.0.9.  */
+	  if (!extsym || !extsym->st_name ||
+	      ELFW(ST_BIND)(extsym->st_info) != STB_LOCAL)
+#endif
+	  value += rel->r_addend;
+#endif
+
+	  /* Do it! */
+	  switch (arch_apply_relocation(f,targsec,symsec,intsym,rel,value))
+	    {
+	    case obj_reloc_ok:
+	      break;
+
+	    case obj_reloc_overflow:
+	      errmsg = "Relocation overflow";
+	      goto bad_reloc;
+	    case obj_reloc_dangerous:
+	      errmsg = "Dangerous relocation";
+	      goto bad_reloc;
+	    case obj_reloc_unhandled:
+	      errmsg = "Unhandled relocation";
+	      goto bad_reloc;
+	    case obj_reloc_constant_gp:
+	      errmsg = "Modules compiled with -mconstant-gp cannot be loaded";
+	      goto bad_reloc;
+	    bad_reloc:
+	      if (extsym)
+		{
+		  error("%s of type %ld for %s", errmsg,
+			(long)ELFW(R_TYPE)(rel->r_info),
+			strtab + extsym->st_name);
+		}
+	      else
+		{
+		  error("%s of type %ld", errmsg,
+			(long)ELFW(R_TYPE)(rel->r_info));
+		}
+	      ret = 0;
+	      break;
+	    }
+	}
+    }
+
+  /* Finally, take care of the patches.  */
+
+  if (f->string_patches)
+    {
+      struct obj_string_patch_struct *p;
+      struct obj_section *strsec;
+      ElfW(Addr) strsec_base;
+      strsec = obj_find_section(f, ".kstrtab");
+      strsec_base = strsec->header.sh_addr;
+
+      for (p = f->string_patches; p ; p = p->next)
+	{
+	  struct obj_section *targsec = f->sections[p->reloc_secidx];
+	  *(ElfW(Addr) *)(targsec->contents + p->reloc_offset)
+	    = strsec_base + p->string_offset;
+	}
+    }
+
+  if (f->symbol_patches)
+    {
+      struct obj_symbol_patch_struct *p;
+
+      for (p = f->symbol_patches; p; p = p->next)
+	{
+	  struct obj_section *targsec = f->sections[p->reloc_secidx];
+	  *(ElfW(Addr) *)(targsec->contents + p->reloc_offset)
+	    = obj_symbol_final_value(f, p->sym);
+	}
+    }
+
+  return ret;
+}
+
+int
+obj_create_image (struct obj_file *f, char *image)
+{
+  struct obj_section *sec;
+  ElfW(Addr) base = f->baseaddr;
+
+  for (sec = f->load_order; sec ; sec = sec->load_next)
+    {
+      char *secimg;
+
+      if (sec->contents == 0)
+	continue;
+
+      secimg = image + (sec->header.sh_addr - base);
+
+      /* Note that we allocated data for NOBITS sections earlier.  */
+      memcpy(secimg, sec->contents, sec->header.sh_size);
+    }
+
+  return 1;
+}
diff --git a/mdk-stage1/insmod-modutils/obj/obj_s390.c b/mdk-stage1/insmod-modutils/obj/obj_s390.c
new file mode 100644
index 000000000..3da72e771
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/obj/obj_s390.c
@@ -0,0 +1,245 @@
+/* S/390 specific support for Elf loading and relocation.
+   Copyright 1996, 1997 Linux International.
+
+   Contributed by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <string.h>
+#include <assert.h>
+
+#include <module.h>
+#include <obj.h>
+#include <util.h>
+
+
+/*======================================================================*/
+
+struct s390_got_entry
+{
+  int offset;
+  unsigned offset_done : 1;
+  unsigned reloc_done : 1;
+};
+
+struct s390_file
+{
+  struct obj_file root;
+  struct obj_section *got;
+};
+
+struct s390_symbol
+{
+  struct obj_symbol root;
+  struct s390_got_entry gotent;
+};
+
+
+/*======================================================================*/
+
+struct obj_file *
+arch_new_file (void)
+{
+  struct s390_file *f;
+  f = xmalloc(sizeof(*f));
+  f->got = NULL;
+  return &f->root;
+}
+
+struct obj_section *
+arch_new_section (void)
+{
+  return xmalloc(sizeof(struct obj_section));
+}
+
+struct obj_symbol *
+arch_new_symbol (void)
+{
+  struct s390_symbol *sym;
+  sym = xmalloc(sizeof(*sym));
+  memset(&sym->gotent, 0, sizeof(sym->gotent));
+  return &sym->root;
+}
+
+int
+arch_load_proc_section(struct obj_section *sec, int fp)
+{
+    /* Assume it's just a debugging section that we can safely
+       ignore ...  */
+    sec->contents = NULL;
+
+    return 0;
+}
+
+enum obj_reloc
+arch_apply_relocation (struct obj_file *f,
+		       struct obj_section *targsec,
+		       struct obj_section *symsec,
+		       struct obj_symbol *sym,
+		       Elf32_Rela *rel,
+		       Elf32_Addr v)
+{
+  struct s390_file *ifile = (struct s390_file *)f;
+  struct s390_symbol *isym  = (struct s390_symbol *)sym;
+
+  Elf32_Addr *loc = (Elf32_Addr *)(targsec->contents + rel->r_offset);
+  Elf32_Addr dot = targsec->header.sh_addr + rel->r_offset;
+  Elf32_Addr got = ifile->got ? ifile->got->header.sh_addr : 0;
+
+  enum obj_reloc ret = obj_reloc_ok;
+
+  switch (ELF32_R_TYPE(rel->r_info))
+    {
+    case R_390_NONE:
+      break;
+
+    case R_390_32:
+      *loc += v;
+      break;
+
+    case R_390_PLT32:
+    case R_390_PC32:
+      *loc += v - dot;
+      break;
+
+    case R_390_GLOB_DAT:
+    case R_390_JMP_SLOT:
+      *loc = v;
+      break;
+
+    case R_390_RELATIVE:
+      *loc += f->baseaddr;
+      break;
+
+    case R_390_GOTPC:
+      assert(got != 0);
+      *loc += got - dot;
+      break;
+
+    case R_390_GOT32:
+      assert(isym != NULL);
+      if (!isym->gotent.reloc_done)
+	{
+	  isym->gotent.reloc_done = 1;
+	  *(Elf32_Addr *)(ifile->got->contents + isym->gotent.offset) = v;
+	}
+      *loc += isym->gotent.offset;
+      break;
+
+    case R_390_GOTOFF:
+      assert(got != 0);
+      *loc += v - got;
+      break;
+
+    default:
+      ret = obj_reloc_unhandled;
+      break;
+    }
+
+  return ret;
+}
+
+int
+arch_create_got (struct obj_file *f)
+{
+  struct s390_file *ifile = (struct s390_file *)f;
+  int i, n, offset = 0, gotneeded = 0;
+
+  n = ifile->root.header.e_shnum;
+  for (i = 0; i < n; ++i)
+    {
+      struct obj_section *relsec, *symsec, *strsec;
+      Elf32_Rel *rel, *relend;
+      Elf32_Sym *symtab;
+      const char *strtab;
+
+      relsec = ifile->root.sections[i];
+      if (relsec->header.sh_type != SHT_REL)
+	continue;
+
+      symsec = ifile->root.sections[relsec->header.sh_link];
+      strsec = ifile->root.sections[symsec->header.sh_link];
+
+      rel = (Elf32_Rel *)relsec->contents;
+      relend = rel + (relsec->header.sh_size / sizeof(Elf32_Rel));
+      symtab = (Elf32_Sym *)symsec->contents;
+      strtab = (const char *)strsec->contents;
+
+      for (; rel < relend; ++rel)
+	{
+	  Elf32_Sym *extsym;
+	  struct s390_symbol *intsym;
+	  const char *name;
+
+	  switch (ELF32_R_TYPE(rel->r_info))
+	    {
+	    case R_390_GOTPC:
+	    case R_390_GOTOFF:
+	      gotneeded = 1;
+	    default:
+	      continue;
+
+	    case R_390_GOT32:
+	      break;
+	    }
+
+	  extsym = &symtab[ELF32_R_SYM(rel->r_info)];
+	  if (extsym->st_name)
+	    name = strtab + extsym->st_name;
+	  else
+	    name = f->sections[extsym->st_shndx]->name;
+	  intsym = (struct s390_symbol *)obj_find_symbol(&ifile->root, name);
+
+	  if (!intsym->gotent.offset_done)
+	    {
+	      intsym->gotent.offset_done = 1;
+	      intsym->gotent.offset = offset;
+	      offset += 4;
+	    }
+	}
+    }
+
+  if (offset > 0 || gotneeded)
+    ifile->got = obj_create_alloced_section(&ifile->root, ".got", 4, offset);
+
+  return 1;
+}
+
+int
+arch_init_module (struct obj_file *f, struct module *m)
+{
+  return 1;
+}
+
+int         
+arch_finalize_section_address(struct obj_file *f, Elf32_Addr base)
+{    
+  int  i, n = f->header.e_shnum;
+             
+  f->baseaddr = base;
+  for (i = 0; i < n; ++i)
+    f->sections[i]->header.sh_addr += base;
+  return 1;  
+}
+
+int
+arch_archdata (struct obj_file *fin, struct obj_section *sec)
+{
+  return 0;
+}
diff --git a/mdk-stage1/insmod-modutils/obj/obj_sparc.c b/mdk-stage1/insmod-modutils/obj/obj_sparc.c
new file mode 100644
index 000000000..1a03c9090
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/obj/obj_sparc.c
@@ -0,0 +1,226 @@
+/* Sparc specific support for Elf loading and relocation.
+   Copyright 1996, 1997 Linux International.
+
+   Contributed by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <stddef.h>
+#include <module.h>
+#include <obj.h>
+#include <util.h>
+
+
+/*======================================================================*/
+
+struct obj_file *
+arch_new_file (void)
+{
+  return xmalloc(sizeof(struct obj_file));
+}
+
+struct obj_section *
+arch_new_section (void)
+{
+  return xmalloc(sizeof(struct obj_section));
+}
+
+struct obj_symbol *
+arch_new_symbol (void)
+{
+  return xmalloc(sizeof(struct obj_symbol));
+}
+
+int
+arch_load_proc_section(struct obj_section *sec, int fp)
+{
+    /* Assume it's just a debugging section that we can safely
+       ignore ...  */
+    sec->contents = NULL;
+
+    return 0;
+}
+
+enum obj_reloc
+arch_apply_relocation (struct obj_file *ef,
+		       struct obj_section *targsec,
+		       struct obj_section *symsec,
+		       struct obj_symbol *sym,
+		       Elf32_Rela *rel,
+		       Elf32_Addr v)
+{
+  Elf32_Addr *loc = (Elf32_Addr *)(targsec->contents + rel->r_offset);
+  Elf32_Addr dot = targsec->header.sh_addr + rel->r_offset;
+
+  enum obj_reloc ret = obj_reloc_ok;
+
+  switch (ELF32_R_TYPE(rel->r_info))
+    {
+    case R_SPARC_NONE:
+      break;
+    case R_SPARC_8:
+      if (v > 0xff)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0xff) | (v & 0xff);
+      break;
+    case R_SPARC_16:
+      if (v > 0xffff)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0xffff) | (v & 0xffff);
+      break;
+    case R_SPARC_32:
+      *loc = v;
+      break;
+    case R_SPARC_DISP8:
+      v -= dot;
+      if (v > 0xff)
+        ret = obj_reloc_overflow;
+      *loc = (*loc & ~0xff) | (v & 0xff);
+      break;
+    case R_SPARC_DISP16:
+      v -= dot;
+      if (v > 0xffff)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0xffff) | (v & 0xffff);
+      break;
+    case R_SPARC_DISP32:
+      v -= dot;
+      *loc = v;
+      break;
+    case R_SPARC_WDISP30:
+      v -= dot;
+      if (v % 4)
+	ret = obj_reloc_dangerous;
+      *loc = (*loc & ~0x3fffffff) | (v >> 2);
+      break;
+    case R_SPARC_WDISP22:
+      v -= dot;
+      if (v % 4)
+	ret = obj_reloc_dangerous;
+      *loc = (*loc & ~0x3fffff) | ((v >> 2) & 0x3fffff);
+      break;
+    case R_SPARC_HI22:
+      *loc = (*loc & ~0x3fffff) | (v >> 10);
+      break;
+    case R_SPARC_22:
+      if (v > 0x3fffff)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0x3fffff) | (v & 0x3fffff);
+      break;
+    case R_SPARC_13:
+      if (v > 0x1fff)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0x1fff) | (v & 0x1fff);
+      break;
+    case R_SPARC_LO10:
+      *loc = (*loc & ~0x3ff) | (v & 0x3ff);
+      break;
+
+    case R_SPARC_PC10:
+      v -= dot;
+      *loc = (*loc & ~0x3ff) | (v & 0x3ff);
+      break;
+    case R_SPARC_PC22:
+      v -= dot;
+      *loc = (*loc & ~0x3fffff) | (v >> 10);
+      break;
+
+    case R_SPARC_UA32:
+      *(((char *)loc) + 0) = (char)(v >> 24);
+      *(((char *)loc) + 1) = (char)(v >> 16);
+      *(((char *)loc) + 2) = (char)(v >> 8);
+      *(((char *)loc) + 3) = (char)v;
+      break;
+
+#ifdef R_SPARC_10
+    case R_SPARC_10:
+      if (v > 0x3ff)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0x3ff) | (v & 0x3ff);
+      break;
+    case R_SPARC_11:
+      if (v > 0x7ff)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0x7ff) | (v & 0x7ff);
+      break;
+    case R_SPARC_WDISP16:
+      v -= dot;
+      if (v % 4)
+	ret = obj_reloc_dangerous;
+      *loc = (*loc & ~0x303fff) | ((v << 4) & 0x300000) | ((v >> 2) & 0x3fff);
+      break;
+    case R_SPARC_WDISP19:
+      v -= dot;
+      if (v % 4)
+	ret = obj_reloc_dangerous;
+      *loc = (*loc & ~0x7ffff) | ((v >> 2) & 0x7ffff);
+      break;
+    case R_SPARC_7:
+      if (v > 0x7f)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0x7f) | (v & 0x7f);
+      break;
+    case R_SPARC_5:
+      if (v > 0x1f)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0x1f) | (v & 0x1f);
+      break;
+    case R_SPARC_6:
+      if (v > 0x3f)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0x3f) | (v & 0x3f);
+      break;
+#endif /* R_SPARC_10 */
+
+    default:
+      ret = obj_reloc_unhandled;
+      break;
+    }
+
+  return ret;
+}
+
+int
+arch_create_got (struct obj_file *ef)
+{
+  return 1;
+}
+
+int
+arch_init_module (struct obj_file *f, struct module *mod)
+{
+  return 1;
+}
+
+int
+arch_finalize_section_address(struct obj_file *f, Elf32_Addr base)
+{
+  int  i, n = f->header.e_shnum;
+
+  f->baseaddr = base;
+  for (i = 0; i < n; ++i)
+    f->sections[i]->header.sh_addr += base;
+  return 1;
+}
+
+int
+arch_archdata (struct obj_file *fin, struct obj_section *sec)
+{
+  return 0;
+}
diff --git a/mdk-stage1/insmod-modutils/obj/obj_sparc64.c b/mdk-stage1/insmod-modutils/obj/obj_sparc64.c
new file mode 100644
index 000000000..84e8d18a0
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/obj/obj_sparc64.c
@@ -0,0 +1,352 @@
+/* Sparc64 specific support for Elf loading and relocation.
+   Copyright 1997 Linux International.
+
+   Contributed by Jakub Jelinek <jj@sunsite.mff.cuni.cz>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <stddef.h>
+#include <module.h>
+#include <obj.h>
+#include <util.h>
+
+
+/*======================================================================*/
+
+struct obj_file *
+arch_new_file (void)
+{
+  return xmalloc(sizeof(struct obj_file));
+}
+
+struct obj_section *
+arch_new_section (void)
+{
+  return xmalloc(sizeof(struct obj_section));
+}
+
+struct obj_symbol *
+arch_new_symbol (void)
+{
+  return xmalloc(sizeof(struct obj_symbol));
+}
+
+#ifdef BROKEN_SPARC64_RELOCS
+
+#undef R_SPARC_PLT32
+#undef R_SPARC_HIPLT22
+#undef R_SPARC_LOPLT10
+#undef R_SPARC_PCPLT32
+#undef R_SPARC_PCPLT22
+#undef R_SPARC_PCPLT10
+#undef R_SPARC_10
+#undef R_SPARC_11
+#undef R_SPARC_64
+#undef R_SPARC_OLO10
+#undef R_SPARC_HH22
+#undef R_SPARC_HM10
+#undef R_SPARC_LM22
+#undef R_SPARC_PC_HH22
+#undef R_SPARC_PC_HM10
+#undef R_SPARC_PC_LM22
+#undef R_SPARC_WDISP16
+#undef R_SPARC_WDISP19
+#undef R_SPARC_GLOB_JMP
+#undef R_SPARC_7
+#undef R_SPARC_5
+#undef R_SPARC_6
+
+#define R_SPARC_10		24
+#define R_SPARC_11		25
+#define R_SPARC_64		26
+#define R_SPARC_OLO10		27
+#define R_SPARC_HH22		28
+#define R_SPARC_HM10		29
+#define R_SPARC_LM22		30
+#define R_SPARC_PC_HH22		31
+#define R_SPARC_PC_HM10		32
+#define R_SPARC_PC_LM22		33
+#define R_SPARC_WDISP16		34
+#define R_SPARC_WDISP19		35
+#define R_SPARC_GLOB_JMP	36
+#define R_SPARC_7		37
+#define R_SPARC_5		38
+#define R_SPARC_6		39
+
+#else
+
+#ifndef R_SPARC_64
+
+#define R_SPARC_64		32
+#define R_SPARC_OLO10		33
+#define R_SPARC_HH22		34
+#define R_SPARC_HM10		35
+#define R_SPARC_LM22		36
+#define R_SPARC_PC_HH22		37
+#define R_SPARC_PC_HM10		38
+#define R_SPARC_PC_LM22		39
+
+#endif
+
+#endif
+
+int
+arch_load_proc_section(struct obj_section *sec, int fp)
+{
+    /* Assume it's just a debugging section that we can safely
+       ignore ...  */
+    sec->contents = NULL;
+
+    return 0;
+}
+
+#define ELF64_R_TYPE_ID(info)	((info) & 0xff)
+#define ELF64_R_TYPE_DATA(info) ((info) >> 8)
+
+enum obj_reloc
+arch_apply_relocation (struct obj_file *ef,
+		       struct obj_section *targsec,
+		       struct obj_section *symsec,
+		       struct obj_symbol *sym,
+		       Elf64_Rela *rel,
+		       Elf64_Addr v)
+{
+  unsigned int *loc = (unsigned int *)(targsec->contents + rel->r_offset);
+  unsigned int dot = targsec->header.sh_addr + rel->r_offset;
+
+  enum obj_reloc ret = obj_reloc_ok;
+
+  switch (ELF64_R_TYPE_ID(rel->r_info))
+    {
+    case R_SPARC_NONE:
+      break;
+
+    case R_SPARC_64:
+    case R_SPARC_UA64:
+      if (! ((long) loc & 3)) {
+	/* Common in .eh_frame */
+	((unsigned int *) loc) [0] = v >> 32;
+	((unsigned int *) loc) [1] = v;
+	break;
+      }
+      ((unsigned char *) loc) [0] = v >> 56;
+      ((unsigned char *) loc) [1] = v >> 48;
+      ((unsigned char *) loc) [2] = v >> 40;
+      ((unsigned char *) loc) [3] = v >> 32;
+      ((unsigned char *) loc) [4] = v >> 24;
+      ((unsigned char *) loc) [5] = v >> 16;
+      ((unsigned char *) loc) [6] = v >> 8;
+      ((unsigned char *) loc) [7] = v;
+      break;
+    case R_SPARC_32:
+    case R_SPARC_UA32:
+      if (! ((long) loc & 3)) {
+	*loc = v;
+	break;
+      }
+      ((unsigned char *) loc) [0] = v >> 24;
+      ((unsigned char *) loc) [1] = v >> 16;
+      ((unsigned char *) loc) [2] = v >> 8;
+      ((unsigned char *) loc) [3] = v;
+      break;
+    case R_SPARC_16:
+      if (v > 0xffff)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0xffff) | (v & 0xffff);
+      break;
+    case R_SPARC_8:
+      if (v > 0xff)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0xff) | (v & 0xff);
+      break;
+
+    case R_SPARC_DISP32:
+      v -= dot;
+      *loc = v;
+      break;
+    case R_SPARC_DISP16:
+      v -= dot;
+      if (v > 0xffff)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0xffff) | (v & 0xffff);
+      break;
+    case R_SPARC_DISP8:
+      v -= dot;
+      if (v > 0xff)
+        ret = obj_reloc_overflow;
+      *loc = (*loc & ~0xff) | (v & 0xff);
+      break;
+    case R_SPARC_WDISP30:
+      v -= dot;
+      if (v % 4)
+	ret = obj_reloc_dangerous;
+      *loc = (*loc & ~0x3fffffff) | ((v >> 2) & 0x3fffffff);
+      break;
+
+    /* MEDLOW code model relocs */
+    case R_SPARC_LO10:
+      *loc = (*loc & ~0x3ff) | (v & 0x3ff);
+      break;
+    case R_SPARC_HI22:
+      *loc = (*loc & ~0x3fffff) | (v >> 10);
+      break;
+    case R_SPARC_OLO10:
+      *loc = (*loc & ~0x1fff) | (((v & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info)) & 0x1fff);
+      break;
+
+    /* MEDMID code model relocs */
+    case R_SPARC_H44:
+      *loc = (*loc & ~0x3fffff) | (v >> 22);
+      break;
+    case R_SPARC_M44:
+      *loc = (*loc & ~0x3ff) | ((v >> 12) & 0x3ff);
+      break;
+    case R_SPARC_L44:
+      *loc = (*loc & ~0xfff) | (v & 0xfff);
+      break;
+
+    /* MEDANY code model relocs */
+    case R_SPARC_HH22:
+      *loc = (*loc & ~0x3fffff) | (v >> 42);
+      break;
+    case R_SPARC_HM10:
+      *loc = (*loc & ~0x3ff) | ((v >> 32) & 0x3ff);
+      break;
+    case R_SPARC_LM22:
+      *loc = (*loc & ~0x3fffff) | ((v >> 10) & 0x3fffff);
+      break;
+
+    case R_SPARC_WDISP22:
+      v -= dot;
+      if (v % 4)
+	ret = obj_reloc_dangerous;
+      *loc = (*loc & ~0x3fffff) | ((v >> 2) & 0x3fffff);
+      break;
+    case R_SPARC_22:
+      if (v > 0x3fffff)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0x3fffff) | (v & 0x3fffff);
+      break;
+    case R_SPARC_13:
+      if (v > 0x1fff)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0x1fff) | (v & 0x1fff);
+      break;
+
+    case R_SPARC_PC10:
+      v -= dot;
+      *loc = (*loc & ~0x3ff) | (v & 0x3ff);
+      break;
+    case R_SPARC_PC22:
+      v -= dot;
+      *loc = (*loc & ~0x3fffff) | ((v >> 10) & 0x3fffff);
+      break;
+
+#ifdef R_SPARC_10
+    case R_SPARC_10:
+      if (v > 0x3ff)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0x3ff) | (v & 0x3ff);
+      break;
+    case R_SPARC_11:
+      if (v > 0x7ff)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0x7ff) | (v & 0x7ff);
+      break;
+
+#ifdef R_SPARC_64
+    case R_SPARC_PC_HH22:
+      v -= dot;
+      *loc = (*loc & ~0x3fffff) | (v >> 42);
+      break;
+    case R_SPARC_PC_HM10:
+      v -= dot;
+      *loc = (*loc & ~0x3ff) | ((v >> 32) & 0x3ff);
+      break;
+    case R_SPARC_PC_LM22:
+      v -= dot;
+      *loc = (*loc & ~0x3fffff) | ((v >> 10) & 0x3fffff);
+      break;
+#endif
+
+    case R_SPARC_WDISP16:
+      v -= dot;
+      if (v % 4)
+	ret = obj_reloc_dangerous;
+      *loc = (*loc & ~0x303fff) | ((v << 4) & 0x300000) | ((v >> 2) & 0x3fff);
+      break;
+    case R_SPARC_WDISP19:
+      v -= dot;
+      if (v % 4)
+	ret = obj_reloc_dangerous;
+      *loc = (*loc & ~0x7ffff) | ((v >> 2) & 0x7ffff);
+      break;
+    case R_SPARC_7:
+      if (v > 0x7f)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0x7f) | (v & 0x7f);
+      break;
+    case R_SPARC_5:
+      if (v > 0x1f)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0x1f) | (v & 0x1f);
+      break;
+    case R_SPARC_6:
+      if (v > 0x3f)
+	ret = obj_reloc_overflow;
+      *loc = (*loc & ~0x3f) | (v & 0x3f);
+      break;
+#endif /* R_SPARC_10 */
+
+    default:
+      ret = obj_reloc_unhandled;
+      break;
+    }
+
+  return ret;
+}
+
+int
+arch_create_got (struct obj_file *ef)
+{
+  return 1;
+}
+
+int
+arch_init_module (struct obj_file *f, struct module *mod)
+{
+  return 1;
+}
+
+int
+arch_finalize_section_address(struct obj_file *f, Elf64_Addr base)
+{
+  int  i, n = f->header.e_shnum;
+
+  f->baseaddr = base;
+  for (i = 0; i < n; ++i)
+    f->sections[i]->header.sh_addr += base;
+  return 1;
+}
+
+int
+arch_archdata (struct obj_file *fin, struct obj_section *sec)
+{
+  return 0;
+}
diff --git a/mdk-stage1/insmod-modutils/util/Makefile b/mdk-stage1/insmod-modutils/util/Makefile
new file mode 100644
index 000000000..844f8c0dc
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/Makefile
@@ -0,0 +1,39 @@
+ #******************************************************************************
+ #
+ #    insmod from modutils (generic)
+ #
+ # $Id$
+ #
+ # Copyright 1996, 1997 Linux International.
+ #
+ #*****************************************************************************
+
+top_dir = ../..
+
+include $(top_dir)/Makefile.common
+
+
+all: libutil.a libutil-STANDALONE.a #libutil-DIET.a
+
+clean:
+	rm -f *.o *.a
+
+
+FLAGS = -c -Wall -Os -fomit-frame-pointer -I./../include -D_GNU_SOURCE -DELF_MACHINE_H='"elf_$(ARCH).h"' -DARCH_$(ARCH) -DHAVE_WORDEXP=1 -DHAVE_GLOB=1 -DCONFIG_ROOT_CHECK_OFF=0
+
+OBJS = xmalloc.o xrealloc.o xstrcat.o xstrdup.o xsystem.o xftw.o \
+        modstat.o meta_expand.o config.o snap_shot.o arch64.o gzfiles.o sys_nim.o sys_oim.o
+
+libutil.a: $(OBJS) logger.o
+	ar cru $@ $^
+	ranlib $@
+
+libutil-STANDALONE.a: $(OBJS) logger-standalone.o
+	ar cru $@ $^
+	ranlib $@
+
+logger-standalone.o: logger.c
+	gcc $(FLAGS) $(GLIBC_INCLUDES) -o $@ -D_STANDALONE_ logger.c
+
+.c.o:
+	gcc $(FLAGS) $(GLIBC_INCLUDES) -c $<
diff --git a/mdk-stage1/insmod-modutils/util/alias.h b/mdk-stage1/insmod-modutils/util/alias.h
new file mode 100644
index 000000000..c925a04f3
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/alias.h
@@ -0,0 +1,244 @@
+/*
+ * This file is split out from config.c for easier editing
+ */
+
+/*
+ * tbpath and tbtype are used to build the complete set of paths for finding
+ * modules, but only when we search for individual directories, they are not
+ * used for [boot] and [toplevel] searches.
+ */
+static char *tbpath[] =
+{
+	"/lib/modules",
+	NULL			/* marks the end of the list! */
+};
+
+char *tbtype[] =
+{
+	"kernel",		/* as of 2.3.14 this must be first */
+	"fs",
+	"net",
+	"scsi",
+	"block",
+	"cdrom",
+	"ipv4",
+	"ipv6",
+	"sound",
+	"fc4",
+	"video",
+	"misc",
+	"pcmcia",
+	"atm",
+	"usb",
+	"ide",
+	"ieee1394",
+	"mtd",
+	NULL			/* marks the end of the list! */
+};
+
+/*
+ * This is the list of pre-defined aliases.
+ * Each entry can be overridden by an entry in /etc/modules.conf
+ */
+char *aliaslist[] =
+{
+	"binfmt-204 binfmt_aout",
+	"binfmt-263 binfmt_aout",
+	"binfmt-264 binfmt_aout",
+	"binfmt-267 binfmt_aout",
+	"binfmt-387 binfmt_aout",
+	"binfmt-332 iBCS",
+	"binfmt--310 binfmt_java",
+
+	"block-major-1 rd",
+	"block-major-2 floppy",
+	"block-major-3 ide-probe-mod",
+	"block-major-7 loop",
+	"block-major-8 sd_mod",
+	"block-major-9 md", /* For modular RAID */
+	"block-major-11 sr_mod",
+	"block-major-13 xd",
+	"block-major-15 cdu31a",
+	"block-major-16 gscd",
+	"block-major-17 optcd",
+	"block-major-18 sjcd",
+	"block-major-20 mcdx",
+	"block-major-22 ide-probe-mod",
+	"block-major-23 mcd",
+	"block-major-24 sonycd535",
+	"block-major-25 sbpcd",
+	"block-major-26 sbpcd",
+	"block-major-27 sbpcd",
+	"block-major-29 aztcd",
+	"block-major-32 cm206",
+	"block-major-33 ide-probe-mod",
+	"block-major-34 ide-probe-mod",
+	"block-major-37 ide-tape",
+	"block-major-44 ftl",		/* from David Woodhouse <dwmw2@infradead.org> */
+	"block-major-56 ide-probe-mod",
+	"block-major-57 ide-probe-mod",
+	"block-major-88 ide-probe-mod",
+	"block-major-89 ide-probe-mod",
+	"block-major-90 ide-probe-mod",
+	"block-major-91 ide-probe-mod",
+	"block-major-93 nftl",		/* from David Woodhouse <dwmw2@infradead.org> */
+
+	"char-major-4 serial",
+	"char-major-5 serial",
+	"char-major-6 lp",
+	"char-major-9 st",
+	"char-major-10 off",		/* was: mouse, was: misc */
+	"char-major-10-0 busmouse",	/* /dev/logibm Logitech bus mouse */
+	"char-major-10-1 off",		/* /dev/psaux PS/2-style mouse port */
+	"char-major-10-2 msbusmouse",	/* /dev/inportbm Microsoft Inport bus mouse */
+	"char-major-10-3 atixlmouse",	/* /dev/atibm ATI XL bus mouse */
+					/* /dev/jbm J-mouse */
+					/* /dev/amigamouse Amiga mouse (68k/Amiga) */
+					/* /dev/atarimouse Atari mouse */
+					/* /dev/sunmouse Sun mouse */
+					/* /dev/beep Fancy beep device */
+					/* /dev/modreq Kernel module load request */
+	"char-major-10-130 wdt",	/* /dev/watchdog Watchdog timer port */
+	"char-major-10-131 wdt",	/* /dev/temperature Machine internal temperature */
+					/* /dev/hwtrap Hardware fault trap */
+					/* /dev/exttrp External device trap */
+	"char-major-10-135 off",	/* rtc cannot be compiled as a module */
+	"char-major-10-139 openprom",	/* /dev/openprom Linux/Sparc interface */
+	"char-major-10-144 nvram",	/* from Tigran Aivazian <tigran@sco.COM> */
+	"char-major-10-157 applicom",	/* from David Woodhouse <dwmw2@infradead.org> */
+	"char-major-10-175 agpgart",    /* /dev/agpgart GART AGP mapping access */
+	"char-major-10-184 microcode",	/* Tigran Aivazian <tigran@veritas.com> */
+
+	"char-major-14 soundcore",
+	"char-major-19 cyclades",
+	"char-major-20 cyclades",
+	"char-major-21 sg",
+	"char-major-22 pcxx", /* ?? */
+	"char-major-23 pcxx", /* ?? */
+	"char-major-27 ftape",
+	"char-major-34 scc",
+	"char-major-35 tclmidi",
+	"char-major-36 netlink",
+	"char-major-37 ide-tape",
+	"char-major-48 riscom8",
+	"char-major-49 riscom8",
+	"char-major-57 esp",
+	"char-major-58 esp",
+	"char-major-63 kdebug",
+	"char-major-90 mtdchar",	/* from David Woodhouse <dwmw2@infradead.org> */
+	"char-major-99 ppdev",
+	"char-major-107 3dfx", /* from Tigran Aivazian <tigran@sco.COM> */
+	"char-major-161 ircomm-tty",
+
+	"dos msdos",
+	"dummy0 dummy",
+	"dummy1 dummy",
+	"eth0 off",
+	"iso9660 isofs",
+	"md-personality-1 linear",
+	"md-personality-2 raid0",
+        "md-personality-3 raid1",
+        "md-personality-4 raid5",
+
+	"net-pf-1 unix",	/* PF_UNIX	1  Unix domain sockets */
+	"net-pf-2 ipv4",	/* PF_INET	2  Internet IP Protocol */
+	"net-pf-3 off",		/* PF_AX25	3  Amateur Radio AX.25 */
+	"net-pf-4 ipx",		/* PF_IPX	4  Novell IPX */
+	"net-pf-5 appletalk",	/* PF_APPLETALK	5  Appletalk DDP */
+	"net-pf-6 off",		/* PF_NETROM	6  Amateur radio NetROM */
+				/* PF_BRIDGE	7  Multiprotocol bridge */
+				/* PF_AAL5	8  Reserved for Werner's ATM */
+				/* PF_X25	9  Reserved for X.25 project */
+				/* PF_INET6	10 IP version 6 */
+
+	/* next two from <dairiki@matthews.dairiki.org>  Thanks! */
+	"net-pf-17 af_packet",
+	"net-pf-19 off",	/* acorn econet */
+
+	"netalias-2 ip_alias",
+	"plip0 plip",
+	"plip1 plip",
+	"cipcb0 cipcb",
+	"cipcb1 cipcb",
+	"cipcb2 cipcb",
+	"cipcb3 cipcb",
+	"ppp0 ppp",
+	"ppp1 ppp",
+	"scsi_hostadapter off",	/* if not in config file */
+	"slip0 slip",
+	"slip1 slip",
+	"tty-ldisc-1 slip",
+	"tty-ldisc-3 ppp",
+	"ppp-compress-21 bsd_comp",
+	"ppp-compress-24 ppp_deflate",
+	"ppp-compress-26 ppp_deflate",
+
+#ifndef __sparc__
+	"parport_lowlevel parport_pc",
+#else
+        "parport_lowlevel parport_ax",
+#endif
+
+	"tty-ldisc-11 irtty",
+
+	"usbdevfs usbcore",
+
+	NULL			/* marks the end of the list! */
+};
+
+/*
+ * This is the list of pre-defined options.
+ * Each entry can be overridden by an entry in /etc/modules.conf
+ */
+char *optlist[] =
+{
+	"dummy0 -o dummy0",
+	"dummy1 -o dummy1",
+	"sb io=0x220 irq=7 dma=1 dma16=5 mpu_io=0x330",
+	NULL			/* marks the end of the list! */
+};
+
+/*
+ * This is the list of pre-defined "above"s,
+ * used for pull-in of additional modules
+ * Each entry can be overridden by an entry in /etc/modules.conf
+ */
+char *above[] =
+{
+	NULL			/* marks the end of the list! */
+};
+
+/*
+ * This is the list of pre-defined "below"s,
+ * used for push-in of additional modules
+ * Each entry can be overridden by an entry in /etc/modules.conf
+ */
+char *below[] =
+{
+	NULL			/* marks the end of the list! */
+};
+
+/*
+ * This is the list of pre-defined "prune"s,
+ * used to exclude paths from scan of /lib/modules.
+ * /etc/modules.conf can add entries but not remove them.
+ */
+char *prune[] =
+{
+        ".rhkmvtag",
+	"modules.dep",
+	"modules.generic_string",
+	"modules.pcimap",
+	"modules.isapnpmap",
+	"modules.usbmap",
+	"modules.parportmap",
+	"System.map",
+	".config",
+	"build",		/* symlink to source tree */
+	"vmlinux",
+	"vmlinuz",
+	"bzImage",
+	"zImage",
+	".rhkmvtag",		/* wish RedHat had told me before they did this */
+	NULL			/* marks the end of the list! */
+};
diff --git a/mdk-stage1/insmod-modutils/util/arch64.c b/mdk-stage1/insmod-modutils/util/arch64.c
new file mode 100644
index 000000000..4d5ace223
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/arch64.c
@@ -0,0 +1,35 @@
+/* Misc utility functions.
+   Copyright 1996, 1997 Linux International.
+   Written by Keith Owens <kaos@ocs.com.au>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <stdlib.h>
+#include <string.h>
+#include <sys/utsname.h>
+#include "util.h"
+
+/*======================================================================*/
+
+/* Indicate if the current machine uses 64 bit architecture */
+int arch64(void)
+{
+	struct utsname u;
+	return(!uname(&u) && strstr(u.machine, "64"));
+}
diff --git a/mdk-stage1/insmod-modutils/util/config.c b/mdk-stage1/insmod-modutils/util/config.c
new file mode 100644
index 000000000..a860920f6
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/config.c
@@ -0,0 +1,1591 @@
+/*
+ * Handle the configuration, including /etc/modules.conf
+ *
+ * Copyright 1994, 1995, 1996, 1997:
+ *	Jacques Gelinas <jack@solucorp.qc.ca>
+ *	Björn Ekwall <bj0rn@blox.se> February 1999
+ *	Keith Owens <kaos@ocs.com.au> October 1999
+ *
+ * "kernelversion" idea from the Debian release via:
+ *      Wichert Akkerman <wakkerma@cs.leidenuniv.nl>
+ *
+ * Björn, inspired by Richard Henderson <rth@twiddle.net>, cleaned up
+ * the wildcard handling and started using ftw in March 1999
+ * Cleanup of hardcoded arrays: Björn Ekwall <bj0rn@blox.se> March 1999
+ * Many additional keywords: Björn Ekwall <bj0rn@blox.se> (C) March 1999
+ * Standardize on /etc/modules.conf Keith Owens <kaos@ocs.com.au> October 1999
+ *
+ * Alpha typecast:Michal Jaegermann <michal@ellpspace.math.ualberta.ca>
+ *
+ * This file is part of the Linux modutils.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Specification: /etc/modules.conf / format
+ *	Modules may be located at different places in the filesystem.
+ *
+ *	The file /etc/modules.conf contains different definitions to
+ *	control the manipulation of modules.
+ *
+ *	Standard Unix style comments and continuation line are supported.
+ *	Comments begin with a # and continue until the end of the line.
+ *	A line continues on the next one if the last non-white character
+ *	is a \.
+ */
+/* #Specification: /etc/modules.conf / format / official name */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <sys/stat.h>
+#include <signal.h>
+#include <limits.h>
+#include <sys/param.h>
+#include <errno.h>
+
+#include "util.h"
+#include "config.h"
+#include "alias.h"
+
+int flag_autoclean; /* set/used by modprobe and insmod */
+
+struct utsname uts_info;
+
+struct PATH_TYPE *modpath;
+int nmodpath = 0;
+static int maxpath = 0;
+
+struct EXEC_TYPE *execs;
+int nexecs = 0;
+static int maxexecs = 0;
+
+OPT_LIST *opt_list;
+static int n_opt_list;
+
+OPT_LIST *abovelist;
+static int n_abovelist;
+
+OPT_LIST *belowlist;
+static int n_belowlist;
+
+OPT_LIST *prunelist;
+static int n_prunelist;
+
+OPT_LIST *probe_list;
+static int n_probe_list;
+
+OPT_LIST *probeall_list;
+static int n_probeall_list;
+
+OPT_LIST *aliases;
+static int n_aliases;
+
+char *persistdir = "/var/lib/modules/persist";
+
+const char symprefix[] = SYMPREFIX;
+
+char *insmod_opt = NULL;
+char *config_file = NULL;	/* Which file was actually used */
+time_t config_mtime;
+int root_check_off = CONFIG_ROOT_CHECK_OFF;	/* Default is modules must be owned by root */
+static char *config_version;	/* Hack for config_add */
+int quick = 0;			/* Option -A */
+
+/* The initialization order must match the gen_file_enum order in config.h */
+struct gen_files gen_file[] = {
+	{"generic_string", NULL, 0},
+	{"pcimap", NULL, 0},
+	{"isapnpmap", NULL, 0},
+	{"usbmap", NULL, 0},
+	{"parportmap", NULL, 0},
+	{"dep", NULL, 0},
+};
+
+const int gen_file_count = sizeof(gen_file)/sizeof(gen_file[0]);
+
+int flag_verbose;
+
+unsigned long safemode;
+
+void verbose(const char *ctl,...)
+{
+	if (flag_verbose) {
+		va_list list;
+		va_start(list, ctl);
+		vprintf(ctl, list);
+		va_end(list); 
+		fflush(stdout);
+	}
+}
+
+
+/*
+ *	Check to see if the existing modules.xxx files need updating,
+ *	based on the timestamps of the modules and the config file.
+ */
+static int check_update (const char *file, const struct stat *sb)
+{
+	int len = strlen(file);
+	int i;
+
+	if (!S_ISREG(sb->st_mode))
+		return 0;
+	for (i = 0; i < gen_file_count; ++i) {
+		if (sb->st_mtime > gen_file[i].mtime)
+			break;
+	}
+	if (i == gen_file_count)
+		return 0;	/* All generated files are up to date */
+
+	if (len > 2 && !strcmp(file + len - 2, ".o"))
+		return 1;
+	else if (len > 4 && !strcmp(file + len - 4, ".mod"))
+		return 1;
+#ifdef CONFIG_USE_ZLIB
+	else if (len > 5 && !strcmp(file + len - 5, ".o.gz"))
+		return 1;
+#endif
+	return 0;
+}
+
+static int need_update (const char *force_ver, const char *base_dir)
+{
+	struct stat tmp;
+	char dep[PATH_MAX];
+	int i;
+	uname (&uts_info);
+	if (!force_ver)
+		force_ver = uts_info.release;
+
+	if (strlen (force_ver) > 50)
+		/* That's just silly. */
+		return 1;
+
+	for (i = 0; i < gen_file_count; ++i) {
+		if (stat(gen_file[i].name, &tmp))
+			return 1;	/* No dependency file yet, so we need to build it. */
+		gen_file[i].mtime = tmp.st_mtime;
+	}
+
+	if (stat ("/etc/modules.conf", &tmp) &&
+	    stat ("/etc/conf.modules", &tmp))
+		return 1;
+
+	for (i = 0; i < gen_file_count; ++i) {
+		if (tmp.st_mtime > gen_file[i].mtime)
+			return 1;	/* Config file is newer. */
+	}
+
+	snprintf (dep, sizeof(dep), "%s/lib/modules/%s", base_dir, force_ver);
+	return xftw (dep, check_update);
+}
+
+
+/*
+ *	Strip white char at the end of a string.
+ *	Return the address of the last non white char + 1 (point on the '\0').
+ */
+static char *strip_end(char *str)
+{
+	int len = strlen(str);
+
+	for (str += len - 1; len > 0 && (isspace(*str)); --len, --str)
+		*str = '\0';
+	return str + 1;
+}
+
+/*
+ *	Read a line of a configuration file and process continuation lines.
+ *	Return buf, or NULL if EOF.
+ *	Blank at the end of line are always stripped.
+ *	Everything on a line following comchar is a comment.
+ *
+ *	Continuation character is \
+ *	Comment character is #
+ */
+char *fgets_strip(char *buf, int sizebuf, FILE * fin, int *lineno)
+{
+	int nocomment = 1; /* No comments found ? */
+	int contline = 0;
+	char *start = buf;
+	char *ret = NULL;
+	char comchar = '#';
+	char contchar = '\\';
+
+	*buf = '\0';
+
+	while (fgets(buf, sizebuf, fin) != NULL) {
+		char *end = strip_end(buf);
+		char *pt = strchr(buf, comchar);
+
+		if (pt != NULL) {
+			nocomment = 0;
+			*pt = '\0';
+			end = strip_end(buf);
+		}
+
+		if (lineno != NULL)
+			(*lineno)++;
+		ret = start;
+		if (contline) {
+			char *pt = buf;
+
+			while (isspace(*pt))
+				pt++;
+			if (pt > buf + 1) {
+				strcpy(buf + 1, pt);	/* safe, backward copy */
+				buf[0] = ' ';
+				end -= (int) (pt - buf) - 1;
+			} else if (pt == buf + 1) {
+				buf[0] = ' ';
+			}
+		}
+		if (end > buf && *(end - 1) == contchar) {
+			if (end == buf + 1 || *(end - 2) != contchar) {
+				/* Continuation */
+				contline = 1;
+				end--;
+				*end = '\0';
+				buf = end;
+			} else {
+				*(end - 1) = '\0';
+				break;
+			}
+		} else {
+			break;
+		}
+	}
+
+	return ret;
+}
+
+static char *next_word(char *pt)
+{
+	char *match;
+	char *pt2;
+
+	/* find end of word */
+	for (pt2 = pt; *pt2 && !(isspace(*pt2)); ++pt2) {
+		if ((match = strchr("\"'`", *pt2)) != NULL) {
+			for (++pt2; *pt2 && *pt2 != *match; ++pt2) {
+				if (*pt2 == '\\' && *(pt2 + 1) == *match)
+					++pt2;
+			}
+		}
+	}
+
+	/* skip leading whitespace before next word */
+	if (*pt2) {
+		*pt2++ = '\0'; /* terminate last word */
+		while (*pt2 && isspace(*pt2))
+			++pt2;
+	}
+	return pt2;
+}
+
+static GLOB_LIST *addlist(GLOB_LIST *orig, GLOB_LIST *add)
+{
+	if (!orig)
+		return add;
+	/* else */
+	orig->pathv = (char **)xrealloc(orig->pathv,
+					(orig->pathc + add->pathc + 1) *
+					sizeof(char *));
+	memcpy(orig->pathv + orig->pathc, add->pathv,
+	       add->pathc * sizeof(char *));
+	orig->pathc += add->pathc;
+	orig->pathv[orig->pathc] = NULL;
+	/*
+	free(add->pathv);
+	free(add);
+	*/
+	return orig;
+}
+
+static void decode_list(int *n, OPT_LIST **list, char *arg, int adding,
+			char *version, int opts)
+{
+	GLOB_LIST *pg;
+	GLOB_LIST *prevlist = NULL;
+	int i, autoclean = 1;
+	int where = *n;
+	char *arg2 = next_word(arg);
+
+	if (opts && !strcmp (arg, "-k")) {
+		if (!*arg2)
+			error("Missing module argument after -k\n");
+		arg = arg2;
+		arg2 = next_word(arg);
+		autoclean = 0;
+	}
+
+	for (i = 0; i < *n; ++i) {
+		if (strcmp((*list)[i].name, arg) == 0) {
+			if (adding)
+				prevlist = (*list)[i].opts;
+			else
+				free((*list)[i].opts);
+			(*list)[i].opts = NULL;
+			where = i;
+			break;
+		}
+	}
+	if (where == *n) {
+		(*list) = (OPT_LIST *)xrealloc((*list),
+			  (*n + 2) * sizeof(OPT_LIST));
+		(*list)[*n].name = xstrdup(arg);
+		(*list)[*n].autoclean = autoclean;
+		*n += 1;
+		memset(&(*list)[*n], 0, sizeof(OPT_LIST));
+	} else if (!autoclean)
+		(*list)[where].autoclean = 0;
+	pg = (GLOB_LIST *)xmalloc(sizeof(GLOB_LIST));
+	meta_expand(arg2, pg, NULL, version, ME_ALL);
+	(*list)[where].opts = addlist(prevlist, pg);
+}
+
+static void decode_exec(char *arg, int type)
+{
+	char *arg2;
+
+	execs[nexecs].when = type;
+	arg2 = next_word(arg);
+	execs[nexecs].module = xstrdup(arg);
+	execs[nexecs].cmd = xstrdup(arg2);
+	if (++nexecs >= maxexecs) {
+		maxexecs += 10;
+		execs = (struct EXEC_TYPE *)xrealloc(execs,
+			maxexecs * sizeof(struct EXEC_TYPE));
+	}
+}
+
+static int build_list(char **in, OPT_LIST **out, char *version, int opts)
+{
+	GLOB_LIST *pg;
+	int i;
+
+	for (i = 0; in[i]; ++i) {
+		char *p = xstrdup(in[i]);
+		char *pt = next_word(p);
+		char *pn = p;
+
+		*out = (OPT_LIST *)xrealloc(*out, (i + 2) * sizeof(OPT_LIST));
+		(*out)[i].autoclean = 1;
+		if (opts && !strcmp (p, "-k")) {
+		    pn = pt;
+		    pt = next_word(pn);
+		    (*out)[i].autoclean = 0;
+		}
+		pg = (GLOB_LIST *)xmalloc(sizeof(GLOB_LIST));
+		meta_expand(pt, pg, NULL, version, ME_ALL);
+		(*out)[i].name = xstrdup(pn);
+		(*out)[i].opts = pg;
+		free(p);
+	}
+	memset(&(*out)[i], 0, sizeof(OPT_LIST));
+
+	return i;
+}
+
+/* Environment variables can override defaults, testing only */
+static void gen_file_env(struct gen_files *gf)
+{
+	if (!safemode) {
+		char *e = xmalloc(strlen(gf->base)+5), *p1 = gf->base, *p2 = e;
+		while ((*p2++ = toupper(*p1++))) ;
+		strcpy(p2-1, "PATH");	/* safe, xmalloc */
+		if ((p2 = getenv(e)) != NULL) {
+			free(gf->name);
+			gf->name = xstrdup(p2);
+		}
+		free(e);
+	}
+}
+
+/* Read a config option for a generated filename */
+static int gen_file_conf(struct gen_files *gf, int assgn, const char *parm, const char *arg)
+{
+
+	int l = strlen(gf->base);
+	if (assgn &&
+	    strncmp(parm, gf->base, l) == 0 &&
+	    strcmp(parm+l, "file") == 0 &&
+	    !gf->name) {
+		gf->name = xstrdup(arg);
+		return(0);
+	}
+	return(1);
+}
+
+/* Check we have a name for a generated file */
+static int gen_file_check(struct gen_files *gf, GLOB_LIST *g,
+			  char *base_dir, char *version)
+{
+	char tmp[PATH_MAX];
+	int ret = 0;
+	if (!gf->name) {
+		/*
+		 * Specification: config file / no xxxfile parameter
+		 * The default value for generated filename xxx is:
+		 *
+		 * xxxfile=/lib/modules/`uname -r`/modules.xxx
+		 *
+		 * If the config file exists but lacks an xxxfile
+		 * specification, the default value is used since
+		 * the system can't work without one.
+		 */
+		snprintf(tmp, sizeof(tmp), "%s/lib/modules/%s/modules.%s",
+			base_dir, version, gf->base);
+		gf->name = xstrdup(tmp);
+	} else { /* xxxfile defined in modules.conf */
+		/*
+		 * If we have a xxxfile definition in the configuration file
+		 * we must resolve any shell meta-chars in its value.
+		 */
+		if (meta_expand(gf->name, g, base_dir, version, ME_ALL))
+			ret = -1;
+		else if (!g->pathv || g->pathv[0] == NULL)
+			ret = -1;
+		else {
+			free(gf->name);
+			gf->name = xstrdup(g->pathv[0]);
+		}
+	}
+	return(ret);
+}
+
+/*
+ *	Read the configuration file.
+ *	If parameter "all" == 0 then ignore everything except path info
+ *	Return -1 if any error.
+ *	Error messages generated.
+ */
+static int do_read(int all, char *force_ver, char *base_dir, char *conf_file, int depth)
+{
+	#define MAX_LEVEL 20
+	FILE *fin;
+	GLOB_LIST g;
+	int i;
+	int assgn;
+	int drop_default_paths = 1;
+	int lineno = 0;
+	int ret = 0;
+	int state[MAX_LEVEL + 1]; /* nested "if" */
+	int level = 0;
+	char buf[3000];
+	char tmpline[100];
+	char **pathp;
+	char *envpath;
+	char *version;
+	char *type;
+	char **glb;
+	char old_name[] = "/etc/conf.modules";
+	int conf_file_specified = 0;
+
+	/*
+	 * The configuration file is optional.
+	 * No error is printed if it is missing.
+	 * If it is missing the following content is assumed.
+	 *
+	 * path[boot]=/lib/modules/boot
+	 *
+	 * path[toplevel]=/lib/modules/`uname -r`
+	 *
+	 * path[toplevel]=/lib/modules/`kernelversion`
+	 *   (where kernelversion gives the major kernel version: "2.0", "2.2"...)
+	 *
+	 * path[toplevel]=/lib/modules/default
+	 *
+	 * path[kernel]=/lib/modules/kernel
+	 * path[fs]=/lib/modules/fs
+	 * path[net]=/lib/modules/net
+	 * path[scsi]=/lib/modules/scsi
+	 * path[block]=/lib/modules/block
+	 * path[cdrom]=/lib/modules/cdrom
+	 * path[ipv4]=/lib/modules/ipv4
+	 * path[ipv6]=/lib/modules/ipv6
+	 * path[sound]=/lib/modules/sound
+	 * path[fc4]=/lib/modules/fc4
+	 * path[video]=/lib/modules/video
+	 * path[misc]=/lib/modules/misc
+	 * path[pcmcia]=/lib/modules/pcmcia
+	 * path[atm]=/lib/modules/atm
+	 * path[usb]=/lib/modules/usb
+	 * path[ide]=/lib/modules/ide
+	 * path[ieee1394]=/lib/modules/ieee1394
+	 * path[mtd]=/lib/modules/mtd
+	 *
+	 * The idea is that modprobe will look first if the
+	 * modules are compiled for the current release of the kernel.
+	 * If not found, it will look for modules that fit for the
+	 * general kernelversion (2.0, 2.2 and so on).
+	 * If still not found, it will look into the default release.
+	 * And if still not found, it will look in the other directories.
+	 *
+	 * The strategy should be like this:
+	 * When you install a new linux kernel, the modules should go
+	 * into a directory related to the release (version) of the kernel.
+	 * Then you can do a symlink "default" to this directory.
+	 *
+	 * Each time you compile a new kernel, the make modules_install
+	 * will create a new directory, but it won't change thee default.
+	 *
+	 * When you get a module unrelated to the kernel distribution
+	 * you can place it in one of the last three directory types.
+	 *
+	 * This is the default strategy. Of course you can overide
+	 * this in /etc/modules.conf.
+	 *
+	 * 2.3.15 added a new file tree walk algorithm which made it possible to
+	 * point at a top level directory and get the same behaviour as earlier
+	 * versions of modutils.  2.3.16 takes this one stage further, it
+	 * removes all the individual directory names from most of the scans,
+	 * only pointing at the top level directory.  The only exception is the
+	 * last ditch scan, scanning all of /lib/modules would be a bad idea(TM)
+	 * so the last ditch scan still runs individual directory names under
+	 * /lib/modules.
+	 *
+	 * Additional syntax:
+	 *
+	 * [add] above module module1 ...
+	 *	Specify additional modules to pull in on top of a module
+	 *
+	 * [add] below module module1 ...
+	 *	Specify additional modules needed to be able to load a module
+	 *
+	 * [add] prune filename ...
+	 *
+	 * [add] probe name module1 ...
+	 *	When "name" is requested, modprobe tries to install each
+	 *	module in the list until it succeeds.
+	 *
+	 * [add] probeall name module1 ...
+	 *	When "name" is requested, modprobe tries to install all
+	 *	modules in the list.
+	 *	If any module is installed, the command has succeeded.
+	 *
+	 * [add] options module option_list
+	 *
+	 * For all of the above, the optional "add" prefix is used to
+	 * add to a list instead of replacing the contents.
+	 *
+	 * include FILE_TO_INCLUDE
+	 *	This does what you expect. No limitation on include levels.
+	 *
+	 * persistdir=persist_directory
+	 *	Name the directory to save persistent data from modules.
+	 *
+	 * In the following WORD is a sequence if non-white characters.
+	 * If ' " or ` is found in the string, all characters up to the
+	 * matching ' " or ` will also be included, even whitespace.
+	 * Every WORD will then be expanded w.r.t. meta-characters.
+	 * If the expanded result gives more than one word, then only
+	 * the first word of the result will be used.
+	 *
+	 *
+	 * define CODE WORD
+	 *		Do a putenv("CODE=WORD")
+	 *
+	 * EXPRESSION below can be:
+	 *	WORD compare_op WORD
+	 *		where compare_op is one of == != < <= >= >
+	 *		The string values of the WORDs are compared
+	 * or
+	 *	-n WORD compare_op WORD
+	 *		where compare_op is one of == != < <= >= >
+	 *		The numeric values of the WORDs are compared
+	 * or
+	 *	WORD
+	 *		if the expansion of WORD fails, or if the
+	 *		expansion is "0" (zero), "false" or "" (empty)
+	 *		then the expansion has the value FALSE.
+	 *		Otherwise the expansion has the value TRUE
+	 * or
+	 *	-f FILENAME
+	 *		Test if the file FILENAME exists
+	 * or
+	 *	-k
+	 *		Test if "autoclean" (i.e. called from the kernel)
+	 * or
+	 *	! EXPRESSION
+	 *		A negated expression is also an expression
+	 *
+	 * if EXPRESSION
+	 *	any config line
+	 *	...
+	 * elseif EXPRESSION
+	 *	any config line
+	 *	...
+	 * else
+	 *	any config line
+	 *	...
+	 * endif
+	 *
+	 * The else and elseif keywords are optional.
+	 * "if"-statements nest up to 20 levels.
+	 */
+
+	state[0] = 1;
+
+	if (force_ver)
+		version = force_ver;
+	else
+		version = uts_info.release;
+
+	config_version = xstrdup(version);
+
+	/* Only read the default entries on the first file */
+	if (depth == 0) {
+		maxpath = 100;
+		modpath = (struct PATH_TYPE *)xmalloc(maxpath * sizeof(struct PATH_TYPE));
+		nmodpath = 0;
+
+		maxexecs = 10;
+		execs = (struct EXEC_TYPE *)xmalloc(maxexecs * sizeof(struct EXEC_TYPE));
+		nexecs = 0;
+
+		/*
+		 * Build predef options
+		 */
+		if (all && optlist[0])
+			n_opt_list = build_list(optlist, &opt_list, version, 1);
+
+		/*
+		 * Build predef above
+		 */
+		if (all && above[0])
+			n_abovelist = build_list(above, &abovelist, version, 0);
+
+		/*
+		 * Build predef below
+		 */
+		if (all && below[0])
+			n_belowlist = build_list(below, &belowlist, version, 0);
+
+		/*
+		 * Build predef prune list
+		 */
+		if (prune[0])
+			n_prunelist = build_list(prune, &prunelist, version, 0);
+
+		/*
+		 * Build predef aliases
+		 */
+		if (all && aliaslist[0])
+			n_aliases = build_list(aliaslist, &aliases, version, 0);
+
+		/* Order and priority is now: (MODPATH + modules.conf) || (predefs + modules.conf) */
+		if ((envpath = getenv("MODPATH")) != NULL && !safemode) {
+			size_t len;
+			char *p;
+			char *path;
+
+			/* Make a copy so's we can mung it with strtok.  */
+			len = strlen(envpath) + 1;
+			p = alloca(len);
+			memcpy(p, envpath, len);
+			path = alloca(PATH_MAX);
+
+			for (p = strtok(p, ":"); p != NULL; p = strtok(NULL, ":")) {
+				len = snprintf(path, PATH_MAX, p, version);
+				modpath[nmodpath].path = xstrdup(path);
+				if ((type = strrchr(path, '/')) != NULL)
+					type += 1;
+				else
+					type = "misc";
+				modpath[nmodpath].type = xstrdup(type);
+				if (++nmodpath >= maxpath) {
+					maxpath += 100;
+					modpath = (struct PATH_TYPE *)xrealloc(modpath,
+						maxpath * sizeof(struct PATH_TYPE));
+				}
+
+			}
+		} else {
+			/*
+			 * Build the default "path[type]" configuration
+			 */
+			int n;
+			char *k;
+
+			/* The first entry in the path list */
+			modpath[nmodpath].type = xstrdup("boot");
+			snprintf(tmpline, sizeof(tmpline), "%s/lib/modules/boot", base_dir);
+			modpath[nmodpath].path = xstrdup(tmpline);
+			++nmodpath;
+
+			/* The second entry in the path list, `uname -r` */
+			modpath[nmodpath].type = xstrdup("toplevel");
+			snprintf(tmpline, sizeof(tmpline), "%s/lib/modules/%s", base_dir, version);
+			modpath[nmodpath].path = xstrdup(tmpline);
+			++nmodpath;
+
+			/* The third entry in the path list, `kernelversion` */
+			modpath[nmodpath].type = xstrdup("toplevel");
+			for (n = 0, k = version; *k; ++k) {
+				if (*k == '.' && ++n == 2)
+					break;
+			}
+			snprintf(tmpline, sizeof(tmpline), "%s/lib/modules/%.*s", base_dir,
+				(/* typecast for Alpha */ int)(k - version), version);
+			modpath[nmodpath].path = xstrdup(tmpline);
+			++nmodpath;
+
+			/* The rest of the entries in the path list */
+			for (pathp = tbpath; *pathp; ++pathp) {
+				char **type;
+
+				for (type = tbtype; *type; ++type) {
+					char path[PATH_MAX];
+
+					snprintf(path, sizeof(path), "%s%s/%s", base_dir, *pathp, *type);
+					if (meta_expand(path, &g, NULL, version, ME_ALL))
+						return -1;
+
+					for (glb = g.pathv; glb && *glb; ++glb) {
+						modpath[nmodpath].type = xstrdup(*type);
+						modpath[nmodpath].path = *glb;
+						if (++nmodpath >= maxpath) {
+							maxpath += 100;
+							modpath = (struct PATH_TYPE *)xrealloc(modpath,
+								maxpath * sizeof(struct PATH_TYPE));
+						}
+					}
+				}
+			}
+		}
+
+		/* Environment overrides for testing only, undocumented */
+		for (i = 0; i < gen_file_count; ++i)
+			gen_file_env(gen_file+i);
+
+	}	/* End of depth == 0 */
+
+	if (conf_file ||
+	    ((conf_file = getenv("MODULECONFIG")) != NULL && *conf_file && !safemode)) {
+		if (!(fin = fopen(conf_file, "r"))) {
+			error("Can't open %s", conf_file);
+			return -1;
+		}
+		conf_file_specified = 1;
+	} else {
+		if (!(fin = fopen((conf_file = ETC_MODULES_CONF), "r"))) {
+			/* Fall back to non-standard name */
+			if ((fin = fopen((conf_file = old_name), "r"))) {
+				fprintf(stderr,
+					"Warning: modutils is reading from %s because\n"
+					"         %s does not exist.  The use of %s is\n"
+					"         deprecated, please rename %s to %s\n"
+					"         as soon as possible.  Command\n"
+					"         mv %s %s\n",
+					old_name, ETC_MODULES_CONF,
+					old_name, old_name, ETC_MODULES_CONF,
+					old_name, ETC_MODULES_CONF);
+			}
+			/* So what... use the default configuration */
+		}
+	}
+
+	if (fin) {
+		struct stat statbuf1, statbuf2;
+		if (fstat(fileno(fin), &statbuf1) == 0)
+			config_mtime = statbuf1.st_mtime;
+		config_file = xstrdup(conf_file);	/* Save name actually used */
+		if (!conf_file_specified &&
+		    stat(ETC_MODULES_CONF, &statbuf1) == 0 &&
+		    stat(old_name, &statbuf2) == 0) {
+			/* Both /etc files exist */
+			if (statbuf1.st_dev == statbuf2.st_dev &&
+			    statbuf1.st_ino == statbuf2.st_ino) {
+				if (lstat(ETC_MODULES_CONF, &statbuf1) == 0 &&
+				    S_ISLNK(statbuf1.st_mode))
+					fprintf(stderr,
+						"Warning: You do not need a link from %s to\n"
+						"         %s.  The use of %s is deprecated,\n"
+						"         please remove %s and rename %s\n"
+						"         to %s as soon as possible.  Commands.\n"
+						"           rm %s\n"
+						"           mv %s %s\n",
+						ETC_MODULES_CONF, old_name,
+						old_name, ETC_MODULES_CONF, old_name, ETC_MODULES_CONF,
+						ETC_MODULES_CONF,
+						old_name, ETC_MODULES_CONF);
+				else {
+#ifndef NO_WARN_ON_OLD_LINK
+					fprintf(stderr,
+						"Warning: You do not need a link from %s to\n"
+						"         %s.  The use of %s is deprecated,\n"
+						"         please remove %s as soon as possible.  Command\n"
+						"           rm %s\n",
+						old_name, ETC_MODULES_CONF,
+						old_name, old_name,
+						old_name);
+#endif
+				}
+			}
+			else
+				fprintf(stderr,
+					"Warning: modutils is reading from %s and\n"
+					"         ignoring %s.  The use of %s is deprecated,\n"
+					"         please remove %s as soon as possible.  Command\n"
+					"           rm %s\n",
+					ETC_MODULES_CONF, old_name,
+					old_name, old_name,
+					old_name);
+		}
+	}
+
+	/*
+	 * Finally, decode the file
+	 */
+	while (fin && fgets_strip(buf, sizeof(buf) - 1, fin, &lineno) != NULL) {
+		char *arg2;
+		char *parm = buf;
+		char *arg;
+		int one_err = 0;
+		int adding;
+
+		while (isspace(*parm))
+			parm++;
+
+		if (strncmp(parm, "add", 3) == 0) {
+			adding = 1;
+			parm += 3;
+			while (isspace(*parm))
+				parm++;
+		} else
+			adding = 0;
+
+		arg = parm;
+
+		if (*parm == '\0')
+			continue;
+
+		one_err = 1;
+
+		while (*arg > ' ' && *arg != '=')
+			arg++;
+
+		if (*arg == '=')
+			assgn = 1;
+		else
+			assgn = 0;
+		*arg++ = '\0';
+		while (isspace(*arg))
+			arg++;
+
+		/*
+		 * endif
+		 */
+		if (!assgn && strcmp(parm, "endif") == 0) {
+			if (level > 0)
+				--level;
+			else {
+				error("unmatched endif in line %d", lineno);
+				return -1;
+			}
+			continue;
+		}
+
+		/*
+		 * else
+		 */
+		if (!assgn && strcmp(parm, "else") == 0) {
+			if (level <= 0) {
+				error("else without if in line %d", lineno);
+				return -1;
+			}
+			state[level] = !state[level];
+			continue;
+		}
+
+		/*
+		 * elseif
+		 */
+		if (!assgn && strcmp(parm, "elseif") == 0) {
+			if (level <= 0) {
+				error("elseif without if in line %d", lineno);
+				return -1;
+			}
+			if (state[level] != 0) {
+				/*
+				 * We have already found a TRUE
+				 * if statement in this "chain".
+				 * That's what "2" means.
+				 */
+				state[level] = 2;
+				continue;
+			}
+			/* else: No TRUE if has been found, cheat */
+			/*
+			 * The "if" handling increments level,
+			 * but this is the _same_ level as before.
+			 * So, compensate for it.
+			 */
+			--level;
+			parm = "if";
+			/* Fallthru to "if" */
+		}
+
+		/*
+		 * if
+		 */
+		if (strcmp(parm, "if") == 0) {
+			char *cmp;
+			int not = 0;
+			int numeric = 0;
+
+			if (level >= MAX_LEVEL) {
+				error("Too many nested if's in line %d\n", lineno);
+				return -1;
+			}
+			state[++level] = 0; /* default false */
+
+			if (*arg == '!') {
+				not = 1;
+				arg = next_word(arg);
+			}
+
+			if (strncmp(arg, "-k", 2) == 0) {
+				state[level] = flag_autoclean;
+				continue;
+			}
+
+			if (strncmp(arg, "-f", 2) == 0) {
+				char *file = next_word(arg);
+				meta_expand(file, &g, NULL, version, ME_ALL);
+				if (access(g.pathc ? g.pathv[0] : file, R_OK) == 0)
+					state[level] = !not;
+				else
+					state[level] = not;
+				continue;
+			}
+
+			if (strncmp(arg, "-n", 2) == 0) {
+				numeric = 1;
+				arg = next_word(arg);
+			}
+
+
+			cmp = next_word(arg);
+			if (*cmp) {
+				GLOB_LIST g2;
+				long n1 = 0;
+				long n2 = 0;
+				char *w1 = "";
+				char *w2 = "";
+
+				arg2 = next_word(cmp);
+
+				meta_expand(arg, &g, NULL, version, ME_ALL);
+				if (g.pathc && g.pathv[0])
+					w1 = g.pathv[0];
+
+				meta_expand(arg2, &g2, NULL, version, ME_ALL);
+				if (g2.pathc && g2.pathv[0])
+					w2 = g2.pathv[0];
+
+				if (numeric) {
+					n1 = strtol(w1, NULL, 0);
+					n2 = strtol(w2, NULL, 0);
+				}
+
+				if (strcmp(cmp, "==") == 0 ||
+				    strcmp(cmp, "=") == 0) {
+					if (numeric)
+					    state[level] = (n1 == n2);
+					else
+					    state[level] = strcmp(w1, w2) == 0;
+				} else if (strcmp(cmp, "!=") == 0) {
+					if (numeric)
+					    state[level] = (n1 != n2);
+					else
+					    state[level] = strcmp(w1, w2) != 0;
+				} else if (strcmp(cmp, ">=") == 0) {
+					if (numeric)
+					    state[level] = (n1 >= n2);
+					else
+					    state[level] = strcmp(w1, w2) >= 0;
+				} else if (strcmp(cmp, "<=") == 0) {
+					if (numeric)
+					    state[level] = (n1 <= n2);
+					else
+					    state[level] = strcmp(w1, w2) <= 0;
+				} else if (strcmp(cmp, ">") == 0) {
+					if (numeric)
+					    state[level] = (n1 > n2);
+					else
+					    state[level] = strcmp(w1, w2) > 0;
+				} else if (strcmp(cmp, "<") == 0) {
+					if (numeric)
+					    state[level] = (n1 < n2);
+					else
+					    state[level] = strcmp(w1, w2) < 0;
+				}
+			} else { /* Check defined value, if any */
+				/* undef or defined as
+				 *	"" or "0" or "false" => false
+				 *  defined => true
+				 */
+				if (!meta_expand(arg, &g, NULL, version, ME_ALL) &&
+				    g.pathc > 0 &&
+				    strcmp(g.pathv[0], "0") != 0 &&
+				    strcmp(g.pathv[0], "false") != 0 &&
+				    strlen(g.pathv[0]) != 0)
+					state[level] = 1; /* true */
+			}
+			if (not)
+				state[level] = !state[level];
+
+			continue;
+		}
+
+		/*
+		 * Should we bother?
+		 */
+		if (state[level] != 1)
+			continue;
+
+		/*
+		 * define
+		 */
+		if (!assgn && strcmp(parm, "define") == 0) {
+			char env[PATH_MAX];
+
+			arg2 = next_word(arg);
+			meta_expand(arg2, &g, NULL, version, ME_ALL);
+			snprintf(env, sizeof(env), "%s=%s", arg, (g.pathc ? g.pathv[0] : ""));
+			putenv(env);
+			one_err = 0;
+		}
+
+		/*
+		 * include
+		 */
+		if (!assgn && strcmp(parm, "include") == 0) {
+			meta_expand(arg, &g, NULL, version, ME_ALL);
+
+			if (!do_read(all, version, base_dir, g.pathc ? g.pathv[0] : arg, depth+1))
+				one_err = 0;
+			else
+				error("include %s failed\n", arg);
+		}
+
+		/*
+		 * above
+		 */
+		else if (all && !assgn && strcmp(parm, "above") == 0) {
+			decode_list(&n_abovelist, &abovelist, arg, adding, version, 0);
+			one_err = 0;
+		}
+
+		/*
+		 * below
+		 */
+		else if (all && !assgn && strcmp(parm, "below") == 0) {
+			decode_list(&n_belowlist, &belowlist, arg, adding, version, 0);
+			one_err = 0;
+		}
+
+		/*
+		 * prune
+		 */
+		else if (all && !assgn && strcmp(parm, "prune") == 0) {
+			decode_list(&n_prunelist, &prunelist, arg, adding, version, 0);
+			one_err = 0;
+		}
+
+		/*
+		 * probe
+		 */
+		else if (all && !assgn && strcmp(parm, "probe") == 0) {
+			decode_list(&n_probe_list, &probe_list, arg, adding, version, 0);
+			one_err = 0;
+		}
+
+		/*
+		 * probeall
+		 */
+		else if (all && !assgn && strcmp(parm, "probeall") == 0) {
+			decode_list(&n_probeall_list, &probeall_list, arg, adding, version, 0);
+			one_err = 0;
+		}
+
+		/*
+		 * options
+		 */
+		else if (all && !assgn && strcmp(parm, "options") == 0) {
+			decode_list(&n_opt_list, &opt_list, arg, adding, version, 1);
+			one_err = 0;
+		}
+
+		/*
+		 * alias
+		 */
+		else if (all && !assgn && strcmp(parm, "alias") == 0) {
+			/*
+			 * Replace any previous (default) definitions
+			 * for the same module
+			 */
+			decode_list(&n_aliases, &aliases, arg, 0, version, 0);
+			one_err = 0;
+		}
+
+		/*
+		 * Specification: /etc/modules.conf
+		 * The format of the commands in /etc/modules.conf are:
+		 *
+		 *	pre-install module command
+		 *	install module command
+		 *	post-install module command
+		 *	pre-remove module command
+		 *	remove module command
+		 *	post-remove module command
+		 *
+		 * The different words are separated by tabs or spaces.
+		 */
+		/*
+		 * pre-install
+		 */
+		else if (all && !assgn && (strcmp(parm, "pre-install") == 0)) {
+			decode_exec(arg, EXEC_PRE_INSTALL);
+			one_err = 0;
+		}
+
+		/*
+		 * install
+		 */
+		else if (all && !assgn && (strcmp(parm, "install") == 0)) {
+			decode_exec(arg, EXEC_INSTALL);
+			one_err = 0;
+		}
+
+		/*
+		 * post-install
+		 */
+		else if (all && !assgn && (strcmp(parm, "post-install") == 0)) {
+			decode_exec(arg, EXEC_POST_INSTALL);
+			one_err = 0;
+		}
+
+		/*
+		 * pre-remove
+		 */
+		else if (all && !assgn && (strcmp(parm, "pre-remove") == 0)) {
+			decode_exec(arg, EXEC_PRE_REMOVE);
+			one_err = 0;
+		}
+
+		/*
+		 * remove
+		 */
+		else if (all && !assgn && (strcmp(parm, "remove") == 0)) {
+			decode_exec(arg, EXEC_REMOVE);
+			one_err = 0;
+		}
+
+		/*
+		 * post-remove
+		 */
+		else if (all && !assgn && (strcmp(parm, "post-remove") == 0)) {
+			decode_exec(arg, EXEC_POST_REMOVE);
+			one_err = 0;
+		}
+
+		/*
+		 * insmod_opt=
+		 */
+		else if (assgn && (strcmp(parm, "insmod_opt") == 0)) {
+			insmod_opt = xstrdup(arg);
+			one_err = 0;
+		}
+
+		/*
+		 * keep
+		 */
+		else if (!assgn && (strcmp(parm, "keep") == 0)) {
+			drop_default_paths = 0;
+			one_err = 0;
+		}
+
+		/*
+		 * path...=
+		 */
+		else if (assgn && strncmp(parm, "path", 4) == 0) {
+			/*
+			 * Specification: config file / path parameter
+			 * The path parameter specifies a directory to
+			 * search for modules.
+			 * This parameter may be repeated multiple times.
+			 *
+			 * Note that the actual path may be defined using
+			 * wildcards and other shell meta-chars, such as "*?`".
+			 * For example:
+			 *      path[misc]=/lib/modules/1.1.5?/misc
+			 *
+			 * Optionally the path keyword carries a tag.
+			 * This tells us a little more about the purpose of
+			 * this directory and allows some automated operations.
+			 * A path is marked with a tag by adding the tag,
+			 * enclosed in square brackets, to the path keyword:
+			 * #
+			 * path[boot]=/lib/modules/boot
+			 * #
+			 * This case identifies the path a of directory
+			 * holding modules loadable a boot time.
+			 */
+
+			if (drop_default_paths) {
+				int n;
+
+				/*
+				 * Specification: config file / path / default
+				 *
+				 * Whenever there is a path[] specification
+				 * in the config file, all the default
+				 * path are reset.
+				 *
+				 * If one instead wants to _add_ to the default
+				 * set of paths, one has to have the option
+				 *    keep
+				 * before the first path[]-specification line
+				 * in the configuration file.
+				 */
+				drop_default_paths = 0;
+				for (n = 0; n < nmodpath; n++) {
+					free(modpath[n].path);
+					free(modpath[n].type);
+				}
+				nmodpath = 0;
+			}
+
+			/*
+			 * Get (the optional) tag
+			 * If the tag is missing, the word "misc"
+			 * is assumed.
+			 */
+			type = "misc";
+
+			if (parm[4] == '[') {
+				char *pt_type = parm + 5;
+
+				while (*pt_type != '\0' && *pt_type != ']')
+					pt_type++;
+
+				if (*pt_type == ']' && pt_type[1] == '\0') {
+					*pt_type = '\0';
+					type = parm + 5;
+				} /* else CHECKME */
+			}
+
+			/*
+			 * Handle the actual path description
+			 */
+			if (meta_expand(arg, &g, base_dir, version, ME_ALL))
+				return -1;
+			for (glb = g.pathv; glb && *glb; ++glb) {
+				modpath[nmodpath].type = xstrdup(type);
+				modpath[nmodpath].path = *glb;
+				if (++nmodpath >= maxpath) {
+					maxpath += 100;
+					modpath = (struct PATH_TYPE *)xrealloc(modpath,
+						maxpath * sizeof(struct PATH_TYPE));
+				}
+			}
+			one_err = 0;
+		}
+
+		/*
+		 * persistdir
+		 */
+		else if (assgn && strcmp(parm, "persistdir") == 0) {
+			meta_expand(arg, &g, NULL, version, ME_ALL);
+			persistdir = xstrdup(g.pathc ? g.pathv[0] : arg);
+			one_err = 0;
+		}
+
+		/* Names for generated files in config file */
+		for (i = 0; one_err && i < gen_file_count; ++i)
+			one_err = gen_file_conf(gen_file+i, assgn, parm, arg);
+
+		/*
+		 * any errors so far?
+		 */
+		if (all == 0)
+			one_err = 0;
+		else if (one_err) {
+			error("Invalid line %d in %s\n\t%s",
+				     lineno, conf_file, buf);
+			ret = -1;
+		}
+	}
+	if (fin)
+		fclose(fin);
+
+	if (level) {
+		error("missing endif at %s EOF", conf_file);
+		ret = -1;
+	}
+
+	if (ret)
+		return ret;
+	/* else */
+
+	/* Check we have names for generated files */
+	for (i = 0; !ret && i < gen_file_count; ++i)
+		ret = gen_file_check(gen_file+i, &g, base_dir, version);
+
+	return ret;
+}
+
+int config_read(int all, char *force_ver, char *base_dir, char *conf_file)
+{
+	int r;
+	if (modpath != NULL)
+		return 0; /* already initialized */
+
+	if (uname(&uts_info) < 0) {
+		error("Failed to find kernel name information");
+		return -1;
+	}
+
+	r = do_read(all, force_ver, base_dir, conf_file, 0);
+
+	if (quick && !r && !need_update (force_ver, base_dir))
+		exit (0);
+
+	return r;
+}
+
+/****************************************************************************/
+/*
+ *	FIXME: Far too much global state.  KAO.
+ */
+static int found;
+static int favail;
+static int one_only;
+static int meta_expand_type;
+char **list;
+static const char *filter_by_file;
+static char *filter_by_dir;
+
+/*
+ *	Add a file name if it exist
+ */
+static int config_add(const char *file, const struct stat *sb)
+{
+	int i;
+	int npaths = 0;
+	char **paths = NULL;
+
+	if (meta_expand_type) {
+		GLOB_LIST g;
+		char **p;
+		char full[PATH_MAX];
+
+		snprintf(full, sizeof(full), "%s/%s", file, filter_by_file);
+
+		if (filter_by_dir && !strstr(full, filter_by_dir))
+			return 0;
+
+		if (meta_expand(full, &g, NULL, config_version, meta_expand_type))
+			return 1;
+		for (p = g.pathv; p && *p; ++p) {
+			paths = (char **)xrealloc(paths,
+					(npaths + 1) * sizeof(char *));
+			paths[npaths++] = *p;
+		}
+	} else { /* normal path match or match with "*" */
+		if (!S_ISREG(sb->st_mode))
+			return 0;
+
+		if (strcmp(filter_by_file, "*")) {
+			char *p;
+
+			if ((p = strrchr(file, '/')) == NULL)
+				p = (char *)file;
+			else
+				p += 1;
+
+			if (strcmp(p, filter_by_file))
+				return 0;
+		}
+		if (filter_by_dir && !strstr(file, filter_by_dir))
+			return 0;
+		paths = (char **)xmalloc(sizeof(char **));
+		*paths = xstrdup(file);
+		npaths = 1;
+	}
+
+	for (i = 0; i < npaths; ++i) {
+		struct stat sbuf;
+
+		if (S_ISDIR(sb->st_mode)) {
+			if (stat(paths[i], &sbuf) == 0)
+				sb = &sbuf;
+		}
+		if (S_ISREG(sb->st_mode) && sb->st_mode & S_IRUSR) {
+			int j;
+			char **this;
+
+			if (!root_check_off) {
+				if (sb->st_uid != 0) {
+					error("%s is not owned by root", paths[i]);
+					continue;
+				}
+			}
+
+			/* avoid duplicates */
+			for (j = 0, this = list; j < found; ++j, ++this) {
+				if (strcmp(*this, paths[i]) == 0) {
+					free(paths[i]);
+					goto next;
+				}
+			}
+
+			list[found] = paths[i];
+			if (++found >= favail)
+				list = (char **)xrealloc(list,
+				     (favail += 100) * sizeof(char *));
+
+			if (one_only) {
+				for (j = i + 1; j < npaths; ++j)
+					free(paths[j]);
+				free(paths);
+				return 1; /* finish xftw */
+			}
+		}
+	    next:
+	}
+
+	if (npaths > 0)
+		free(paths);
+
+	return 0;
+}
+
+/*
+ * Find modules matching the name "match" in directory of type "type"
+ * (type == NULL matches all)
+ *
+ * Return a pointer to the list of modules found (or NULL if error).
+ * Update the counter (sent as parameter).
+ */
+GLOB_LIST *config_lstmod(const char *match, const char *type, int first_only)
+{
+	/*
+	 * Note:
+	 * There are _no_ wildcards remaining in the path descriptions!
+	 */
+	struct stat sb;
+	int i;
+	int ret = 0;
+	char *path = NULL;
+	char this[PATH_MAX];
+
+	if (!match)
+		match = "*";
+	one_only = first_only;
+	found = 0;
+	filter_by_file = match;
+	filter_by_dir = NULL;
+	if (type) {
+		char tmpdir[PATH_MAX];
+		snprintf(tmpdir, sizeof(tmpdir), "/%s/", type);
+		filter_by_dir = xstrdup(tmpdir);
+	}
+	/* In safe mode, the module name is always handled as is, without meta
+	 * expansion.  It might have come from an end user via kmod and must
+	 * not be trusted.  Even in unsafe mode, only apply globbing to the
+	 * module name, not command expansion.  We trust config file input so
+	 * applying command expansion is safe, we do not trust command line input.
+	 * This assumes that the only time the user can specify -C config file 
+	 * is when they run under their own authority.  In particular all
+	 * mechanisms that call modprobe as root on behalf of the user must
+	 * run in safe mode, without letting the user supply a config filename.
+	 */
+	meta_expand_type = 0;
+	if (strpbrk(match, SHELL_META) && strcmp(match, "*") && !safemode)
+		meta_expand_type = ME_GLOB|ME_BUILTIN_COMMAND;
+
+	list = (char **)xmalloc((favail = 100) * sizeof(char *));
+
+	for (i = 0; i < nmodpath; i++) {
+		path = modpath[i].path;
+		/* Special case: insmod: handle single, non-wildcard match */
+		if (first_only && strpbrk(match, SHELL_META) == NULL) {
+			/* Fix for "2.1.121 syntax */
+			snprintf(this, sizeof(this), "%s/%s/%s", path,
+						  modpath[i].type, match);
+			if (stat(this, &sb) == 0 &&
+			    config_add(this, &sb))
+				break;
+			/* End fix for "2.1.121 syntax */
+
+			snprintf(this, sizeof(this), "%s/%s", path, match);
+			if (stat(this, &sb) == 0 &&
+			    config_add(this, &sb))
+				break;
+		}
+
+		/* Start looking */
+		if ((ret = xftw(path, config_add))) {
+			break;
+		}
+	}
+	if (ret >= 0) {
+		GLOB_LIST *g = (GLOB_LIST *)xmalloc(sizeof(GLOB_LIST));
+		g->pathc = found;
+		g->pathv = list;
+		free(filter_by_dir);
+		return g;
+	}
+	free(list);
+	free(filter_by_dir);
+	return NULL;
+}
+
+/* Given a bare module name, poke through the module path to find the file.  */
+char *search_module_path(const char *base)
+{
+	GLOB_LIST *g;
+
+	if (config_read(0, NULL, "", NULL) < 0)
+		return NULL;
+	/* else */
+	g = config_lstmod(base, NULL, 1);
+	if (g == NULL || g->pathc == 0) {
+		char base_o[PATH_MAX];
+
+		snprintf(base_o, sizeof(base_o), "%s.o", base);
+		g = config_lstmod(base_o, NULL, 1);
+#ifdef CONFIG_USE_ZLIB
+		if (g == NULL || g->pathc == 0) {
+			snprintf(base_o, sizeof(base_o), "%s.o.gz", base);
+			g = config_lstmod(base_o, NULL, 1);
+		}
+#endif
+	}
+	if (g == NULL || g->pathc == 0)
+		return NULL;
+	/* else */
+	return g->pathv[0];
+}
diff --git a/mdk-stage1/insmod-modutils/util/gzfiles.c b/mdk-stage1/insmod-modutils/util/gzfiles.c
new file mode 100644
index 000000000..8d02253bb
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/gzfiles.c
@@ -0,0 +1,74 @@
+/*
+ * This simple library intends to make it transparent to read gzipped and/or
+ * standard files. This is simple enough to fit modutils' needs, but may be
+ * easily adapted to anyone's needs. It's completely free, do what you want
+ * with it .  - Willy Tarreau <willy@meta-x.org> - 2000/05/05 -
+ */
+
+#ifdef CONFIG_USE_ZLIB
+
+#include <stdio.h>
+#include <zlib.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+/* redefinition of gz_stream which isn't exported by zlib */
+typedef struct gz_stream {
+    z_stream stream;
+    int      z_err;   /* error code for last stream operation */
+    int      z_eof;   /* set if end of input file */
+    FILE     *file;   /* .gz file */
+    Byte     *inbuf;  /* input buffer */
+    Byte     *outbuf; /* output buffer */
+    uLong    crc;     /* crc32 of uncompressed data */
+    char     *msg;    /* error message */
+    char     *path;   /* path name for debugging only */
+    int      transparent; /* 1 if input file is not a .gz file */
+    char     mode;    /* 'w' or 'r' */
+    long     startpos; /* start of compressed data in file (header skipped) */
+} gz_stream;
+
+/* maximum number of simultaneous open files, also greater file descriptor number */
+#define MAXFD	64
+
+/* this static list is assumed to be filled with NULLs at runtime */
+static gzFile gzf_fds[MAXFD];
+
+/* returns the filedesc of the opened file. */
+int gzf_open(const char *name, int mode) {
+    int fd;
+    gzFile g;
+
+    if ((g=gzopen(name, "rb")) != NULL) {
+	fd=fileno(((gz_stream*)g)->file);
+	gzf_fds[fd]=g;
+    }
+    else if ((fd=open(name, mode)) != -1) {
+	gzf_fds[fd]=NULL; /* NULL means not GZ mode */
+    }
+    return fd;
+}
+
+off_t gzf_lseek(int fd, off_t offset, int whence) {
+    if (fd<0 || fd>=MAXFD || gzf_fds[fd]==NULL)
+	return lseek(fd, offset, whence);
+    else
+	return gzseek(gzf_fds[fd], offset, whence);
+}
+
+int gzf_read(int fd, void *buf, size_t count) {
+    if (fd<0 || fd>=MAXFD || gzf_fds[fd]==NULL)
+	return read(fd, buf, count);
+    else
+	return gzread(gzf_fds[fd], buf, count);
+}
+
+void gzf_close(int fd) {
+    if (fd<0 || fd>=MAXFD || gzf_fds[fd]==NULL)
+	close(fd);
+    else
+	gzclose(gzf_fds[fd]);
+}
+#endif
+
diff --git a/mdk-stage1/insmod-modutils/util/logger.c b/mdk-stage1/insmod-modutils/util/logger.c
new file mode 100644
index 000000000..3b790df5a
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/logger.c
@@ -0,0 +1,163 @@
+/* Error logging facilities.
+   Copyright 1996, 1997 Linux International.
+
+   Contributed by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+  */
+
+#ident "$Id$"
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <syslog.h>
+
+#include "util.h"
+
+/*======================================================================*/
+
+int errors;
+const char *error_file;
+int log;
+
+#define STOREMSG
+#ifdef STOREMSG
+struct cbuf {
+	struct cbuf *next;
+	int type;
+	char *msg;
+} *head, *tail;
+
+static void savemsg(int type, char *msg)
+{
+	struct cbuf *me = (struct cbuf *)xmalloc(sizeof(struct cbuf));
+	char *s = xstrdup(msg);
+
+	me->next = NULL;
+	me->type = type;
+	me->msg = s;
+
+	if (tail)
+		tail->next = me;
+	else
+		head = me;
+	tail = me;
+}
+
+#endif /* STOREMSG */
+
+static void dumpmsg(void)
+{
+	for (;head; head = head->next)
+		syslog(head->type, "%s", head->msg);
+}
+
+void setsyslog(const char *program)
+{
+	openlog(program, LOG_CONS, LOG_DAEMON);
+#ifdef STOREMSG
+	atexit(dumpmsg);
+#endif
+	log = 1;
+}
+
+
+
+#ifdef _STANDALONE_
+static int silent;
+
+const char *program_name;
+
+void error(const char *fmt,...)
+{
+	va_list args;
+
+	if (silent)
+		;
+	else if (log) {
+		char buf[1024];
+		int n;
+
+		if (error_file)
+			n = snprintf(buf, sizeof(buf), "%s: ", error_file);
+		else
+			n = 0;
+		va_start(args, fmt);
+		vsnprintf(buf + n, sizeof(buf) - n, fmt, args);
+		va_end(args);
+#ifdef STOREMSG
+		savemsg(LOG_ERR, buf);
+#else
+		syslog(LOG_ERR, "%s", buf);
+#endif
+	} else {
+		if (error_file)
+			fprintf(stderr, "%s: ", error_file);
+		va_start(args, fmt);
+		vfprintf(stderr, fmt, args);
+		va_end(args);
+		putc('\n', stderr);
+	}
+
+	errors++;
+}
+
+void lprintf(const char *fmt,...)
+{
+	va_list args;
+
+	if (silent);
+	else if (log) {
+		char buf[1024];
+		va_start(args, fmt);
+		vsnprintf(buf, sizeof(buf), fmt, args);
+		va_end(args);
+#ifdef STOREMSG
+		savemsg(LOG_INFO, buf);
+#else
+		syslog(LOG_INFO, "%s", buf);
+#endif
+	} else {
+		va_start(args, fmt);
+		vfprintf(stdout, fmt, args);
+		va_end(args);
+		putchar('\n');
+	}
+}
+
+#else /* _STANDALONE_ */
+#include "../../log.h"
+void error(const char *s, ...)
+{
+	va_list p;
+
+	va_start(p, s);
+	vlog_message(s, p);
+	va_end(p);
+}
+
+void lprintf(const char *s, ...)
+{
+	va_list p;
+
+	va_start(p, s);
+	vlog_message(s, p);
+	va_end(p);
+}
+#endif
diff --git a/mdk-stage1/insmod-modutils/util/meta_expand.c b/mdk-stage1/insmod-modutils/util/meta_expand.c
new file mode 100644
index 000000000..41fb4024c
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/meta_expand.c
@@ -0,0 +1,339 @@
+/*
+ * Handle expansion of meta charaters
+ *
+ * Copyright 1999 Björn Ekwall <bj0rn@blox.se>
+ *
+ * "kernelversion" idea from the Debian release via:
+ *	Wichert Akkerman <wakkerma@cs.leidenuniv.nl>
+ *
+ * Use wordexp(): idea from Tim Waugh <tim@cyberelk.demon.co.uk>
+ *
+ * Alpha typecast: Michal Jaegermann <michal@ellpspace.math.ualberta.ca>
+ *
+ * This file is part of the Linux modutils.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_WORDEXP
+#undef HAVE_WORDEXP
+#define HAVE_WORDEXP 0
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <string.h>
+#include <ctype.h>
+#if HAVE_WORDEXP
+#include <wordexp.h>
+#elif HAVE_GLOB
+#include <glob.h>
+#endif
+#include "util.h"
+
+/*
+ * Split into words delimited by whitespace,
+ * handle remaining quotes though...
+ * If strip_quotes != 0 then strip one level of quotes from the line.
+ */
+static void split_line(GLOB_LIST *g, char *line, int strip_quotes)
+{
+	int len;
+	char *d;
+	char *e;
+	char *p;
+	char tmpline[PATH_MAX];
+
+	for (p = line; *p; p = e) {
+		/* Skip leading whitespace */
+		while (*p && isspace(*p))
+			++p;
+
+		/* find end of word */
+		d = tmpline;
+		for (e = p; *e && !(isspace(*e)); ++e) {
+			char match;
+
+			/* Quote handling */
+			switch (*e) {
+			case '\\':
+				if (!strip_quotes)
+					*d++ = *e;
+				break;
+
+			case '"':
+			case '\'':
+				match = *e;
+				if (!strip_quotes)
+					*d++ = *e;
+				for (++e; *e && *e != match; ++e) {
+					*d++ = *e;
+					if (*e == '\\' && *(e + 1) == match)
+						*d++ = *++e;
+				}
+				if (!strip_quotes)
+					*d++ = *e;
+				break;
+
+			default:
+				*d++ = *e;
+				break;
+			}
+		}
+
+		if ((len = (int)(d - tmpline)) > 0) {
+			char *str = xmalloc(len + 1);
+			strncpy(str, tmpline, len);
+			str[len] = '\0';
+			g->pathv = (char **)xrealloc(g->pathv,
+				   (g->pathc + 2) * sizeof(char *));
+			g->pathv[g->pathc++] = str;
+		}
+	}
+
+	if (g->pathc)
+		g->pathv[g->pathc] = NULL;
+}
+
+static int glob_it(char *pt, GLOB_LIST *g)
+{
+#if HAVE_WORDEXP
+	wordexp_t w;
+
+	memset(&w, 0, sizeof(w));
+	if (wordexp(pt, &w, WRDE_UNDEF)) {
+		/*
+		error("wordexp %s failed", pt);
+		*/
+		return -1;
+	}
+	/* else */
+	g->pathc = w.we_wordc;
+	g->pathv = w.we_wordv;
+
+	return 0;
+#elif HAVE_GLOB /* but not wordexp */
+	glob_t w;
+
+	memset(&w, 0, sizeof(w));
+	if (glob(pt, GLOB_NOSORT, NULL, &w)) {
+		/*
+		error("glob %s failed", pt);
+		*/
+		return -1;
+	}
+	/* else */
+	if (w.gl_pathc && strpbrk(w.gl_pathv[0], SHELL_META)) {
+		globfree(&w);
+		return -1;
+	}
+	g->pathc = w.gl_pathc;
+	g->pathv = w.gl_pathv;
+
+	return 0;
+#else /* Neither wordexp nor glob */
+	return -1;
+#endif
+}
+
+/*
+ * Expand the string (including meta-character) to a list of matches
+ *
+ * Return 0 if OK else -1
+ */
+int meta_expand(char *pt, GLOB_LIST *g, char *base_dir, char *version, int type)
+{
+	FILE *fin;
+	int len = 0;
+	char *line = NULL;
+	char *p, *p1;
+	char tmpline[PATH_MAX + 1];
+	char wrk[sizeof(tmpline)];
+	char tmpcmd[2*sizeof(tmpline)+20];	/* room for /bin/echo "text" */
+
+	g->pathc = 0;
+	g->pathv = NULL;
+
+	/*
+	 * Take care of version dependent expansions
+	 * Needed for forced version handling
+	 */
+	if ((p = strchr(pt, '`')) != NULL && (type & ME_BUILTIN_COMMAND)) {
+		do {
+			char *s;
+
+			for (s = p + 1; isspace(*s); ++s)
+				;
+
+			if (strncmp(s, "uname -r", 8) == 0) {
+				while (*s && (*s != '`'))
+					++s;
+				if (*s == '`') {
+					*p = '\0';
+					snprintf(wrk, sizeof(wrk), "%s%s%s",
+						     pt,
+						     version,
+						     s + 1);
+					*p = '`';
+				}
+				strcpy(tmpline, wrk);	/* safe, same size */
+				pt = tmpline;
+			} else if (strncmp(s, "kernelversion", 13) == 0) {
+				while (*s && (*s != '`'))
+					++s;
+				if (*s == '`') {
+					int n;
+					char *k;
+
+					*p = '\0';
+					for (n = 0, k = version; *k; ++k) {
+						if (*k == '.' && ++n == 2)
+							break;
+					}
+					snprintf(wrk, sizeof(wrk), "%s%.*s%s",
+						     pt,
+						     /* typecast for Alpha */
+						     (int)(k - version),
+						     version,
+						     s + 1);
+					*p = '`';
+					strcpy(tmpline, wrk);	/* safe, same size */
+					pt = tmpline;
+				}
+			} else
+				break;
+		} while ((p = strchr(pt, '`')) != NULL);
+	}
+
+	/*
+	 * Any remaining meta-chars?
+	 */
+	if (strpbrk(pt, SHELL_META) == NULL) {
+		/*
+		 * No meta-chars.
+		 * Split into words, delimited by whitespace.
+		 */
+		snprintf(wrk, sizeof(wrk), "%s%s", (base_dir ? base_dir : ""), pt);
+		strcpy(tmpline, wrk);	/* safe, same size */
+		if ((p = strtok(tmpline, " \t\n")) != NULL) {
+			while (p) {
+				g->pathv = (char **)xrealloc(g->pathv,
+					   (g->pathc + 2) * sizeof(char *));
+				g->pathv[g->pathc++] = xstrdup(p);
+				p = strtok(NULL, " \t\n");
+			}
+		}
+		if (g->pathc)
+			g->pathv[g->pathc] = NULL;
+		return 0;
+	}
+	/* else */
+	/*
+	 * Handle remaining meta-chars
+	 */
+
+	/*
+	 * Just plain quotes?
+	 */
+	if (strpbrk(pt, "&();|<>$`!{}[]~=+:?*") == NULL &&
+	    (p = strpbrk(pt, "\"'\\"))) {
+		split_line(g, pt, 1);
+		return 0;
+	}
+
+	if (strpbrk(pt, "&();|<>$`\"'\\!{}~+:[]~?*") == NULL) {
+		/* Only "=" remaining, should be module options */
+		split_line(g, pt, 0);
+		return 0;
+	}
+
+	/*
+	 * If there are meta-characters and
+	 * if they are only shell glob meta-characters: do globbing
+	 */
+#if HAVE_WORDEXP
+	if (strpbrk(pt, "&();|<>`\"'\\!{}~=+:") == NULL &&
+	    strpbrk(pt, "$[]~?*"))
+#else
+	if (strpbrk(pt, "&();|<>$`\"'\\!{}~=+:") == NULL &&
+	    strpbrk(pt, "[]~?*"))
+#endif
+		if ((type & ME_GLOB) && glob_it(pt, g) == 0)
+			return 0;
+
+	if (strpbrk(pt, "&();|<>$`\"'\\!{}~+:[]~?*") == NULL) {
+		/* Only "=" remaining, should be module options */
+		split_line(g, pt, 0);
+		return 0;
+	}
+
+	/*
+	 * Last resort: Use "echo".
+	 * DANGER: Applying shell expansion to user supplied input is a
+	 *         major security risk.  Modutils code should only do meta
+	 *         expansion via shell commands for trusted data.  Basically
+	 *         this means only for data in the config file.   Even that
+	 *         assumes that the user cannot run modprobe as root with
+	 *         their own config file.  Programs (including the kernel)
+	 *         that invoke modprobe as root with user supplied input must
+	 *         pass exactly one user supplied parameter and must set
+	 *         safe mode.
+	 */
+	if (!(type & ME_SHELL_COMMAND))
+		return 0;
+	snprintf(wrk, sizeof(wrk), "%s%s", (base_dir ? base_dir : ""), pt);
+	strcpy(tmpline, wrk);	/* safe, same size */
+	snprintf(tmpcmd, sizeof(tmpcmd), "/bin/echo \"");
+	for (p = tmpline, p1 = tmpcmd + strlen(tmpcmd); *p; ++p, ++p1) {
+		if (*p == '"' || *p == '\\')
+			*p1++ = '\\';
+		*p1 = *p;
+	}
+	*p1++ = '"';
+	*p1++ = '\0';
+	if (p1 - tmpcmd > sizeof(tmpcmd)) {
+		error("tmpcmd overflow, should never happen");
+		exit(1);
+	}
+	if ((fin = popen(tmpcmd, "r")) == NULL) {
+		error("Can't execute: %s", tmpcmd);
+		return -1;
+	}
+	/* else */
+
+	/*
+	 * Collect the result
+	 */
+	while (fgets(tmpcmd, PATH_MAX, fin) != NULL) {
+		int l = strlen(tmpcmd);
+
+		line = (char *)xrealloc(line, len + l + 1);
+		line[len] = '\0';
+		strcat(line + len, tmpcmd);	/* safe, realloc */
+		len += l;
+	}
+	pclose(fin);
+
+	if (line) {
+		/* shell used to strip one set of quotes.  Paranoia code in
+		 * 2.3.20 stops that strip so we do it ourselves.
+		 */
+		split_line(g, line, 1);
+		free(line);
+	}
+
+	return 0;
+}
diff --git a/mdk-stage1/insmod-modutils/util/modstat.c b/mdk-stage1/insmod-modutils/util/modstat.c
new file mode 100644
index 000000000..ad82306c0
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/modstat.c
@@ -0,0 +1,419 @@
+/*
+ * Get kernel symbol table(s) and other relevant module info.
+ *
+ * Add module_name_list and l_module_name_list.
+ *   Keith Owens <kaos@ocs.com.au> November 1999.
+ * Björn Ekwall <bj0rn@blox.se> in February 1999 (C)
+ * Initial work contributed by Richard Henderson <rth@tamu.edu>
+ *
+ * This file is part of the Linux modutils.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include "util.h"
+#include "module.h"
+#include "obj.h"
+#include "modstat.h"
+
+struct module_stat *module_stat;
+size_t n_module_stat;
+char *module_name_list;
+size_t l_module_name_list;
+struct module_symbol *ksyms;
+size_t nksyms;
+int k_new_syscalls;
+
+static void *old_kernsym;
+
+/************************************************************************/
+static void drop(void)
+{
+	/*
+	 * Clean the slate for multiple runs
+	 */
+	if (module_stat) {
+		struct module_stat *m;
+		int i;
+
+		for (i = 0, m = module_stat; i < n_module_stat; ++i, ++m) {
+			if (m->syms)
+				free(m->syms);
+			if (m->refs)
+				free(m->refs);
+		}
+		free(module_stat);
+		module_stat = NULL;
+		n_module_stat = 0;
+	}
+	if (module_name_list) {
+		free(module_name_list);
+		module_name_list = NULL;
+		l_module_name_list = 0;
+	}
+	if (ksyms) {
+		free(ksyms);
+		ksyms = NULL;
+		nksyms = 0;
+	}
+	if (old_kernsym) {
+		free(old_kernsym);
+		old_kernsym = NULL;
+	}
+}
+
+static int new_get_kernel_info(int type)
+{
+	struct module_stat *modules;
+	struct module_stat *m;
+	struct module_symbol *syms;
+	struct module_symbol *s;
+	size_t ret;
+	size_t bufsize;
+	size_t nmod;
+	size_t nsyms;
+	size_t i;
+	size_t j;
+	char *module_names;
+	char *mn;
+
+	drop();
+
+	/*
+	 * Collect the loaded modules
+	 */
+	module_names = xmalloc(bufsize = 256);
+	while (query_module(NULL, QM_MODULES, module_names, bufsize, &ret)) {
+		if (errno != ENOSPC) {
+			error("QM_MODULES: %m\n");
+			return 0;
+		}
+		module_names = xrealloc(module_names, bufsize = ret);
+	}
+	module_name_list = module_names;
+	l_module_name_list = bufsize;
+	n_module_stat = nmod = ret;
+	module_stat = modules = xmalloc(nmod * sizeof(struct module_stat));
+	memset(modules, 0, nmod * sizeof(struct module_stat));
+
+	/* Collect the info from the modules */
+	for (i = 0, mn = module_names, m = modules;
+	     i < nmod;
+	     ++i, ++m, mn += strlen(mn) + 1) {
+		struct module_info info;
+
+		m->name = mn;
+		if (query_module(mn, QM_INFO, &info, sizeof(info), &ret)) {
+			if (errno == ENOENT) {
+			/* The module was removed out from underneath us. */
+				m->flags = NEW_MOD_DELETED;
+				continue;
+			}
+			/* else oops */
+			error("module %s: QM_INFO: %m", mn);
+			return 0;
+		}
+
+		m->addr = info.addr;
+
+		if (type & K_INFO) {
+			m->size = info.size;
+			m->flags = info.flags;
+			m->usecount = info.usecount;
+			m->modstruct = info.addr;
+		}
+
+		if (type & K_REFS) {
+			int mm;
+			char *mrefs;
+			char *mr;
+
+			mrefs = xmalloc(bufsize = 64);
+			while (query_module(mn, QM_REFS, mrefs, bufsize, &ret)) {
+				if (errno != ENOSPC) {
+					error("QM_REFS: %m");
+					return 1;
+				}
+				mrefs = xrealloc(mrefs, bufsize = ret);
+			}
+			for (j = 0, mr = mrefs;
+			     j < ret;
+			     ++j, mr += strlen(mr) + 1) {
+				for (mm = 0; mm < i; ++mm) {
+					if (strcmp(mr, module_stat[mm].name) == 0) {
+						m->nrefs += 1;
+						m->refs = xrealloc(m->refs, m->nrefs * sizeof(struct module_stat **));
+						m->refs[m->nrefs - 1] = module_stat + mm;
+						break;
+					}
+				}
+			}
+			free(mrefs);
+		}
+
+		if (type & K_SYMBOLS) { /* Want info about symbols */
+			syms = xmalloc(bufsize = 1024);
+			while (query_module(mn, QM_SYMBOLS, syms, bufsize, &ret)) {
+				if (errno == ENOSPC) {
+					syms = xrealloc(syms, bufsize = ret);
+					continue;
+				}
+				if (errno == ENOENT) {
+					/*
+					 * The module was removed out
+					 * from underneath us.
+					 */
+					m->flags = NEW_MOD_DELETED;
+					free(syms);
+					goto next;
+				} else {
+					error("module %s: QM_SYMBOLS: %m", mn);
+					return 0;
+				}
+			}
+			nsyms = ret;
+
+			m->nsyms = nsyms;
+			m->syms = syms;
+
+			/* Convert string offsets to string pointers */
+			for (j = 0, s = syms; j < nsyms; ++j, ++s)
+				s->name += (unsigned long) syms;
+		}
+		next:
+	}
+
+	if (type & K_SYMBOLS) { /* Want info about symbols */
+		/* Collect the kernel's symbols.  */
+		syms = xmalloc(bufsize = 16 * 1024);
+		while (query_module(NULL, QM_SYMBOLS, syms, bufsize, &ret)) {
+			if (errno != ENOSPC) {
+				error("kernel: QM_SYMBOLS: %m");
+				return 0;
+			}
+			syms = xrealloc(syms, bufsize = ret);
+		}
+		nksyms = nsyms = ret;
+		ksyms = syms;
+
+		/* Convert string offsets to string pointers */
+		for (j = 0, s = syms; j < nsyms; ++j, ++s)
+			s->name += (unsigned long) syms;
+	}
+
+	return 1;
+}
+
+#ifdef COMPAT_2_0
+/************************************************************************/
+
+#define mscan(offs,siz,ptr) \
+	if (lseek(kmem_fd, (off_t)(offs), SEEK_SET) == -1 || \
+	    read(kmem_fd, (ptr), (siz)) != (siz)) { \
+		if (kmem_fd != -1) \
+			close(kmem_fd); \
+		error("kmem: %m"); \
+		return 0; \
+	}
+
+#define OLD_MOD_RUNNING 1
+#define OLD_MOD_DELETED 2
+#define OLD_MOD_VISITED   0x20000000
+
+/* Fetch all the symbols and divvy them up as appropriate for the modules.  */
+static int old_get_kernel_info(int type)
+{
+	struct old_kernel_sym *kernsym;
+	struct old_kernel_sym *k;
+	struct module_stat *module;
+	struct module_stat *mod;
+	struct module_symbol *s = NULL;
+	int kmem_fd = -1;
+	int nkernsym;
+	int nmod;
+	int nm;
+	int nms;
+	int i;
+
+	drop();
+	module_name_list = xmalloc(1);
+	*module_name_list = '\0';
+
+	if ((nkernsym = get_kernel_syms(NULL)) < 0) {
+		error("get_kernel_syms: %m");
+		return 0;
+	}
+	kernsym = k = xmalloc(nkernsym * sizeof(struct old_kernel_sym));
+	old_kernsym = kernsym;
+	if (get_kernel_syms(kernsym) != nkernsym) {
+		error("inconsistency with get_kernel_syms -- is someone else "
+		      "playing with modules?");
+		free(kernsym);
+		return 0;
+	}
+
+	/* Number of modules */
+	for (k = kernsym, nmod = 0, i = 0; i < nkernsym; ++i, ++k) {
+		if (k->name[0] == '#') {
+			if (k->name[1]) {
+				++nmod;
+				i = strlen(k->name+1) + 1;
+				module_name_list =
+					xrealloc(module_name_list,
+					l_module_name_list + i);
+				strcpy(module_name_list+l_module_name_list,	/* safe, xrealloc */
+					k->name+1);
+				l_module_name_list += i;	/* NUL separated strings */
+			}
+			else
+				break;
+		}
+	}
+	module_stat = mod = module = xmalloc(nmod * sizeof(struct module_stat));
+	memset(module, 0, nmod * sizeof(struct module_stat));
+	n_module_stat = nmod;
+
+	/*
+	 * Will we need kernel internal info?
+	 */
+	if ((type & K_INFO) || (type & K_REFS)) {
+		if ((kmem_fd = open("/dev/kmem", O_RDONLY)) < 0) {
+			perror("ksyms: open /dev/kmem");
+			return 0;
+		}
+	}
+
+	/*
+	 * Collect the module information.
+	 */
+	for (k = kernsym, nm = 0, i = 0; i < nkernsym; ++i, ++k) {
+		if (k->name[0] == '#') {
+			struct old_kernel_sym *p;
+			struct old_module info;
+
+			if (k->name[1] == '\0')
+				break; /* kernel resident symbols follow */
+			/* else normal module */
+
+			module = mod++;
+			++nm;
+			module->name = k->name + 1;
+			module->modstruct = k->value;
+
+			if ((type & K_INFO) || (type & K_REFS)) {
+				long tmp;
+				/*
+				 * k->value is the address of the
+				 * struct old_module
+				 * in the kernel (for use via /dev/kmem)
+				 */
+				mscan(k->value, sizeof(info), &info);
+				module->addr = info.addr;
+				module->size = info.size * getpagesize();
+
+				mscan(info.addr, sizeof(long), &tmp);
+				module->flags = info.state &
+						(OLD_MOD_RUNNING | OLD_MOD_DELETED);
+				module->flags |= NEW_MOD_USED_ONCE; /* Cheat */
+				if (tmp & OLD_MOD_AUTOCLEAN)
+					module->flags |= NEW_MOD_AUTOCLEAN;
+				if (tmp & OLD_MOD_VISITED)
+					module->flags |= NEW_MOD_VISITED;
+
+				module->usecount = tmp & ~(OLD_MOD_AUTOCLEAN | OLD_MOD_VISITED);
+			}
+
+			if ((type & K_REFS) && info.ref) {
+				struct old_module_ref mr;
+				int j;
+				unsigned long ref = info.ref;
+
+				do {
+					mscan(ref, sizeof(struct old_module_ref), &mr);
+					for (j = 0; j < nm -1; ++j) {
+						if (mr.module == module_stat[j].modstruct) {
+							module->nrefs += 1;
+							module->refs = xrealloc(module->refs, module->nrefs * sizeof(struct module_stat **));
+							module->refs[module->nrefs - 1] = module_stat + j;
+							break;
+						}
+					}
+				} while ((ref = mr.next) != 0);
+			}
+
+			if (!(type & K_SYMBOLS))
+				continue;
+			/*
+			 * Find out how many symbols this module has.
+			 */
+			for (nms = 0, p = k+1; p->name[0] != '#'; ++p)
+				++nms;
+			s = xmalloc(nms * sizeof(struct module_symbol));
+			module->syms = s;
+			module->nsyms = nms;
+		} else if (type & K_SYMBOLS) { /* Want info about symbols */
+			s->name = (unsigned long) k->name;
+			s->value = k->value;
+			++s;
+		}
+	}
+	if ((type & K_INFO) || (type & K_REFS)) {
+		if (kmem_fd != -1)
+			close(kmem_fd);
+	}
+
+	/*
+	 * Kernel resident symbols follows
+	 */
+	if (type & K_SYMBOLS) { /* Want info about symbols */
+		if (k->name[0] == '#')
+			++k;
+		nksyms = nkernsym - (k - kernsym);
+		if (nksyms) {
+			ksyms = s = xmalloc(nksyms * sizeof(struct module_symbol));
+			for (i = 0; i < nksyms; ++i, ++k) {
+				if (k->name[0] != '#') {
+					s->name = (unsigned long) k->name;
+					s->value = k->value;
+					++s;
+				}
+			}
+			nksyms = s - ksyms;
+		} else
+			ksyms = NULL;
+	}
+
+	return 1;
+}
+#endif /* COMPAT_2_0 */
+
+int get_kernel_info(int type)
+{
+	k_new_syscalls = !query_module(NULL, 0, NULL, 0, NULL);
+
+#ifdef COMPAT_2_0
+	if (!k_new_syscalls)
+		return old_get_kernel_info(type);
+#endif /* COMPAT_2_0 */
+
+	return new_get_kernel_info(type);
+}
diff --git a/mdk-stage1/insmod-modutils/util/snap_shot.c b/mdk-stage1/insmod-modutils/util/snap_shot.c
new file mode 100644
index 000000000..ae0cc7c79
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/snap_shot.c
@@ -0,0 +1,154 @@
+/* Take a snap shot of ksyms and modules for Oops debugging
+   Copyright 1999 Linux International.
+
+   Contributed by Keith Owens <kaos@ocs.com.au>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+  */
+
+#ident "$Id$"
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <time.h>
+#include <unistd.h>
+#include <string.h>
+
+#include "module.h"
+#include "obj.h"
+#include "modstat.h"
+#include "util.h"
+
+static char snap_dir[] = "/var/log/ksymoops";
+
+/* If snap_dir exists, take a snap shot of ksyms and modules to snap_dir.
+ * Prefix the files with the equivalent of
+ * date +%Y%m%d%T%M%S | sed -e 's/://g'
+ */
+void snap_shot(const char *module_names, int n_module_names)
+{
+	char file[] = "ccyymmddhhmmss.modules", buffer[4096];
+	static char *infile[] = { "/proc/ksyms", "/proc/modules" };
+	static char *suffix[] = {       "ksyms",       "modules" };
+	struct tm *local;
+	time_t t;
+	int i, l;
+	FILE *in, *out;
+
+	if (module_names) {
+		/* Only snap shot if the list of modules has changed.
+		 * Otherwise auto cleanup takes a snap shot every time
+		 * and ends up with a large snap shot directory.
+		 */
+		char *new_module_names;
+		size_t n_new_module_names;
+		get_kernel_info(0);
+		new_module_names = module_name_list;
+		n_new_module_names = n_module_stat;
+		if (n_module_names && n_new_module_names == n_module_names) {
+			while (n_module_names) {
+				if (strcmp(module_names, new_module_names))
+					break;	/* difference detected */
+				i = strlen(module_names) + 1;
+				module_names += i;
+				new_module_names += i;
+				--n_module_names;
+			}
+		}
+		if (!n_module_names)
+			return;	/* no difference, no need for snap shot */
+	}
+
+	if (chdir(snap_dir))
+		return;
+	t = time(NULL);
+	local = localtime(&t);
+	for (i = 0; i < sizeof(infile)/sizeof(infile[0]); ++i) {
+		snprintf(file, sizeof(file), "%04d%02d%02d%02d%02d%02d.%s",
+			local->tm_year+1900,
+			local->tm_mon + 1,
+			local->tm_mday,
+			local->tm_hour,
+			local->tm_min,
+			local->tm_sec,
+			suffix[i]);
+		out = fopen(file, "w");
+		if (!out) {
+			error("cannot create %s/%s %m", snap_dir, file);
+			return;
+		}
+		in = fopen(infile[i], "r");
+		if (!in) {
+			error("cannot open %s %m", infile[i]);
+			return;
+		}
+		while ((l = fread(buffer, 1, sizeof(buffer), in)) > 0) {
+			if (fwrite(buffer, l, 1, out) != 1) {
+				error("unable to write to %s %m", file);
+				fclose(in);
+				fclose(out);
+				return;
+			}
+		}
+		if (ferror(in))
+			error("unable to read from %s %m", infile[i]);
+		fclose(in);
+		fclose(out);
+	}
+}
+
+/* If snap_dir exists, log a message to snap_dir.  The log file is called the
+ * equivalent of date +%Y%m%d | sed -e 's/://g'.  Each line is prefixed with
+ * timestamp down to seconds and followed by a newline.
+ */
+void snap_shot_log(const char *fmt,...)
+{
+	char date[] = "ccyymmdd", file[] = "ccyymmdd.log", stamp[] = "ccyymmdd hhmmss";
+	struct tm *local;
+	time_t t;
+	FILE *log;
+	va_list args;
+	int save_errno = errno;
+
+	if (chdir(snap_dir))
+		return;
+	t = time(NULL);
+	local = localtime(&t);
+	snprintf(date, sizeof(date), "%04d%02d%02d",
+			local->tm_year+1900,
+			local->tm_mon + 1,
+			local->tm_mday);
+	snprintf(file, sizeof(file), "%s.log", date);
+	log = fopen(file, "a");
+	if (!log) {
+		error("cannot create %s/%s %m", snap_dir, file);
+		return;
+	}
+	snprintf(stamp, sizeof(stamp), "%s %02d%02d%02d",
+		date,
+		local->tm_hour,
+		local->tm_min,
+		local->tm_sec);
+	fprintf(log, "%s ", stamp);
+	va_start(args, fmt);
+	errno = save_errno;	/* fmt may use %m */
+	vfprintf(log, fmt, args);
+	va_end(args);
+	fprintf(log, "\n");
+	fclose(log);
+}
diff --git a/mdk-stage1/insmod-modutils/util/sys_cm.c b/mdk-stage1/insmod-modutils/util/sys_cm.c
new file mode 100644
index 000000000..851fb709e
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/sys_cm.c
@@ -0,0 +1,88 @@
+/* Functions for the Linux module syscall interface.
+   Copyright 1996, 1997 Linux International.
+   Contributed by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <stdlib.h>
+#include <errno.h>
+
+#include "module.h"
+
+/* Kernel headers before 2.1.mumble need this on the Alpha to get
+   _syscall* defined.  */
+#define __LIBRARY__
+
+#include <asm/unistd.h>
+
+
+/*======================================================================*/
+
+#if defined(__i386__) || defined(__m68k__) || defined(__arm__)
+
+#define __NR__create_module  __NR_create_module
+static inline _syscall2(long, _create_module, const char *, name, size_t, size)
+
+unsigned long create_module(const char *name, size_t size)
+{
+  /* Why all this fuss?
+
+     In linux 2.1, the address returned by create module point in
+     kernel space which is now mapped at the top of user space (at
+     0xc0000000 on i386). This looks like a negative number for a
+     long. The normal syscall macro of linux 2.0 (and all libc compile
+     with linux 2.0 or below) consider that the return value is a
+     negative number and consider it is an error number (A kernel
+     convention, return value are positive or negative, indicating the
+     error number).
+
+     By checking the value of errno, we know if we have been fooled by
+     the syscall2 macro and we fix it.  */
+
+  long ret = _create_module(name, size);
+  if (ret == -1 && errno > 125)
+    {
+      ret = -errno;
+      errno = 0;
+    }
+  return ret;
+}
+
+#elif defined(__alpha__)
+
+/* Alpha doesn't have the same problem, exactly, but a bug in older
+   kernels fails to clear the error flag.  Clear it here explicitly.  */
+
+#define __NR__create_module  __NR_create_module
+static inline _syscall4(unsigned long, _create_module, const char *, name,
+			size_t, size, size_t, dummy, size_t, err);
+
+unsigned long create_module(const char *name, size_t size)
+{
+  return _create_module(name, size, 0, 0);
+}
+
+#else
+
+/* Sparc, MIPS, (and Alpha, but that's another problem) don't mistake
+   return values for errors due to the nature of the system call.  */
+
+_syscall2(unsigned long, create_module, const char *, name, size_t, size)
+
+#endif
diff --git a/mdk-stage1/insmod-modutils/util/sys_dm.c b/mdk-stage1/insmod-modutils/util/sys_dm.c
new file mode 100644
index 000000000..a166a30f4
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/sys_dm.c
@@ -0,0 +1,37 @@
+/* Functions for the Linux module syscall interface.
+   Copyright 1996, 1997 Linux International.
+   Contributed by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <stdlib.h>
+#include <errno.h>
+
+#include "module.h"
+
+/* Kernel headers before 2.1.mumble need this on the Alpha to get
+   _syscall* defined.  */
+#define __LIBRARY__
+
+#include <asm/unistd.h>
+
+
+/*======================================================================*/
+
+_syscall1(int, delete_module, const char *, name)
diff --git a/mdk-stage1/insmod-modutils/util/sys_gks.c b/mdk-stage1/insmod-modutils/util/sys_gks.c
new file mode 100644
index 000000000..f71772c71
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/sys_gks.c
@@ -0,0 +1,37 @@
+/* Functions for the Linux module syscall interface.
+   Copyright 1996, 1997 Linux International.
+   Contributed by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <stdlib.h>
+#include <errno.h>
+
+#include "module.h"
+
+/* Kernel headers before 2.1.mumble need this on the Alpha to get
+   _syscall* defined.  */
+#define __LIBRARY__
+
+#include <asm/unistd.h>
+
+
+/*======================================================================*/
+
+_syscall1(int, get_kernel_syms, struct old_kernel_sym *, ksyms)
diff --git a/mdk-stage1/insmod-modutils/util/sys_nim.c b/mdk-stage1/insmod-modutils/util/sys_nim.c
new file mode 100644
index 000000000..bbe42135c
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/sys_nim.c
@@ -0,0 +1,53 @@
+/* Functions for the Linux module syscall interface.
+   Copyright 1996, 1997 Linux International.
+   Contributed by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <stdlib.h>
+#include <errno.h>
+
+#include "module.h"
+
+/* Kernel headers before 2.1.mumble need this on the Alpha to get
+   _syscall* defined.  */
+#define __LIBRARY__
+
+#include <asm/unistd.h>
+
+
+/*======================================================================*/
+
+#ifndef CONFIG_USE_SYSCALL
+
+extern int init_module(const char *name, const struct module *info);
+
+int 
+sys_init_module(const char *name, const struct module *info)
+{
+  return init_module(name, info);
+}
+
+#else
+
+#define __NR_sys_init_module  __NR_init_module
+_syscall2(int, sys_init_module, const char *, name,
+	  const struct module *, info)
+
+#endif
diff --git a/mdk-stage1/insmod-modutils/util/sys_oim.c b/mdk-stage1/insmod-modutils/util/sys_oim.c
new file mode 100644
index 000000000..73ac6be52
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/sys_oim.c
@@ -0,0 +1,40 @@
+/* Functions for the Linux module syscall interface.
+   Copyright 1996, 1997 Linux International.
+   Contributed by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <stdlib.h>
+#include <errno.h>
+
+#include "module.h"
+
+/* Kernel headers before 2.1.mumble need this on the Alpha to get
+   _syscall* defined.  */
+#define __LIBRARY__
+
+#include <asm/unistd.h>
+
+
+/*======================================================================*/
+
+#define __NR_old_sys_init_module  __NR_init_module
+_syscall5(int, old_sys_init_module, const char *, name, char *, code,
+	  unsigned, codesize, struct old_mod_routines *, routines,
+	  struct old_symbol_table *, symtab)
diff --git a/mdk-stage1/insmod-modutils/util/sys_qm.c b/mdk-stage1/insmod-modutils/util/sys_qm.c
new file mode 100644
index 000000000..119a219a2
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/sys_qm.c
@@ -0,0 +1,56 @@
+/* Functions for the Linux module syscall interface.
+   Copyright 1996, 1997 Linux International.
+   Contributed by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <stdlib.h>
+#include <errno.h>
+
+#include "module.h"
+
+/* Kernel headers before 2.1.mumble need this on the Alpha to get
+   _syscall* defined.  */
+#define __LIBRARY__
+
+#include <asm/unistd.h>
+
+
+/*======================================================================*/
+
+/* I am fucking tired of the "this doesn't build on 2.0.x" questions.
+   But if you ask, we still officially require 2.1.x to build.  */
+#if !defined(__NR_query_module)
+# if defined(__i386__)
+#  define __NR_query_module 167
+# elif defined(__alpha__)
+#  define __NR_query_module 347
+# elif defined(__sparc__)
+#  define __NR_query_module 184
+# elif defined(__mc68000__)
+#  define __NR_query_module 167
+# elif defined(__arm__)
+#  define __NR_query_module (__NR_SYSCALL_BASE + 167)
+# elif defined(__mips__)
+#  define __NR_query_module 4187
+# endif
+#endif
+
+_syscall5(int, query_module, const char *, name, int, which,
+	  void *, buf, size_t, bufsize, size_t *, ret);
diff --git a/mdk-stage1/insmod-modutils/util/xftw.c b/mdk-stage1/insmod-modutils/util/xftw.c
new file mode 100644
index 000000000..fe764a63c
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/xftw.c
@@ -0,0 +1,422 @@
+/*
+ * modutils specific implementation of ftw().
+ *
+ * Copyright 2000:
+ *  Keith Owens <kaos@ocs.com.au> August 2000
+ *
+ * This file is part of the Linux modutils.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/*
+    modutils requires special processing during the file tree walk
+    of /lib/modules/<version> and any paths that the user specifies.
+    The standard ftw() does a blind walk of all paths and can end
+    up following the build symlink down the kernel source tree.
+    Although nftw() has the option to get more control such as not
+    automatically following symbolic links, even that is not enough
+    for modutils.  The requirements are:
+
+    Paths must be directories or symlinks to directories.
+
+    Each directory is read and sorted into alphabetical order
+    before processing.
+
+    A directory is type 1 iff it was specified on a path statement
+    (either explicit or default) and the directory contains a
+    subdirectory with one of the known names and the directory name
+    does not end with "/kernel".  Otherwise it is type 2.
+
+    In a type 1 directory, walk the kernel subdirectory if it exists,
+    then the old known names in their historical order then any
+    remaining directory entries in alphabetical order and finally any
+    non-directory entries in alphabetical order.
+
+    Entries in a type 1 directory are filtered against the "prune"
+    list.  A type 1 directory can contain additional files which
+    are not modules nor symlinks to modules.  The prune list skips
+    known additional files, if a distribution wants to store
+    additional text files in the top level directory they should be
+    added to the prune list.
+
+    A type 2 directory must contain only modules or symlinks to
+    modules.  They are processed in alphabetical order, without
+    pruning.  Symlinks to directories are an error in type 2
+    directories.
+
+    The user function is not called for type 1 directories, nor for
+    pruned entries.  It is called for type 2 directories and their
+    contents.  It is also called for any files left in a type 1
+    directory after pruning and processing type 2 subdirectories.
+    The user function never sees symlinks, they are resolved before
+    calling the function.
+
+    Why have different directory types?  The original file tree
+    walk was not well defined.  Some users specified each directory
+    individually, others just pointed at the top level directory.
+    Either version worked until the "build" symlink was added.  Now
+    users who specify the top level directory end up running the
+    entire kernel source tree looking for modules, not nice.  We
+    cannot just ignore symlinks because pcmcia uses symlinks to
+    modules for backwards compatibility.
+
+    Type 1 is when a user specifies the top level directory which needs
+    special processing, type 2 is individual subdirectories.  But the
+    only way to tell the difference is by looking at the contents.  The
+    "/kernel" directory introduced in 2.3.12 either contains nothing
+    (old make modules_install) or contains all the kernel modules using
+    the same tree structure as the source.  Because "/kernel" can
+    contain old names but is really a type 2 directory, it is detected
+    as a special case.
+ */
+
+#include <dirent.h>
+#include <errno.h>
+#include <limits.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+
+#include "util.h"
+#include "config.h"
+
+extern char *tbpath[];
+
+extern OPT_LIST *prune_list;
+extern int n_prune_list;
+
+extern char *tbtype[];
+
+struct xftw_dirent {
+    struct stat statbuf;
+    char *name;
+    char *fullname;
+};
+
+#define XFTW_MAXDEPTH 64    /* Maximum directory depth handled */
+
+typedef struct {
+    struct xftw_dirent *contents;
+    int size;
+    int used;
+} xftw_tree_t;
+
+static xftw_tree_t tree[XFTW_MAXDEPTH];
+
+/* Free all data for one tree level */
+static void xftw_free_tree(int depth)
+{
+    int i;
+    xftw_tree_t *t = tree+depth;
+    for (i = 0; i < t->size; ++i) {
+	free(t->contents[i].name);
+	free(t->contents[i].fullname);
+    }
+    free(t->contents);
+    t->contents = NULL;
+    t->size = 0;
+    t->used = 0;
+}
+
+/* Increment dirents used at this depth, resizing if necessary */
+static void xftw_add_dirent(int depth)
+{
+    xftw_tree_t *t = tree+depth;
+    int i, size = t->size;
+    if (++t->used < size)
+	return;
+    size += 10; /* arbitrary increment */
+    t->contents = xrealloc(t->contents, size*sizeof(*(t->contents)));
+    for (i = t->size; i < size; ++i) {
+	memset(&(t->contents[i].statbuf), 0, sizeof(t->contents[i].statbuf));
+	t->contents[i].name = NULL;
+	t->contents[i].fullname = NULL;
+    }
+    t->size = size;
+}
+
+/* Concatenate directory name and entry name into one string.
+ * Note: caller must free result or leak.
+ */
+static char *xftw_dir_name(const char *directory, const char *entry)
+{
+    int i = strlen(directory);
+    char *name;
+    if (entry)
+	i += strlen(entry);
+    i += 2;
+    name = xmalloc(i);
+    strcpy(name, directory);	/* safe, xmalloc */
+    if (*directory && entry)
+	strcat(name, "/");	/* safe, xmalloc */
+    if (entry)
+	strcat(name, entry);	/* safe, xmalloc */
+    return(name);
+}
+
+/* Call the user function for a directory entry */
+static int xftw_do_name(const char *directory, const char *entry, struct stat *sb, xftw_func_t funcptr)
+{
+    int ret = 0;
+    char *name = xftw_dir_name(directory, entry);
+
+    if (S_ISLNK(sb->st_mode)) {
+	char real[PATH_MAX], *newname;
+	verbose("resolving %s symlink to ", name);
+	if (!(newname = realpath(name, real))) {
+	    if (errno == ENOENT) {
+		verbose("%s: does not exist, dangling symlink ignored\n", real);
+		goto cleanup;
+	    }
+	    perror("... failed");
+	    goto cleanup;
+	}
+	verbose("%s ", newname);
+	if (lstat(newname, sb)) {
+	    error("lstat on %s failed ", newname);
+	    perror("");
+	    goto cleanup;
+	}
+	free(name);
+	name = xstrdup(newname);
+    }
+
+    if (!S_ISREG(sb->st_mode) &&
+	!S_ISDIR(sb->st_mode)) {
+	error("%s is not plain file nor directory\n", name);
+	goto cleanup;
+    }
+	
+    verbose("user function %s\n", name);
+    ret = (*funcptr)(name, sb);
+cleanup:
+    free(name);
+    return(ret);
+}
+
+/* Sort directory entries into alphabetical order */
+static int xftw_sortdir(const void *a, const void *b)
+{
+    return(strcmp(((struct xftw_dirent *)a)->name, ((struct xftw_dirent *)b)->name));
+}
+
+/* Read a directory and sort it, ignoring "." and ".." */
+static int xftw_readdir(const char *directory, int depth)
+{
+    DIR *d;
+    struct dirent *ent;
+    verbose("xftw_readdir %s\n", directory);
+    if (!(d = opendir(directory))) {
+	perror(directory);
+	return(1);
+    }
+    while ((ent = readdir(d))) {
+	char *name;
+	struct xftw_dirent *f;
+	if (strcmp(ent->d_name, ".") == 0 ||
+	    strcmp(ent->d_name, "..") == 0)
+	    continue;
+	name = xftw_dir_name(directory, ent->d_name);
+	xftw_add_dirent(depth); 
+	f = tree[depth].contents+tree[depth].used-1;
+	f->name = xstrdup(ent->d_name);
+	f->fullname = name;     /* do not free name, it is in use */
+	if (lstat(name, &(f->statbuf))) {
+	    perror(name);
+	    return(1);
+	}
+    }
+    closedir(d);
+    qsort(tree[depth].contents, tree[depth].used, sizeof(*(tree[0].contents)), &xftw_sortdir);
+    return(0);
+}
+
+/* Process a type 2 directory */
+int xftw_type2(const char *directory, const char *entry, int depth, xftw_func_t funcptr)
+{
+    int ret, i;
+    xftw_tree_t *t = tree+depth;
+    struct stat statbuf;
+    char *dirname = xftw_dir_name(directory, entry);
+
+    verbose("type 2 %s\n", dirname);
+    if (depth > XFTW_MAXDEPTH) {
+	error("xftw_type2 exceeded maxdepth\n");
+	ret = 1;
+	goto cleanup;
+    }
+    if ((ret = xftw_readdir(dirname, depth)))
+	goto cleanup;
+
+    t = tree+depth;
+    /* user function sees type 2 directories */
+    if ((ret = lstat(dirname, &statbuf)) ||
+	(ret = xftw_do_name("", dirname, &statbuf, funcptr)))
+	goto cleanup;
+
+    /* user sees all contents of type 2 directory, no pruning */
+    for (i = 0; i < t->used; ++i) {
+	struct xftw_dirent *c = t->contents+i;
+	if (S_ISLNK(c->statbuf.st_mode)) {
+	    if (!stat(c->name, &(c->statbuf))) {
+		if (S_ISDIR(c->statbuf.st_mode)) {
+		    error("symlink to directory is not allowed, %s ignored\n", c->name);
+		    *(c->name) = '\0';  /* ignore it */
+		}
+	    }
+	}
+	if (!*(c->name))
+	    continue;
+	if (S_ISDIR(c->statbuf.st_mode)) {
+	    /* recursion is the curse of the programming classes */
+	    ret = xftw_type2(dirname, c->name, depth+1, funcptr);
+	    if (ret)
+		goto cleanup;
+	}
+	else if ((ret = xftw_do_name(dirname, c->name, &(c->statbuf), funcptr)))
+	    goto cleanup;
+	*(c->name) = '\0';  /* processed */
+    }
+
+    ret = 0;
+cleanup:
+    free(dirname);
+    return(ret);
+}
+
+/* Only external visible function.  Decide on the type of directory and
+ * process accordingly.
+ */
+int xftw(const char *directory, xftw_func_t funcptr)
+{
+    struct stat statbuf;
+    int ret, i, j, type;
+    xftw_tree_t *t;
+    struct xftw_dirent *c;
+
+    verbose("xftw starting at %s ", directory);
+    if (lstat(directory, &statbuf)) {
+	verbose("lstat on %s failed\n", directory);
+	return(0);
+    }
+    if (S_ISLNK(statbuf.st_mode)) {
+	char real[PATH_MAX];
+	verbose("resolving symlink to ");
+	if (!(directory = realpath(directory, real))) {
+	    if (errno == ENOENT) {
+		verbose("%s: does not exist, dangling symlink ignored\n", real);
+		return(0);
+	    }
+	    perror("... failed");
+	    return(-1);
+	}
+	verbose("%s ", directory);
+	if (lstat(directory, &statbuf)) {
+	    error("lstat on %s failed ", directory);
+	    perror("");
+	    return(-1);
+	}
+    }
+    if (!S_ISDIR(statbuf.st_mode)) {
+	error("%s is not a directory\n", directory);
+	return(-1);
+    }
+    verbose("\n");
+
+    /* All returns after this point must be via cleanup */
+
+    if ((ret = xftw_readdir(directory, 0)))
+	goto cleanup;
+
+    t = tree;   /* depth 0 */
+    type = 2;
+    for (i = 0 ; type == 2 && i < t->used; ++i) {
+	c = t->contents+i;
+	for (j = 0; tbtype[j]; ++j) {
+	    if (strcmp(c->name, tbtype[j]) == 0 &&
+		S_ISDIR(c->statbuf.st_mode)) {
+		const char *p = directory + strlen(directory) - 1;
+		if (*p == '/')
+		    --p;
+		if (p - directory >= 6 && strncmp(p-6, "/kernel", 7) == 0)
+		    continue;	/* "/kernel" path is a special case, type 2 */
+		type = 1;   /* known subdirectory */
+		break;
+	    }
+	}
+    }
+
+    if (type == 1) {
+	OPT_LIST *p;
+	/* prune entries in type 1 directories only */
+	for (i = 0 ; i < t->used; ++i) {
+	    for (p = prunelist; p->name; ++p) {
+		c = t->contents+i;
+		if (strcmp(p->name, c->name) == 0) {
+		    verbose("pruned %s\n", c->name);
+		    *(c->name) = '\0';  /* ignore */
+		}
+	    }
+	}
+	/* run known subdirectories first in historical order, "kernel" is now top of list */
+	for (i = 0 ; i < t->used; ++i) {
+	    c = t->contents+i;
+	    for (j = 0; tbtype[j]; ++j) {
+		if (*(c->name) &&
+		    strcmp(c->name, tbtype[j]) == 0 &&
+		    S_ISDIR(c->statbuf.st_mode)) {
+		    if ((ret = xftw_type2(directory, c->name, 1, funcptr)))
+			goto cleanup;
+		    *(c->name) = '\0';  /* processed */
+		}
+	    }
+	}
+	/* any other directories left, in alphabetical order */
+	for (i = 0 ; i < t->used; ++i) {
+	    c = t->contents+i;
+	    if (*(c->name) &&
+	        S_ISDIR(c->statbuf.st_mode)) {
+		if ((ret = xftw_type2(directory, c->name, 1, funcptr)))
+		    goto cleanup;
+		*(c->name) = '\0';  /* processed */
+	    }
+	}
+	/* anything else is passed to the user function */
+	for (i = 0 ; i < t->used; ++i) {
+	    c = t->contents+i;
+	    if (*(c->name)) {
+		verbose("%s found in type 1 directory %s\n", c->name, directory);
+		if ((ret = xftw_do_name(directory, c->name, &(c->statbuf), funcptr)))
+		    goto cleanup;
+		*(c->name) = '\0';  /* processed */
+	    }
+	}
+    }
+    else {
+	/* type 2 */
+	xftw_free_tree(0);
+	if ((ret = xftw_type2(directory, NULL, 0, funcptr)))
+	    goto cleanup;
+    }
+
+    /* amazing, it all worked */
+    ret = 0;
+cleanup:
+    for (i = 0; i < XFTW_MAXDEPTH; ++i)
+	xftw_free_tree(i);
+    return(ret);
+}
diff --git a/mdk-stage1/insmod-modutils/util/xmalloc.c b/mdk-stage1/insmod-modutils/util/xmalloc.c
new file mode 100644
index 000000000..9113d47fe
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/xmalloc.c
@@ -0,0 +1,39 @@
+/* Misc utility functions.
+   Copyright 1996, 1997 Linux International.
+   Contributed by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <stdlib.h>
+#include "util.h"
+
+
+/*======================================================================*/
+
+void *
+xmalloc(size_t size)
+{
+  void *ptr = malloc(size);
+  if (!ptr)
+    {
+      error("Out of memory");
+      exit(1);
+    }
+  return ptr;
+}
diff --git a/mdk-stage1/insmod-modutils/util/xrealloc.c b/mdk-stage1/insmod-modutils/util/xrealloc.c
new file mode 100644
index 000000000..d287486f7
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/xrealloc.c
@@ -0,0 +1,39 @@
+/* Misc utility functions.
+   Copyright 1996, 1997 Linux International.
+   Contributed by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <stdlib.h>
+#include "util.h"
+
+
+/*======================================================================*/
+
+void *
+xrealloc(void *old, size_t size)
+{
+  void *ptr = realloc(old, size);
+  if (!ptr)
+    {
+      error("Out of memory");
+      exit(1);
+    }
+  return ptr;
+}
diff --git a/mdk-stage1/insmod-modutils/util/xstrcat.c b/mdk-stage1/insmod-modutils/util/xstrcat.c
new file mode 100644
index 000000000..abb075c83
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/xstrcat.c
@@ -0,0 +1,40 @@
+/* Misc utility functions.
+   Copyright 2000 Keith Owens <kaos@ocs.com.au>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id"
+
+#include <stdlib.h>
+#include <string.h>
+#include "util.h"
+
+
+/*======================================================================*/
+
+char *
+xstrcat(char *dest, const char *src, size_t size)
+{
+  int ldest = strlen(dest);
+  int lsrc = strlen(src);
+  if ((size - ldest - 1) < lsrc) {
+    error("xstrcat: destination overflow");
+    exit(1);
+  }
+  memcpy(dest+ldest, src, lsrc+1);
+  return(dest);
+}
diff --git a/mdk-stage1/insmod-modutils/util/xstrdup.c b/mdk-stage1/insmod-modutils/util/xstrdup.c
new file mode 100644
index 000000000..11b289eb0
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/xstrdup.c
@@ -0,0 +1,41 @@
+/* Misc utility functions.
+   Copyright 1996, 1997 Linux International.
+   Contributed by Richard Henderson <rth@tamu.edu>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id$"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "util.h"
+
+
+/*======================================================================*/
+
+char *
+xstrdup(const char *s)
+{
+  char *n = strdup(s);
+  if (!n)
+    {
+      error("Out of memory");
+      exit(1);
+    }
+  return n;
+}
diff --git a/mdk-stage1/insmod-modutils/util/xsystem.c b/mdk-stage1/insmod-modutils/util/xsystem.c
new file mode 100644
index 000000000..edb995268
--- /dev/null
+++ b/mdk-stage1/insmod-modutils/util/xsystem.c
@@ -0,0 +1,51 @@
+/* Misc utility functions.
+   Copyright 2000 Keith Owens <kaos@ocs.com.au>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ident "$Id"
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <errno.h>
+#include <unistd.h>
+
+
+/*======================================================================*/
+
+/* Clone of the system() function From Steven's Advanced Programming in a Unix
+ * Environment.  Modified to use *argv[] and execvp to avoid shell expansion
+ * problems, modutils runs as root so system() is unsafe.
+ */
+
+int
+xsystem(const char *file, char *const argv[])
+{
+  pid_t pid;
+  int status;
+  if ((pid = fork()) < 0)
+    return(-1);
+  if (pid == 0) {
+    execvp(file, argv);
+    _exit(127);
+  }
+  while (waitpid(pid, &status, 0) < 0) {
+    if (errno != EINTR)
+      return(-1);
+  }
+  return(status);
+}
diff --git a/mdk-stage1/insmod.h b/mdk-stage1/insmod.h
new file mode 100644
index 000000000..d91f239cf
--- /dev/null
+++ b/mdk-stage1/insmod.h
@@ -0,0 +1,20 @@
+/*
+ * Guillaume Cottenceau (gc@mandrakesoft.com)
+ *
+ * Copyright 2000 MandrakeSoft
+ *
+ * This software may be freely redistributed under the terms of the GNU
+ * public license.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef _INSMOD_INTERFACE_H_
+#define _INSMOD_INTERFACE_H_
+
+int insmod_call(char * full_filename, char * params);
+
+#endif
diff --git a/mdk-stage1/modules.c b/mdk-stage1/modules.c
index 1b85fa7c8..2788315f8 100644
--- a/mdk-stage1/modules.c
+++ b/mdk-stage1/modules.c
@@ -25,7 +25,7 @@
 #include <unistd.h>
 #include <string.h>
 #include <stdio.h>
-#include "insmod-busybox/insmod.h"
+#include "insmod.h"
 #include "stage1.h"
 #include "log.h"
 #include "mar/mar-extract-only.h"
diff --git a/mdk-stage1/stage1.c b/mdk-stage1/stage1.c
index 64753bdcf..8956a2a7f 100644
--- a/mdk-stage1/stage1.c
+++ b/mdk-stage1/stage1.c
@@ -45,7 +45,7 @@
 #include "tools.h"
 #include "automatic.h"
 #include "mount.h"
-#include "insmod-busybox/insmod.h"
+#include "insmod.h"
 
 #ifdef ENABLE_PCMCIA
 #include "pcmcia/pcmcia.h"