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
871 ret = obj_reloc_overflow;
873 *(unsigned short *)loc = v;
878 if ((ElfW(Sword))v > 0x7f
879 || (ElfW(Sword))v < -(ElfW(Sword))0x80
881 ret = obj_reloc_overflow;
883 *(unsigned char *)loc = v;
887 #elif defined(__i386__)
919 #elif defined(__microblaze__)
920 case R_MICROBLAZE_NONE:
921 case R_MICROBLAZE_64_NONE:
922 case R_MICROBLAZE_32_SYM_OP_SYM:
923 case R_MICROBLAZE_32_PCREL:
926 case R_MICROBLAZE_64_PCREL: {
927 /* dot is the address of the current instruction.
928 * v is the target symbol address.
929 * So we need to extract the offset in the code,
930 * adding v, then subtrating the current address
931 * of this instruction.
932 * Ex: "IMM 0xFFFE bralid 0x0000" = "bralid 0xFFFE0000"
935 /* Get split offset stored in code */
936 unsigned int temp = (loc[0] & 0xFFFF) << 16 |
939 /* Adjust relative offset. -4 adjustment required
940 * because dot points to the IMM insn, but branch
941 * is computed relative to the branch instruction itself.
945 /* Store back into code */
946 loc[0] = (loc[0] & 0xFFFF0000) | temp >> 16;
947 loc[1] = (loc[1] & 0xFFFF0000) | (temp & 0xFFFF);
952 case R_MICROBLAZE_32:
956 case R_MICROBLAZE_64: {
957 /* Get split pointer stored in code */
958 unsigned int temp1 = (loc[0] & 0xFFFF) << 16 |
961 /* Add reloc offset */
964 /* Store back into code */
965 loc[0] = (loc[0] & 0xFFFF0000) | temp1 >> 16;
966 loc[1] = (loc[1] & 0xFFFF0000) | (temp1 & 0xFFFF);
971 case R_MICROBLAZE_32_PCREL_LO:
972 case R_MICROBLAZE_32_LO:
973 case R_MICROBLAZE_SRO32:
974 case R_MICROBLAZE_SRW32:
975 ret = obj_reloc_unhandled;
978 #elif defined(__mc68000__)
989 ret = obj_reloc_overflow;
996 ret = obj_reloc_overflow;
1003 if ((ElfW(Sword))v > 0x7f
1004 || (ElfW(Sword))v < -(ElfW(Sword))0x80
1006 ret = obj_reloc_overflow;
1013 if ((ElfW(Sword))v > 0x7fff
1014 || (ElfW(Sword))v < -(ElfW(Sword))0x8000
1016 ret = obj_reloc_overflow;
1022 *(int *)loc = v - dot;
1025 case R_68K_GLOB_DAT:
1026 case R_68K_JMP_SLOT:
1030 case R_68K_RELATIVE:
1031 *(int *)loc += f->baseaddr;
1037 # ifdef R_68K_GOTOFF
1043 #elif defined(__mips__)
1054 ret = obj_reloc_dangerous;
1055 if ((v & 0xf0000000) != ((dot + 4) & 0xf0000000))
1056 ret = obj_reloc_overflow;
1058 (*loc & ~0x03ffffff) | ((*loc + (v >> 2)) &
1064 struct mips_hi16 *n;
1066 /* We cannot relocate this one now because we don't know the value
1067 of the carry we need to add. Save the information, and let LO16
1068 do the actual relocation. */
1069 n = xmalloc(sizeof *n);
1072 n->next = ifile->mips_hi16_list;
1073 ifile->mips_hi16_list = n;
1079 unsigned long insnlo = *loc;
1080 ElfW(Addr) val, vallo;
1082 /* Sign extend the addend we extract from the lo insn. */
1083 vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
1085 if (ifile->mips_hi16_list != NULL) {
1086 struct mips_hi16 *l;
1088 l = ifile->mips_hi16_list;
1090 struct mips_hi16 *next;
1093 /* Do the HI16 relocation. Note that we actually don't
1094 need to know anything about the LO16 itself, except where
1095 to find the low 16 bits of the addend needed by the LO16. */
1098 ((insn & 0xffff) << 16) +
1102 /* Account for the sign extension that will happen in the
1109 insn = (insn & ~0xffff) | val;
1117 ifile->mips_hi16_list = NULL;
1120 /* Ok, we're done with the HI16 relocs. Now deal with the LO16. */
1122 insnlo = (insnlo & ~0xffff) | (val & 0xffff);
1127 #elif defined(__nios2__)
1132 case R_NIOS2_BFD_RELOC_32:
1136 case R_NIOS2_BFD_RELOC_16:
1138 ret = obj_reloc_overflow;
1143 case R_NIOS2_BFD_RELOC_8:
1145 ret = obj_reloc_overflow;
1154 if ((Elf32_Sword)v > 0x7fff
1155 || (Elf32_Sword)v < -(Elf32_Sword)0x8000
1157 ret = obj_reloc_overflow;
1161 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1171 ret = obj_reloc_overflow;
1175 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1180 case R_NIOS2_PCREL16:
1185 if ((Elf32_Sword)v > 0x7fff
1186 || (Elf32_Sword)v < -(Elf32_Sword)0x8000
1188 ret = obj_reloc_overflow;
1192 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) | (word & 0x3f);
1198 Elf32_Addr word, gp;
1200 gp = obj_symbol_final_value(f, obj_find_symbol(f, SPFX "_gp"));
1202 if ((Elf32_Sword)v > 0x7fff
1203 || (Elf32_Sword)v < -(Elf32_Sword)0x8000
1205 ret = obj_reloc_overflow;
1209 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) | (word & 0x3f);
1213 case R_NIOS2_CALL26:
1215 ret = obj_reloc_dangerous;
1216 if ((v >> 28) != (dot >> 28))
1217 ret = obj_reloc_overflow;
1218 *loc = (*loc & 0x3f) | ((v >> 2) << 6);
1226 ret = obj_reloc_overflow;
1229 word = *loc & ~0x7c0;
1230 *loc = word | ((v & 0x1f) << 6);
1239 ret = obj_reloc_overflow;
1242 word = *loc & ~0xfc0;
1243 *loc = word | ((v & 0x3f) << 6);
1252 ret = obj_reloc_overflow;
1255 word = *loc & ~0x3fc0;
1256 *loc = word | ((v & 0xff) << 6);
1265 *loc = ((((word >> 22) << 16) | ((v >>16) & 0xffff)) << 6) |
1275 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1280 case R_NIOS2_HIADJ16:
1282 Elf32_Addr word1, word2;
1285 word2 = ((v >> 16) + ((v >> 15) & 1)) & 0xffff;
1286 *loc = ((((word1 >> 22) << 16) | word2) << 6) |
1291 #elif defined(__powerpc64__)
1292 /* PPC64 needs a 2.6 kernel, 2.4 module relocation irrelevant */
1294 #elif defined(__powerpc__)
1296 case R_PPC_ADDR16_HA:
1297 *(unsigned short *)loc = (v + 0x8000) >> 16;
1300 case R_PPC_ADDR16_HI:
1301 *(unsigned short *)loc = v >> 16;
1304 case R_PPC_ADDR16_LO:
1305 *(unsigned short *)loc = v;
1319 #elif defined(__s390__)
1322 *(unsigned int *) loc += v;
1325 *(unsigned short *) loc += v;
1328 *(unsigned char *) loc += v;
1332 *(unsigned int *) loc += v - dot;
1335 *(unsigned short *) loc += (v - dot) >> 1;
1338 *(unsigned short *) loc += v - dot;
1342 case R_390_PLT16DBL:
1343 /* find the plt entry and initialize it. */
1344 pe = (struct arch_single_entry *) &isym->pltent;
1345 if (pe->inited == 0) {
1346 ip = (unsigned long *)(ifile->plt->contents + pe->offset);
1347 ip[0] = 0x0d105810; /* basr 1,0; lg 1,10(1); br 1 */
1349 if (ELF_R_TYPE(rel->r_info) == R_390_PLT16DBL)
1356 /* Insert relative distance to target. */
1357 v = plt + pe->offset - dot;
1358 if (ELF_R_TYPE(rel->r_info) == R_390_PLT32)
1359 *(unsigned int *) loc = (unsigned int) v;
1360 else if (ELF_R_TYPE(rel->r_info) == R_390_PLT16DBL)
1361 *(unsigned short *) loc = (unsigned short) ((v + 2) >> 1);
1364 case R_390_GLOB_DAT:
1365 case R_390_JMP_SLOT:
1369 case R_390_RELATIVE:
1370 *loc += f->baseaddr;
1374 *(unsigned long *) loc += got - dot;
1380 if (!isym->gotent.inited)
1382 isym->gotent.inited = 1;
1383 *(ElfW(Addr) *)(ifile->got->contents + isym->gotent.offset) = v;
1385 if (ELF_R_TYPE(rel->r_info) == R_390_GOT12)
1386 *(unsigned short *) loc |= (*(unsigned short *) loc + isym->gotent.offset) & 0xfff;
1387 else if (ELF_R_TYPE(rel->r_info) == R_390_GOT16)
1388 *(unsigned short *) loc += isym->gotent.offset;
1389 else if (ELF_R_TYPE(rel->r_info) == R_390_GOT32)
1390 *(unsigned int *) loc += isym->gotent.offset;
1393 # ifndef R_390_GOTOFF32
1394 # define R_390_GOTOFF32 R_390_GOTOFF
1396 case R_390_GOTOFF32:
1400 #elif defined(__sh__)
1423 *loc = f->baseaddr + rel->r_addend;
1427 *loc = got - dot + rel->r_addend;
1437 # if defined(__SH5__)
1438 case R_SH_IMM_MEDLOW16:
1439 case R_SH_IMM_LOW16:
1443 if (ELF_R_TYPE(rel->r_info) == R_SH_IMM_MEDLOW16)
1447 * movi and shori have the format:
1449 * | op | imm | reg | reserved |
1450 * 31..26 25..10 9.. 4 3 .. 0
1452 * so we simply mask and or in imm.
1454 word = *loc & ~0x3fffc00;
1455 word |= (v & 0xffff) << 10;
1462 case R_SH_IMM_MEDLOW16_PCREL:
1463 case R_SH_IMM_LOW16_PCREL:
1467 word = *loc & ~0x3fffc00;
1471 if (ELF_R_TYPE(rel->r_info) == R_SH_IMM_MEDLOW16_PCREL)
1474 word |= (v & 0xffff) << 10;
1480 # endif /* __SH5__ */
1482 #elif defined(__v850e__)
1488 /* We write two shorts instead of a long because even
1489 32-bit insns only need half-word alignment, but
1490 32-bit data needs to be long-word aligned. */
1491 v += ((unsigned short *)loc)[0];
1492 v += ((unsigned short *)loc)[1] << 16;
1493 ((unsigned short *)loc)[0] = v & 0xffff;
1494 ((unsigned short *)loc)[1] = (v >> 16) & 0xffff;
1497 case R_V850_22_PCREL:
1500 #elif defined(__x86_64__)
1510 *(unsigned int *) loc += v;
1513 ret = obj_reloc_overflow; /* Kernel module compiled without -mcmodel=kernel. */
1514 /* error("Possibly is module compiled without -mcmodel=kernel!"); */
1519 *(signed int *) loc += v;
1523 *(unsigned short *) loc += v;
1527 *(unsigned char *) loc += v;
1531 *(unsigned int *) loc += v - dot;
1535 *(unsigned short *) loc += v - dot;
1539 *(unsigned char *) loc += v - dot;
1542 case R_X86_64_GLOB_DAT:
1543 case R_X86_64_JUMP_SLOT:
1547 case R_X86_64_RELATIVE:
1548 *loc += f->baseaddr;
1551 case R_X86_64_GOT32:
1552 case R_X86_64_GOTPCREL:
1555 if (!isym->gotent.reloc_done)
1557 isym->gotent.reloc_done = 1;
1558 *(Elf64_Addr *)(ifile->got->contents + isym->gotent.offset) = v;
1560 /* XXX are these really correct? */
1561 if (ELF64_R_TYPE(rel->r_info) == R_X86_64_GOTPCREL)
1562 *(unsigned int *) loc += v + isym->gotent.offset;
1564 *loc += isym->gotent.offset;
1569 # warning "no idea how to handle relocations on your arch"
1573 printf("Warning: unhandled reloc %d\n", (int)ELF_R_TYPE(rel->r_info));
1574 ret = obj_reloc_unhandled;
1577 #if defined(USE_PLT_ENTRIES)
1581 /* find the plt entry and initialize it if necessary */
1583 #if defined(USE_PLT_LIST)
1584 for (pe = isym->pltent; pe != NULL && pe->addend != rel->r_addend;)
1591 ip = (unsigned long *) (ifile->plt->contents + pe->offset);
1593 /* generate some machine code */
1595 #if defined(__arm__)
1596 ip[0] = 0xe51ff004; /* ldr pc,[pc,#-4] */
1597 ip[1] = v; /* sym@ */
1599 #if defined(__powerpc__)
1600 ip[0] = 0x3d600000 + ((v + 0x8000) >> 16); /* lis r11,sym@ha */
1601 ip[1] = 0x396b0000 + (v & 0xffff); /* addi r11,r11,sym@l */
1602 ip[2] = 0x7d6903a6; /* mtctr r11 */
1603 ip[3] = 0x4e800420; /* bctr */
1605 #if defined(__v850e__)
1606 /* We have to trash a register, so we assume that any control
1607 transfer more than 21-bits away must be a function call
1608 (so we can use a call-clobbered register). */
1609 ip[0] = 0x0621 + ((v & 0xffff) << 16); /* mov sym, r1 ... */
1610 ip[1] = ((v >> 16) & 0xffff) + 0x610000; /* ...; jmp r1 */
1615 /* relative distance to target */
1617 /* if the target is too far away.... */
1618 #if defined(__arm__) || defined(__powerpc__)
1619 if ((int)v < -0x02000000 || (int)v >= 0x02000000)
1620 #elif defined(__v850e__)
1621 if ((ElfW(Sword))v > 0x1fffff || (ElfW(Sword))v < (ElfW(Sword))-0x200000)
1623 /* go via the plt */
1624 v = plt + pe->offset - dot;
1626 #if defined(__v850e__)
1631 ret = obj_reloc_dangerous;
1633 /* merge the offset into the instruction. */
1634 #if defined(__arm__)
1635 /* Convert to words. */
1638 *loc = (*loc & ~0x00ffffff) | ((v + *loc) & 0x00ffffff);
1640 #if defined(__powerpc__)
1641 *loc = (*loc & ~0x03fffffc) | (v & 0x03fffffc);
1643 #if defined(__v850e__)
1644 /* We write two shorts instead of a long because even 32-bit insns
1645 only need half-word alignment, but the 32-bit data write needs
1646 to be long-word aligned. */
1647 ((unsigned short *)loc)[0] =
1648 (*(unsigned short *)loc & 0xffc0) /* opcode + reg */
1649 | ((v >> 16) & 0x3f); /* offs high part */
1650 ((unsigned short *)loc)[1] =
1651 (v & 0xffff); /* offs low part */
1654 #endif /* USE_PLT_ENTRIES */
1656 #if defined(USE_GOT_ENTRIES)
1659 /* needs an entry in the .got: set it, once */
1660 if (!isym->gotent.inited) {
1661 isym->gotent.inited = 1;
1662 *(ElfW(Addr) *) (ifile->got->contents + isym->gotent.offset) = v;
1664 /* make the reloc with_respect_to_.got */
1666 *loc += isym->gotent.offset + rel->r_addend;
1667 #elif defined(__i386__) || defined(__arm__) || defined(__mc68000__)
1668 *loc += isym->gotent.offset;
1672 #endif /* USE_GOT_ENTRIES */
1679 #if defined(USE_LIST)
1681 static int arch_list_add(ElfW(RelM) *rel, struct arch_list_entry **list,
1682 int offset, int size)
1684 struct arch_list_entry *pe;
1686 for (pe = *list; pe != NULL; pe = pe->next) {
1687 if (pe->addend == rel->r_addend) {
1693 pe = xzalloc(sizeof(struct arch_list_entry));
1695 pe->addend = rel->r_addend;
1696 pe->offset = offset;
1706 #if defined(USE_SINGLE)
1708 static int arch_single_init(/*ElfW(RelM) *rel,*/ struct arch_single_entry *single,
1709 int offset, int size)
1711 if (single->allocated == 0) {
1712 single->allocated = 1;
1713 single->offset = offset;
1722 #if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
1724 static struct obj_section *arch_xsect_init(struct obj_file *f, const char *name,
1725 int offset, int size)
1727 struct obj_section *myrelsec = obj_find_section(f, name);
1734 obj_extend_section(myrelsec, offset);
1736 myrelsec = obj_create_alloced_section(f, name,
1745 static void arch_create_got(struct obj_file *f)
1747 #if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
1748 struct arch_file *ifile = (struct arch_file *) f;
1750 #if defined(USE_GOT_ENTRIES)
1751 int got_offset = 0, got_needed = 0, got_allocate;
1753 #if defined(USE_PLT_ENTRIES)
1754 int plt_offset = 0, plt_needed = 0, plt_allocate;
1756 struct obj_section *relsec, *symsec, *strsec;
1757 ElfW(RelM) *rel, *relend;
1758 ElfW(Sym) *symtab, *extsym;
1759 const char *strtab, *name;
1760 struct arch_symbol *intsym;
1762 for (i = 0; i < f->header.e_shnum; ++i) {
1763 relsec = f->sections[i];
1764 if (relsec->header.sh_type != SHT_RELM)
1767 symsec = f->sections[relsec->header.sh_link];
1768 strsec = f->sections[symsec->header.sh_link];
1770 rel = (ElfW(RelM) *) relsec->contents;
1771 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
1772 symtab = (ElfW(Sym) *) symsec->contents;
1773 strtab = (const char *) strsec->contents;
1775 for (; rel < relend; ++rel) {
1776 extsym = &symtab[ELF_R_SYM(rel->r_info)];
1778 #if defined(USE_GOT_ENTRIES)
1781 #if defined(USE_PLT_ENTRIES)
1785 switch (ELF_R_TYPE(rel->r_info)) {
1786 #if defined(__arm__)
1801 #elif defined(__i386__)
1811 #elif defined(__powerpc__)
1816 #elif defined(__mc68000__)
1827 #elif defined(__sh__)
1837 #elif defined(__v850e__)
1838 case R_V850_22_PCREL:
1847 if (extsym->st_name != 0) {
1848 name = strtab + extsym->st_name;
1850 name = f->sections[extsym->st_shndx]->name;
1852 intsym = (struct arch_symbol *) obj_find_symbol(f, name);
1853 #if defined(USE_GOT_ENTRIES)
1855 got_offset += arch_single_init(
1856 /*rel,*/ &intsym->gotent,
1857 got_offset, GOT_ENTRY_SIZE);
1862 #if defined(USE_PLT_ENTRIES)
1864 #if defined(USE_PLT_LIST)
1865 plt_offset += arch_list_add(
1866 rel, &intsym->pltent,
1867 plt_offset, PLT_ENTRY_SIZE);
1869 plt_offset += arch_single_init(
1870 /*rel,*/ &intsym->pltent,
1871 plt_offset, PLT_ENTRY_SIZE);
1879 #if defined(USE_GOT_ENTRIES)
1881 ifile->got = arch_xsect_init(f, ".got", got_offset,
1886 #if defined(USE_PLT_ENTRIES)
1888 ifile->plt = arch_xsect_init(f, ".plt", plt_offset,
1893 #endif /* defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES) */
1896 /*======================================================================*/
1898 /* Standard ELF hash function. */
1899 static unsigned long obj_elf_hash_n(const char *name, unsigned long n)
1901 unsigned long h = 0;
1908 g = (h & 0xf0000000);
1918 static unsigned long FAST_FUNC obj_elf_hash(const char *name)
1920 return obj_elf_hash_n(name, strlen(name));
1923 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
1924 /* String comparison for non-co-versioned kernel and module. */
1926 static int ncv_strcmp(const char *a, const char *b)
1928 size_t alen = strlen(a), blen = strlen(b);
1930 if (blen == alen + 10 && b[alen] == '_' && b[alen + 1] == 'R')
1931 return strncmp(a, b, alen);
1932 else if (alen == blen + 10 && a[blen] == '_' && a[blen + 1] == 'R')
1933 return strncmp(a, b, blen);
1935 return strcmp(a, b);
1938 /* String hashing for non-co-versioned kernel and module. Here
1939 we are simply forced to drop the crc from the hash. */
1941 static unsigned long FAST_FUNC ncv_symbol_hash(const char *str)
1943 size_t len = strlen(str);
1944 if (len > 10 && str[len - 10] == '_' && str[len - 9] == 'R')
1946 return obj_elf_hash_n(str, len);
1950 obj_set_symbol_compare(struct obj_file *f,
1951 int (*cmp) (const char *, const char *),
1952 unsigned long (*hash) (const char *) FAST_FUNC)
1955 f->symbol_cmp = cmp;
1957 struct obj_symbol *tmptab[HASH_BUCKETS], *sym, *next;
1960 f->symbol_hash = hash;
1962 memcpy(tmptab, f->symtab, sizeof(tmptab));
1963 memset(f->symtab, 0, sizeof(f->symtab));
1965 for (i = 0; i < HASH_BUCKETS; ++i) {
1966 for (sym = tmptab[i]; sym; sym = next) {
1967 unsigned long h = hash(sym->name) % HASH_BUCKETS;
1969 sym->next = f->symtab[h];
1976 #endif /* FEATURE_INSMOD_VERSION_CHECKING */
1978 static struct obj_symbol *
1979 obj_add_symbol(struct obj_file *f, const char *name,
1980 unsigned long symidx, int info,
1981 int secidx, ElfW(Addr) value,
1984 struct obj_symbol *sym;
1985 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
1986 int n_type = ELF_ST_TYPE(info);
1987 int n_binding = ELF_ST_BIND(info);
1989 for (sym = f->symtab[hash]; sym; sym = sym->next) {
1990 if (f->symbol_cmp(sym->name, name) == 0) {
1991 int o_secidx = sym->secidx;
1992 int o_info = sym->info;
1993 int o_type = ELF_ST_TYPE(o_info);
1994 int o_binding = ELF_ST_BIND(o_info);
1996 /* A redefinition! Is it legal? */
1998 if (secidx == SHN_UNDEF)
2000 else if (o_secidx == SHN_UNDEF)
2002 else if (n_binding == STB_GLOBAL && o_binding == STB_LOCAL) {
2003 /* Cope with local and global symbols of the same name
2004 in the same object file, as might have been created
2005 by ld -r. The only reason locals are now seen at this
2006 level at all is so that we can do semi-sensible things
2009 struct obj_symbol *nsym, **p;
2011 nsym = arch_new_symbol();
2012 nsym->next = sym->next;
2015 /* Excise the old (local) symbol from the hash chain. */
2016 for (p = &f->symtab[hash]; *p != sym; p = &(*p)->next)
2020 } else if (n_binding == STB_LOCAL) {
2021 /* Another symbol of the same name has already been defined.
2022 Just add this to the local table. */
2023 sym = arch_new_symbol();
2026 f->local_symtab[symidx] = sym;
2028 } else if (n_binding == STB_WEAK)
2030 else if (o_binding == STB_WEAK)
2032 /* Don't unify COMMON symbols with object types the programmer
2034 else if (secidx == SHN_COMMON
2035 && (o_type == STT_NOTYPE || o_type == STT_OBJECT))
2037 else if (o_secidx == SHN_COMMON
2038 && (n_type == STT_NOTYPE || n_type == STT_OBJECT))
2041 /* Don't report an error if the symbol is coming from
2042 the kernel or some external module. */
2043 if (secidx <= SHN_HIRESERVE)
2044 bb_error_msg("%s multiply defined", name);
2050 /* Completely new symbol. */
2051 sym = arch_new_symbol();
2052 sym->next = f->symtab[hash];
2053 f->symtab[hash] = sym;
2055 if (ELF_ST_BIND(info) == STB_LOCAL && symidx != (unsigned long)(-1)) {
2056 if (symidx >= f->local_symtab_size)
2057 bb_error_msg("local symbol %s with index %ld exceeds local_symtab_size %ld",
2058 name, (long) symidx, (long) f->local_symtab_size);
2060 f->local_symtab[symidx] = sym;
2067 sym->secidx = secidx;
2073 static struct obj_symbol *
2074 obj_find_symbol(struct obj_file *f, const char *name)
2076 struct obj_symbol *sym;
2077 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
2079 for (sym = f->symtab[hash]; sym; sym = sym->next)
2080 if (f->symbol_cmp(sym->name, name) == 0)
2085 static ElfW(Addr) obj_symbol_final_value(struct obj_file * f, struct obj_symbol * sym)
2088 if (sym->secidx >= SHN_LORESERVE)
2090 return sym->value + f->sections[sym->secidx]->header.sh_addr;
2092 /* As a special case, a NULL sym has value zero. */
2096 static struct obj_section *obj_find_section(struct obj_file *f, const char *name)
2098 int i, n = f->header.e_shnum;
2100 for (i = 0; i < n; ++i)
2101 if (strcmp(f->sections[i]->name, name) == 0)
2102 return f->sections[i];
2106 static int obj_load_order_prio(struct obj_section *a)
2108 unsigned long af, ac;
2110 af = a->header.sh_flags;
2113 if (a->name[0] != '.' || strlen(a->name) != 10
2114 || strcmp(a->name + 5, ".init") != 0
2120 if (!(af & SHF_WRITE))
2122 if (af & SHF_EXECINSTR)
2124 if (a->header.sh_type != SHT_NOBITS)
2131 obj_insert_section_load_order(struct obj_file *f, struct obj_section *sec)
2133 struct obj_section **p;
2134 int prio = obj_load_order_prio(sec);
2135 for (p = f->load_order_search_start; *p; p = &(*p)->load_next)
2136 if (obj_load_order_prio(*p) < prio)
2138 sec->load_next = *p;
2142 static struct obj_section *helper_create_alloced_section(struct obj_file *f,
2144 unsigned long align,
2147 int newidx = f->header.e_shnum++;
2148 struct obj_section *sec;
2150 f->sections = xrealloc_vector(f->sections, 2, newidx);
2151 f->sections[newidx] = sec = arch_new_section();
2153 sec->header.sh_type = SHT_PROGBITS;
2154 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2155 sec->header.sh_size = size;
2156 sec->header.sh_addralign = align;
2160 sec->contents = xzalloc(size);
2165 static struct obj_section *obj_create_alloced_section(struct obj_file *f,
2167 unsigned long align,
2170 struct obj_section *sec;
2172 sec = helper_create_alloced_section(f, name, align, size);
2173 obj_insert_section_load_order(f, sec);
2177 static struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
2179 unsigned long align,
2182 struct obj_section *sec;
2184 sec = helper_create_alloced_section(f, name, align, size);
2185 sec->load_next = f->load_order;
2186 f->load_order = sec;
2187 if (f->load_order_search_start == &f->load_order)
2188 f->load_order_search_start = &sec->load_next;
2193 static void *obj_extend_section(struct obj_section *sec, unsigned long more)
2195 unsigned long oldsize = sec->header.sh_size;
2197 sec->header.sh_size += more;
2198 sec->contents = xrealloc(sec->contents, sec->header.sh_size);
2200 return sec->contents + oldsize;
2204 /* Conditionally add the symbols from the given symbol set to the
2207 static int add_symbols_from(struct obj_file *f,
2209 struct new_module_symbol *syms,
2212 struct new_module_symbol *s;
2215 #ifdef SYMBOL_PREFIX
2216 char *name_buf = NULL;
2217 size_t name_alloced_size = 0;
2219 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
2222 gpl = obj_gpl_license(f, NULL) == 0;
2224 for (i = 0, s = syms; i < nsyms; ++i, ++s) {
2225 /* Only add symbols that are already marked external.
2226 If we override locals we may cause problems for
2227 argument initialization. We will also create a false
2228 dependency on the module. */
2229 struct obj_symbol *sym;
2232 /* GPL licensed modules can use symbols exported with
2233 * EXPORT_SYMBOL_GPL, so ignore any GPLONLY_ prefix on the
2234 * exported names. Non-GPL modules never see any GPLONLY_
2235 * symbols so they cannot fudge it by adding the prefix on
2238 if (strncmp((char *)s->name, "GPLONLY_", 8) == 0) {
2239 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
2246 name = (char *)s->name;
2248 #ifdef SYMBOL_PREFIX
2249 /* Prepend SYMBOL_PREFIX to the symbol's name (the
2250 kernel exports `C names', but module object files
2251 reference `linker names'). */
2252 size_t extra = sizeof SYMBOL_PREFIX;
2253 size_t name_size = strlen(name) + extra;
2254 if (name_size > name_alloced_size) {
2255 name_alloced_size = name_size * 2;
2256 name_buf = alloca(name_alloced_size);
2258 strcpy(name_buf, SYMBOL_PREFIX);
2259 strcpy(name_buf + extra - 1, name);
2263 sym = obj_find_symbol(f, name);
2264 if (sym && !(ELF_ST_BIND(sym->info) == STB_LOCAL)) {
2265 #ifdef SYMBOL_PREFIX
2266 /* Put NAME_BUF into more permanent storage. */
2267 name = xmalloc(name_size);
2268 strcpy(name, name_buf);
2270 sym = obj_add_symbol(f, name, -1,
2271 ELF_ST_INFO(STB_GLOBAL,
2274 /* Did our symbol just get installed? If so, mark the
2275 module as "used". */
2276 if (sym->secidx == idx)
2284 static void add_kernel_symbols(struct obj_file *f)
2286 struct external_module *m;
2289 /* Add module symbols first. */
2291 for (i = 0, m = ext_modules; i < n_ext_modules; ++i, ++m) {
2293 && add_symbols_from(f, SHN_HIRESERVE + 2 + i, m->syms, m->nsyms)
2300 n_ext_modules_used = nused;
2302 /* And finally the symbols from the kernel proper. */
2305 add_symbols_from(f, SHN_HIRESERVE + 1, ksyms, nksyms);
2308 static char *get_modinfo_value(struct obj_file *f, const char *key)
2310 struct obj_section *sec;
2311 char *p, *v, *n, *ep;
2312 size_t klen = strlen(key);
2314 sec = obj_find_section(f, ".modinfo");
2318 ep = p + sec->header.sh_size;
2321 n = strchr(p, '\0');
2323 if (p + klen == v && strncmp(p, key, klen) == 0)
2326 if (p + klen == n && strcmp(p, key) == 0)
2336 /*======================================================================*/
2337 /* Functions relating to module loading after 2.1.18. */
2339 /* From Linux-2.6 sources */
2340 /* You can use " around spaces, but can't escape ". */
2341 /* Hyphens and underscores equivalent in parameter names. */
2342 static char *next_arg(char *args, char **param, char **val)
2344 unsigned int i, equals = 0;
2345 int in_quote = 0, quoted = 0;
2354 for (i = 0; args[i]; i++) {
2355 if (args[i] == ' ' && !in_quote)
2362 in_quote = !in_quote;
2369 args[equals] = '\0';
2370 *val = args + equals + 1;
2372 /* Don't include quotes in value. */
2375 if (args[i-1] == '"')
2378 if (quoted && args[i-1] == '"')
2384 next = args + i + 1;
2388 /* Chew up trailing spaces. */
2389 return skip_whitespace(next);
2393 new_process_module_arguments(struct obj_file *f, const char *options)
2395 char *xoptions, *pos;
2398 xoptions = pos = xstrdup(skip_whitespace(options));
2400 unsigned long charssize = 0;
2401 char *tmp, *contents, *loc, *pinfo, *p;
2402 struct obj_symbol *sym;
2403 int min, max, n, len;
2405 pos = next_arg(pos, ¶m, &val);
2407 tmp = xasprintf("parm_%s", param);
2408 pinfo = get_modinfo_value(f, tmp);
2411 bb_error_msg_and_die("invalid parameter %s", param);
2413 #ifdef SYMBOL_PREFIX
2414 tmp = xasprintf(SYMBOL_PREFIX "%s", param);
2415 sym = obj_find_symbol(f, tmp);
2418 sym = obj_find_symbol(f, param);
2421 /* Also check that the parameter was not resolved from the kernel. */
2422 if (sym == NULL || sym->secidx > SHN_HIRESERVE)
2423 bb_error_msg_and_die("symbol for parameter %s not found", param);
2425 /* Number of parameters */
2426 if (isdigit(*pinfo)) {
2427 min = strtoul(pinfo, &pinfo, 10);
2429 max = strtoul(pinfo + 1, &pinfo, 10);
2435 contents = f->sections[sym->secidx]->contents;
2436 loc = contents + sym->value;
2438 if (*pinfo == 'c') {
2439 if (!isdigit(pinfo[1])) {
2440 bb_error_msg_and_die("parameter type 'c' for %s must be followed by"
2441 " the maximum size", param);
2443 charssize = strtoul(pinfo + 1, NULL, 10);
2448 bb_error_msg_and_die("argument expected for parameter %s", param);
2452 /* Parse parameter values */
2459 bb_error_msg_and_die("too many values for %s (max %d)", param, max);
2463 len = strcspn(p, ",");
2465 obj_string_patch(f, sym->secidx,
2467 loc += tgt_sizeof_char_p;
2471 len = strcspn(p, ",");
2473 if (len >= charssize)
2474 bb_error_msg_and_die("string too long for %s (max %ld)", param,
2476 strcpy((char *) loc, p);
2481 *loc++ = strtoul(p, &endp, 0);
2482 p = endp; /* gcc likes temp var for &endp */
2485 *(short *) loc = strtoul(p, &endp, 0);
2486 loc += tgt_sizeof_short;
2490 *(int *) loc = strtoul(p, &endp, 0);
2491 loc += tgt_sizeof_int;
2495 *(long *) loc = strtoul(p, &endp, 0);
2496 loc += tgt_sizeof_long;
2500 bb_error_msg_and_die("unknown parameter type '%c' for %s",
2504 p = skip_whitespace(p);
2507 p = skip_whitespace(p + 1);
2511 bb_error_msg_and_die("parameter %s requires at least %d arguments", param, min);
2513 bb_error_msg_and_die("invalid argument syntax for %s", param);
2519 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
2520 static int new_is_module_checksummed(struct obj_file *f)
2522 const char *p = get_modinfo_value(f, "using_checksums");
2528 /* Get the module's kernel version in the canonical integer form. */
2531 new_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
2536 p = get_modinfo_value(f, "kernel_version");
2539 safe_strncpy(str, p, STRVERSIONLEN);
2541 a = strtoul(p, &p, 10);
2544 b = strtoul(p + 1, &p, 10);
2547 c = strtoul(p + 1, &q, 10);
2551 return a << 16 | b << 8 | c;
2554 #endif /* FEATURE_INSMOD_VERSION_CHECKING */
2557 /* Fetch the loaded modules, and all currently exported symbols. */
2559 static void new_get_kernel_symbols(void)
2561 char *module_names, *mn;
2562 struct external_module *modules, *m;
2563 struct new_module_symbol *syms, *s;
2564 size_t ret, bufsize, nmod, nsyms, i, j;
2566 /* Collect the loaded modules. */
2569 module_names = xmalloc(bufsize);
2572 if (query_module(NULL, QM_MODULES, module_names, bufsize, &ret)) {
2573 if (errno == ENOSPC && bufsize < ret) {
2575 module_names = xrealloc(module_names, bufsize);
2576 goto retry_modules_load;
2578 bb_perror_msg_and_die("QM_MODULES");
2581 n_ext_modules = nmod = ret;
2583 /* Collect the modules' symbols. */
2586 ext_modules = modules = xzalloc(nmod * sizeof(*modules));
2587 for (i = 0, mn = module_names, m = modules;
2588 i < nmod; ++i, ++m, mn += strlen(mn) + 1) {
2589 struct new_module_info info;
2591 if (query_module(mn, QM_INFO, &info, sizeof(info), &ret)) {
2592 if (errno == ENOENT) {
2593 /* The module was removed out from underneath us. */
2596 bb_perror_msg_and_die("query_module: QM_INFO: %s", mn);
2600 syms = xmalloc(bufsize);
2602 if (query_module(mn, QM_SYMBOLS, syms, bufsize, &ret)) {
2606 syms = xrealloc(syms, bufsize);
2607 goto retry_mod_sym_load;
2609 /* The module was removed out from underneath us. */
2612 bb_perror_msg_and_die("query_module: QM_SYMBOLS: %s", mn);
2618 m->addr = info.addr;
2622 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2623 s->name += (unsigned long) syms;
2628 /* Collect the kernel's symbols. */
2630 bufsize = 16 * 1024;
2631 syms = xmalloc(bufsize);
2632 retry_kern_sym_load:
2633 if (query_module(NULL, QM_SYMBOLS, syms, bufsize, &ret)) {
2634 if (errno == ENOSPC && bufsize < ret) {
2636 syms = xrealloc(syms, bufsize);
2637 goto retry_kern_sym_load;
2639 bb_perror_msg_and_die("kernel: QM_SYMBOLS");
2641 nksyms = nsyms = ret;
2644 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2645 s->name += (unsigned long) syms;
2650 /* Return the kernel symbol checksum version, or zero if not used. */
2652 static int new_is_kernel_checksummed(void)
2654 struct new_module_symbol *s;
2657 /* Using_Versions is not the first symbol, but it should be in there. */
2659 for (i = 0, s = ksyms; i < nksyms; ++i, ++s)
2660 if (strcmp((char *) s->name, "Using_Versions") == 0)
2667 static void new_create_this_module(struct obj_file *f, const char *m_name)
2669 struct obj_section *sec;
2671 sec = obj_create_alloced_section_first(f, ".this", tgt_sizeof_long,
2672 sizeof(struct new_module));
2673 /* done by obj_create_alloced_section_first: */
2674 /*memset(sec->contents, 0, sizeof(struct new_module));*/
2676 obj_add_symbol(f, SPFX "__this_module", -1,
2677 ELF_ST_INFO(STB_LOCAL, STT_OBJECT), sec->idx, 0,
2678 sizeof(struct new_module));
2680 obj_string_patch(f, sec->idx, offsetof(struct new_module, name),
2684 #if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
2685 /* add an entry to the __ksymtab section, creating it if necessary */
2686 static void new_add_ksymtab(struct obj_file *f, struct obj_symbol *sym)
2688 struct obj_section *sec;
2691 /* ensure __ksymtab is allocated, EXPORT_NOSYMBOLS creates a non-alloc section.
2692 * If __ksymtab is defined but not marked alloc, x out the first character
2693 * (no obj_delete routine) and create a new __ksymtab with the correct
2696 sec = obj_find_section(f, "__ksymtab");
2697 if (sec && !(sec->header.sh_flags & SHF_ALLOC)) {
2698 *((char *)(sec->name)) = 'x'; /* override const */
2702 sec = obj_create_alloced_section(f, "__ksymtab",
2703 tgt_sizeof_void_p, 0);
2706 sec->header.sh_flags |= SHF_ALLOC;
2707 /* Empty section might be byte-aligned */
2708 sec->header.sh_addralign = tgt_sizeof_void_p;
2709 ofs = sec->header.sh_size;
2710 obj_symbol_patch(f, sec->idx, ofs, sym);
2711 obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p, sym->name);
2712 obj_extend_section(sec, 2 * tgt_sizeof_char_p);
2714 #endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
2716 static int new_create_module_ksymtab(struct obj_file *f)
2718 struct obj_section *sec;
2721 /* We must always add the module references. */
2723 if (n_ext_modules_used) {
2724 struct new_module_ref *dep;
2725 struct obj_symbol *tm;
2727 sec = obj_create_alloced_section(f, ".kmodtab", tgt_sizeof_void_p,
2728 (sizeof(struct new_module_ref)
2729 * n_ext_modules_used));
2733 tm = obj_find_symbol(f, SPFX "__this_module");
2734 dep = (struct new_module_ref *) sec->contents;
2735 for (i = 0; i < n_ext_modules; ++i)
2736 if (ext_modules[i].used) {
2737 dep->dep = ext_modules[i].addr;
2738 obj_symbol_patch(f, sec->idx,
2739 (char *) &dep->ref - sec->contents, tm);
2745 if (!flag_noexport && !obj_find_section(f, "__ksymtab")) {
2749 sec = obj_create_alloced_section(f, "__ksymtab", tgt_sizeof_void_p, 0);
2751 /* We don't want to export symbols residing in sections that
2752 aren't loaded. There are a number of these created so that
2753 we make sure certain module options don't appear twice. */
2754 i = f->header.e_shnum;
2755 loaded = alloca(sizeof(int) * i);
2757 loaded[i] = (f->sections[i]->header.sh_flags & SHF_ALLOC) != 0;
2759 for (nsyms = i = 0; i < HASH_BUCKETS; ++i) {
2760 struct obj_symbol *sym;
2761 for (sym = f->symtab[i]; sym; sym = sym->next) {
2762 if (ELF_ST_BIND(sym->info) != STB_LOCAL
2763 && sym->secidx <= SHN_HIRESERVE
2764 && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx])
2766 ElfW(Addr) ofs = nsyms * 2 * tgt_sizeof_void_p;
2768 obj_symbol_patch(f, sec->idx, ofs, sym);
2769 obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p,
2776 obj_extend_section(sec, nsyms * 2 * tgt_sizeof_char_p);
2784 new_init_module(const char *m_name, struct obj_file *f, unsigned long m_size)
2786 struct new_module *module;
2787 struct obj_section *sec;
2792 sec = obj_find_section(f, ".this");
2793 if (!sec || !sec->contents) {
2794 bb_perror_msg_and_die("corrupt module %s?", m_name);
2796 module = (struct new_module *) sec->contents;
2797 m_addr = sec->header.sh_addr;
2799 module->size_of_struct = sizeof(*module);
2800 module->size = m_size;
2801 module->flags = flag_autoclean ? NEW_MOD_AUTOCLEAN : 0;
2803 sec = obj_find_section(f, "__ksymtab");
2804 if (sec && sec->header.sh_size) {
2805 module->syms = sec->header.sh_addr;
2806 module->nsyms = sec->header.sh_size / (2 * tgt_sizeof_char_p);
2809 if (n_ext_modules_used) {
2810 sec = obj_find_section(f, ".kmodtab");
2811 module->deps = sec->header.sh_addr;
2812 module->ndeps = n_ext_modules_used;
2815 module->init = obj_symbol_final_value(f, obj_find_symbol(f, SPFX "init_module"));
2816 module->cleanup = obj_symbol_final_value(f, obj_find_symbol(f, SPFX "cleanup_module"));
2818 sec = obj_find_section(f, "__ex_table");
2820 module->ex_table_start = sec->header.sh_addr;
2821 module->ex_table_end = sec->header.sh_addr + sec->header.sh_size;
2824 sec = obj_find_section(f, ".text.init");
2826 module->runsize = sec->header.sh_addr - m_addr;
2828 sec = obj_find_section(f, ".data.init");
2830 if (!module->runsize
2831 || module->runsize > sec->header.sh_addr - m_addr
2833 module->runsize = sec->header.sh_addr - m_addr;
2836 sec = obj_find_section(f, ARCHDATA_SEC_NAME);
2837 if (sec && sec->header.sh_size) {
2838 module->archdata_start = (void*)sec->header.sh_addr;
2839 module->archdata_end = module->archdata_start + sec->header.sh_size;
2841 sec = obj_find_section(f, KALLSYMS_SEC_NAME);
2842 if (sec && sec->header.sh_size) {
2843 module->kallsyms_start = (void*)sec->header.sh_addr;
2844 module->kallsyms_end = module->kallsyms_start + sec->header.sh_size;
2847 /* Whew! All of the initialization is complete. Collect the final
2848 module image and give it to the kernel. */
2850 image = xmalloc(m_size);
2851 obj_create_image(f, image);
2853 ret = init_module(m_name, (struct new_module *) image);
2855 bb_perror_msg("init_module: %s", m_name);
2863 /*======================================================================*/
2866 obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2869 struct obj_string_patch *p;
2870 struct obj_section *strsec;
2871 size_t len = strlen(string) + 1;
2874 p = xzalloc(sizeof(*p));
2875 p->next = f->string_patches;
2876 p->reloc_secidx = secidx;
2877 p->reloc_offset = offset;
2878 f->string_patches = p;
2880 strsec = obj_find_section(f, ".kstrtab");
2881 if (strsec == NULL) {
2882 strsec = obj_create_alloced_section(f, ".kstrtab", 1, len);
2883 /*p->string_offset = 0;*/
2884 loc = strsec->contents;
2886 p->string_offset = strsec->header.sh_size;
2887 loc = obj_extend_section(strsec, len);
2889 memcpy(loc, string, len);
2893 obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2894 struct obj_symbol *sym)
2896 struct obj_symbol_patch *p;
2898 p = xmalloc(sizeof(*p));
2899 p->next = f->symbol_patches;
2900 p->reloc_secidx = secidx;
2901 p->reloc_offset = offset;
2903 f->symbol_patches = p;
2906 static void obj_check_undefineds(struct obj_file *f)
2910 for (i = 0; i < HASH_BUCKETS; ++i) {
2911 struct obj_symbol *sym;
2912 for (sym = f->symtab[i]; sym; sym = sym->next) {
2913 if (sym->secidx == SHN_UNDEF) {
2914 if (ELF_ST_BIND(sym->info) == STB_WEAK) {
2915 sym->secidx = SHN_ABS;
2919 bb_error_msg_and_die("unresolved symbol %s", sym->name);
2926 static void obj_allocate_commons(struct obj_file *f)
2928 struct common_entry {
2929 struct common_entry *next;
2930 struct obj_symbol *sym;
2931 } *common_head = NULL;
2935 for (i = 0; i < HASH_BUCKETS; ++i) {
2936 struct obj_symbol *sym;
2937 for (sym = f->symtab[i]; sym; sym = sym->next) {
2938 if (sym->secidx == SHN_COMMON) {
2939 /* Collect all COMMON symbols and sort them by size so as to
2940 minimize space wasted by alignment requirements. */
2941 struct common_entry **p, *n;
2942 for (p = &common_head; *p; p = &(*p)->next)
2943 if (sym->size <= (*p)->sym->size)
2945 n = alloca(sizeof(*n));
2953 for (i = 1; i < f->local_symtab_size; ++i) {
2954 struct obj_symbol *sym = f->local_symtab[i];
2955 if (sym && sym->secidx == SHN_COMMON) {
2956 struct common_entry **p, *n;
2957 for (p = &common_head; *p; p = &(*p)->next) {
2958 if (sym == (*p)->sym)
2960 if (sym->size < (*p)->sym->size) {
2961 n = alloca(sizeof(*n));
2972 /* Find the bss section. */
2973 for (i = 0; i < f->header.e_shnum; ++i)
2974 if (f->sections[i]->header.sh_type == SHT_NOBITS)
2977 /* If for some reason there hadn't been one, create one. */
2978 if (i == f->header.e_shnum) {
2979 struct obj_section *sec;
2981 f->header.e_shnum++;
2982 f->sections = xrealloc_vector(f->sections, 2, i);
2983 f->sections[i] = sec = arch_new_section();
2985 sec->header.sh_type = SHT_PROGBITS;
2986 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2991 /* Allocate the COMMONS. */
2993 ElfW(Addr) bss_size = f->sections[i]->header.sh_size;
2994 ElfW(Addr) max_align = f->sections[i]->header.sh_addralign;
2995 struct common_entry *c;
2997 for (c = common_head; c; c = c->next) {
2998 ElfW(Addr) align = c->sym->value;
3000 if (align > max_align)
3002 if (bss_size & (align - 1))
3003 bss_size = (bss_size | (align - 1)) + 1;
3006 c->sym->value = bss_size;
3008 bss_size += c->sym->size;
3011 f->sections[i]->header.sh_size = bss_size;
3012 f->sections[i]->header.sh_addralign = max_align;
3016 /* For the sake of patch relocation and parameter initialization,
3017 allocate zeroed data for NOBITS sections now. Note that after
3018 this we cannot assume NOBITS are really empty. */
3019 for (i = 0; i < f->header.e_shnum; ++i) {
3020 struct obj_section *s = f->sections[i];
3021 if (s->header.sh_type == SHT_NOBITS) {
3023 if (s->header.sh_size != 0)
3024 s->contents = xzalloc(s->header.sh_size);
3025 s->header.sh_type = SHT_PROGBITS;
3030 static unsigned long obj_load_size(struct obj_file *f)
3032 unsigned long dot = 0;
3033 struct obj_section *sec;
3035 /* Finalize the positions of the sections relative to one another. */
3037 for (sec = f->load_order; sec; sec = sec->load_next) {
3040 align = sec->header.sh_addralign;
3041 if (align && (dot & (align - 1)))
3042 dot = (dot | (align - 1)) + 1;
3044 sec->header.sh_addr = dot;
3045 dot += sec->header.sh_size;
3051 static int obj_relocate(struct obj_file *f, ElfW(Addr) base)
3053 int i, n = f->header.e_shnum;
3056 /* Finalize the addresses of the sections. */
3059 for (i = 0; i < n; ++i)
3060 f->sections[i]->header.sh_addr += base;
3062 /* And iterate over all of the relocations. */
3064 for (i = 0; i < n; ++i) {
3065 struct obj_section *relsec, *symsec, *targsec, *strsec;
3066 ElfW(RelM) * rel, *relend;
3070 relsec = f->sections[i];
3071 if (relsec->header.sh_type != SHT_RELM)
3074 symsec = f->sections[relsec->header.sh_link];
3075 targsec = f->sections[relsec->header.sh_info];
3076 strsec = f->sections[symsec->header.sh_link];
3078 rel = (ElfW(RelM) *) relsec->contents;
3079 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
3080 symtab = (ElfW(Sym) *) symsec->contents;
3081 strtab = (const char *) strsec->contents;
3083 for (; rel < relend; ++rel) {
3084 ElfW(Addr) value = 0;
3085 struct obj_symbol *intsym = NULL;
3086 unsigned long symndx;
3087 ElfW(Sym) *extsym = NULL;
3090 /* Attempt to find a value to use for this relocation. */
3092 symndx = ELF_R_SYM(rel->r_info);
3094 /* Note we've already checked for undefined symbols. */
3096 extsym = &symtab[symndx];
3097 if (ELF_ST_BIND(extsym->st_info) == STB_LOCAL) {
3098 /* Local symbols we look up in the local table to be sure
3099 we get the one that is really intended. */
3100 intsym = f->local_symtab[symndx];
3102 /* Others we look up in the hash table. */
3104 if (extsym->st_name)
3105 name = strtab + extsym->st_name;
3107 name = f->sections[extsym->st_shndx]->name;
3108 intsym = obj_find_symbol(f, name);
3111 value = obj_symbol_final_value(f, intsym);
3112 intsym->referenced = 1;
3114 #if SHT_RELM == SHT_RELA
3115 #if defined(__alpha__) && defined(AXP_BROKEN_GAS)
3116 /* Work around a nasty GAS bug, that is fixed as of 2.7.0.9. */
3117 if (!extsym || !extsym->st_name
3118 || ELF_ST_BIND(extsym->st_info) != STB_LOCAL)
3120 value += rel->r_addend;
3124 switch (arch_apply_relocation
3125 (f, targsec, /*symsec,*/ intsym, rel, value)
3130 case obj_reloc_overflow:
3131 errmsg = "Relocation overflow";
3133 case obj_reloc_dangerous:
3134 errmsg = "Dangerous relocation";
3136 case obj_reloc_unhandled:
3137 errmsg = "Unhandled relocation";
3140 bb_error_msg("%s of type %ld for %s", errmsg,
3141 (long) ELF_R_TYPE(rel->r_info),
3142 strtab + extsym->st_name);
3144 bb_error_msg("%s of type %ld", errmsg,
3145 (long) ELF_R_TYPE(rel->r_info));
3153 /* Finally, take care of the patches. */
3155 if (f->string_patches) {
3156 struct obj_string_patch *p;
3157 struct obj_section *strsec;
3158 ElfW(Addr) strsec_base;
3159 strsec = obj_find_section(f, ".kstrtab");
3160 strsec_base = strsec->header.sh_addr;
3162 for (p = f->string_patches; p; p = p->next) {
3163 struct obj_section *targsec = f->sections[p->reloc_secidx];
3164 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
3165 = strsec_base + p->string_offset;
3169 if (f->symbol_patches) {
3170 struct obj_symbol_patch *p;
3172 for (p = f->symbol_patches; p; p = p->next) {
3173 struct obj_section *targsec = f->sections[p->reloc_secidx];
3174 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
3175 = obj_symbol_final_value(f, p->sym);
3182 static int obj_create_image(struct obj_file *f, char *image)
3184 struct obj_section *sec;
3185 ElfW(Addr) base = f->baseaddr;
3187 for (sec = f->load_order; sec; sec = sec->load_next) {
3190 if (sec->contents == 0 || sec->header.sh_size == 0)
3193 secimg = image + (sec->header.sh_addr - base);
3195 /* Note that we allocated data for NOBITS sections earlier. */
3196 memcpy(secimg, sec->contents, sec->header.sh_size);
3202 /*======================================================================*/
3204 static struct obj_file *obj_load(char *image, size_t image_size, int loadprogbits)
3206 typedef uint32_t aliased_uint32_t FIX_ALIASING;
3207 #if BB_LITTLE_ENDIAN
3208 # define ELFMAG_U32 ((uint32_t)(ELFMAG0 + 0x100 * (ELFMAG1 + (0x100 * (ELFMAG2 + 0x100 * ELFMAG3)))))
3210 # define ELFMAG_U32 ((uint32_t)((((ELFMAG0 * 0x100) + ELFMAG1) * 0x100 + ELFMAG2) * 0x100 + ELFMAG3))
3213 ElfW(Shdr) * section_headers;
3217 /* Read the file header. */
3219 f = arch_new_file();
3220 f->symbol_cmp = strcmp;
3221 f->symbol_hash = obj_elf_hash;
3222 f->load_order_search_start = &f->load_order;
3224 if (image_size < sizeof(f->header))
3225 bb_error_msg_and_die("error while loading ELF header");
3226 memcpy(&f->header, image, sizeof(f->header));
3228 if (*(aliased_uint32_t*)(&f->header.e_ident) != ELFMAG_U32) {
3229 bb_error_msg_and_die("not an ELF file");
3231 if (f->header.e_ident[EI_CLASS] != ELFCLASSM
3232 || f->header.e_ident[EI_DATA] != (BB_BIG_ENDIAN ? ELFDATA2MSB : ELFDATA2LSB)
3233 || f->header.e_ident[EI_VERSION] != EV_CURRENT
3234 || !MATCH_MACHINE(f->header.e_machine)
3236 bb_error_msg_and_die("ELF file not for this architecture");
3238 if (f->header.e_type != ET_REL) {
3239 bb_error_msg_and_die("ELF file not a relocatable object");
3242 /* Read the section headers. */
3244 if (f->header.e_shentsize != sizeof(ElfW(Shdr))) {
3245 bb_error_msg_and_die("section header size mismatch: %lu != %lu",
3246 (unsigned long) f->header.e_shentsize,
3247 (unsigned long) sizeof(ElfW(Shdr)));
3250 shnum = f->header.e_shnum;
3251 /* Growth of ->sections vector will be done by
3252 * xrealloc_vector(..., 2, ...), therefore we must allocate
3253 * at least 2^2 = 4 extra elements here. */
3254 f->sections = xzalloc(sizeof(f->sections[0]) * (shnum + 4));
3256 section_headers = alloca(sizeof(ElfW(Shdr)) * shnum);
3257 if (image_size < f->header.e_shoff + sizeof(ElfW(Shdr)) * shnum)
3258 bb_error_msg_and_die("error while loading section headers");
3259 memcpy(section_headers, image + f->header.e_shoff, sizeof(ElfW(Shdr)) * shnum);
3261 /* Read the section data. */
3263 for (i = 0; i < shnum; ++i) {
3264 struct obj_section *sec;
3266 f->sections[i] = sec = arch_new_section();
3268 sec->header = section_headers[i];
3271 if (sec->header.sh_size) {
3272 switch (sec->header.sh_type) {
3280 if (!loadprogbits) {
3281 sec->contents = NULL;
3288 #if defined(__mips__)
3289 case SHT_MIPS_DWARF:
3291 sec->contents = NULL;
3292 if (sec->header.sh_size > 0) {
3293 sec->contents = xmalloc(sec->header.sh_size);
3294 if (image_size < (sec->header.sh_offset + sec->header.sh_size))
3295 bb_error_msg_and_die("error while loading section data");
3296 memcpy(sec->contents, image + sec->header.sh_offset, sec->header.sh_size);
3299 #if SHT_RELM == SHT_REL
3301 bb_error_msg_and_die("RELA relocations not supported on this architecture");
3304 bb_error_msg_and_die("REL relocations not supported on this architecture");
3307 if (sec->header.sh_type >= SHT_LOPROC) {
3308 /* Assume processor specific section types are debug
3309 info and can safely be ignored. If this is ever not
3310 the case (Hello MIPS?), don't put ifdefs here but
3311 create an arch_load_proc_section(). */
3315 bb_error_msg_and_die("can't handle sections of type %ld",
3316 (long) sec->header.sh_type);
3321 /* Do what sort of interpretation as needed by each section. */
3323 shstrtab = f->sections[f->header.e_shstrndx]->contents;
3325 for (i = 0; i < shnum; ++i) {
3326 struct obj_section *sec = f->sections[i];
3327 sec->name = shstrtab + sec->header.sh_name;
3330 for (i = 0; i < shnum; ++i) {
3331 struct obj_section *sec = f->sections[i];
3333 /* .modinfo should be contents only but gcc has no attribute for that.
3334 * The kernel may have marked .modinfo as ALLOC, ignore this bit.
3336 if (strcmp(sec->name, ".modinfo") == 0)
3337 sec->header.sh_flags &= ~SHF_ALLOC;
3339 if (sec->header.sh_flags & SHF_ALLOC)
3340 obj_insert_section_load_order(f, sec);
3342 switch (sec->header.sh_type) {
3345 unsigned long nsym, j;
3349 if (sec->header.sh_entsize != sizeof(ElfW(Sym))) {
3350 bb_error_msg_and_die("symbol size mismatch: %lu != %lu",
3351 (unsigned long) sec->header.sh_entsize,
3352 (unsigned long) sizeof(ElfW(Sym)));
3355 nsym = sec->header.sh_size / sizeof(ElfW(Sym));
3356 strtab = f->sections[sec->header.sh_link]->contents;
3357 sym = (ElfW(Sym) *) sec->contents;
3359 /* Allocate space for a table of local symbols. */
3360 j = f->local_symtab_size = sec->header.sh_info;
3361 f->local_symtab = xzalloc(j * sizeof(struct obj_symbol *));
3363 /* Insert all symbols into the hash table. */
3364 for (j = 1, ++sym; j < nsym; ++j, ++sym) {
3365 ElfW(Addr) val = sym->st_value;
3368 name = strtab + sym->st_name;
3369 else if (sym->st_shndx < shnum)
3370 name = f->sections[sym->st_shndx]->name;
3373 #if defined(__SH5__)
3375 * For sh64 it is possible that the target of a branch
3376 * requires a mode switch (32 to 16 and back again).
3378 * This is implied by the lsb being set in the target
3379 * address for SHmedia mode and clear for SHcompact.
3381 val |= sym->st_other & 4;
3383 obj_add_symbol(f, name, j, sym->st_info, sym->st_shndx,
3390 if (sec->header.sh_entsize != sizeof(ElfW(RelM))) {
3391 bb_error_msg_and_die("relocation entry size mismatch: %lu != %lu",
3392 (unsigned long) sec->header.sh_entsize,
3393 (unsigned long) sizeof(ElfW(RelM)));
3396 /* XXX Relocation code from modutils-2.3.19 is not here.
3397 * Why? That's about 20 lines of code from obj/obj_load.c,
3398 * which gets done in a second pass through the sections.
3399 * This BusyBox insmod does similar work in obj_relocate(). */
3406 #if ENABLE_FEATURE_INSMOD_LOADINKMEM
3408 * load the unloaded sections directly into the memory allocated by
3409 * kernel for the module
3412 static int obj_load_progbits(char *image, size_t image_size, struct obj_file *f, char *imagebase)
3414 ElfW(Addr) base = f->baseaddr;
3415 struct obj_section* sec;
3417 for (sec = f->load_order; sec; sec = sec->load_next) {
3418 /* section already loaded? */
3419 if (sec->contents != NULL)
3421 if (sec->header.sh_size == 0)
3423 sec->contents = imagebase + (sec->header.sh_addr - base);
3424 if (image_size < (sec->header.sh_offset + sec->header.sh_size)) {
3425 bb_error_msg("error reading ELF section data");
3426 return 0; /* need to delete half-loaded module! */
3428 memcpy(sec->contents, image + sec->header.sh_offset, sec->header.sh_size);
3434 static void hide_special_symbols(struct obj_file *f)
3436 static const char *const specials[] = {
3437 SPFX "cleanup_module",
3439 SPFX "kernel_version",
3443 struct obj_symbol *sym;
3444 const char *const *p;
3446 for (p = specials; *p; ++p) {
3447 sym = obj_find_symbol(f, *p);
3449 sym->info = ELF_ST_INFO(STB_LOCAL, ELF_ST_TYPE(sym->info));
3454 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
3455 static int obj_gpl_license(struct obj_file *f, const char **license)
3457 struct obj_section *sec;
3458 /* This list must match *exactly* the list of allowable licenses in
3459 * linux/include/linux/module.h. Checking for leading "GPL" will not
3460 * work, somebody will use "GPL sucks, this is proprietary".
3462 static const char *const gpl_licenses[] = {
3465 "GPL and additional rights",
3470 sec = obj_find_section(f, ".modinfo");
3472 const char *value, *ptr, *endptr;
3473 ptr = sec->contents;
3474 endptr = ptr + sec->header.sh_size;
3475 while (ptr < endptr) {
3476 value = strchr(ptr, '=');
3477 if (value && strncmp(ptr, "license", value-ptr) == 0) {
3481 for (i = 0; i < ARRAY_SIZE(gpl_licenses); ++i) {
3482 if (strcmp(value+1, gpl_licenses[i]) == 0)
3487 ptr = strchr(ptr, '\0');
3497 #define TAINT_FILENAME "/proc/sys/kernel/tainted"
3498 #define TAINT_PROPRIETORY_MODULE (1 << 0)
3499 #define TAINT_FORCED_MODULE (1 << 1)
3500 #define TAINT_UNSAFE_SMP (1 << 2)
3501 #define TAINT_URL "http://www.tux.org/lkml/#export-tainted"
3503 static void set_tainted(int fd, const char *m_name,
3504 int kernel_has_tainted, int taint,
3505 const char *text1, const char *text2)
3507 static smallint printed_info;
3512 if (fd < 0 && !kernel_has_tainted)
3513 return; /* New modutils on old kernel */
3514 printf("Warning: loading %s will taint the kernel: %s%s\n",
3515 m_name, text1, text2);
3516 if (!printed_info) {
3517 printf(" See %s for information about tainted modules\n", TAINT_URL);
3521 read(fd, buf, sizeof(buf)-1);
3522 buf[sizeof(buf)-1] = '\0';
3523 oldval = strtoul(buf, NULL, 10);
3524 sprintf(buf, "%d\n", oldval | taint);
3525 xwrite_str(fd, buf);
3529 /* Check if loading this module will taint the kernel. */
3530 static void check_tainted_module(struct obj_file *f, const char *m_name)
3532 static const char tainted_file[] ALIGN1 = TAINT_FILENAME;
3534 int fd, kernel_has_tainted;
3537 kernel_has_tainted = 1;
3538 fd = open(tainted_file, O_RDWR);
3540 if (errno == ENOENT)
3541 kernel_has_tainted = 0;
3542 else if (errno == EACCES)
3543 kernel_has_tainted = 1;
3545 perror(tainted_file);
3546 kernel_has_tainted = 0;
3550 switch (obj_gpl_license(f, &ptr)) {
3554 set_tainted(fd, m_name, kernel_has_tainted, TAINT_PROPRIETORY_MODULE, "no license", "");
3556 default: /* case 2: */
3557 /* The module has a non-GPL license so we pretend that the
3558 * kernel always has a taint flag to get a warning even on
3559 * kernels without the proc flag.
3561 set_tainted(fd, m_name, 1, TAINT_PROPRIETORY_MODULE, "non-GPL license - ", ptr);
3565 if (flag_force_load)
3566 set_tainted(fd, m_name, 1, TAINT_FORCED_MODULE, "forced load", "");
3571 #else /* !FEATURE_CHECK_TAINTED_MODULE */
3572 #define check_tainted_module(x, y) do { } while (0);
3575 #if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
3576 /* add module source, timestamp, kernel version and a symbol for the
3577 * start of some sections. this info is used by ksymoops to do better
3580 #if !ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3581 #define get_module_version(f, str) get_module_version(str)
3584 get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
3586 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3587 return new_get_module_version(f, str);
3589 strncpy(str, "???", sizeof(str));
3594 /* add module source, timestamp, kernel version and a symbol for the
3595 * start of some sections. this info is used by ksymoops to do better
3599 add_ksymoops_symbols(struct obj_file *f, const char *filename,
3602 static const char symprefix[] ALIGN1 = "__insmod_";
3603 static const char section_names[][8] = {
3611 struct obj_section *sec;
3612 struct obj_symbol *sym;
3613 char *name, *absolute_filename;
3614 char str[STRVERSIONLEN];
3616 int lm_name, lfilename, use_ksymtab, version;
3617 struct stat statbuf;
3619 /* WARNING: was using realpath, but replaced by readlink to stop using
3620 * lots of stack. But here it seems to be able to cause problems? */
3621 absolute_filename = xmalloc_readlink(filename);
3622 if (!absolute_filename)
3623 absolute_filename = xstrdup(filename);
3625 lm_name = strlen(m_name);
3626 lfilename = strlen(absolute_filename);
3628 /* add to ksymtab if it already exists or there is no ksymtab and other symbols
3629 * are not to be exported. otherwise leave ksymtab alone for now, the
3630 * "export all symbols" compatibility code will export these symbols later.
3632 use_ksymtab = obj_find_section(f, "__ksymtab") || flag_noexport;
3634 sec = obj_find_section(f, ".this");
3636 /* tag the module header with the object name, last modified
3637 * timestamp and module version. worst case for module version
3638 * is 0xffffff, decimal 16777215. putting all three fields in
3639 * one symbol is less readable but saves kernel space.
3641 if (stat(absolute_filename, &statbuf) != 0)
3642 statbuf.st_mtime = 0;
3643 version = get_module_version(f, str); /* -1 if not found */
3644 name = xasprintf("%s%s_O%s_M%0*lX_V%d",
3645 symprefix, m_name, absolute_filename,
3646 (int)(2 * sizeof(statbuf.st_mtime)),
3647 (long)statbuf.st_mtime,
3649 sym = obj_add_symbol(f, name, -1,
3650 ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3651 sec->idx, sec->header.sh_addr, 0);
3653 new_add_ksymtab(f, sym);
3655 free(absolute_filename);
3656 #ifdef _NOT_SUPPORTED_
3657 /* record where the persistent data is going, same address as previous symbol */
3659 name = xasprintf("%s%s_P%s",
3660 symprefix, m_name, f->persist);
3661 sym = obj_add_symbol(f, name, -1, ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3662 sec->idx, sec->header.sh_addr, 0);
3664 new_add_ksymtab(f, sym);
3667 /* tag the desired sections if size is non-zero */
3668 for (i = 0; i < ARRAY_SIZE(section_names); ++i) {
3669 sec = obj_find_section(f, section_names[i]);
3670 if (sec && sec->header.sh_size) {
3671 name = xasprintf("%s%s_S%s_L%ld",
3672 symprefix, m_name, sec->name,
3673 (long)sec->header.sh_size);
3674 sym = obj_add_symbol(f, name, -1, ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3675 sec->idx, sec->header.sh_addr, 0);
3677 new_add_ksymtab(f, sym);
3681 #endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
3683 #if ENABLE_FEATURE_INSMOD_LOAD_MAP
3684 static void print_load_map(struct obj_file *f)
3686 struct obj_section *sec;
3687 #if ENABLE_FEATURE_INSMOD_LOAD_MAP_FULL
3688 struct obj_symbol **all, **p;
3690 char *loaded; /* array of booleans */
3691 struct obj_symbol *sym;
3693 /* Report on the section layout. */
3694 printf("Sections: Size %-*s Align\n",
3695 (int) (2 * sizeof(void *)), "Address");
3697 for (sec = f->load_order; sec; sec = sec->load_next) {
3701 for (a = -1, tmp = sec->header.sh_addralign; tmp; ++a)
3706 printf("%-15s %08lx %0*lx 2**%d\n",
3708 (long)sec->header.sh_size,
3709 (int) (2 * sizeof(void *)),
3710 (long)sec->header.sh_addr,
3713 #if ENABLE_FEATURE_INSMOD_LOAD_MAP_FULL
3714 /* Quick reference which section indices are loaded. */
3715 i = f->header.e_shnum;
3716 loaded = alloca(i * sizeof(loaded[0]));
3718 loaded[i] = ((f->sections[i]->header.sh_flags & SHF_ALLOC) != 0);
3720 /* Collect the symbols we'll be listing. */
3721 for (nsyms = i = 0; i < HASH_BUCKETS; ++i)
3722 for (sym = f->symtab[i]; sym; sym = sym->next)
3723 if (sym->secidx <= SHN_HIRESERVE
3724 && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx])
3729 all = alloca(nsyms * sizeof(all[0]));
3731 for (i = 0, p = all; i < HASH_BUCKETS; ++i)
3732 for (sym = f->symtab[i]; sym; sym = sym->next)
3733 if (sym->secidx <= SHN_HIRESERVE
3734 && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx])
3739 /* And list them. */
3740 printf("\nSymbols:\n");
3741 for (p = all; p < all + nsyms; ++p) {
3743 unsigned long value;
3746 if (sym->secidx == SHN_ABS) {
3749 } else if (sym->secidx == SHN_UNDEF) {
3753 sec = f->sections[sym->secidx];
3755 if (sec->header.sh_type == SHT_NOBITS)
3757 else if (sec->header.sh_flags & SHF_ALLOC) {
3758 if (sec->header.sh_flags & SHF_EXECINSTR)
3760 else if (sec->header.sh_flags & SHF_WRITE)
3765 value = sym->value + sec->header.sh_addr;
3768 if (ELF_ST_BIND(sym->info) == STB_LOCAL)
3769 type |= 0x20; /* tolower. safe for '?' too */
3771 printf("%0*lx %c %s\n", (int) (2 * sizeof(void *)), value,
3776 #else /* !FEATURE_INSMOD_LOAD_MAP */
3777 static void print_load_map(struct obj_file *f UNUSED_PARAM)
3782 int FAST_FUNC bb_init_module_24(const char *m_filename, const char *options)
3785 unsigned long m_size;
3788 int exit_status = EXIT_FAILURE;
3790 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3797 image_size = INT_MAX - 4095;
3799 image = try_to_mmap_module(m_filename, &image_size);
3803 /* Load module into memory and unzip if compressed */
3804 image = xmalloc_open_zipped_read_close(m_filename, &image_size);
3806 return EXIT_FAILURE;
3809 m_name = xstrdup(bb_basename(m_filename));
3810 /* "module.o[.gz]" -> "module" */
3811 *strchrnul(m_name, '.') = '\0';
3813 f = obj_load(image, image_size, LOADBITS);
3815 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3816 /* Version correspondence? */
3817 m_has_modinfo = (get_modinfo_value(f, "kernel_version") != NULL);
3819 char m_strversion[STRVERSIONLEN];
3822 if (m_has_modinfo) {
3823 int m_version = new_get_module_version(f, m_strversion);
3824 if (m_version == -1) {
3825 bb_error_msg_and_die("can't find the kernel version "
3826 "the module was compiled for");
3831 if (strncmp(uts.release, m_strversion, STRVERSIONLEN) != 0) {
3832 bb_error_msg("%skernel-module version mismatch\n"
3833 "\t%s was compiled for kernel version %s\n"
3834 "\twhile this kernel is version %s",
3835 flag_force_load ? "warning: " : "",
3836 m_name, m_strversion, uts.release);
3837 if (!flag_force_load)
3843 if (query_module(NULL, 0, NULL, 0, NULL))
3844 bb_error_msg_and_die("old (unsupported) kernel");
3845 new_get_kernel_symbols();
3846 k_crcs = new_is_kernel_checksummed();
3848 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3852 m_crcs = new_is_module_checksummed(f);
3853 if (m_crcs != k_crcs)
3854 obj_set_symbol_compare(f, ncv_strcmp, ncv_symbol_hash);
3858 /* Let the module know about the kernel symbols. */
3859 add_kernel_symbols(f);
3861 /* Allocate common symbols, symbol tables, and string tables. */
3862 new_create_this_module(f, m_name);
3863 obj_check_undefineds(f);
3864 obj_allocate_commons(f);
3865 check_tainted_module(f, m_name);
3867 /* Done with the module name, on to the optional var=value arguments */
3868 new_process_module_arguments(f, options);
3871 hide_special_symbols(f);
3873 #if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
3874 add_ksymoops_symbols(f, m_filename, m_name);
3877 new_create_module_ksymtab(f);
3879 /* Find current size of the module */
3880 m_size = obj_load_size(f);
3882 m_addr = create_module(m_name, m_size);
3883 if (m_addr == (ElfW(Addr))(-1)) switch (errno) {
3885 bb_error_msg_and_die("a module named %s already exists", m_name);
3887 bb_error_msg_and_die("can't allocate kernel memory for module; needed %lu bytes",
3890 bb_perror_msg_and_die("create_module: %s", m_name);
3895 * the PROGBITS section was not loaded by the obj_load
3896 * now we can load them directly into the kernel memory
3898 if (!obj_load_progbits(image, image_size, f, (char*)m_addr)) {
3899 delete_module(m_name, 0);
3904 if (!obj_relocate(f, m_addr)) {
3905 delete_module(m_name, 0);
3909 if (!new_init_module(m_name, f, m_size)) {
3910 delete_module(m_name, 0);
3914 if (flag_print_load_map)
3917 exit_status = EXIT_SUCCESS;
3921 munmap(image, image_size);