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;
518 struct obj_section *load_next;
523 struct obj_symbol *next; /* hash table link */
527 int secidx; /* the defining section index/module */
529 int ksymidx; /* for export to the kernel symtab */
530 int referenced; /* actually used in the link */
533 /* Hardcode the hash table size. We shouldn't be needing so many
534 symbols that we begin to degrade performance, and we get a big win
535 by giving the compiler a constant divisor. */
537 #define HASH_BUCKETS 521
542 struct obj_section **sections;
543 struct obj_section *load_order;
544 struct obj_section **load_order_search_start;
545 struct obj_string_patch *string_patches;
546 struct obj_symbol_patch *symbol_patches;
547 int (*symbol_cmp)(const char *, const char *); /* cant be FAST_FUNC */
548 unsigned long (*symbol_hash)(const char *) FAST_FUNC;
549 unsigned long local_symtab_size;
550 struct obj_symbol **local_symtab;
551 struct obj_symbol *symtab[HASH_BUCKETS];
561 struct obj_string_patch {
562 struct obj_string_patch *next;
564 ElfW(Addr) reloc_offset;
565 ElfW(Addr) string_offset;
568 struct obj_symbol_patch {
569 struct obj_symbol_patch *next;
571 ElfW(Addr) reloc_offset;
572 struct obj_symbol *sym;
576 /* Generic object manipulation routines. */
578 static unsigned long FAST_FUNC obj_elf_hash(const char *);
580 static unsigned long obj_elf_hash_n(const char *, unsigned long len);
582 static struct obj_symbol *obj_find_symbol(struct obj_file *f,
585 static ElfW(Addr) obj_symbol_final_value(struct obj_file *f,
586 struct obj_symbol *sym);
588 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
589 static void obj_set_symbol_compare(struct obj_file *f,
590 int (*cmp)(const char *, const char *),
591 unsigned long (*hash)(const char *) FAST_FUNC);
594 static struct obj_section *obj_find_section(struct obj_file *f,
597 static void obj_insert_section_load_order(struct obj_file *f,
598 struct obj_section *sec);
600 static struct obj_section *obj_create_alloced_section(struct obj_file *f,
605 static struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
610 static void *obj_extend_section(struct obj_section *sec, unsigned long more);
612 static void obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
615 static void obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
616 struct obj_symbol *sym);
618 static void obj_check_undefineds(struct obj_file *f);
620 static void obj_allocate_commons(struct obj_file *f);
622 static unsigned long obj_load_size(struct obj_file *f);
624 static int obj_relocate(struct obj_file *f, ElfW(Addr) base);
627 #define obj_load(image, image_size, loadprogbits) \
628 obj_load(image, image_size)
630 static struct obj_file *obj_load(char *image, size_t image_size, int loadprogbits);
632 static int obj_create_image(struct obj_file *f, char *image);
634 /* Architecture specific manipulation routines. */
636 static struct obj_file *arch_new_file(void);
638 static struct obj_section *arch_new_section(void);
640 static struct obj_symbol *arch_new_symbol(void);
642 static enum obj_reloc arch_apply_relocation(struct obj_file *f,
643 struct obj_section *targsec,
644 /*struct obj_section *symsec,*/
645 struct obj_symbol *sym,
646 ElfW(RelM) *rel, ElfW(Addr) value);
648 static void arch_create_got(struct obj_file *f);
649 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
650 static int obj_gpl_license(struct obj_file *f, const char **license);
653 //----------------------------------------------------------------------------
654 //--------end of modutils obj.h
655 //----------------------------------------------------------------------------
658 /* SPFX is always a string, so it can be concatenated to string constants. */
660 #define SPFX SYMBOL_PREFIX
665 enum { STRVERSIONLEN = 64 };
667 /*======================================================================*/
669 #define flag_force_load (option_mask32 & INSMOD_OPT_FORCE)
670 #define flag_autoclean (option_mask32 & INSMOD_OPT_KERNELD)
671 #define flag_verbose (option_mask32 & INSMOD_OPT_VERBOSE)
672 #define flag_quiet (option_mask32 & INSMOD_OPT_SILENT)
673 #define flag_noexport (option_mask32 & INSMOD_OPT_NO_EXPORT)
674 #define flag_print_load_map (option_mask32 & INSMOD_OPT_PRINT_MAP)
676 /*======================================================================*/
678 #if defined(USE_LIST)
680 struct arch_list_entry {
681 struct arch_list_entry *next;
682 LIST_ARCHTYPE addend;
689 #if defined(USE_SINGLE)
691 struct arch_single_entry {
699 #if defined(__mips__)
701 struct mips_hi16 *next;
708 struct obj_file root;
709 #if defined(USE_PLT_ENTRIES)
710 struct obj_section *plt;
712 #if defined(USE_GOT_ENTRIES)
713 struct obj_section *got;
715 #if defined(__mips__)
716 struct mips_hi16 *mips_hi16_list;
721 struct obj_symbol root;
722 #if defined(USE_PLT_ENTRIES)
723 #if defined(USE_PLT_LIST)
724 struct arch_list_entry *pltent;
726 struct arch_single_entry pltent;
729 #if defined(USE_GOT_ENTRIES)
730 struct arch_single_entry gotent;
735 struct external_module {
740 struct new_module_symbol *syms;
743 static struct new_module_symbol *ksyms;
744 static size_t nksyms;
746 static struct external_module *ext_modules;
747 static int n_ext_modules;
748 static int n_ext_modules_used;
750 /*======================================================================*/
753 static struct obj_file *arch_new_file(void)
756 f = xzalloc(sizeof(*f));
757 return &f->root; /* it's a first member */
760 static struct obj_section *arch_new_section(void)
762 return xzalloc(sizeof(struct obj_section));
765 static struct obj_symbol *arch_new_symbol(void)
767 struct arch_symbol *sym;
768 sym = xzalloc(sizeof(*sym));
772 static enum obj_reloc
773 arch_apply_relocation(struct obj_file *f,
774 struct obj_section *targsec,
775 /*struct obj_section *symsec,*/
776 struct obj_symbol *sym,
777 ElfW(RelM) *rel, ElfW(Addr) v)
779 #if defined(__arm__) || defined(__i386__) || defined(__mc68000__) \
780 || defined(__sh__) || defined(__s390__) || defined(__x86_64__) \
781 || defined(__powerpc__) || defined(__mips__)
782 struct arch_file *ifile = (struct arch_file *) f;
784 enum obj_reloc ret = obj_reloc_ok;
785 ElfW(Addr) *loc = (ElfW(Addr) *) (targsec->contents + rel->r_offset);
786 #if defined(__arm__) || defined(__H8300H__) || defined(__H8300S__) \
787 || defined(__i386__) || defined(__mc68000__) || defined(__microblaze__) \
788 || defined(__mips__) || defined(__nios2__) || defined(__powerpc__) \
789 || defined(__s390__) || defined(__sh__) || defined(__x86_64__)
790 ElfW(Addr) dot = targsec->header.sh_addr + rel->r_offset;
792 #if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
793 struct arch_symbol *isym = (struct arch_symbol *) sym;
795 #if defined(__arm__) || defined(__i386__) || defined(__mc68000__) \
796 || defined(__sh__) || defined(__s390__)
797 #if defined(USE_GOT_ENTRIES)
798 ElfW(Addr) got = ifile->got ? ifile->got->header.sh_addr : 0;
801 #if defined(USE_PLT_ENTRIES)
802 ElfW(Addr) plt = ifile->plt ? ifile->plt->header.sh_addr : 0;
804 # if defined(USE_PLT_LIST)
805 struct arch_list_entry *pe;
807 struct arch_single_entry *pe;
811 switch (ELF_R_TYPE(rel->r_info)) {
826 /* relative reloc, always to _GLOBAL_OFFSET_TABLE_
827 * (which is .got) similar to branch,
828 * but is full 32 bits relative */
837 case R_ARM_GOTOFF: /* address relative to the got */
841 #elif defined(__cris__)
847 /* CRIS keeps the relocation value in the r_addend field and
848 * should not use whats in *loc at all
853 #elif defined(__H8300H__) || defined(__H8300S__)
856 loc = (ElfW(Addr) *)((ElfW(Addr))loc - 1);
857 *loc = (*loc & 0xff000000) | ((*loc & 0xffffff) + v);
868 if ((ElfW(Sword))v > 0x7fff ||
869 (ElfW(Sword))v < -(ElfW(Sword))0x8000)
870 ret = obj_reloc_overflow;
872 *(unsigned short *)loc = v;
876 if ((ElfW(Sword))v > 0x7f ||
877 (ElfW(Sword))v < -(ElfW(Sword))0x80)
878 ret = obj_reloc_overflow;
880 *(unsigned char *)loc = v;
883 #elif defined(__i386__)
915 #elif defined(__microblaze__)
916 case R_MICROBLAZE_NONE:
917 case R_MICROBLAZE_64_NONE:
918 case R_MICROBLAZE_32_SYM_OP_SYM:
919 case R_MICROBLAZE_32_PCREL:
922 case R_MICROBLAZE_64_PCREL: {
923 /* dot is the address of the current instruction.
924 * v is the target symbol address.
925 * So we need to extract the offset in the code,
926 * adding v, then subtrating the current address
927 * of this instruction.
928 * Ex: "IMM 0xFFFE bralid 0x0000" = "bralid 0xFFFE0000"
931 /* Get split offset stored in code */
932 unsigned int temp = (loc[0] & 0xFFFF) << 16 |
935 /* Adjust relative offset. -4 adjustment required
936 * because dot points to the IMM insn, but branch
937 * is computed relative to the branch instruction itself.
941 /* Store back into code */
942 loc[0] = (loc[0] & 0xFFFF0000) | temp >> 16;
943 loc[1] = (loc[1] & 0xFFFF0000) | (temp & 0xFFFF);
948 case R_MICROBLAZE_32:
952 case R_MICROBLAZE_64: {
953 /* Get split pointer stored in code */
954 unsigned int temp1 = (loc[0] & 0xFFFF) << 16 |
957 /* Add reloc offset */
960 /* Store back into code */
961 loc[0] = (loc[0] & 0xFFFF0000) | temp1 >> 16;
962 loc[1] = (loc[1] & 0xFFFF0000) | (temp1 & 0xFFFF);
967 case R_MICROBLAZE_32_PCREL_LO:
968 case R_MICROBLAZE_32_LO:
969 case R_MICROBLAZE_SRO32:
970 case R_MICROBLAZE_SRW32:
971 ret = obj_reloc_unhandled;
974 #elif defined(__mc68000__)
985 ret = obj_reloc_overflow;
992 ret = obj_reloc_overflow;
999 if ((ElfW(Sword))v > 0x7f
1000 || (ElfW(Sword))v < -(ElfW(Sword))0x80
1002 ret = obj_reloc_overflow;
1009 if ((ElfW(Sword))v > 0x7fff
1010 || (ElfW(Sword))v < -(ElfW(Sword))0x8000
1012 ret = obj_reloc_overflow;
1018 *(int *)loc = v - dot;
1021 case R_68K_GLOB_DAT:
1022 case R_68K_JMP_SLOT:
1026 case R_68K_RELATIVE:
1027 *(int *)loc += f->baseaddr;
1033 # ifdef R_68K_GOTOFF
1039 #elif defined(__mips__)
1050 ret = obj_reloc_dangerous;
1051 if ((v & 0xf0000000) != ((dot + 4) & 0xf0000000))
1052 ret = obj_reloc_overflow;
1054 (*loc & ~0x03ffffff) | ((*loc + (v >> 2)) &
1060 struct mips_hi16 *n;
1062 /* We cannot relocate this one now because we don't know the value
1063 of the carry we need to add. Save the information, and let LO16
1064 do the actual relocation. */
1065 n = xmalloc(sizeof *n);
1068 n->next = ifile->mips_hi16_list;
1069 ifile->mips_hi16_list = n;
1075 unsigned long insnlo = *loc;
1076 ElfW(Addr) val, vallo;
1078 /* Sign extend the addend we extract from the lo insn. */
1079 vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
1081 if (ifile->mips_hi16_list != NULL) {
1082 struct mips_hi16 *l;
1084 l = ifile->mips_hi16_list;
1086 struct mips_hi16 *next;
1089 /* Do the HI16 relocation. Note that we actually don't
1090 need to know anything about the LO16 itself, except where
1091 to find the low 16 bits of the addend needed by the LO16. */
1094 ((insn & 0xffff) << 16) +
1098 /* Account for the sign extension that will happen in the
1105 insn = (insn & ~0xffff) | val;
1113 ifile->mips_hi16_list = NULL;
1116 /* Ok, we're done with the HI16 relocs. Now deal with the LO16. */
1118 insnlo = (insnlo & ~0xffff) | (val & 0xffff);
1123 #elif defined(__nios2__)
1128 case R_NIOS2_BFD_RELOC_32:
1132 case R_NIOS2_BFD_RELOC_16:
1134 ret = obj_reloc_overflow;
1139 case R_NIOS2_BFD_RELOC_8:
1141 ret = obj_reloc_overflow;
1150 if ((Elf32_Sword)v > 0x7fff
1151 || (Elf32_Sword)v < -(Elf32_Sword)0x8000
1153 ret = obj_reloc_overflow;
1157 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1167 ret = obj_reloc_overflow;
1171 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1176 case R_NIOS2_PCREL16:
1181 if ((Elf32_Sword)v > 0x7fff
1182 || (Elf32_Sword)v < -(Elf32_Sword)0x8000
1184 ret = obj_reloc_overflow;
1188 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) | (word & 0x3f);
1194 Elf32_Addr word, gp;
1196 gp = obj_symbol_final_value(f, obj_find_symbol(f, SPFX "_gp"));
1198 if ((Elf32_Sword)v > 0x7fff
1199 || (Elf32_Sword)v < -(Elf32_Sword)0x8000
1201 ret = obj_reloc_overflow;
1205 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) | (word & 0x3f);
1209 case R_NIOS2_CALL26:
1211 ret = obj_reloc_dangerous;
1212 if ((v >> 28) != (dot >> 28))
1213 ret = obj_reloc_overflow;
1214 *loc = (*loc & 0x3f) | ((v >> 2) << 6);
1222 ret = obj_reloc_overflow;
1225 word = *loc & ~0x7c0;
1226 *loc = word | ((v & 0x1f) << 6);
1235 ret = obj_reloc_overflow;
1238 word = *loc & ~0xfc0;
1239 *loc = word | ((v & 0x3f) << 6);
1248 ret = obj_reloc_overflow;
1251 word = *loc & ~0x3fc0;
1252 *loc = word | ((v & 0xff) << 6);
1261 *loc = ((((word >> 22) << 16) | ((v >>16) & 0xffff)) << 6) |
1271 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1276 case R_NIOS2_HIADJ16:
1278 Elf32_Addr word1, word2;
1281 word2 = ((v >> 16) + ((v >> 15) & 1)) & 0xffff;
1282 *loc = ((((word1 >> 22) << 16) | word2) << 6) |
1287 #elif defined(__powerpc64__)
1288 /* PPC64 needs a 2.6 kernel, 2.4 module relocation irrelevant */
1290 #elif defined(__powerpc__)
1292 case R_PPC_ADDR16_HA:
1293 *(unsigned short *)loc = (v + 0x8000) >> 16;
1296 case R_PPC_ADDR16_HI:
1297 *(unsigned short *)loc = v >> 16;
1300 case R_PPC_ADDR16_LO:
1301 *(unsigned short *)loc = v;
1315 #elif defined(__s390__)
1318 *(unsigned int *) loc += v;
1321 *(unsigned short *) loc += v;
1324 *(unsigned char *) loc += v;
1328 *(unsigned int *) loc += v - dot;
1331 *(unsigned short *) loc += (v - dot) >> 1;
1334 *(unsigned short *) loc += v - dot;
1338 case R_390_PLT16DBL:
1339 /* find the plt entry and initialize it. */
1340 pe = (struct arch_single_entry *) &isym->pltent;
1341 if (pe->inited == 0) {
1342 ip = (unsigned long *)(ifile->plt->contents + pe->offset);
1343 ip[0] = 0x0d105810; /* basr 1,0; lg 1,10(1); br 1 */
1345 if (ELF_R_TYPE(rel->r_info) == R_390_PLT16DBL)
1352 /* Insert relative distance to target. */
1353 v = plt + pe->offset - dot;
1354 if (ELF_R_TYPE(rel->r_info) == R_390_PLT32)
1355 *(unsigned int *) loc = (unsigned int) v;
1356 else if (ELF_R_TYPE(rel->r_info) == R_390_PLT16DBL)
1357 *(unsigned short *) loc = (unsigned short) ((v + 2) >> 1);
1360 case R_390_GLOB_DAT:
1361 case R_390_JMP_SLOT:
1365 case R_390_RELATIVE:
1366 *loc += f->baseaddr;
1370 *(unsigned long *) loc += got - dot;
1376 if (!isym->gotent.inited)
1378 isym->gotent.inited = 1;
1379 *(ElfW(Addr) *)(ifile->got->contents + isym->gotent.offset) = v;
1381 if (ELF_R_TYPE(rel->r_info) == R_390_GOT12)
1382 *(unsigned short *) loc |= (*(unsigned short *) loc + isym->gotent.offset) & 0xfff;
1383 else if (ELF_R_TYPE(rel->r_info) == R_390_GOT16)
1384 *(unsigned short *) loc += isym->gotent.offset;
1385 else if (ELF_R_TYPE(rel->r_info) == R_390_GOT32)
1386 *(unsigned int *) loc += isym->gotent.offset;
1389 # ifndef R_390_GOTOFF32
1390 # define R_390_GOTOFF32 R_390_GOTOFF
1392 case R_390_GOTOFF32:
1396 #elif defined(__sh__)
1419 *loc = f->baseaddr + rel->r_addend;
1423 *loc = got - dot + rel->r_addend;
1433 # if defined(__SH5__)
1434 case R_SH_IMM_MEDLOW16:
1435 case R_SH_IMM_LOW16:
1439 if (ELF_R_TYPE(rel->r_info) == R_SH_IMM_MEDLOW16)
1443 * movi and shori have the format:
1445 * | op | imm | reg | reserved |
1446 * 31..26 25..10 9.. 4 3 .. 0
1448 * so we simply mask and or in imm.
1450 word = *loc & ~0x3fffc00;
1451 word |= (v & 0xffff) << 10;
1458 case R_SH_IMM_MEDLOW16_PCREL:
1459 case R_SH_IMM_LOW16_PCREL:
1463 word = *loc & ~0x3fffc00;
1467 if (ELF_R_TYPE(rel->r_info) == R_SH_IMM_MEDLOW16_PCREL)
1470 word |= (v & 0xffff) << 10;
1476 # endif /* __SH5__ */
1478 #elif defined(__v850e__)
1484 /* We write two shorts instead of a long because even
1485 32-bit insns only need half-word alignment, but
1486 32-bit data needs to be long-word aligned. */
1487 v += ((unsigned short *)loc)[0];
1488 v += ((unsigned short *)loc)[1] << 16;
1489 ((unsigned short *)loc)[0] = v & 0xffff;
1490 ((unsigned short *)loc)[1] = (v >> 16) & 0xffff;
1493 case R_V850_22_PCREL:
1496 #elif defined(__x86_64__)
1506 *(unsigned int *) loc += v;
1509 ret = obj_reloc_overflow; /* Kernel module compiled without -mcmodel=kernel. */
1510 /* error("Possibly is module compiled without -mcmodel=kernel!"); */
1515 *(signed int *) loc += v;
1519 *(unsigned short *) loc += v;
1523 *(unsigned char *) loc += v;
1527 *(unsigned int *) loc += v - dot;
1531 *(unsigned short *) loc += v - dot;
1535 *(unsigned char *) loc += v - dot;
1538 case R_X86_64_GLOB_DAT:
1539 case R_X86_64_JUMP_SLOT:
1543 case R_X86_64_RELATIVE:
1544 *loc += f->baseaddr;
1547 case R_X86_64_GOT32:
1548 case R_X86_64_GOTPCREL:
1551 if (!isym->gotent.reloc_done)
1553 isym->gotent.reloc_done = 1;
1554 *(Elf64_Addr *)(ifile->got->contents + isym->gotent.offset) = v;
1556 /* XXX are these really correct? */
1557 if (ELF64_R_TYPE(rel->r_info) == R_X86_64_GOTPCREL)
1558 *(unsigned int *) loc += v + isym->gotent.offset;
1560 *loc += isym->gotent.offset;
1565 # warning "no idea how to handle relocations on your arch"
1569 printf("Warning: unhandled reloc %d\n",(int)ELF_R_TYPE(rel->r_info));
1570 ret = obj_reloc_unhandled;
1573 #if defined(USE_PLT_ENTRIES)
1577 /* find the plt entry and initialize it if necessary */
1579 #if defined(USE_PLT_LIST)
1580 for (pe = isym->pltent; pe != NULL && pe->addend != rel->r_addend;)
1587 ip = (unsigned long *) (ifile->plt->contents + pe->offset);
1589 /* generate some machine code */
1591 #if defined(__arm__)
1592 ip[0] = 0xe51ff004; /* ldr pc,[pc,#-4] */
1593 ip[1] = v; /* sym@ */
1595 #if defined(__powerpc__)
1596 ip[0] = 0x3d600000 + ((v + 0x8000) >> 16); /* lis r11,sym@ha */
1597 ip[1] = 0x396b0000 + (v & 0xffff); /* addi r11,r11,sym@l */
1598 ip[2] = 0x7d6903a6; /* mtctr r11 */
1599 ip[3] = 0x4e800420; /* bctr */
1601 #if defined(__v850e__)
1602 /* We have to trash a register, so we assume that any control
1603 transfer more than 21-bits away must be a function call
1604 (so we can use a call-clobbered register). */
1605 ip[0] = 0x0621 + ((v & 0xffff) << 16); /* mov sym, r1 ... */
1606 ip[1] = ((v >> 16) & 0xffff) + 0x610000; /* ...; jmp r1 */
1611 /* relative distance to target */
1613 /* if the target is too far away.... */
1614 #if defined(__arm__) || defined(__powerpc__)
1615 if ((int)v < -0x02000000 || (int)v >= 0x02000000)
1616 #elif defined(__v850e__)
1617 if ((ElfW(Sword))v > 0x1fffff || (ElfW(Sword))v < (ElfW(Sword))-0x200000)
1619 /* go via the plt */
1620 v = plt + pe->offset - dot;
1622 #if defined(__v850e__)
1627 ret = obj_reloc_dangerous;
1629 /* merge the offset into the instruction. */
1630 #if defined(__arm__)
1631 /* Convert to words. */
1634 *loc = (*loc & ~0x00ffffff) | ((v + *loc) & 0x00ffffff);
1636 #if defined(__powerpc__)
1637 *loc = (*loc & ~0x03fffffc) | (v & 0x03fffffc);
1639 #if defined(__v850e__)
1640 /* We write two shorts instead of a long because even 32-bit insns
1641 only need half-word alignment, but the 32-bit data write needs
1642 to be long-word aligned. */
1643 ((unsigned short *)loc)[0] =
1644 (*(unsigned short *)loc & 0xffc0) /* opcode + reg */
1645 | ((v >> 16) & 0x3f); /* offs high part */
1646 ((unsigned short *)loc)[1] =
1647 (v & 0xffff); /* offs low part */
1650 #endif /* USE_PLT_ENTRIES */
1652 #if defined(USE_GOT_ENTRIES)
1655 /* needs an entry in the .got: set it, once */
1656 if (!isym->gotent.inited) {
1657 isym->gotent.inited = 1;
1658 *(ElfW(Addr) *) (ifile->got->contents + isym->gotent.offset) = v;
1660 /* make the reloc with_respect_to_.got */
1662 *loc += isym->gotent.offset + rel->r_addend;
1663 #elif defined(__i386__) || defined(__arm__) || defined(__mc68000__)
1664 *loc += isym->gotent.offset;
1668 #endif /* USE_GOT_ENTRIES */
1675 #if defined(USE_LIST)
1677 static int arch_list_add(ElfW(RelM) *rel, struct arch_list_entry **list,
1678 int offset, int size)
1680 struct arch_list_entry *pe;
1682 for (pe = *list; pe != NULL; pe = pe->next) {
1683 if (pe->addend == rel->r_addend) {
1689 pe = xzalloc(sizeof(struct arch_list_entry));
1691 pe->addend = rel->r_addend;
1692 pe->offset = offset;
1702 #if defined(USE_SINGLE)
1704 static int arch_single_init(/*ElfW(RelM) *rel,*/ struct arch_single_entry *single,
1705 int offset, int size)
1707 if (single->allocated == 0) {
1708 single->allocated = 1;
1709 single->offset = offset;
1718 #if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
1720 static struct obj_section *arch_xsect_init(struct obj_file *f, const char *name,
1721 int offset, int size)
1723 struct obj_section *myrelsec = obj_find_section(f, name);
1730 obj_extend_section(myrelsec, offset);
1732 myrelsec = obj_create_alloced_section(f, name,
1741 static void arch_create_got(struct obj_file *f)
1743 #if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
1744 struct arch_file *ifile = (struct arch_file *) f;
1746 #if defined(USE_GOT_ENTRIES)
1747 int got_offset = 0, got_needed = 0, got_allocate;
1749 #if defined(USE_PLT_ENTRIES)
1750 int plt_offset = 0, plt_needed = 0, plt_allocate;
1752 struct obj_section *relsec, *symsec, *strsec;
1753 ElfW(RelM) *rel, *relend;
1754 ElfW(Sym) *symtab, *extsym;
1755 const char *strtab, *name;
1756 struct arch_symbol *intsym;
1758 for (i = 0; i < f->header.e_shnum; ++i) {
1759 relsec = f->sections[i];
1760 if (relsec->header.sh_type != SHT_RELM)
1763 symsec = f->sections[relsec->header.sh_link];
1764 strsec = f->sections[symsec->header.sh_link];
1766 rel = (ElfW(RelM) *) relsec->contents;
1767 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
1768 symtab = (ElfW(Sym) *) symsec->contents;
1769 strtab = (const char *) strsec->contents;
1771 for (; rel < relend; ++rel) {
1772 extsym = &symtab[ELF_R_SYM(rel->r_info)];
1774 #if defined(USE_GOT_ENTRIES)
1777 #if defined(USE_PLT_ENTRIES)
1781 switch (ELF_R_TYPE(rel->r_info)) {
1782 #if defined(__arm__)
1797 #elif defined(__i386__)
1807 #elif defined(__powerpc__)
1812 #elif defined(__mc68000__)
1823 #elif defined(__sh__)
1833 #elif defined(__v850e__)
1834 case R_V850_22_PCREL:
1843 if (extsym->st_name != 0) {
1844 name = strtab + extsym->st_name;
1846 name = f->sections[extsym->st_shndx]->name;
1848 intsym = (struct arch_symbol *) obj_find_symbol(f, name);
1849 #if defined(USE_GOT_ENTRIES)
1851 got_offset += arch_single_init(
1852 /*rel,*/ &intsym->gotent,
1853 got_offset, GOT_ENTRY_SIZE);
1858 #if defined(USE_PLT_ENTRIES)
1860 #if defined(USE_PLT_LIST)
1861 plt_offset += arch_list_add(
1862 rel, &intsym->pltent,
1863 plt_offset, PLT_ENTRY_SIZE);
1865 plt_offset += arch_single_init(
1866 /*rel,*/ &intsym->pltent,
1867 plt_offset, PLT_ENTRY_SIZE);
1875 #if defined(USE_GOT_ENTRIES)
1877 ifile->got = arch_xsect_init(f, ".got", got_offset,
1882 #if defined(USE_PLT_ENTRIES)
1884 ifile->plt = arch_xsect_init(f, ".plt", plt_offset,
1889 #endif /* defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES) */
1892 /*======================================================================*/
1894 /* Standard ELF hash function. */
1895 static unsigned long obj_elf_hash_n(const char *name, unsigned long n)
1897 unsigned long h = 0;
1904 g = (h & 0xf0000000);
1914 static unsigned long FAST_FUNC obj_elf_hash(const char *name)
1916 return obj_elf_hash_n(name, strlen(name));
1919 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
1920 /* String comparison for non-co-versioned kernel and module. */
1922 static int ncv_strcmp(const char *a, const char *b)
1924 size_t alen = strlen(a), blen = strlen(b);
1926 if (blen == alen + 10 && b[alen] == '_' && b[alen + 1] == 'R')
1927 return strncmp(a, b, alen);
1928 else if (alen == blen + 10 && a[blen] == '_' && a[blen + 1] == 'R')
1929 return strncmp(a, b, blen);
1931 return strcmp(a, b);
1934 /* String hashing for non-co-versioned kernel and module. Here
1935 we are simply forced to drop the crc from the hash. */
1937 static unsigned long FAST_FUNC ncv_symbol_hash(const char *str)
1939 size_t len = strlen(str);
1940 if (len > 10 && str[len - 10] == '_' && str[len - 9] == 'R')
1942 return obj_elf_hash_n(str, len);
1946 obj_set_symbol_compare(struct obj_file *f,
1947 int (*cmp) (const char *, const char *),
1948 unsigned long (*hash) (const char *) FAST_FUNC)
1951 f->symbol_cmp = cmp;
1953 struct obj_symbol *tmptab[HASH_BUCKETS], *sym, *next;
1956 f->symbol_hash = hash;
1958 memcpy(tmptab, f->symtab, sizeof(tmptab));
1959 memset(f->symtab, 0, sizeof(f->symtab));
1961 for (i = 0; i < HASH_BUCKETS; ++i) {
1962 for (sym = tmptab[i]; sym; sym = next) {
1963 unsigned long h = hash(sym->name) % HASH_BUCKETS;
1965 sym->next = f->symtab[h];
1972 #endif /* FEATURE_INSMOD_VERSION_CHECKING */
1974 static struct obj_symbol *
1975 obj_add_symbol(struct obj_file *f, const char *name,
1976 unsigned long symidx, int info,
1977 int secidx, ElfW(Addr) value,
1980 struct obj_symbol *sym;
1981 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
1982 int n_type = ELF_ST_TYPE(info);
1983 int n_binding = ELF_ST_BIND(info);
1985 for (sym = f->symtab[hash]; sym; sym = sym->next) {
1986 if (f->symbol_cmp(sym->name, name) == 0) {
1987 int o_secidx = sym->secidx;
1988 int o_info = sym->info;
1989 int o_type = ELF_ST_TYPE(o_info);
1990 int o_binding = ELF_ST_BIND(o_info);
1992 /* A redefinition! Is it legal? */
1994 if (secidx == SHN_UNDEF)
1996 else if (o_secidx == SHN_UNDEF)
1998 else if (n_binding == STB_GLOBAL && o_binding == STB_LOCAL) {
1999 /* Cope with local and global symbols of the same name
2000 in the same object file, as might have been created
2001 by ld -r. The only reason locals are now seen at this
2002 level at all is so that we can do semi-sensible things
2005 struct obj_symbol *nsym, **p;
2007 nsym = arch_new_symbol();
2008 nsym->next = sym->next;
2011 /* Excise the old (local) symbol from the hash chain. */
2012 for (p = &f->symtab[hash]; *p != sym; p = &(*p)->next)
2016 } else if (n_binding == STB_LOCAL) {
2017 /* Another symbol of the same name has already been defined.
2018 Just add this to the local table. */
2019 sym = arch_new_symbol();
2022 f->local_symtab[symidx] = sym;
2024 } else if (n_binding == STB_WEAK)
2026 else if (o_binding == STB_WEAK)
2028 /* Don't unify COMMON symbols with object types the programmer
2030 else if (secidx == SHN_COMMON
2031 && (o_type == STT_NOTYPE || o_type == STT_OBJECT))
2033 else if (o_secidx == SHN_COMMON
2034 && (n_type == STT_NOTYPE || n_type == STT_OBJECT))
2037 /* Don't report an error if the symbol is coming from
2038 the kernel or some external module. */
2039 if (secidx <= SHN_HIRESERVE)
2040 bb_error_msg("%s multiply defined", name);
2046 /* Completely new symbol. */
2047 sym = arch_new_symbol();
2048 sym->next = f->symtab[hash];
2049 f->symtab[hash] = sym;
2051 if (ELF_ST_BIND(info) == STB_LOCAL && symidx != (unsigned long)(-1)) {
2052 if (symidx >= f->local_symtab_size)
2053 bb_error_msg("local symbol %s with index %ld exceeds local_symtab_size %ld",
2054 name, (long) symidx, (long) f->local_symtab_size);
2056 f->local_symtab[symidx] = sym;
2063 sym->secidx = secidx;
2069 static struct obj_symbol *
2070 obj_find_symbol(struct obj_file *f, const char *name)
2072 struct obj_symbol *sym;
2073 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
2075 for (sym = f->symtab[hash]; sym; sym = sym->next)
2076 if (f->symbol_cmp(sym->name, name) == 0)
2081 static ElfW(Addr) obj_symbol_final_value(struct obj_file * f, struct obj_symbol * sym)
2084 if (sym->secidx >= SHN_LORESERVE)
2086 return sym->value + f->sections[sym->secidx]->header.sh_addr;
2088 /* As a special case, a NULL sym has value zero. */
2092 static struct obj_section *obj_find_section(struct obj_file *f, const char *name)
2094 int i, n = f->header.e_shnum;
2096 for (i = 0; i < n; ++i)
2097 if (strcmp(f->sections[i]->name, name) == 0)
2098 return f->sections[i];
2102 static int obj_load_order_prio(struct obj_section *a)
2104 unsigned long af, ac;
2106 af = a->header.sh_flags;
2109 if (a->name[0] != '.' || strlen(a->name) != 10
2110 || strcmp(a->name + 5, ".init") != 0
2116 if (!(af & SHF_WRITE))
2118 if (af & SHF_EXECINSTR)
2120 if (a->header.sh_type != SHT_NOBITS)
2127 obj_insert_section_load_order(struct obj_file *f, struct obj_section *sec)
2129 struct obj_section **p;
2130 int prio = obj_load_order_prio(sec);
2131 for (p = f->load_order_search_start; *p; p = &(*p)->load_next)
2132 if (obj_load_order_prio(*p) < prio)
2134 sec->load_next = *p;
2138 static struct obj_section *helper_create_alloced_section(struct obj_file *f,
2140 unsigned long align,
2143 int newidx = f->header.e_shnum++;
2144 struct obj_section *sec;
2146 f->sections = xrealloc_vector(f->sections, 2, newidx);
2147 f->sections[newidx] = sec = arch_new_section();
2149 sec->header.sh_type = SHT_PROGBITS;
2150 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2151 sec->header.sh_size = size;
2152 sec->header.sh_addralign = align;
2156 sec->contents = xzalloc(size);
2161 static struct obj_section *obj_create_alloced_section(struct obj_file *f,
2163 unsigned long align,
2166 struct obj_section *sec;
2168 sec = helper_create_alloced_section(f, name, align, size);
2169 obj_insert_section_load_order(f, sec);
2173 static struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
2175 unsigned long align,
2178 struct obj_section *sec;
2180 sec = helper_create_alloced_section(f, name, align, size);
2181 sec->load_next = f->load_order;
2182 f->load_order = sec;
2183 if (f->load_order_search_start == &f->load_order)
2184 f->load_order_search_start = &sec->load_next;
2189 static void *obj_extend_section(struct obj_section *sec, unsigned long more)
2191 unsigned long oldsize = sec->header.sh_size;
2193 sec->header.sh_size += more;
2194 sec->contents = xrealloc(sec->contents, sec->header.sh_size);
2196 return sec->contents + oldsize;
2200 /* Conditionally add the symbols from the given symbol set to the
2203 static int add_symbols_from(struct obj_file *f,
2205 struct new_module_symbol *syms,
2208 struct new_module_symbol *s;
2211 #ifdef SYMBOL_PREFIX
2212 char *name_buf = NULL;
2213 size_t name_alloced_size = 0;
2215 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
2218 gpl = obj_gpl_license(f, NULL) == 0;
2220 for (i = 0, s = syms; i < nsyms; ++i, ++s) {
2221 /* Only add symbols that are already marked external.
2222 If we override locals we may cause problems for
2223 argument initialization. We will also create a false
2224 dependency on the module. */
2225 struct obj_symbol *sym;
2228 /* GPL licensed modules can use symbols exported with
2229 * EXPORT_SYMBOL_GPL, so ignore any GPLONLY_ prefix on the
2230 * exported names. Non-GPL modules never see any GPLONLY_
2231 * symbols so they cannot fudge it by adding the prefix on
2234 if (strncmp((char *)s->name, "GPLONLY_", 8) == 0) {
2235 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
2242 name = (char *)s->name;
2244 #ifdef SYMBOL_PREFIX
2245 /* Prepend SYMBOL_PREFIX to the symbol's name (the
2246 kernel exports `C names', but module object files
2247 reference `linker names'). */
2248 size_t extra = sizeof SYMBOL_PREFIX;
2249 size_t name_size = strlen(name) + extra;
2250 if (name_size > name_alloced_size) {
2251 name_alloced_size = name_size * 2;
2252 name_buf = alloca(name_alloced_size);
2254 strcpy(name_buf, SYMBOL_PREFIX);
2255 strcpy(name_buf + extra - 1, name);
2259 sym = obj_find_symbol(f, name);
2260 if (sym && !(ELF_ST_BIND(sym->info) == STB_LOCAL)) {
2261 #ifdef SYMBOL_PREFIX
2262 /* Put NAME_BUF into more permanent storage. */
2263 name = xmalloc(name_size);
2264 strcpy(name, name_buf);
2266 sym = obj_add_symbol(f, name, -1,
2267 ELF_ST_INFO(STB_GLOBAL,
2270 /* Did our symbol just get installed? If so, mark the
2271 module as "used". */
2272 if (sym->secidx == idx)
2280 static void add_kernel_symbols(struct obj_file *f)
2282 struct external_module *m;
2285 /* Add module symbols first. */
2287 for (i = 0, m = ext_modules; i < n_ext_modules; ++i, ++m) {
2289 && add_symbols_from(f, SHN_HIRESERVE + 2 + i, m->syms, m->nsyms)
2296 n_ext_modules_used = nused;
2298 /* And finally the symbols from the kernel proper. */
2301 add_symbols_from(f, SHN_HIRESERVE + 1, ksyms, nksyms);
2304 static char *get_modinfo_value(struct obj_file *f, const char *key)
2306 struct obj_section *sec;
2307 char *p, *v, *n, *ep;
2308 size_t klen = strlen(key);
2310 sec = obj_find_section(f, ".modinfo");
2314 ep = p + sec->header.sh_size;
2317 n = strchr(p, '\0');
2319 if (p + klen == v && strncmp(p, key, klen) == 0)
2322 if (p + klen == n && strcmp(p, key) == 0)
2332 /*======================================================================*/
2333 /* Functions relating to module loading after 2.1.18. */
2335 /* From Linux-2.6 sources */
2336 /* You can use " around spaces, but can't escape ". */
2337 /* Hyphens and underscores equivalent in parameter names. */
2338 static char *next_arg(char *args, char **param, char **val)
2340 unsigned int i, equals = 0;
2341 int in_quote = 0, quoted = 0;
2350 for (i = 0; args[i]; i++) {
2351 if (args[i] == ' ' && !in_quote)
2358 in_quote = !in_quote;
2365 args[equals] = '\0';
2366 *val = args + equals + 1;
2368 /* Don't include quotes in value. */
2371 if (args[i-1] == '"')
2374 if (quoted && args[i-1] == '"')
2380 next = args + i + 1;
2384 /* Chew up trailing spaces. */
2385 return skip_whitespace(next);
2389 new_process_module_arguments(struct obj_file *f, const char *options)
2391 char *xoptions, *pos;
2394 xoptions = pos = xstrdup(skip_whitespace(options));
2396 unsigned long charssize = 0;
2397 char *tmp, *contents, *loc, *pinfo, *p;
2398 struct obj_symbol *sym;
2399 int min, max, n, len;
2401 pos = next_arg(pos, ¶m, &val);
2403 tmp = xasprintf("parm_%s", param);
2404 pinfo = get_modinfo_value(f, tmp);
2407 bb_error_msg_and_die("invalid parameter %s", param);
2409 #ifdef SYMBOL_PREFIX
2410 tmp = xasprintf(SYMBOL_PREFIX "%s", param);
2411 sym = obj_find_symbol(f, tmp);
2414 sym = obj_find_symbol(f, param);
2417 /* Also check that the parameter was not resolved from the kernel. */
2418 if (sym == NULL || sym->secidx > SHN_HIRESERVE)
2419 bb_error_msg_and_die("symbol for parameter %s not found", param);
2421 /* Number of parameters */
2422 if (isdigit(*pinfo)) {
2423 min = strtoul(pinfo, &pinfo, 10);
2425 max = strtoul(pinfo + 1, &pinfo, 10);
2431 contents = f->sections[sym->secidx]->contents;
2432 loc = contents + sym->value;
2434 if (*pinfo == 'c') {
2435 if (!isdigit(pinfo[1])) {
2436 bb_error_msg_and_die("parameter type 'c' for %s must be followed by"
2437 " the maximum size", param);
2439 charssize = strtoul(pinfo + 1, NULL, 10);
2444 bb_error_msg_and_die("argument expected for parameter %s", param);
2448 /* Parse parameter values */
2455 bb_error_msg_and_die("too many values for %s (max %d)", param, max);
2459 len = strcspn(p, ",");
2461 obj_string_patch(f, sym->secidx,
2463 loc += tgt_sizeof_char_p;
2467 len = strcspn(p, ",");
2469 if (len >= charssize)
2470 bb_error_msg_and_die("string too long for %s (max %ld)", param,
2472 strcpy((char *) loc, p);
2477 *loc++ = strtoul(p, &endp, 0);
2478 p = endp; /* gcc likes temp var for &endp */
2481 *(short *) loc = strtoul(p, &endp, 0);
2482 loc += tgt_sizeof_short;
2486 *(int *) loc = strtoul(p, &endp, 0);
2487 loc += tgt_sizeof_int;
2491 *(long *) loc = strtoul(p, &endp, 0);
2492 loc += tgt_sizeof_long;
2496 bb_error_msg_and_die("unknown parameter type '%c' for %s",
2500 p = skip_whitespace(p);
2503 p = skip_whitespace(p + 1);
2507 bb_error_msg_and_die("parameter %s requires at least %d arguments", param, min);
2509 bb_error_msg_and_die("invalid argument syntax for %s", param);
2515 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
2516 static int new_is_module_checksummed(struct obj_file *f)
2518 const char *p = get_modinfo_value(f, "using_checksums");
2524 /* Get the module's kernel version in the canonical integer form. */
2527 new_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
2532 p = get_modinfo_value(f, "kernel_version");
2535 safe_strncpy(str, p, STRVERSIONLEN);
2537 a = strtoul(p, &p, 10);
2540 b = strtoul(p + 1, &p, 10);
2543 c = strtoul(p + 1, &q, 10);
2547 return a << 16 | b << 8 | c;
2550 #endif /* FEATURE_INSMOD_VERSION_CHECKING */
2553 /* Fetch the loaded modules, and all currently exported symbols. */
2555 static void new_get_kernel_symbols(void)
2557 char *module_names, *mn;
2558 struct external_module *modules, *m;
2559 struct new_module_symbol *syms, *s;
2560 size_t ret, bufsize, nmod, nsyms, i, j;
2562 /* Collect the loaded modules. */
2565 module_names = xmalloc(bufsize);
2568 if (query_module(NULL, QM_MODULES, module_names, bufsize, &ret)) {
2569 if (errno == ENOSPC && bufsize < ret) {
2571 module_names = xrealloc(module_names, bufsize);
2572 goto retry_modules_load;
2574 bb_perror_msg_and_die("QM_MODULES");
2577 n_ext_modules = nmod = ret;
2579 /* Collect the modules' symbols. */
2582 ext_modules = modules = xzalloc(nmod * sizeof(*modules));
2583 for (i = 0, mn = module_names, m = modules;
2584 i < nmod; ++i, ++m, mn += strlen(mn) + 1) {
2585 struct new_module_info info;
2587 if (query_module(mn, QM_INFO, &info, sizeof(info), &ret)) {
2588 if (errno == ENOENT) {
2589 /* The module was removed out from underneath us. */
2592 bb_perror_msg_and_die("query_module: QM_INFO: %s", mn);
2596 syms = xmalloc(bufsize);
2598 if (query_module(mn, QM_SYMBOLS, syms, bufsize, &ret)) {
2602 syms = xrealloc(syms, bufsize);
2603 goto retry_mod_sym_load;
2605 /* The module was removed out from underneath us. */
2608 bb_perror_msg_and_die("query_module: QM_SYMBOLS: %s", mn);
2614 m->addr = info.addr;
2618 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2619 s->name += (unsigned long) syms;
2624 /* Collect the kernel's symbols. */
2626 bufsize = 16 * 1024;
2627 syms = xmalloc(bufsize);
2628 retry_kern_sym_load:
2629 if (query_module(NULL, QM_SYMBOLS, syms, bufsize, &ret)) {
2630 if (errno == ENOSPC && bufsize < ret) {
2632 syms = xrealloc(syms, bufsize);
2633 goto retry_kern_sym_load;
2635 bb_perror_msg_and_die("kernel: QM_SYMBOLS");
2637 nksyms = nsyms = ret;
2640 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2641 s->name += (unsigned long) syms;
2646 /* Return the kernel symbol checksum version, or zero if not used. */
2648 static int new_is_kernel_checksummed(void)
2650 struct new_module_symbol *s;
2653 /* Using_Versions is not the first symbol, but it should be in there. */
2655 for (i = 0, s = ksyms; i < nksyms; ++i, ++s)
2656 if (strcmp((char *) s->name, "Using_Versions") == 0)
2663 static void new_create_this_module(struct obj_file *f, const char *m_name)
2665 struct obj_section *sec;
2667 sec = obj_create_alloced_section_first(f, ".this", tgt_sizeof_long,
2668 sizeof(struct new_module));
2669 /* done by obj_create_alloced_section_first: */
2670 /*memset(sec->contents, 0, sizeof(struct new_module));*/
2672 obj_add_symbol(f, SPFX "__this_module", -1,
2673 ELF_ST_INFO(STB_LOCAL, STT_OBJECT), sec->idx, 0,
2674 sizeof(struct new_module));
2676 obj_string_patch(f, sec->idx, offsetof(struct new_module, name),
2680 #if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
2681 /* add an entry to the __ksymtab section, creating it if necessary */
2682 static void new_add_ksymtab(struct obj_file *f, struct obj_symbol *sym)
2684 struct obj_section *sec;
2687 /* ensure __ksymtab is allocated, EXPORT_NOSYMBOLS creates a non-alloc section.
2688 * If __ksymtab is defined but not marked alloc, x out the first character
2689 * (no obj_delete routine) and create a new __ksymtab with the correct
2692 sec = obj_find_section(f, "__ksymtab");
2693 if (sec && !(sec->header.sh_flags & SHF_ALLOC)) {
2694 *((char *)(sec->name)) = 'x'; /* override const */
2698 sec = obj_create_alloced_section(f, "__ksymtab",
2699 tgt_sizeof_void_p, 0);
2702 sec->header.sh_flags |= SHF_ALLOC;
2703 /* Empty section might be byte-aligned */
2704 sec->header.sh_addralign = tgt_sizeof_void_p;
2705 ofs = sec->header.sh_size;
2706 obj_symbol_patch(f, sec->idx, ofs, sym);
2707 obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p, sym->name);
2708 obj_extend_section(sec, 2 * tgt_sizeof_char_p);
2710 #endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
2712 static int new_create_module_ksymtab(struct obj_file *f)
2714 struct obj_section *sec;
2717 /* We must always add the module references. */
2719 if (n_ext_modules_used) {
2720 struct new_module_ref *dep;
2721 struct obj_symbol *tm;
2723 sec = obj_create_alloced_section(f, ".kmodtab", tgt_sizeof_void_p,
2724 (sizeof(struct new_module_ref)
2725 * n_ext_modules_used));
2729 tm = obj_find_symbol(f, SPFX "__this_module");
2730 dep = (struct new_module_ref *) sec->contents;
2731 for (i = 0; i < n_ext_modules; ++i)
2732 if (ext_modules[i].used) {
2733 dep->dep = ext_modules[i].addr;
2734 obj_symbol_patch(f, sec->idx,
2735 (char *) &dep->ref - sec->contents, tm);
2741 if (!flag_noexport && !obj_find_section(f, "__ksymtab")) {
2745 sec = obj_create_alloced_section(f, "__ksymtab", tgt_sizeof_void_p, 0);
2747 /* We don't want to export symbols residing in sections that
2748 aren't loaded. There are a number of these created so that
2749 we make sure certain module options don't appear twice. */
2750 i = f->header.e_shnum;
2751 loaded = alloca(sizeof(int) * i);
2753 loaded[i] = (f->sections[i]->header.sh_flags & SHF_ALLOC) != 0;
2755 for (nsyms = i = 0; i < HASH_BUCKETS; ++i) {
2756 struct obj_symbol *sym;
2757 for (sym = f->symtab[i]; sym; sym = sym->next) {
2758 if (ELF_ST_BIND(sym->info) != STB_LOCAL
2759 && sym->secidx <= SHN_HIRESERVE
2760 && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx])
2762 ElfW(Addr) ofs = nsyms * 2 * tgt_sizeof_void_p;
2764 obj_symbol_patch(f, sec->idx, ofs, sym);
2765 obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p,
2772 obj_extend_section(sec, nsyms * 2 * tgt_sizeof_char_p);
2780 new_init_module(const char *m_name, struct obj_file *f, unsigned long m_size)
2782 struct new_module *module;
2783 struct obj_section *sec;
2788 sec = obj_find_section(f, ".this");
2789 if (!sec || !sec->contents) {
2790 bb_perror_msg_and_die("corrupt module %s?", m_name);
2792 module = (struct new_module *) sec->contents;
2793 m_addr = sec->header.sh_addr;
2795 module->size_of_struct = sizeof(*module);
2796 module->size = m_size;
2797 module->flags = flag_autoclean ? NEW_MOD_AUTOCLEAN : 0;
2799 sec = obj_find_section(f, "__ksymtab");
2800 if (sec && sec->header.sh_size) {
2801 module->syms = sec->header.sh_addr;
2802 module->nsyms = sec->header.sh_size / (2 * tgt_sizeof_char_p);
2805 if (n_ext_modules_used) {
2806 sec = obj_find_section(f, ".kmodtab");
2807 module->deps = sec->header.sh_addr;
2808 module->ndeps = n_ext_modules_used;
2811 module->init = obj_symbol_final_value(f, obj_find_symbol(f, SPFX "init_module"));
2812 module->cleanup = obj_symbol_final_value(f, obj_find_symbol(f, SPFX "cleanup_module"));
2814 sec = obj_find_section(f, "__ex_table");
2816 module->ex_table_start = sec->header.sh_addr;
2817 module->ex_table_end = sec->header.sh_addr + sec->header.sh_size;
2820 sec = obj_find_section(f, ".text.init");
2822 module->runsize = sec->header.sh_addr - m_addr;
2824 sec = obj_find_section(f, ".data.init");
2826 if (!module->runsize
2827 || module->runsize > sec->header.sh_addr - m_addr
2829 module->runsize = sec->header.sh_addr - m_addr;
2832 sec = obj_find_section(f, ARCHDATA_SEC_NAME);
2833 if (sec && sec->header.sh_size) {
2834 module->archdata_start = (void*)sec->header.sh_addr;
2835 module->archdata_end = module->archdata_start + sec->header.sh_size;
2837 sec = obj_find_section(f, KALLSYMS_SEC_NAME);
2838 if (sec && sec->header.sh_size) {
2839 module->kallsyms_start = (void*)sec->header.sh_addr;
2840 module->kallsyms_end = module->kallsyms_start + sec->header.sh_size;
2843 /* Whew! All of the initialization is complete. Collect the final
2844 module image and give it to the kernel. */
2846 image = xmalloc(m_size);
2847 obj_create_image(f, image);
2849 ret = init_module(m_name, (struct new_module *) image);
2851 bb_perror_msg("init_module: %s", m_name);
2859 /*======================================================================*/
2862 obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2865 struct obj_string_patch *p;
2866 struct obj_section *strsec;
2867 size_t len = strlen(string) + 1;
2870 p = xzalloc(sizeof(*p));
2871 p->next = f->string_patches;
2872 p->reloc_secidx = secidx;
2873 p->reloc_offset = offset;
2874 f->string_patches = p;
2876 strsec = obj_find_section(f, ".kstrtab");
2877 if (strsec == NULL) {
2878 strsec = obj_create_alloced_section(f, ".kstrtab", 1, len);
2879 /*p->string_offset = 0;*/
2880 loc = strsec->contents;
2882 p->string_offset = strsec->header.sh_size;
2883 loc = obj_extend_section(strsec, len);
2885 memcpy(loc, string, len);
2889 obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2890 struct obj_symbol *sym)
2892 struct obj_symbol_patch *p;
2894 p = xmalloc(sizeof(*p));
2895 p->next = f->symbol_patches;
2896 p->reloc_secidx = secidx;
2897 p->reloc_offset = offset;
2899 f->symbol_patches = p;
2902 static void obj_check_undefineds(struct obj_file *f)
2906 for (i = 0; i < HASH_BUCKETS; ++i) {
2907 struct obj_symbol *sym;
2908 for (sym = f->symtab[i]; sym; sym = sym->next) {
2909 if (sym->secidx == SHN_UNDEF) {
2910 if (ELF_ST_BIND(sym->info) == STB_WEAK) {
2911 sym->secidx = SHN_ABS;
2915 bb_error_msg_and_die("unresolved symbol %s", sym->name);
2922 static void obj_allocate_commons(struct obj_file *f)
2924 struct common_entry {
2925 struct common_entry *next;
2926 struct obj_symbol *sym;
2927 } *common_head = NULL;
2931 for (i = 0; i < HASH_BUCKETS; ++i) {
2932 struct obj_symbol *sym;
2933 for (sym = f->symtab[i]; sym; sym = sym->next) {
2934 if (sym->secidx == SHN_COMMON) {
2935 /* Collect all COMMON symbols and sort them by size so as to
2936 minimize space wasted by alignment requirements. */
2937 struct common_entry **p, *n;
2938 for (p = &common_head; *p; p = &(*p)->next)
2939 if (sym->size <= (*p)->sym->size)
2941 n = alloca(sizeof(*n));
2949 for (i = 1; i < f->local_symtab_size; ++i) {
2950 struct obj_symbol *sym = f->local_symtab[i];
2951 if (sym && sym->secidx == SHN_COMMON) {
2952 struct common_entry **p, *n;
2953 for (p = &common_head; *p; p = &(*p)->next) {
2954 if (sym == (*p)->sym)
2956 if (sym->size < (*p)->sym->size) {
2957 n = alloca(sizeof(*n));
2968 /* Find the bss section. */
2969 for (i = 0; i < f->header.e_shnum; ++i)
2970 if (f->sections[i]->header.sh_type == SHT_NOBITS)
2973 /* If for some reason there hadn't been one, create one. */
2974 if (i == f->header.e_shnum) {
2975 struct obj_section *sec;
2977 f->header.e_shnum++;
2978 f->sections = xrealloc_vector(f->sections, 2, i);
2979 f->sections[i] = sec = arch_new_section();
2981 sec->header.sh_type = SHT_PROGBITS;
2982 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2987 /* Allocate the COMMONS. */
2989 ElfW(Addr) bss_size = f->sections[i]->header.sh_size;
2990 ElfW(Addr) max_align = f->sections[i]->header.sh_addralign;
2991 struct common_entry *c;
2993 for (c = common_head; c; c = c->next) {
2994 ElfW(Addr) align = c->sym->value;
2996 if (align > max_align)
2998 if (bss_size & (align - 1))
2999 bss_size = (bss_size | (align - 1)) + 1;
3002 c->sym->value = bss_size;
3004 bss_size += c->sym->size;
3007 f->sections[i]->header.sh_size = bss_size;
3008 f->sections[i]->header.sh_addralign = max_align;
3012 /* For the sake of patch relocation and parameter initialization,
3013 allocate zeroed data for NOBITS sections now. Note that after
3014 this we cannot assume NOBITS are really empty. */
3015 for (i = 0; i < f->header.e_shnum; ++i) {
3016 struct obj_section *s = f->sections[i];
3017 if (s->header.sh_type == SHT_NOBITS) {
3019 if (s->header.sh_size != 0)
3020 s->contents = xzalloc(s->header.sh_size);
3021 s->header.sh_type = SHT_PROGBITS;
3026 static unsigned long obj_load_size(struct obj_file *f)
3028 unsigned long dot = 0;
3029 struct obj_section *sec;
3031 /* Finalize the positions of the sections relative to one another. */
3033 for (sec = f->load_order; sec; sec = sec->load_next) {
3036 align = sec->header.sh_addralign;
3037 if (align && (dot & (align - 1)))
3038 dot = (dot | (align - 1)) + 1;
3040 sec->header.sh_addr = dot;
3041 dot += sec->header.sh_size;
3047 static int obj_relocate(struct obj_file *f, ElfW(Addr) base)
3049 int i, n = f->header.e_shnum;
3052 /* Finalize the addresses of the sections. */
3055 for (i = 0; i < n; ++i)
3056 f->sections[i]->header.sh_addr += base;
3058 /* And iterate over all of the relocations. */
3060 for (i = 0; i < n; ++i) {
3061 struct obj_section *relsec, *symsec, *targsec, *strsec;
3062 ElfW(RelM) * rel, *relend;
3066 relsec = f->sections[i];
3067 if (relsec->header.sh_type != SHT_RELM)
3070 symsec = f->sections[relsec->header.sh_link];
3071 targsec = f->sections[relsec->header.sh_info];
3072 strsec = f->sections[symsec->header.sh_link];
3074 rel = (ElfW(RelM) *) relsec->contents;
3075 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
3076 symtab = (ElfW(Sym) *) symsec->contents;
3077 strtab = (const char *) strsec->contents;
3079 for (; rel < relend; ++rel) {
3080 ElfW(Addr) value = 0;
3081 struct obj_symbol *intsym = NULL;
3082 unsigned long symndx;
3083 ElfW(Sym) *extsym = NULL;
3086 /* Attempt to find a value to use for this relocation. */
3088 symndx = ELF_R_SYM(rel->r_info);
3090 /* Note we've already checked for undefined symbols. */
3092 extsym = &symtab[symndx];
3093 if (ELF_ST_BIND(extsym->st_info) == STB_LOCAL) {
3094 /* Local symbols we look up in the local table to be sure
3095 we get the one that is really intended. */
3096 intsym = f->local_symtab[symndx];
3098 /* Others we look up in the hash table. */
3100 if (extsym->st_name)
3101 name = strtab + extsym->st_name;
3103 name = f->sections[extsym->st_shndx]->name;
3104 intsym = obj_find_symbol(f, name);
3107 value = obj_symbol_final_value(f, intsym);
3108 intsym->referenced = 1;
3110 #if SHT_RELM == SHT_RELA
3111 #if defined(__alpha__) && defined(AXP_BROKEN_GAS)
3112 /* Work around a nasty GAS bug, that is fixed as of 2.7.0.9. */
3113 if (!extsym || !extsym->st_name
3114 || ELF_ST_BIND(extsym->st_info) != STB_LOCAL)
3116 value += rel->r_addend;
3120 switch (arch_apply_relocation
3121 (f, targsec, /*symsec,*/ intsym, rel, value)
3126 case obj_reloc_overflow:
3127 errmsg = "Relocation overflow";
3129 case obj_reloc_dangerous:
3130 errmsg = "Dangerous relocation";
3132 case obj_reloc_unhandled:
3133 errmsg = "Unhandled relocation";
3136 bb_error_msg("%s of type %ld for %s", errmsg,
3137 (long) ELF_R_TYPE(rel->r_info),
3138 strtab + extsym->st_name);
3140 bb_error_msg("%s of type %ld", errmsg,
3141 (long) ELF_R_TYPE(rel->r_info));
3149 /* Finally, take care of the patches. */
3151 if (f->string_patches) {
3152 struct obj_string_patch *p;
3153 struct obj_section *strsec;
3154 ElfW(Addr) strsec_base;
3155 strsec = obj_find_section(f, ".kstrtab");
3156 strsec_base = strsec->header.sh_addr;
3158 for (p = f->string_patches; p; p = p->next) {
3159 struct obj_section *targsec = f->sections[p->reloc_secidx];
3160 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
3161 = strsec_base + p->string_offset;
3165 if (f->symbol_patches) {
3166 struct obj_symbol_patch *p;
3168 for (p = f->symbol_patches; p; p = p->next) {
3169 struct obj_section *targsec = f->sections[p->reloc_secidx];
3170 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
3171 = obj_symbol_final_value(f, p->sym);
3178 static int obj_create_image(struct obj_file *f, char *image)
3180 struct obj_section *sec;
3181 ElfW(Addr) base = f->baseaddr;
3183 for (sec = f->load_order; sec; sec = sec->load_next) {
3186 if (sec->contents == 0 || sec->header.sh_size == 0)
3189 secimg = image + (sec->header.sh_addr - base);
3191 /* Note that we allocated data for NOBITS sections earlier. */
3192 memcpy(secimg, sec->contents, sec->header.sh_size);
3198 /*======================================================================*/
3200 static struct obj_file *obj_load(char *image, size_t image_size, int loadprogbits)
3202 #if BB_LITTLE_ENDIAN
3203 # define ELFMAG_U32 ((uint32_t)(ELFMAG0 + 0x100 * (ELFMAG1 + (0x100 * (ELFMAG2 + 0x100 * ELFMAG3)))))
3205 # define ELFMAG_U32 ((uint32_t)((((ELFMAG0 * 0x100) + ELFMAG1) * 0x100 + ELFMAG2) * 0x100 + ELFMAG3))
3208 ElfW(Shdr) * section_headers;
3212 /* Read the file header. */
3214 f = arch_new_file();
3215 f->symbol_cmp = strcmp;
3216 f->symbol_hash = obj_elf_hash;
3217 f->load_order_search_start = &f->load_order;
3219 if (image_size < sizeof(f->header))
3220 bb_error_msg_and_die("error while loading ELF header");
3221 memcpy(&f->header, image, sizeof(f->header));
3223 if (*(uint32_t*)(&f->header.e_ident) != ELFMAG_U32) {
3224 bb_error_msg_and_die("not an ELF file");
3226 if (f->header.e_ident[EI_CLASS] != ELFCLASSM
3227 || f->header.e_ident[EI_DATA] != (BB_BIG_ENDIAN ? ELFDATA2MSB : ELFDATA2LSB)
3228 || f->header.e_ident[EI_VERSION] != EV_CURRENT
3229 || !MATCH_MACHINE(f->header.e_machine)
3231 bb_error_msg_and_die("ELF file not for this architecture");
3233 if (f->header.e_type != ET_REL) {
3234 bb_error_msg_and_die("ELF file not a relocatable object");
3237 /* Read the section headers. */
3239 if (f->header.e_shentsize != sizeof(ElfW(Shdr))) {
3240 bb_error_msg_and_die("section header size mismatch: %lu != %lu",
3241 (unsigned long) f->header.e_shentsize,
3242 (unsigned long) sizeof(ElfW(Shdr)));
3245 shnum = f->header.e_shnum;
3246 /* Growth of ->sections vector will be done by
3247 * xrealloc_vector(..., 2, ...), therefore we must allocate
3248 * at least 2^2 = 4 extra elements here. */
3249 f->sections = xzalloc(sizeof(f->sections[0]) * (shnum + 4));
3251 section_headers = alloca(sizeof(ElfW(Shdr)) * shnum);
3252 if (image_size < f->header.e_shoff + sizeof(ElfW(Shdr)) * shnum)
3253 bb_error_msg_and_die("error while loading section headers");
3254 memcpy(section_headers, image + f->header.e_shoff, sizeof(ElfW(Shdr)) * shnum);
3256 /* Read the section data. */
3258 for (i = 0; i < shnum; ++i) {
3259 struct obj_section *sec;
3261 f->sections[i] = sec = arch_new_section();
3263 sec->header = section_headers[i];
3266 if (sec->header.sh_size) {
3267 switch (sec->header.sh_type) {
3275 if (!loadprogbits) {
3276 sec->contents = NULL;
3283 sec->contents = NULL;
3284 if (sec->header.sh_size > 0) {
3285 sec->contents = xmalloc(sec->header.sh_size);
3286 if (image_size < (sec->header.sh_offset + sec->header.sh_size))
3287 bb_error_msg_and_die("error while loading section data");
3288 memcpy(sec->contents, image + sec->header.sh_offset, sec->header.sh_size);
3291 #if SHT_RELM == SHT_REL
3293 bb_error_msg_and_die("RELA relocations not supported on this architecture");
3296 bb_error_msg_and_die("REL relocations not supported on this architecture");
3299 if (sec->header.sh_type >= SHT_LOPROC) {
3300 /* Assume processor specific section types are debug
3301 info and can safely be ignored. If this is ever not
3302 the case (Hello MIPS?), don't put ifdefs here but
3303 create an arch_load_proc_section(). */
3307 bb_error_msg_and_die("can't handle sections of type %ld",
3308 (long) sec->header.sh_type);
3313 /* Do what sort of interpretation as needed by each section. */
3315 shstrtab = f->sections[f->header.e_shstrndx]->contents;
3317 for (i = 0; i < shnum; ++i) {
3318 struct obj_section *sec = f->sections[i];
3319 sec->name = shstrtab + sec->header.sh_name;
3322 for (i = 0; i < shnum; ++i) {
3323 struct obj_section *sec = f->sections[i];
3325 /* .modinfo should be contents only but gcc has no attribute for that.
3326 * The kernel may have marked .modinfo as ALLOC, ignore this bit.
3328 if (strcmp(sec->name, ".modinfo") == 0)
3329 sec->header.sh_flags &= ~SHF_ALLOC;
3331 if (sec->header.sh_flags & SHF_ALLOC)
3332 obj_insert_section_load_order(f, sec);
3334 switch (sec->header.sh_type) {
3337 unsigned long nsym, j;
3341 if (sec->header.sh_entsize != sizeof(ElfW(Sym))) {
3342 bb_error_msg_and_die("symbol size mismatch: %lu != %lu",
3343 (unsigned long) sec->header.sh_entsize,
3344 (unsigned long) sizeof(ElfW(Sym)));
3347 nsym = sec->header.sh_size / sizeof(ElfW(Sym));
3348 strtab = f->sections[sec->header.sh_link]->contents;
3349 sym = (ElfW(Sym) *) sec->contents;
3351 /* Allocate space for a table of local symbols. */
3352 j = f->local_symtab_size = sec->header.sh_info;
3353 f->local_symtab = xzalloc(j * sizeof(struct obj_symbol *));
3355 /* Insert all symbols into the hash table. */
3356 for (j = 1, ++sym; j < nsym; ++j, ++sym) {
3357 ElfW(Addr) val = sym->st_value;
3360 name = strtab + sym->st_name;
3361 else if (sym->st_shndx < shnum)
3362 name = f->sections[sym->st_shndx]->name;
3365 #if defined(__SH5__)
3367 * For sh64 it is possible that the target of a branch
3368 * requires a mode switch (32 to 16 and back again).
3370 * This is implied by the lsb being set in the target
3371 * address for SHmedia mode and clear for SHcompact.
3373 val |= sym->st_other & 4;
3375 obj_add_symbol(f, name, j, sym->st_info, sym->st_shndx,
3382 if (sec->header.sh_entsize != sizeof(ElfW(RelM))) {
3383 bb_error_msg_and_die("relocation entry size mismatch: %lu != %lu",
3384 (unsigned long) sec->header.sh_entsize,
3385 (unsigned long) sizeof(ElfW(RelM)));
3388 /* XXX Relocation code from modutils-2.3.19 is not here.
3389 * Why? That's about 20 lines of code from obj/obj_load.c,
3390 * which gets done in a second pass through the sections.
3391 * This BusyBox insmod does similar work in obj_relocate(). */
3398 #if ENABLE_FEATURE_INSMOD_LOADINKMEM
3400 * load the unloaded sections directly into the memory allocated by
3401 * kernel for the module
3404 static int obj_load_progbits(char *image, size_t image_size, struct obj_file *f, char *imagebase)
3406 ElfW(Addr) base = f->baseaddr;
3407 struct obj_section* sec;
3409 for (sec = f->load_order; sec; sec = sec->load_next) {
3410 /* section already loaded? */
3411 if (sec->contents != NULL)
3413 if (sec->header.sh_size == 0)
3415 sec->contents = imagebase + (sec->header.sh_addr - base);
3416 if (image_size < (sec->header.sh_offset + sec->header.sh_size)) {
3417 bb_error_msg("error reading ELF section data");
3418 return 0; /* need to delete half-loaded module! */
3420 memcpy(sec->contents, image + sec->header.sh_offset, sec->header.sh_size);
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,
3497 const char *text1, const char *text2)
3499 static smallint printed_info;
3504 if (fd < 0 && !kernel_has_tainted)
3505 return; /* New modutils on old kernel */
3506 printf("Warning: loading %s will taint the kernel: %s%s\n",
3507 m_name, text1, text2);
3508 if (!printed_info) {
3509 printf(" See %s for information about tainted modules\n", TAINT_URL);
3513 read(fd, buf, sizeof(buf)-1);
3514 buf[sizeof(buf)-1] = '\0';
3515 oldval = strtoul(buf, NULL, 10);
3516 sprintf(buf, "%d\n", oldval | taint);
3517 xwrite_str(fd, buf);
3521 /* Check if loading this module will taint the kernel. */
3522 static void check_tainted_module(struct obj_file *f, const char *m_name)
3524 static const char tainted_file[] ALIGN1 = TAINT_FILENAME;
3526 int fd, kernel_has_tainted;
3529 kernel_has_tainted = 1;
3530 fd = open(tainted_file, O_RDWR);
3532 if (errno == ENOENT)
3533 kernel_has_tainted = 0;
3534 else if (errno == EACCES)
3535 kernel_has_tainted = 1;
3537 perror(tainted_file);
3538 kernel_has_tainted = 0;
3542 switch (obj_gpl_license(f, &ptr)) {
3546 set_tainted(fd, m_name, kernel_has_tainted, TAINT_PROPRIETORY_MODULE, "no license", "");
3548 default: /* case 2: */
3549 /* The module has a non-GPL license so we pretend that the
3550 * kernel always has a taint flag to get a warning even on
3551 * kernels without the proc flag.
3553 set_tainted(fd, m_name, 1, TAINT_PROPRIETORY_MODULE, "non-GPL license - ", ptr);
3557 if (flag_force_load)
3558 set_tainted(fd, m_name, 1, TAINT_FORCED_MODULE, "forced load", "");
3563 #else /* !FEATURE_CHECK_TAINTED_MODULE */
3564 #define check_tainted_module(x, y) do { } while (0);
3567 #if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
3568 /* add module source, timestamp, kernel version and a symbol for the
3569 * start of some sections. this info is used by ksymoops to do better
3572 #if !ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3573 #define get_module_version(f, str) get_module_version(str)
3576 get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
3578 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3579 return new_get_module_version(f, str);
3581 strncpy(str, "???", sizeof(str));
3586 /* add module source, timestamp, kernel version and a symbol for the
3587 * start of some sections. this info is used by ksymoops to do better
3591 add_ksymoops_symbols(struct obj_file *f, const char *filename,
3594 static const char symprefix[] ALIGN1 = "__insmod_";
3595 static const char section_names[][8] = {
3603 struct obj_section *sec;
3604 struct obj_symbol *sym;
3605 char *name, *absolute_filename;
3606 char str[STRVERSIONLEN];
3608 int lm_name, lfilename, use_ksymtab, version;
3609 struct stat statbuf;
3611 /* WARNING: was using realpath, but replaced by readlink to stop using
3612 * lots of stack. But here it seems to be able to cause problems? */
3613 absolute_filename = xmalloc_readlink(filename);
3614 if (!absolute_filename)
3615 absolute_filename = xstrdup(filename);
3617 lm_name = strlen(m_name);
3618 lfilename = strlen(absolute_filename);
3620 /* add to ksymtab if it already exists or there is no ksymtab and other symbols
3621 * are not to be exported. otherwise leave ksymtab alone for now, the
3622 * "export all symbols" compatibility code will export these symbols later.
3624 use_ksymtab = obj_find_section(f, "__ksymtab") || flag_noexport;
3626 sec = obj_find_section(f, ".this");
3628 /* tag the module header with the object name, last modified
3629 * timestamp and module version. worst case for module version
3630 * is 0xffffff, decimal 16777215. putting all three fields in
3631 * one symbol is less readable but saves kernel space.
3633 if (stat(absolute_filename, &statbuf) != 0)
3634 statbuf.st_mtime = 0;
3635 version = get_module_version(f, str); /* -1 if not found */
3636 name = xasprintf("%s%s_O%s_M%0*lX_V%d",
3637 symprefix, m_name, absolute_filename,
3638 (int)(2 * sizeof(statbuf.st_mtime)),
3639 (long)statbuf.st_mtime,
3641 sym = obj_add_symbol(f, name, -1,
3642 ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3643 sec->idx, sec->header.sh_addr, 0);
3645 new_add_ksymtab(f, sym);
3647 free(absolute_filename);
3648 #ifdef _NOT_SUPPORTED_
3649 /* record where the persistent data is going, same address as previous symbol */
3651 name = xasprintf("%s%s_P%s",
3652 symprefix, m_name, f->persist);
3653 sym = obj_add_symbol(f, name, -1, ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3654 sec->idx, sec->header.sh_addr, 0);
3656 new_add_ksymtab(f, sym);
3659 /* tag the desired sections if size is non-zero */
3660 for (i = 0; i < ARRAY_SIZE(section_names); ++i) {
3661 sec = obj_find_section(f, section_names[i]);
3662 if (sec && sec->header.sh_size) {
3663 name = xasprintf("%s%s_S%s_L%ld",
3664 symprefix, m_name, sec->name,
3665 (long)sec->header.sh_size);
3666 sym = obj_add_symbol(f, name, -1, ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3667 sec->idx, sec->header.sh_addr, 0);
3669 new_add_ksymtab(f, sym);
3673 #endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
3675 #if ENABLE_FEATURE_INSMOD_LOAD_MAP
3676 static void print_load_map(struct obj_file *f)
3678 struct obj_section *sec;
3679 #if ENABLE_FEATURE_INSMOD_LOAD_MAP_FULL
3680 struct obj_symbol **all, **p;
3682 char *loaded; /* array of booleans */
3683 struct obj_symbol *sym;
3685 /* Report on the section layout. */
3686 printf("Sections: Size %-*s Align\n",
3687 (int) (2 * sizeof(void *)), "Address");
3689 for (sec = f->load_order; sec; sec = sec->load_next) {
3693 for (a = -1, tmp = sec->header.sh_addralign; tmp; ++a)
3698 printf("%-15s %08lx %0*lx 2**%d\n",
3700 (long)sec->header.sh_size,
3701 (int) (2 * sizeof(void *)),
3702 (long)sec->header.sh_addr,
3705 #if ENABLE_FEATURE_INSMOD_LOAD_MAP_FULL
3706 /* Quick reference which section indices are loaded. */
3707 i = f->header.e_shnum;
3708 loaded = alloca(i * sizeof(loaded[0]));
3710 loaded[i] = ((f->sections[i]->header.sh_flags & SHF_ALLOC) != 0);
3712 /* Collect the symbols we'll be listing. */
3713 for (nsyms = i = 0; i < HASH_BUCKETS; ++i)
3714 for (sym = f->symtab[i]; sym; sym = sym->next)
3715 if (sym->secidx <= SHN_HIRESERVE
3716 && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx])
3721 all = alloca(nsyms * sizeof(all[0]));
3723 for (i = 0, p = all; i < HASH_BUCKETS; ++i)
3724 for (sym = f->symtab[i]; sym; sym = sym->next)
3725 if (sym->secidx <= SHN_HIRESERVE
3726 && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx])
3731 /* And list them. */
3732 printf("\nSymbols:\n");
3733 for (p = all; p < all + nsyms; ++p) {
3735 unsigned long value;
3738 if (sym->secidx == SHN_ABS) {
3741 } else if (sym->secidx == SHN_UNDEF) {
3745 sec = f->sections[sym->secidx];
3747 if (sec->header.sh_type == SHT_NOBITS)
3749 else if (sec->header.sh_flags & SHF_ALLOC) {
3750 if (sec->header.sh_flags & SHF_EXECINSTR)
3752 else if (sec->header.sh_flags & SHF_WRITE)
3757 value = sym->value + sec->header.sh_addr;
3760 if (ELF_ST_BIND(sym->info) == STB_LOCAL)
3761 type |= 0x20; /* tolower. safe for '?' too */
3763 printf("%0*lx %c %s\n", (int) (2 * sizeof(void *)), value,
3768 #else /* !FEATURE_INSMOD_LOAD_MAP */
3769 static void print_load_map(struct obj_file *f UNUSED_PARAM)
3774 int FAST_FUNC bb_init_module_24(const char *m_filename, const char *options)
3777 unsigned long m_size;
3780 int exit_status = EXIT_FAILURE;
3782 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3789 image_size = INT_MAX - 4095;
3791 image = try_to_mmap_module(m_filename, &image_size);
3795 /* Load module into memory and unzip if compressed */
3796 image = xmalloc_open_zipped_read_close(m_filename, &image_size);
3798 return EXIT_FAILURE;
3801 m_name = xstrdup(bb_basename(m_filename));
3802 /* "module.o[.gz]" -> "module" */
3803 *strchrnul(m_name, '.') = '\0';
3805 f = obj_load(image, image_size, LOADBITS);
3807 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3808 /* Version correspondence? */
3809 m_has_modinfo = (get_modinfo_value(f, "kernel_version") != NULL);
3811 char m_strversion[STRVERSIONLEN];
3814 if (m_has_modinfo) {
3815 int m_version = new_get_module_version(f, m_strversion);
3816 if (m_version == -1) {
3817 bb_error_msg_and_die("can't find the kernel version "
3818 "the module was compiled for");
3823 if (strncmp(uts.release, m_strversion, STRVERSIONLEN) != 0) {
3824 bb_error_msg("%skernel-module version mismatch\n"
3825 "\t%s was compiled for kernel version %s\n"
3826 "\twhile this kernel is version %s",
3827 flag_force_load ? "warning: " : "",
3828 m_name, m_strversion, uts.release);
3829 if (!flag_force_load)
3835 if (query_module(NULL, 0, NULL, 0, NULL))
3836 bb_error_msg_and_die("old (unsupported) kernel");
3837 new_get_kernel_symbols();
3838 k_crcs = new_is_kernel_checksummed();
3840 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3844 m_crcs = new_is_module_checksummed(f);
3845 if (m_crcs != k_crcs)
3846 obj_set_symbol_compare(f, ncv_strcmp, ncv_symbol_hash);
3850 /* Let the module know about the kernel symbols. */
3851 add_kernel_symbols(f);
3853 /* Allocate common symbols, symbol tables, and string tables. */
3854 new_create_this_module(f, m_name);
3855 obj_check_undefineds(f);
3856 obj_allocate_commons(f);
3857 check_tainted_module(f, m_name);
3859 /* Done with the module name, on to the optional var=value arguments */
3860 new_process_module_arguments(f, options);
3863 hide_special_symbols(f);
3865 #if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
3866 add_ksymoops_symbols(f, m_filename, m_name);
3869 new_create_module_ksymtab(f);
3871 /* Find current size of the module */
3872 m_size = obj_load_size(f);
3874 m_addr = create_module(m_name, m_size);
3875 if (m_addr == (ElfW(Addr))(-1)) switch (errno) {
3877 bb_error_msg_and_die("a module named %s already exists", m_name);
3879 bb_error_msg_and_die("can't allocate kernel memory for module; needed %lu bytes",
3882 bb_perror_msg_and_die("create_module: %s", m_name);
3887 * the PROGBITS section was not loaded by the obj_load
3888 * now we can load them directly into the kernel memory
3890 if (!obj_load_progbits(image, image_size, f, (char*)m_addr)) {
3891 delete_module(m_name, 0);
3896 if (!obj_relocate(f, m_addr)) {
3897 delete_module(m_name, 0);
3901 if (!new_init_module(m_name, f, m_size)) {
3902 delete_module(m_name, 0);
3906 if (flag_print_load_map)
3909 exit_status = EXIT_SUCCESS;
3913 munmap(image, image_size);