1 /* vi: set sw=4 ts=4: */
3 * Mini insmod implementation for busybox
5 * This version of insmod supports x86, ARM, SH3/4, powerpc, m68k,
8 * Copyright (C) 1999,2000 by Lineo, inc. and Erik Andersen
9 * Copyright (C) 1999,2000,2001 by Erik Andersen <andersee@debian.org>
10 * and Ron Alder <alder@lineo.com>
12 * Modified by Bryan Rittmeyer <bryan@ixiacom.com> to support SH4
13 * and (theoretically) SH3. I have only tested SH4 in little endian mode.
15 * Modified by Alcove, Julien Gaulmin <julien.gaulmin@alcove.fr> and
16 * Nicolas Ferre <nicolas.ferre@alcove.fr> to support ARM7TDMI. Only
17 * very minor changes required to also work with StrongArm and presumably
18 * all ARM based systems.
20 * Magnus Damm <damm@opensource.se> added PowerPC support 20-Feb-2001.
21 * PowerPC specific code stolen from modutils-2.3.16,
22 * written by Paul Mackerras, Copyright 1996, 1997 Linux International.
23 * I've only tested the code on mpc8xx platforms in big-endian mode.
24 * Did some cleanup and added CONFIG_USE_xxx_ENTRIES...
26 * Quinn Jensen <jensenq@lineo.com> added MIPS support 23-Feb-2001.
27 * based on modutils-2.4.2
28 * MIPS specific support for Elf loading and relocation.
29 * Copyright 1996, 1997 Linux International.
30 * Contributed by Ralf Baechle <ralf@gnu.ai.mit.edu>
32 * Based almost entirely on the Linux modutils-2.3.11 implementation.
33 * Copyright 1996, 1997 Linux International.
34 * New implementation contributed by Richard Henderson <rth@tamu.edu>
35 * Based on original work by Bjorn Ekwall <bj0rn@blox.se>
36 * Restructured (and partly rewritten) by:
37 * Björn Ekwall <bj0rn@blox.se> February 1999
39 * This program is free software; you can redistribute it and/or modify
40 * it under the terms of the GNU General Public License as published by
41 * the Free Software Foundation; either version 2 of the License, or
42 * (at your option) any later version.
44 * This program is distributed in the hope that it will be useful,
45 * but WITHOUT ANY WARRANTY; without even the implied warranty of
46 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
47 * General Public License for more details.
49 * You should have received a copy of the GNU General Public License
50 * along with this program; if not, write to the Free Software
51 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
65 #include <sys/utsname.h>
68 #ifdef CONFIG_FEATURE_NEW_MODULE_INTERFACE
69 # undef CONFIG_FEATURE_OLD_MODULE_INTERFACE
70 # define new_sys_init_module init_module
72 # define old_sys_init_module init_module
75 #ifdef CONFIG_FEATURE_INSMOD_LOADINKMEM
81 #if defined(__powerpc__)
82 #define CONFIG_USE_PLT_ENTRIES
83 #define CONFIG_PLT_ENTRY_SIZE 16
87 #define CONFIG_USE_PLT_ENTRIES
88 #define CONFIG_PLT_ENTRY_SIZE 8
89 #define CONFIG_USE_GOT_ENTRIES
90 #define CONFIG_GOT_ENTRY_SIZE 8
94 #define CONFIG_USE_GOT_ENTRIES
95 #define CONFIG_GOT_ENTRY_SIZE 4
99 #define CONFIG_USE_GOT_ENTRIES
100 #define CONFIG_GOT_ENTRY_SIZE 4
103 #if defined(__mips__)
107 //----------------------------------------------------------------------------
108 //--------modutils module.h, lines 45-242
109 //----------------------------------------------------------------------------
111 /* Definitions for the Linux module syscall interface.
112 Copyright 1996, 1997 Linux International.
114 Contributed by Richard Henderson <rth@tamu.edu>
116 This file is part of the Linux modutils.
118 This program is free software; you can redistribute it and/or modify it
119 under the terms of the GNU General Public License as published by the
120 Free Software Foundation; either version 2 of the License, or (at your
121 option) any later version.
123 This program is distributed in the hope that it will be useful, but
124 WITHOUT ANY WARRANTY; without even the implied warranty of
125 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
126 General Public License for more details.
128 You should have received a copy of the GNU General Public License
129 along with this program; if not, write to the Free Software Foundation,
130 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
133 #ifndef MODUTILS_MODULE_H
134 static const int MODUTILS_MODULE_H = 1;
136 #ident "$Id: insmod.c,v 1.78 2001/12/29 04:15:13 andersen Exp $"
138 /* This file contains the structures used by the 2.0 and 2.1 kernels.
139 We do not use the kernel headers directly because we do not wish
140 to be dependant on a particular kernel version to compile insmod. */
143 /*======================================================================*/
144 /* The structures used by Linux 2.0. */
146 /* The symbol format used by get_kernel_syms(2). */
147 struct old_kernel_sym
153 struct old_module_ref
155 unsigned long module; /* kernel addresses */
159 struct old_module_symbol
165 struct old_symbol_table
167 int size; /* total, including string table!!! */
170 struct old_module_symbol symbol[0]; /* actual size defined by n_symbols */
171 struct old_module_ref ref[0]; /* actual size defined by n_refs */
174 struct old_mod_routines
177 unsigned long cleanup;
183 unsigned long ref; /* the list of modules that refer to me */
184 unsigned long symtab;
186 int size; /* size of module in pages */
187 unsigned long addr; /* address of module */
189 unsigned long cleanup; /* cleanup routine */
192 /* Sent to init_module(2) or'ed into the code size parameter. */
193 static const int OLD_MOD_AUTOCLEAN = 0x40000000; /* big enough, but no sign problems... */
195 int get_kernel_syms(struct old_kernel_sym *);
196 int old_sys_init_module(const char *name, char *code, unsigned codesize,
197 struct old_mod_routines *, struct old_symbol_table *);
199 /*======================================================================*/
200 /* For sizeof() which are related to the module platform and not to the
201 environment isnmod is running in, use sizeof_xx instead of sizeof(xx). */
203 #define tgt_sizeof_char sizeof(char)
204 #define tgt_sizeof_short sizeof(short)
205 #define tgt_sizeof_int sizeof(int)
206 #define tgt_sizeof_long sizeof(long)
207 #define tgt_sizeof_char_p sizeof(char *)
208 #define tgt_sizeof_void_p sizeof(void *)
209 #define tgt_long long
211 #if defined(__sparc__) && !defined(__sparc_v9__) && defined(ARCH_sparc64)
212 #undef tgt_sizeof_long
213 #undef tgt_sizeof_char_p
214 #undef tgt_sizeof_void_p
216 static const int tgt_sizeof_long = 8;
217 static const int tgt_sizeof_char_p = 8;
218 static const int tgt_sizeof_void_p = 8;
219 #define tgt_long long long
222 /*======================================================================*/
223 /* The structures used in Linux 2.1. */
225 /* Note: new_module_symbol does not use tgt_long intentionally */
226 struct new_module_symbol
232 struct new_module_persist;
234 struct new_module_ref
236 unsigned tgt_long dep; /* kernel addresses */
237 unsigned tgt_long ref;
238 unsigned tgt_long next_ref;
243 unsigned tgt_long size_of_struct; /* == sizeof(module) */
244 unsigned tgt_long next;
245 unsigned tgt_long name;
246 unsigned tgt_long size;
249 unsigned tgt_long flags; /* AUTOCLEAN et al */
254 unsigned tgt_long syms;
255 unsigned tgt_long deps;
256 unsigned tgt_long refs;
257 unsigned tgt_long init;
258 unsigned tgt_long cleanup;
259 unsigned tgt_long ex_table_start;
260 unsigned tgt_long ex_table_end;
262 unsigned tgt_long gp;
264 /* Everything after here is extension. */
265 unsigned tgt_long persist_start;
266 unsigned tgt_long persist_end;
267 unsigned tgt_long can_unload;
268 unsigned tgt_long runsize;
269 #ifdef CONFIG_FEATURE_NEW_MODULE_INTERFACE
270 const char *kallsyms_start; /* All symbols for kernel debugging */
271 const char *kallsyms_end;
272 const char *archdata_start; /* arch specific data for module */
273 const char *archdata_end;
274 const char *kernel_data; /* Reserved for kernel internal use */
278 #define ARCHDATA_SEC_NAME "__archdata"
279 #define KALLSYMS_SEC_NAME "__kallsyms"
282 struct new_module_info
290 /* Bits of module.flags. */
291 static const int NEW_MOD_RUNNING = 1;
292 static const int NEW_MOD_DELETED = 2;
293 static const int NEW_MOD_AUTOCLEAN = 4;
294 static const int NEW_MOD_VISITED = 8;
295 static const int NEW_MOD_USED_ONCE = 16;
297 int new_sys_init_module(const char *name, const struct new_module *);
298 int query_module(const char *name, int which, void *buf, size_t bufsize,
301 /* Values for query_module's which. */
303 static const int QM_MODULES = 1;
304 static const int QM_DEPS = 2;
305 static const int QM_REFS = 3;
306 static const int QM_SYMBOLS = 4;
307 static const int QM_INFO = 5;
309 /*======================================================================*/
310 /* The system calls unchanged between 2.0 and 2.1. */
312 unsigned long create_module(const char *, size_t);
313 int delete_module(const char *);
316 #endif /* module.h */
318 //----------------------------------------------------------------------------
319 //--------end of modutils module.h
320 //----------------------------------------------------------------------------
324 //----------------------------------------------------------------------------
325 //--------modutils obj.h, lines 253-462
326 //----------------------------------------------------------------------------
328 /* Elf object file loading and relocation routines.
329 Copyright 1996, 1997 Linux International.
331 Contributed by Richard Henderson <rth@tamu.edu>
333 This file is part of the Linux modutils.
335 This program is free software; you can redistribute it and/or modify it
336 under the terms of the GNU General Public License as published by the
337 Free Software Foundation; either version 2 of the License, or (at your
338 option) any later version.
340 This program is distributed in the hope that it will be useful, but
341 WITHOUT ANY WARRANTY; without even the implied warranty of
342 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
343 General Public License for more details.
345 You should have received a copy of the GNU General Public License
346 along with this program; if not, write to the Free Software Foundation,
347 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
350 #ifndef MODUTILS_OBJ_H
351 static const int MODUTILS_OBJ_H = 1;
353 #ident "$Id: insmod.c,v 1.78 2001/12/29 04:15:13 andersen Exp $"
355 /* The relocatable object is manipulated using elfin types. */
361 /* Machine-specific elf macros for i386 et al. */
363 /* the SH changes have only been tested on the SH4 in =little endian= mode */
364 /* I'm not sure about big endian, so let's warn: */
366 #if (defined(__SH4__) || defined(__SH3__)) && defined(__BIG_ENDIAN__)
367 #error insmod.c may require changes for use on big endian SH4/SH3
370 /* it may or may not work on the SH1/SH2... So let's error on those
372 #if (defined(__sh__) && (!(defined(__SH3__) || defined(__SH4__))))
373 #error insmod.c may require changes for non-SH3/SH4 use
376 #define ELFCLASSM ELFCLASS32
378 #if (defined(__mc68000__))
379 #define ELFDATAM ELFDATA2MSB
386 #define MATCH_MACHINE(x) (x == EM_SH)
387 #define SHT_RELM SHT_RELA
388 #define Elf32_RelM Elf32_Rela
389 #define ELFDATAM ELFDATA2LSB
391 #elif defined(__arm__)
393 #define MATCH_MACHINE(x) (x == EM_ARM)
394 #define SHT_RELM SHT_REL
395 #define Elf32_RelM Elf32_Rel
397 #define ELFDATAM ELFDATA2MSB
400 #define ELFDATAM ELFDATA2LSB
403 #elif defined(__powerpc__)
405 #define MATCH_MACHINE(x) (x == EM_PPC)
406 #define SHT_RELM SHT_RELA
407 #define Elf32_RelM Elf32_Rela
408 #define ELFDATAM ELFDATA2MSB
410 #elif defined(__mips__)
412 /* Account for ELF spec changes. */
413 #ifndef EM_MIPS_RS3_LE
414 #ifdef EM_MIPS_RS4_BE
415 #define EM_MIPS_RS3_LE EM_MIPS_RS4_BE
417 #define EM_MIPS_RS3_LE 10
419 #endif /* !EM_MIPS_RS3_LE */
421 #define MATCH_MACHINE(x) (x == EM_MIPS || x == EM_MIPS_RS3_LE)
422 #define SHT_RELM SHT_REL
423 #define Elf32_RelM Elf32_Rel
425 #define ELFDATAM ELFDATA2MSB
428 #define ELFDATAM ELFDATA2LSB
431 #elif defined(__i386__)
433 /* presumably we can use these for anything but the SH and ARM*/
434 /* this is the previous behavior, but it does result in
435 insmod.c being broken on anything except i386 */
437 #define MATCH_MACHINE(x) (x == EM_386)
439 #define MATCH_MACHINE(x) (x == EM_386 || x == EM_486)
442 #define SHT_RELM SHT_REL
443 #define Elf32_RelM Elf32_Rel
444 #define ELFDATAM ELFDATA2LSB
446 #elif defined(__mc68000__)
448 #define MATCH_MACHINE(x) (x == EM_68K)
449 #define SHT_RELM SHT_RELA
450 #define Elf32_RelM Elf32_Rela
453 #error Sorry, but insmod.c does not yet support this architecture...
457 # if ELFCLASSM == ELFCLASS32
458 # define ElfW(x) Elf32_ ## x
459 # define ELFW(x) ELF32_ ## x
461 # define ElfW(x) Elf64_ ## x
462 # define ELFW(x) ELF64_ ## x
466 /* For some reason this is missing from libc5. */
467 #ifndef ELF32_ST_INFO
468 # define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
471 #ifndef ELF64_ST_INFO
472 # define ELF64_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
475 struct obj_string_patch;
476 struct obj_symbol_patch;
483 struct obj_section *load_next;
489 struct obj_symbol *next; /* hash table link */
493 int secidx; /* the defining section index/module */
495 int ksymidx; /* for export to the kernel symtab */
496 int referenced; /* actually used in the link */
499 /* Hardcode the hash table size. We shouldn't be needing so many
500 symbols that we begin to degrade performance, and we get a big win
501 by giving the compiler a constant divisor. */
503 #define HASH_BUCKETS 521
509 struct obj_section **sections;
510 struct obj_section *load_order;
511 struct obj_section **load_order_search_start;
512 struct obj_string_patch *string_patches;
513 struct obj_symbol_patch *symbol_patches;
514 int (*symbol_cmp)(const char *, const char *);
515 unsigned long (*symbol_hash)(const char *);
516 unsigned long local_symtab_size;
517 struct obj_symbol **local_symtab;
518 struct obj_symbol *symtab[HASH_BUCKETS];
529 struct obj_string_patch
531 struct obj_string_patch *next;
533 ElfW(Addr) reloc_offset;
534 ElfW(Addr) string_offset;
537 struct obj_symbol_patch
539 struct obj_symbol_patch *next;
541 ElfW(Addr) reloc_offset;
542 struct obj_symbol *sym;
546 /* Generic object manipulation routines. */
548 static unsigned long obj_elf_hash(const char *);
550 static unsigned long obj_elf_hash_n(const char *, unsigned long len);
552 static struct obj_symbol *obj_find_symbol (struct obj_file *f,
555 static ElfW(Addr) obj_symbol_final_value(struct obj_file *f,
556 struct obj_symbol *sym);
558 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
559 static void obj_set_symbol_compare(struct obj_file *f,
560 int (*cmp)(const char *, const char *),
561 unsigned long (*hash)(const char *));
564 static struct obj_section *obj_find_section (struct obj_file *f,
567 static void obj_insert_section_load_order (struct obj_file *f,
568 struct obj_section *sec);
570 static struct obj_section *obj_create_alloced_section (struct obj_file *f,
575 static struct obj_section *obj_create_alloced_section_first (struct obj_file *f,
580 static void *obj_extend_section (struct obj_section *sec, unsigned long more);
582 static int obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
585 #ifdef CONFIG_FEATURE_NEW_MODULE_INTERFACE
586 static int obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
587 struct obj_symbol *sym);
590 static int obj_check_undefineds(struct obj_file *f);
592 static void obj_allocate_commons(struct obj_file *f);
594 static unsigned long obj_load_size (struct obj_file *f);
596 static int obj_relocate (struct obj_file *f, ElfW(Addr) base);
598 static struct obj_file *obj_load(FILE *f, int loadprogbits);
600 static int obj_create_image (struct obj_file *f, char *image);
602 /* Architecture specific manipulation routines. */
604 static struct obj_file *arch_new_file (void);
606 static struct obj_section *arch_new_section (void);
608 static struct obj_symbol *arch_new_symbol (void);
610 static enum obj_reloc arch_apply_relocation (struct obj_file *f,
611 struct obj_section *targsec,
612 struct obj_section *symsec,
613 struct obj_symbol *sym,
614 ElfW(RelM) *rel, ElfW(Addr) value);
616 static int arch_create_got (struct obj_file *f);
618 #ifdef CONFIG_FEATURE_NEW_MODULE_INTERFACE
619 static int arch_init_module (struct obj_file *f, struct new_module *);
623 //----------------------------------------------------------------------------
624 //--------end of modutils obj.h
625 //----------------------------------------------------------------------------
631 #define _PATH_MODULES "/lib/modules"
632 static const int STRVERSIONLEN = 32;
634 /*======================================================================*/
636 static int flag_force_load = 0;
637 static int flag_autoclean = 0;
638 static int flag_verbose = 0;
639 static int flag_export = 1;
642 /*======================================================================*/
644 /* previously, these were named i386_* but since we could be
645 compiling for the sh, I've renamed them to the more general
646 arch_* These structures are the same between the x86 and SH,
647 and we can't support anything else right now anyway. In the
648 future maybe they should be #if defined'd */
654 #if defined(CONFIG_USE_PLT_ENTRIES)
655 struct arch_plt_entry
659 int inited:1; /* has been set up */
663 #if defined(CONFIG_USE_GOT_ENTRIES)
664 struct arch_got_entry {
666 unsigned offset_done:1;
667 unsigned reloc_done:1;
671 #if defined(__mips__)
674 struct mips_hi16 *next;
681 struct obj_file root;
682 #if defined(CONFIG_USE_PLT_ENTRIES)
683 struct obj_section *plt;
685 #if defined(CONFIG_USE_GOT_ENTRIES)
686 struct obj_section *got;
688 #if defined(__mips__)
689 struct mips_hi16 *mips_hi16_list;
694 struct obj_symbol root;
695 #if defined(CONFIG_USE_PLT_ENTRIES)
696 struct arch_plt_entry pltent;
698 #if defined(CONFIG_USE_GOT_ENTRIES)
699 struct arch_got_entry gotent;
704 struct external_module {
709 struct new_module_symbol *syms;
712 static struct new_module_symbol *ksyms;
713 static size_t nksyms;
715 static struct external_module *ext_modules;
716 static int n_ext_modules;
717 static int n_ext_modules_used;
718 extern int delete_module(const char *);
720 static char m_filename[FILENAME_MAX + 1];
721 static char m_fullName[FILENAME_MAX + 1];
725 /*======================================================================*/
728 static int check_module_name_match(const char *filename, struct stat *statbuf,
731 char *fullname = (char *) userdata;
733 if (fullname[0] == '\0')
736 char *tmp, *tmp1 = xstrdup(filename);
737 tmp = get_last_path_component(tmp1);
738 if (strcmp(tmp, fullname) == 0) {
740 /* Stop searching if we find a match */
741 safe_strncpy(m_filename, filename, sizeof(m_filename));
750 /*======================================================================*/
752 static struct obj_file *arch_new_file(void)
755 f = xmalloc(sizeof(*f));
757 #if defined(CONFIG_USE_PLT_ENTRIES)
760 #if defined(CONFIG_USE_GOT_ENTRIES)
763 #if defined(__mips__)
764 f->mips_hi16_list = NULL;
770 static struct obj_section *arch_new_section(void)
772 return xmalloc(sizeof(struct obj_section));
775 static struct obj_symbol *arch_new_symbol(void)
777 struct arch_symbol *sym;
778 sym = xmalloc(sizeof(*sym));
780 #if defined(CONFIG_USE_PLT_ENTRIES)
781 memset(&sym->pltent, 0, sizeof(sym->pltent));
783 #if defined(CONFIG_USE_GOT_ENTRIES)
784 memset(&sym->gotent, 0, sizeof(sym->gotent));
790 static enum obj_reloc
791 arch_apply_relocation(struct obj_file *f,
792 struct obj_section *targsec,
793 struct obj_section *symsec,
794 struct obj_symbol *sym,
795 ElfW(RelM) *rel, ElfW(Addr) v)
797 struct arch_file *ifile = (struct arch_file *) f;
798 #if !(defined(__mips__))
799 struct arch_symbol *isym = (struct arch_symbol *) sym;
802 ElfW(Addr) *loc = (ElfW(Addr) *) (targsec->contents + rel->r_offset);
803 ElfW(Addr) dot = targsec->header.sh_addr + rel->r_offset;
804 #if defined(CONFIG_USE_GOT_ENTRIES)
805 ElfW(Addr) got = ifile->got ? ifile->got->header.sh_addr : 0;
807 #if defined(CONFIG_USE_PLT_ENTRIES)
808 ElfW(Addr) plt = ifile->plt ? ifile->plt->header.sh_addr : 0;
809 struct arch_plt_entry *pe;
812 enum obj_reloc ret = obj_reloc_ok;
814 switch (ELF32_R_TYPE(rel->r_info)) {
816 /* even though these constants seem to be the same for
817 the i386 and the sh, we "#if define" them for clarity
818 and in case that ever changes */
821 #elif defined(__arm__)
823 #elif defined(__i386__)
825 #elif defined(__mc68000__)
827 #elif defined(__powerpc__)
829 #elif defined(__mips__)
836 #elif defined(__arm__)
838 #elif defined(__i386__)
840 #elif defined(__mc68000__)
842 #elif defined(__powerpc__)
844 #elif defined(__mips__)
849 #if defined(__mc68000__)
852 ret = obj_reloc_overflow;
857 ret = obj_reloc_overflow;
860 #endif /* __mc68000__ */
862 #if defined(__powerpc__)
863 case R_PPC_ADDR16_HA:
864 *(unsigned short *)loc = (v + 0x8000) >> 16;
867 case R_PPC_ADDR16_HI:
868 *(unsigned short *)loc = v >> 16;
871 case R_PPC_ADDR16_LO:
872 *(unsigned short *)loc = v;
876 #if defined(__mips__)
879 ret = obj_reloc_dangerous;
880 if ((v & 0xf0000000) != ((dot + 4) & 0xf0000000))
881 ret = obj_reloc_overflow;
883 (*loc & ~0x03ffffff) | ((*loc + (v >> 2)) &
891 /* We cannot relocate this one now because we don't know the value
892 of the carry we need to add. Save the information, and let LO16
893 do the actual relocation. */
894 n = (struct mips_hi16 *) xmalloc(sizeof *n);
897 n->next = ifile->mips_hi16_list;
898 ifile->mips_hi16_list = n;
904 unsigned long insnlo = *loc;
905 Elf32_Addr val, vallo;
907 /* Sign extend the addend we extract from the lo insn. */
908 vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
910 if (ifile->mips_hi16_list != NULL) {
913 l = ifile->mips_hi16_list;
915 struct mips_hi16 *next;
918 /* The value for the HI16 had best be the same. */
919 assert(v == l->value);
921 /* Do the HI16 relocation. Note that we actually don't
922 need to know anything about the LO16 itself, except where
923 to find the low 16 bits of the addend needed by the LO16. */
926 ((insn & 0xffff) << 16) +
930 /* Account for the sign extension that will happen in the
937 insn = (insn & ~0xffff) | val;
945 ifile->mips_hi16_list = NULL;
948 /* Ok, we're done with the HI16 relocs. Now deal with the LO16. */
950 insnlo = (insnlo & ~0xffff) | (val & 0xffff);
957 #elif defined(__sh__)
961 #elif defined(__i386__)
966 #elif defined(__mc68000__)
969 if ((Elf32_Sword)v > 0x7f || (Elf32_Sword)v < -(Elf32_Sword)0x80)
970 ret = obj_reloc_overflow;
975 if ((Elf32_Sword)v > 0x7fff || (Elf32_Sword)v < -(Elf32_Sword)0x8000)
976 ret = obj_reloc_overflow;
980 *(int *)loc = v - dot;
982 #elif defined(__powerpc__)
992 #elif defined(__i386__)
995 #if defined(CONFIG_USE_PLT_ENTRIES)
1001 #if defined(__powerpc__)
1004 /* find the plt entry and initialize it if necessary */
1005 assert(isym != NULL);
1007 pe = (struct arch_plt_entry*) &isym->pltent;
1010 ip = (unsigned long *) (ifile->plt->contents + pe->offset);
1012 /* generate some machine code */
1014 #if defined(__arm__)
1015 ip[0] = 0xe51ff004; /* ldr pc,[pc,#-4] */
1016 ip[1] = v; /* sym@ */
1018 #if defined(__powerpc__)
1019 ip[0] = 0x3d600000 + ((v + 0x8000) >> 16); /* lis r11,sym@ha */
1020 ip[1] = 0x396b0000 + (v & 0xffff); /* addi r11,r11,sym@l */
1021 ip[2] = 0x7d6903a6; /* mtctr r11 */
1022 ip[3] = 0x4e800420; /* bctr */
1027 /* relative distance to target */
1029 /* if the target is too far away.... */
1030 if ((int)v < -0x02000000 || (int)v >= 0x02000000) {
1031 /* go via the plt */
1032 v = plt + pe->offset - dot;
1035 ret = obj_reloc_dangerous;
1037 /* merge the offset into the instruction. */
1038 #if defined(__arm__)
1039 /* Convert to words. */
1042 *loc = (*loc & ~0x00ffffff) | ((v + *loc) & 0x00ffffff);
1044 #if defined(__powerpc__)
1045 *loc = (*loc & ~0x03fffffc) | (v & 0x03fffffc);
1048 #endif /* CONFIG_USE_PLT_ENTRIES */
1050 #if defined(__arm__)
1051 #elif defined(__sh__)
1056 #elif defined(__i386__)
1057 case R_386_GLOB_DAT:
1058 case R_386_JMP_SLOT:
1061 #elif defined(__mc68000__)
1062 case R_68K_GLOB_DAT:
1063 case R_68K_JMP_SLOT:
1068 #if defined(__arm__)
1069 #elif defined(__sh__)
1071 *loc += f->baseaddr + rel->r_addend;
1073 #elif defined(__i386__)
1074 case R_386_RELATIVE:
1075 *loc += f->baseaddr;
1077 #elif defined(__mc68000__)
1078 case R_68K_RELATIVE:
1079 *(int *)loc += f->baseaddr;
1083 #if defined(CONFIG_USE_GOT_ENTRIES)
1085 #if !defined(__68k__)
1088 #elif defined(__arm__)
1090 #elif defined(__i386__)
1095 *loc += got - dot + rel->r_addend;;
1096 #elif defined(__i386__) || defined(__arm__) || defined(__m68k_)
1104 #elif defined(__arm__)
1106 #elif defined(__i386__)
1108 #elif defined(__mc68000__)
1111 assert(isym != NULL);
1112 /* needs an entry in the .got: set it, once */
1113 if (!isym->gotent.reloc_done) {
1114 isym->gotent.reloc_done = 1;
1115 *(ElfW(Addr) *) (ifile->got->contents + isym->gotent.offset) = v;
1117 /* make the reloc with_respect_to_.got */
1119 *loc += isym->gotent.offset + rel->r_addend;
1120 #elif defined(__i386__) || defined(__arm__) || defined(__mc68000__)
1121 *loc += isym->gotent.offset;
1125 /* address relative to the got */
1126 #if !defined(__mc68000__)
1129 #elif defined(__arm__)
1131 #elif defined(__i386__)
1133 #elif defined(__mc68000__)
1139 #endif // __mc68000__
1141 #endif /* CONFIG_USE_GOT_ENTRIES */
1144 printf("Warning: unhandled reloc %d\n",(int)ELF32_R_TYPE(rel->r_info));
1145 ret = obj_reloc_unhandled;
1152 static int arch_create_got(struct obj_file *f)
1154 #if defined(CONFIG_USE_GOT_ENTRIES) || defined(CONFIG_USE_PLT_ENTRIES)
1155 struct arch_file *ifile = (struct arch_file *) f;
1157 #if defined(CONFIG_USE_GOT_ENTRIES)
1158 int got_offset = 0, gotneeded = 0;
1160 #if defined(CONFIG_USE_PLT_ENTRIES)
1161 int plt_offset = 0, pltneeded = 0;
1163 struct obj_section *relsec, *symsec, *strsec;
1164 ElfW(RelM) *rel, *relend;
1165 ElfW(Sym) *symtab, *extsym;
1166 const char *strtab, *name;
1167 struct arch_symbol *intsym;
1169 for (i = 0; i < f->header.e_shnum; ++i) {
1170 relsec = f->sections[i];
1171 if (relsec->header.sh_type != SHT_RELM)
1174 symsec = f->sections[relsec->header.sh_link];
1175 strsec = f->sections[symsec->header.sh_link];
1177 rel = (ElfW(RelM) *) relsec->contents;
1178 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
1179 symtab = (ElfW(Sym) *) symsec->contents;
1180 strtab = (const char *) strsec->contents;
1182 for (; rel < relend; ++rel) {
1183 extsym = &symtab[ELF32_R_SYM(rel->r_info)];
1185 switch (ELF32_R_TYPE(rel->r_info)) {
1186 #if defined(__arm__)
1189 #elif defined(__sh__)
1192 #elif defined(__i386__)
1195 #elif defined(__mc68000__)
1200 #if defined(__powerpc__)
1206 #if defined(__arm__)
1215 if (got_offset == 0)
1217 #elif defined(__sh__)
1221 #elif defined(__i386__)
1231 if (extsym->st_name != 0) {
1232 name = strtab + extsym->st_name;
1234 name = f->sections[extsym->st_shndx]->name;
1236 intsym = (struct arch_symbol *) obj_find_symbol(f, name);
1237 #if defined(CONFIG_USE_GOT_ENTRIES)
1238 if (!intsym->gotent.offset_done) {
1239 intsym->gotent.offset_done = 1;
1240 intsym->gotent.offset = got_offset;
1241 got_offset += CONFIG_GOT_ENTRY_SIZE;
1244 #if defined(CONFIG_USE_PLT_ENTRIES)
1245 if (pltneeded && intsym->pltent.allocated == 0) {
1246 intsym->pltent.allocated = 1;
1247 intsym->pltent.offset = plt_offset;
1248 plt_offset += CONFIG_PLT_ENTRY_SIZE;
1249 intsym->pltent.inited = 0;
1256 #if defined(CONFIG_USE_GOT_ENTRIES)
1258 struct obj_section* myrelsec = obj_find_section(f, ".got");
1261 obj_extend_section(myrelsec, got_offset);
1263 myrelsec = obj_create_alloced_section(f, ".got",
1264 CONFIG_GOT_ENTRY_SIZE,
1269 ifile->got = myrelsec;
1273 #if defined(CONFIG_USE_PLT_ENTRIES)
1275 ifile->plt = obj_create_alloced_section(f, ".plt",
1276 CONFIG_PLT_ENTRY_SIZE,
1283 #ifdef CONFIG_FEATURE_NEW_MODULE_INTERFACE
1284 static int arch_init_module(struct obj_file *f, struct new_module *mod)
1290 /*======================================================================*/
1292 /* Standard ELF hash function. */
1293 static inline unsigned long obj_elf_hash_n(const char *name, unsigned long n)
1295 unsigned long h = 0;
1302 if ((g = (h & 0xf0000000)) != 0) {
1311 static unsigned long obj_elf_hash(const char *name)
1313 return obj_elf_hash_n(name, strlen(name));
1316 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
1317 /* String comparison for non-co-versioned kernel and module. */
1319 static int ncv_strcmp(const char *a, const char *b)
1321 size_t alen = strlen(a), blen = strlen(b);
1323 if (blen == alen + 10 && b[alen] == '_' && b[alen + 1] == 'R')
1324 return strncmp(a, b, alen);
1325 else if (alen == blen + 10 && a[blen] == '_' && a[blen + 1] == 'R')
1326 return strncmp(a, b, blen);
1328 return strcmp(a, b);
1331 /* String hashing for non-co-versioned kernel and module. Here
1332 we are simply forced to drop the crc from the hash. */
1334 static unsigned long ncv_symbol_hash(const char *str)
1336 size_t len = strlen(str);
1337 if (len > 10 && str[len - 10] == '_' && str[len - 9] == 'R')
1339 return obj_elf_hash_n(str, len);
1343 obj_set_symbol_compare(struct obj_file *f,
1344 int (*cmp) (const char *, const char *),
1345 unsigned long (*hash) (const char *))
1348 f->symbol_cmp = cmp;
1350 struct obj_symbol *tmptab[HASH_BUCKETS], *sym, *next;
1353 f->symbol_hash = hash;
1355 memcpy(tmptab, f->symtab, sizeof(tmptab));
1356 memset(f->symtab, 0, sizeof(f->symtab));
1358 for (i = 0; i < HASH_BUCKETS; ++i)
1359 for (sym = tmptab[i]; sym; sym = next) {
1360 unsigned long h = hash(sym->name) % HASH_BUCKETS;
1362 sym->next = f->symtab[h];
1368 #endif /* CONFIG_FEATURE_INSMOD_VERSION_CHECKING */
1370 static struct obj_symbol *
1371 obj_add_symbol(struct obj_file *f, const char *name,
1372 unsigned long symidx, int info,
1373 int secidx, ElfW(Addr) value,
1376 struct obj_symbol *sym;
1377 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
1378 int n_type = ELFW(ST_TYPE) (info);
1379 int n_binding = ELFW(ST_BIND) (info);
1381 for (sym = f->symtab[hash]; sym; sym = sym->next)
1382 if (f->symbol_cmp(sym->name, name) == 0) {
1383 int o_secidx = sym->secidx;
1384 int o_info = sym->info;
1385 int o_type = ELFW(ST_TYPE) (o_info);
1386 int o_binding = ELFW(ST_BIND) (o_info);
1388 /* A redefinition! Is it legal? */
1390 if (secidx == SHN_UNDEF)
1392 else if (o_secidx == SHN_UNDEF)
1394 else if (n_binding == STB_GLOBAL && o_binding == STB_LOCAL) {
1395 /* Cope with local and global symbols of the same name
1396 in the same object file, as might have been created
1397 by ld -r. The only reason locals are now seen at this
1398 level at all is so that we can do semi-sensible things
1401 struct obj_symbol *nsym, **p;
1403 nsym = arch_new_symbol();
1404 nsym->next = sym->next;
1407 /* Excise the old (local) symbol from the hash chain. */
1408 for (p = &f->symtab[hash]; *p != sym; p = &(*p)->next)
1412 } else if (n_binding == STB_LOCAL) {
1413 /* Another symbol of the same name has already been defined.
1414 Just add this to the local table. */
1415 sym = arch_new_symbol();
1418 f->local_symtab[symidx] = sym;
1420 } else if (n_binding == STB_WEAK)
1422 else if (o_binding == STB_WEAK)
1424 /* Don't unify COMMON symbols with object types the programmer
1426 else if (secidx == SHN_COMMON
1427 && (o_type == STT_NOTYPE || o_type == STT_OBJECT))
1429 else if (o_secidx == SHN_COMMON
1430 && (n_type == STT_NOTYPE || n_type == STT_OBJECT))
1433 /* Don't report an error if the symbol is coming from
1434 the kernel or some external module. */
1435 if (secidx <= SHN_HIRESERVE)
1436 error_msg("%s multiply defined", name);
1441 /* Completely new symbol. */
1442 sym = arch_new_symbol();
1443 sym->next = f->symtab[hash];
1444 f->symtab[hash] = sym;
1447 if (ELFW(ST_BIND)(info) == STB_LOCAL && symidx != -1) {
1448 if (symidx >= f->local_symtab_size)
1449 error_msg("local symbol %s with index %ld exceeds local_symtab_size %ld",
1450 name, (long) symidx, (long) f->local_symtab_size);
1452 f->local_symtab[symidx] = sym;
1459 sym->secidx = secidx;
1465 static struct obj_symbol *
1466 obj_find_symbol(struct obj_file *f, const char *name)
1468 struct obj_symbol *sym;
1469 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
1471 for (sym = f->symtab[hash]; sym; sym = sym->next)
1472 if (f->symbol_cmp(sym->name, name) == 0)
1479 obj_symbol_final_value(struct obj_file * f, struct obj_symbol * sym)
1482 if (sym->secidx >= SHN_LORESERVE)
1485 return sym->value + f->sections[sym->secidx]->header.sh_addr;
1487 /* As a special case, a NULL sym has value zero. */
1492 static struct obj_section *obj_find_section(struct obj_file *f, const char *name)
1494 int i, n = f->header.e_shnum;
1496 for (i = 0; i < n; ++i)
1497 if (strcmp(f->sections[i]->name, name) == 0)
1498 return f->sections[i];
1503 static int obj_load_order_prio(struct obj_section *a)
1505 unsigned long af, ac;
1507 af = a->header.sh_flags;
1510 if (a->name[0] != '.' || strlen(a->name) != 10 ||
1511 strcmp(a->name + 5, ".init"))
1515 if (!(af & SHF_WRITE))
1517 if (af & SHF_EXECINSTR)
1519 if (a->header.sh_type != SHT_NOBITS)
1526 obj_insert_section_load_order(struct obj_file *f, struct obj_section *sec)
1528 struct obj_section **p;
1529 int prio = obj_load_order_prio(sec);
1530 for (p = f->load_order_search_start; *p; p = &(*p)->load_next)
1531 if (obj_load_order_prio(*p) < prio)
1533 sec->load_next = *p;
1537 static struct obj_section *obj_create_alloced_section(struct obj_file *f,
1539 unsigned long align,
1542 int newidx = f->header.e_shnum++;
1543 struct obj_section *sec;
1545 f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
1546 f->sections[newidx] = sec = arch_new_section();
1548 memset(sec, 0, sizeof(*sec));
1549 sec->header.sh_type = SHT_PROGBITS;
1550 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
1551 sec->header.sh_size = size;
1552 sec->header.sh_addralign = align;
1556 sec->contents = xmalloc(size);
1558 obj_insert_section_load_order(f, sec);
1563 static struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
1565 unsigned long align,
1568 int newidx = f->header.e_shnum++;
1569 struct obj_section *sec;
1571 f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
1572 f->sections[newidx] = sec = arch_new_section();
1574 memset(sec, 0, sizeof(*sec));
1575 sec->header.sh_type = SHT_PROGBITS;
1576 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
1577 sec->header.sh_size = size;
1578 sec->header.sh_addralign = align;
1582 sec->contents = xmalloc(size);
1584 sec->load_next = f->load_order;
1585 f->load_order = sec;
1586 if (f->load_order_search_start == &f->load_order)
1587 f->load_order_search_start = &sec->load_next;
1592 static void *obj_extend_section(struct obj_section *sec, unsigned long more)
1594 unsigned long oldsize = sec->header.sh_size;
1596 sec->contents = xrealloc(sec->contents, sec->header.sh_size += more);
1598 return sec->contents + oldsize;
1602 /* Conditionally add the symbols from the given symbol set to the
1608 int idx, struct new_module_symbol *syms, size_t nsyms)
1610 struct new_module_symbol *s;
1614 for (i = 0, s = syms; i < nsyms; ++i, ++s) {
1616 /* Only add symbols that are already marked external. If we
1617 override locals we may cause problems for argument initialization.
1618 We will also create a false dependency on the module. */
1619 struct obj_symbol *sym;
1621 sym = obj_find_symbol(f, (char *) s->name);
1622 if (sym && !ELFW(ST_BIND) (sym->info) == STB_LOCAL) {
1623 sym = obj_add_symbol(f, (char *) s->name, -1,
1624 ELFW(ST_INFO) (STB_GLOBAL, STT_NOTYPE),
1626 /* Did our symbol just get installed? If so, mark the
1627 module as "used". */
1628 if (sym->secidx == idx)
1636 static void add_kernel_symbols(struct obj_file *f)
1638 struct external_module *m;
1641 /* Add module symbols first. */
1643 for (i = 0, m = ext_modules; i < n_ext_modules; ++i, ++m)
1645 && add_symbols_from(f, SHN_HIRESERVE + 2 + i, m->syms,
1646 m->nsyms)) m->used = 1, ++nused;
1648 n_ext_modules_used = nused;
1650 /* And finally the symbols from the kernel proper. */
1653 add_symbols_from(f, SHN_HIRESERVE + 1, ksyms, nksyms);
1656 static char *get_modinfo_value(struct obj_file *f, const char *key)
1658 struct obj_section *sec;
1659 char *p, *v, *n, *ep;
1660 size_t klen = strlen(key);
1662 sec = obj_find_section(f, ".modinfo");
1666 ep = p + sec->header.sh_size;
1669 n = strchr(p, '\0');
1671 if (p + klen == v && strncmp(p, key, klen) == 0)
1674 if (p + klen == n && strcmp(p, key) == 0)
1684 /*======================================================================*/
1685 /* Functions relating to module loading in pre 2.1 kernels. */
1688 old_process_module_arguments(struct obj_file *f, int argc, char **argv)
1692 struct obj_symbol *sym;
1696 if ((q = strchr(p, '=')) == NULL) {
1702 sym = obj_find_symbol(f, p);
1704 /* Also check that the parameter was not resolved from the kernel. */
1705 if (sym == NULL || sym->secidx > SHN_HIRESERVE) {
1706 error_msg("symbol for parameter %s not found", p);
1710 loc = (int *) (f->sections[sym->secidx]->contents + sym->value);
1712 /* Do C quoting if we begin with a ". */
1716 str = alloca(strlen(q));
1717 for (r = str, q++; *q != '"'; ++q, ++r) {
1719 error_msg("improperly terminated string argument for %s", p);
1721 } else if (*q == '\\')
1755 if (q[1] >= '0' && q[1] <= '7') {
1756 c = (c * 8) + *++q - '0';
1757 if (q[1] >= '0' && q[1] <= '7')
1758 c = (c * 8) + *++q - '0';
1771 obj_string_patch(f, sym->secidx, sym->value, str);
1772 } else if (*q >= '0' && *q <= '9') {
1774 *loc++ = strtoul(q, &q, 0);
1775 while (*q++ == ',');
1777 char *contents = f->sections[sym->secidx]->contents;
1778 char *myloc = contents + sym->value;
1779 char *r; /* To search for commas */
1781 /* Break the string with comas */
1782 while ((r = strchr(q, ',')) != (char *) NULL) {
1784 obj_string_patch(f, sym->secidx, myloc - contents, q);
1785 myloc += sizeof(char *);
1790 obj_string_patch(f, sym->secidx, myloc - contents, q);
1799 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
1800 static int old_is_module_checksummed(struct obj_file *f)
1802 return obj_find_symbol(f, "Using_Versions") != NULL;
1804 /* Get the module's kernel version in the canonical integer form. */
1807 old_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
1809 struct obj_symbol *sym;
1813 sym = obj_find_symbol(f, "kernel_version");
1817 p = f->sections[sym->secidx]->contents + sym->value;
1818 strncpy(str, p, STRVERSIONLEN);
1820 a = strtoul(p, &p, 10);
1823 b = strtoul(p + 1, &p, 10);
1826 c = strtoul(p + 1, &q, 10);
1830 return a << 16 | b << 8 | c;
1833 #endif /* CONFIG_FEATURE_INSMOD_VERSION_CHECKING */
1835 #ifdef CONFIG_FEATURE_OLD_MODULE_INTERFACE
1837 /* Fetch all the symbols and divvy them up as appropriate for the modules. */
1839 static int old_get_kernel_symbols(const char *m_name)
1841 struct old_kernel_sym *ks, *k;
1842 struct new_module_symbol *s;
1843 struct external_module *mod;
1844 int nks, nms, nmod, i;
1846 nks = get_kernel_syms(NULL);
1849 perror_msg("get_kernel_syms: %s", m_name);
1851 error_msg("No kernel symbols");
1855 ks = k = xmalloc(nks * sizeof(*ks));
1857 if (get_kernel_syms(ks) != nks) {
1858 perror("inconsistency with get_kernel_syms -- is someone else "
1859 "playing with modules?");
1864 /* Collect the module information. */
1869 while (k->name[0] == '#' && k->name[1]) {
1870 struct old_kernel_sym *k2;
1872 /* Find out how many symbols this module has. */
1873 for (k2 = k + 1; k2->name[0] != '#'; ++k2)
1877 mod = xrealloc(mod, (++nmod + 1) * sizeof(*mod));
1878 mod[nmod].name = k->name + 1;
1879 mod[nmod].addr = k->value;
1881 mod[nmod].nsyms = nms;
1882 mod[nmod].syms = s = (nms ? xmalloc(nms * sizeof(*s)) : NULL);
1884 for (i = 0, ++k; i < nms; ++i, ++s, ++k) {
1885 s->name = (unsigned long) k->name;
1886 s->value = k->value;
1893 n_ext_modules = nmod + 1;
1895 /* Now collect the symbols for the kernel proper. */
1897 if (k->name[0] == '#')
1900 nksyms = nms = nks - (k - ks);
1901 ksyms = s = (nms ? xmalloc(nms * sizeof(*s)) : NULL);
1903 for (i = 0; i < nms; ++i, ++s, ++k) {
1904 s->name = (unsigned long) k->name;
1905 s->value = k->value;
1911 /* Return the kernel symbol checksum version, or zero if not used. */
1913 static int old_is_kernel_checksummed(void)
1915 /* Using_Versions is the first symbol. */
1917 && strcmp((char *) ksyms[0].name,
1918 "Using_Versions") == 0) return ksyms[0].value;
1924 static int old_create_mod_use_count(struct obj_file *f)
1926 struct obj_section *sec;
1928 sec = obj_create_alloced_section_first(f, ".moduse", sizeof(long),
1931 obj_add_symbol(f, "mod_use_count_", -1,
1932 ELFW(ST_INFO) (STB_LOCAL, STT_OBJECT), sec->idx, 0,
1939 old_init_module(const char *m_name, struct obj_file *f,
1940 unsigned long m_size)
1943 struct old_mod_routines routines;
1944 struct old_symbol_table *symtab;
1947 /* Create the symbol table */
1949 int nsyms = 0, strsize = 0, total;
1951 /* Size things first... */
1954 for (i = 0; i < HASH_BUCKETS; ++i) {
1955 struct obj_symbol *sym;
1956 for (sym = f->symtab[i]; sym; sym = sym->next)
1957 if (ELFW(ST_BIND) (sym->info) != STB_LOCAL
1958 && sym->secidx <= SHN_HIRESERVE)
1960 sym->ksymidx = nsyms++;
1961 strsize += strlen(sym->name) + 1;
1966 total = (sizeof(struct old_symbol_table)
1967 + nsyms * sizeof(struct old_module_symbol)
1968 + n_ext_modules_used * sizeof(struct old_module_ref)
1970 symtab = xmalloc(total);
1971 symtab->size = total;
1972 symtab->n_symbols = nsyms;
1973 symtab->n_refs = n_ext_modules_used;
1975 if (flag_export && nsyms) {
1976 struct old_module_symbol *ksym;
1980 ksym = symtab->symbol;
1981 str = ((char *) ksym + nsyms * sizeof(struct old_module_symbol)
1982 + n_ext_modules_used * sizeof(struct old_module_ref));
1984 for (i = 0; i < HASH_BUCKETS; ++i) {
1985 struct obj_symbol *sym;
1986 for (sym = f->symtab[i]; sym; sym = sym->next)
1987 if (sym->ksymidx >= 0) {
1988 ksym->addr = obj_symbol_final_value(f, sym);
1990 (unsigned long) str - (unsigned long) symtab;
1992 strcpy(str, sym->name);
1993 str += strlen(sym->name) + 1;
1999 if (n_ext_modules_used) {
2000 struct old_module_ref *ref;
2003 ref = (struct old_module_ref *)
2004 ((char *) symtab->symbol + nsyms * sizeof(struct old_module_symbol));
2006 for (i = 0; i < n_ext_modules; ++i)
2007 if (ext_modules[i].used)
2008 ref++->module = ext_modules[i].addr;
2012 /* Fill in routines. */
2015 obj_symbol_final_value(f, obj_find_symbol(f, "init_module"));
2017 obj_symbol_final_value(f, obj_find_symbol(f, "cleanup_module"));
2019 /* Whew! All of the initialization is complete. Collect the final
2020 module image and give it to the kernel. */
2022 image = xmalloc(m_size);
2023 obj_create_image(f, image);
2025 /* image holds the complete relocated module, accounting correctly for
2026 mod_use_count. However the old module kernel support assume that
2027 it is receiving something which does not contain mod_use_count. */
2028 ret = old_sys_init_module(m_name, image + sizeof(long),
2029 m_size | (flag_autoclean ? OLD_MOD_AUTOCLEAN
2030 : 0), &routines, symtab);
2032 perror_msg("init_module: %s", m_name);
2042 #define old_create_mod_use_count(x) TRUE
2043 #define old_init_module(x, y, z) TRUE
2045 #endif /* CONFIG_FEATURE_OLD_MODULE_INTERFACE */
2049 /*======================================================================*/
2050 /* Functions relating to module loading after 2.1.18. */
2053 new_process_module_arguments(struct obj_file *f, int argc, char **argv)
2057 struct obj_symbol *sym;
2058 char *contents, *loc;
2062 if ((q = strchr(p, '=')) == NULL) {
2067 key = alloca(q - p + 6);
2068 memcpy(key, "parm_", 5);
2069 memcpy(key + 5, p, q - p);
2072 p = get_modinfo_value(f, key);
2075 error_msg("invalid parameter %s", key);
2079 sym = obj_find_symbol(f, key);
2081 /* Also check that the parameter was not resolved from the kernel. */
2082 if (sym == NULL || sym->secidx > SHN_HIRESERVE) {
2083 error_msg("symbol for parameter %s not found", key);
2088 min = strtoul(p, &p, 10);
2090 max = strtoul(p + 1, &p, 10);
2096 contents = f->sections[sym->secidx]->contents;
2097 loc = contents + sym->value;
2101 if ((*p == 's') || (*p == 'c')) {
2104 /* Do C quoting if we begin with a ", else slurp the lot. */
2108 str = alloca(strlen(q));
2109 for (r = str, q++; *q != '"'; ++q, ++r) {
2111 error_msg("improperly terminated string argument for %s",
2114 } else if (*q == '\\')
2148 if (q[1] >= '0' && q[1] <= '7') {
2149 c = (c * 8) + *++q - '0';
2150 if (q[1] >= '0' && q[1] <= '7')
2151 c = (c * 8) + *++q - '0';
2168 /* In this case, the string is not quoted. We will break
2169 it using the coma (like for ints). If the user wants to
2170 include comas in a string, he just has to quote it */
2172 /* Search the next coma */
2176 if (r != (char *) NULL) {
2177 /* Recopy the current field */
2178 str = alloca(r - q + 1);
2179 memcpy(str, q, r - q);
2181 /* I don't know if it is usefull, as the previous case
2182 doesn't null terminate the string ??? */
2185 /* Keep next fields */
2196 obj_string_patch(f, sym->secidx, loc - contents, str);
2197 loc += tgt_sizeof_char_p;
2199 /* Array of chars (in fact, matrix !) */
2200 unsigned long charssize; /* size of each member */
2202 /* Get the size of each member */
2203 /* Probably we should do that outside the loop ? */
2204 if (!isdigit(*(p + 1))) {
2205 error_msg("parameter type 'c' for %s must be followed by"
2206 " the maximum size", key);
2209 charssize = strtoul(p + 1, (char **) NULL, 10);
2212 if (strlen(str) >= charssize) {
2213 error_msg("string too long for %s (max %ld)", key,
2218 /* Copy to location */
2219 strcpy((char *) loc, str);
2223 long v = strtoul(q, &q, 0);
2230 loc += tgt_sizeof_short;
2234 loc += tgt_sizeof_int;
2238 loc += tgt_sizeof_long;
2242 error_msg("unknown parameter type '%c' for %s", *p, key);
2257 goto retry_end_of_value;
2261 error_msg("too many values for %s (max %d)", key, max);
2268 error_msg("invalid argument syntax for %s", key);
2275 error_msg("too few values for %s (min %d)", key, min);
2285 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
2286 static int new_is_module_checksummed(struct obj_file *f)
2288 const char *p = get_modinfo_value(f, "using_checksums");
2295 /* Get the module's kernel version in the canonical integer form. */
2298 new_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
2303 p = get_modinfo_value(f, "kernel_version");
2306 strncpy(str, p, STRVERSIONLEN);
2308 a = strtoul(p, &p, 10);
2311 b = strtoul(p + 1, &p, 10);
2314 c = strtoul(p + 1, &q, 10);
2318 return a << 16 | b << 8 | c;
2321 #endif /* CONFIG_FEATURE_INSMOD_VERSION_CHECKING */
2324 #ifdef CONFIG_FEATURE_NEW_MODULE_INTERFACE
2326 /* Fetch the loaded modules, and all currently exported symbols. */
2328 static int new_get_kernel_symbols(void)
2330 char *module_names, *mn;
2331 struct external_module *modules, *m;
2332 struct new_module_symbol *syms, *s;
2333 size_t ret, bufsize, nmod, nsyms, i, j;
2335 /* Collect the loaded modules. */
2337 module_names = xmalloc(bufsize = 256);
2339 if (query_module(NULL, QM_MODULES, module_names, bufsize, &ret)) {
2340 if (errno == ENOSPC && bufsize < ret) {
2341 module_names = xrealloc(module_names, bufsize = ret);
2342 goto retry_modules_load;
2344 perror_msg("QM_MODULES");
2348 n_ext_modules = nmod = ret;
2350 /* Collect the modules' symbols. */
2353 ext_modules = modules = xmalloc(nmod * sizeof(*modules));
2354 memset(modules, 0, nmod * sizeof(*modules));
2355 for (i = 0, mn = module_names, m = modules;
2356 i < nmod; ++i, ++m, mn += strlen(mn) + 1) {
2357 struct new_module_info info;
2359 if (query_module(mn, QM_INFO, &info, sizeof(info), &ret)) {
2360 if (errno == ENOENT) {
2361 /* The module was removed out from underneath us. */
2364 perror_msg("query_module: QM_INFO: %s", mn);
2368 syms = xmalloc(bufsize = 1024);
2370 if (query_module(mn, QM_SYMBOLS, syms, bufsize, &ret)) {
2373 syms = xrealloc(syms, bufsize = ret);
2374 goto retry_mod_sym_load;
2376 /* The module was removed out from underneath us. */
2379 perror_msg("query_module: QM_SYMBOLS: %s", mn);
2386 m->addr = info.addr;
2390 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2391 s->name += (unsigned long) syms;
2396 /* Collect the kernel's symbols. */
2398 syms = xmalloc(bufsize = 16 * 1024);
2399 retry_kern_sym_load:
2400 if (query_module(NULL, QM_SYMBOLS, syms, bufsize, &ret)) {
2401 if (errno == ENOSPC && bufsize < ret) {
2402 syms = xrealloc(syms, bufsize = ret);
2403 goto retry_kern_sym_load;
2405 perror_msg("kernel: QM_SYMBOLS");
2408 nksyms = nsyms = ret;
2411 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2412 s->name += (unsigned long) syms;
2418 /* Return the kernel symbol checksum version, or zero if not used. */
2420 static int new_is_kernel_checksummed(void)
2422 struct new_module_symbol *s;
2425 /* Using_Versions is not the first symbol, but it should be in there. */
2427 for (i = 0, s = ksyms; i < nksyms; ++i, ++s)
2428 if (strcmp((char *) s->name, "Using_Versions") == 0)
2435 static int new_create_this_module(struct obj_file *f, const char *m_name)
2437 struct obj_section *sec;
2439 sec = obj_create_alloced_section_first(f, ".this", tgt_sizeof_long,
2440 sizeof(struct new_module));
2441 memset(sec->contents, 0, sizeof(struct new_module));
2443 obj_add_symbol(f, "__this_module", -1,
2444 ELFW(ST_INFO) (STB_LOCAL, STT_OBJECT), sec->idx, 0,
2445 sizeof(struct new_module));
2447 obj_string_patch(f, sec->idx, offsetof(struct new_module, name),
2454 static int new_create_module_ksymtab(struct obj_file *f)
2456 struct obj_section *sec;
2459 /* We must always add the module references. */
2461 if (n_ext_modules_used) {
2462 struct new_module_ref *dep;
2463 struct obj_symbol *tm;
2465 sec = obj_create_alloced_section(f, ".kmodtab", tgt_sizeof_void_p,
2466 (sizeof(struct new_module_ref)
2467 * n_ext_modules_used));
2471 tm = obj_find_symbol(f, "__this_module");
2472 dep = (struct new_module_ref *) sec->contents;
2473 for (i = 0; i < n_ext_modules; ++i)
2474 if (ext_modules[i].used) {
2475 dep->dep = ext_modules[i].addr;
2476 obj_symbol_patch(f, sec->idx,
2477 (char *) &dep->ref - sec->contents, tm);
2483 if (flag_export && !obj_find_section(f, "__ksymtab")) {
2488 obj_create_alloced_section(f, "__ksymtab", tgt_sizeof_void_p,
2491 /* We don't want to export symbols residing in sections that
2492 aren't loaded. There are a number of these created so that
2493 we make sure certain module options don't appear twice. */
2495 loaded = alloca(sizeof(int) * (i = f->header.e_shnum));
2497 loaded[i] = (f->sections[i]->header.sh_flags & SHF_ALLOC) != 0;
2499 for (nsyms = i = 0; i < HASH_BUCKETS; ++i) {
2500 struct obj_symbol *sym;
2501 for (sym = f->symtab[i]; sym; sym = sym->next)
2502 if (ELFW(ST_BIND) (sym->info) != STB_LOCAL
2503 && sym->secidx <= SHN_HIRESERVE
2504 && (sym->secidx >= SHN_LORESERVE
2505 || loaded[sym->secidx])) {
2506 ElfW(Addr) ofs = nsyms * 2 * tgt_sizeof_void_p;
2508 obj_symbol_patch(f, sec->idx, ofs, sym);
2509 obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p,
2516 obj_extend_section(sec, nsyms * 2 * tgt_sizeof_char_p);
2524 new_init_module(const char *m_name, struct obj_file *f,
2525 unsigned long m_size)
2527 struct new_module *module;
2528 struct obj_section *sec;
2533 sec = obj_find_section(f, ".this");
2534 if (!sec || !sec->contents) {
2535 perror_msg_and_die("corrupt module %s?",m_name);
2537 module = (struct new_module *) sec->contents;
2538 m_addr = sec->header.sh_addr;
2540 module->size_of_struct = sizeof(*module);
2541 module->size = m_size;
2542 module->flags = flag_autoclean ? NEW_MOD_AUTOCLEAN : 0;
2544 sec = obj_find_section(f, "__ksymtab");
2545 if (sec && sec->header.sh_size) {
2546 module->syms = sec->header.sh_addr;
2547 module->nsyms = sec->header.sh_size / (2 * tgt_sizeof_char_p);
2550 if (n_ext_modules_used) {
2551 sec = obj_find_section(f, ".kmodtab");
2552 module->deps = sec->header.sh_addr;
2553 module->ndeps = n_ext_modules_used;
2557 obj_symbol_final_value(f, obj_find_symbol(f, "init_module"));
2559 obj_symbol_final_value(f, obj_find_symbol(f, "cleanup_module"));
2561 sec = obj_find_section(f, "__ex_table");
2563 module->ex_table_start = sec->header.sh_addr;
2564 module->ex_table_end = sec->header.sh_addr + sec->header.sh_size;
2567 sec = obj_find_section(f, ".text.init");
2569 module->runsize = sec->header.sh_addr - m_addr;
2571 sec = obj_find_section(f, ".data.init");
2573 if (!module->runsize ||
2574 module->runsize > sec->header.sh_addr - m_addr)
2575 module->runsize = sec->header.sh_addr - m_addr;
2577 sec = obj_find_section(f, ARCHDATA_SEC_NAME);
2578 if (sec && sec->header.sh_size) {
2579 module->archdata_start = (void*)sec->header.sh_addr;
2580 module->archdata_end = module->archdata_start + sec->header.sh_size;
2582 sec = obj_find_section(f, KALLSYMS_SEC_NAME);
2583 if (sec && sec->header.sh_size) {
2584 module->kallsyms_start = (void*)sec->header.sh_addr;
2585 module->kallsyms_end = module->kallsyms_start + sec->header.sh_size;
2588 if (!arch_init_module(f, module))
2591 /* Whew! All of the initialization is complete. Collect the final
2592 module image and give it to the kernel. */
2594 image = xmalloc(m_size);
2595 obj_create_image(f, image);
2597 ret = new_sys_init_module(m_name, (struct new_module *) image);
2599 perror_msg("init_module: %s", m_name);
2608 #define new_init_module(x, y, z) TRUE
2609 #define new_create_this_module(x, y) 0
2610 #define new_create_module_ksymtab(x)
2611 #define query_module(v, w, x, y, z) -1
2613 #endif /* CONFIG_FEATURE_NEW_MODULE_INTERFACE */
2616 /*======================================================================*/
2619 obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2622 struct obj_string_patch *p;
2623 struct obj_section *strsec;
2624 size_t len = strlen(string) + 1;
2627 p = xmalloc(sizeof(*p));
2628 p->next = f->string_patches;
2629 p->reloc_secidx = secidx;
2630 p->reloc_offset = offset;
2631 f->string_patches = p;
2633 strsec = obj_find_section(f, ".kstrtab");
2634 if (strsec == NULL) {
2635 strsec = obj_create_alloced_section(f, ".kstrtab", 1, len);
2636 p->string_offset = 0;
2637 loc = strsec->contents;
2639 p->string_offset = strsec->header.sh_size;
2640 loc = obj_extend_section(strsec, len);
2642 memcpy(loc, string, len);
2647 #ifdef CONFIG_FEATURE_NEW_MODULE_INTERFACE
2649 obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2650 struct obj_symbol *sym)
2652 struct obj_symbol_patch *p;
2654 p = xmalloc(sizeof(*p));
2655 p->next = f->symbol_patches;
2656 p->reloc_secidx = secidx;
2657 p->reloc_offset = offset;
2659 f->symbol_patches = p;
2665 static int obj_check_undefineds(struct obj_file *f)
2670 for (i = 0; i < HASH_BUCKETS; ++i) {
2671 struct obj_symbol *sym;
2672 for (sym = f->symtab[i]; sym; sym = sym->next)
2673 if (sym->secidx == SHN_UNDEF) {
2674 if (ELFW(ST_BIND) (sym->info) == STB_WEAK) {
2675 sym->secidx = SHN_ABS;
2678 error_msg("unresolved symbol %s", sym->name);
2687 static void obj_allocate_commons(struct obj_file *f)
2689 struct common_entry {
2690 struct common_entry *next;
2691 struct obj_symbol *sym;
2692 } *common_head = NULL;
2696 for (i = 0; i < HASH_BUCKETS; ++i) {
2697 struct obj_symbol *sym;
2698 for (sym = f->symtab[i]; sym; sym = sym->next)
2699 if (sym->secidx == SHN_COMMON) {
2700 /* Collect all COMMON symbols and sort them by size so as to
2701 minimize space wasted by alignment requirements. */
2703 struct common_entry **p, *n;
2704 for (p = &common_head; *p; p = &(*p)->next)
2705 if (sym->size <= (*p)->sym->size)
2708 n = alloca(sizeof(*n));
2716 for (i = 1; i < f->local_symtab_size; ++i) {
2717 struct obj_symbol *sym = f->local_symtab[i];
2718 if (sym && sym->secidx == SHN_COMMON) {
2719 struct common_entry **p, *n;
2720 for (p = &common_head; *p; p = &(*p)->next)
2721 if (sym == (*p)->sym)
2723 else if (sym->size < (*p)->sym->size) {
2724 n = alloca(sizeof(*n));
2734 /* Find the bss section. */
2735 for (i = 0; i < f->header.e_shnum; ++i)
2736 if (f->sections[i]->header.sh_type == SHT_NOBITS)
2739 /* If for some reason there hadn't been one, create one. */
2740 if (i == f->header.e_shnum) {
2741 struct obj_section *sec;
2743 f->sections = xrealloc(f->sections, (i + 1) * sizeof(sec));
2744 f->sections[i] = sec = arch_new_section();
2745 f->header.e_shnum = i + 1;
2747 memset(sec, 0, sizeof(*sec));
2748 sec->header.sh_type = SHT_PROGBITS;
2749 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2754 /* Allocate the COMMONS. */
2756 ElfW(Addr) bss_size = f->sections[i]->header.sh_size;
2757 ElfW(Addr) max_align = f->sections[i]->header.sh_addralign;
2758 struct common_entry *c;
2760 for (c = common_head; c; c = c->next) {
2761 ElfW(Addr) align = c->sym->value;
2763 if (align > max_align)
2765 if (bss_size & (align - 1))
2766 bss_size = (bss_size | (align - 1)) + 1;
2769 c->sym->value = bss_size;
2771 bss_size += c->sym->size;
2774 f->sections[i]->header.sh_size = bss_size;
2775 f->sections[i]->header.sh_addralign = max_align;
2779 /* For the sake of patch relocation and parameter initialization,
2780 allocate zeroed data for NOBITS sections now. Note that after
2781 this we cannot assume NOBITS are really empty. */
2782 for (i = 0; i < f->header.e_shnum; ++i) {
2783 struct obj_section *s = f->sections[i];
2784 if (s->header.sh_type == SHT_NOBITS) {
2785 if (s->header.sh_size != 0)
2786 s->contents = memset(xmalloc(s->header.sh_size),
2787 0, s->header.sh_size);
2791 s->header.sh_type = SHT_PROGBITS;
2796 static unsigned long obj_load_size(struct obj_file *f)
2798 unsigned long dot = 0;
2799 struct obj_section *sec;
2801 /* Finalize the positions of the sections relative to one another. */
2803 for (sec = f->load_order; sec; sec = sec->load_next) {
2806 align = sec->header.sh_addralign;
2807 if (align && (dot & (align - 1)))
2808 dot = (dot | (align - 1)) + 1;
2810 sec->header.sh_addr = dot;
2811 dot += sec->header.sh_size;
2817 static int obj_relocate(struct obj_file *f, ElfW(Addr) base)
2819 int i, n = f->header.e_shnum;
2822 /* Finalize the addresses of the sections. */
2825 for (i = 0; i < n; ++i)
2826 f->sections[i]->header.sh_addr += base;
2828 /* And iterate over all of the relocations. */
2830 for (i = 0; i < n; ++i) {
2831 struct obj_section *relsec, *symsec, *targsec, *strsec;
2832 ElfW(RelM) * rel, *relend;
2836 relsec = f->sections[i];
2837 if (relsec->header.sh_type != SHT_RELM)
2840 symsec = f->sections[relsec->header.sh_link];
2841 targsec = f->sections[relsec->header.sh_info];
2842 strsec = f->sections[symsec->header.sh_link];
2844 rel = (ElfW(RelM) *) relsec->contents;
2845 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
2846 symtab = (ElfW(Sym) *) symsec->contents;
2847 strtab = (const char *) strsec->contents;
2849 for (; rel < relend; ++rel) {
2850 ElfW(Addr) value = 0;
2851 struct obj_symbol *intsym = NULL;
2852 unsigned long symndx;
2853 ElfW(Sym) * extsym = 0;
2856 /* Attempt to find a value to use for this relocation. */
2858 symndx = ELFW(R_SYM) (rel->r_info);
2860 /* Note we've already checked for undefined symbols. */
2862 extsym = &symtab[symndx];
2863 if (ELFW(ST_BIND) (extsym->st_info) == STB_LOCAL) {
2864 /* Local symbols we look up in the local table to be sure
2865 we get the one that is really intended. */
2866 intsym = f->local_symtab[symndx];
2868 /* Others we look up in the hash table. */
2870 if (extsym->st_name)
2871 name = strtab + extsym->st_name;
2873 name = f->sections[extsym->st_shndx]->name;
2874 intsym = obj_find_symbol(f, name);
2877 value = obj_symbol_final_value(f, intsym);
2878 intsym->referenced = 1;
2880 #if SHT_RELM == SHT_RELA
2881 #if defined(__alpha__) && defined(AXP_BROKEN_GAS)
2882 /* Work around a nasty GAS bug, that is fixed as of 2.7.0.9. */
2883 if (!extsym || !extsym->st_name ||
2884 ELFW(ST_BIND) (extsym->st_info) != STB_LOCAL)
2886 value += rel->r_addend;
2890 switch (arch_apply_relocation
2891 (f, targsec, symsec, intsym, rel, value)) {
2895 case obj_reloc_overflow:
2896 errmsg = "Relocation overflow";
2898 case obj_reloc_dangerous:
2899 errmsg = "Dangerous relocation";
2901 case obj_reloc_unhandled:
2902 errmsg = "Unhandled relocation";
2905 error_msg("%s of type %ld for %s", errmsg,
2906 (long) ELFW(R_TYPE) (rel->r_info),
2907 strtab + extsym->st_name);
2909 error_msg("%s of type %ld", errmsg,
2910 (long) ELFW(R_TYPE) (rel->r_info));
2918 /* Finally, take care of the patches. */
2920 if (f->string_patches) {
2921 struct obj_string_patch *p;
2922 struct obj_section *strsec;
2923 ElfW(Addr) strsec_base;
2924 strsec = obj_find_section(f, ".kstrtab");
2925 strsec_base = strsec->header.sh_addr;
2927 for (p = f->string_patches; p; p = p->next) {
2928 struct obj_section *targsec = f->sections[p->reloc_secidx];
2929 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
2930 = strsec_base + p->string_offset;
2934 if (f->symbol_patches) {
2935 struct obj_symbol_patch *p;
2937 for (p = f->symbol_patches; p; p = p->next) {
2938 struct obj_section *targsec = f->sections[p->reloc_secidx];
2939 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
2940 = obj_symbol_final_value(f, p->sym);
2947 static int obj_create_image(struct obj_file *f, char *image)
2949 struct obj_section *sec;
2950 ElfW(Addr) base = f->baseaddr;
2952 for (sec = f->load_order; sec; sec = sec->load_next) {
2955 if (sec->contents == 0 || sec->header.sh_size == 0)
2958 secimg = image + (sec->header.sh_addr - base);
2960 /* Note that we allocated data for NOBITS sections earlier. */
2961 memcpy(secimg, sec->contents, sec->header.sh_size);
2967 /*======================================================================*/
2969 static struct obj_file *obj_load(FILE * fp, int loadprogbits)
2972 ElfW(Shdr) * section_headers;
2976 /* Read the file header. */
2978 f = arch_new_file();
2979 memset(f, 0, sizeof(*f));
2980 f->symbol_cmp = strcmp;
2981 f->symbol_hash = obj_elf_hash;
2982 f->load_order_search_start = &f->load_order;
2984 fseek(fp, 0, SEEK_SET);
2985 if (fread(&f->header, sizeof(f->header), 1, fp) != 1) {
2986 perror_msg("error reading ELF header");
2990 if (f->header.e_ident[EI_MAG0] != ELFMAG0
2991 || f->header.e_ident[EI_MAG1] != ELFMAG1
2992 || f->header.e_ident[EI_MAG2] != ELFMAG2
2993 || f->header.e_ident[EI_MAG3] != ELFMAG3) {
2994 error_msg("not an ELF file");
2997 if (f->header.e_ident[EI_CLASS] != ELFCLASSM
2998 || f->header.e_ident[EI_DATA] != ELFDATAM
2999 || f->header.e_ident[EI_VERSION] != EV_CURRENT
3000 || !MATCH_MACHINE(f->header.e_machine)) {
3001 error_msg("ELF file not for this architecture");
3004 if (f->header.e_type != ET_REL) {
3005 error_msg("ELF file not a relocatable object");
3009 /* Read the section headers. */
3011 if (f->header.e_shentsize != sizeof(ElfW(Shdr))) {
3012 error_msg("section header size mismatch: %lu != %lu",
3013 (unsigned long) f->header.e_shentsize,
3014 (unsigned long) sizeof(ElfW(Shdr)));
3018 shnum = f->header.e_shnum;
3019 f->sections = xmalloc(sizeof(struct obj_section *) * shnum);
3020 memset(f->sections, 0, sizeof(struct obj_section *) * shnum);
3022 section_headers = alloca(sizeof(ElfW(Shdr)) * shnum);
3023 fseek(fp, f->header.e_shoff, SEEK_SET);
3024 if (fread(section_headers, sizeof(ElfW(Shdr)), shnum, fp) != shnum) {
3025 perror_msg("error reading ELF section headers");
3029 /* Read the section data. */
3031 for (i = 0; i < shnum; ++i) {
3032 struct obj_section *sec;
3034 f->sections[i] = sec = arch_new_section();
3035 memset(sec, 0, sizeof(*sec));
3037 sec->header = section_headers[i];
3040 if(sec->header.sh_size) switch (sec->header.sh_type) {
3049 if (!loadprogbits) {
3050 sec->contents = NULL;
3057 if (sec->header.sh_size > 0) {
3058 sec->contents = xmalloc(sec->header.sh_size);
3059 fseek(fp, sec->header.sh_offset, SEEK_SET);
3060 if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
3061 perror_msg("error reading ELF section data");
3065 sec->contents = NULL;
3069 #if SHT_RELM == SHT_REL
3071 error_msg("RELA relocations not supported on this architecture");
3075 error_msg("REL relocations not supported on this architecture");
3080 if (sec->header.sh_type >= SHT_LOPROC) {
3081 /* Assume processor specific section types are debug
3082 info and can safely be ignored. If this is ever not
3083 the case (Hello MIPS?), don't put ifdefs here but
3084 create an arch_load_proc_section(). */
3088 error_msg("can't handle sections of type %ld",
3089 (long) sec->header.sh_type);
3094 /* Do what sort of interpretation as needed by each section. */
3096 shstrtab = f->sections[f->header.e_shstrndx]->contents;
3098 for (i = 0; i < shnum; ++i) {
3099 struct obj_section *sec = f->sections[i];
3100 sec->name = shstrtab + sec->header.sh_name;
3103 for (i = 0; i < shnum; ++i) {
3104 struct obj_section *sec = f->sections[i];
3106 /* .modinfo should be contents only but gcc has no attribute for that.
3107 * The kernel may have marked .modinfo as ALLOC, ignore this bit.
3109 if (strcmp(sec->name, ".modinfo") == 0)
3110 sec->header.sh_flags &= ~SHF_ALLOC;
3112 if (sec->header.sh_flags & SHF_ALLOC)
3113 obj_insert_section_load_order(f, sec);
3115 switch (sec->header.sh_type) {
3118 unsigned long nsym, j;
3122 if (sec->header.sh_entsize != sizeof(ElfW(Sym))) {
3123 error_msg("symbol size mismatch: %lu != %lu",
3124 (unsigned long) sec->header.sh_entsize,
3125 (unsigned long) sizeof(ElfW(Sym)));
3129 nsym = sec->header.sh_size / sizeof(ElfW(Sym));
3130 strtab = f->sections[sec->header.sh_link]->contents;
3131 sym = (ElfW(Sym) *) sec->contents;
3133 /* Allocate space for a table of local symbols. */
3134 j = f->local_symtab_size = sec->header.sh_info;
3135 f->local_symtab = xcalloc(j, sizeof(struct obj_symbol *));
3137 /* Insert all symbols into the hash table. */
3138 for (j = 1, ++sym; j < nsym; ++j, ++sym) {
3141 name = strtab + sym->st_name;
3143 name = f->sections[sym->st_shndx]->name;
3145 obj_add_symbol(f, name, j, sym->st_info, sym->st_shndx,
3146 sym->st_value, sym->st_size);
3152 if (sec->header.sh_entsize != sizeof(ElfW(RelM))) {
3153 error_msg("relocation entry size mismatch: %lu != %lu",
3154 (unsigned long) sec->header.sh_entsize,
3155 (unsigned long) sizeof(ElfW(RelM)));
3159 /* XXX Relocation code from modutils-2.3.19 is not here.
3160 * Why? That's about 20 lines of code from obj/obj_load.c,
3161 * which gets done in a second pass through the sections.
3162 * This BusyBox insmod does similar work in obj_relocate(). */
3169 #ifdef CONFIG_FEATURE_INSMOD_LOADINKMEM
3171 * load the unloaded sections directly into the memory allocated by
3172 * kernel for the module
3175 static int obj_load_progbits(FILE * fp, struct obj_file* f, char* imagebase)
3177 ElfW(Addr) base = f->baseaddr;
3178 struct obj_section* sec;
3180 for (sec = f->load_order; sec; sec = sec->load_next) {
3182 /* section already loaded? */
3183 if (sec->contents != NULL)
3186 if (sec->header.sh_size == 0)
3189 sec->contents = imagebase + (sec->header.sh_addr - base);
3190 fseek(fp, sec->header.sh_offset, SEEK_SET);
3191 if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
3192 error_msg("error reading ELF section data: %s\n", strerror(errno));
3201 static void hide_special_symbols(struct obj_file *f)
3203 static const char *const specials[] = {
3210 struct obj_symbol *sym;
3211 const char *const *p;
3213 for (p = specials; *p; ++p)
3214 if ((sym = obj_find_symbol(f, *p)) != NULL)
3216 ELFW(ST_INFO) (STB_LOCAL, ELFW(ST_TYPE) (sym->info));
3221 extern int insmod_main( int argc, char **argv)
3228 unsigned long m_size;
3233 char m_name[FILENAME_MAX + 1] = "\0";
3234 int exit_status = EXIT_FAILURE;
3236 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
3237 struct utsname uts_info;
3238 char m_strversion[STRVERSIONLEN];
3243 /* Parse any options */
3244 while ((opt = getopt(argc, argv, "fkvxLo:")) > 0) {
3246 case 'f': /* force loading */
3247 flag_force_load = 1;
3249 case 'k': /* module loaded by kerneld, auto-cleanable */
3252 case 'v': /* verbose output */
3255 case 'x': /* do not export externs */
3258 case 'o': /* name the output module */
3259 strncpy(m_name, optarg, FILENAME_MAX);
3261 case 'L': /* Stub warning */
3262 /* This is needed for compatibility with modprobe.
3263 * In theory, this does locking, but we don't do
3264 * that. So be careful and plan your life around not
3265 * loading the same module 50 times concurrently. */
3272 if (argv[optind] == NULL) {
3276 /* Grab the module name */
3277 if ((tmp = strrchr(argv[optind], '/')) != NULL) {
3284 if (len > 2 && tmp[len - 2] == '.' && tmp[len - 1] == 'o')
3286 memcpy(m_fullName, tmp, len);
3287 m_fullName[len]='\0';
3288 if (*m_name == '\0') {
3289 strcpy(m_name, m_fullName);
3291 strcat(m_fullName, ".o");
3293 /* Get a filedesc for the module. Check we we have a complete path */
3294 if (stat(argv[optind], &st) < 0 || !S_ISREG(st.st_mode) ||
3295 (fp = fopen(argv[optind], "r")) == NULL) {
3296 struct utsname myuname;
3298 /* Hmm. Could not open it. First search under /lib/modules/`uname -r`,
3299 * but do not error out yet if we fail to find it... */
3300 if (uname(&myuname) == 0) {
3301 char module_dir[FILENAME_MAX];
3302 char real_module_dir[FILENAME_MAX];
3303 snprintf (module_dir, sizeof(module_dir), "%s/%s",
3304 _PATH_MODULES, myuname.release);
3305 /* Jump through hoops in case /lib/modules/`uname -r`
3306 * is a symlink. We do not want recursive_action to
3307 * follow symlinks, but we do want to follow the
3308 * /lib/modules/`uname -r` dir, So resolve it ourselves
3309 * if it is a link... */
3310 if (realpath (module_dir, real_module_dir) == NULL)
3311 strcpy(real_module_dir, module_dir);
3312 recursive_action(real_module_dir, TRUE, FALSE, FALSE,
3313 check_module_name_match, 0, m_fullName);
3316 /* Check if we have found anything yet */
3317 if (m_filename[0] == '\0' || ((fp = fopen(m_filename, "r")) == NULL))
3319 char module_dir[FILENAME_MAX];
3320 if (realpath (_PATH_MODULES, module_dir) == NULL)
3321 strcpy(module_dir, _PATH_MODULES);
3322 /* No module found under /lib/modules/`uname -r`, this
3323 * time cast the net a bit wider. Search /lib/modules/ */
3324 if (! recursive_action(module_dir, TRUE, FALSE, FALSE,
3325 check_module_name_match, 0, m_fullName))
3327 if (m_filename[0] == '\0'
3328 || ((fp = fopen(m_filename, "r")) == NULL))
3330 error_msg("%s: no module by that name found", m_fullName);
3331 return EXIT_FAILURE;
3334 error_msg_and_die("%s: no module by that name found", m_fullName);
3337 safe_strncpy(m_filename, argv[optind], sizeof(m_filename));
3339 printf("Using %s\n", m_filename);
3341 if ((f = obj_load(fp, LOADBITS)) == NULL)
3342 perror_msg_and_die("Could not load the module");
3344 if (get_modinfo_value(f, "kernel_version") == NULL)
3349 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
3350 /* Version correspondence? */
3352 if (uname(&uts_info) < 0)
3353 uts_info.release[0] = '\0';
3354 if (m_has_modinfo) {
3355 m_version = new_get_module_version(f, m_strversion);
3357 m_version = old_get_module_version(f, m_strversion);
3358 if (m_version == -1) {
3359 error_msg("couldn't find the kernel version the module was "
3365 if (strncmp(uts_info.release, m_strversion, STRVERSIONLEN) != 0) {
3366 if (flag_force_load) {
3367 error_msg("Warning: kernel-module version mismatch\n"
3368 "\t%s was compiled for kernel version %s\n"
3369 "\twhile this kernel is version %s",
3370 m_filename, m_strversion, uts_info.release);
3372 error_msg("kernel-module version mismatch\n"
3373 "\t%s was compiled for kernel version %s\n"
3374 "\twhile this kernel is version %s.",
3375 m_filename, m_strversion, uts_info.release);
3380 #endif /* CONFIG_FEATURE_INSMOD_VERSION_CHECKING */
3382 k_new_syscalls = !query_module(NULL, 0, NULL, 0, NULL);
3384 if (k_new_syscalls) {
3385 #ifdef CONFIG_FEATURE_NEW_MODULE_INTERFACE
3386 if (!new_get_kernel_symbols())
3388 k_crcs = new_is_kernel_checksummed();
3390 error_msg("Not configured to support new kernels");
3394 #ifdef CONFIG_FEATURE_OLD_MODULE_INTERFACE
3395 if (!old_get_kernel_symbols(m_name))
3397 k_crcs = old_is_kernel_checksummed();
3399 error_msg("Not configured to support old kernels");
3404 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
3406 m_crcs = new_is_module_checksummed(f);
3408 m_crcs = old_is_module_checksummed(f);
3410 if (m_crcs != k_crcs)
3411 obj_set_symbol_compare(f, ncv_strcmp, ncv_symbol_hash);
3412 #endif /* CONFIG_FEATURE_INSMOD_VERSION_CHECKING */
3414 /* Let the module know about the kernel symbols. */
3415 add_kernel_symbols(f);
3417 /* Allocate common symbols, symbol tables, and string tables. */
3420 ? !new_create_this_module(f, m_name)
3421 : !old_create_mod_use_count(f))
3426 if (!obj_check_undefineds(f)) {
3429 obj_allocate_commons(f);
3431 /* done with the module name, on to the optional var=value arguments */
3434 if (optind < argc) {
3436 ? !new_process_module_arguments(f, argc - optind, argv + optind)
3437 : !old_process_module_arguments(f, argc - optind, argv + optind))
3444 hide_special_symbols(f);
3447 new_create_module_ksymtab(f);
3449 /* Find current size of the module */
3450 m_size = obj_load_size(f);
3453 m_addr = create_module(m_name, m_size);
3454 if (m_addr==-1) switch (errno) {
3456 error_msg("A module named %s already exists", m_name);
3459 error_msg("Can't allocate kernel memory for module; needed %lu bytes",
3463 perror_msg("create_module: %s", m_name);
3469 * the PROGBITS section was not loaded by the obj_load
3470 * now we can load them directly into the kernel memory
3472 if (!obj_load_progbits(fp, f, (char*)m_addr)) {
3473 delete_module(m_name);
3478 if (!obj_relocate(f, m_addr)) {
3479 delete_module(m_name);
3484 ? !new_init_module(m_name, f, m_size)
3485 : !old_init_module(m_name, f, m_size))
3487 delete_module(m_name);
3491 exit_status = EXIT_SUCCESS;
3495 return(exit_status);