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.67 2001/06/28 21:36:06 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.67 2001/06/28 21:36:06 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(__mc68000__))
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(__mc68000__)
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(__mc68000__)
818 #elif defined(__powerpc__)
820 #elif defined(__mips__)
827 #elif defined(__arm__)
829 #elif defined(__i386__)
831 #elif defined(__mc68000__)
833 #elif defined(__powerpc__)
835 #elif defined(__mips__)
840 #if defined(__mc68000__)
843 ret = obj_reloc_overflow;
848 ret = obj_reloc_overflow;
851 #endif /* __mc68000__ */
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(__mc68000__)
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(__mc68000__)
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(__mc68000__)
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(__mc68000__)
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(__mc68000__)
1112 *loc += isym->gotent.offset;
1116 /* address relative to the got */
1117 #if !defined(__mc68000__)
1120 #elif defined(__arm__)
1122 #elif defined(__i386__)
1124 #elif defined(__mc68000__)
1130 #endif // __mc68000__
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(__mc68000__)
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 && symidx != -1) {
1464 if (symidx >= f->local_symtab_size)
1465 error_msg("local symbol %s with index %ld exceeds local_symtab_size %ld",
1466 name, (long) symidx, (long) f->local_symtab_size);
1468 f->local_symtab[symidx] = sym;
1475 sym->secidx = secidx;
1481 struct obj_symbol *obj_find_symbol(struct obj_file *f, const char *name)
1483 struct obj_symbol *sym;
1484 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
1486 for (sym = f->symtab[hash]; sym; sym = sym->next)
1487 if (f->symbol_cmp(sym->name, name) == 0)
1494 obj_symbol_final_value(struct obj_file * f, struct obj_symbol * sym)
1497 if (sym->secidx >= SHN_LORESERVE)
1500 return sym->value + f->sections[sym->secidx]->header.sh_addr;
1502 /* As a special case, a NULL sym has value zero. */
1507 struct obj_section *obj_find_section(struct obj_file *f, const char *name)
1509 int i, n = f->header.e_shnum;
1511 for (i = 0; i < n; ++i)
1512 if (strcmp(f->sections[i]->name, name) == 0)
1513 return f->sections[i];
1518 static int obj_load_order_prio(struct obj_section *a)
1520 unsigned long af, ac;
1522 af = a->header.sh_flags;
1525 if (a->name[0] != '.' || strlen(a->name) != 10 ||
1526 strcmp(a->name + 5, ".init"))
1530 if (!(af & SHF_WRITE))
1532 if (af & SHF_EXECINSTR)
1534 if (a->header.sh_type != SHT_NOBITS)
1541 obj_insert_section_load_order(struct obj_file *f, struct obj_section *sec)
1543 struct obj_section **p;
1544 int prio = obj_load_order_prio(sec);
1545 for (p = f->load_order_search_start; *p; p = &(*p)->load_next)
1546 if (obj_load_order_prio(*p) < prio)
1548 sec->load_next = *p;
1552 struct obj_section *obj_create_alloced_section(struct obj_file *f,
1554 unsigned long align,
1557 int newidx = f->header.e_shnum++;
1558 struct obj_section *sec;
1560 f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
1561 f->sections[newidx] = sec = arch_new_section();
1563 memset(sec, 0, sizeof(*sec));
1564 sec->header.sh_type = SHT_PROGBITS;
1565 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
1566 sec->header.sh_size = size;
1567 sec->header.sh_addralign = align;
1571 sec->contents = xmalloc(size);
1573 obj_insert_section_load_order(f, sec);
1578 struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
1580 unsigned long align,
1583 int newidx = f->header.e_shnum++;
1584 struct obj_section *sec;
1586 f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
1587 f->sections[newidx] = sec = arch_new_section();
1589 memset(sec, 0, sizeof(*sec));
1590 sec->header.sh_type = SHT_PROGBITS;
1591 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
1592 sec->header.sh_size = size;
1593 sec->header.sh_addralign = align;
1597 sec->contents = xmalloc(size);
1599 sec->load_next = f->load_order;
1600 f->load_order = sec;
1601 if (f->load_order_search_start == &f->load_order)
1602 f->load_order_search_start = &sec->load_next;
1607 void *obj_extend_section(struct obj_section *sec, unsigned long more)
1609 unsigned long oldsize = sec->header.sh_size;
1611 sec->contents = xrealloc(sec->contents, sec->header.sh_size += more);
1613 return sec->contents + oldsize;
1618 /* Conditionally add the symbols from the given symbol set to the
1624 int idx, struct new_module_symbol *syms, size_t nsyms)
1626 struct new_module_symbol *s;
1630 for (i = 0, s = syms; i < nsyms; ++i, ++s) {
1632 /* Only add symbols that are already marked external. If we
1633 override locals we may cause problems for argument initialization.
1634 We will also create a false dependency on the module. */
1635 struct obj_symbol *sym;
1637 sym = obj_find_symbol(f, (char *) s->name);
1638 if (sym && !ELFW(ST_BIND) (sym->info) == STB_LOCAL) {
1639 sym = obj_add_symbol(f, (char *) s->name, -1,
1640 ELFW(ST_INFO) (STB_GLOBAL, STT_NOTYPE),
1642 /* Did our symbol just get installed? If so, mark the
1643 module as "used". */
1644 if (sym->secidx == idx)
1652 static void add_kernel_symbols(struct obj_file *f)
1654 struct external_module *m;
1657 /* Add module symbols first. */
1659 for (i = 0, m = ext_modules; i < n_ext_modules; ++i, ++m)
1661 && add_symbols_from(f, SHN_HIRESERVE + 2 + i, m->syms,
1662 m->nsyms)) m->used = 1, ++nused;
1664 n_ext_modules_used = nused;
1666 /* And finally the symbols from the kernel proper. */
1669 add_symbols_from(f, SHN_HIRESERVE + 1, ksyms, nksyms);
1672 static char *get_modinfo_value(struct obj_file *f, const char *key)
1674 struct obj_section *sec;
1675 char *p, *v, *n, *ep;
1676 size_t klen = strlen(key);
1678 sec = obj_find_section(f, ".modinfo");
1682 ep = p + sec->header.sh_size;
1685 n = strchr(p, '\0');
1687 if (p + klen == v && strncmp(p, key, klen) == 0)
1690 if (p + klen == n && strcmp(p, key) == 0)
1700 /*======================================================================*/
1701 /* Functions relating to module loading in pre 2.1 kernels. */
1704 old_process_module_arguments(struct obj_file *f, int argc, char **argv)
1708 struct obj_symbol *sym;
1712 if ((q = strchr(p, '=')) == NULL) {
1718 sym = obj_find_symbol(f, p);
1720 /* Also check that the parameter was not resolved from the kernel. */
1721 if (sym == NULL || sym->secidx > SHN_HIRESERVE) {
1722 error_msg("symbol for parameter %s not found", p);
1726 loc = (int *) (f->sections[sym->secidx]->contents + sym->value);
1728 /* Do C quoting if we begin with a ". */
1732 str = alloca(strlen(q));
1733 for (r = str, q++; *q != '"'; ++q, ++r) {
1735 error_msg("improperly terminated string argument for %s", p);
1737 } else if (*q == '\\')
1771 if (q[1] >= '0' && q[1] <= '7') {
1772 c = (c * 8) + *++q - '0';
1773 if (q[1] >= '0' && q[1] <= '7')
1774 c = (c * 8) + *++q - '0';
1787 obj_string_patch(f, sym->secidx, sym->value, str);
1788 } else if (*q >= '0' && *q <= '9') {
1790 *loc++ = strtoul(q, &q, 0);
1791 while (*q++ == ',');
1793 char *contents = f->sections[sym->secidx]->contents;
1794 char *myloc = contents + sym->value;
1795 char *r; /* To search for commas */
1797 /* Break the string with comas */
1798 while ((r = strchr(q, ',')) != (char *) NULL) {
1800 obj_string_patch(f, sym->secidx, myloc - contents, q);
1801 myloc += sizeof(char *);
1806 obj_string_patch(f, sym->secidx, myloc - contents, q);
1815 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
1816 static int old_is_module_checksummed(struct obj_file *f)
1818 return obj_find_symbol(f, "Using_Versions") != NULL;
1820 /* Get the module's kernel version in the canonical integer form. */
1823 old_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
1825 struct obj_symbol *sym;
1829 sym = obj_find_symbol(f, "kernel_version");
1833 p = f->sections[sym->secidx]->contents + sym->value;
1834 strncpy(str, p, STRVERSIONLEN);
1836 a = strtoul(p, &p, 10);
1839 b = strtoul(p + 1, &p, 10);
1842 c = strtoul(p + 1, &q, 10);
1846 return a << 16 | b << 8 | c;
1849 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
1851 #ifdef BB_FEATURE_OLD_MODULE_INTERFACE
1853 /* Fetch all the symbols and divvy them up as appropriate for the modules. */
1855 static int old_get_kernel_symbols(const char *m_name)
1857 struct old_kernel_sym *ks, *k;
1858 struct new_module_symbol *s;
1859 struct external_module *mod;
1860 int nks, nms, nmod, i;
1862 nks = get_kernel_syms(NULL);
1865 perror_msg("get_kernel_syms: %s", m_name);
1867 error_msg("No kernel symbols");
1871 ks = k = xmalloc(nks * sizeof(*ks));
1873 if (get_kernel_syms(ks) != nks) {
1874 perror("inconsistency with get_kernel_syms -- is someone else "
1875 "playing with modules?");
1880 /* Collect the module information. */
1885 while (k->name[0] == '#' && k->name[1]) {
1886 struct old_kernel_sym *k2;
1888 /* Find out how many symbols this module has. */
1889 for (k2 = k + 1; k2->name[0] != '#'; ++k2)
1893 mod = xrealloc(mod, (++nmod + 1) * sizeof(*mod));
1894 mod[nmod].name = k->name + 1;
1895 mod[nmod].addr = k->value;
1897 mod[nmod].nsyms = nms;
1898 mod[nmod].syms = s = (nms ? xmalloc(nms * sizeof(*s)) : NULL);
1900 for (i = 0, ++k; i < nms; ++i, ++s, ++k) {
1901 s->name = (unsigned long) k->name;
1902 s->value = k->value;
1909 n_ext_modules = nmod + 1;
1911 /* Now collect the symbols for the kernel proper. */
1913 if (k->name[0] == '#')
1916 nksyms = nms = nks - (k - ks);
1917 ksyms = s = (nms ? xmalloc(nms * sizeof(*s)) : NULL);
1919 for (i = 0; i < nms; ++i, ++s, ++k) {
1920 s->name = (unsigned long) k->name;
1921 s->value = k->value;
1927 /* Return the kernel symbol checksum version, or zero if not used. */
1929 static int old_is_kernel_checksummed(void)
1931 /* Using_Versions is the first symbol. */
1933 && strcmp((char *) ksyms[0].name,
1934 "Using_Versions") == 0) return ksyms[0].value;
1940 static int old_create_mod_use_count(struct obj_file *f)
1942 struct obj_section *sec;
1944 sec = obj_create_alloced_section_first(f, ".moduse", sizeof(long),
1947 obj_add_symbol(f, "mod_use_count_", -1,
1948 ELFW(ST_INFO) (STB_LOCAL, STT_OBJECT), sec->idx, 0,
1955 old_init_module(const char *m_name, struct obj_file *f,
1956 unsigned long m_size)
1959 struct old_mod_routines routines;
1960 struct old_symbol_table *symtab;
1963 /* Create the symbol table */
1965 int nsyms = 0, strsize = 0, total;
1967 /* Size things first... */
1970 for (i = 0; i < HASH_BUCKETS; ++i) {
1971 struct obj_symbol *sym;
1972 for (sym = f->symtab[i]; sym; sym = sym->next)
1973 if (ELFW(ST_BIND) (sym->info) != STB_LOCAL
1974 && sym->secidx <= SHN_HIRESERVE)
1976 sym->ksymidx = nsyms++;
1977 strsize += strlen(sym->name) + 1;
1982 total = (sizeof(struct old_symbol_table)
1983 + nsyms * sizeof(struct old_module_symbol)
1984 + n_ext_modules_used * sizeof(struct old_module_ref)
1986 symtab = xmalloc(total);
1987 symtab->size = total;
1988 symtab->n_symbols = nsyms;
1989 symtab->n_refs = n_ext_modules_used;
1991 if (flag_export && nsyms) {
1992 struct old_module_symbol *ksym;
1996 ksym = symtab->symbol;
1997 str = ((char *) ksym + nsyms * sizeof(struct old_module_symbol)
1998 + n_ext_modules_used * sizeof(struct old_module_ref));
2000 for (i = 0; i < HASH_BUCKETS; ++i) {
2001 struct obj_symbol *sym;
2002 for (sym = f->symtab[i]; sym; sym = sym->next)
2003 if (sym->ksymidx >= 0) {
2004 ksym->addr = obj_symbol_final_value(f, sym);
2006 (unsigned long) str - (unsigned long) symtab;
2008 strcpy(str, sym->name);
2009 str += strlen(sym->name) + 1;
2015 if (n_ext_modules_used) {
2016 struct old_module_ref *ref;
2019 ref = (struct old_module_ref *)
2020 ((char *) symtab->symbol + nsyms * sizeof(struct old_module_symbol));
2022 for (i = 0; i < n_ext_modules; ++i)
2023 if (ext_modules[i].used)
2024 ref++->module = ext_modules[i].addr;
2028 /* Fill in routines. */
2031 obj_symbol_final_value(f, obj_find_symbol(f, "init_module"));
2033 obj_symbol_final_value(f, obj_find_symbol(f, "cleanup_module"));
2035 /* Whew! All of the initialization is complete. Collect the final
2036 module image and give it to the kernel. */
2038 image = xmalloc(m_size);
2039 obj_create_image(f, image);
2041 /* image holds the complete relocated module, accounting correctly for
2042 mod_use_count. However the old module kernel support assume that
2043 it is receiving something which does not contain mod_use_count. */
2044 ret = old_sys_init_module(m_name, image + sizeof(long),
2045 m_size | (flag_autoclean ? OLD_MOD_AUTOCLEAN
2046 : 0), &routines, symtab);
2048 perror_msg("init_module: %s", m_name);
2058 #define old_create_mod_use_count(x) TRUE
2059 #define old_init_module(x, y, z) TRUE
2061 #endif /* BB_FEATURE_OLD_MODULE_INTERFACE */
2065 /*======================================================================*/
2066 /* Functions relating to module loading after 2.1.18. */
2069 new_process_module_arguments(struct obj_file *f, int argc, char **argv)
2073 struct obj_symbol *sym;
2074 char *contents, *loc;
2078 if ((q = strchr(p, '=')) == NULL) {
2083 key = alloca(q - p + 6);
2084 memcpy(key, "parm_", 5);
2085 memcpy(key + 5, p, q - p);
2088 p = get_modinfo_value(f, key);
2091 error_msg("invalid parameter %s", key);
2095 sym = obj_find_symbol(f, key);
2097 /* Also check that the parameter was not resolved from the kernel. */
2098 if (sym == NULL || sym->secidx > SHN_HIRESERVE) {
2099 error_msg("symbol for parameter %s not found", key);
2104 min = strtoul(p, &p, 10);
2106 max = strtoul(p + 1, &p, 10);
2112 contents = f->sections[sym->secidx]->contents;
2113 loc = contents + sym->value;
2117 if ((*p == 's') || (*p == 'c')) {
2120 /* Do C quoting if we begin with a ", else slurp the lot. */
2124 str = alloca(strlen(q));
2125 for (r = str, q++; *q != '"'; ++q, ++r) {
2127 error_msg("improperly terminated string argument for %s",
2130 } else if (*q == '\\')
2164 if (q[1] >= '0' && q[1] <= '7') {
2165 c = (c * 8) + *++q - '0';
2166 if (q[1] >= '0' && q[1] <= '7')
2167 c = (c * 8) + *++q - '0';
2184 /* In this case, the string is not quoted. We will break
2185 it using the coma (like for ints). If the user wants to
2186 include comas in a string, he just has to quote it */
2188 /* Search the next coma */
2192 if (r != (char *) NULL) {
2193 /* Recopy the current field */
2194 str = alloca(r - q + 1);
2195 memcpy(str, q, r - q);
2197 /* I don't know if it is usefull, as the previous case
2198 doesn't null terminate the string ??? */
2201 /* Keep next fields */
2212 obj_string_patch(f, sym->secidx, loc - contents, str);
2213 loc += tgt_sizeof_char_p;
2215 /* Array of chars (in fact, matrix !) */
2216 unsigned long charssize; /* size of each member */
2218 /* Get the size of each member */
2219 /* Probably we should do that outside the loop ? */
2220 if (!isdigit(*(p + 1))) {
2221 error_msg("parameter type 'c' for %s must be followed by"
2222 " the maximum size", key);
2225 charssize = strtoul(p + 1, (char **) NULL, 10);
2228 if (strlen(str) >= charssize) {
2229 error_msg("string too long for %s (max %ld)", key,
2234 /* Copy to location */
2235 strcpy((char *) loc, str);
2239 long v = strtoul(q, &q, 0);
2246 loc += tgt_sizeof_short;
2250 loc += tgt_sizeof_int;
2254 loc += tgt_sizeof_long;
2258 error_msg("unknown parameter type '%c' for %s", *p, key);
2273 goto retry_end_of_value;
2277 error_msg("too many values for %s (max %d)", key, max);
2284 error_msg("invalid argument syntax for %s", key);
2291 error_msg("too few values for %s (min %d)", key, min);
2301 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
2302 static int new_is_module_checksummed(struct obj_file *f)
2304 const char *p = get_modinfo_value(f, "using_checksums");
2311 /* Get the module's kernel version in the canonical integer form. */
2314 new_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
2319 p = get_modinfo_value(f, "kernel_version");
2322 strncpy(str, p, STRVERSIONLEN);
2324 a = strtoul(p, &p, 10);
2327 b = strtoul(p + 1, &p, 10);
2330 c = strtoul(p + 1, &q, 10);
2334 return a << 16 | b << 8 | c;
2337 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
2340 #ifdef BB_FEATURE_NEW_MODULE_INTERFACE
2342 /* Fetch the loaded modules, and all currently exported symbols. */
2344 static int new_get_kernel_symbols(void)
2346 char *module_names, *mn;
2347 struct external_module *modules, *m;
2348 struct new_module_symbol *syms, *s;
2349 size_t ret, bufsize, nmod, nsyms, i, j;
2351 /* Collect the loaded modules. */
2353 module_names = xmalloc(bufsize = 256);
2355 if (query_module(NULL, QM_MODULES, module_names, bufsize, &ret)) {
2356 if (errno == ENOSPC && bufsize < ret) {
2357 module_names = xrealloc(module_names, bufsize = ret);
2358 goto retry_modules_load;
2360 perror_msg("QM_MODULES");
2364 n_ext_modules = nmod = ret;
2366 /* Collect the modules' symbols. */
2369 ext_modules = modules = xmalloc(nmod * sizeof(*modules));
2370 memset(modules, 0, nmod * sizeof(*modules));
2371 for (i = 0, mn = module_names, m = modules;
2372 i < nmod; ++i, ++m, mn += strlen(mn) + 1) {
2373 struct new_module_info info;
2375 if (query_module(mn, QM_INFO, &info, sizeof(info), &ret)) {
2376 if (errno == ENOENT) {
2377 /* The module was removed out from underneath us. */
2380 perror_msg("query_module: QM_INFO: %s", mn);
2384 syms = xmalloc(bufsize = 1024);
2386 if (query_module(mn, QM_SYMBOLS, syms, bufsize, &ret)) {
2389 syms = xrealloc(syms, bufsize = ret);
2390 goto retry_mod_sym_load;
2392 /* The module was removed out from underneath us. */
2395 perror_msg("query_module: QM_SYMBOLS: %s", mn);
2402 m->addr = info.addr;
2406 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2407 s->name += (unsigned long) syms;
2412 /* Collect the kernel's symbols. */
2414 syms = xmalloc(bufsize = 16 * 1024);
2415 retry_kern_sym_load:
2416 if (query_module(NULL, QM_SYMBOLS, syms, bufsize, &ret)) {
2417 if (errno == ENOSPC && bufsize < ret) {
2418 syms = xrealloc(syms, bufsize = ret);
2419 goto retry_kern_sym_load;
2421 perror_msg("kernel: QM_SYMBOLS");
2424 nksyms = nsyms = ret;
2427 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2428 s->name += (unsigned long) syms;
2434 /* Return the kernel symbol checksum version, or zero if not used. */
2436 static int new_is_kernel_checksummed(void)
2438 struct new_module_symbol *s;
2441 /* Using_Versions is not the first symbol, but it should be in there. */
2443 for (i = 0, s = ksyms; i < nksyms; ++i, ++s)
2444 if (strcmp((char *) s->name, "Using_Versions") == 0)
2451 static int new_create_this_module(struct obj_file *f, const char *m_name)
2453 struct obj_section *sec;
2455 sec = obj_create_alloced_section_first(f, ".this", tgt_sizeof_long,
2456 sizeof(struct new_module));
2457 memset(sec->contents, 0, sizeof(struct new_module));
2459 obj_add_symbol(f, "__this_module", -1,
2460 ELFW(ST_INFO) (STB_LOCAL, STT_OBJECT), sec->idx, 0,
2461 sizeof(struct new_module));
2463 obj_string_patch(f, sec->idx, offsetof(struct new_module, name),
2470 static int new_create_module_ksymtab(struct obj_file *f)
2472 struct obj_section *sec;
2475 /* We must always add the module references. */
2477 if (n_ext_modules_used) {
2478 struct new_module_ref *dep;
2479 struct obj_symbol *tm;
2481 sec = obj_create_alloced_section(f, ".kmodtab", tgt_sizeof_void_p,
2482 (sizeof(struct new_module_ref)
2483 * n_ext_modules_used));
2487 tm = obj_find_symbol(f, "__this_module");
2488 dep = (struct new_module_ref *) sec->contents;
2489 for (i = 0; i < n_ext_modules; ++i)
2490 if (ext_modules[i].used) {
2491 dep->dep = ext_modules[i].addr;
2492 obj_symbol_patch(f, sec->idx,
2493 (char *) &dep->ref - sec->contents, tm);
2499 if (flag_export && !obj_find_section(f, "__ksymtab")) {
2504 obj_create_alloced_section(f, "__ksymtab", tgt_sizeof_void_p,
2507 /* We don't want to export symbols residing in sections that
2508 aren't loaded. There are a number of these created so that
2509 we make sure certain module options don't appear twice. */
2511 loaded = alloca(sizeof(int) * (i = f->header.e_shnum));
2513 loaded[i] = (f->sections[i]->header.sh_flags & SHF_ALLOC) != 0;
2515 for (nsyms = i = 0; i < HASH_BUCKETS; ++i) {
2516 struct obj_symbol *sym;
2517 for (sym = f->symtab[i]; sym; sym = sym->next)
2518 if (ELFW(ST_BIND) (sym->info) != STB_LOCAL
2519 && sym->secidx <= SHN_HIRESERVE
2520 && (sym->secidx >= SHN_LORESERVE
2521 || loaded[sym->secidx])) {
2522 ElfW(Addr) ofs = nsyms * 2 * tgt_sizeof_void_p;
2524 obj_symbol_patch(f, sec->idx, ofs, sym);
2525 obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p,
2532 obj_extend_section(sec, nsyms * 2 * tgt_sizeof_char_p);
2540 new_init_module(const char *m_name, struct obj_file *f,
2541 unsigned long m_size)
2543 struct new_module *module;
2544 struct obj_section *sec;
2549 sec = obj_find_section(f, ".this");
2550 if (!sec || !sec->contents) {
2551 perror_msg_and_die("corrupt module %s?",m_name);
2553 module = (struct new_module *) sec->contents;
2554 m_addr = sec->header.sh_addr;
2556 module->size_of_struct = sizeof(*module);
2557 module->size = m_size;
2558 module->flags = flag_autoclean ? NEW_MOD_AUTOCLEAN : 0;
2560 sec = obj_find_section(f, "__ksymtab");
2561 if (sec && sec->header.sh_size) {
2562 module->syms = sec->header.sh_addr;
2563 module->nsyms = sec->header.sh_size / (2 * tgt_sizeof_char_p);
2566 if (n_ext_modules_used) {
2567 sec = obj_find_section(f, ".kmodtab");
2568 module->deps = sec->header.sh_addr;
2569 module->ndeps = n_ext_modules_used;
2573 obj_symbol_final_value(f, obj_find_symbol(f, "init_module"));
2575 obj_symbol_final_value(f, obj_find_symbol(f, "cleanup_module"));
2577 sec = obj_find_section(f, "__ex_table");
2579 module->ex_table_start = sec->header.sh_addr;
2580 module->ex_table_end = sec->header.sh_addr + sec->header.sh_size;
2583 sec = obj_find_section(f, ".text.init");
2585 module->runsize = sec->header.sh_addr - m_addr;
2587 sec = obj_find_section(f, ".data.init");
2589 if (!module->runsize ||
2590 module->runsize > sec->header.sh_addr - m_addr)
2591 module->runsize = sec->header.sh_addr - m_addr;
2593 sec = obj_find_section(f, ARCHDATA_SEC_NAME);
2594 if (sec && sec->header.sh_size) {
2595 module->archdata_start = (void*)sec->header.sh_addr;
2596 module->archdata_end = module->archdata_start + sec->header.sh_size;
2598 sec = obj_find_section(f, KALLSYMS_SEC_NAME);
2599 if (sec && sec->header.sh_size) {
2600 module->kallsyms_start = (void*)sec->header.sh_addr;
2601 module->kallsyms_end = module->kallsyms_start + sec->header.sh_size;
2604 if (!arch_init_module(f, module))
2607 /* Whew! All of the initialization is complete. Collect the final
2608 module image and give it to the kernel. */
2610 image = xmalloc(m_size);
2611 obj_create_image(f, image);
2613 ret = new_sys_init_module(m_name, (struct new_module *) image);
2615 perror_msg("init_module: %s", m_name);
2624 #define new_init_module(x, y, z) TRUE
2625 #define new_create_this_module(x, y) 0
2626 #define new_create_module_ksymtab(x)
2627 #define query_module(v, w, x, y, z) -1
2629 #endif /* BB_FEATURE_NEW_MODULE_INTERFACE */
2632 /*======================================================================*/
2635 obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2638 struct obj_string_patch *p;
2639 struct obj_section *strsec;
2640 size_t len = strlen(string) + 1;
2643 p = xmalloc(sizeof(*p));
2644 p->next = f->string_patches;
2645 p->reloc_secidx = secidx;
2646 p->reloc_offset = offset;
2647 f->string_patches = p;
2649 strsec = obj_find_section(f, ".kstrtab");
2650 if (strsec == NULL) {
2651 strsec = obj_create_alloced_section(f, ".kstrtab", 1, len);
2652 p->string_offset = 0;
2653 loc = strsec->contents;
2655 p->string_offset = strsec->header.sh_size;
2656 loc = obj_extend_section(strsec, len);
2658 memcpy(loc, string, len);
2664 obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2665 struct obj_symbol *sym)
2667 struct obj_symbol_patch *p;
2669 p = xmalloc(sizeof(*p));
2670 p->next = f->symbol_patches;
2671 p->reloc_secidx = secidx;
2672 p->reloc_offset = offset;
2674 f->symbol_patches = p;
2679 int obj_check_undefineds(struct obj_file *f)
2684 for (i = 0; i < HASH_BUCKETS; ++i) {
2685 struct obj_symbol *sym;
2686 for (sym = f->symtab[i]; sym; sym = sym->next)
2687 if (sym->secidx == SHN_UNDEF) {
2688 if (ELFW(ST_BIND) (sym->info) == STB_WEAK) {
2689 sym->secidx = SHN_ABS;
2692 error_msg("unresolved symbol %s", sym->name);
2701 void obj_allocate_commons(struct obj_file *f)
2703 struct common_entry {
2704 struct common_entry *next;
2705 struct obj_symbol *sym;
2706 } *common_head = NULL;
2710 for (i = 0; i < HASH_BUCKETS; ++i) {
2711 struct obj_symbol *sym;
2712 for (sym = f->symtab[i]; sym; sym = sym->next)
2713 if (sym->secidx == SHN_COMMON) {
2714 /* Collect all COMMON symbols and sort them by size so as to
2715 minimize space wasted by alignment requirements. */
2717 struct common_entry **p, *n;
2718 for (p = &common_head; *p; p = &(*p)->next)
2719 if (sym->size <= (*p)->sym->size)
2722 n = alloca(sizeof(*n));
2730 for (i = 1; i < f->local_symtab_size; ++i) {
2731 struct obj_symbol *sym = f->local_symtab[i];
2732 if (sym && sym->secidx == SHN_COMMON) {
2733 struct common_entry **p, *n;
2734 for (p = &common_head; *p; p = &(*p)->next)
2735 if (sym == (*p)->sym)
2737 else if (sym->size < (*p)->sym->size) {
2738 n = alloca(sizeof(*n));
2748 /* Find the bss section. */
2749 for (i = 0; i < f->header.e_shnum; ++i)
2750 if (f->sections[i]->header.sh_type == SHT_NOBITS)
2753 /* If for some reason there hadn't been one, create one. */
2754 if (i == f->header.e_shnum) {
2755 struct obj_section *sec;
2757 f->sections = xrealloc(f->sections, (i + 1) * sizeof(sec));
2758 f->sections[i] = sec = arch_new_section();
2759 f->header.e_shnum = i + 1;
2761 memset(sec, 0, sizeof(*sec));
2762 sec->header.sh_type = SHT_PROGBITS;
2763 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2768 /* Allocate the COMMONS. */
2770 ElfW(Addr) bss_size = f->sections[i]->header.sh_size;
2771 ElfW(Addr) max_align = f->sections[i]->header.sh_addralign;
2772 struct common_entry *c;
2774 for (c = common_head; c; c = c->next) {
2775 ElfW(Addr) align = c->sym->value;
2777 if (align > max_align)
2779 if (bss_size & (align - 1))
2780 bss_size = (bss_size | (align - 1)) + 1;
2783 c->sym->value = bss_size;
2785 bss_size += c->sym->size;
2788 f->sections[i]->header.sh_size = bss_size;
2789 f->sections[i]->header.sh_addralign = max_align;
2793 /* For the sake of patch relocation and parameter initialization,
2794 allocate zeroed data for NOBITS sections now. Note that after
2795 this we cannot assume NOBITS are really empty. */
2796 for (i = 0; i < f->header.e_shnum; ++i) {
2797 struct obj_section *s = f->sections[i];
2798 if (s->header.sh_type == SHT_NOBITS) {
2799 if (s->header.sh_size != 0)
2800 s->contents = memset(xmalloc(s->header.sh_size),
2801 0, s->header.sh_size);
2805 s->header.sh_type = SHT_PROGBITS;
2810 unsigned long obj_load_size(struct obj_file *f)
2812 unsigned long dot = 0;
2813 struct obj_section *sec;
2815 /* Finalize the positions of the sections relative to one another. */
2817 for (sec = f->load_order; sec; sec = sec->load_next) {
2820 align = sec->header.sh_addralign;
2821 if (align && (dot & (align - 1)))
2822 dot = (dot | (align - 1)) + 1;
2824 sec->header.sh_addr = dot;
2825 dot += sec->header.sh_size;
2831 int obj_relocate(struct obj_file *f, ElfW(Addr) base)
2833 int i, n = f->header.e_shnum;
2836 /* Finalize the addresses of the sections. */
2839 for (i = 0; i < n; ++i)
2840 f->sections[i]->header.sh_addr += base;
2842 /* And iterate over all of the relocations. */
2844 for (i = 0; i < n; ++i) {
2845 struct obj_section *relsec, *symsec, *targsec, *strsec;
2846 ElfW(RelM) * rel, *relend;
2850 relsec = f->sections[i];
2851 if (relsec->header.sh_type != SHT_RELM)
2854 symsec = f->sections[relsec->header.sh_link];
2855 targsec = f->sections[relsec->header.sh_info];
2856 strsec = f->sections[symsec->header.sh_link];
2858 rel = (ElfW(RelM) *) relsec->contents;
2859 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
2860 symtab = (ElfW(Sym) *) symsec->contents;
2861 strtab = (const char *) strsec->contents;
2863 for (; rel < relend; ++rel) {
2864 ElfW(Addr) value = 0;
2865 struct obj_symbol *intsym = NULL;
2866 unsigned long symndx;
2867 ElfW(Sym) * extsym = 0;
2870 /* Attempt to find a value to use for this relocation. */
2872 symndx = ELFW(R_SYM) (rel->r_info);
2874 /* Note we've already checked for undefined symbols. */
2876 extsym = &symtab[symndx];
2877 if (ELFW(ST_BIND) (extsym->st_info) == STB_LOCAL) {
2878 /* Local symbols we look up in the local table to be sure
2879 we get the one that is really intended. */
2880 intsym = f->local_symtab[symndx];
2882 /* Others we look up in the hash table. */
2884 if (extsym->st_name)
2885 name = strtab + extsym->st_name;
2887 name = f->sections[extsym->st_shndx]->name;
2888 intsym = obj_find_symbol(f, name);
2891 value = obj_symbol_final_value(f, intsym);
2892 intsym->referenced = 1;
2894 #if SHT_RELM == SHT_RELA
2895 #if defined(__alpha__) && defined(AXP_BROKEN_GAS)
2896 /* Work around a nasty GAS bug, that is fixed as of 2.7.0.9. */
2897 if (!extsym || !extsym->st_name ||
2898 ELFW(ST_BIND) (extsym->st_info) != STB_LOCAL)
2900 value += rel->r_addend;
2904 switch (arch_apply_relocation
2905 (f, targsec, symsec, intsym, rel, value)) {
2909 case obj_reloc_overflow:
2910 errmsg = "Relocation overflow";
2912 case obj_reloc_dangerous:
2913 errmsg = "Dangerous relocation";
2915 case obj_reloc_unhandled:
2916 errmsg = "Unhandled relocation";
2919 error_msg("%s of type %ld for %s", errmsg,
2920 (long) ELFW(R_TYPE) (rel->r_info),
2921 strtab + extsym->st_name);
2923 error_msg("%s of type %ld", errmsg,
2924 (long) ELFW(R_TYPE) (rel->r_info));
2932 /* Finally, take care of the patches. */
2934 if (f->string_patches) {
2935 struct obj_string_patch *p;
2936 struct obj_section *strsec;
2937 ElfW(Addr) strsec_base;
2938 strsec = obj_find_section(f, ".kstrtab");
2939 strsec_base = strsec->header.sh_addr;
2941 for (p = f->string_patches; p; p = p->next) {
2942 struct obj_section *targsec = f->sections[p->reloc_secidx];
2943 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
2944 = strsec_base + p->string_offset;
2948 if (f->symbol_patches) {
2949 struct obj_symbol_patch *p;
2951 for (p = f->symbol_patches; p; p = p->next) {
2952 struct obj_section *targsec = f->sections[p->reloc_secidx];
2953 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
2954 = obj_symbol_final_value(f, p->sym);
2961 int obj_create_image(struct obj_file *f, char *image)
2963 struct obj_section *sec;
2964 ElfW(Addr) base = f->baseaddr;
2966 for (sec = f->load_order; sec; sec = sec->load_next) {
2969 if (sec->contents == 0 || sec->header.sh_size == 0)
2972 secimg = image + (sec->header.sh_addr - base);
2974 /* Note that we allocated data for NOBITS sections earlier. */
2975 memcpy(secimg, sec->contents, sec->header.sh_size);
2981 /*======================================================================*/
2983 struct obj_file *obj_load(FILE * fp, int loadprogbits)
2986 ElfW(Shdr) * section_headers;
2990 /* Read the file header. */
2992 f = arch_new_file();
2993 memset(f, 0, sizeof(*f));
2994 f->symbol_cmp = strcmp;
2995 f->symbol_hash = obj_elf_hash;
2996 f->load_order_search_start = &f->load_order;
2998 fseek(fp, 0, SEEK_SET);
2999 if (fread(&f->header, sizeof(f->header), 1, fp) != 1) {
3000 perror_msg("error reading ELF header");
3004 if (f->header.e_ident[EI_MAG0] != ELFMAG0
3005 || f->header.e_ident[EI_MAG1] != ELFMAG1
3006 || f->header.e_ident[EI_MAG2] != ELFMAG2
3007 || f->header.e_ident[EI_MAG3] != ELFMAG3) {
3008 error_msg("not an ELF file");
3011 if (f->header.e_ident[EI_CLASS] != ELFCLASSM
3012 || f->header.e_ident[EI_DATA] != ELFDATAM
3013 || f->header.e_ident[EI_VERSION] != EV_CURRENT
3014 || !MATCH_MACHINE(f->header.e_machine)) {
3015 error_msg("ELF file not for this architecture");
3018 if (f->header.e_type != ET_REL) {
3019 error_msg("ELF file not a relocatable object");
3023 /* Read the section headers. */
3025 if (f->header.e_shentsize != sizeof(ElfW(Shdr))) {
3026 error_msg("section header size mismatch: %lu != %lu",
3027 (unsigned long) f->header.e_shentsize,
3028 (unsigned long) sizeof(ElfW(Shdr)));
3032 shnum = f->header.e_shnum;
3033 f->sections = xmalloc(sizeof(struct obj_section *) * shnum);
3034 memset(f->sections, 0, sizeof(struct obj_section *) * shnum);
3036 section_headers = alloca(sizeof(ElfW(Shdr)) * shnum);
3037 fseek(fp, f->header.e_shoff, SEEK_SET);
3038 if (fread(section_headers, sizeof(ElfW(Shdr)), shnum, fp) != shnum) {
3039 perror_msg("error reading ELF section headers");
3043 /* Read the section data. */
3045 for (i = 0; i < shnum; ++i) {
3046 struct obj_section *sec;
3048 f->sections[i] = sec = arch_new_section();
3049 memset(sec, 0, sizeof(*sec));
3051 sec->header = section_headers[i];
3054 if(sec->header.sh_size) switch (sec->header.sh_type) {
3063 if (!loadprogbits) {
3064 sec->contents = NULL;
3071 if (sec->header.sh_size > 0) {
3072 sec->contents = xmalloc(sec->header.sh_size);
3073 fseek(fp, sec->header.sh_offset, SEEK_SET);
3074 if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
3075 perror_msg("error reading ELF section data");
3079 sec->contents = NULL;
3083 #if SHT_RELM == SHT_REL
3085 error_msg("RELA relocations not supported on this architecture");
3089 error_msg("REL relocations not supported on this architecture");
3094 if (sec->header.sh_type >= SHT_LOPROC) {
3095 /* Assume processor specific section types are debug
3096 info and can safely be ignored. If this is ever not
3097 the case (Hello MIPS?), don't put ifdefs here but
3098 create an arch_load_proc_section(). */
3102 error_msg("can't handle sections of type %ld",
3103 (long) sec->header.sh_type);
3108 /* Do what sort of interpretation as needed by each section. */
3110 shstrtab = f->sections[f->header.e_shstrndx]->contents;
3112 for (i = 0; i < shnum; ++i) {
3113 struct obj_section *sec = f->sections[i];
3114 sec->name = shstrtab + sec->header.sh_name;
3117 for (i = 0; i < shnum; ++i) {
3118 struct obj_section *sec = f->sections[i];
3120 /* .modinfo should be contents only but gcc has no attribute for that.
3121 * The kernel may have marked .modinfo as ALLOC, ignore this bit.
3123 if (strcmp(sec->name, ".modinfo") == 0)
3124 sec->header.sh_flags &= ~SHF_ALLOC;
3126 if (sec->header.sh_flags & SHF_ALLOC)
3127 obj_insert_section_load_order(f, sec);
3129 switch (sec->header.sh_type) {
3132 unsigned long nsym, j;
3136 if (sec->header.sh_entsize != sizeof(ElfW(Sym))) {
3137 error_msg("symbol size mismatch: %lu != %lu",
3138 (unsigned long) sec->header.sh_entsize,
3139 (unsigned long) sizeof(ElfW(Sym)));
3143 nsym = sec->header.sh_size / sizeof(ElfW(Sym));
3144 strtab = f->sections[sec->header.sh_link]->contents;
3145 sym = (ElfW(Sym) *) sec->contents;
3147 /* Allocate space for a table of local symbols. */
3148 j = f->local_symtab_size = sec->header.sh_info;
3149 f->local_symtab = xcalloc(j, sizeof(struct obj_symbol *));
3151 /* Insert all symbols into the hash table. */
3152 for (j = 1, ++sym; j < nsym; ++j, ++sym) {
3155 name = strtab + sym->st_name;
3157 name = f->sections[sym->st_shndx]->name;
3159 obj_add_symbol(f, name, j, sym->st_info, sym->st_shndx,
3160 sym->st_value, sym->st_size);
3166 if (sec->header.sh_entsize != sizeof(ElfW(RelM))) {
3167 error_msg("relocation entry size mismatch: %lu != %lu",
3168 (unsigned long) sec->header.sh_entsize,
3169 (unsigned long) sizeof(ElfW(RelM)));
3173 /* XXX Relocation code from modutils-2.3.19 is not here.
3174 * Why? That's about 20 lines of code from obj/obj_load.c,
3175 * which gets done in a second pass through the sections.
3176 * This BusyBox insmod does similar work in obj_relocate(). */
3183 #ifdef BB_FEATURE_INSMOD_LOADINKMEM
3185 * load the unloaded sections directly into the memory allocated by
3186 * kernel for the module
3189 int obj_load_progbits(FILE * fp, struct obj_file* f)
3191 char* imagebase = (char*) f->imagebase;
3192 ElfW(Addr) base = f->baseaddr;
3193 struct obj_section* sec;
3195 for (sec = f->load_order; sec; sec = sec->load_next) {
3197 /* section already loaded? */
3198 if (sec->contents != NULL)
3201 if (sec->header.sh_size == 0)
3204 sec->contents = imagebase + (sec->header.sh_addr - base);
3205 fseek(fp, sec->header.sh_offset, SEEK_SET);
3206 if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
3207 errorMsg("error reading ELF section data: %s\n", strerror(errno));
3216 static void hide_special_symbols(struct obj_file *f)
3218 static const char *const specials[] = {
3225 struct obj_symbol *sym;
3226 const char *const *p;
3228 for (p = specials; *p; ++p)
3229 if ((sym = obj_find_symbol(f, *p)) != NULL)
3231 ELFW(ST_INFO) (STB_LOCAL, ELFW(ST_TYPE) (sym->info));
3236 extern int insmod_main( int argc, char **argv)
3243 unsigned long m_size;
3248 char m_name[FILENAME_MAX + 1] = "\0";
3249 int exit_status = EXIT_FAILURE;
3251 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
3253 char k_strversion[STRVERSIONLEN];
3254 char m_strversion[STRVERSIONLEN];
3259 /* Parse any options */
3260 while ((opt = getopt(argc, argv, "fkvxLo:")) > 0) {
3262 case 'f': /* force loading */
3263 flag_force_load = 1;
3265 case 'k': /* module loaded by kerneld, auto-cleanable */
3268 case 'v': /* verbose output */
3271 case 'x': /* do not export externs */
3274 case 'o': /* name the output module */
3275 strncpy(m_name, optarg, FILENAME_MAX);
3277 case 'L': /* Stub warning */
3278 /* This is needed for compatibility with modprobe.
3279 * In theory, this does locking, but we don't do
3280 * that. So be careful and plan your life around not
3281 * loading the same module 50 times concurrently. */
3288 if (argv[optind] == NULL) {
3292 /* Grab the module name */
3293 if ((tmp = strrchr(argv[optind], '/')) != NULL) {
3300 if (len > 2 && tmp[len - 2] == '.' && tmp[len - 1] == 'o')
3302 memcpy(m_fullName, tmp, len);
3303 m_fullName[len]='\0';
3304 if (*m_name == '\0') {
3305 strcpy(m_name, m_fullName);
3307 strcat(m_fullName, ".o");
3309 /* Get a filedesc for the module. Check we we have a complete path */
3310 if (stat(argv[optind], &st) < 0 || !S_ISREG(st.st_mode) ||
3311 (fp = fopen(argv[optind], "r")) == NULL) {
3312 struct utsname myuname;
3314 /* Hmm. Could not open it. First search under /lib/modules/`uname -r`,
3315 * but do not error out yet if we fail to find it... */
3316 if (uname(&myuname) == 0) {
3317 char module_dir[FILENAME_MAX];
3318 char real_module_dir[FILENAME_MAX];
3319 snprintf (module_dir, sizeof(module_dir), "%s/%s",
3320 _PATH_MODULES, myuname.release);
3321 /* Jump through hoops in case /lib/modules/`uname -r`
3322 * is a symlink. We do not want recursive_action to
3323 * follow symlinks, but we do want to follow the
3324 * /lib/modules/`uname -r` dir, So resolve it ourselves
3325 * if it is a link... */
3326 if (realpath (module_dir, real_module_dir) == NULL)
3327 strcpy(real_module_dir, module_dir);
3328 recursive_action(real_module_dir, TRUE, FALSE, FALSE,
3329 check_module_name_match, 0, m_fullName);
3332 /* Check if we have found anything yet */
3333 if (m_filename[0] == '\0' || ((fp = fopen(m_filename, "r")) == NULL))
3335 char module_dir[FILENAME_MAX];
3336 if (realpath (_PATH_MODULES, module_dir) == NULL)
3337 strcpy(module_dir, _PATH_MODULES);
3338 /* No module found under /lib/modules/`uname -r`, this
3339 * time cast the net a bit wider. Search /lib/modules/ */
3340 if (recursive_action(module_dir, TRUE, FALSE, FALSE,
3341 check_module_name_match, 0, m_fullName) == FALSE)
3343 if (m_filename[0] == '\0'
3344 || ((fp = fopen(m_filename, "r")) == NULL))
3346 error_msg("%s: no module by that name found", m_fullName);
3347 return EXIT_FAILURE;
3350 error_msg_and_die("%s: no module by that name found", m_fullName);
3353 safe_strncpy(m_filename, argv[optind], sizeof(m_filename));
3355 printf("Using %s\n", m_filename);
3357 if ((f = obj_load(fp, LOADBITS)) == NULL)
3358 perror_msg_and_die("Could not load the module");
3360 if (get_modinfo_value(f, "kernel_version") == NULL)
3365 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
3366 /* Version correspondence? */
3368 k_version = get_kernel_version(k_strversion);
3369 if (m_has_modinfo) {
3370 m_version = new_get_module_version(f, m_strversion);
3372 m_version = old_get_module_version(f, m_strversion);
3373 if (m_version == -1) {
3374 error_msg("couldn't find the kernel version the module was "
3380 if (strncmp(k_strversion, m_strversion, STRVERSIONLEN) != 0) {
3381 if (flag_force_load) {
3382 error_msg("Warning: 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);
3387 error_msg("kernel-module version mismatch\n"
3388 "\t%s was compiled for kernel version %s\n"
3389 "\twhile this kernel is version %s.",
3390 m_filename, m_strversion, k_strversion);
3395 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
3397 k_new_syscalls = !query_module(NULL, 0, NULL, 0, NULL);
3399 if (k_new_syscalls) {
3400 #ifdef BB_FEATURE_NEW_MODULE_INTERFACE
3401 if (!new_get_kernel_symbols())
3403 k_crcs = new_is_kernel_checksummed();
3405 error_msg("Not configured to support new kernels");
3409 #ifdef BB_FEATURE_OLD_MODULE_INTERFACE
3410 if (!old_get_kernel_symbols(m_name))
3412 k_crcs = old_is_kernel_checksummed();
3414 error_msg("Not configured to support old kernels");
3419 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
3421 m_crcs = new_is_module_checksummed(f);
3423 m_crcs = old_is_module_checksummed(f);
3425 if (m_crcs != k_crcs)
3426 obj_set_symbol_compare(f, ncv_strcmp, ncv_symbol_hash);
3427 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
3429 /* Let the module know about the kernel symbols. */
3430 add_kernel_symbols(f);
3432 /* Allocate common symbols, symbol tables, and string tables. */
3435 ? !new_create_this_module(f, m_name)
3436 : !old_create_mod_use_count(f))
3441 if (!obj_check_undefineds(f)) {
3444 obj_allocate_commons(f);
3446 /* done with the module name, on to the optional var=value arguments */
3449 if (optind < argc) {
3451 ? !new_process_module_arguments(f, argc - optind, argv + optind)
3452 : !old_process_module_arguments(f, argc - optind, argv + optind))
3459 hide_special_symbols(f);
3462 new_create_module_ksymtab(f);
3464 /* Find current size of the module */
3465 m_size = obj_load_size(f);
3468 m_addr = create_module(m_name, m_size);
3469 if (m_addr==-1) switch (errno) {
3471 error_msg("A module named %s already exists", m_name);
3474 error_msg("Can't allocate kernel memory for module; needed %lu bytes",
3478 perror_msg("create_module: %s", m_name);
3484 * the PROGBITS section was not loaded by the obj_load
3485 * now we can load them directly into the kernel memory
3487 // f->imagebase = (char*) m_addr;
3488 f->imagebase = (ElfW(Addr)) m_addr;
3489 if (!obj_load_progbits(fp, f)) {
3490 delete_module(m_name);
3495 if (!obj_relocate(f, m_addr)) {
3496 delete_module(m_name);
3501 ? !new_init_module(m_name, f, m_size)
3502 : !old_init_module(m_name, f, m_size))
3504 delete_module(m_name);
3508 exit_status = EXIT_SUCCESS;
3512 return(exit_status);