1 /* vi: set sw=4 ts=4: */
3 * Mini insmod implementation for busybox
5 * This version of insmod supports ARM, CRIS, H8/300, x86, ia64, x86_64,
6 * m68k, MIPS, PowerPC, S390, SH3/4/5, Sparc, v850e, and x86_64.
8 * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
9 * and Ron Alder <alder@lineo.com>
11 * Rodney Radford <rradford@mindspring.com> 17-Aug-2004.
12 * Added x86_64 support.
14 * Miles Bader <miles@gnu.org> added NEC V850E support.
16 * Modified by Bryan Rittmeyer <bryan@ixiacom.com> to support SH4
17 * and (theoretically) SH3. I have only tested SH4 in little endian mode.
19 * Modified by Alcove, Julien Gaulmin <julien.gaulmin@alcove.fr> and
20 * Nicolas Ferre <nicolas.ferre@alcove.fr> to support ARM7TDMI. Only
21 * very minor changes required to also work with StrongArm and presumably
22 * all ARM based systems.
24 * Yoshinori Sato <ysato@users.sourceforge.jp> 19-May-2004.
25 * added Renesas H8/300 support.
27 * Paul Mundt <lethal@linux-sh.org> 08-Aug-2003.
28 * Integrated support for sh64 (SH-5), from preliminary modutils
29 * patches from Benedict Gaster <benedict.gaster@superh.com>.
30 * Currently limited to support for 32bit ABI.
32 * Magnus Damm <damm@opensource.se> 22-May-2002.
33 * The plt and got code are now using the same structs.
34 * Added generic linked list code to fully support PowerPC.
35 * Replaced the mess in arch_apply_relocation() with architecture blocks.
36 * The arch_create_got() function got cleaned up with architecture blocks.
37 * These blocks should be easy maintain and sync with obj_xxx.c in modutils.
39 * Magnus Damm <damm@opensource.se> added PowerPC support 20-Feb-2001.
40 * PowerPC specific code stolen from modutils-2.3.16,
41 * written by Paul Mackerras, Copyright 1996, 1997 Linux International.
42 * I've only tested the code on mpc8xx platforms in big-endian mode.
43 * Did some cleanup and added USE_xxx_ENTRIES...
45 * Quinn Jensen <jensenq@lineo.com> added MIPS support 23-Feb-2001.
46 * based on modutils-2.4.2
47 * MIPS specific support for Elf loading and relocation.
48 * Copyright 1996, 1997 Linux International.
49 * Contributed by Ralf Baechle <ralf@gnu.ai.mit.edu>
51 * Based almost entirely on the Linux modutils-2.3.11 implementation.
52 * Copyright 1996, 1997 Linux International.
53 * New implementation contributed by Richard Henderson <rth@tamu.edu>
54 * Based on original work by Bjorn Ekwall <bj0rn@blox.se>
55 * Restructured (and partly rewritten) by:
56 * Björn Ekwall <bj0rn@blox.se> February 1999
58 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
64 #include <sys/utsname.h>
66 #if ENABLE_FEATURE_INSMOD_LOADINKMEM
73 #if defined(__alpha__)
74 #define MATCH_MACHINE(x) (x == EM_ALPHA)
75 #define SHT_RELM SHT_RELA
76 #define Elf64_RelM Elf64_Rela
77 #define ELFCLASSM ELFCLASS64
82 #define MATCH_MACHINE(x) (x == EM_ARM)
83 #define SHT_RELM SHT_REL
84 #define Elf32_RelM Elf32_Rel
85 #define ELFCLASSM ELFCLASS32
86 #define USE_PLT_ENTRIES
87 #define PLT_ENTRY_SIZE 8
88 #define USE_GOT_ENTRIES
89 #define GOT_ENTRY_SIZE 8
95 #define MATCH_MACHINE(x) (x == EM_BLACKFIN)
96 #define SHT_RELM SHT_RELA
97 #define Elf32_RelM Elf32_Rela
98 #define ELFCLASSM ELFCLASS32
102 #if defined(__cris__)
103 #define MATCH_MACHINE(x) (x == EM_CRIS)
104 #define SHT_RELM SHT_RELA
105 #define Elf32_RelM Elf32_Rela
106 #define ELFCLASSM ELFCLASS32
109 #define R_CRIS_NONE 0
115 #if defined(__H8300H__) || defined(__H8300S__)
116 #define MATCH_MACHINE(x) (x == EM_H8_300)
117 #define SHT_RELM SHT_RELA
118 #define Elf32_RelM Elf32_Rela
119 #define ELFCLASSM ELFCLASS32
121 #define SYMBOL_PREFIX "_"
124 /* PA-RISC / HP-PA */
125 #if defined(__hppa__)
126 #define MATCH_MACHINE(x) (x == EM_PARISC)
127 #define SHT_RELM SHT_RELA
128 #if defined(__LP64__)
129 #define Elf64_RelM Elf64_Rela
130 #define ELFCLASSM ELFCLASS64
132 #define Elf32_RelM Elf32_Rela
133 #define ELFCLASSM ELFCLASS32
138 #if defined(__i386__)
140 #define MATCH_MACHINE(x) (x == EM_386)
142 #define MATCH_MACHINE(x) (x == EM_386 || x == EM_486)
144 #define SHT_RELM SHT_REL
145 #define Elf32_RelM Elf32_Rel
146 #define ELFCLASSM ELFCLASS32
147 #define USE_GOT_ENTRIES
148 #define GOT_ENTRY_SIZE 4
152 /* IA64, aka Itanium */
153 #if defined(__ia64__)
154 #define MATCH_MACHINE(x) (x == EM_IA_64)
155 #define SHT_RELM SHT_RELA
156 #define Elf64_RelM Elf64_Rela
157 #define ELFCLASSM ELFCLASS64
161 #if defined(__mc68000__)
162 #define MATCH_MACHINE(x) (x == EM_68K)
163 #define SHT_RELM SHT_RELA
164 #define Elf32_RelM Elf32_Rela
165 #define ELFCLASSM ELFCLASS32
166 #define USE_GOT_ENTRIES
167 #define GOT_ENTRY_SIZE 4
172 #if defined(__microblaze__)
174 #include <linux/elf-em.h>
175 #define MATCH_MACHINE(x) (x == EM_XILINX_MICROBLAZE)
176 #define SHT_RELM SHT_RELA
177 #define Elf32_RelM Elf32_Rela
178 #define ELFCLASSM ELFCLASS32
182 #if defined(__mips__)
183 #define MATCH_MACHINE(x) (x == EM_MIPS || x == EM_MIPS_RS3_LE)
184 #define SHT_RELM SHT_REL
185 #define Elf32_RelM Elf32_Rel
186 #define ELFCLASSM ELFCLASS32
187 /* Account for ELF spec changes. */
188 #ifndef EM_MIPS_RS3_LE
189 #ifdef EM_MIPS_RS4_BE
190 #define EM_MIPS_RS3_LE EM_MIPS_RS4_BE
192 #define EM_MIPS_RS3_LE 10
194 #endif /* !EM_MIPS_RS3_LE */
195 #define ARCHDATAM "__dbe_table"
199 #if defined(__nios2__)
200 #define MATCH_MACHINE(x) (x == EM_ALTERA_NIOS2)
201 #define SHT_RELM SHT_RELA
202 #define Elf32_RelM Elf32_Rela
203 #define ELFCLASSM ELFCLASS32
207 #if defined(__powerpc64__)
208 #define MATCH_MACHINE(x) (x == EM_PPC64)
209 #define SHT_RELM SHT_RELA
210 #define Elf64_RelM Elf64_Rela
211 #define ELFCLASSM ELFCLASS64
212 #elif defined(__powerpc__)
213 #define MATCH_MACHINE(x) (x == EM_PPC)
214 #define SHT_RELM SHT_RELA
215 #define Elf32_RelM Elf32_Rela
216 #define ELFCLASSM ELFCLASS32
217 #define USE_PLT_ENTRIES
218 #define PLT_ENTRY_SIZE 16
220 #define LIST_ARCHTYPE ElfW(Addr)
222 #define ARCHDATAM "__ftr_fixup"
226 #if defined(__s390__)
227 #define MATCH_MACHINE(x) (x == EM_S390)
228 #define SHT_RELM SHT_RELA
229 #define Elf32_RelM Elf32_Rela
230 #define ELFCLASSM ELFCLASS32
231 #define USE_PLT_ENTRIES
232 #define PLT_ENTRY_SIZE 8
233 #define USE_GOT_ENTRIES
234 #define GOT_ENTRY_SIZE 8
240 #define MATCH_MACHINE(x) (x == EM_SH)
241 #define SHT_RELM SHT_RELA
242 #define Elf32_RelM Elf32_Rela
243 #define ELFCLASSM ELFCLASS32
244 #define USE_GOT_ENTRIES
245 #define GOT_ENTRY_SIZE 4
247 /* the SH changes have only been tested in =little endian= mode */
248 /* I'm not sure about big endian, so let's warn: */
249 #if defined(__sh__) && BB_BIG_ENDIAN
250 # error insmod.c may require changes for use on big endian SH
252 /* it may or may not work on the SH1/SH2... Error on those also */
253 #if ((!(defined(__SH3__) || defined(__SH4__) || defined(__SH5__)))) && (defined(__sh__))
254 #error insmod.c may require changes for SH1 or SH2 use
259 #if defined(__sparc__)
260 #define MATCH_MACHINE(x) (x == EM_SPARC)
261 #define SHT_RELM SHT_RELA
262 #define Elf32_RelM Elf32_Rela
263 #define ELFCLASSM ELFCLASS32
267 #if defined(__v850e__)
268 #define MATCH_MACHINE(x) ((x) == EM_V850 || (x) == EM_CYGNUS_V850)
269 #define SHT_RELM SHT_RELA
270 #define Elf32_RelM Elf32_Rela
271 #define ELFCLASSM ELFCLASS32
272 #define USE_PLT_ENTRIES
273 #define PLT_ENTRY_SIZE 8
275 #ifndef EM_CYGNUS_V850 /* grumble */
276 #define EM_CYGNUS_V850 0x9080
278 #define SYMBOL_PREFIX "_"
282 #if defined(__x86_64__)
283 #define MATCH_MACHINE(x) (x == EM_X86_64)
284 #define SHT_RELM SHT_RELA
285 #define USE_GOT_ENTRIES
286 #define GOT_ENTRY_SIZE 8
288 #define Elf64_RelM Elf64_Rela
289 #define ELFCLASSM ELFCLASS64
293 #error Sorry, but insmod.c does not yet support this architecture...
297 //----------------------------------------------------------------------------
298 //--------modutils module.h, lines 45-242
299 //----------------------------------------------------------------------------
301 /* Definitions for the Linux module syscall interface.
302 Copyright 1996, 1997 Linux International.
304 Contributed by Richard Henderson <rth@tamu.edu>
306 This file is part of the Linux modutils.
308 This program is free software; you can redistribute it and/or modify it
309 under the terms of the GNU General Public License as published by the
310 Free Software Foundation; either version 2 of the License, or (at your
311 option) any later version.
313 This program is distributed in the hope that it will be useful, but
314 WITHOUT ANY WARRANTY; without even the implied warranty of
315 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
316 General Public License for more details.
318 You should have received a copy of the GNU General Public License
319 along with this program; if not, write to the Free Software Foundation,
320 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
323 #ifndef MODUTILS_MODULE_H
325 /*======================================================================*/
326 /* For sizeof() which are related to the module platform and not to the
327 environment isnmod is running in, use sizeof_xx instead of sizeof(xx). */
329 #define tgt_sizeof_char sizeof(char)
330 #define tgt_sizeof_short sizeof(short)
331 #define tgt_sizeof_int sizeof(int)
332 #define tgt_sizeof_long sizeof(long)
333 #define tgt_sizeof_char_p sizeof(char *)
334 #define tgt_sizeof_void_p sizeof(void *)
335 #define tgt_long long
337 #if defined(__sparc__) && !defined(__sparc_v9__) && defined(ARCH_sparc64)
338 #undef tgt_sizeof_long
339 #undef tgt_sizeof_char_p
340 #undef tgt_sizeof_void_p
344 tgt_sizeof_char_p = 8,
345 tgt_sizeof_void_p = 8
347 #define tgt_long long long
350 /*======================================================================*/
351 /* The structures used in Linux 2.1. */
353 /* Note: new_module_symbol does not use tgt_long intentionally */
354 struct new_module_symbol {
359 struct new_module_persist;
361 struct new_module_ref {
362 unsigned tgt_long dep; /* kernel addresses */
363 unsigned tgt_long ref;
364 unsigned tgt_long next_ref;
368 unsigned tgt_long size_of_struct; /* == sizeof(module) */
369 unsigned tgt_long next;
370 unsigned tgt_long name;
371 unsigned tgt_long size;
374 unsigned tgt_long flags; /* AUTOCLEAN et al */
379 unsigned tgt_long syms;
380 unsigned tgt_long deps;
381 unsigned tgt_long refs;
382 unsigned tgt_long init;
383 unsigned tgt_long cleanup;
384 unsigned tgt_long ex_table_start;
385 unsigned tgt_long ex_table_end;
387 unsigned tgt_long gp;
389 /* Everything after here is extension. */
390 unsigned tgt_long persist_start;
391 unsigned tgt_long persist_end;
392 unsigned tgt_long can_unload;
393 unsigned tgt_long runsize;
394 const char *kallsyms_start; /* All symbols for kernel debugging */
395 const char *kallsyms_end;
396 const char *archdata_start; /* arch specific data for module */
397 const char *archdata_end;
398 const char *kernel_data; /* Reserved for kernel internal use */
402 #define ARCHDATA_SEC_NAME ARCHDATAM
404 #define ARCHDATA_SEC_NAME "__archdata"
406 #define KALLSYMS_SEC_NAME "__kallsyms"
409 struct new_module_info {
416 /* Bits of module.flags. */
420 NEW_MOD_AUTOCLEAN = 4,
422 NEW_MOD_USED_ONCE = 16
425 int init_module(const char *name, const struct new_module *);
426 int query_module(const char *name, int which, void *buf,
427 size_t bufsize, size_t *ret);
429 /* Values for query_module's which. */
438 /*======================================================================*/
439 /* The system calls unchanged between 2.0 and 2.1. */
441 unsigned long create_module(const char *, size_t);
442 int delete_module(const char *module, unsigned int flags);
445 #endif /* module.h */
447 //----------------------------------------------------------------------------
448 //--------end of modutils module.h
449 //----------------------------------------------------------------------------
453 //----------------------------------------------------------------------------
454 //--------modutils obj.h, lines 253-462
455 //----------------------------------------------------------------------------
457 /* Elf object file loading and relocation routines.
458 Copyright 1996, 1997 Linux International.
460 Contributed by Richard Henderson <rth@tamu.edu>
462 This file is part of the Linux modutils.
464 This program is free software; you can redistribute it and/or modify it
465 under the terms of the GNU General Public License as published by the
466 Free Software Foundation; either version 2 of the License, or (at your
467 option) any later version.
469 This program is distributed in the hope that it will be useful, but
470 WITHOUT ANY WARRANTY; without even the implied warranty of
471 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
472 General Public License for more details.
474 You should have received a copy of the GNU General Public License
475 along with this program; if not, write to the Free Software Foundation,
476 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
479 #ifndef MODUTILS_OBJ_H
481 /* The relocatable object is manipulated using elfin types. */
487 # if ELFCLASSM == ELFCLASS32
488 # define ElfW(x) Elf32_ ## x
489 # define ELFW(x) ELF32_ ## x
491 # define ElfW(x) Elf64_ ## x
492 # define ELFW(x) ELF64_ ## x
496 /* For some reason this is missing from some ancient C libraries.... */
497 #ifndef ELF32_ST_INFO
498 # define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
501 #ifndef ELF64_ST_INFO
502 # define ELF64_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
505 #define ELF_ST_BIND(info) ELFW(ST_BIND)(info)
506 #define ELF_ST_TYPE(info) ELFW(ST_TYPE)(info)
507 #define ELF_ST_INFO(bind, type) ELFW(ST_INFO)(bind, type)
508 #define ELF_R_TYPE(val) ELFW(R_TYPE)(val)
509 #define ELF_R_SYM(val) ELFW(R_SYM)(val)
511 struct obj_string_patch;
512 struct obj_symbol_patch;
519 struct obj_section *load_next;
525 struct obj_symbol *next; /* hash table link */
529 int secidx; /* the defining section index/module */
531 int ksymidx; /* for export to the kernel symtab */
532 int referenced; /* actually used in the link */
535 /* Hardcode the hash table size. We shouldn't be needing so many
536 symbols that we begin to degrade performance, and we get a big win
537 by giving the compiler a constant divisor. */
539 #define HASH_BUCKETS 521
544 struct obj_section **sections;
545 struct obj_section *load_order;
546 struct obj_section **load_order_search_start;
547 struct obj_string_patch *string_patches;
548 struct obj_symbol_patch *symbol_patches;
549 int (*symbol_cmp)(const char *, const char *);
550 unsigned long (*symbol_hash)(const char *);
551 unsigned long local_symtab_size;
552 struct obj_symbol **local_symtab;
553 struct obj_symbol *symtab[HASH_BUCKETS];
563 struct obj_string_patch {
564 struct obj_string_patch *next;
566 ElfW(Addr) reloc_offset;
567 ElfW(Addr) string_offset;
570 struct obj_symbol_patch {
571 struct obj_symbol_patch *next;
573 ElfW(Addr) reloc_offset;
574 struct obj_symbol *sym;
578 /* Generic object manipulation routines. */
580 static unsigned long obj_elf_hash(const char *);
582 static unsigned long obj_elf_hash_n(const char *, unsigned long len);
584 static struct obj_symbol *obj_find_symbol(struct obj_file *f,
587 static ElfW(Addr) obj_symbol_final_value(struct obj_file *f,
588 struct obj_symbol *sym);
590 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
591 static void obj_set_symbol_compare(struct obj_file *f,
592 int (*cmp)(const char *, const char *),
593 unsigned long (*hash)(const char *));
596 static struct obj_section *obj_find_section(struct obj_file *f,
599 static void obj_insert_section_load_order(struct obj_file *f,
600 struct obj_section *sec);
602 static struct obj_section *obj_create_alloced_section(struct obj_file *f,
607 static struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
612 static void *obj_extend_section(struct obj_section *sec, unsigned long more);
614 static void obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
617 static void obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
618 struct obj_symbol *sym);
620 static void obj_check_undefineds(struct obj_file *f);
622 static void obj_allocate_commons(struct obj_file *f);
624 static unsigned long obj_load_size(struct obj_file *f);
626 static int obj_relocate(struct obj_file *f, ElfW(Addr) base);
628 static struct obj_file *obj_load(FILE *f, int loadprogbits);
630 static int obj_create_image(struct obj_file *f, char *image);
632 /* Architecture specific manipulation routines. */
634 static struct obj_file *arch_new_file(void);
636 static struct obj_section *arch_new_section(void);
638 static struct obj_symbol *arch_new_symbol(void);
640 static enum obj_reloc arch_apply_relocation(struct obj_file *f,
641 struct obj_section *targsec,
642 /*struct obj_section *symsec,*/
643 struct obj_symbol *sym,
644 ElfW(RelM) *rel, ElfW(Addr) value);
646 static void arch_create_got(struct obj_file *f);
647 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
648 static int obj_gpl_license(struct obj_file *f, const char **license);
649 #endif /* FEATURE_CHECK_TAINTED_MODULE */
651 //----------------------------------------------------------------------------
652 //--------end of modutils obj.h
653 //----------------------------------------------------------------------------
656 /* SPFX is always a string, so it can be concatenated to string constants. */
658 #define SPFX SYMBOL_PREFIX
663 enum { STRVERSIONLEN = 64 };
665 /*======================================================================*/
667 #define flag_force_load (option_mask32 & INSMOD_OPT_FORCE)
668 #define flag_autoclean (option_mask32 & INSMOD_OPT_KERNELD)
669 #define flag_verbose (option_mask32 & INSMOD_OPT_VERBOSE)
670 #define flag_quiet (option_mask32 & INSMOD_OPT_SILENT)
671 #define flag_noexport (option_mask32 & INSMOD_OPT_NO_EXPORT)
672 #define flag_print_load_map (option_mask32 & INSMOD_OPT_PRINT_MAP)
674 /*======================================================================*/
676 #if defined(USE_LIST)
678 struct arch_list_entry
680 struct arch_list_entry *next;
681 LIST_ARCHTYPE addend;
688 #if defined(USE_SINGLE)
690 struct arch_single_entry
699 #if defined(__mips__)
702 struct mips_hi16 *next;
709 struct obj_file root;
710 #if defined(USE_PLT_ENTRIES)
711 struct obj_section *plt;
713 #if defined(USE_GOT_ENTRIES)
714 struct obj_section *got;
716 #if defined(__mips__)
717 struct mips_hi16 *mips_hi16_list;
722 struct obj_symbol root;
723 #if defined(USE_PLT_ENTRIES)
724 #if defined(USE_PLT_LIST)
725 struct arch_list_entry *pltent;
727 struct arch_single_entry pltent;
730 #if defined(USE_GOT_ENTRIES)
731 struct arch_single_entry gotent;
736 struct external_module {
741 struct new_module_symbol *syms;
744 static struct new_module_symbol *ksyms;
745 static size_t nksyms;
747 static struct external_module *ext_modules;
748 static int n_ext_modules;
749 static int n_ext_modules_used;
751 /*======================================================================*/
754 static struct obj_file *arch_new_file(void)
757 f = xzalloc(sizeof(*f));
758 return &f->root; /* it's a first member */
761 static struct obj_section *arch_new_section(void)
763 return xzalloc(sizeof(struct obj_section));
766 static struct obj_symbol *arch_new_symbol(void)
768 struct arch_symbol *sym;
769 sym = xzalloc(sizeof(*sym));
773 static enum obj_reloc
774 arch_apply_relocation(struct obj_file *f,
775 struct obj_section *targsec,
776 /*struct obj_section *symsec,*/
777 struct obj_symbol *sym,
778 ElfW(RelM) *rel, ElfW(Addr) v)
780 #if defined(__arm__) || defined(__i386__) || defined(__mc68000__) \
781 || defined(__sh__) || defined(__s390__) || defined(__x86_64__) \
782 || defined(__powerpc__) || defined(__mips__)
783 struct arch_file *ifile = (struct arch_file *) f;
785 enum obj_reloc ret = obj_reloc_ok;
786 ElfW(Addr) *loc = (ElfW(Addr) *) (targsec->contents + rel->r_offset);
787 #if defined(__arm__) || defined(__H8300H__) || defined(__H8300S__) \
788 || defined(__i386__) || defined(__mc68000__) || defined(__microblaze__) \
789 || defined(__mips__) || defined(__nios2__) || defined(__powerpc__) \
790 || defined(__s390__) || defined(__sh__) || defined(__x86_64__)
791 ElfW(Addr) dot = targsec->header.sh_addr + rel->r_offset;
793 #if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
794 struct arch_symbol *isym = (struct arch_symbol *) sym;
796 #if defined(__arm__) || defined(__i386__) || defined(__mc68000__) \
797 || defined(__sh__) || defined(__s390__)
798 #if defined(USE_GOT_ENTRIES)
799 ElfW(Addr) got = ifile->got ? ifile->got->header.sh_addr : 0;
802 #if defined(USE_PLT_ENTRIES)
803 ElfW(Addr) plt = ifile->plt ? ifile->plt->header.sh_addr : 0;
805 # if defined(USE_PLT_LIST)
806 struct arch_list_entry *pe;
808 struct arch_single_entry *pe;
812 switch (ELF_R_TYPE(rel->r_info)) {
827 /* relative reloc, always to _GLOBAL_OFFSET_TABLE_
828 * (which is .got) similar to branch,
829 * but is full 32 bits relative */
838 case R_ARM_GOTOFF: /* address relative to the got */
842 #elif defined(__cris__)
848 /* CRIS keeps the relocation value in the r_addend field and
849 * should not use whats in *loc at all
854 #elif defined(__H8300H__) || defined(__H8300S__)
857 loc = (ElfW(Addr) *)((ElfW(Addr))loc - 1);
858 *loc = (*loc & 0xff000000) | ((*loc & 0xffffff) + v);
869 if ((ElfW(Sword))v > 0x7fff ||
870 (ElfW(Sword))v < -(ElfW(Sword))0x8000)
871 ret = obj_reloc_overflow;
873 *(unsigned short *)loc = v;
877 if ((ElfW(Sword))v > 0x7f ||
878 (ElfW(Sword))v < -(ElfW(Sword))0x80)
879 ret = obj_reloc_overflow;
881 *(unsigned char *)loc = v;
884 #elif defined(__i386__)
916 #elif defined(__microblaze__)
917 case R_MICROBLAZE_NONE:
918 case R_MICROBLAZE_64_NONE:
919 case R_MICROBLAZE_32_SYM_OP_SYM:
920 case R_MICROBLAZE_32_PCREL:
923 case R_MICROBLAZE_64_PCREL: {
924 /* dot is the address of the current instruction.
925 * v is the target symbol address.
926 * So we need to extract the offset in the code,
927 * adding v, then subtrating the current address
928 * of this instruction.
929 * Ex: "IMM 0xFFFE bralid 0x0000" = "bralid 0xFFFE0000"
932 /* Get split offset stored in code */
933 unsigned int temp = (loc[0] & 0xFFFF) << 16 |
936 /* Adjust relative offset. -4 adjustment required
937 * because dot points to the IMM insn, but branch
938 * is computed relative to the branch instruction itself.
942 /* Store back into code */
943 loc[0] = (loc[0] & 0xFFFF0000) | temp >> 16;
944 loc[1] = (loc[1] & 0xFFFF0000) | (temp & 0xFFFF);
949 case R_MICROBLAZE_32:
953 case R_MICROBLAZE_64: {
954 /* Get split pointer stored in code */
955 unsigned int temp1 = (loc[0] & 0xFFFF) << 16 |
958 /* Add reloc offset */
961 /* Store back into code */
962 loc[0] = (loc[0] & 0xFFFF0000) | temp1 >> 16;
963 loc[1] = (loc[1] & 0xFFFF0000) | (temp1 & 0xFFFF);
968 case R_MICROBLAZE_32_PCREL_LO:
969 case R_MICROBLAZE_32_LO:
970 case R_MICROBLAZE_SRO32:
971 case R_MICROBLAZE_SRW32:
972 ret = obj_reloc_unhandled;
975 #elif defined(__mc68000__)
986 ret = obj_reloc_overflow;
993 ret = obj_reloc_overflow;
1000 if ((ElfW(Sword))v > 0x7f ||
1001 (ElfW(Sword))v < -(ElfW(Sword))0x80) {
1002 ret = obj_reloc_overflow;
1009 if ((ElfW(Sword))v > 0x7fff ||
1010 (ElfW(Sword))v < -(ElfW(Sword))0x8000) {
1011 ret = obj_reloc_overflow;
1017 *(int *)loc = v - dot;
1020 case R_68K_GLOB_DAT:
1021 case R_68K_JMP_SLOT:
1025 case R_68K_RELATIVE:
1026 *(int *)loc += f->baseaddr;
1032 # ifdef R_68K_GOTOFF
1038 #elif defined(__mips__)
1049 ret = obj_reloc_dangerous;
1050 if ((v & 0xf0000000) != ((dot + 4) & 0xf0000000))
1051 ret = obj_reloc_overflow;
1053 (*loc & ~0x03ffffff) | ((*loc + (v >> 2)) &
1059 struct mips_hi16 *n;
1061 /* We cannot relocate this one now because we don't know the value
1062 of the carry we need to add. Save the information, and let LO16
1063 do the actual relocation. */
1064 n = xmalloc(sizeof *n);
1067 n->next = ifile->mips_hi16_list;
1068 ifile->mips_hi16_list = n;
1074 unsigned long insnlo = *loc;
1075 ElfW(Addr) val, vallo;
1077 /* Sign extend the addend we extract from the lo insn. */
1078 vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
1080 if (ifile->mips_hi16_list != NULL) {
1081 struct mips_hi16 *l;
1083 l = ifile->mips_hi16_list;
1085 struct mips_hi16 *next;
1088 /* Do the HI16 relocation. Note that we actually don't
1089 need to know anything about the LO16 itself, except where
1090 to find the low 16 bits of the addend needed by the LO16. */
1093 ((insn & 0xffff) << 16) +
1097 /* Account for the sign extension that will happen in the
1104 insn = (insn & ~0xffff) | val;
1112 ifile->mips_hi16_list = NULL;
1115 /* Ok, we're done with the HI16 relocs. Now deal with the LO16. */
1117 insnlo = (insnlo & ~0xffff) | (val & 0xffff);
1122 #elif defined(__nios2__)
1127 case R_NIOS2_BFD_RELOC_32:
1131 case R_NIOS2_BFD_RELOC_16:
1133 ret = obj_reloc_overflow;
1138 case R_NIOS2_BFD_RELOC_8:
1140 ret = obj_reloc_overflow;
1149 if ((Elf32_Sword)v > 0x7fff ||
1150 (Elf32_Sword)v < -(Elf32_Sword)0x8000) {
1151 ret = obj_reloc_overflow;
1155 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1165 ret = obj_reloc_overflow;
1169 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1174 case R_NIOS2_PCREL16:
1179 if ((Elf32_Sword)v > 0x7fff ||
1180 (Elf32_Sword)v < -(Elf32_Sword)0x8000) {
1181 ret = obj_reloc_overflow;
1185 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) | (word & 0x3f);
1191 Elf32_Addr word, gp;
1193 gp = obj_symbol_final_value(f, obj_find_symbol(f, SPFX "_gp"));
1195 if ((Elf32_Sword)v > 0x7fff ||
1196 (Elf32_Sword)v < -(Elf32_Sword)0x8000) {
1197 ret = obj_reloc_overflow;
1201 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) | (word & 0x3f);
1205 case R_NIOS2_CALL26:
1207 ret = obj_reloc_dangerous;
1208 if ((v >> 28) != (dot >> 28))
1209 ret = obj_reloc_overflow;
1210 *loc = (*loc & 0x3f) | ((v >> 2) << 6);
1218 ret = obj_reloc_overflow;
1221 word = *loc & ~0x7c0;
1222 *loc = word | ((v & 0x1f) << 6);
1231 ret = obj_reloc_overflow;
1234 word = *loc & ~0xfc0;
1235 *loc = word | ((v & 0x3f) << 6);
1244 ret = obj_reloc_overflow;
1247 word = *loc & ~0x3fc0;
1248 *loc = word | ((v & 0xff) << 6);
1257 *loc = ((((word >> 22) << 16) | ((v >>16) & 0xffff)) << 6) |
1267 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1272 case R_NIOS2_HIADJ16:
1274 Elf32_Addr word1, word2;
1277 word2 = ((v >> 16) + ((v >> 15) & 1)) & 0xffff;
1278 *loc = ((((word1 >> 22) << 16) | word2) << 6) |
1283 #elif defined(__powerpc64__)
1284 /* PPC64 needs a 2.6 kernel, 2.4 module relocation irrelevant */
1286 #elif defined(__powerpc__)
1288 case R_PPC_ADDR16_HA:
1289 *(unsigned short *)loc = (v + 0x8000) >> 16;
1292 case R_PPC_ADDR16_HI:
1293 *(unsigned short *)loc = v >> 16;
1296 case R_PPC_ADDR16_LO:
1297 *(unsigned short *)loc = v;
1311 #elif defined(__s390__)
1314 *(unsigned int *) loc += v;
1317 *(unsigned short *) loc += v;
1320 *(unsigned char *) loc += v;
1324 *(unsigned int *) loc += v - dot;
1327 *(unsigned short *) loc += (v - dot) >> 1;
1330 *(unsigned short *) loc += v - dot;
1334 case R_390_PLT16DBL:
1335 /* find the plt entry and initialize it. */
1336 pe = (struct arch_single_entry *) &isym->pltent;
1337 if (pe->inited == 0) {
1338 ip = (unsigned long *)(ifile->plt->contents + pe->offset);
1339 ip[0] = 0x0d105810; /* basr 1,0; lg 1,10(1); br 1 */
1341 if (ELF_R_TYPE(rel->r_info) == R_390_PLT16DBL)
1348 /* Insert relative distance to target. */
1349 v = plt + pe->offset - dot;
1350 if (ELF_R_TYPE(rel->r_info) == R_390_PLT32)
1351 *(unsigned int *) loc = (unsigned int) v;
1352 else if (ELF_R_TYPE(rel->r_info) == R_390_PLT16DBL)
1353 *(unsigned short *) loc = (unsigned short) ((v + 2) >> 1);
1356 case R_390_GLOB_DAT:
1357 case R_390_JMP_SLOT:
1361 case R_390_RELATIVE:
1362 *loc += f->baseaddr;
1366 *(unsigned long *) loc += got - dot;
1372 if (!isym->gotent.inited)
1374 isym->gotent.inited = 1;
1375 *(ElfW(Addr) *)(ifile->got->contents + isym->gotent.offset) = v;
1377 if (ELF_R_TYPE(rel->r_info) == R_390_GOT12)
1378 *(unsigned short *) loc |= (*(unsigned short *) loc + isym->gotent.offset) & 0xfff;
1379 else if (ELF_R_TYPE(rel->r_info) == R_390_GOT16)
1380 *(unsigned short *) loc += isym->gotent.offset;
1381 else if (ELF_R_TYPE(rel->r_info) == R_390_GOT32)
1382 *(unsigned int *) loc += isym->gotent.offset;
1385 # ifndef R_390_GOTOFF32
1386 # define R_390_GOTOFF32 R_390_GOTOFF
1388 case R_390_GOTOFF32:
1392 #elif defined(__sh__)
1415 *loc = f->baseaddr + rel->r_addend;
1419 *loc = got - dot + rel->r_addend;
1429 # if defined(__SH5__)
1430 case R_SH_IMM_MEDLOW16:
1431 case R_SH_IMM_LOW16:
1435 if (ELF_R_TYPE(rel->r_info) == R_SH_IMM_MEDLOW16)
1439 * movi and shori have the format:
1441 * | op | imm | reg | reserved |
1442 * 31..26 25..10 9.. 4 3 .. 0
1444 * so we simply mask and or in imm.
1446 word = *loc & ~0x3fffc00;
1447 word |= (v & 0xffff) << 10;
1454 case R_SH_IMM_MEDLOW16_PCREL:
1455 case R_SH_IMM_LOW16_PCREL:
1459 word = *loc & ~0x3fffc00;
1463 if (ELF_R_TYPE(rel->r_info) == R_SH_IMM_MEDLOW16_PCREL)
1466 word |= (v & 0xffff) << 10;
1472 # endif /* __SH5__ */
1474 #elif defined(__v850e__)
1480 /* We write two shorts instead of a long because even
1481 32-bit insns only need half-word alignment, but
1482 32-bit data needs to be long-word aligned. */
1483 v += ((unsigned short *)loc)[0];
1484 v += ((unsigned short *)loc)[1] << 16;
1485 ((unsigned short *)loc)[0] = v & 0xffff;
1486 ((unsigned short *)loc)[1] = (v >> 16) & 0xffff;
1489 case R_V850_22_PCREL:
1492 #elif defined(__x86_64__)
1502 *(unsigned int *) loc += v;
1505 ret = obj_reloc_overflow; /* Kernel module compiled without -mcmodel=kernel. */
1506 /* error("Possibly is module compiled without -mcmodel=kernel!"); */
1511 *(signed int *) loc += v;
1515 *(unsigned short *) loc += v;
1519 *(unsigned char *) loc += v;
1523 *(unsigned int *) loc += v - dot;
1527 *(unsigned short *) loc += v - dot;
1531 *(unsigned char *) loc += v - dot;
1534 case R_X86_64_GLOB_DAT:
1535 case R_X86_64_JUMP_SLOT:
1539 case R_X86_64_RELATIVE:
1540 *loc += f->baseaddr;
1543 case R_X86_64_GOT32:
1544 case R_X86_64_GOTPCREL:
1547 if (!isym->gotent.reloc_done)
1549 isym->gotent.reloc_done = 1;
1550 *(Elf64_Addr *)(ifile->got->contents + isym->gotent.offset) = v;
1552 /* XXX are these really correct? */
1553 if (ELF64_R_TYPE(rel->r_info) == R_X86_64_GOTPCREL)
1554 *(unsigned int *) loc += v + isym->gotent.offset;
1556 *loc += isym->gotent.offset;
1561 # warning "no idea how to handle relocations on your arch"
1565 printf("Warning: unhandled reloc %d\n",(int)ELF_R_TYPE(rel->r_info));
1566 ret = obj_reloc_unhandled;
1569 #if defined(USE_PLT_ENTRIES)
1573 /* find the plt entry and initialize it if necessary */
1575 #if defined(USE_PLT_LIST)
1576 for (pe = isym->pltent; pe != NULL && pe->addend != rel->r_addend;)
1583 ip = (unsigned long *) (ifile->plt->contents + pe->offset);
1585 /* generate some machine code */
1587 #if defined(__arm__)
1588 ip[0] = 0xe51ff004; /* ldr pc,[pc,#-4] */
1589 ip[1] = v; /* sym@ */
1591 #if defined(__powerpc__)
1592 ip[0] = 0x3d600000 + ((v + 0x8000) >> 16); /* lis r11,sym@ha */
1593 ip[1] = 0x396b0000 + (v & 0xffff); /* addi r11,r11,sym@l */
1594 ip[2] = 0x7d6903a6; /* mtctr r11 */
1595 ip[3] = 0x4e800420; /* bctr */
1597 #if defined(__v850e__)
1598 /* We have to trash a register, so we assume that any control
1599 transfer more than 21-bits away must be a function call
1600 (so we can use a call-clobbered register). */
1601 ip[0] = 0x0621 + ((v & 0xffff) << 16); /* mov sym, r1 ... */
1602 ip[1] = ((v >> 16) & 0xffff) + 0x610000; /* ...; jmp r1 */
1607 /* relative distance to target */
1609 /* if the target is too far away.... */
1610 #if defined(__arm__) || defined(__powerpc__)
1611 if ((int)v < -0x02000000 || (int)v >= 0x02000000)
1612 #elif defined(__v850e__)
1613 if ((ElfW(Sword))v > 0x1fffff || (ElfW(Sword))v < (ElfW(Sword))-0x200000)
1615 /* go via the plt */
1616 v = plt + pe->offset - dot;
1618 #if defined(__v850e__)
1623 ret = obj_reloc_dangerous;
1625 /* merge the offset into the instruction. */
1626 #if defined(__arm__)
1627 /* Convert to words. */
1630 *loc = (*loc & ~0x00ffffff) | ((v + *loc) & 0x00ffffff);
1632 #if defined(__powerpc__)
1633 *loc = (*loc & ~0x03fffffc) | (v & 0x03fffffc);
1635 #if defined(__v850e__)
1636 /* We write two shorts instead of a long because even 32-bit insns
1637 only need half-word alignment, but the 32-bit data write needs
1638 to be long-word aligned. */
1639 ((unsigned short *)loc)[0] =
1640 (*(unsigned short *)loc & 0xffc0) /* opcode + reg */
1641 | ((v >> 16) & 0x3f); /* offs high part */
1642 ((unsigned short *)loc)[1] =
1643 (v & 0xffff); /* offs low part */
1646 #endif /* USE_PLT_ENTRIES */
1648 #if defined(USE_GOT_ENTRIES)
1651 /* needs an entry in the .got: set it, once */
1652 if (!isym->gotent.inited) {
1653 isym->gotent.inited = 1;
1654 *(ElfW(Addr) *) (ifile->got->contents + isym->gotent.offset) = v;
1656 /* make the reloc with_respect_to_.got */
1658 *loc += isym->gotent.offset + rel->r_addend;
1659 #elif defined(__i386__) || defined(__arm__) || defined(__mc68000__)
1660 *loc += isym->gotent.offset;
1664 #endif /* USE_GOT_ENTRIES */
1671 #if defined(USE_LIST)
1673 static int arch_list_add(ElfW(RelM) *rel, struct arch_list_entry **list,
1674 int offset, int size)
1676 struct arch_list_entry *pe;
1678 for (pe = *list; pe != NULL; pe = pe->next) {
1679 if (pe->addend == rel->r_addend) {
1685 pe = xmalloc(sizeof(struct arch_list_entry));
1687 pe->addend = rel->r_addend;
1688 pe->offset = offset;
1698 #if defined(USE_SINGLE)
1700 static int arch_single_init(/*ElfW(RelM) *rel,*/ struct arch_single_entry *single,
1701 int offset, int size)
1703 if (single->allocated == 0) {
1704 single->allocated = 1;
1705 single->offset = offset;
1714 #if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
1716 static struct obj_section *arch_xsect_init(struct obj_file *f, const char *name,
1717 int offset, int size)
1719 struct obj_section *myrelsec = obj_find_section(f, name);
1726 obj_extend_section(myrelsec, offset);
1728 myrelsec = obj_create_alloced_section(f, name,
1737 static void arch_create_got(struct obj_file *f)
1739 #if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
1740 struct arch_file *ifile = (struct arch_file *) f;
1742 #if defined(USE_GOT_ENTRIES)
1743 int got_offset = 0, got_needed = 0, got_allocate;
1745 #if defined(USE_PLT_ENTRIES)
1746 int plt_offset = 0, plt_needed = 0, plt_allocate;
1748 struct obj_section *relsec, *symsec, *strsec;
1749 ElfW(RelM) *rel, *relend;
1750 ElfW(Sym) *symtab, *extsym;
1751 const char *strtab, *name;
1752 struct arch_symbol *intsym;
1754 for (i = 0; i < f->header.e_shnum; ++i) {
1755 relsec = f->sections[i];
1756 if (relsec->header.sh_type != SHT_RELM)
1759 symsec = f->sections[relsec->header.sh_link];
1760 strsec = f->sections[symsec->header.sh_link];
1762 rel = (ElfW(RelM) *) relsec->contents;
1763 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
1764 symtab = (ElfW(Sym) *) symsec->contents;
1765 strtab = (const char *) strsec->contents;
1767 for (; rel < relend; ++rel) {
1768 extsym = &symtab[ELF_R_SYM(rel->r_info)];
1770 #if defined(USE_GOT_ENTRIES)
1773 #if defined(USE_PLT_ENTRIES)
1777 switch (ELF_R_TYPE(rel->r_info)) {
1778 #if defined(__arm__)
1793 #elif defined(__i386__)
1803 #elif defined(__powerpc__)
1808 #elif defined(__mc68000__)
1819 #elif defined(__sh__)
1829 #elif defined(__v850e__)
1830 case R_V850_22_PCREL:
1839 if (extsym->st_name != 0) {
1840 name = strtab + extsym->st_name;
1842 name = f->sections[extsym->st_shndx]->name;
1844 intsym = (struct arch_symbol *) obj_find_symbol(f, name);
1845 #if defined(USE_GOT_ENTRIES)
1847 got_offset += arch_single_init(
1848 /*rel,*/ &intsym->gotent,
1849 got_offset, GOT_ENTRY_SIZE);
1854 #if defined(USE_PLT_ENTRIES)
1856 #if defined(USE_PLT_LIST)
1857 plt_offset += arch_list_add(
1858 rel, &intsym->pltent,
1859 plt_offset, PLT_ENTRY_SIZE);
1861 plt_offset += arch_single_init(
1862 /*rel,*/ &intsym->pltent,
1863 plt_offset, PLT_ENTRY_SIZE);
1871 #if defined(USE_GOT_ENTRIES)
1873 ifile->got = arch_xsect_init(f, ".got", got_offset,
1878 #if defined(USE_PLT_ENTRIES)
1880 ifile->plt = arch_xsect_init(f, ".plt", plt_offset,
1885 #endif /* defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES) */
1888 /*======================================================================*/
1890 /* Standard ELF hash function. */
1891 static unsigned long obj_elf_hash_n(const char *name, unsigned long n)
1893 unsigned long h = 0;
1900 g = (h & 0xf0000000);
1910 static unsigned long obj_elf_hash(const char *name)
1912 return obj_elf_hash_n(name, strlen(name));
1915 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
1916 /* String comparison for non-co-versioned kernel and module. */
1918 static int ncv_strcmp(const char *a, const char *b)
1920 size_t alen = strlen(a), blen = strlen(b);
1922 if (blen == alen + 10 && b[alen] == '_' && b[alen + 1] == 'R')
1923 return strncmp(a, b, alen);
1924 else if (alen == blen + 10 && a[blen] == '_' && a[blen + 1] == 'R')
1925 return strncmp(a, b, blen);
1927 return strcmp(a, b);
1930 /* String hashing for non-co-versioned kernel and module. Here
1931 we are simply forced to drop the crc from the hash. */
1933 static unsigned long ncv_symbol_hash(const char *str)
1935 size_t len = strlen(str);
1936 if (len > 10 && str[len - 10] == '_' && str[len - 9] == 'R')
1938 return obj_elf_hash_n(str, len);
1942 obj_set_symbol_compare(struct obj_file *f,
1943 int (*cmp) (const char *, const char *),
1944 unsigned long (*hash) (const char *))
1947 f->symbol_cmp = cmp;
1949 struct obj_symbol *tmptab[HASH_BUCKETS], *sym, *next;
1952 f->symbol_hash = hash;
1954 memcpy(tmptab, f->symtab, sizeof(tmptab));
1955 memset(f->symtab, 0, sizeof(f->symtab));
1957 for (i = 0; i < HASH_BUCKETS; ++i)
1958 for (sym = tmptab[i]; sym; sym = next) {
1959 unsigned long h = hash(sym->name) % HASH_BUCKETS;
1961 sym->next = f->symtab[h];
1967 #endif /* FEATURE_INSMOD_VERSION_CHECKING */
1969 static struct obj_symbol *
1970 obj_add_symbol(struct obj_file *f, const char *name,
1971 unsigned long symidx, int info,
1972 int secidx, ElfW(Addr) value,
1975 struct obj_symbol *sym;
1976 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
1977 int n_type = ELF_ST_TYPE(info);
1978 int n_binding = ELF_ST_BIND(info);
1980 for (sym = f->symtab[hash]; sym; sym = sym->next) {
1981 if (f->symbol_cmp(sym->name, name) == 0) {
1982 int o_secidx = sym->secidx;
1983 int o_info = sym->info;
1984 int o_type = ELF_ST_TYPE(o_info);
1985 int o_binding = ELF_ST_BIND(o_info);
1987 /* A redefinition! Is it legal? */
1989 if (secidx == SHN_UNDEF)
1991 else if (o_secidx == SHN_UNDEF)
1993 else if (n_binding == STB_GLOBAL && o_binding == STB_LOCAL) {
1994 /* Cope with local and global symbols of the same name
1995 in the same object file, as might have been created
1996 by ld -r. The only reason locals are now seen at this
1997 level at all is so that we can do semi-sensible things
2000 struct obj_symbol *nsym, **p;
2002 nsym = arch_new_symbol();
2003 nsym->next = sym->next;
2006 /* Excise the old (local) symbol from the hash chain. */
2007 for (p = &f->symtab[hash]; *p != sym; p = &(*p)->next)
2011 } else if (n_binding == STB_LOCAL) {
2012 /* Another symbol of the same name has already been defined.
2013 Just add this to the local table. */
2014 sym = arch_new_symbol();
2017 f->local_symtab[symidx] = sym;
2019 } else if (n_binding == STB_WEAK)
2021 else if (o_binding == STB_WEAK)
2023 /* Don't unify COMMON symbols with object types the programmer
2025 else if (secidx == SHN_COMMON
2026 && (o_type == STT_NOTYPE || o_type == STT_OBJECT))
2028 else if (o_secidx == SHN_COMMON
2029 && (n_type == STT_NOTYPE || n_type == STT_OBJECT))
2032 /* Don't report an error if the symbol is coming from
2033 the kernel or some external module. */
2034 if (secidx <= SHN_HIRESERVE)
2035 bb_error_msg("%s multiply defined", name);
2041 /* Completely new symbol. */
2042 sym = arch_new_symbol();
2043 sym->next = f->symtab[hash];
2044 f->symtab[hash] = sym;
2046 if (ELF_ST_BIND(info) == STB_LOCAL && symidx != (unsigned long)(-1)) {
2047 if (symidx >= f->local_symtab_size)
2048 bb_error_msg("local symbol %s with index %ld exceeds local_symtab_size %ld",
2049 name, (long) symidx, (long) f->local_symtab_size);
2051 f->local_symtab[symidx] = sym;
2058 sym->secidx = secidx;
2064 static struct obj_symbol *
2065 obj_find_symbol(struct obj_file *f, const char *name)
2067 struct obj_symbol *sym;
2068 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
2070 for (sym = f->symtab[hash]; sym; sym = sym->next)
2071 if (f->symbol_cmp(sym->name, name) == 0)
2077 static ElfW(Addr) obj_symbol_final_value(struct obj_file * f, struct obj_symbol * sym)
2080 if (sym->secidx >= SHN_LORESERVE)
2083 return sym->value + f->sections[sym->secidx]->header.sh_addr;
2085 /* As a special case, a NULL sym has value zero. */
2090 static struct obj_section *obj_find_section(struct obj_file *f, const char *name)
2092 int i, n = f->header.e_shnum;
2094 for (i = 0; i < n; ++i)
2095 if (strcmp(f->sections[i]->name, name) == 0)
2096 return f->sections[i];
2101 static int obj_load_order_prio(struct obj_section *a)
2103 unsigned long af, ac;
2105 af = a->header.sh_flags;
2108 if (a->name[0] != '.' || strlen(a->name) != 10 ||
2109 strcmp(a->name + 5, ".init"))
2113 if (!(af & SHF_WRITE))
2115 if (af & SHF_EXECINSTR)
2117 if (a->header.sh_type != SHT_NOBITS)
2124 obj_insert_section_load_order(struct obj_file *f, struct obj_section *sec)
2126 struct obj_section **p;
2127 int prio = obj_load_order_prio(sec);
2128 for (p = f->load_order_search_start; *p; p = &(*p)->load_next)
2129 if (obj_load_order_prio(*p) < prio)
2131 sec->load_next = *p;
2135 static struct obj_section *obj_create_alloced_section(struct obj_file *f,
2137 unsigned long align,
2140 int newidx = f->header.e_shnum++;
2141 struct obj_section *sec;
2143 f->sections = xrealloc_vector(f->sections, 2, newidx);
2144 f->sections[newidx] = sec = arch_new_section();
2146 sec->header.sh_type = SHT_PROGBITS;
2147 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2148 sec->header.sh_size = size;
2149 sec->header.sh_addralign = align;
2153 sec->contents = xmalloc(size);
2155 obj_insert_section_load_order(f, sec);
2160 static struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
2162 unsigned long align,
2165 int newidx = f->header.e_shnum++;
2166 struct obj_section *sec;
2168 f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
2169 f->sections[newidx] = sec = arch_new_section();
2171 sec->header.sh_type = SHT_PROGBITS;
2172 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2173 sec->header.sh_size = size;
2174 sec->header.sh_addralign = align;
2178 sec->contents = xmalloc(size);
2180 sec->load_next = f->load_order;
2181 f->load_order = sec;
2182 if (f->load_order_search_start == &f->load_order)
2183 f->load_order_search_start = &sec->load_next;
2188 static void *obj_extend_section(struct obj_section *sec, unsigned long more)
2190 unsigned long oldsize = sec->header.sh_size;
2192 sec->header.sh_size += more;
2193 sec->contents = xrealloc(sec->contents, sec->header.sh_size);
2195 return sec->contents + oldsize;
2199 /* Conditionally add the symbols from the given symbol set to the
2203 add_symbols_from( struct obj_file *f,
2204 int idx, struct new_module_symbol *syms, size_t nsyms)
2206 struct new_module_symbol *s;
2209 #ifdef SYMBOL_PREFIX
2211 size_t name_alloced_size = 0;
2213 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
2216 gpl = obj_gpl_license(f, NULL) == 0;
2218 for (i = 0, s = syms; i < nsyms; ++i, ++s) {
2219 /* Only add symbols that are already marked external.
2220 If we override locals we may cause problems for
2221 argument initialization. We will also create a false
2222 dependency on the module. */
2223 struct obj_symbol *sym;
2226 /* GPL licensed modules can use symbols exported with
2227 * EXPORT_SYMBOL_GPL, so ignore any GPLONLY_ prefix on the
2228 * exported names. Non-GPL modules never see any GPLONLY_
2229 * symbols so they cannot fudge it by adding the prefix on
2232 if (strncmp((char *)s->name, "GPLONLY_", 8) == 0) {
2233 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
2240 name = (char *)s->name;
2242 #ifdef SYMBOL_PREFIX
2243 /* Prepend SYMBOL_PREFIX to the symbol's name (the
2244 kernel exports `C names', but module object files
2245 reference `linker names'). */
2246 size_t extra = sizeof SYMBOL_PREFIX;
2247 size_t name_size = strlen(name) + extra;
2248 if (name_size > name_alloced_size) {
2249 name_alloced_size = name_size * 2;
2250 name_buf = alloca(name_alloced_size);
2252 strcpy(name_buf, SYMBOL_PREFIX);
2253 strcpy(name_buf + extra - 1, name);
2255 #endif /* SYMBOL_PREFIX */
2257 sym = obj_find_symbol(f, name);
2258 if (sym && !(ELF_ST_BIND(sym->info) == STB_LOCAL)) {
2259 #ifdef SYMBOL_PREFIX
2260 /* Put NAME_BUF into more permanent storage. */
2261 name = xmalloc(name_size);
2262 strcpy(name, name_buf);
2264 sym = obj_add_symbol(f, name, -1,
2265 ELF_ST_INFO(STB_GLOBAL,
2268 /* Did our symbol just get installed? If so, mark the
2269 module as "used". */
2270 if (sym->secidx == idx)
2278 static void add_kernel_symbols(struct obj_file *f)
2280 struct external_module *m;
2283 /* Add module symbols first. */
2285 for (i = 0, m = ext_modules; i < n_ext_modules; ++i, ++m) {
2287 && add_symbols_from(f, SHN_HIRESERVE + 2 + i, m->syms, m->nsyms)
2294 n_ext_modules_used = nused;
2296 /* And finally the symbols from the kernel proper. */
2299 add_symbols_from(f, SHN_HIRESERVE + 1, ksyms, nksyms);
2302 static char *get_modinfo_value(struct obj_file *f, const char *key)
2304 struct obj_section *sec;
2305 char *p, *v, *n, *ep;
2306 size_t klen = strlen(key);
2308 sec = obj_find_section(f, ".modinfo");
2312 ep = p + sec->header.sh_size;
2315 n = strchr(p, '\0');
2317 if (p + klen == v && strncmp(p, key, klen) == 0)
2320 if (p + klen == n && strcmp(p, key) == 0)
2330 /*======================================================================*/
2331 /* Functions relating to module loading after 2.1.18. */
2333 /* From Linux-2.6 sources */
2334 /* You can use " around spaces, but can't escape ". */
2335 /* Hyphens and underscores equivalent in parameter names. */
2336 static char *next_arg(char *args, char **param, char **val)
2338 unsigned int i, equals = 0;
2339 int in_quote = 0, quoted = 0;
2348 for (i = 0; args[i]; i++) {
2349 if (args[i] == ' ' && !in_quote)
2356 in_quote = !in_quote;
2363 args[equals] = '\0';
2364 *val = args + equals + 1;
2366 /* Don't include quotes in value. */
2369 if (args[i-1] == '"')
2372 if (quoted && args[i-1] == '"')
2378 next = args + i + 1;
2382 /* Chew up trailing spaces. */
2383 return skip_whitespace(next);
2387 new_process_module_arguments(struct obj_file *f, const char *options)
2389 char *xoptions, *pos;
2392 xoptions = pos = xstrdup(skip_whitespace(options));
2394 unsigned long charssize = 0;
2395 char *tmp, *contents, *loc, *pinfo, *p;
2396 struct obj_symbol *sym;
2397 int min, max, n, len;
2399 pos = next_arg(pos, ¶m, &val);
2401 tmp = xasprintf("parm_%s", param);
2402 pinfo = get_modinfo_value(f, tmp);
2405 bb_error_msg_and_die("invalid parameter %s", param);
2407 #ifdef SYMBOL_PREFIX
2408 tmp = xasprintf(SYMBOL_PREFIX "%s", param);
2409 sym = obj_find_symbol(f, tmp);
2412 sym = obj_find_symbol(f, param);
2415 /* Also check that the parameter was not resolved from the kernel. */
2416 if (sym == NULL || sym->secidx > SHN_HIRESERVE)
2417 bb_error_msg_and_die("symbol for parameter %s not found", param);
2419 /* Number of parameters */
2420 if (isdigit(*pinfo)) {
2421 min = strtoul(pinfo, &pinfo, 10);
2423 max = strtoul(pinfo + 1, &pinfo, 10);
2429 contents = f->sections[sym->secidx]->contents;
2430 loc = contents + sym->value;
2432 if (*pinfo == 'c') {
2433 if (!isdigit(*(pinfo + 1))) {
2434 bb_error_msg_and_die("parameter type 'c' for %s must be followed by"
2435 " the maximum size", param);
2437 charssize = strtoul(pinfo + 1, (char **) NULL, 10);
2442 bb_error_msg_and_die("argument expected for parameter %s", param);
2446 /* Parse parameter values */
2451 bb_error_msg_and_die("too many values for %s (max %d)", param, max);
2455 len = strcspn(p, ",");
2457 obj_string_patch(f, sym->secidx,
2459 loc += tgt_sizeof_char_p;
2463 len = strcspn(p, ",");
2465 if (len >= charssize)
2466 bb_error_msg_and_die("string too long for %s (max %ld)", param,
2468 strcpy((char *) loc, p);
2473 *loc++ = strtoul(p, &p, 0);
2476 *(short *) loc = strtoul(p, &p, 0);
2477 loc += tgt_sizeof_short;
2480 *(int *) loc = strtoul(p, &p, 0);
2481 loc += tgt_sizeof_int;
2484 *(long *) loc = strtoul(p, &p, 0);
2485 loc += tgt_sizeof_long;
2488 bb_error_msg_and_die("unknown parameter type '%c' for %s",
2492 p = skip_whitespace(p);
2495 p = skip_whitespace(p + 1);
2499 bb_error_msg_and_die("parameter %s requires at least %d arguments", param, min);
2501 bb_error_msg_and_die("invalid argument syntax for %s", param);
2507 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
2508 static int new_is_module_checksummed(struct obj_file *f)
2510 const char *p = get_modinfo_value(f, "using_checksums");
2516 /* Get the module's kernel version in the canonical integer form. */
2519 new_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
2524 p = get_modinfo_value(f, "kernel_version");
2527 safe_strncpy(str, p, STRVERSIONLEN);
2529 a = strtoul(p, &p, 10);
2532 b = strtoul(p + 1, &p, 10);
2535 c = strtoul(p + 1, &q, 10);
2539 return a << 16 | b << 8 | c;
2542 #endif /* FEATURE_INSMOD_VERSION_CHECKING */
2545 /* Fetch the loaded modules, and all currently exported symbols. */
2547 static void new_get_kernel_symbols(void)
2549 char *module_names, *mn;
2550 struct external_module *modules, *m;
2551 struct new_module_symbol *syms, *s;
2552 size_t ret, bufsize, nmod, nsyms, i, j;
2554 /* Collect the loaded modules. */
2557 module_names = xmalloc(bufsize);
2560 if (query_module(NULL, QM_MODULES, module_names, bufsize, &ret)) {
2561 if (errno == ENOSPC && bufsize < ret) {
2563 module_names = xrealloc(module_names, bufsize);
2564 goto retry_modules_load;
2566 bb_perror_msg_and_die("QM_MODULES");
2569 n_ext_modules = nmod = ret;
2571 /* Collect the modules' symbols. */
2574 ext_modules = modules = xmalloc(nmod * sizeof(*modules));
2575 memset(modules, 0, nmod * sizeof(*modules));
2576 for (i = 0, mn = module_names, m = modules;
2577 i < nmod; ++i, ++m, mn += strlen(mn) + 1) {
2578 struct new_module_info info;
2580 if (query_module(mn, QM_INFO, &info, sizeof(info), &ret)) {
2581 if (errno == ENOENT) {
2582 /* The module was removed out from underneath us. */
2585 bb_perror_msg_and_die("query_module: QM_INFO: %s", mn);
2589 syms = xmalloc(bufsize);
2591 if (query_module(mn, QM_SYMBOLS, syms, bufsize, &ret)) {
2595 syms = xrealloc(syms, bufsize);
2596 goto retry_mod_sym_load;
2598 /* The module was removed out from underneath us. */
2601 bb_perror_msg_and_die("query_module: QM_SYMBOLS: %s", mn);
2607 m->addr = info.addr;
2611 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2612 s->name += (unsigned long) syms;
2617 /* Collect the kernel's symbols. */
2619 syms = xmalloc(bufsize = 16 * 1024);
2620 retry_kern_sym_load:
2621 if (query_module(NULL, QM_SYMBOLS, syms, bufsize, &ret)) {
2622 if (errno == ENOSPC && bufsize < ret) {
2624 syms = xrealloc(syms, bufsize);
2625 goto retry_kern_sym_load;
2627 bb_perror_msg_and_die("kernel: QM_SYMBOLS");
2629 nksyms = nsyms = ret;
2632 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2633 s->name += (unsigned long) syms;
2638 /* Return the kernel symbol checksum version, or zero if not used. */
2640 static int new_is_kernel_checksummed(void)
2642 struct new_module_symbol *s;
2645 /* Using_Versions is not the first symbol, but it should be in there. */
2647 for (i = 0, s = ksyms; i < nksyms; ++i, ++s)
2648 if (strcmp((char *) s->name, "Using_Versions") == 0)
2655 static void new_create_this_module(struct obj_file *f, const char *m_name)
2657 struct obj_section *sec;
2659 sec = obj_create_alloced_section_first(f, ".this", tgt_sizeof_long,
2660 sizeof(struct new_module));
2661 memset(sec->contents, 0, sizeof(struct new_module));
2663 obj_add_symbol(f, SPFX "__this_module", -1,
2664 ELF_ST_INFO(STB_LOCAL, STT_OBJECT), sec->idx, 0,
2665 sizeof(struct new_module));
2667 obj_string_patch(f, sec->idx, offsetof(struct new_module, name),
2671 #if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
2672 /* add an entry to the __ksymtab section, creating it if necessary */
2673 static void new_add_ksymtab(struct obj_file *f, struct obj_symbol *sym)
2675 struct obj_section *sec;
2678 /* ensure __ksymtab is allocated, EXPORT_NOSYMBOLS creates a non-alloc section.
2679 * If __ksymtab is defined but not marked alloc, x out the first character
2680 * (no obj_delete routine) and create a new __ksymtab with the correct
2683 sec = obj_find_section(f, "__ksymtab");
2684 if (sec && !(sec->header.sh_flags & SHF_ALLOC)) {
2685 *((char *)(sec->name)) = 'x'; /* override const */
2689 sec = obj_create_alloced_section(f, "__ksymtab",
2690 tgt_sizeof_void_p, 0);
2693 sec->header.sh_flags |= SHF_ALLOC;
2694 /* Empty section might be byte-aligned */
2695 sec->header.sh_addralign = tgt_sizeof_void_p;
2696 ofs = sec->header.sh_size;
2697 obj_symbol_patch(f, sec->idx, ofs, sym);
2698 obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p, sym->name);
2699 obj_extend_section(sec, 2 * tgt_sizeof_char_p);
2701 #endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
2703 static int new_create_module_ksymtab(struct obj_file *f)
2705 struct obj_section *sec;
2708 /* We must always add the module references. */
2710 if (n_ext_modules_used) {
2711 struct new_module_ref *dep;
2712 struct obj_symbol *tm;
2714 sec = obj_create_alloced_section(f, ".kmodtab", tgt_sizeof_void_p,
2715 (sizeof(struct new_module_ref)
2716 * n_ext_modules_used));
2720 tm = obj_find_symbol(f, SPFX "__this_module");
2721 dep = (struct new_module_ref *) sec->contents;
2722 for (i = 0; i < n_ext_modules; ++i)
2723 if (ext_modules[i].used) {
2724 dep->dep = ext_modules[i].addr;
2725 obj_symbol_patch(f, sec->idx,
2726 (char *) &dep->ref - sec->contents, tm);
2732 if (!flag_noexport && !obj_find_section(f, "__ksymtab")) {
2736 sec = obj_create_alloced_section(f, "__ksymtab", tgt_sizeof_void_p, 0);
2738 /* We don't want to export symbols residing in sections that
2739 aren't loaded. There are a number of these created so that
2740 we make sure certain module options don't appear twice. */
2742 loaded = alloca(sizeof(int) * (i = f->header.e_shnum));
2744 loaded[i] = (f->sections[i]->header.sh_flags & SHF_ALLOC) != 0;
2746 for (nsyms = i = 0; i < HASH_BUCKETS; ++i) {
2747 struct obj_symbol *sym;
2748 for (sym = f->symtab[i]; sym; sym = sym->next)
2749 if (ELF_ST_BIND(sym->info) != STB_LOCAL
2750 && sym->secidx <= SHN_HIRESERVE
2751 && (sym->secidx >= SHN_LORESERVE
2752 || loaded[sym->secidx])) {
2753 ElfW(Addr) ofs = nsyms * 2 * tgt_sizeof_void_p;
2755 obj_symbol_patch(f, sec->idx, ofs, sym);
2756 obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p,
2763 obj_extend_section(sec, nsyms * 2 * tgt_sizeof_char_p);
2771 new_init_module(const char *m_name, struct obj_file *f, unsigned long m_size)
2773 struct new_module *module;
2774 struct obj_section *sec;
2779 sec = obj_find_section(f, ".this");
2780 if (!sec || !sec->contents) {
2781 bb_perror_msg_and_die("corrupt module %s?", m_name);
2783 module = (struct new_module *) sec->contents;
2784 m_addr = sec->header.sh_addr;
2786 module->size_of_struct = sizeof(*module);
2787 module->size = m_size;
2788 module->flags = flag_autoclean ? NEW_MOD_AUTOCLEAN : 0;
2790 sec = obj_find_section(f, "__ksymtab");
2791 if (sec && sec->header.sh_size) {
2792 module->syms = sec->header.sh_addr;
2793 module->nsyms = sec->header.sh_size / (2 * tgt_sizeof_char_p);
2796 if (n_ext_modules_used) {
2797 sec = obj_find_section(f, ".kmodtab");
2798 module->deps = sec->header.sh_addr;
2799 module->ndeps = n_ext_modules_used;
2803 obj_symbol_final_value(f, obj_find_symbol(f, SPFX "init_module"));
2805 obj_symbol_final_value(f, obj_find_symbol(f, SPFX "cleanup_module"));
2807 sec = obj_find_section(f, "__ex_table");
2809 module->ex_table_start = sec->header.sh_addr;
2810 module->ex_table_end = sec->header.sh_addr + sec->header.sh_size;
2813 sec = obj_find_section(f, ".text.init");
2815 module->runsize = sec->header.sh_addr - m_addr;
2817 sec = obj_find_section(f, ".data.init");
2819 if (!module->runsize ||
2820 module->runsize > sec->header.sh_addr - m_addr)
2821 module->runsize = sec->header.sh_addr - m_addr;
2823 sec = obj_find_section(f, ARCHDATA_SEC_NAME);
2824 if (sec && sec->header.sh_size) {
2825 module->archdata_start = (void*)sec->header.sh_addr;
2826 module->archdata_end = module->archdata_start + sec->header.sh_size;
2828 sec = obj_find_section(f, KALLSYMS_SEC_NAME);
2829 if (sec && sec->header.sh_size) {
2830 module->kallsyms_start = (void*)sec->header.sh_addr;
2831 module->kallsyms_end = module->kallsyms_start + sec->header.sh_size;
2834 /* Whew! All of the initialization is complete. Collect the final
2835 module image and give it to the kernel. */
2837 image = xmalloc(m_size);
2838 obj_create_image(f, image);
2840 ret = init_module(m_name, (struct new_module *) image);
2842 bb_perror_msg("init_module: %s", m_name);
2850 /*======================================================================*/
2853 obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2856 struct obj_string_patch *p;
2857 struct obj_section *strsec;
2858 size_t len = strlen(string) + 1;
2861 p = xmalloc(sizeof(*p));
2862 p->next = f->string_patches;
2863 p->reloc_secidx = secidx;
2864 p->reloc_offset = offset;
2865 f->string_patches = p;
2867 strsec = obj_find_section(f, ".kstrtab");
2868 if (strsec == NULL) {
2869 strsec = obj_create_alloced_section(f, ".kstrtab", 1, len);
2870 p->string_offset = 0;
2871 loc = strsec->contents;
2873 p->string_offset = strsec->header.sh_size;
2874 loc = obj_extend_section(strsec, len);
2876 memcpy(loc, string, len);
2880 obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2881 struct obj_symbol *sym)
2883 struct obj_symbol_patch *p;
2885 p = xmalloc(sizeof(*p));
2886 p->next = f->symbol_patches;
2887 p->reloc_secidx = secidx;
2888 p->reloc_offset = offset;
2890 f->symbol_patches = p;
2893 static void obj_check_undefineds(struct obj_file *f)
2897 for (i = 0; i < HASH_BUCKETS; ++i) {
2898 struct obj_symbol *sym;
2899 for (sym = f->symtab[i]; sym; sym = sym->next)
2900 if (sym->secidx == SHN_UNDEF) {
2901 if (ELF_ST_BIND(sym->info) == STB_WEAK) {
2902 sym->secidx = SHN_ABS;
2906 bb_error_msg_and_die("unresolved symbol %s", sym->name);
2912 static void obj_allocate_commons(struct obj_file *f)
2914 struct common_entry {
2915 struct common_entry *next;
2916 struct obj_symbol *sym;
2917 } *common_head = NULL;
2921 for (i = 0; i < HASH_BUCKETS; ++i) {
2922 struct obj_symbol *sym;
2923 for (sym = f->symtab[i]; sym; sym = sym->next)
2924 if (sym->secidx == SHN_COMMON) {
2925 /* Collect all COMMON symbols and sort them by size so as to
2926 minimize space wasted by alignment requirements. */
2928 struct common_entry **p, *n;
2929 for (p = &common_head; *p; p = &(*p)->next)
2930 if (sym->size <= (*p)->sym->size)
2933 n = alloca(sizeof(*n));
2941 for (i = 1; i < f->local_symtab_size; ++i) {
2942 struct obj_symbol *sym = f->local_symtab[i];
2943 if (sym && sym->secidx == SHN_COMMON) {
2944 struct common_entry **p, *n;
2945 for (p = &common_head; *p; p = &(*p)->next)
2946 if (sym == (*p)->sym)
2948 else if (sym->size < (*p)->sym->size) {
2949 n = alloca(sizeof(*n));
2959 /* Find the bss section. */
2960 for (i = 0; i < f->header.e_shnum; ++i)
2961 if (f->sections[i]->header.sh_type == SHT_NOBITS)
2964 /* If for some reason there hadn't been one, create one. */
2965 if (i == f->header.e_shnum) {
2966 struct obj_section *sec;
2968 f->sections = xrealloc_vector(f->sections, 2, i);
2969 f->sections[i] = sec = arch_new_section();
2970 f->header.e_shnum = i + 1;
2972 sec->header.sh_type = SHT_PROGBITS;
2973 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2978 /* Allocate the COMMONS. */
2980 ElfW(Addr) bss_size = f->sections[i]->header.sh_size;
2981 ElfW(Addr) max_align = f->sections[i]->header.sh_addralign;
2982 struct common_entry *c;
2984 for (c = common_head; c; c = c->next) {
2985 ElfW(Addr) align = c->sym->value;
2987 if (align > max_align)
2989 if (bss_size & (align - 1))
2990 bss_size = (bss_size | (align - 1)) + 1;
2993 c->sym->value = bss_size;
2995 bss_size += c->sym->size;
2998 f->sections[i]->header.sh_size = bss_size;
2999 f->sections[i]->header.sh_addralign = max_align;
3003 /* For the sake of patch relocation and parameter initialization,
3004 allocate zeroed data for NOBITS sections now. Note that after
3005 this we cannot assume NOBITS are really empty. */
3006 for (i = 0; i < f->header.e_shnum; ++i) {
3007 struct obj_section *s = f->sections[i];
3008 if (s->header.sh_type == SHT_NOBITS) {
3009 if (s->header.sh_size != 0)
3010 s->contents = memset(xmalloc(s->header.sh_size),
3011 0, s->header.sh_size);
3015 s->header.sh_type = SHT_PROGBITS;
3020 static unsigned long obj_load_size(struct obj_file *f)
3022 unsigned long dot = 0;
3023 struct obj_section *sec;
3025 /* Finalize the positions of the sections relative to one another. */
3027 for (sec = f->load_order; sec; sec = sec->load_next) {
3030 align = sec->header.sh_addralign;
3031 if (align && (dot & (align - 1)))
3032 dot = (dot | (align - 1)) + 1;
3034 sec->header.sh_addr = dot;
3035 dot += sec->header.sh_size;
3041 static int obj_relocate(struct obj_file *f, ElfW(Addr) base)
3043 int i, n = f->header.e_shnum;
3046 /* Finalize the addresses of the sections. */
3049 for (i = 0; i < n; ++i)
3050 f->sections[i]->header.sh_addr += base;
3052 /* And iterate over all of the relocations. */
3054 for (i = 0; i < n; ++i) {
3055 struct obj_section *relsec, *symsec, *targsec, *strsec;
3056 ElfW(RelM) * rel, *relend;
3060 relsec = f->sections[i];
3061 if (relsec->header.sh_type != SHT_RELM)
3064 symsec = f->sections[relsec->header.sh_link];
3065 targsec = f->sections[relsec->header.sh_info];
3066 strsec = f->sections[symsec->header.sh_link];
3068 rel = (ElfW(RelM) *) relsec->contents;
3069 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
3070 symtab = (ElfW(Sym) *) symsec->contents;
3071 strtab = (const char *) strsec->contents;
3073 for (; rel < relend; ++rel) {
3074 ElfW(Addr) value = 0;
3075 struct obj_symbol *intsym = NULL;
3076 unsigned long symndx;
3077 ElfW(Sym) * extsym = 0;
3080 /* Attempt to find a value to use for this relocation. */
3082 symndx = ELF_R_SYM(rel->r_info);
3084 /* Note we've already checked for undefined symbols. */
3086 extsym = &symtab[symndx];
3087 if (ELF_ST_BIND(extsym->st_info) == STB_LOCAL) {
3088 /* Local symbols we look up in the local table to be sure
3089 we get the one that is really intended. */
3090 intsym = f->local_symtab[symndx];
3092 /* Others we look up in the hash table. */
3094 if (extsym->st_name)
3095 name = strtab + extsym->st_name;
3097 name = f->sections[extsym->st_shndx]->name;
3098 intsym = obj_find_symbol(f, name);
3101 value = obj_symbol_final_value(f, intsym);
3102 intsym->referenced = 1;
3104 #if SHT_RELM == SHT_RELA
3105 #if defined(__alpha__) && defined(AXP_BROKEN_GAS)
3106 /* Work around a nasty GAS bug, that is fixed as of 2.7.0.9. */
3107 if (!extsym || !extsym->st_name ||
3108 ELF_ST_BIND(extsym->st_info) != STB_LOCAL)
3110 value += rel->r_addend;
3114 switch (arch_apply_relocation
3115 (f, targsec, /*symsec,*/ intsym, rel, value)
3120 case obj_reloc_overflow:
3121 errmsg = "Relocation overflow";
3123 case obj_reloc_dangerous:
3124 errmsg = "Dangerous relocation";
3126 case obj_reloc_unhandled:
3127 errmsg = "Unhandled relocation";
3130 bb_error_msg("%s of type %ld for %s", errmsg,
3131 (long) ELF_R_TYPE(rel->r_info),
3132 strtab + extsym->st_name);
3134 bb_error_msg("%s of type %ld", errmsg,
3135 (long) ELF_R_TYPE(rel->r_info));
3143 /* Finally, take care of the patches. */
3145 if (f->string_patches) {
3146 struct obj_string_patch *p;
3147 struct obj_section *strsec;
3148 ElfW(Addr) strsec_base;
3149 strsec = obj_find_section(f, ".kstrtab");
3150 strsec_base = strsec->header.sh_addr;
3152 for (p = f->string_patches; p; p = p->next) {
3153 struct obj_section *targsec = f->sections[p->reloc_secidx];
3154 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
3155 = strsec_base + p->string_offset;
3159 if (f->symbol_patches) {
3160 struct obj_symbol_patch *p;
3162 for (p = f->symbol_patches; p; p = p->next) {
3163 struct obj_section *targsec = f->sections[p->reloc_secidx];
3164 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
3165 = obj_symbol_final_value(f, p->sym);
3172 static int obj_create_image(struct obj_file *f, char *image)
3174 struct obj_section *sec;
3175 ElfW(Addr) base = f->baseaddr;
3177 for (sec = f->load_order; sec; sec = sec->load_next) {
3180 if (sec->contents == 0 || sec->header.sh_size == 0)
3183 secimg = image + (sec->header.sh_addr - base);
3185 /* Note that we allocated data for NOBITS sections earlier. */
3186 memcpy(secimg, sec->contents, sec->header.sh_size);
3192 /*======================================================================*/
3194 static struct obj_file *obj_load(FILE *fp, int loadprogbits UNUSED_PARAM)
3197 ElfW(Shdr) * section_headers;
3201 /* Read the file header. */
3203 f = arch_new_file();
3204 f->symbol_cmp = strcmp;
3205 f->symbol_hash = obj_elf_hash;
3206 f->load_order_search_start = &f->load_order;
3208 fseek(fp, 0, SEEK_SET);
3209 if (fread(&f->header, sizeof(f->header), 1, fp) != 1) {
3210 bb_perror_msg_and_die("error reading ELF header");
3213 if (f->header.e_ident[EI_MAG0] != ELFMAG0
3214 || f->header.e_ident[EI_MAG1] != ELFMAG1
3215 || f->header.e_ident[EI_MAG2] != ELFMAG2
3216 || f->header.e_ident[EI_MAG3] != ELFMAG3) {
3217 bb_error_msg_and_die("not an ELF file");
3219 if (f->header.e_ident[EI_CLASS] != ELFCLASSM
3220 || f->header.e_ident[EI_DATA] != (BB_BIG_ENDIAN
3221 ? ELFDATA2MSB : ELFDATA2LSB)
3222 || f->header.e_ident[EI_VERSION] != EV_CURRENT
3223 || !MATCH_MACHINE(f->header.e_machine)) {
3224 bb_error_msg_and_die("ELF file not for this architecture");
3226 if (f->header.e_type != ET_REL) {
3227 bb_error_msg_and_die("ELF file not a relocatable object");
3230 /* Read the section headers. */
3232 if (f->header.e_shentsize != sizeof(ElfW(Shdr))) {
3233 bb_error_msg_and_die("section header size mismatch: %lu != %lu",
3234 (unsigned long) f->header.e_shentsize,
3235 (unsigned long) sizeof(ElfW(Shdr)));
3238 shnum = f->header.e_shnum;
3239 f->sections = xmalloc(sizeof(struct obj_section *) * shnum);
3240 memset(f->sections, 0, sizeof(struct obj_section *) * shnum);
3242 section_headers = alloca(sizeof(ElfW(Shdr)) * shnum);
3243 fseek(fp, f->header.e_shoff, SEEK_SET);
3244 if (fread(section_headers, sizeof(ElfW(Shdr)), shnum, fp) != shnum) {
3245 bb_perror_msg_and_die("error reading ELF section headers");
3248 /* Read the section data. */
3250 for (i = 0; i < shnum; ++i) {
3251 struct obj_section *sec;
3253 f->sections[i] = sec = arch_new_section();
3255 sec->header = section_headers[i];
3258 if (sec->header.sh_size) {
3259 switch (sec->header.sh_type) {
3268 if (!loadprogbits) {
3269 sec->contents = NULL;
3276 if (sec->header.sh_size > 0) {
3277 sec->contents = xmalloc(sec->header.sh_size);
3278 fseek(fp, sec->header.sh_offset, SEEK_SET);
3279 if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
3280 bb_perror_msg_and_die("error reading ELF section data");
3283 sec->contents = NULL;
3287 #if SHT_RELM == SHT_REL
3289 bb_error_msg_and_die("RELA relocations not supported on this architecture");
3292 bb_error_msg_and_die("REL relocations not supported on this architecture");
3295 if (sec->header.sh_type >= SHT_LOPROC) {
3296 /* Assume processor specific section types are debug
3297 info and can safely be ignored. If this is ever not
3298 the case (Hello MIPS?), don't put ifdefs here but
3299 create an arch_load_proc_section(). */
3303 bb_error_msg_and_die("can't handle sections of type %ld",
3304 (long) sec->header.sh_type);
3309 /* Do what sort of interpretation as needed by each section. */
3311 shstrtab = f->sections[f->header.e_shstrndx]->contents;
3313 for (i = 0; i < shnum; ++i) {
3314 struct obj_section *sec = f->sections[i];
3315 sec->name = shstrtab + sec->header.sh_name;
3318 for (i = 0; i < shnum; ++i) {
3319 struct obj_section *sec = f->sections[i];
3321 /* .modinfo should be contents only but gcc has no attribute for that.
3322 * The kernel may have marked .modinfo as ALLOC, ignore this bit.
3324 if (strcmp(sec->name, ".modinfo") == 0)
3325 sec->header.sh_flags &= ~SHF_ALLOC;
3327 if (sec->header.sh_flags & SHF_ALLOC)
3328 obj_insert_section_load_order(f, sec);
3330 switch (sec->header.sh_type) {
3333 unsigned long nsym, j;
3337 if (sec->header.sh_entsize != sizeof(ElfW(Sym))) {
3338 bb_error_msg_and_die("symbol size mismatch: %lu != %lu",
3339 (unsigned long) sec->header.sh_entsize,
3340 (unsigned long) sizeof(ElfW(Sym)));
3343 nsym = sec->header.sh_size / sizeof(ElfW(Sym));
3344 strtab = f->sections[sec->header.sh_link]->contents;
3345 sym = (ElfW(Sym) *) sec->contents;
3347 /* Allocate space for a table of local symbols. */
3348 j = f->local_symtab_size = sec->header.sh_info;
3349 f->local_symtab = xzalloc(j * sizeof(struct obj_symbol *));
3351 /* Insert all symbols into the hash table. */
3352 for (j = 1, ++sym; j < nsym; ++j, ++sym) {
3353 ElfW(Addr) val = sym->st_value;
3356 name = strtab + sym->st_name;
3357 else if (sym->st_shndx < shnum)
3358 name = f->sections[sym->st_shndx]->name;
3361 #if defined(__SH5__)
3363 * For sh64 it is possible that the target of a branch
3364 * requires a mode switch (32 to 16 and back again).
3366 * This is implied by the lsb being set in the target
3367 * address for SHmedia mode and clear for SHcompact.
3369 val |= sym->st_other & 4;
3371 obj_add_symbol(f, name, j, sym->st_info, sym->st_shndx,
3378 if (sec->header.sh_entsize != sizeof(ElfW(RelM))) {
3379 bb_error_msg_and_die("relocation entry size mismatch: %lu != %lu",
3380 (unsigned long) sec->header.sh_entsize,
3381 (unsigned long) sizeof(ElfW(RelM)));
3384 /* XXX Relocation code from modutils-2.3.19 is not here.
3385 * Why? That's about 20 lines of code from obj/obj_load.c,
3386 * which gets done in a second pass through the sections.
3387 * This BusyBox insmod does similar work in obj_relocate(). */
3394 #if ENABLE_FEATURE_INSMOD_LOADINKMEM
3396 * load the unloaded sections directly into the memory allocated by
3397 * kernel for the module
3400 static int obj_load_progbits(FILE *fp, struct obj_file *f, char *imagebase)
3402 ElfW(Addr) base = f->baseaddr;
3403 struct obj_section* sec;
3405 for (sec = f->load_order; sec; sec = sec->load_next) {
3407 /* section already loaded? */
3408 if (sec->contents != NULL)
3411 if (sec->header.sh_size == 0)
3414 sec->contents = imagebase + (sec->header.sh_addr - base);
3415 fseek(fp, sec->header.sh_offset, SEEK_SET);
3416 if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
3417 bb_perror_msg("error reading ELF section data");
3426 static void hide_special_symbols(struct obj_file *f)
3428 static const char *const specials[] = {
3429 SPFX "cleanup_module",
3431 SPFX "kernel_version",
3435 struct obj_symbol *sym;
3436 const char *const *p;
3438 for (p = specials; *p; ++p) {
3439 sym = obj_find_symbol(f, *p);
3441 sym->info = ELF_ST_INFO(STB_LOCAL, ELF_ST_TYPE(sym->info));
3446 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
3447 static int obj_gpl_license(struct obj_file *f, const char **license)
3449 struct obj_section *sec;
3450 /* This list must match *exactly* the list of allowable licenses in
3451 * linux/include/linux/module.h. Checking for leading "GPL" will not
3452 * work, somebody will use "GPL sucks, this is proprietary".
3454 static const char *const gpl_licenses[] = {
3457 "GPL and additional rights",
3462 sec = obj_find_section(f, ".modinfo");
3464 const char *value, *ptr, *endptr;
3465 ptr = sec->contents;
3466 endptr = ptr + sec->header.sh_size;
3467 while (ptr < endptr) {
3468 value = strchr(ptr, '=');
3469 if (value && strncmp(ptr, "license", value-ptr) == 0) {
3473 for (i = 0; i < ARRAY_SIZE(gpl_licenses); ++i) {
3474 if (strcmp(value+1, gpl_licenses[i]) == 0)
3479 ptr = strchr(ptr, '\0');
3489 #define TAINT_FILENAME "/proc/sys/kernel/tainted"
3490 #define TAINT_PROPRIETORY_MODULE (1 << 0)
3491 #define TAINT_FORCED_MODULE (1 << 1)
3492 #define TAINT_UNSAFE_SMP (1 << 2)
3493 #define TAINT_URL "http://www.tux.org/lkml/#export-tainted"
3495 static void set_tainted(int fd, const char *m_name,
3496 int kernel_has_tainted, int taint, const char *text1, const char *text2)
3498 static smallint printed_info;
3503 if (fd < 0 && !kernel_has_tainted)
3504 return; /* New modutils on old kernel */
3505 printf("Warning: loading %s will taint the kernel: %s%s\n",
3506 m_name, text1, text2);
3507 if (!printed_info) {
3508 printf(" See %s for information about tainted modules\n", TAINT_URL);
3512 read(fd, buf, sizeof(buf)-1);
3513 buf[sizeof(buf)-1] = '\0';
3514 oldval = strtoul(buf, NULL, 10);
3515 sprintf(buf, "%d\n", oldval | taint);
3516 write(fd, buf, strlen(buf));
3520 /* Check if loading this module will taint the kernel. */
3521 static void check_tainted_module(struct obj_file *f, const char *m_name)
3523 static const char tainted_file[] ALIGN1 = TAINT_FILENAME;
3525 int fd, kernel_has_tainted;
3528 kernel_has_tainted = 1;
3529 fd = open(tainted_file, O_RDWR);
3531 if (errno == ENOENT)
3532 kernel_has_tainted = 0;
3533 else if (errno == EACCES)
3534 kernel_has_tainted = 1;
3536 perror(tainted_file);
3537 kernel_has_tainted = 0;
3541 switch (obj_gpl_license(f, &ptr)) {
3545 set_tainted(fd, m_name, kernel_has_tainted, TAINT_PROPRIETORY_MODULE, "no license", "");
3548 /* The module has a non-GPL license so we pretend that the
3549 * kernel always has a taint flag to get a warning even on
3550 * kernels without the proc flag.
3552 set_tainted(fd, m_name, 1, TAINT_PROPRIETORY_MODULE, "non-GPL license - ", ptr);
3555 set_tainted(fd, m_name, 1, TAINT_PROPRIETORY_MODULE, "Unexpected return from obj_gpl_license", "");
3559 if (flag_force_load)
3560 set_tainted(fd, m_name, 1, TAINT_FORCED_MODULE, "forced load", "");
3565 #else /* FEATURE_CHECK_TAINTED_MODULE */
3566 #define check_tainted_module(x, y) do { } while (0);
3567 #endif /* FEATURE_CHECK_TAINTED_MODULE */
3569 #if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
3570 /* add module source, timestamp, kernel version and a symbol for the
3571 * start of some sections. this info is used by ksymoops to do better
3574 #if !ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3575 #define get_module_version(f, str) get_module_version(str)
3578 get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
3580 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3581 return new_get_module_version(f, str);
3582 #else /* FEATURE_INSMOD_VERSION_CHECKING */
3583 strncpy(str, "???", sizeof(str));
3585 #endif /* FEATURE_INSMOD_VERSION_CHECKING */
3588 /* add module source, timestamp, kernel version and a symbol for the
3589 * start of some sections. this info is used by ksymoops to do better
3593 add_ksymoops_symbols(struct obj_file *f, const char *filename,
3596 static const char symprefix[] ALIGN1 = "__insmod_";
3597 static const char section_names[][8] = {
3605 struct obj_section *sec;
3606 struct obj_symbol *sym;
3607 char *name, *absolute_filename;
3608 char str[STRVERSIONLEN];
3610 int l, lm_name, lfilename, use_ksymtab, version;
3611 struct stat statbuf;
3613 /* WARNING: was using realpath, but replaced by readlink to stop using
3614 * lots of stack. But here it seems to be able to cause problems? */
3615 absolute_filename = xmalloc_readlink(filename);
3616 if (!absolute_filename)
3617 absolute_filename = xstrdup(filename);
3619 lm_name = strlen(m_name);
3620 lfilename = strlen(absolute_filename);
3622 /* add to ksymtab if it already exists or there is no ksymtab and other symbols
3623 * are not to be exported. otherwise leave ksymtab alone for now, the
3624 * "export all symbols" compatibility code will export these symbols later.
3626 use_ksymtab = obj_find_section(f, "__ksymtab") || flag_noexport;
3628 sec = obj_find_section(f, ".this");
3630 /* tag the module header with the object name, last modified
3631 * timestamp and module version. worst case for module version
3632 * is 0xffffff, decimal 16777215. putting all three fields in
3633 * one symbol is less readable but saves kernel space.
3635 l = sizeof(symprefix) + /* "__insmod_" */
3636 lm_name + /* module name */
3638 lfilename + /* object filename */
3640 2 * sizeof(statbuf.st_mtime) + /* mtime in hex */
3642 8 + /* version in dec */
3645 if (stat(absolute_filename, &statbuf) != 0)
3646 statbuf.st_mtime = 0;
3647 version = get_module_version(f, str); /* -1 if not found */
3648 snprintf(name, l, "%s%s_O%s_M%0*lX_V%d",
3649 symprefix, m_name, absolute_filename,
3650 (int)(2 * sizeof(statbuf.st_mtime)), statbuf.st_mtime,
3652 sym = obj_add_symbol(f, name, -1,
3653 ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3654 sec->idx, sec->header.sh_addr, 0);
3656 new_add_ksymtab(f, sym);
3658 free(absolute_filename);
3659 #ifdef _NOT_SUPPORTED_
3660 /* record where the persistent data is going, same address as previous symbol */
3663 l = sizeof(symprefix) + /* "__insmod_" */
3664 lm_name + /* module name */
3666 strlen(f->persist) + /* data store */
3669 snprintf(name, l, "%s%s_P%s",
3670 symprefix, m_name, f->persist);
3671 sym = obj_add_symbol(f, name, -1, ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3672 sec->idx, sec->header.sh_addr, 0);
3674 new_add_ksymtab(f, sym);
3676 #endif /* _NOT_SUPPORTED_ */
3677 /* tag the desired sections if size is non-zero */
3679 for (i = 0; i < ARRAY_SIZE(section_names); ++i) {
3680 sec = obj_find_section(f, section_names[i]);
3681 if (sec && sec->header.sh_size) {
3682 l = sizeof(symprefix) + /* "__insmod_" */
3683 lm_name + /* module name */
3685 strlen(sec->name) + /* section name */
3687 8 + /* length in dec */
3690 snprintf(name, l, "%s%s_S%s_L%ld",
3691 symprefix, m_name, sec->name,
3692 (long)sec->header.sh_size);
3693 sym = obj_add_symbol(f, name, -1, ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3694 sec->idx, sec->header.sh_addr, 0);
3696 new_add_ksymtab(f, sym);
3700 #endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
3702 #if ENABLE_FEATURE_INSMOD_LOAD_MAP
3703 static void print_load_map(struct obj_file *f)
3705 struct obj_section *sec;
3706 #if ENABLE_FEATURE_INSMOD_LOAD_MAP_FULL
3707 struct obj_symbol **all, **p;
3708 int i, nsyms, *loaded;
3709 struct obj_symbol *sym;
3711 /* Report on the section layout. */
3713 printf("Sections: Size %-*s Align\n",
3714 (int) (2 * sizeof(void *)), "Address");
3716 for (sec = f->load_order; sec; sec = sec->load_next) {
3720 for (a = -1, tmp = sec->header.sh_addralign; tmp; ++a)
3725 printf("%-15s %08lx %0*lx 2**%d\n",
3727 (long)sec->header.sh_size,
3728 (int) (2 * sizeof(void *)),
3729 (long)sec->header.sh_addr,
3732 #if ENABLE_FEATURE_INSMOD_LOAD_MAP_FULL
3733 /* Quick reference which section indices are loaded. */
3735 i = f->header.e_shnum;
3736 loaded = alloca(sizeof(int) * i);
3738 loaded[i] = ((f->sections[i]->header.sh_flags & SHF_ALLOC) != 0);
3740 /* Collect the symbols we'll be listing. */
3742 for (nsyms = i = 0; i < HASH_BUCKETS; ++i)
3743 for (sym = f->symtab[i]; sym; sym = sym->next)
3744 if (sym->secidx <= SHN_HIRESERVE
3745 && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx]))
3748 all = alloca(nsyms * sizeof(struct obj_symbol *));
3750 for (i = 0, p = all; i < HASH_BUCKETS; ++i)
3751 for (sym = f->symtab[i]; sym; sym = sym->next)
3752 if (sym->secidx <= SHN_HIRESERVE
3753 && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx]))
3756 /* And list them. */
3757 printf("\nSymbols:\n");
3758 for (p = all; p < all + nsyms; ++p) {
3760 unsigned long value;
3763 if (sym->secidx == SHN_ABS) {
3766 } else if (sym->secidx == SHN_UNDEF) {
3770 sec = f->sections[sym->secidx];
3772 if (sec->header.sh_type == SHT_NOBITS)
3774 else if (sec->header.sh_flags & SHF_ALLOC) {
3775 if (sec->header.sh_flags & SHF_EXECINSTR)
3777 else if (sec->header.sh_flags & SHF_WRITE)
3782 value = sym->value + sec->header.sh_addr;
3785 if (ELF_ST_BIND(sym->info) == STB_LOCAL)
3786 type = tolower(type);
3788 printf("%0*lx %c %s\n", (int) (2 * sizeof(void *)), value,
3793 #else /* !FEATURE_INSMOD_LOAD_MAP */
3794 static void print_load_map(struct obj_file *f UNUSED_PARAM)
3799 int FAST_FUNC bb_init_module_24(const char *m_filename, const char *options UNUSED_PARAM)
3802 unsigned long m_size;
3806 int exit_status = EXIT_FAILURE;
3809 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3810 char m_strversion[STRVERSIONLEN];
3811 int m_version, m_crcs;
3816 fp = fopen_for_read(m_filename);
3818 return EXIT_FAILURE;
3820 m_name = xstrdup(bb_basename(m_filename));
3821 *strrchr(m_name, '.') = 0;
3823 f = obj_load(fp, LOADBITS);
3825 if (get_modinfo_value(f, "kernel_version") == NULL)
3830 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3831 /* Version correspondence? */
3833 if (m_has_modinfo) {
3834 m_version = new_get_module_version(f, m_strversion);
3835 if (m_version == -1) {
3836 bb_error_msg_and_die("cannot find the kernel version the module was "
3841 if (strncmp(uts.release, m_strversion, STRVERSIONLEN) != 0) {
3842 bb_error_msg("%skernel-module version mismatch\n"
3843 "\t%s was compiled for kernel version %s\n"
3844 "\twhile this kernel is version %s",
3845 flag_force_load ? "warning: " : "",
3846 m_name, m_strversion, uts.release);
3847 if (!flag_force_load)
3852 #endif /* FEATURE_INSMOD_VERSION_CHECKING */
3854 if (query_module(NULL, 0, NULL, 0, NULL))
3855 bb_error_msg_and_die("not configured to support old kernels");
3856 new_get_kernel_symbols();
3857 k_crcs = new_is_kernel_checksummed();
3859 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3862 m_crcs = new_is_module_checksummed(f);
3864 if (m_crcs != k_crcs)
3865 obj_set_symbol_compare(f, ncv_strcmp, ncv_symbol_hash);
3866 #endif /* FEATURE_INSMOD_VERSION_CHECKING */
3868 /* Let the module know about the kernel symbols. */
3869 add_kernel_symbols(f);
3871 /* Allocate common symbols, symbol tables, and string tables. */
3873 new_create_this_module(f, m_name);
3874 obj_check_undefineds(f);
3875 obj_allocate_commons(f);
3876 check_tainted_module(f, m_name);
3878 /* done with the module name, on to the optional var=value arguments */
3879 new_process_module_arguments(f, options);
3882 hide_special_symbols(f);
3884 #if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
3885 add_ksymoops_symbols(f, m_filename, m_name);
3886 #endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
3888 new_create_module_ksymtab(f);
3890 /* Find current size of the module */
3891 m_size = obj_load_size(f);
3893 m_addr = create_module(m_name, m_size);
3894 if (m_addr == (ElfW(Addr))(-1)) switch (errno) {
3896 bb_error_msg_and_die("a module named %s already exists", m_name);
3898 bb_error_msg_and_die("can't allocate kernel memory for module; needed %lu bytes",
3901 bb_perror_msg_and_die("create_module: %s", m_name);
3906 * the PROGBITS section was not loaded by the obj_load
3907 * now we can load them directly into the kernel memory
3909 if (!obj_load_progbits(fp, f, (char*)m_addr)) {
3910 delete_module(m_name, 0);
3915 if (!obj_relocate(f, m_addr)) {
3916 delete_module(m_name, 0);
3920 if (!new_init_module(m_name, f, m_size)) {
3921 delete_module(m_name, 0);
3925 if (flag_print_load_map)
3928 exit_status = EXIT_SUCCESS;