1 /* vi: set sw=4 ts=4: */
3 * Mini insmod implementation for busybox
4 * This version of insmod now supports x86, ARM, SH3/4, powerpc, and MIPS.
6 * Copyright (C) 1999,2000,2001 by Lineo, inc.
7 * Written by Erik Andersen <andersen@lineo.com>
8 * and Ron Alder <alder@lineo.com>
10 * Modified by Bryan Rittmeyer <bryan@ixiacom.com> to support SH4
11 * and (theoretically) SH3. I have only tested SH4 in little endian mode.
13 * Modified by Alcove, Julien Gaulmin <julien.gaulmin@alcove.fr> and
14 * Nicolas Ferre <nicolas.ferre@alcove.fr> to support ARM7TDMI. Only
15 * very minor changes required to also work with StrongArm and presumably
16 * all ARM based systems.
18 * Magnus Damm <damm@opensource.se> added PowerPC support 20-Feb-2001.
19 * PowerPC specific code stolen from modutils-2.3.16,
20 * written by Paul Mackerras, Copyright 1996, 1997 Linux International.
21 * I've only tested the code on mpc8xx platforms in big-endian mode.
22 * Did some cleanup and added BB_USE_xxx_ENTRIES...
24 * Quinn Jensen <jensenq@lineo.com> added MIPS support 23-Feb-2001.
25 * based on modutils-2.4.2
26 * MIPS specific support for Elf loading and relocation.
27 * Copyright 1996, 1997 Linux International.
28 * Contributed by Ralf Baechle <ralf@gnu.ai.mit.edu>
30 * Based almost entirely on the Linux modutils-2.3.11 implementation.
31 * Copyright 1996, 1997 Linux International.
32 * New implementation contributed by Richard Henderson <rth@tamu.edu>
33 * Based on original work by Bjorn Ekwall <bj0rn@blox.se>
34 * Restructured (and partly rewritten) by:
35 * Björn Ekwall <bj0rn@blox.se> February 1999
37 * This program is free software; you can redistribute it and/or modify
38 * it under the terms of the GNU General Public License as published by
39 * the Free Software Foundation; either version 2 of the License, or
40 * (at your option) any later version.
42 * This program is distributed in the hope that it will be useful,
43 * but WITHOUT ANY WARRANTY; without even the implied warranty of
44 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
45 * General Public License for more details.
47 * You should have received a copy of the GNU General Public License
48 * along with this program; if not, write to the Free Software
49 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
63 #include <sys/utsname.h>
66 #ifdef BB_FEATURE_NEW_MODULE_INTERFACE
67 # define new_sys_init_module init_module
69 # define old_sys_init_module init_module
72 #ifdef BB_FEATURE_INSMOD_LOADINKMEM
78 #if defined(__powerpc__)
79 #define BB_USE_PLT_ENTRIES
80 #define BB_PLT_ENTRY_SIZE 16
84 #define BB_USE_PLT_ENTRIES
85 #define BB_PLT_ENTRY_SIZE 8
86 #define BB_USE_GOT_ENTRIES
87 #define BB_GOT_ENTRY_SIZE 8
91 #define BB_USE_GOT_ENTRIES
92 #define BB_GOT_ENTRY_SIZE 4
96 #define BB_USE_GOT_ENTRIES
97 #define BB_GOT_ENTRY_SIZE 4
100 #if defined(__mips__)
104 //----------------------------------------------------------------------------
105 //--------modutils module.h, lines 45-242
106 //----------------------------------------------------------------------------
108 /* Definitions for the Linux module syscall interface.
109 Copyright 1996, 1997 Linux International.
111 Contributed by Richard Henderson <rth@tamu.edu>
113 This file is part of the Linux modutils.
115 This program is free software; you can redistribute it and/or modify it
116 under the terms of the GNU General Public License as published by the
117 Free Software Foundation; either version 2 of the License, or (at your
118 option) any later version.
120 This program is distributed in the hope that it will be useful, but
121 WITHOUT ANY WARRANTY; without even the implied warranty of
122 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
123 General Public License for more details.
125 You should have received a copy of the GNU General Public License
126 along with this program; if not, write to the Free Software Foundation,
127 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
130 #ifndef MODUTILS_MODULE_H
131 static const int MODUTILS_MODULE_H = 1;
133 #ident "$Id: insmod.c,v 1.65 2001/05/24 14:16:28 andersen Exp $"
135 /* This file contains the structures used by the 2.0 and 2.1 kernels.
136 We do not use the kernel headers directly because we do not wish
137 to be dependant on a particular kernel version to compile insmod. */
140 /*======================================================================*/
141 /* The structures used by Linux 2.0. */
143 /* The symbol format used by get_kernel_syms(2). */
144 struct old_kernel_sym
150 struct old_module_ref
152 unsigned long module; /* kernel addresses */
156 struct old_module_symbol
162 struct old_symbol_table
164 int size; /* total, including string table!!! */
167 struct old_module_symbol symbol[0]; /* actual size defined by n_symbols */
168 struct old_module_ref ref[0]; /* actual size defined by n_refs */
171 struct old_mod_routines
174 unsigned long cleanup;
180 unsigned long ref; /* the list of modules that refer to me */
181 unsigned long symtab;
183 int size; /* size of module in pages */
184 unsigned long addr; /* address of module */
186 unsigned long cleanup; /* cleanup routine */
189 /* Sent to init_module(2) or'ed into the code size parameter. */
190 static const int OLD_MOD_AUTOCLEAN = 0x40000000; /* big enough, but no sign problems... */
192 int get_kernel_syms(struct old_kernel_sym *);
193 int old_sys_init_module(const char *name, char *code, unsigned codesize,
194 struct old_mod_routines *, struct old_symbol_table *);
196 /*======================================================================*/
197 /* For sizeof() which are related to the module platform and not to the
198 environment isnmod is running in, use sizeof_xx instead of sizeof(xx). */
200 #define tgt_sizeof_char sizeof(char)
201 #define tgt_sizeof_short sizeof(short)
202 #define tgt_sizeof_int sizeof(int)
203 #define tgt_sizeof_long sizeof(long)
204 #define tgt_sizeof_char_p sizeof(char *)
205 #define tgt_sizeof_void_p sizeof(void *)
206 #define tgt_long long
208 #if defined(__sparc__) && !defined(__sparc_v9__) && defined(ARCH_sparc64)
209 #undef tgt_sizeof_long
210 #undef tgt_sizeof_char_p
211 #undef tgt_sizeof_void_p
213 static const int tgt_sizeof_long = 8;
214 static const int tgt_sizeof_char_p = 8;
215 static const int tgt_sizeof_void_p = 8;
216 #define tgt_long long long
219 /*======================================================================*/
220 /* The structures used in Linux 2.1. */
222 /* Note: new_module_symbol does not use tgt_long intentionally */
223 struct new_module_symbol
229 struct new_module_persist;
231 struct new_module_ref
233 unsigned tgt_long dep; /* kernel addresses */
234 unsigned tgt_long ref;
235 unsigned tgt_long next_ref;
240 unsigned tgt_long size_of_struct; /* == sizeof(module) */
241 unsigned tgt_long next;
242 unsigned tgt_long name;
243 unsigned tgt_long size;
246 unsigned tgt_long flags; /* AUTOCLEAN et al */
251 unsigned tgt_long syms;
252 unsigned tgt_long deps;
253 unsigned tgt_long refs;
254 unsigned tgt_long init;
255 unsigned tgt_long cleanup;
256 unsigned tgt_long ex_table_start;
257 unsigned tgt_long ex_table_end;
259 unsigned tgt_long gp;
261 /* Everything after here is extension. */
262 unsigned tgt_long persist_start;
263 unsigned tgt_long persist_end;
264 unsigned tgt_long can_unload;
265 unsigned tgt_long runsize;
266 #ifdef BB_FEATURE_NEW_MODULE_INTERFACE
267 const char *kallsyms_start; /* All symbols for kernel debugging */
268 const char *kallsyms_end;
269 const char *archdata_start; /* arch specific data for module */
270 const char *archdata_end;
271 const char *kernel_data; /* Reserved for kernel internal use */
275 #define ARCHDATA_SEC_NAME "__archdata"
276 #define KALLSYMS_SEC_NAME "__kallsyms"
279 struct new_module_info
287 /* Bits of module.flags. */
288 static const int NEW_MOD_RUNNING = 1;
289 static const int NEW_MOD_DELETED = 2;
290 static const int NEW_MOD_AUTOCLEAN = 4;
291 static const int NEW_MOD_VISITED = 8;
292 static const int NEW_MOD_USED_ONCE = 16;
294 int new_sys_init_module(const char *name, const struct new_module *);
295 int query_module(const char *name, int which, void *buf, size_t bufsize,
298 /* Values for query_module's which. */
300 static const int QM_MODULES = 1;
301 static const int QM_DEPS = 2;
302 static const int QM_REFS = 3;
303 static const int QM_SYMBOLS = 4;
304 static const int QM_INFO = 5;
306 /*======================================================================*/
307 /* The system calls unchanged between 2.0 and 2.1. */
309 unsigned long create_module(const char *, size_t);
310 int delete_module(const char *);
313 #endif /* module.h */
315 //----------------------------------------------------------------------------
316 //--------end of modutils module.h
317 //----------------------------------------------------------------------------
321 //----------------------------------------------------------------------------
322 //--------modutils obj.h, lines 253-462
323 //----------------------------------------------------------------------------
325 /* Elf object file loading and relocation routines.
326 Copyright 1996, 1997 Linux International.
328 Contributed by Richard Henderson <rth@tamu.edu>
330 This file is part of the Linux modutils.
332 This program is free software; you can redistribute it and/or modify it
333 under the terms of the GNU General Public License as published by the
334 Free Software Foundation; either version 2 of the License, or (at your
335 option) any later version.
337 This program is distributed in the hope that it will be useful, but
338 WITHOUT ANY WARRANTY; without even the implied warranty of
339 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
340 General Public License for more details.
342 You should have received a copy of the GNU General Public License
343 along with this program; if not, write to the Free Software Foundation,
344 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
347 #ifndef MODUTILS_OBJ_H
348 static const int MODUTILS_OBJ_H = 1;
350 #ident "$Id: insmod.c,v 1.65 2001/05/24 14:16:28 andersen Exp $"
352 /* The relocatable object is manipulated using elfin types. */
358 /* Machine-specific elf macros for i386 et al. */
360 /* the SH changes have only been tested on the SH4 in =little endian= mode */
361 /* I'm not sure about big endian, so let's warn: */
363 #if (defined(__SH4__) || defined(__SH3__)) && defined(__BIG_ENDIAN__)
364 #error insmod.c may require changes for use on big endian SH4/SH3
367 /* it may or may not work on the SH1/SH2... So let's error on those
369 #if (defined(__sh__) && (!(defined(__SH3__) || defined(__SH4__))))
370 #error insmod.c may require changes for non-SH3/SH4 use
373 #define ELFCLASSM ELFCLASS32
375 #if (defined(__m68k__))
376 #define ELFDATAM ELFDATA2MSB
383 #define MATCH_MACHINE(x) (x == EM_SH)
384 #define SHT_RELM SHT_RELA
385 #define Elf32_RelM Elf32_Rela
386 #define ELFDATAM ELFDATA2LSB
388 #elif defined(__arm__)
390 #define MATCH_MACHINE(x) (x == EM_ARM)
391 #define SHT_RELM SHT_REL
392 #define Elf32_RelM Elf32_Rel
393 #define ELFDATAM ELFDATA2LSB
395 #elif defined(__powerpc__)
397 #define MATCH_MACHINE(x) (x == EM_PPC)
398 #define SHT_RELM SHT_RELA
399 #define Elf32_RelM Elf32_Rela
400 #define ELFDATAM ELFDATA2MSB
402 #elif defined(__mips__)
404 /* Account for ELF spec changes. */
405 #ifndef EM_MIPS_RS3_LE
406 #ifdef EM_MIPS_RS4_BE
407 #define EM_MIPS_RS3_LE EM_MIPS_RS4_BE
409 #define EM_MIPS_RS3_LE 10
411 #endif /* !EM_MIPS_RS3_LE */
413 #define MATCH_MACHINE(x) (x == EM_MIPS || x == EM_MIPS_RS3_LE)
414 #define SHT_RELM SHT_REL
415 #define Elf32_RelM Elf32_Rel
417 #define ELFDATAM ELFDATA2MSB
420 #define ELFDATAM ELFDATA2LSB
423 #elif defined(__i386__)
425 /* presumably we can use these for anything but the SH and ARM*/
426 /* this is the previous behavior, but it does result in
427 insmod.c being broken on anything except i386 */
429 #define MATCH_MACHINE(x) (x == EM_386)
431 #define MATCH_MACHINE(x) (x == EM_386 || x == EM_486)
434 #define SHT_RELM SHT_REL
435 #define Elf32_RelM Elf32_Rel
436 #define ELFDATAM ELFDATA2LSB
438 #elif defined(__m68k__)
440 #define MATCH_MACHINE(x) (x == EM_68K)
441 #define SHT_RELM SHT_RELA
442 #define Elf32_RelM Elf32_Rela
445 #error Sorry, but insmod.c does not yet support this architecture...
449 # if ELFCLASSM == ELFCLASS32
450 # define ElfW(x) Elf32_ ## x
451 # define ELFW(x) ELF32_ ## x
453 # define ElfW(x) Elf64_ ## x
454 # define ELFW(x) ELF64_ ## x
458 /* For some reason this is missing from libc5. */
459 #ifndef ELF32_ST_INFO
460 # define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
463 #ifndef ELF64_ST_INFO
464 # define ELF64_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
467 struct obj_string_patch;
468 struct obj_symbol_patch;
475 struct obj_section *load_next;
481 struct obj_symbol *next; /* hash table link */
485 int secidx; /* the defining section index/module */
487 int ksymidx; /* for export to the kernel symtab */
488 int referenced; /* actually used in the link */
491 /* Hardcode the hash table size. We shouldn't be needing so many
492 symbols that we begin to degrade performance, and we get a big win
493 by giving the compiler a constant divisor. */
495 #define HASH_BUCKETS 521
501 struct obj_section **sections;
502 struct obj_section *load_order;
503 struct obj_section **load_order_search_start;
504 struct obj_string_patch *string_patches;
505 struct obj_symbol_patch *symbol_patches;
506 int (*symbol_cmp)(const char *, const char *);
507 unsigned long (*symbol_hash)(const char *);
508 unsigned long local_symtab_size;
509 struct obj_symbol **local_symtab;
510 struct obj_symbol *symtab[HASH_BUCKETS];
521 struct obj_string_patch
523 struct obj_string_patch *next;
525 ElfW(Addr) reloc_offset;
526 ElfW(Addr) string_offset;
529 struct obj_symbol_patch
531 struct obj_symbol_patch *next;
533 ElfW(Addr) reloc_offset;
534 struct obj_symbol *sym;
538 /* Generic object manipulation routines. */
540 unsigned long obj_elf_hash(const char *);
542 unsigned long obj_elf_hash_n(const char *, unsigned long len);
544 struct obj_symbol *obj_add_symbol (struct obj_file *f, const char *name,
545 unsigned long symidx, int info, int secidx,
546 ElfW(Addr) value, unsigned long size);
548 struct obj_symbol *obj_find_symbol (struct obj_file *f,
551 ElfW(Addr) obj_symbol_final_value(struct obj_file *f,
552 struct obj_symbol *sym);
554 void obj_set_symbol_compare(struct obj_file *f,
555 int (*cmp)(const char *, const char *),
556 unsigned long (*hash)(const char *));
558 struct obj_section *obj_find_section (struct obj_file *f,
561 void obj_insert_section_load_order (struct obj_file *f,
562 struct obj_section *sec);
564 struct obj_section *obj_create_alloced_section (struct obj_file *f,
569 struct obj_section *obj_create_alloced_section_first (struct obj_file *f,
574 void *obj_extend_section (struct obj_section *sec, unsigned long more);
576 int obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
579 int obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
580 struct obj_symbol *sym);
582 int obj_check_undefineds(struct obj_file *f);
584 void obj_allocate_commons(struct obj_file *f);
586 unsigned long obj_load_size (struct obj_file *f);
588 int obj_relocate (struct obj_file *f, ElfW(Addr) base);
590 struct obj_file *obj_load(FILE *f, int loadprogbits);
592 int obj_create_image (struct obj_file *f, char *image);
594 /* Architecture specific manipulation routines. */
596 struct obj_file *arch_new_file (void);
598 struct obj_section *arch_new_section (void);
600 struct obj_symbol *arch_new_symbol (void);
602 enum obj_reloc arch_apply_relocation (struct obj_file *f,
603 struct obj_section *targsec,
604 struct obj_section *symsec,
605 struct obj_symbol *sym,
606 ElfW(RelM) *rel, ElfW(Addr) value);
608 int arch_create_got (struct obj_file *f);
611 int arch_init_module (struct obj_file *f, struct new_module *);
614 //----------------------------------------------------------------------------
615 //--------end of modutils obj.h
616 //----------------------------------------------------------------------------
622 #define _PATH_MODULES "/lib/modules"
623 static const int STRVERSIONLEN = 32;
625 /*======================================================================*/
627 int flag_force_load = 0;
628 int flag_autoclean = 0;
629 int flag_verbose = 0;
633 /*======================================================================*/
635 /* previously, these were named i386_* but since we could be
636 compiling for the sh, I've renamed them to the more general
637 arch_* These structures are the same between the x86 and SH,
638 and we can't support anything else right now anyway. In the
639 future maybe they should be #if defined'd */
645 #if defined(BB_USE_PLT_ENTRIES)
646 struct arch_plt_entry
650 int inited:1; /* has been set up */
654 #if defined(BB_USE_GOT_ENTRIES)
655 struct arch_got_entry {
657 unsigned offset_done:1;
658 unsigned reloc_done:1;
662 #if defined(__mips__)
665 struct mips_hi16 *next;
672 struct obj_file root;
673 #if defined(BB_USE_PLT_ENTRIES)
674 struct obj_section *plt;
676 #if defined(BB_USE_GOT_ENTRIES)
677 struct obj_section *got;
679 #if defined(__mips__)
680 struct mips_hi16 *mips_hi16_list;
685 struct obj_symbol root;
686 #if defined(BB_USE_PLT_ENTRIES)
687 struct arch_plt_entry pltent;
689 #if defined(BB_USE_GOT_ENTRIES)
690 struct arch_got_entry gotent;
695 struct external_module {
700 struct new_module_symbol *syms;
703 struct new_module_symbol *ksyms;
706 struct external_module *ext_modules;
708 int n_ext_modules_used;
709 extern int delete_module(const char *);
711 static char m_filename[FILENAME_MAX + 1];
712 static char m_fullName[FILENAME_MAX + 1];
716 /*======================================================================*/
719 static int check_module_name_match(const char *filename, struct stat *statbuf,
722 char *fullname = (char *) userdata;
724 if (fullname[0] == '\0')
727 char *tmp, *tmp1 = strdup(filename);
728 tmp = get_last_path_component(tmp1);
729 if (strcmp(tmp, fullname) == 0) {
731 /* Stop searching if we find a match */
732 safe_strncpy(m_filename, filename, sizeof(m_filename));
741 /*======================================================================*/
743 struct obj_file *arch_new_file(void)
746 f = xmalloc(sizeof(*f));
748 #if defined(BB_USE_PLT_ENTRIES)
751 #if defined(BB_USE_GOT_ENTRIES)
754 #if defined(__mips__)
755 f->mips_hi16_list = NULL;
761 struct obj_section *arch_new_section(void)
763 return xmalloc(sizeof(struct obj_section));
766 struct obj_symbol *arch_new_symbol(void)
768 struct arch_symbol *sym;
769 sym = xmalloc(sizeof(*sym));
771 #if defined(BB_USE_PLT_ENTRIES)
772 memset(&sym->pltent, 0, sizeof(sym->pltent));
774 #if defined(BB_USE_GOT_ENTRIES)
775 memset(&sym->gotent, 0, sizeof(sym->gotent));
782 arch_apply_relocation(struct obj_file *f,
783 struct obj_section *targsec,
784 struct obj_section *symsec,
785 struct obj_symbol *sym,
786 ElfW(RelM) *rel, ElfW(Addr) v)
788 struct arch_file *ifile = (struct arch_file *) f;
789 #if !(defined(__mips__))
790 struct arch_symbol *isym = (struct arch_symbol *) sym;
793 ElfW(Addr) *loc = (ElfW(Addr) *) (targsec->contents + rel->r_offset);
794 ElfW(Addr) dot = targsec->header.sh_addr + rel->r_offset;
795 #if defined(BB_USE_GOT_ENTRIES)
796 ElfW(Addr) got = ifile->got ? ifile->got->header.sh_addr : 0;
798 #if defined(BB_USE_PLT_ENTRIES)
799 ElfW(Addr) plt = ifile->plt ? ifile->plt->header.sh_addr : 0;
800 struct arch_plt_entry *pe;
803 enum obj_reloc ret = obj_reloc_ok;
805 switch (ELF32_R_TYPE(rel->r_info)) {
807 /* even though these constants seem to be the same for
808 the i386 and the sh, we "#if define" them for clarity
809 and in case that ever changes */
812 #elif defined(__arm__)
814 #elif defined(__i386__)
816 #elif defined(__m68k__)
818 #elif defined(__powerpc__)
820 #elif defined(__mips__)
827 #elif defined(__arm__)
829 #elif defined(__i386__)
831 #elif defined(__m68k__)
833 #elif defined(__powerpc__)
835 #elif defined(__mips__)
840 #if defined(__m68k__)
843 ret = obj_reloc_overflow;
848 ret = obj_reloc_overflow;
851 #endif /* __m68k__ */
853 #if defined(__powerpc__)
854 case R_PPC_ADDR16_HA:
855 *(unsigned short *)loc = (v + 0x8000) >> 16;
858 case R_PPC_ADDR16_HI:
859 *(unsigned short *)loc = v >> 16;
862 case R_PPC_ADDR16_LO:
863 *(unsigned short *)loc = v;
867 #if defined(__mips__)
870 ret = obj_reloc_dangerous;
871 if ((v & 0xf0000000) != ((dot + 4) & 0xf0000000))
872 ret = obj_reloc_overflow;
874 (*loc & ~0x03ffffff) | ((*loc + (v >> 2)) &
882 /* We cannot relocate this one now because we don't know the value
883 of the carry we need to add. Save the information, and let LO16
884 do the actual relocation. */
885 n = (struct mips_hi16 *) xmalloc(sizeof *n);
888 n->next = ifile->mips_hi16_list;
889 ifile->mips_hi16_list = n;
895 unsigned long insnlo = *loc;
896 Elf32_Addr val, vallo;
898 /* Sign extend the addend we extract from the lo insn. */
899 vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
901 if (ifile->mips_hi16_list != NULL) {
904 l = ifile->mips_hi16_list;
906 struct mips_hi16 *next;
909 /* The value for the HI16 had best be the same. */
910 assert(v == l->value);
912 /* Do the HI16 relocation. Note that we actually don't
913 need to know anything about the LO16 itself, except where
914 to find the low 16 bits of the addend needed by the LO16. */
917 ((insn & 0xffff) << 16) +
921 /* Account for the sign extension that will happen in the
928 insn = (insn & ~0xffff) | val;
936 ifile->mips_hi16_list = NULL;
939 /* Ok, we're done with the HI16 relocs. Now deal with the LO16. */
941 insnlo = (insnlo & ~0xffff) | (val & 0xffff);
948 #elif defined(__sh__)
952 #elif defined(__i386__)
957 #elif defined(__m68k__)
960 if ((Elf32_Sword)v > 0x7f || (Elf32_Sword)v < -(Elf32_Sword)0x80)
961 ret = obj_reloc_overflow;
966 if ((Elf32_Sword)v > 0x7fff || (Elf32_Sword)v < -(Elf32_Sword)0x8000)
967 ret = obj_reloc_overflow;
971 *(int *)loc = v - dot;
973 #elif defined(__powerpc__)
983 #elif defined(__i386__)
986 #if defined(BB_USE_PLT_ENTRIES)
992 #if defined(__powerpc__)
995 /* find the plt entry and initialize it if necessary */
996 assert(isym != NULL);
998 pe = (struct arch_plt_entry*) &isym->pltent;
1001 ip = (unsigned long *) (ifile->plt->contents + pe->offset);
1003 /* generate some machine code */
1005 #if defined(__arm__)
1006 ip[0] = 0xe51ff004; /* ldr pc,[pc,#-4] */
1007 ip[1] = v; /* sym@ */
1009 #if defined(__powerpc__)
1010 ip[0] = 0x3d600000 + ((v + 0x8000) >> 16); /* lis r11,sym@ha */
1011 ip[1] = 0x396b0000 + (v & 0xffff); /* addi r11,r11,sym@l */
1012 ip[2] = 0x7d6903a6; /* mtctr r11 */
1013 ip[3] = 0x4e800420; /* bctr */
1018 /* relative distance to target */
1020 /* if the target is too far away.... */
1021 if ((int)v < -0x02000000 || (int)v >= 0x02000000) {
1022 /* go via the plt */
1023 v = plt + pe->offset - dot;
1026 ret = obj_reloc_dangerous;
1028 /* merge the offset into the instruction. */
1029 #if defined(__arm__)
1030 /* Convert to words. */
1033 *loc = (*loc & ~0x00ffffff) | ((v + *loc) & 0x00ffffff);
1035 #if defined(__powerpc__)
1036 *loc = (*loc & ~0x03fffffc) | (v & 0x03fffffc);
1039 #endif /* BB_USE_PLT_ENTRIES */
1041 #if defined(__arm__)
1042 #elif defined(__sh__)
1047 #elif defined(__i386__)
1048 case R_386_GLOB_DAT:
1049 case R_386_JMP_SLOT:
1052 #elif defined(__m68k__)
1053 case R_68K_GLOB_DAT:
1054 case R_68K_JMP_SLOT:
1059 #if defined(__arm__)
1060 #elif defined(__sh__)
1062 *loc += f->baseaddr + rel->r_addend;
1064 #elif defined(__i386__)
1065 case R_386_RELATIVE:
1066 *loc += f->baseaddr;
1068 #elif defined(__m68k__)
1069 case R_68K_RELATIVE:
1070 *(int *)loc += f->baseaddr;
1074 #if defined(BB_USE_GOT_ENTRIES)
1076 #if !defined(__68k__)
1079 #elif defined(__arm__)
1081 #elif defined(__i386__)
1086 *loc += got - dot + rel->r_addend;;
1087 #elif defined(__i386__) || defined(__arm__) || defined(__m68k_)
1095 #elif defined(__arm__)
1097 #elif defined(__i386__)
1099 #elif defined(__m68k__)
1102 assert(isym != NULL);
1103 /* needs an entry in the .got: set it, once */
1104 if (!isym->gotent.reloc_done) {
1105 isym->gotent.reloc_done = 1;
1106 *(ElfW(Addr) *) (ifile->got->contents + isym->gotent.offset) = v;
1108 /* make the reloc with_respect_to_.got */
1110 *loc += isym->gotent.offset + rel->r_addend;
1111 #elif defined(__i386__) || defined(__arm__) || defined(__m68k__)
1112 *loc += isym->gotent.offset;
1116 /* address relative to the got */
1117 #if !defined(__m68k__)
1120 #elif defined(__arm__)
1122 #elif defined(__i386__)
1124 #elif defined(__m68k__)
1132 #endif /* BB_USE_GOT_ENTRIES */
1135 printf("Warning: unhandled reloc %d\n",(int)ELF32_R_TYPE(rel->r_info));
1136 ret = obj_reloc_unhandled;
1143 int arch_create_got(struct obj_file *f)
1145 #if defined(BB_USE_GOT_ENTRIES) || defined(BB_USE_PLT_ENTRIES)
1146 struct arch_file *ifile = (struct arch_file *) f;
1148 #if defined(BB_USE_GOT_ENTRIES)
1149 int got_offset = 0, gotneeded = 0;
1151 #if defined(BB_USE_PLT_ENTRIES)
1152 int plt_offset = 0, pltneeded = 0;
1154 struct obj_section *relsec, *symsec, *strsec;
1155 ElfW(RelM) *rel, *relend;
1156 ElfW(Sym) *symtab, *extsym;
1157 const char *strtab, *name;
1158 struct arch_symbol *intsym;
1160 for (i = 0; i < f->header.e_shnum; ++i) {
1161 relsec = f->sections[i];
1162 if (relsec->header.sh_type != SHT_RELM)
1165 symsec = f->sections[relsec->header.sh_link];
1166 strsec = f->sections[symsec->header.sh_link];
1168 rel = (ElfW(RelM) *) relsec->contents;
1169 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
1170 symtab = (ElfW(Sym) *) symsec->contents;
1171 strtab = (const char *) strsec->contents;
1173 for (; rel < relend; ++rel) {
1174 extsym = &symtab[ELF32_R_SYM(rel->r_info)];
1176 switch (ELF32_R_TYPE(rel->r_info)) {
1177 #if defined(__arm__)
1180 #elif defined(__sh__)
1183 #elif defined(__i386__)
1186 #elif defined(__m68k__)
1191 #if defined(__powerpc__)
1197 #if defined(__arm__)
1206 if (got_offset == 0)
1208 #elif defined(__sh__)
1212 #elif defined(__i386__)
1222 if (extsym->st_name != 0) {
1223 name = strtab + extsym->st_name;
1225 name = f->sections[extsym->st_shndx]->name;
1227 intsym = (struct arch_symbol *) obj_find_symbol(f, name);
1228 #if defined(BB_USE_GOT_ENTRIES)
1229 if (!intsym->gotent.offset_done) {
1230 intsym->gotent.offset_done = 1;
1231 intsym->gotent.offset = got_offset;
1232 got_offset += BB_GOT_ENTRY_SIZE;
1235 #if defined(BB_USE_PLT_ENTRIES)
1236 if (pltneeded && intsym->pltent.allocated == 0) {
1237 intsym->pltent.allocated = 1;
1238 intsym->pltent.offset = plt_offset;
1239 plt_offset += BB_PLT_ENTRY_SIZE;
1240 intsym->pltent.inited = 0;
1247 #if defined(BB_USE_GOT_ENTRIES)
1249 struct obj_section* myrelsec = obj_find_section(f, ".got");
1252 obj_extend_section(myrelsec, got_offset);
1254 myrelsec = obj_create_alloced_section(f, ".got",
1260 ifile->got = myrelsec;
1264 #if defined(BB_USE_PLT_ENTRIES)
1266 ifile->plt = obj_create_alloced_section(f, ".plt",
1274 int arch_init_module(struct obj_file *f, struct new_module *mod)
1280 /*======================================================================*/
1282 /* Standard ELF hash function. */
1283 inline unsigned long obj_elf_hash_n(const char *name, unsigned long n)
1285 unsigned long h = 0;
1292 if ((g = (h & 0xf0000000)) != 0) {
1301 unsigned long obj_elf_hash(const char *name)
1303 return obj_elf_hash_n(name, strlen(name));
1306 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
1307 /* Get the kernel version in the canonical integer form. */
1309 static int get_kernel_version(char str[STRVERSIONLEN])
1311 struct utsname uts_info;
1315 if (uname(&uts_info) < 0)
1317 strncpy(str, uts_info.release, STRVERSIONLEN);
1318 p = uts_info.release;
1320 a = strtoul(p, &p, 10);
1323 b = strtoul(p + 1, &p, 10);
1326 c = strtoul(p + 1, &q, 10);
1330 return a << 16 | b << 8 | c;
1333 /* String comparison for non-co-versioned kernel and module. */
1335 static int ncv_strcmp(const char *a, const char *b)
1337 size_t alen = strlen(a), blen = strlen(b);
1339 if (blen == alen + 10 && b[alen] == '_' && b[alen + 1] == 'R')
1340 return strncmp(a, b, alen);
1341 else if (alen == blen + 10 && a[blen] == '_' && a[blen + 1] == 'R')
1342 return strncmp(a, b, blen);
1344 return strcmp(a, b);
1347 /* String hashing for non-co-versioned kernel and module. Here
1348 we are simply forced to drop the crc from the hash. */
1350 static unsigned long ncv_symbol_hash(const char *str)
1352 size_t len = strlen(str);
1353 if (len > 10 && str[len - 10] == '_' && str[len - 9] == 'R')
1355 return obj_elf_hash_n(str, len);
1359 obj_set_symbol_compare(struct obj_file *f,
1360 int (*cmp) (const char *, const char *),
1361 unsigned long (*hash) (const char *))
1364 f->symbol_cmp = cmp;
1366 struct obj_symbol *tmptab[HASH_BUCKETS], *sym, *next;
1369 f->symbol_hash = hash;
1371 memcpy(tmptab, f->symtab, sizeof(tmptab));
1372 memset(f->symtab, 0, sizeof(f->symtab));
1374 for (i = 0; i < HASH_BUCKETS; ++i)
1375 for (sym = tmptab[i]; sym; sym = next) {
1376 unsigned long h = hash(sym->name) % HASH_BUCKETS;
1378 sym->next = f->symtab[h];
1384 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
1387 struct obj_symbol *obj_add_symbol(struct obj_file *f, const char *name,
1388 unsigned long symidx, int info,
1389 int secidx, ElfW(Addr) value,
1392 struct obj_symbol *sym;
1393 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
1394 int n_type = ELFW(ST_TYPE) (info);
1395 int n_binding = ELFW(ST_BIND) (info);
1397 for (sym = f->symtab[hash]; sym; sym = sym->next)
1398 if (f->symbol_cmp(sym->name, name) == 0) {
1399 int o_secidx = sym->secidx;
1400 int o_info = sym->info;
1401 int o_type = ELFW(ST_TYPE) (o_info);
1402 int o_binding = ELFW(ST_BIND) (o_info);
1404 /* A redefinition! Is it legal? */
1406 if (secidx == SHN_UNDEF)
1408 else if (o_secidx == SHN_UNDEF)
1410 else if (n_binding == STB_GLOBAL && o_binding == STB_LOCAL) {
1411 /* Cope with local and global symbols of the same name
1412 in the same object file, as might have been created
1413 by ld -r. The only reason locals are now seen at this
1414 level at all is so that we can do semi-sensible things
1417 struct obj_symbol *nsym, **p;
1419 nsym = arch_new_symbol();
1420 nsym->next = sym->next;
1423 /* Excise the old (local) symbol from the hash chain. */
1424 for (p = &f->symtab[hash]; *p != sym; p = &(*p)->next)
1428 } else if (n_binding == STB_LOCAL) {
1429 /* Another symbol of the same name has already been defined.
1430 Just add this to the local table. */
1431 sym = arch_new_symbol();
1434 f->local_symtab[symidx] = sym;
1436 } else if (n_binding == STB_WEAK)
1438 else if (o_binding == STB_WEAK)
1440 /* Don't unify COMMON symbols with object types the programmer
1442 else if (secidx == SHN_COMMON
1443 && (o_type == STT_NOTYPE || o_type == STT_OBJECT))
1445 else if (o_secidx == SHN_COMMON
1446 && (n_type == STT_NOTYPE || n_type == STT_OBJECT))
1449 /* Don't report an error if the symbol is coming from
1450 the kernel or some external module. */
1451 if (secidx <= SHN_HIRESERVE)
1452 error_msg("%s multiply defined", name);
1457 /* Completely new symbol. */
1458 sym = arch_new_symbol();
1459 sym->next = f->symtab[hash];
1460 f->symtab[hash] = sym;
1463 if (ELFW(ST_BIND) (info) == STB_LOCAL)
1464 f->local_symtab[symidx] = sym;
1470 sym->secidx = secidx;
1476 struct obj_symbol *obj_find_symbol(struct obj_file *f, const char *name)
1478 struct obj_symbol *sym;
1479 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
1481 for (sym = f->symtab[hash]; sym; sym = sym->next)
1482 if (f->symbol_cmp(sym->name, name) == 0)
1489 obj_symbol_final_value(struct obj_file * f, struct obj_symbol * sym)
1492 if (sym->secidx >= SHN_LORESERVE)
1495 return sym->value + f->sections[sym->secidx]->header.sh_addr;
1497 /* As a special case, a NULL sym has value zero. */
1502 struct obj_section *obj_find_section(struct obj_file *f, const char *name)
1504 int i, n = f->header.e_shnum;
1506 for (i = 0; i < n; ++i)
1507 if (strcmp(f->sections[i]->name, name) == 0)
1508 return f->sections[i];
1513 static int obj_load_order_prio(struct obj_section *a)
1515 unsigned long af, ac;
1517 af = a->header.sh_flags;
1520 if (a->name[0] != '.' || strlen(a->name) != 10 ||
1521 strcmp(a->name + 5, ".init"))
1525 if (!(af & SHF_WRITE))
1527 if (af & SHF_EXECINSTR)
1529 if (a->header.sh_type != SHT_NOBITS)
1536 obj_insert_section_load_order(struct obj_file *f, struct obj_section *sec)
1538 struct obj_section **p;
1539 int prio = obj_load_order_prio(sec);
1540 for (p = f->load_order_search_start; *p; p = &(*p)->load_next)
1541 if (obj_load_order_prio(*p) < prio)
1543 sec->load_next = *p;
1547 struct obj_section *obj_create_alloced_section(struct obj_file *f,
1549 unsigned long align,
1552 int newidx = f->header.e_shnum++;
1553 struct obj_section *sec;
1555 f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
1556 f->sections[newidx] = sec = arch_new_section();
1558 memset(sec, 0, sizeof(*sec));
1559 sec->header.sh_type = SHT_PROGBITS;
1560 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
1561 sec->header.sh_size = size;
1562 sec->header.sh_addralign = align;
1566 sec->contents = xmalloc(size);
1568 obj_insert_section_load_order(f, sec);
1573 struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
1575 unsigned long align,
1578 int newidx = f->header.e_shnum++;
1579 struct obj_section *sec;
1581 f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
1582 f->sections[newidx] = sec = arch_new_section();
1584 memset(sec, 0, sizeof(*sec));
1585 sec->header.sh_type = SHT_PROGBITS;
1586 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
1587 sec->header.sh_size = size;
1588 sec->header.sh_addralign = align;
1592 sec->contents = xmalloc(size);
1594 sec->load_next = f->load_order;
1595 f->load_order = sec;
1596 if (f->load_order_search_start == &f->load_order)
1597 f->load_order_search_start = &sec->load_next;
1602 void *obj_extend_section(struct obj_section *sec, unsigned long more)
1604 unsigned long oldsize = sec->header.sh_size;
1606 sec->contents = xrealloc(sec->contents, sec->header.sh_size += more);
1608 return sec->contents + oldsize;
1613 /* Conditionally add the symbols from the given symbol set to the
1619 int idx, struct new_module_symbol *syms, size_t nsyms)
1621 struct new_module_symbol *s;
1625 for (i = 0, s = syms; i < nsyms; ++i, ++s) {
1627 /* Only add symbols that are already marked external. If we
1628 override locals we may cause problems for argument initialization.
1629 We will also create a false dependency on the module. */
1630 struct obj_symbol *sym;
1632 sym = obj_find_symbol(f, (char *) s->name);
1633 if (sym && !ELFW(ST_BIND) (sym->info) == STB_LOCAL) {
1634 sym = obj_add_symbol(f, (char *) s->name, -1,
1635 ELFW(ST_INFO) (STB_GLOBAL, STT_NOTYPE),
1637 /* Did our symbol just get installed? If so, mark the
1638 module as "used". */
1639 if (sym->secidx == idx)
1647 static void add_kernel_symbols(struct obj_file *f)
1649 struct external_module *m;
1652 /* Add module symbols first. */
1654 for (i = 0, m = ext_modules; i < n_ext_modules; ++i, ++m)
1656 && add_symbols_from(f, SHN_HIRESERVE + 2 + i, m->syms,
1657 m->nsyms)) m->used = 1, ++nused;
1659 n_ext_modules_used = nused;
1661 /* And finally the symbols from the kernel proper. */
1664 add_symbols_from(f, SHN_HIRESERVE + 1, ksyms, nksyms);
1667 static char *get_modinfo_value(struct obj_file *f, const char *key)
1669 struct obj_section *sec;
1670 char *p, *v, *n, *ep;
1671 size_t klen = strlen(key);
1673 sec = obj_find_section(f, ".modinfo");
1677 ep = p + sec->header.sh_size;
1680 n = strchr(p, '\0');
1682 if (p + klen == v && strncmp(p, key, klen) == 0)
1685 if (p + klen == n && strcmp(p, key) == 0)
1695 /*======================================================================*/
1696 /* Functions relating to module loading in pre 2.1 kernels. */
1699 old_process_module_arguments(struct obj_file *f, int argc, char **argv)
1703 struct obj_symbol *sym;
1707 if ((q = strchr(p, '=')) == NULL) {
1713 sym = obj_find_symbol(f, p);
1715 /* Also check that the parameter was not resolved from the kernel. */
1716 if (sym == NULL || sym->secidx > SHN_HIRESERVE) {
1717 error_msg("symbol for parameter %s not found", p);
1721 loc = (int *) (f->sections[sym->secidx]->contents + sym->value);
1723 /* Do C quoting if we begin with a ". */
1727 str = alloca(strlen(q));
1728 for (r = str, q++; *q != '"'; ++q, ++r) {
1730 error_msg("improperly terminated string argument for %s", p);
1732 } else if (*q == '\\')
1766 if (q[1] >= '0' && q[1] <= '7') {
1767 c = (c * 8) + *++q - '0';
1768 if (q[1] >= '0' && q[1] <= '7')
1769 c = (c * 8) + *++q - '0';
1782 obj_string_patch(f, sym->secidx, sym->value, str);
1783 } else if (*q >= '0' && *q <= '9') {
1785 *loc++ = strtoul(q, &q, 0);
1786 while (*q++ == ',');
1788 char *contents = f->sections[sym->secidx]->contents;
1789 char *myloc = contents + sym->value;
1790 char *r; /* To search for commas */
1792 /* Break the string with comas */
1793 while ((r = strchr(q, ',')) != (char *) NULL) {
1795 obj_string_patch(f, sym->secidx, myloc - contents, q);
1796 myloc += sizeof(char *);
1801 obj_string_patch(f, sym->secidx, myloc - contents, q);
1810 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
1811 static int old_is_module_checksummed(struct obj_file *f)
1813 return obj_find_symbol(f, "Using_Versions") != NULL;
1815 /* Get the module's kernel version in the canonical integer form. */
1818 old_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
1820 struct obj_symbol *sym;
1824 sym = obj_find_symbol(f, "kernel_version");
1828 p = f->sections[sym->secidx]->contents + sym->value;
1829 strncpy(str, p, STRVERSIONLEN);
1831 a = strtoul(p, &p, 10);
1834 b = strtoul(p + 1, &p, 10);
1837 c = strtoul(p + 1, &q, 10);
1841 return a << 16 | b << 8 | c;
1844 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
1846 #ifdef BB_FEATURE_OLD_MODULE_INTERFACE
1848 /* Fetch all the symbols and divvy them up as appropriate for the modules. */
1850 static int old_get_kernel_symbols(const char *m_name)
1852 struct old_kernel_sym *ks, *k;
1853 struct new_module_symbol *s;
1854 struct external_module *mod;
1855 int nks, nms, nmod, i;
1857 nks = get_kernel_syms(NULL);
1860 perror_msg("get_kernel_syms: %s", m_name);
1862 error_msg("No kernel symbols");
1866 ks = k = xmalloc(nks * sizeof(*ks));
1868 if (get_kernel_syms(ks) != nks) {
1869 perror("inconsistency with get_kernel_syms -- is someone else "
1870 "playing with modules?");
1875 /* Collect the module information. */
1880 while (k->name[0] == '#' && k->name[1]) {
1881 struct old_kernel_sym *k2;
1883 /* Find out how many symbols this module has. */
1884 for (k2 = k + 1; k2->name[0] != '#'; ++k2)
1888 mod = xrealloc(mod, (++nmod + 1) * sizeof(*mod));
1889 mod[nmod].name = k->name + 1;
1890 mod[nmod].addr = k->value;
1892 mod[nmod].nsyms = nms;
1893 mod[nmod].syms = s = (nms ? xmalloc(nms * sizeof(*s)) : NULL);
1895 for (i = 0, ++k; i < nms; ++i, ++s, ++k) {
1896 s->name = (unsigned long) k->name;
1897 s->value = k->value;
1904 n_ext_modules = nmod + 1;
1906 /* Now collect the symbols for the kernel proper. */
1908 if (k->name[0] == '#')
1911 nksyms = nms = nks - (k - ks);
1912 ksyms = s = (nms ? xmalloc(nms * sizeof(*s)) : NULL);
1914 for (i = 0; i < nms; ++i, ++s, ++k) {
1915 s->name = (unsigned long) k->name;
1916 s->value = k->value;
1922 /* Return the kernel symbol checksum version, or zero if not used. */
1924 static int old_is_kernel_checksummed(void)
1926 /* Using_Versions is the first symbol. */
1928 && strcmp((char *) ksyms[0].name,
1929 "Using_Versions") == 0) return ksyms[0].value;
1935 static int old_create_mod_use_count(struct obj_file *f)
1937 struct obj_section *sec;
1939 sec = obj_create_alloced_section_first(f, ".moduse", sizeof(long),
1942 obj_add_symbol(f, "mod_use_count_", -1,
1943 ELFW(ST_INFO) (STB_LOCAL, STT_OBJECT), sec->idx, 0,
1950 old_init_module(const char *m_name, struct obj_file *f,
1951 unsigned long m_size)
1954 struct old_mod_routines routines;
1955 struct old_symbol_table *symtab;
1958 /* Create the symbol table */
1960 int nsyms = 0, strsize = 0, total;
1962 /* Size things first... */
1965 for (i = 0; i < HASH_BUCKETS; ++i) {
1966 struct obj_symbol *sym;
1967 for (sym = f->symtab[i]; sym; sym = sym->next)
1968 if (ELFW(ST_BIND) (sym->info) != STB_LOCAL
1969 && sym->secidx <= SHN_HIRESERVE)
1971 sym->ksymidx = nsyms++;
1972 strsize += strlen(sym->name) + 1;
1977 total = (sizeof(struct old_symbol_table)
1978 + nsyms * sizeof(struct old_module_symbol)
1979 + n_ext_modules_used * sizeof(struct old_module_ref)
1981 symtab = xmalloc(total);
1982 symtab->size = total;
1983 symtab->n_symbols = nsyms;
1984 symtab->n_refs = n_ext_modules_used;
1986 if (flag_export && nsyms) {
1987 struct old_module_symbol *ksym;
1991 ksym = symtab->symbol;
1992 str = ((char *) ksym + nsyms * sizeof(struct old_module_symbol)
1993 + n_ext_modules_used * sizeof(struct old_module_ref));
1995 for (i = 0; i < HASH_BUCKETS; ++i) {
1996 struct obj_symbol *sym;
1997 for (sym = f->symtab[i]; sym; sym = sym->next)
1998 if (sym->ksymidx >= 0) {
1999 ksym->addr = obj_symbol_final_value(f, sym);
2001 (unsigned long) str - (unsigned long) symtab;
2003 strcpy(str, sym->name);
2004 str += strlen(sym->name) + 1;
2010 if (n_ext_modules_used) {
2011 struct old_module_ref *ref;
2014 ref = (struct old_module_ref *)
2015 ((char *) symtab->symbol + nsyms * sizeof(struct old_module_symbol));
2017 for (i = 0; i < n_ext_modules; ++i)
2018 if (ext_modules[i].used)
2019 ref++->module = ext_modules[i].addr;
2023 /* Fill in routines. */
2026 obj_symbol_final_value(f, obj_find_symbol(f, "init_module"));
2028 obj_symbol_final_value(f, obj_find_symbol(f, "cleanup_module"));
2030 /* Whew! All of the initialization is complete. Collect the final
2031 module image and give it to the kernel. */
2033 image = xmalloc(m_size);
2034 obj_create_image(f, image);
2036 /* image holds the complete relocated module, accounting correctly for
2037 mod_use_count. However the old module kernel support assume that
2038 it is receiving something which does not contain mod_use_count. */
2039 ret = old_sys_init_module(m_name, image + sizeof(long),
2040 m_size | (flag_autoclean ? OLD_MOD_AUTOCLEAN
2041 : 0), &routines, symtab);
2043 perror_msg("init_module: %s", m_name);
2053 #define old_create_mod_use_count(x) TRUE
2054 #define old_init_module(x, y, z) TRUE
2056 #endif /* BB_FEATURE_OLD_MODULE_INTERFACE */
2060 /*======================================================================*/
2061 /* Functions relating to module loading after 2.1.18. */
2064 new_process_module_arguments(struct obj_file *f, int argc, char **argv)
2068 struct obj_symbol *sym;
2069 char *contents, *loc;
2073 if ((q = strchr(p, '=')) == NULL) {
2078 key = alloca(q - p + 6);
2079 memcpy(key, "parm_", 5);
2080 memcpy(key + 5, p, q - p);
2083 p = get_modinfo_value(f, key);
2086 error_msg("invalid parameter %s", key);
2090 sym = obj_find_symbol(f, key);
2092 /* Also check that the parameter was not resolved from the kernel. */
2093 if (sym == NULL || sym->secidx > SHN_HIRESERVE) {
2094 error_msg("symbol for parameter %s not found", key);
2099 min = strtoul(p, &p, 10);
2101 max = strtoul(p + 1, &p, 10);
2107 contents = f->sections[sym->secidx]->contents;
2108 loc = contents + sym->value;
2112 if ((*p == 's') || (*p == 'c')) {
2115 /* Do C quoting if we begin with a ", else slurp the lot. */
2119 str = alloca(strlen(q));
2120 for (r = str, q++; *q != '"'; ++q, ++r) {
2122 error_msg("improperly terminated string argument for %s",
2125 } else if (*q == '\\')
2159 if (q[1] >= '0' && q[1] <= '7') {
2160 c = (c * 8) + *++q - '0';
2161 if (q[1] >= '0' && q[1] <= '7')
2162 c = (c * 8) + *++q - '0';
2179 /* In this case, the string is not quoted. We will break
2180 it using the coma (like for ints). If the user wants to
2181 include comas in a string, he just has to quote it */
2183 /* Search the next coma */
2187 if (r != (char *) NULL) {
2188 /* Recopy the current field */
2189 str = alloca(r - q + 1);
2190 memcpy(str, q, r - q);
2192 /* I don't know if it is usefull, as the previous case
2193 doesn't null terminate the string ??? */
2196 /* Keep next fields */
2207 obj_string_patch(f, sym->secidx, loc - contents, str);
2208 loc += tgt_sizeof_char_p;
2210 /* Array of chars (in fact, matrix !) */
2211 unsigned long charssize; /* size of each member */
2213 /* Get the size of each member */
2214 /* Probably we should do that outside the loop ? */
2215 if (!isdigit(*(p + 1))) {
2216 error_msg("parameter type 'c' for %s must be followed by"
2217 " the maximum size", key);
2220 charssize = strtoul(p + 1, (char **) NULL, 10);
2223 if (strlen(str) >= charssize) {
2224 error_msg("string too long for %s (max %ld)", key,
2229 /* Copy to location */
2230 strcpy((char *) loc, str);
2234 long v = strtoul(q, &q, 0);
2241 loc += tgt_sizeof_short;
2245 loc += tgt_sizeof_int;
2249 loc += tgt_sizeof_long;
2253 error_msg("unknown parameter type '%c' for %s", *p, key);
2268 goto retry_end_of_value;
2272 error_msg("too many values for %s (max %d)", key, max);
2279 error_msg("invalid argument syntax for %s", key);
2286 error_msg("too few values for %s (min %d)", key, min);
2296 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
2297 static int new_is_module_checksummed(struct obj_file *f)
2299 const char *p = get_modinfo_value(f, "using_checksums");
2306 /* Get the module's kernel version in the canonical integer form. */
2309 new_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
2314 p = get_modinfo_value(f, "kernel_version");
2317 strncpy(str, p, STRVERSIONLEN);
2319 a = strtoul(p, &p, 10);
2322 b = strtoul(p + 1, &p, 10);
2325 c = strtoul(p + 1, &q, 10);
2329 return a << 16 | b << 8 | c;
2332 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
2335 #ifdef BB_FEATURE_NEW_MODULE_INTERFACE
2337 /* Fetch the loaded modules, and all currently exported symbols. */
2339 static int new_get_kernel_symbols(void)
2341 char *module_names, *mn;
2342 struct external_module *modules, *m;
2343 struct new_module_symbol *syms, *s;
2344 size_t ret, bufsize, nmod, nsyms, i, j;
2346 /* Collect the loaded modules. */
2348 module_names = xmalloc(bufsize = 256);
2350 if (query_module(NULL, QM_MODULES, module_names, bufsize, &ret)) {
2351 if (errno == ENOSPC && bufsize < ret) {
2352 module_names = xrealloc(module_names, bufsize = ret);
2353 goto retry_modules_load;
2355 perror_msg("QM_MODULES");
2359 n_ext_modules = nmod = ret;
2361 /* Collect the modules' symbols. */
2364 ext_modules = modules = xmalloc(nmod * sizeof(*modules));
2365 memset(modules, 0, nmod * sizeof(*modules));
2366 for (i = 0, mn = module_names, m = modules;
2367 i < nmod; ++i, ++m, mn += strlen(mn) + 1) {
2368 struct new_module_info info;
2370 if (query_module(mn, QM_INFO, &info, sizeof(info), &ret)) {
2371 if (errno == ENOENT) {
2372 /* The module was removed out from underneath us. */
2375 perror_msg("query_module: QM_INFO: %s", mn);
2379 syms = xmalloc(bufsize = 1024);
2381 if (query_module(mn, QM_SYMBOLS, syms, bufsize, &ret)) {
2384 syms = xrealloc(syms, bufsize = ret);
2385 goto retry_mod_sym_load;
2387 /* The module was removed out from underneath us. */
2390 perror_msg("query_module: QM_SYMBOLS: %s", mn);
2397 m->addr = info.addr;
2401 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2402 s->name += (unsigned long) syms;
2407 /* Collect the kernel's symbols. */
2409 syms = xmalloc(bufsize = 16 * 1024);
2410 retry_kern_sym_load:
2411 if (query_module(NULL, QM_SYMBOLS, syms, bufsize, &ret)) {
2412 if (errno == ENOSPC && bufsize < ret) {
2413 syms = xrealloc(syms, bufsize = ret);
2414 goto retry_kern_sym_load;
2416 perror_msg("kernel: QM_SYMBOLS");
2419 nksyms = nsyms = ret;
2422 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2423 s->name += (unsigned long) syms;
2429 /* Return the kernel symbol checksum version, or zero if not used. */
2431 static int new_is_kernel_checksummed(void)
2433 struct new_module_symbol *s;
2436 /* Using_Versions is not the first symbol, but it should be in there. */
2438 for (i = 0, s = ksyms; i < nksyms; ++i, ++s)
2439 if (strcmp((char *) s->name, "Using_Versions") == 0)
2446 static int new_create_this_module(struct obj_file *f, const char *m_name)
2448 struct obj_section *sec;
2450 sec = obj_create_alloced_section_first(f, ".this", tgt_sizeof_long,
2451 sizeof(struct new_module));
2452 memset(sec->contents, 0, sizeof(struct new_module));
2454 obj_add_symbol(f, "__this_module", -1,
2455 ELFW(ST_INFO) (STB_LOCAL, STT_OBJECT), sec->idx, 0,
2456 sizeof(struct new_module));
2458 obj_string_patch(f, sec->idx, offsetof(struct new_module, name),
2465 static int new_create_module_ksymtab(struct obj_file *f)
2467 struct obj_section *sec;
2470 /* We must always add the module references. */
2472 if (n_ext_modules_used) {
2473 struct new_module_ref *dep;
2474 struct obj_symbol *tm;
2476 sec = obj_create_alloced_section(f, ".kmodtab", tgt_sizeof_void_p,
2477 (sizeof(struct new_module_ref)
2478 * n_ext_modules_used));
2482 tm = obj_find_symbol(f, "__this_module");
2483 dep = (struct new_module_ref *) sec->contents;
2484 for (i = 0; i < n_ext_modules; ++i)
2485 if (ext_modules[i].used) {
2486 dep->dep = ext_modules[i].addr;
2487 obj_symbol_patch(f, sec->idx,
2488 (char *) &dep->ref - sec->contents, tm);
2494 if (flag_export && !obj_find_section(f, "__ksymtab")) {
2499 obj_create_alloced_section(f, "__ksymtab", tgt_sizeof_void_p,
2502 /* We don't want to export symbols residing in sections that
2503 aren't loaded. There are a number of these created so that
2504 we make sure certain module options don't appear twice. */
2506 loaded = alloca(sizeof(int) * (i = f->header.e_shnum));
2508 loaded[i] = (f->sections[i]->header.sh_flags & SHF_ALLOC) != 0;
2510 for (nsyms = i = 0; i < HASH_BUCKETS; ++i) {
2511 struct obj_symbol *sym;
2512 for (sym = f->symtab[i]; sym; sym = sym->next)
2513 if (ELFW(ST_BIND) (sym->info) != STB_LOCAL
2514 && sym->secidx <= SHN_HIRESERVE
2515 && (sym->secidx >= SHN_LORESERVE
2516 || loaded[sym->secidx])) {
2517 ElfW(Addr) ofs = nsyms * 2 * tgt_sizeof_void_p;
2519 obj_symbol_patch(f, sec->idx, ofs, sym);
2520 obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p,
2527 obj_extend_section(sec, nsyms * 2 * tgt_sizeof_char_p);
2535 new_init_module(const char *m_name, struct obj_file *f,
2536 unsigned long m_size)
2538 struct new_module *module;
2539 struct obj_section *sec;
2544 sec = obj_find_section(f, ".this");
2545 if (!sec || !sec->contents) {
2546 perror_msg_and_die("corrupt module %s?",m_name);
2548 module = (struct new_module *) sec->contents;
2549 m_addr = sec->header.sh_addr;
2551 module->size_of_struct = sizeof(*module);
2552 module->size = m_size;
2553 module->flags = flag_autoclean ? NEW_MOD_AUTOCLEAN : 0;
2555 sec = obj_find_section(f, "__ksymtab");
2556 if (sec && sec->header.sh_size) {
2557 module->syms = sec->header.sh_addr;
2558 module->nsyms = sec->header.sh_size / (2 * tgt_sizeof_char_p);
2561 if (n_ext_modules_used) {
2562 sec = obj_find_section(f, ".kmodtab");
2563 module->deps = sec->header.sh_addr;
2564 module->ndeps = n_ext_modules_used;
2568 obj_symbol_final_value(f, obj_find_symbol(f, "init_module"));
2570 obj_symbol_final_value(f, obj_find_symbol(f, "cleanup_module"));
2572 sec = obj_find_section(f, "__ex_table");
2574 module->ex_table_start = sec->header.sh_addr;
2575 module->ex_table_end = sec->header.sh_addr + sec->header.sh_size;
2578 sec = obj_find_section(f, ".text.init");
2580 module->runsize = sec->header.sh_addr - m_addr;
2582 sec = obj_find_section(f, ".data.init");
2584 if (!module->runsize ||
2585 module->runsize > sec->header.sh_addr - m_addr)
2586 module->runsize = sec->header.sh_addr - m_addr;
2588 sec = obj_find_section(f, ARCHDATA_SEC_NAME);
2589 if (sec && sec->header.sh_size) {
2590 module->archdata_start = (void*)sec->header.sh_addr;
2591 module->archdata_end = module->archdata_start + sec->header.sh_size;
2593 sec = obj_find_section(f, KALLSYMS_SEC_NAME);
2594 if (sec && sec->header.sh_size) {
2595 module->kallsyms_start = (void*)sec->header.sh_addr;
2596 module->kallsyms_end = module->kallsyms_start + sec->header.sh_size;
2599 if (!arch_init_module(f, module))
2602 /* Whew! All of the initialization is complete. Collect the final
2603 module image and give it to the kernel. */
2605 image = xmalloc(m_size);
2606 obj_create_image(f, image);
2608 ret = new_sys_init_module(m_name, (struct new_module *) image);
2610 perror_msg("init_module: %s", m_name);
2619 #define new_init_module(x, y, z) TRUE
2620 #define new_create_this_module(x, y) 0
2621 #define new_create_module_ksymtab(x)
2622 #define query_module(v, w, x, y, z) -1
2624 #endif /* BB_FEATURE_NEW_MODULE_INTERFACE */
2627 /*======================================================================*/
2630 obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2633 struct obj_string_patch *p;
2634 struct obj_section *strsec;
2635 size_t len = strlen(string) + 1;
2638 p = xmalloc(sizeof(*p));
2639 p->next = f->string_patches;
2640 p->reloc_secidx = secidx;
2641 p->reloc_offset = offset;
2642 f->string_patches = p;
2644 strsec = obj_find_section(f, ".kstrtab");
2645 if (strsec == NULL) {
2646 strsec = obj_create_alloced_section(f, ".kstrtab", 1, len);
2647 p->string_offset = 0;
2648 loc = strsec->contents;
2650 p->string_offset = strsec->header.sh_size;
2651 loc = obj_extend_section(strsec, len);
2653 memcpy(loc, string, len);
2659 obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2660 struct obj_symbol *sym)
2662 struct obj_symbol_patch *p;
2664 p = xmalloc(sizeof(*p));
2665 p->next = f->symbol_patches;
2666 p->reloc_secidx = secidx;
2667 p->reloc_offset = offset;
2669 f->symbol_patches = p;
2674 int obj_check_undefineds(struct obj_file *f)
2679 for (i = 0; i < HASH_BUCKETS; ++i) {
2680 struct obj_symbol *sym;
2681 for (sym = f->symtab[i]; sym; sym = sym->next)
2682 if (sym->secidx == SHN_UNDEF) {
2683 if (ELFW(ST_BIND) (sym->info) == STB_WEAK) {
2684 sym->secidx = SHN_ABS;
2687 error_msg("unresolved symbol %s", sym->name);
2696 void obj_allocate_commons(struct obj_file *f)
2698 struct common_entry {
2699 struct common_entry *next;
2700 struct obj_symbol *sym;
2701 } *common_head = NULL;
2705 for (i = 0; i < HASH_BUCKETS; ++i) {
2706 struct obj_symbol *sym;
2707 for (sym = f->symtab[i]; sym; sym = sym->next)
2708 if (sym->secidx == SHN_COMMON) {
2709 /* Collect all COMMON symbols and sort them by size so as to
2710 minimize space wasted by alignment requirements. */
2712 struct common_entry **p, *n;
2713 for (p = &common_head; *p; p = &(*p)->next)
2714 if (sym->size <= (*p)->sym->size)
2717 n = alloca(sizeof(*n));
2725 for (i = 1; i < f->local_symtab_size; ++i) {
2726 struct obj_symbol *sym = f->local_symtab[i];
2727 if (sym && sym->secidx == SHN_COMMON) {
2728 struct common_entry **p, *n;
2729 for (p = &common_head; *p; p = &(*p)->next)
2730 if (sym == (*p)->sym)
2732 else if (sym->size < (*p)->sym->size) {
2733 n = alloca(sizeof(*n));
2743 /* Find the bss section. */
2744 for (i = 0; i < f->header.e_shnum; ++i)
2745 if (f->sections[i]->header.sh_type == SHT_NOBITS)
2748 /* If for some reason there hadn't been one, create one. */
2749 if (i == f->header.e_shnum) {
2750 struct obj_section *sec;
2752 f->sections = xrealloc(f->sections, (i + 1) * sizeof(sec));
2753 f->sections[i] = sec = arch_new_section();
2754 f->header.e_shnum = i + 1;
2756 memset(sec, 0, sizeof(*sec));
2757 sec->header.sh_type = SHT_PROGBITS;
2758 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2763 /* Allocate the COMMONS. */
2765 ElfW(Addr) bss_size = f->sections[i]->header.sh_size;
2766 ElfW(Addr) max_align = f->sections[i]->header.sh_addralign;
2767 struct common_entry *c;
2769 for (c = common_head; c; c = c->next) {
2770 ElfW(Addr) align = c->sym->value;
2772 if (align > max_align)
2774 if (bss_size & (align - 1))
2775 bss_size = (bss_size | (align - 1)) + 1;
2778 c->sym->value = bss_size;
2780 bss_size += c->sym->size;
2783 f->sections[i]->header.sh_size = bss_size;
2784 f->sections[i]->header.sh_addralign = max_align;
2788 /* For the sake of patch relocation and parameter initialization,
2789 allocate zeroed data for NOBITS sections now. Note that after
2790 this we cannot assume NOBITS are really empty. */
2791 for (i = 0; i < f->header.e_shnum; ++i) {
2792 struct obj_section *s = f->sections[i];
2793 if (s->header.sh_type == SHT_NOBITS) {
2794 if (s->header.sh_size != 0)
2795 s->contents = memset(xmalloc(s->header.sh_size),
2796 0, s->header.sh_size);
2800 s->header.sh_type = SHT_PROGBITS;
2805 unsigned long obj_load_size(struct obj_file *f)
2807 unsigned long dot = 0;
2808 struct obj_section *sec;
2810 /* Finalize the positions of the sections relative to one another. */
2812 for (sec = f->load_order; sec; sec = sec->load_next) {
2815 align = sec->header.sh_addralign;
2816 if (align && (dot & (align - 1)))
2817 dot = (dot | (align - 1)) + 1;
2819 sec->header.sh_addr = dot;
2820 dot += sec->header.sh_size;
2826 int obj_relocate(struct obj_file *f, ElfW(Addr) base)
2828 int i, n = f->header.e_shnum;
2831 /* Finalize the addresses of the sections. */
2834 for (i = 0; i < n; ++i)
2835 f->sections[i]->header.sh_addr += base;
2837 /* And iterate over all of the relocations. */
2839 for (i = 0; i < n; ++i) {
2840 struct obj_section *relsec, *symsec, *targsec, *strsec;
2841 ElfW(RelM) * rel, *relend;
2845 relsec = f->sections[i];
2846 if (relsec->header.sh_type != SHT_RELM)
2849 symsec = f->sections[relsec->header.sh_link];
2850 targsec = f->sections[relsec->header.sh_info];
2851 strsec = f->sections[symsec->header.sh_link];
2853 rel = (ElfW(RelM) *) relsec->contents;
2854 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
2855 symtab = (ElfW(Sym) *) symsec->contents;
2856 strtab = (const char *) strsec->contents;
2858 for (; rel < relend; ++rel) {
2859 ElfW(Addr) value = 0;
2860 struct obj_symbol *intsym = NULL;
2861 unsigned long symndx;
2862 ElfW(Sym) * extsym = 0;
2865 /* Attempt to find a value to use for this relocation. */
2867 symndx = ELFW(R_SYM) (rel->r_info);
2869 /* Note we've already checked for undefined symbols. */
2871 extsym = &symtab[symndx];
2872 if (ELFW(ST_BIND) (extsym->st_info) == STB_LOCAL) {
2873 /* Local symbols we look up in the local table to be sure
2874 we get the one that is really intended. */
2875 intsym = f->local_symtab[symndx];
2877 /* Others we look up in the hash table. */
2879 if (extsym->st_name)
2880 name = strtab + extsym->st_name;
2882 name = f->sections[extsym->st_shndx]->name;
2883 intsym = obj_find_symbol(f, name);
2886 value = obj_symbol_final_value(f, intsym);
2887 intsym->referenced = 1;
2889 #if SHT_RELM == SHT_RELA
2890 #if defined(__alpha__) && defined(AXP_BROKEN_GAS)
2891 /* Work around a nasty GAS bug, that is fixed as of 2.7.0.9. */
2892 if (!extsym || !extsym->st_name ||
2893 ELFW(ST_BIND) (extsym->st_info) != STB_LOCAL)
2895 value += rel->r_addend;
2899 switch (arch_apply_relocation
2900 (f, targsec, symsec, intsym, rel, value)) {
2904 case obj_reloc_overflow:
2905 errmsg = "Relocation overflow";
2907 case obj_reloc_dangerous:
2908 errmsg = "Dangerous relocation";
2910 case obj_reloc_unhandled:
2911 errmsg = "Unhandled relocation";
2914 error_msg("%s of type %ld for %s", errmsg,
2915 (long) ELFW(R_TYPE) (rel->r_info),
2916 strtab + extsym->st_name);
2918 error_msg("%s of type %ld", errmsg,
2919 (long) ELFW(R_TYPE) (rel->r_info));
2927 /* Finally, take care of the patches. */
2929 if (f->string_patches) {
2930 struct obj_string_patch *p;
2931 struct obj_section *strsec;
2932 ElfW(Addr) strsec_base;
2933 strsec = obj_find_section(f, ".kstrtab");
2934 strsec_base = strsec->header.sh_addr;
2936 for (p = f->string_patches; p; p = p->next) {
2937 struct obj_section *targsec = f->sections[p->reloc_secidx];
2938 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
2939 = strsec_base + p->string_offset;
2943 if (f->symbol_patches) {
2944 struct obj_symbol_patch *p;
2946 for (p = f->symbol_patches; p; p = p->next) {
2947 struct obj_section *targsec = f->sections[p->reloc_secidx];
2948 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
2949 = obj_symbol_final_value(f, p->sym);
2956 int obj_create_image(struct obj_file *f, char *image)
2958 struct obj_section *sec;
2959 ElfW(Addr) base = f->baseaddr;
2961 for (sec = f->load_order; sec; sec = sec->load_next) {
2964 if (sec->contents == 0 || sec->header.sh_size == 0)
2967 secimg = image + (sec->header.sh_addr - base);
2969 /* Note that we allocated data for NOBITS sections earlier. */
2970 memcpy(secimg, sec->contents, sec->header.sh_size);
2976 /*======================================================================*/
2978 struct obj_file *obj_load(FILE * fp, int loadprogbits)
2981 ElfW(Shdr) * section_headers;
2985 /* Read the file header. */
2987 f = arch_new_file();
2988 memset(f, 0, sizeof(*f));
2989 f->symbol_cmp = strcmp;
2990 f->symbol_hash = obj_elf_hash;
2991 f->load_order_search_start = &f->load_order;
2993 fseek(fp, 0, SEEK_SET);
2994 if (fread(&f->header, sizeof(f->header), 1, fp) != 1) {
2995 perror_msg("error reading ELF header");
2999 if (f->header.e_ident[EI_MAG0] != ELFMAG0
3000 || f->header.e_ident[EI_MAG1] != ELFMAG1
3001 || f->header.e_ident[EI_MAG2] != ELFMAG2
3002 || f->header.e_ident[EI_MAG3] != ELFMAG3) {
3003 error_msg("not an ELF file");
3006 if (f->header.e_ident[EI_CLASS] != ELFCLASSM
3007 || f->header.e_ident[EI_DATA] != ELFDATAM
3008 || f->header.e_ident[EI_VERSION] != EV_CURRENT
3009 || !MATCH_MACHINE(f->header.e_machine)) {
3010 error_msg("ELF file not for this architecture");
3013 if (f->header.e_type != ET_REL) {
3014 error_msg("ELF file not a relocatable object");
3018 /* Read the section headers. */
3020 if (f->header.e_shentsize != sizeof(ElfW(Shdr))) {
3021 error_msg("section header size mismatch: %lu != %lu",
3022 (unsigned long) f->header.e_shentsize,
3023 (unsigned long) sizeof(ElfW(Shdr)));
3027 shnum = f->header.e_shnum;
3028 f->sections = xmalloc(sizeof(struct obj_section *) * shnum);
3029 memset(f->sections, 0, sizeof(struct obj_section *) * shnum);
3031 section_headers = alloca(sizeof(ElfW(Shdr)) * shnum);
3032 fseek(fp, f->header.e_shoff, SEEK_SET);
3033 if (fread(section_headers, sizeof(ElfW(Shdr)), shnum, fp) != shnum) {
3034 perror_msg("error reading ELF section headers");
3038 /* Read the section data. */
3040 for (i = 0; i < shnum; ++i) {
3041 struct obj_section *sec;
3043 f->sections[i] = sec = arch_new_section();
3044 memset(sec, 0, sizeof(*sec));
3046 sec->header = section_headers[i];
3049 if(sec->header.sh_size) switch (sec->header.sh_type) {
3058 if (!loadprogbits) {
3059 sec->contents = NULL;
3066 if (sec->header.sh_size > 0) {
3067 sec->contents = xmalloc(sec->header.sh_size);
3068 fseek(fp, sec->header.sh_offset, SEEK_SET);
3069 if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
3070 perror_msg("error reading ELF section data");
3074 sec->contents = NULL;
3078 #if SHT_RELM == SHT_REL
3080 error_msg("RELA relocations not supported on this architecture");
3084 error_msg("REL relocations not supported on this architecture");
3089 if (sec->header.sh_type >= SHT_LOPROC) {
3090 /* Assume processor specific section types are debug
3091 info and can safely be ignored. If this is ever not
3092 the case (Hello MIPS?), don't put ifdefs here but
3093 create an arch_load_proc_section(). */
3097 error_msg("can't handle sections of type %ld",
3098 (long) sec->header.sh_type);
3103 /* Do what sort of interpretation as needed by each section. */
3105 shstrtab = f->sections[f->header.e_shstrndx]->contents;
3107 for (i = 0; i < shnum; ++i) {
3108 struct obj_section *sec = f->sections[i];
3109 sec->name = shstrtab + sec->header.sh_name;
3112 for (i = 0; i < shnum; ++i) {
3113 struct obj_section *sec = f->sections[i];
3115 /* .modinfo should be contents only but gcc has no attribute for that.
3116 * The kernel may have marked .modinfo as ALLOC, ignore this bit.
3118 if (strcmp(sec->name, ".modinfo") == 0)
3119 sec->header.sh_flags &= ~SHF_ALLOC;
3121 if (sec->header.sh_flags & SHF_ALLOC)
3122 obj_insert_section_load_order(f, sec);
3124 switch (sec->header.sh_type) {
3127 unsigned long nsym, j;
3131 if (sec->header.sh_entsize != sizeof(ElfW(Sym))) {
3132 error_msg("symbol size mismatch: %lu != %lu",
3133 (unsigned long) sec->header.sh_entsize,
3134 (unsigned long) sizeof(ElfW(Sym)));
3138 nsym = sec->header.sh_size / sizeof(ElfW(Sym));
3139 strtab = f->sections[sec->header.sh_link]->contents;
3140 sym = (ElfW(Sym) *) sec->contents;
3142 /* Allocate space for a table of local symbols. */
3143 j = f->local_symtab_size = sec->header.sh_info;
3144 f->local_symtab = xcalloc(j, sizeof(struct obj_symbol *));
3146 /* Insert all symbols into the hash table. */
3147 for (j = 1, ++sym; j < nsym; ++j, ++sym) {
3150 name = strtab + sym->st_name;
3152 name = f->sections[sym->st_shndx]->name;
3154 obj_add_symbol(f, name, j, sym->st_info, sym->st_shndx,
3155 sym->st_value, sym->st_size);
3161 if (sec->header.sh_entsize != sizeof(ElfW(RelM))) {
3162 error_msg("relocation entry size mismatch: %lu != %lu",
3163 (unsigned long) sec->header.sh_entsize,
3164 (unsigned long) sizeof(ElfW(RelM)));
3168 /* XXX Relocation code from modutils-2.3.19 is not here.
3169 * Why? That's about 20 lines of code from obj/obj_load.c,
3170 * which gets done in a second pass through the sections.
3171 * This BusyBox insmod does similar work in obj_relocate(). */
3178 #ifdef BB_FEATURE_INSMOD_LOADINKMEM
3180 * load the unloaded sections directly into the memory allocated by
3181 * kernel for the module
3184 int obj_load_progbits(FILE * fp, struct obj_file* f)
3186 char* imagebase = (char*) f->imagebase;
3187 ElfW(Addr) base = f->baseaddr;
3188 struct obj_section* sec;
3190 for (sec = f->load_order; sec; sec = sec->load_next) {
3192 /* section already loaded? */
3193 if (sec->contents != NULL)
3196 if (sec->header.sh_size == 0)
3199 sec->contents = imagebase + (sec->header.sh_addr - base);
3200 fseek(fp, sec->header.sh_offset, SEEK_SET);
3201 if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
3202 errorMsg("error reading ELF section data: %s\n", strerror(errno));
3211 static void hide_special_symbols(struct obj_file *f)
3213 static const char *const specials[] = {
3220 struct obj_symbol *sym;
3221 const char *const *p;
3223 for (p = specials; *p; ++p)
3224 if ((sym = obj_find_symbol(f, *p)) != NULL)
3226 ELFW(ST_INFO) (STB_LOCAL, ELFW(ST_TYPE) (sym->info));
3231 extern int insmod_main( int argc, char **argv)
3238 unsigned long m_size;
3243 char m_name[FILENAME_MAX + 1] = "\0";
3244 int exit_status = EXIT_FAILURE;
3246 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
3248 char k_strversion[STRVERSIONLEN];
3249 char m_strversion[STRVERSIONLEN];
3254 /* Parse any options */
3255 while ((opt = getopt(argc, argv, "fkvxLo:")) > 0) {
3257 case 'f': /* force loading */
3258 flag_force_load = 1;
3260 case 'k': /* module loaded by kerneld, auto-cleanable */
3263 case 'v': /* verbose output */
3266 case 'x': /* do not export externs */
3269 case 'o': /* name the output module */
3270 strncpy(m_name, optarg, FILENAME_MAX);
3272 case 'L': /* Stub warning */
3273 /* This is needed for compatibility with modprobe.
3274 * In theory, this does locking, but we don't do
3275 * that. So be careful and plan your life around not
3276 * loading the same module 50 times concurrently. */
3283 if (argv[optind] == NULL) {
3287 /* Grab the module name */
3288 if ((tmp = strrchr(argv[optind], '/')) != NULL) {
3295 if (len > 2 && tmp[len - 2] == '.' && tmp[len - 1] == 'o')
3297 memcpy(m_fullName, tmp, len);
3298 m_fullName[len]='\0';
3299 if (*m_name == '\0') {
3300 strcpy(m_name, m_fullName);
3302 strcat(m_fullName, ".o");
3304 /* Get a filedesc for the module. Check we we have a complete path */
3305 if (stat(argv[optind], &st) < 0 || !S_ISREG(st.st_mode) ||
3306 (fp = fopen(argv[optind], "r")) == NULL) {
3307 struct utsname myuname;
3309 /* Hmm. Could not open it. First search under /lib/modules/`uname -r`,
3310 * but do not error out yet if we fail to find it... */
3311 if (uname(&myuname) == 0) {
3312 char module_dir[FILENAME_MAX];
3313 char real_module_dir[FILENAME_MAX];
3314 snprintf (module_dir, sizeof(module_dir), "%s/%s",
3315 _PATH_MODULES, myuname.release);
3316 /* Jump through hoops in case /lib/modules/`uname -r`
3317 * is a symlink. We do not want recursive_action to
3318 * follow symlinks, but we do want to follow the
3319 * /lib/modules/`uname -r` dir, So resolve it ourselves
3320 * if it is a link... */
3321 if (realpath (module_dir, real_module_dir) == NULL)
3322 strcpy(real_module_dir, module_dir);
3323 recursive_action(real_module_dir, TRUE, FALSE, FALSE,
3324 check_module_name_match, 0, m_fullName);
3327 /* Check if we have found anything yet */
3328 if (m_filename[0] == '\0' || ((fp = fopen(m_filename, "r")) == NULL))
3330 char module_dir[FILENAME_MAX];
3331 if (realpath (_PATH_MODULES, module_dir) == NULL)
3332 strcpy(module_dir, _PATH_MODULES);
3333 /* No module found under /lib/modules/`uname -r`, this
3334 * time cast the net a bit wider. Search /lib/modules/ */
3335 if (recursive_action(module_dir, TRUE, FALSE, FALSE,
3336 check_module_name_match, 0, m_fullName) == FALSE)
3338 if (m_filename[0] == '\0'
3339 || ((fp = fopen(m_filename, "r")) == NULL))
3341 error_msg("%s: no module by that name found", m_fullName);
3342 return EXIT_FAILURE;
3345 error_msg_and_die("%s: no module by that name found", m_fullName);
3348 safe_strncpy(m_filename, argv[optind], sizeof(m_filename));
3350 printf("Using %s\n", m_filename);
3352 if ((f = obj_load(fp, LOADBITS)) == NULL)
3353 perror_msg_and_die("Could not load the module");
3355 if (get_modinfo_value(f, "kernel_version") == NULL)
3360 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
3361 /* Version correspondence? */
3363 k_version = get_kernel_version(k_strversion);
3364 if (m_has_modinfo) {
3365 m_version = new_get_module_version(f, m_strversion);
3367 m_version = old_get_module_version(f, m_strversion);
3368 if (m_version == -1) {
3369 error_msg("couldn't find the kernel version the module was "
3375 if (strncmp(k_strversion, m_strversion, STRVERSIONLEN) != 0) {
3376 if (flag_force_load) {
3377 error_msg("Warning: kernel-module version mismatch\n"
3378 "\t%s was compiled for kernel version %s\n"
3379 "\twhile this kernel is version %s",
3380 m_filename, m_strversion, k_strversion);
3382 error_msg("kernel-module version mismatch\n"
3383 "\t%s was compiled for kernel version %s\n"
3384 "\twhile this kernel is version %s.",
3385 m_filename, m_strversion, k_strversion);
3390 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
3392 k_new_syscalls = !query_module(NULL, 0, NULL, 0, NULL);
3394 if (k_new_syscalls) {
3395 #ifdef BB_FEATURE_NEW_MODULE_INTERFACE
3396 if (!new_get_kernel_symbols())
3398 k_crcs = new_is_kernel_checksummed();
3400 error_msg("Not configured to support new kernels");
3404 #ifdef BB_FEATURE_OLD_MODULE_INTERFACE
3405 if (!old_get_kernel_symbols(m_name))
3407 k_crcs = old_is_kernel_checksummed();
3409 error_msg("Not configured to support old kernels");
3414 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
3416 m_crcs = new_is_module_checksummed(f);
3418 m_crcs = old_is_module_checksummed(f);
3420 if (m_crcs != k_crcs)
3421 obj_set_symbol_compare(f, ncv_strcmp, ncv_symbol_hash);
3422 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
3424 /* Let the module know about the kernel symbols. */
3425 add_kernel_symbols(f);
3427 /* Allocate common symbols, symbol tables, and string tables. */
3430 ? !new_create_this_module(f, m_name)
3431 : !old_create_mod_use_count(f))
3436 if (!obj_check_undefineds(f)) {
3439 obj_allocate_commons(f);
3441 /* done with the module name, on to the optional var=value arguments */
3444 if (optind < argc) {
3446 ? !new_process_module_arguments(f, argc - optind, argv + optind)
3447 : !old_process_module_arguments(f, argc - optind, argv + optind))
3454 hide_special_symbols(f);
3457 new_create_module_ksymtab(f);
3459 /* Find current size of the module */
3460 m_size = obj_load_size(f);
3463 m_addr = create_module(m_name, m_size);
3464 if (m_addr==-1) switch (errno) {
3466 error_msg("A module named %s already exists", m_name);
3469 error_msg("Can't allocate kernel memory for module; needed %lu bytes",
3473 perror_msg("create_module: %s", m_name);
3479 * the PROGBITS section was not loaded by the obj_load
3480 * now we can load them directly into the kernel memory
3482 // f->imagebase = (char*) m_addr;
3483 f->imagebase = (ElfW(Addr)) m_addr;
3484 if (!obj_load_progbits(fp, f)) {
3485 delete_module(m_name);
3490 if (!obj_relocate(f, m_addr)) {
3491 delete_module(m_name);
3496 ? !new_init_module(m_name, f, m_size)
3497 : !old_init_module(m_name, f, m_size))
3499 delete_module(m_name);
3503 exit_status = EXIT_SUCCESS;
3507 return(exit_status);