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.
63 #include <sys/utsname.h>
65 #if !ENABLE_FEATURE_2_4_MODULES && !ENABLE_FEATURE_2_6_MODULES
66 #undef ENABLE_FEATURE_2_4_MODULES
67 #define ENABLE_FEATURE_2_4_MODULES 1
71 * Big piece of 2.4-specific code
73 #if ENABLE_FEATURE_2_4_MODULES
75 #if ENABLE_FEATURE_2_6_MODULES
76 static int insmod_ng_main(int argc, char **argv);
79 #if ENABLE_FEATURE_INSMOD_LOADINKMEM
86 #if defined(__alpha__)
87 #define MATCH_MACHINE(x) (x == EM_ALPHA)
88 #define SHT_RELM SHT_RELA
89 #define Elf64_RelM Elf64_Rela
90 #define ELFCLASSM ELFCLASS64
95 #define MATCH_MACHINE(x) (x == EM_ARM)
96 #define SHT_RELM SHT_REL
97 #define Elf32_RelM Elf32_Rel
98 #define ELFCLASSM ELFCLASS32
99 #define USE_PLT_ENTRIES
100 #define PLT_ENTRY_SIZE 8
101 #define USE_GOT_ENTRIES
102 #define GOT_ENTRY_SIZE 8
108 #define MATCH_MACHINE(x) (x == EM_BLACKFIN)
109 #define SHT_RELM SHT_RELA
110 #define Elf32_RelM Elf32_Rela
111 #define ELFCLASSM ELFCLASS32
115 #if defined(__cris__)
116 #define MATCH_MACHINE(x) (x == EM_CRIS)
117 #define SHT_RELM SHT_RELA
118 #define Elf32_RelM Elf32_Rela
119 #define ELFCLASSM ELFCLASS32
122 #define R_CRIS_NONE 0
128 #if defined(__H8300H__) || defined(__H8300S__)
129 #define MATCH_MACHINE(x) (x == EM_H8_300)
130 #define SHT_RELM SHT_RELA
131 #define Elf32_RelM Elf32_Rela
132 #define ELFCLASSM ELFCLASS32
134 #define SYMBOL_PREFIX "_"
137 /* PA-RISC / HP-PA */
138 #if defined(__hppa__)
139 #define MATCH_MACHINE(x) (x == EM_PARISC)
140 #define SHT_RELM SHT_RELA
141 #if defined(__LP64__)
142 #define Elf64_RelM Elf64_Rela
143 #define ELFCLASSM ELFCLASS64
145 #define Elf32_RelM Elf32_Rela
146 #define ELFCLASSM ELFCLASS32
151 #if defined(__i386__)
153 #define MATCH_MACHINE(x) (x == EM_386)
155 #define MATCH_MACHINE(x) (x == EM_386 || x == EM_486)
157 #define SHT_RELM SHT_REL
158 #define Elf32_RelM Elf32_Rel
159 #define ELFCLASSM ELFCLASS32
160 #define USE_GOT_ENTRIES
161 #define GOT_ENTRY_SIZE 4
165 /* IA64, aka Itanium */
166 #if defined(__ia64__)
167 #define MATCH_MACHINE(x) (x == EM_IA_64)
168 #define SHT_RELM SHT_RELA
169 #define Elf64_RelM Elf64_Rela
170 #define ELFCLASSM ELFCLASS64
174 #if defined(__mc68000__)
175 #define MATCH_MACHINE(x) (x == EM_68K)
176 #define SHT_RELM SHT_RELA
177 #define Elf32_RelM Elf32_Rela
178 #define ELFCLASSM ELFCLASS32
179 #define USE_GOT_ENTRIES
180 #define GOT_ENTRY_SIZE 4
185 #if defined(__microblaze__)
187 #define MATCH_MACHINE(x) (x == EM_XILINX_MICROBLAZE)
188 #define SHT_RELM SHT_RELA
189 #define Elf32_RelM Elf32_Rela
190 #define ELFCLASSM ELFCLASS32
194 #if defined(__mips__)
195 #define MATCH_MACHINE(x) (x == EM_MIPS || x == EM_MIPS_RS3_LE)
196 #define SHT_RELM SHT_REL
197 #define Elf32_RelM Elf32_Rel
198 #define ELFCLASSM ELFCLASS32
199 /* Account for ELF spec changes. */
200 #ifndef EM_MIPS_RS3_LE
201 #ifdef EM_MIPS_RS4_BE
202 #define EM_MIPS_RS3_LE EM_MIPS_RS4_BE
204 #define EM_MIPS_RS3_LE 10
206 #endif /* !EM_MIPS_RS3_LE */
207 #define ARCHDATAM "__dbe_table"
211 #if defined(__nios2__)
212 #define MATCH_MACHINE(x) (x == EM_ALTERA_NIOS2)
213 #define SHT_RELM SHT_RELA
214 #define Elf32_RelM Elf32_Rela
215 #define ELFCLASSM ELFCLASS32
219 #if defined(__powerpc64__)
220 #define MATCH_MACHINE(x) (x == EM_PPC64)
221 #define SHT_RELM SHT_RELA
222 #define Elf64_RelM Elf64_Rela
223 #define ELFCLASSM ELFCLASS64
224 #elif defined(__powerpc__)
225 #define MATCH_MACHINE(x) (x == EM_PPC)
226 #define SHT_RELM SHT_RELA
227 #define Elf32_RelM Elf32_Rela
228 #define ELFCLASSM ELFCLASS32
229 #define USE_PLT_ENTRIES
230 #define PLT_ENTRY_SIZE 16
232 #define LIST_ARCHTYPE ElfW(Addr)
234 #define ARCHDATAM "__ftr_fixup"
238 #if defined(__s390__)
239 #define MATCH_MACHINE(x) (x == EM_S390)
240 #define SHT_RELM SHT_RELA
241 #define Elf32_RelM Elf32_Rela
242 #define ELFCLASSM ELFCLASS32
243 #define USE_PLT_ENTRIES
244 #define PLT_ENTRY_SIZE 8
245 #define USE_GOT_ENTRIES
246 #define GOT_ENTRY_SIZE 8
252 #define MATCH_MACHINE(x) (x == EM_SH)
253 #define SHT_RELM SHT_RELA
254 #define Elf32_RelM Elf32_Rela
255 #define ELFCLASSM ELFCLASS32
256 #define USE_GOT_ENTRIES
257 #define GOT_ENTRY_SIZE 4
259 /* the SH changes have only been tested in =little endian= mode */
260 /* I'm not sure about big endian, so let's warn: */
261 #if defined(__sh__) && BB_BIG_ENDIAN
262 # error insmod.c may require changes for use on big endian SH
264 /* it may or may not work on the SH1/SH2... Error on those also */
265 #if ((!(defined(__SH3__) || defined(__SH4__) || defined(__SH5__)))) && (defined(__sh__))
266 #error insmod.c may require changes for SH1 or SH2 use
271 #if defined(__sparc__)
272 #define MATCH_MACHINE(x) (x == EM_SPARC)
273 #define SHT_RELM SHT_RELA
274 #define Elf32_RelM Elf32_Rela
275 #define ELFCLASSM ELFCLASS32
279 #if defined(__v850e__)
280 #define MATCH_MACHINE(x) ((x) == EM_V850 || (x) == EM_CYGNUS_V850)
281 #define SHT_RELM SHT_RELA
282 #define Elf32_RelM Elf32_Rela
283 #define ELFCLASSM ELFCLASS32
284 #define USE_PLT_ENTRIES
285 #define PLT_ENTRY_SIZE 8
287 #ifndef EM_CYGNUS_V850 /* grumble */
288 #define EM_CYGNUS_V850 0x9080
290 #define SYMBOL_PREFIX "_"
294 #if defined(__x86_64__)
295 #define MATCH_MACHINE(x) (x == EM_X86_64)
296 #define SHT_RELM SHT_RELA
297 #define USE_GOT_ENTRIES
298 #define GOT_ENTRY_SIZE 8
300 #define Elf64_RelM Elf64_Rela
301 #define ELFCLASSM ELFCLASS64
305 #error Sorry, but insmod.c does not yet support this architecture...
309 //----------------------------------------------------------------------------
310 //--------modutils module.h, lines 45-242
311 //----------------------------------------------------------------------------
313 /* Definitions for the Linux module syscall interface.
314 Copyright 1996, 1997 Linux International.
316 Contributed by Richard Henderson <rth@tamu.edu>
318 This file is part of the Linux modutils.
320 This program is free software; you can redistribute it and/or modify it
321 under the terms of the GNU General Public License as published by the
322 Free Software Foundation; either version 2 of the License, or (at your
323 option) any later version.
325 This program is distributed in the hope that it will be useful, but
326 WITHOUT ANY WARRANTY; without even the implied warranty of
327 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
328 General Public License for more details.
330 You should have received a copy of the GNU General Public License
331 along with this program; if not, write to the Free Software Foundation,
332 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
335 #ifndef MODUTILS_MODULE_H
337 /*======================================================================*/
338 /* For sizeof() which are related to the module platform and not to the
339 environment isnmod is running in, use sizeof_xx instead of sizeof(xx). */
341 #define tgt_sizeof_char sizeof(char)
342 #define tgt_sizeof_short sizeof(short)
343 #define tgt_sizeof_int sizeof(int)
344 #define tgt_sizeof_long sizeof(long)
345 #define tgt_sizeof_char_p sizeof(char *)
346 #define tgt_sizeof_void_p sizeof(void *)
347 #define tgt_long long
349 #if defined(__sparc__) && !defined(__sparc_v9__) && defined(ARCH_sparc64)
350 #undef tgt_sizeof_long
351 #undef tgt_sizeof_char_p
352 #undef tgt_sizeof_void_p
356 tgt_sizeof_char_p = 8,
357 tgt_sizeof_void_p = 8
359 #define tgt_long long long
362 /*======================================================================*/
363 /* The structures used in Linux 2.1. */
365 /* Note: new_module_symbol does not use tgt_long intentionally */
366 struct new_module_symbol {
371 struct new_module_persist;
373 struct new_module_ref {
374 unsigned tgt_long dep; /* kernel addresses */
375 unsigned tgt_long ref;
376 unsigned tgt_long next_ref;
380 unsigned tgt_long size_of_struct; /* == sizeof(module) */
381 unsigned tgt_long next;
382 unsigned tgt_long name;
383 unsigned tgt_long size;
386 unsigned tgt_long flags; /* AUTOCLEAN et al */
391 unsigned tgt_long syms;
392 unsigned tgt_long deps;
393 unsigned tgt_long refs;
394 unsigned tgt_long init;
395 unsigned tgt_long cleanup;
396 unsigned tgt_long ex_table_start;
397 unsigned tgt_long ex_table_end;
399 unsigned tgt_long gp;
401 /* Everything after here is extension. */
402 unsigned tgt_long persist_start;
403 unsigned tgt_long persist_end;
404 unsigned tgt_long can_unload;
405 unsigned tgt_long runsize;
406 const char *kallsyms_start; /* All symbols for kernel debugging */
407 const char *kallsyms_end;
408 const char *archdata_start; /* arch specific data for module */
409 const char *archdata_end;
410 const char *kernel_data; /* Reserved for kernel internal use */
414 #define ARCHDATA_SEC_NAME ARCHDATAM
416 #define ARCHDATA_SEC_NAME "__archdata"
418 #define KALLSYMS_SEC_NAME "__kallsyms"
421 struct new_module_info {
428 /* Bits of module.flags. */
432 NEW_MOD_AUTOCLEAN = 4,
434 NEW_MOD_USED_ONCE = 16
437 int init_module(const char *name, const struct new_module *);
438 int query_module(const char *name, int which, void *buf,
439 size_t bufsize, size_t *ret);
441 /* Values for query_module's which. */
450 /*======================================================================*/
451 /* The system calls unchanged between 2.0 and 2.1. */
453 unsigned long create_module(const char *, size_t);
454 int delete_module(const char *);
457 #endif /* module.h */
459 //----------------------------------------------------------------------------
460 //--------end of modutils module.h
461 //----------------------------------------------------------------------------
465 //----------------------------------------------------------------------------
466 //--------modutils obj.h, lines 253-462
467 //----------------------------------------------------------------------------
469 /* Elf object file loading and relocation routines.
470 Copyright 1996, 1997 Linux International.
472 Contributed by Richard Henderson <rth@tamu.edu>
474 This file is part of the Linux modutils.
476 This program is free software; you can redistribute it and/or modify it
477 under the terms of the GNU General Public License as published by the
478 Free Software Foundation; either version 2 of the License, or (at your
479 option) any later version.
481 This program is distributed in the hope that it will be useful, but
482 WITHOUT ANY WARRANTY; without even the implied warranty of
483 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
484 General Public License for more details.
486 You should have received a copy of the GNU General Public License
487 along with this program; if not, write to the Free Software Foundation,
488 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
491 #ifndef MODUTILS_OBJ_H
493 /* The relocatable object is manipulated using elfin types. */
499 # if ELFCLASSM == ELFCLASS32
500 # define ElfW(x) Elf32_ ## x
501 # define ELFW(x) ELF32_ ## x
503 # define ElfW(x) Elf64_ ## x
504 # define ELFW(x) ELF64_ ## x
508 /* For some reason this is missing from some ancient C libraries.... */
509 #ifndef ELF32_ST_INFO
510 # define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
513 #ifndef ELF64_ST_INFO
514 # define ELF64_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
517 #define ELF_ST_BIND(info) ELFW(ST_BIND)(info)
518 #define ELF_ST_TYPE(info) ELFW(ST_TYPE)(info)
519 #define ELF_ST_INFO(bind, type) ELFW(ST_INFO)(bind, type)
520 #define ELF_R_TYPE(val) ELFW(R_TYPE)(val)
521 #define ELF_R_SYM(val) ELFW(R_SYM)(val)
523 struct obj_string_patch;
524 struct obj_symbol_patch;
531 struct obj_section *load_next;
537 struct obj_symbol *next; /* hash table link */
541 int secidx; /* the defining section index/module */
543 int ksymidx; /* for export to the kernel symtab */
544 int referenced; /* actually used in the link */
547 /* Hardcode the hash table size. We shouldn't be needing so many
548 symbols that we begin to degrade performance, and we get a big win
549 by giving the compiler a constant divisor. */
551 #define HASH_BUCKETS 521
556 struct obj_section **sections;
557 struct obj_section *load_order;
558 struct obj_section **load_order_search_start;
559 struct obj_string_patch *string_patches;
560 struct obj_symbol_patch *symbol_patches;
561 int (*symbol_cmp)(const char *, const char *);
562 unsigned long (*symbol_hash)(const char *);
563 unsigned long local_symtab_size;
564 struct obj_symbol **local_symtab;
565 struct obj_symbol *symtab[HASH_BUCKETS];
575 struct obj_string_patch {
576 struct obj_string_patch *next;
578 ElfW(Addr) reloc_offset;
579 ElfW(Addr) string_offset;
582 struct obj_symbol_patch {
583 struct obj_symbol_patch *next;
585 ElfW(Addr) reloc_offset;
586 struct obj_symbol *sym;
590 /* Generic object manipulation routines. */
592 static unsigned long obj_elf_hash(const char *);
594 static unsigned long obj_elf_hash_n(const char *, unsigned long len);
596 static struct obj_symbol *obj_find_symbol(struct obj_file *f,
599 static ElfW(Addr) obj_symbol_final_value(struct obj_file *f,
600 struct obj_symbol *sym);
602 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
603 static void obj_set_symbol_compare(struct obj_file *f,
604 int (*cmp)(const char *, const char *),
605 unsigned long (*hash)(const char *));
608 static struct obj_section *obj_find_section(struct obj_file *f,
611 static void obj_insert_section_load_order(struct obj_file *f,
612 struct obj_section *sec);
614 static struct obj_section *obj_create_alloced_section(struct obj_file *f,
619 static struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
624 static void *obj_extend_section(struct obj_section *sec, unsigned long more);
626 static void obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
629 static void obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
630 struct obj_symbol *sym);
632 static void obj_check_undefineds(struct obj_file *f);
634 static void obj_allocate_commons(struct obj_file *f);
636 static unsigned long obj_load_size(struct obj_file *f);
638 static int obj_relocate(struct obj_file *f, ElfW(Addr) base);
640 static struct obj_file *obj_load(FILE *f, int loadprogbits);
642 static int obj_create_image(struct obj_file *f, char *image);
644 /* Architecture specific manipulation routines. */
646 static struct obj_file *arch_new_file(void);
648 static struct obj_section *arch_new_section(void);
650 static struct obj_symbol *arch_new_symbol(void);
652 static enum obj_reloc arch_apply_relocation(struct obj_file *f,
653 struct obj_section *targsec,
654 struct obj_section *symsec,
655 struct obj_symbol *sym,
656 ElfW(RelM) *rel, ElfW(Addr) value);
658 static void arch_create_got(struct obj_file *f);
659 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
660 static int obj_gpl_license(struct obj_file *f, const char **license);
661 #endif /* FEATURE_CHECK_TAINTED_MODULE */
663 //----------------------------------------------------------------------------
664 //--------end of modutils obj.h
665 //----------------------------------------------------------------------------
668 /* SPFX is always a string, so it can be concatenated to string constants. */
670 #define SPFX SYMBOL_PREFIX
676 #define _PATH_MODULES "/lib/modules"
677 enum { STRVERSIONLEN = 64 };
679 /*======================================================================*/
681 #define OPTION_STR "sLo:fkvqx" USE_FEATURE_INSMOD_LOAD_MAP("m")
683 OPT_s = 0x1, // -s /* log to syslog */
684 /* Not supported but kernel needs this for request_module(),
685 as this calls: modprobe -k -s -- <module>
686 so silently ignore this flag */
687 OPT_L = 0x2, // -L /* Stub warning */
688 /* Compatibility with modprobe.
689 In theory, this does locking, but we don't do
690 that. So be careful and plan your life around not
691 loading the same module 50 times concurrently. */
692 OPT_o = 0x4, // -o /* name the output module */
693 OPT_f = 0x8, // -f /* force loading */
694 OPT_k = 0x10, // -k /* module loaded by kerneld, auto-cleanable */
695 OPT_v = 0x20, // -v /* verbose output */
696 OPT_q = 0x40, // -q /* silent */
697 OPT_x = 0x80, // -x /* do not export externs */
698 OPT_m = 0x100, // -m /* print module load map */
700 #define flag_force_load (option_mask32 & OPT_f)
701 #define flag_autoclean (option_mask32 & OPT_k)
702 #define flag_verbose (option_mask32 & OPT_v)
703 #define flag_quiet (option_mask32 & OPT_q)
704 #define flag_noexport (option_mask32 & OPT_x)
705 #if ENABLE_FEATURE_INSMOD_LOAD_MAP
706 #define flag_print_load_map (option_mask32 & OPT_m)
708 #define flag_print_load_map 0
711 /*======================================================================*/
713 #if defined(USE_LIST)
715 struct arch_list_entry
717 struct arch_list_entry *next;
718 LIST_ARCHTYPE addend;
725 #if defined(USE_SINGLE)
727 struct arch_single_entry
736 #if defined(__mips__)
739 struct mips_hi16 *next;
746 struct obj_file root;
747 #if defined(USE_PLT_ENTRIES)
748 struct obj_section *plt;
750 #if defined(USE_GOT_ENTRIES)
751 struct obj_section *got;
753 #if defined(__mips__)
754 struct mips_hi16 *mips_hi16_list;
759 struct obj_symbol root;
760 #if defined(USE_PLT_ENTRIES)
761 #if defined(USE_PLT_LIST)
762 struct arch_list_entry *pltent;
764 struct arch_single_entry pltent;
767 #if defined(USE_GOT_ENTRIES)
768 struct arch_single_entry gotent;
773 struct external_module {
778 struct new_module_symbol *syms;
781 static struct new_module_symbol *ksyms;
782 static size_t nksyms;
784 static struct external_module *ext_modules;
785 static int n_ext_modules;
786 static int n_ext_modules_used;
788 static char *m_filename;
789 static char *m_fullName;
792 /*======================================================================*/
795 static int check_module_name_match(const char *filename, struct stat *statbuf,
796 void *userdata, int depth)
798 char *fullname = (char *) userdata;
801 if (fullname[0] == '\0')
804 tmp = bb_get_last_path_component_nostrip(filename);
805 if (strcmp(tmp, fullname) == 0) {
806 /* Stop searching if we find a match */
807 m_filename = xstrdup(filename);
814 /*======================================================================*/
816 static struct obj_file *arch_new_file(void)
819 f = xzalloc(sizeof(*f));
820 return &f->root; /* it's a first member */
823 static struct obj_section *arch_new_section(void)
825 return xzalloc(sizeof(struct obj_section));
828 static struct obj_symbol *arch_new_symbol(void)
830 struct arch_symbol *sym;
831 sym = xzalloc(sizeof(*sym));
835 static enum obj_reloc
836 arch_apply_relocation(struct obj_file *f,
837 struct obj_section *targsec,
838 struct obj_section *symsec,
839 struct obj_symbol *sym,
840 ElfW(RelM) *rel, ElfW(Addr) v)
842 struct arch_file *ifile = (struct arch_file *) f;
843 enum obj_reloc ret = obj_reloc_ok;
844 ElfW(Addr) *loc = (ElfW(Addr) *) (targsec->contents + rel->r_offset);
845 ElfW(Addr) dot = targsec->header.sh_addr + rel->r_offset;
846 #if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
847 struct arch_symbol *isym = (struct arch_symbol *) sym;
849 #if defined(__arm__) || defined(__i386__) || defined(__mc68000__) || defined(__sh__) || defined(__s390__)
850 #if defined(USE_GOT_ENTRIES)
851 ElfW(Addr) got = ifile->got ? ifile->got->header.sh_addr : 0;
854 #if defined(USE_PLT_ENTRIES)
855 ElfW(Addr) plt = ifile->plt ? ifile->plt->header.sh_addr : 0;
857 # if defined(USE_PLT_LIST)
858 struct arch_list_entry *pe;
860 struct arch_single_entry *pe;
864 switch (ELF_R_TYPE(rel->r_info)) {
879 /* relative reloc, always to _GLOBAL_OFFSET_TABLE_
880 * (which is .got) similar to branch,
881 * but is full 32 bits relative */
890 case R_ARM_GOTOFF: /* address relative to the got */
894 #elif defined(__cris__)
900 /* CRIS keeps the relocation value in the r_addend field and
901 * should not use whats in *loc at all
906 #elif defined(__H8300H__) || defined(__H8300S__)
909 loc = (ElfW(Addr) *)((ElfW(Addr))loc - 1);
910 *loc = (*loc & 0xff000000) | ((*loc & 0xffffff) + v);
921 if ((ElfW(Sword))v > 0x7fff ||
922 (ElfW(Sword))v < -(ElfW(Sword))0x8000)
923 ret = obj_reloc_overflow;
925 *(unsigned short *)loc = v;
929 if ((ElfW(Sword))v > 0x7f ||
930 (ElfW(Sword))v < -(ElfW(Sword))0x80)
931 ret = obj_reloc_overflow;
933 *(unsigned char *)loc = v;
936 #elif defined(__i386__)
970 #elif defined(__microblaze__)
971 case R_MICROBLAZE_NONE:
972 case R_MICROBLAZE_64_NONE:
973 case R_MICROBLAZE_32_SYM_OP_SYM:
974 case R_MICROBLAZE_32_PCREL:
977 case R_MICROBLAZE_64_PCREL: {
978 /* dot is the address of the current instruction.
979 * v is the target symbol address.
980 * So we need to extract the offset in the code,
981 * adding v, then subtrating the current address
982 * of this instruction.
983 * Ex: "IMM 0xFFFE bralid 0x0000" = "bralid 0xFFFE0000"
986 /* Get split offset stored in code */
987 unsigned int temp = (loc[0] & 0xFFFF) << 16 |
990 /* Adjust relative offset. -4 adjustment required
991 * because dot points to the IMM insn, but branch
992 * is computed relative to the branch instruction itself.
996 /* Store back into code */
997 loc[0] = (loc[0] & 0xFFFF0000) | temp >> 16;
998 loc[1] = (loc[1] & 0xFFFF0000) | (temp & 0xFFFF);
1003 case R_MICROBLAZE_32:
1007 case R_MICROBLAZE_64: {
1008 /* Get split pointer stored in code */
1009 unsigned int temp1 = (loc[0] & 0xFFFF) << 16 |
1012 /* Add reloc offset */
1015 /* Store back into code */
1016 loc[0] = (loc[0] & 0xFFFF0000) | temp1 >> 16;
1017 loc[1] = (loc[1] & 0xFFFF0000) | (temp1 & 0xFFFF);
1022 case R_MICROBLAZE_32_PCREL_LO:
1023 case R_MICROBLAZE_32_LO:
1024 case R_MICROBLAZE_SRO32:
1025 case R_MICROBLAZE_SRW32:
1026 ret = obj_reloc_unhandled;
1029 #elif defined(__mc68000__)
1040 ret = obj_reloc_overflow;
1047 ret = obj_reloc_overflow;
1054 if ((ElfW(Sword))v > 0x7f ||
1055 (ElfW(Sword))v < -(ElfW(Sword))0x80) {
1056 ret = obj_reloc_overflow;
1063 if ((ElfW(Sword))v > 0x7fff ||
1064 (ElfW(Sword))v < -(ElfW(Sword))0x8000) {
1065 ret = obj_reloc_overflow;
1071 *(int *)loc = v - dot;
1074 case R_68K_GLOB_DAT:
1075 case R_68K_JMP_SLOT:
1079 case R_68K_RELATIVE:
1080 *(int *)loc += f->baseaddr;
1086 # ifdef R_68K_GOTOFF
1092 #elif defined(__mips__)
1103 ret = obj_reloc_dangerous;
1104 if ((v & 0xf0000000) != ((dot + 4) & 0xf0000000))
1105 ret = obj_reloc_overflow;
1107 (*loc & ~0x03ffffff) | ((*loc + (v >> 2)) &
1113 struct mips_hi16 *n;
1115 /* We cannot relocate this one now because we don't know the value
1116 of the carry we need to add. Save the information, and let LO16
1117 do the actual relocation. */
1118 n = xmalloc(sizeof *n);
1121 n->next = ifile->mips_hi16_list;
1122 ifile->mips_hi16_list = n;
1128 unsigned long insnlo = *loc;
1129 ElfW(Addr) val, vallo;
1131 /* Sign extend the addend we extract from the lo insn. */
1132 vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
1134 if (ifile->mips_hi16_list != NULL) {
1135 struct mips_hi16 *l;
1137 l = ifile->mips_hi16_list;
1139 struct mips_hi16 *next;
1142 /* Do the HI16 relocation. Note that we actually don't
1143 need to know anything about the LO16 itself, except where
1144 to find the low 16 bits of the addend needed by the LO16. */
1147 ((insn & 0xffff) << 16) +
1151 /* Account for the sign extension that will happen in the
1158 insn = (insn & ~0xffff) | val;
1166 ifile->mips_hi16_list = NULL;
1169 /* Ok, we're done with the HI16 relocs. Now deal with the LO16. */
1171 insnlo = (insnlo & ~0xffff) | (val & 0xffff);
1176 #elif defined(__nios2__)
1181 case R_NIOS2_BFD_RELOC_32:
1185 case R_NIOS2_BFD_RELOC_16:
1187 ret = obj_reloc_overflow;
1192 case R_NIOS2_BFD_RELOC_8:
1194 ret = obj_reloc_overflow;
1203 if ((Elf32_Sword)v > 0x7fff ||
1204 (Elf32_Sword)v < -(Elf32_Sword)0x8000) {
1205 ret = obj_reloc_overflow;
1209 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1219 ret = obj_reloc_overflow;
1223 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1228 case R_NIOS2_PCREL16:
1233 if ((Elf32_Sword)v > 0x7fff ||
1234 (Elf32_Sword)v < -(Elf32_Sword)0x8000) {
1235 ret = obj_reloc_overflow;
1239 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) | (word & 0x3f);
1245 Elf32_Addr word, gp;
1247 gp = obj_symbol_final_value(f, obj_find_symbol(f, SPFX "_gp"));
1249 if ((Elf32_Sword)v > 0x7fff ||
1250 (Elf32_Sword)v < -(Elf32_Sword)0x8000) {
1251 ret = obj_reloc_overflow;
1255 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) | (word & 0x3f);
1259 case R_NIOS2_CALL26:
1261 ret = obj_reloc_dangerous;
1262 if ((v >> 28) != (dot >> 28))
1263 ret = obj_reloc_overflow;
1264 *loc = (*loc & 0x3f) | ((v >> 2) << 6);
1272 ret = obj_reloc_overflow;
1275 word = *loc & ~0x7c0;
1276 *loc = word | ((v & 0x1f) << 6);
1285 ret = obj_reloc_overflow;
1288 word = *loc & ~0xfc0;
1289 *loc = word | ((v & 0x3f) << 6);
1298 ret = obj_reloc_overflow;
1301 word = *loc & ~0x3fc0;
1302 *loc = word | ((v & 0xff) << 6);
1311 *loc = ((((word >> 22) << 16) | ((v >>16) & 0xffff)) << 6) |
1321 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1326 case R_NIOS2_HIADJ16:
1328 Elf32_Addr word1, word2;
1331 word2 = ((v >> 16) + ((v >> 15) & 1)) & 0xffff;
1332 *loc = ((((word1 >> 22) << 16) | word2) << 6) |
1337 #elif defined(__powerpc64__)
1338 /* PPC64 needs a 2.6 kernel, 2.4 module relocation irrelevant */
1340 #elif defined(__powerpc__)
1342 case R_PPC_ADDR16_HA:
1343 *(unsigned short *)loc = (v + 0x8000) >> 16;
1346 case R_PPC_ADDR16_HI:
1347 *(unsigned short *)loc = v >> 16;
1350 case R_PPC_ADDR16_LO:
1351 *(unsigned short *)loc = v;
1365 #elif defined(__s390__)
1368 *(unsigned int *) loc += v;
1371 *(unsigned short *) loc += v;
1374 *(unsigned char *) loc += v;
1378 *(unsigned int *) loc += v - dot;
1381 *(unsigned short *) loc += (v - dot) >> 1;
1384 *(unsigned short *) loc += v - dot;
1388 case R_390_PLT16DBL:
1389 /* find the plt entry and initialize it. */
1390 pe = (struct arch_single_entry *) &isym->pltent;
1391 if (pe->inited == 0) {
1392 ip = (unsigned long *)(ifile->plt->contents + pe->offset);
1393 ip[0] = 0x0d105810; /* basr 1,0; lg 1,10(1); br 1 */
1395 if (ELF_R_TYPE(rel->r_info) == R_390_PLT16DBL)
1402 /* Insert relative distance to target. */
1403 v = plt + pe->offset - dot;
1404 if (ELF_R_TYPE(rel->r_info) == R_390_PLT32)
1405 *(unsigned int *) loc = (unsigned int) v;
1406 else if (ELF_R_TYPE(rel->r_info) == R_390_PLT16DBL)
1407 *(unsigned short *) loc = (unsigned short) ((v + 2) >> 1);
1410 case R_390_GLOB_DAT:
1411 case R_390_JMP_SLOT:
1415 case R_390_RELATIVE:
1416 *loc += f->baseaddr;
1420 *(unsigned long *) loc += got - dot;
1426 if (!isym->gotent.inited)
1428 isym->gotent.inited = 1;
1429 *(ElfW(Addr) *)(ifile->got->contents + isym->gotent.offset) = v;
1431 if (ELF_R_TYPE(rel->r_info) == R_390_GOT12)
1432 *(unsigned short *) loc |= (*(unsigned short *) loc + isym->gotent.offset) & 0xfff;
1433 else if (ELF_R_TYPE(rel->r_info) == R_390_GOT16)
1434 *(unsigned short *) loc += isym->gotent.offset;
1435 else if (ELF_R_TYPE(rel->r_info) == R_390_GOT32)
1436 *(unsigned int *) loc += isym->gotent.offset;
1439 # ifndef R_390_GOTOFF32
1440 # define R_390_GOTOFF32 R_390_GOTOFF
1442 case R_390_GOTOFF32:
1446 #elif defined(__sh__)
1469 *loc = f->baseaddr + rel->r_addend;
1473 *loc = got - dot + rel->r_addend;
1483 # if defined(__SH5__)
1484 case R_SH_IMM_MEDLOW16:
1485 case R_SH_IMM_LOW16:
1489 if (ELF_R_TYPE(rel->r_info) == R_SH_IMM_MEDLOW16)
1493 * movi and shori have the format:
1495 * | op | imm | reg | reserved |
1496 * 31..26 25..10 9.. 4 3 .. 0
1498 * so we simply mask and or in imm.
1500 word = *loc & ~0x3fffc00;
1501 word |= (v & 0xffff) << 10;
1508 case R_SH_IMM_MEDLOW16_PCREL:
1509 case R_SH_IMM_LOW16_PCREL:
1513 word = *loc & ~0x3fffc00;
1517 if (ELF_R_TYPE(rel->r_info) == R_SH_IMM_MEDLOW16_PCREL)
1520 word |= (v & 0xffff) << 10;
1526 # endif /* __SH5__ */
1528 #elif defined(__v850e__)
1534 /* We write two shorts instead of a long because even
1535 32-bit insns only need half-word alignment, but
1536 32-bit data needs to be long-word aligned. */
1537 v += ((unsigned short *)loc)[0];
1538 v += ((unsigned short *)loc)[1] << 16;
1539 ((unsigned short *)loc)[0] = v & 0xffff;
1540 ((unsigned short *)loc)[1] = (v >> 16) & 0xffff;
1543 case R_V850_22_PCREL:
1546 #elif defined(__x86_64__)
1556 *(unsigned int *) loc += v;
1559 ret = obj_reloc_overflow; /* Kernel module compiled without -mcmodel=kernel. */
1560 /* error("Possibly is module compiled without -mcmodel=kernel!"); */
1565 *(signed int *) loc += v;
1569 *(unsigned short *) loc += v;
1573 *(unsigned char *) loc += v;
1577 *(unsigned int *) loc += v - dot;
1581 *(unsigned short *) loc += v - dot;
1585 *(unsigned char *) loc += v - dot;
1588 case R_X86_64_GLOB_DAT:
1589 case R_X86_64_JUMP_SLOT:
1593 case R_X86_64_RELATIVE:
1594 *loc += f->baseaddr;
1597 case R_X86_64_GOT32:
1598 case R_X86_64_GOTPCREL:
1601 if (!isym->gotent.reloc_done)
1603 isym->gotent.reloc_done = 1;
1604 *(Elf64_Addr *)(ifile->got->contents + isym->gotent.offset) = v;
1606 /* XXX are these really correct? */
1607 if (ELF64_R_TYPE(rel->r_info) == R_X86_64_GOTPCREL)
1608 *(unsigned int *) loc += v + isym->gotent.offset;
1610 *loc += isym->gotent.offset;
1615 # warning "no idea how to handle relocations on your arch"
1619 printf("Warning: unhandled reloc %d\n",(int)ELF_R_TYPE(rel->r_info));
1620 ret = obj_reloc_unhandled;
1623 #if defined(USE_PLT_ENTRIES)
1627 /* find the plt entry and initialize it if necessary */
1629 #if defined(USE_PLT_LIST)
1630 for (pe = isym->pltent; pe != NULL && pe->addend != rel->r_addend;)
1637 ip = (unsigned long *) (ifile->plt->contents + pe->offset);
1639 /* generate some machine code */
1641 #if defined(__arm__)
1642 ip[0] = 0xe51ff004; /* ldr pc,[pc,#-4] */
1643 ip[1] = v; /* sym@ */
1645 #if defined(__powerpc__)
1646 ip[0] = 0x3d600000 + ((v + 0x8000) >> 16); /* lis r11,sym@ha */
1647 ip[1] = 0x396b0000 + (v & 0xffff); /* addi r11,r11,sym@l */
1648 ip[2] = 0x7d6903a6; /* mtctr r11 */
1649 ip[3] = 0x4e800420; /* bctr */
1651 #if defined(__v850e__)
1652 /* We have to trash a register, so we assume that any control
1653 transfer more than 21-bits away must be a function call
1654 (so we can use a call-clobbered register). */
1655 ip[0] = 0x0621 + ((v & 0xffff) << 16); /* mov sym, r1 ... */
1656 ip[1] = ((v >> 16) & 0xffff) + 0x610000; /* ...; jmp r1 */
1661 /* relative distance to target */
1663 /* if the target is too far away.... */
1664 #if defined(__arm__) || defined(__powerpc__)
1665 if ((int)v < -0x02000000 || (int)v >= 0x02000000)
1666 #elif defined(__v850e__)
1667 if ((ElfW(Sword))v > 0x1fffff || (ElfW(Sword))v < (ElfW(Sword))-0x200000)
1669 /* go via the plt */
1670 v = plt + pe->offset - dot;
1672 #if defined(__v850e__)
1677 ret = obj_reloc_dangerous;
1679 /* merge the offset into the instruction. */
1680 #if defined(__arm__)
1681 /* Convert to words. */
1684 *loc = (*loc & ~0x00ffffff) | ((v + *loc) & 0x00ffffff);
1686 #if defined(__powerpc__)
1687 *loc = (*loc & ~0x03fffffc) | (v & 0x03fffffc);
1689 #if defined(__v850e__)
1690 /* We write two shorts instead of a long because even 32-bit insns
1691 only need half-word alignment, but the 32-bit data write needs
1692 to be long-word aligned. */
1693 ((unsigned short *)loc)[0] =
1694 (*(unsigned short *)loc & 0xffc0) /* opcode + reg */
1695 | ((v >> 16) & 0x3f); /* offs high part */
1696 ((unsigned short *)loc)[1] =
1697 (v & 0xffff); /* offs low part */
1700 #endif /* USE_PLT_ENTRIES */
1702 #if defined(USE_GOT_ENTRIES)
1705 /* needs an entry in the .got: set it, once */
1706 if (!isym->gotent.inited) {
1707 isym->gotent.inited = 1;
1708 *(ElfW(Addr) *) (ifile->got->contents + isym->gotent.offset) = v;
1710 /* make the reloc with_respect_to_.got */
1712 *loc += isym->gotent.offset + rel->r_addend;
1713 #elif defined(__i386__) || defined(__arm__) || defined(__mc68000__)
1714 *loc += isym->gotent.offset;
1718 #endif /* USE_GOT_ENTRIES */
1725 #if defined(USE_LIST)
1727 static int arch_list_add(ElfW(RelM) *rel, struct arch_list_entry **list,
1728 int offset, int size)
1730 struct arch_list_entry *pe;
1732 for (pe = *list; pe != NULL; pe = pe->next) {
1733 if (pe->addend == rel->r_addend) {
1739 pe = xmalloc(sizeof(struct arch_list_entry));
1741 pe->addend = rel->r_addend;
1742 pe->offset = offset;
1752 #if defined(USE_SINGLE)
1754 static int arch_single_init(ElfW(RelM) *rel, struct arch_single_entry *single,
1755 int offset, int size)
1757 if (single->allocated == 0) {
1758 single->allocated = 1;
1759 single->offset = offset;
1768 #if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
1770 static struct obj_section *arch_xsect_init(struct obj_file *f, const char *name,
1771 int offset, int size)
1773 struct obj_section *myrelsec = obj_find_section(f, name);
1780 obj_extend_section(myrelsec, offset);
1782 myrelsec = obj_create_alloced_section(f, name,
1791 static void arch_create_got(struct obj_file *f)
1793 #if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
1794 struct arch_file *ifile = (struct arch_file *) f;
1796 #if defined(USE_GOT_ENTRIES)
1797 int got_offset = 0, got_needed = 0, got_allocate;
1799 #if defined(USE_PLT_ENTRIES)
1800 int plt_offset = 0, plt_needed = 0, plt_allocate;
1802 struct obj_section *relsec, *symsec, *strsec;
1803 ElfW(RelM) *rel, *relend;
1804 ElfW(Sym) *symtab, *extsym;
1805 const char *strtab, *name;
1806 struct arch_symbol *intsym;
1808 for (i = 0; i < f->header.e_shnum; ++i) {
1809 relsec = f->sections[i];
1810 if (relsec->header.sh_type != SHT_RELM)
1813 symsec = f->sections[relsec->header.sh_link];
1814 strsec = f->sections[symsec->header.sh_link];
1816 rel = (ElfW(RelM) *) relsec->contents;
1817 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
1818 symtab = (ElfW(Sym) *) symsec->contents;
1819 strtab = (const char *) strsec->contents;
1821 for (; rel < relend; ++rel) {
1822 extsym = &symtab[ELF_R_SYM(rel->r_info)];
1824 #if defined(USE_GOT_ENTRIES)
1827 #if defined(USE_PLT_ENTRIES)
1831 switch (ELF_R_TYPE(rel->r_info)) {
1832 #if defined(__arm__)
1847 #elif defined(__i386__)
1857 #elif defined(__powerpc__)
1862 #elif defined(__mc68000__)
1873 #elif defined(__sh__)
1883 #elif defined(__v850e__)
1884 case R_V850_22_PCREL:
1893 if (extsym->st_name != 0) {
1894 name = strtab + extsym->st_name;
1896 name = f->sections[extsym->st_shndx]->name;
1898 intsym = (struct arch_symbol *) obj_find_symbol(f, name);
1899 #if defined(USE_GOT_ENTRIES)
1901 got_offset += arch_single_init(
1902 rel, &intsym->gotent,
1903 got_offset, GOT_ENTRY_SIZE);
1908 #if defined(USE_PLT_ENTRIES)
1910 #if defined(USE_PLT_LIST)
1911 plt_offset += arch_list_add(
1912 rel, &intsym->pltent,
1913 plt_offset, PLT_ENTRY_SIZE);
1915 plt_offset += arch_single_init(
1916 rel, &intsym->pltent,
1917 plt_offset, PLT_ENTRY_SIZE);
1925 #if defined(USE_GOT_ENTRIES)
1927 ifile->got = arch_xsect_init(f, ".got", got_offset,
1932 #if defined(USE_PLT_ENTRIES)
1934 ifile->plt = arch_xsect_init(f, ".plt", plt_offset,
1939 #endif /* defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES) */
1942 /*======================================================================*/
1944 /* Standard ELF hash function. */
1945 static unsigned long obj_elf_hash_n(const char *name, unsigned long n)
1947 unsigned long h = 0;
1954 if ((g = (h & 0xf0000000)) != 0) {
1963 static unsigned long obj_elf_hash(const char *name)
1965 return obj_elf_hash_n(name, strlen(name));
1968 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
1969 /* String comparison for non-co-versioned kernel and module. */
1971 static int ncv_strcmp(const char *a, const char *b)
1973 size_t alen = strlen(a), blen = strlen(b);
1975 if (blen == alen + 10 && b[alen] == '_' && b[alen + 1] == 'R')
1976 return strncmp(a, b, alen);
1977 else if (alen == blen + 10 && a[blen] == '_' && a[blen + 1] == 'R')
1978 return strncmp(a, b, blen);
1980 return strcmp(a, b);
1983 /* String hashing for non-co-versioned kernel and module. Here
1984 we are simply forced to drop the crc from the hash. */
1986 static unsigned long ncv_symbol_hash(const char *str)
1988 size_t len = strlen(str);
1989 if (len > 10 && str[len - 10] == '_' && str[len - 9] == 'R')
1991 return obj_elf_hash_n(str, len);
1995 obj_set_symbol_compare(struct obj_file *f,
1996 int (*cmp) (const char *, const char *),
1997 unsigned long (*hash) (const char *))
2000 f->symbol_cmp = cmp;
2002 struct obj_symbol *tmptab[HASH_BUCKETS], *sym, *next;
2005 f->symbol_hash = hash;
2007 memcpy(tmptab, f->symtab, sizeof(tmptab));
2008 memset(f->symtab, 0, sizeof(f->symtab));
2010 for (i = 0; i < HASH_BUCKETS; ++i)
2011 for (sym = tmptab[i]; sym; sym = next) {
2012 unsigned long h = hash(sym->name) % HASH_BUCKETS;
2014 sym->next = f->symtab[h];
2020 #endif /* FEATURE_INSMOD_VERSION_CHECKING */
2022 static struct obj_symbol *
2023 obj_add_symbol(struct obj_file *f, const char *name,
2024 unsigned long symidx, int info,
2025 int secidx, ElfW(Addr) value,
2028 struct obj_symbol *sym;
2029 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
2030 int n_type = ELF_ST_TYPE(info);
2031 int n_binding = ELF_ST_BIND(info);
2033 for (sym = f->symtab[hash]; sym; sym = sym->next)
2034 if (f->symbol_cmp(sym->name, name) == 0) {
2035 int o_secidx = sym->secidx;
2036 int o_info = sym->info;
2037 int o_type = ELF_ST_TYPE(o_info);
2038 int o_binding = ELF_ST_BIND(o_info);
2040 /* A redefinition! Is it legal? */
2042 if (secidx == SHN_UNDEF)
2044 else if (o_secidx == SHN_UNDEF)
2046 else if (n_binding == STB_GLOBAL && o_binding == STB_LOCAL) {
2047 /* Cope with local and global symbols of the same name
2048 in the same object file, as might have been created
2049 by ld -r. The only reason locals are now seen at this
2050 level at all is so that we can do semi-sensible things
2053 struct obj_symbol *nsym, **p;
2055 nsym = arch_new_symbol();
2056 nsym->next = sym->next;
2059 /* Excise the old (local) symbol from the hash chain. */
2060 for (p = &f->symtab[hash]; *p != sym; p = &(*p)->next)
2064 } else if (n_binding == STB_LOCAL) {
2065 /* Another symbol of the same name has already been defined.
2066 Just add this to the local table. */
2067 sym = arch_new_symbol();
2070 f->local_symtab[symidx] = sym;
2072 } else if (n_binding == STB_WEAK)
2074 else if (o_binding == STB_WEAK)
2076 /* Don't unify COMMON symbols with object types the programmer
2078 else if (secidx == SHN_COMMON
2079 && (o_type == STT_NOTYPE || o_type == STT_OBJECT))
2081 else if (o_secidx == SHN_COMMON
2082 && (n_type == STT_NOTYPE || n_type == STT_OBJECT))
2085 /* Don't report an error if the symbol is coming from
2086 the kernel or some external module. */
2087 if (secidx <= SHN_HIRESERVE)
2088 bb_error_msg("%s multiply defined", name);
2093 /* Completely new symbol. */
2094 sym = arch_new_symbol();
2095 sym->next = f->symtab[hash];
2096 f->symtab[hash] = sym;
2099 if (ELF_ST_BIND(info) == STB_LOCAL && symidx != -1) {
2100 if (symidx >= f->local_symtab_size)
2101 bb_error_msg("local symbol %s with index %ld exceeds local_symtab_size %ld",
2102 name, (long) symidx, (long) f->local_symtab_size);
2104 f->local_symtab[symidx] = sym;
2111 sym->secidx = secidx;
2117 static struct obj_symbol *
2118 obj_find_symbol(struct obj_file *f, const char *name)
2120 struct obj_symbol *sym;
2121 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
2123 for (sym = f->symtab[hash]; sym; sym = sym->next)
2124 if (f->symbol_cmp(sym->name, name) == 0)
2130 static ElfW(Addr) obj_symbol_final_value(struct obj_file * f, struct obj_symbol * sym)
2133 if (sym->secidx >= SHN_LORESERVE)
2136 return sym->value + f->sections[sym->secidx]->header.sh_addr;
2138 /* As a special case, a NULL sym has value zero. */
2143 static struct obj_section *obj_find_section(struct obj_file *f, const char *name)
2145 int i, n = f->header.e_shnum;
2147 for (i = 0; i < n; ++i)
2148 if (strcmp(f->sections[i]->name, name) == 0)
2149 return f->sections[i];
2154 static int obj_load_order_prio(struct obj_section *a)
2156 unsigned long af, ac;
2158 af = a->header.sh_flags;
2161 if (a->name[0] != '.' || strlen(a->name) != 10 ||
2162 strcmp(a->name + 5, ".init"))
2166 if (!(af & SHF_WRITE))
2168 if (af & SHF_EXECINSTR)
2170 if (a->header.sh_type != SHT_NOBITS)
2177 obj_insert_section_load_order(struct obj_file *f, struct obj_section *sec)
2179 struct obj_section **p;
2180 int prio = obj_load_order_prio(sec);
2181 for (p = f->load_order_search_start; *p; p = &(*p)->load_next)
2182 if (obj_load_order_prio(*p) < prio)
2184 sec->load_next = *p;
2188 static struct obj_section *obj_create_alloced_section(struct obj_file *f,
2190 unsigned long align,
2193 int newidx = f->header.e_shnum++;
2194 struct obj_section *sec;
2196 f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
2197 f->sections[newidx] = sec = arch_new_section();
2199 sec->header.sh_type = SHT_PROGBITS;
2200 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2201 sec->header.sh_size = size;
2202 sec->header.sh_addralign = align;
2206 sec->contents = xmalloc(size);
2208 obj_insert_section_load_order(f, sec);
2213 static struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
2215 unsigned long align,
2218 int newidx = f->header.e_shnum++;
2219 struct obj_section *sec;
2221 f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
2222 f->sections[newidx] = sec = arch_new_section();
2224 sec->header.sh_type = SHT_PROGBITS;
2225 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2226 sec->header.sh_size = size;
2227 sec->header.sh_addralign = align;
2231 sec->contents = xmalloc(size);
2233 sec->load_next = f->load_order;
2234 f->load_order = sec;
2235 if (f->load_order_search_start == &f->load_order)
2236 f->load_order_search_start = &sec->load_next;
2241 static void *obj_extend_section(struct obj_section *sec, unsigned long more)
2243 unsigned long oldsize = sec->header.sh_size;
2245 sec->contents = xrealloc(sec->contents, sec->header.sh_size += more);
2247 return sec->contents + oldsize;
2251 /* Conditionally add the symbols from the given symbol set to the
2255 add_symbols_from( struct obj_file *f,
2256 int idx, struct new_module_symbol *syms, size_t nsyms)
2258 struct new_module_symbol *s;
2261 #ifdef SYMBOL_PREFIX
2263 size_t name_alloced_size = 0;
2265 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
2268 gpl = obj_gpl_license(f, NULL) == 0;
2270 for (i = 0, s = syms; i < nsyms; ++i, ++s) {
2271 /* Only add symbols that are already marked external.
2272 If we override locals we may cause problems for
2273 argument initialization. We will also create a false
2274 dependency on the module. */
2275 struct obj_symbol *sym;
2278 /* GPL licensed modules can use symbols exported with
2279 * EXPORT_SYMBOL_GPL, so ignore any GPLONLY_ prefix on the
2280 * exported names. Non-GPL modules never see any GPLONLY_
2281 * symbols so they cannot fudge it by adding the prefix on
2284 if (strncmp((char *)s->name, "GPLONLY_", 8) == 0) {
2285 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
2292 name = (char *)s->name;
2294 #ifdef SYMBOL_PREFIX
2295 /* Prepend SYMBOL_PREFIX to the symbol's name (the
2296 kernel exports `C names', but module object files
2297 reference `linker names'). */
2298 size_t extra = sizeof SYMBOL_PREFIX;
2299 size_t name_size = strlen(name) + extra;
2300 if (name_size > name_alloced_size) {
2301 name_alloced_size = name_size * 2;
2302 name_buf = alloca(name_alloced_size);
2304 strcpy(name_buf, SYMBOL_PREFIX);
2305 strcpy(name_buf + extra - 1, name);
2307 #endif /* SYMBOL_PREFIX */
2309 sym = obj_find_symbol(f, name);
2310 if (sym && !(ELF_ST_BIND(sym->info) == STB_LOCAL)) {
2311 #ifdef SYMBOL_PREFIX
2312 /* Put NAME_BUF into more permanent storage. */
2313 name = xmalloc(name_size);
2314 strcpy(name, name_buf);
2316 sym = obj_add_symbol(f, name, -1,
2317 ELF_ST_INFO(STB_GLOBAL,
2320 /* Did our symbol just get installed? If so, mark the
2321 module as "used". */
2322 if (sym->secidx == idx)
2330 static void add_kernel_symbols(struct obj_file *f)
2332 struct external_module *m;
2335 /* Add module symbols first. */
2337 for (i = 0, m = ext_modules; i < n_ext_modules; ++i, ++m) {
2339 && add_symbols_from(f, SHN_HIRESERVE + 2 + i, m->syms, m->nsyms)
2346 n_ext_modules_used = nused;
2348 /* And finally the symbols from the kernel proper. */
2351 add_symbols_from(f, SHN_HIRESERVE + 1, ksyms, nksyms);
2354 static char *get_modinfo_value(struct obj_file *f, const char *key)
2356 struct obj_section *sec;
2357 char *p, *v, *n, *ep;
2358 size_t klen = strlen(key);
2360 sec = obj_find_section(f, ".modinfo");
2364 ep = p + sec->header.sh_size;
2367 n = strchr(p, '\0');
2369 if (p + klen == v && strncmp(p, key, klen) == 0)
2372 if (p + klen == n && strcmp(p, key) == 0)
2382 /*======================================================================*/
2383 /* Functions relating to module loading after 2.1.18. */
2386 new_process_module_arguments(struct obj_file *f, int argc, char **argv)
2389 char *p, *q, *key, *sym_name;
2390 struct obj_symbol *sym;
2391 char *contents, *loc;
2401 key = alloca(q - p + 6);
2402 memcpy(key, "parm_", 5);
2403 memcpy(key + 5, p, q - p);
2406 p = get_modinfo_value(f, key);
2409 bb_error_msg_and_die("invalid parameter %s", key);
2412 #ifdef SYMBOL_PREFIX
2413 sym_name = alloca(strlen(key) + sizeof SYMBOL_PREFIX);
2414 strcpy(sym_name, SYMBOL_PREFIX);
2415 strcat(sym_name, key);
2419 sym = obj_find_symbol(f, sym_name);
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", key);
2427 min = strtoul(p, &p, 10);
2429 max = strtoul(p + 1, &p, 10);
2435 contents = f->sections[sym->secidx]->contents;
2436 loc = contents + sym->value;
2440 if ((*p == 's') || (*p == 'c')) {
2443 /* Do C quoting if we begin with a ", else slurp the lot. */
2447 str = alloca(strlen(q));
2448 for (r = str, q++; *q != '"'; ++q, ++r) {
2450 bb_error_msg_and_die("improperly terminated string argument for %s",
2486 if (q[1] >= '0' && q[1] <= '7') {
2487 c = (c * 8) + *++q - '0';
2488 if (q[1] >= '0' && q[1] <= '7')
2489 c = (c * 8) + *++q - '0';
2507 /* In this case, the string is not quoted. We will break
2508 it using the coma (like for ints). If the user wants to
2509 include comas in a string, he just has to quote it */
2511 /* Search the next coma */
2515 if (r != (char *) NULL) {
2516 /* Recopy the current field */
2517 str = alloca(r - q + 1);
2518 memcpy(str, q, r - q);
2520 /* I don't know if it is useful, as the previous case
2521 doesn't nul terminate the string ??? */
2524 /* Keep next fields */
2535 obj_string_patch(f, sym->secidx, loc - contents, str);
2536 loc += tgt_sizeof_char_p;
2538 /* Array of chars (in fact, matrix!) */
2539 unsigned long charssize; /* size of each member */
2541 /* Get the size of each member */
2542 /* Probably we should do that outside the loop ? */
2543 if (!isdigit(*(p + 1))) {
2544 bb_error_msg_and_die("parameter type 'c' for %s must be followed by"
2545 " the maximum size", key);
2547 charssize = strtoul(p + 1, (char **) NULL, 10);
2550 if (strlen(str) >= charssize) {
2551 bb_error_msg_and_die("string too long for %s (max %ld)", key,
2555 /* Copy to location */
2556 strcpy((char *) loc, str);
2560 long v = strtoul(q, &q, 0);
2567 loc += tgt_sizeof_short;
2571 loc += tgt_sizeof_int;
2575 loc += tgt_sizeof_long;
2579 bb_error_msg_and_die("unknown parameter type '%c' for %s", *p, key);
2592 goto retry_end_of_value;
2596 bb_error_msg_and_die("too many values for %s (max %d)", key, max);
2602 bb_error_msg_and_die("invalid argument syntax for %s", key);
2607 bb_error_msg_and_die("too few values for %s (min %d)", key, min);
2615 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
2616 static int new_is_module_checksummed(struct obj_file *f)
2618 const char *p = get_modinfo_value(f, "using_checksums");
2624 /* Get the module's kernel version in the canonical integer form. */
2627 new_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
2632 p = get_modinfo_value(f, "kernel_version");
2635 safe_strncpy(str, p, STRVERSIONLEN);
2637 a = strtoul(p, &p, 10);
2640 b = strtoul(p + 1, &p, 10);
2643 c = strtoul(p + 1, &q, 10);
2647 return a << 16 | b << 8 | c;
2650 #endif /* FEATURE_INSMOD_VERSION_CHECKING */
2653 /* Fetch the loaded modules, and all currently exported symbols. */
2655 static void new_get_kernel_symbols(void)
2657 char *module_names, *mn;
2658 struct external_module *modules, *m;
2659 struct new_module_symbol *syms, *s;
2660 size_t ret, bufsize, nmod, nsyms, i, j;
2662 /* Collect the loaded modules. */
2665 module_names = xmalloc(bufsize);
2668 if (query_module(NULL, QM_MODULES, module_names, bufsize, &ret)) {
2669 if (errno == ENOSPC && bufsize < ret) {
2671 module_names = xrealloc(module_names, bufsize);
2672 goto retry_modules_load;
2674 bb_perror_msg_and_die("QM_MODULES");
2677 n_ext_modules = nmod = ret;
2679 /* Collect the modules' symbols. */
2682 ext_modules = modules = xmalloc(nmod * sizeof(*modules));
2683 memset(modules, 0, nmod * sizeof(*modules));
2684 for (i = 0, mn = module_names, m = modules;
2685 i < nmod; ++i, ++m, mn += strlen(mn) + 1) {
2686 struct new_module_info info;
2688 if (query_module(mn, QM_INFO, &info, sizeof(info), &ret)) {
2689 if (errno == ENOENT) {
2690 /* The module was removed out from underneath us. */
2693 bb_perror_msg_and_die("query_module: QM_INFO: %s", mn);
2697 syms = xmalloc(bufsize);
2699 if (query_module(mn, QM_SYMBOLS, syms, bufsize, &ret)) {
2703 syms = xrealloc(syms, bufsize);
2704 goto retry_mod_sym_load;
2706 /* The module was removed out from underneath us. */
2709 bb_perror_msg_and_die("query_module: QM_SYMBOLS: %s", mn);
2715 m->addr = info.addr;
2719 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2720 s->name += (unsigned long) syms;
2725 /* Collect the kernel's symbols. */
2727 syms = xmalloc(bufsize = 16 * 1024);
2728 retry_kern_sym_load:
2729 if (query_module(NULL, QM_SYMBOLS, syms, bufsize, &ret)) {
2730 if (errno == ENOSPC && bufsize < ret) {
2731 syms = xrealloc(syms, bufsize = ret);
2732 goto retry_kern_sym_load;
2734 bb_perror_msg_and_die("kernel: QM_SYMBOLS");
2736 nksyms = nsyms = ret;
2739 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2740 s->name += (unsigned long) syms;
2745 /* Return the kernel symbol checksum version, or zero if not used. */
2747 static int new_is_kernel_checksummed(void)
2749 struct new_module_symbol *s;
2752 /* Using_Versions is not the first symbol, but it should be in there. */
2754 for (i = 0, s = ksyms; i < nksyms; ++i, ++s)
2755 if (strcmp((char *) s->name, "Using_Versions") == 0)
2762 static void new_create_this_module(struct obj_file *f, const char *m_name)
2764 struct obj_section *sec;
2766 sec = obj_create_alloced_section_first(f, ".this", tgt_sizeof_long,
2767 sizeof(struct new_module));
2768 memset(sec->contents, 0, sizeof(struct new_module));
2770 obj_add_symbol(f, SPFX "__this_module", -1,
2771 ELF_ST_INFO(STB_LOCAL, STT_OBJECT), sec->idx, 0,
2772 sizeof(struct new_module));
2774 obj_string_patch(f, sec->idx, offsetof(struct new_module, name),
2778 #if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
2779 /* add an entry to the __ksymtab section, creating it if necessary */
2780 static void new_add_ksymtab(struct obj_file *f, struct obj_symbol *sym)
2782 struct obj_section *sec;
2785 /* ensure __ksymtab is allocated, EXPORT_NOSYMBOLS creates a non-alloc section.
2786 * If __ksymtab is defined but not marked alloc, x out the first character
2787 * (no obj_delete routine) and create a new __ksymtab with the correct
2790 sec = obj_find_section(f, "__ksymtab");
2791 if (sec && !(sec->header.sh_flags & SHF_ALLOC)) {
2792 *((char *)(sec->name)) = 'x'; /* override const */
2796 sec = obj_create_alloced_section(f, "__ksymtab",
2797 tgt_sizeof_void_p, 0);
2800 sec->header.sh_flags |= SHF_ALLOC;
2801 /* Empty section might be byte-aligned */
2802 sec->header.sh_addralign = tgt_sizeof_void_p;
2803 ofs = sec->header.sh_size;
2804 obj_symbol_patch(f, sec->idx, ofs, sym);
2805 obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p, sym->name);
2806 obj_extend_section(sec, 2 * tgt_sizeof_char_p);
2808 #endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
2810 static int new_create_module_ksymtab(struct obj_file *f)
2812 struct obj_section *sec;
2815 /* We must always add the module references. */
2817 if (n_ext_modules_used) {
2818 struct new_module_ref *dep;
2819 struct obj_symbol *tm;
2821 sec = obj_create_alloced_section(f, ".kmodtab", tgt_sizeof_void_p,
2822 (sizeof(struct new_module_ref)
2823 * n_ext_modules_used));
2827 tm = obj_find_symbol(f, SPFX "__this_module");
2828 dep = (struct new_module_ref *) sec->contents;
2829 for (i = 0; i < n_ext_modules; ++i)
2830 if (ext_modules[i].used) {
2831 dep->dep = ext_modules[i].addr;
2832 obj_symbol_patch(f, sec->idx,
2833 (char *) &dep->ref - sec->contents, tm);
2839 if (!flag_noexport && !obj_find_section(f, "__ksymtab")) {
2843 sec = obj_create_alloced_section(f, "__ksymtab", tgt_sizeof_void_p, 0);
2845 /* We don't want to export symbols residing in sections that
2846 aren't loaded. There are a number of these created so that
2847 we make sure certain module options don't appear twice. */
2849 loaded = alloca(sizeof(int) * (i = f->header.e_shnum));
2851 loaded[i] = (f->sections[i]->header.sh_flags & SHF_ALLOC) != 0;
2853 for (nsyms = i = 0; i < HASH_BUCKETS; ++i) {
2854 struct obj_symbol *sym;
2855 for (sym = f->symtab[i]; sym; sym = sym->next)
2856 if (ELF_ST_BIND(sym->info) != STB_LOCAL
2857 && sym->secidx <= SHN_HIRESERVE
2858 && (sym->secidx >= SHN_LORESERVE
2859 || loaded[sym->secidx])) {
2860 ElfW(Addr) ofs = nsyms * 2 * tgt_sizeof_void_p;
2862 obj_symbol_patch(f, sec->idx, ofs, sym);
2863 obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p,
2870 obj_extend_section(sec, nsyms * 2 * tgt_sizeof_char_p);
2878 new_init_module(const char *m_name, struct obj_file *f, unsigned long m_size)
2880 struct new_module *module;
2881 struct obj_section *sec;
2886 sec = obj_find_section(f, ".this");
2887 if (!sec || !sec->contents) {
2888 bb_perror_msg_and_die("corrupt module %s?",m_name);
2890 module = (struct new_module *) sec->contents;
2891 m_addr = sec->header.sh_addr;
2893 module->size_of_struct = sizeof(*module);
2894 module->size = m_size;
2895 module->flags = flag_autoclean ? NEW_MOD_AUTOCLEAN : 0;
2897 sec = obj_find_section(f, "__ksymtab");
2898 if (sec && sec->header.sh_size) {
2899 module->syms = sec->header.sh_addr;
2900 module->nsyms = sec->header.sh_size / (2 * tgt_sizeof_char_p);
2903 if (n_ext_modules_used) {
2904 sec = obj_find_section(f, ".kmodtab");
2905 module->deps = sec->header.sh_addr;
2906 module->ndeps = n_ext_modules_used;
2910 obj_symbol_final_value(f, obj_find_symbol(f, SPFX "init_module"));
2912 obj_symbol_final_value(f, obj_find_symbol(f, SPFX "cleanup_module"));
2914 sec = obj_find_section(f, "__ex_table");
2916 module->ex_table_start = sec->header.sh_addr;
2917 module->ex_table_end = sec->header.sh_addr + sec->header.sh_size;
2920 sec = obj_find_section(f, ".text.init");
2922 module->runsize = sec->header.sh_addr - m_addr;
2924 sec = obj_find_section(f, ".data.init");
2926 if (!module->runsize ||
2927 module->runsize > sec->header.sh_addr - m_addr)
2928 module->runsize = sec->header.sh_addr - m_addr;
2930 sec = obj_find_section(f, ARCHDATA_SEC_NAME);
2931 if (sec && sec->header.sh_size) {
2932 module->archdata_start = (void*)sec->header.sh_addr;
2933 module->archdata_end = module->archdata_start + sec->header.sh_size;
2935 sec = obj_find_section(f, KALLSYMS_SEC_NAME);
2936 if (sec && sec->header.sh_size) {
2937 module->kallsyms_start = (void*)sec->header.sh_addr;
2938 module->kallsyms_end = module->kallsyms_start + sec->header.sh_size;
2941 /* Whew! All of the initialization is complete. Collect the final
2942 module image and give it to the kernel. */
2944 image = xmalloc(m_size);
2945 obj_create_image(f, image);
2947 ret = init_module(m_name, (struct new_module *) image);
2949 bb_perror_msg("init_module: %s", m_name);
2957 /*======================================================================*/
2960 obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2963 struct obj_string_patch *p;
2964 struct obj_section *strsec;
2965 size_t len = strlen(string) + 1;
2968 p = xmalloc(sizeof(*p));
2969 p->next = f->string_patches;
2970 p->reloc_secidx = secidx;
2971 p->reloc_offset = offset;
2972 f->string_patches = p;
2974 strsec = obj_find_section(f, ".kstrtab");
2975 if (strsec == NULL) {
2976 strsec = obj_create_alloced_section(f, ".kstrtab", 1, len);
2977 p->string_offset = 0;
2978 loc = strsec->contents;
2980 p->string_offset = strsec->header.sh_size;
2981 loc = obj_extend_section(strsec, len);
2983 memcpy(loc, string, len);
2987 obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2988 struct obj_symbol *sym)
2990 struct obj_symbol_patch *p;
2992 p = xmalloc(sizeof(*p));
2993 p->next = f->symbol_patches;
2994 p->reloc_secidx = secidx;
2995 p->reloc_offset = offset;
2997 f->symbol_patches = p;
3000 static void obj_check_undefineds(struct obj_file *f)
3004 for (i = 0; i < HASH_BUCKETS; ++i) {
3005 struct obj_symbol *sym;
3006 for (sym = f->symtab[i]; sym; sym = sym->next)
3007 if (sym->secidx == SHN_UNDEF) {
3008 if (ELF_ST_BIND(sym->info) == STB_WEAK) {
3009 sym->secidx = SHN_ABS;
3013 bb_error_msg_and_die("unresolved symbol %s", sym->name);
3019 static void obj_allocate_commons(struct obj_file *f)
3021 struct common_entry {
3022 struct common_entry *next;
3023 struct obj_symbol *sym;
3024 } *common_head = NULL;
3028 for (i = 0; i < HASH_BUCKETS; ++i) {
3029 struct obj_symbol *sym;
3030 for (sym = f->symtab[i]; sym; sym = sym->next)
3031 if (sym->secidx == SHN_COMMON) {
3032 /* Collect all COMMON symbols and sort them by size so as to
3033 minimize space wasted by alignment requirements. */
3035 struct common_entry **p, *n;
3036 for (p = &common_head; *p; p = &(*p)->next)
3037 if (sym->size <= (*p)->sym->size)
3040 n = alloca(sizeof(*n));
3048 for (i = 1; i < f->local_symtab_size; ++i) {
3049 struct obj_symbol *sym = f->local_symtab[i];
3050 if (sym && sym->secidx == SHN_COMMON) {
3051 struct common_entry **p, *n;
3052 for (p = &common_head; *p; p = &(*p)->next)
3053 if (sym == (*p)->sym)
3055 else if (sym->size < (*p)->sym->size) {
3056 n = alloca(sizeof(*n));
3066 /* Find the bss section. */
3067 for (i = 0; i < f->header.e_shnum; ++i)
3068 if (f->sections[i]->header.sh_type == SHT_NOBITS)
3071 /* If for some reason there hadn't been one, create one. */
3072 if (i == f->header.e_shnum) {
3073 struct obj_section *sec;
3075 f->sections = xrealloc(f->sections, (i + 1) * sizeof(sec));
3076 f->sections[i] = sec = arch_new_section();
3077 f->header.e_shnum = i + 1;
3079 sec->header.sh_type = SHT_PROGBITS;
3080 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
3085 /* Allocate the COMMONS. */
3087 ElfW(Addr) bss_size = f->sections[i]->header.sh_size;
3088 ElfW(Addr) max_align = f->sections[i]->header.sh_addralign;
3089 struct common_entry *c;
3091 for (c = common_head; c; c = c->next) {
3092 ElfW(Addr) align = c->sym->value;
3094 if (align > max_align)
3096 if (bss_size & (align - 1))
3097 bss_size = (bss_size | (align - 1)) + 1;
3100 c->sym->value = bss_size;
3102 bss_size += c->sym->size;
3105 f->sections[i]->header.sh_size = bss_size;
3106 f->sections[i]->header.sh_addralign = max_align;
3110 /* For the sake of patch relocation and parameter initialization,
3111 allocate zeroed data for NOBITS sections now. Note that after
3112 this we cannot assume NOBITS are really empty. */
3113 for (i = 0; i < f->header.e_shnum; ++i) {
3114 struct obj_section *s = f->sections[i];
3115 if (s->header.sh_type == SHT_NOBITS) {
3116 if (s->header.sh_size != 0)
3117 s->contents = memset(xmalloc(s->header.sh_size),
3118 0, s->header.sh_size);
3122 s->header.sh_type = SHT_PROGBITS;
3127 static unsigned long obj_load_size(struct obj_file *f)
3129 unsigned long dot = 0;
3130 struct obj_section *sec;
3132 /* Finalize the positions of the sections relative to one another. */
3134 for (sec = f->load_order; sec; sec = sec->load_next) {
3137 align = sec->header.sh_addralign;
3138 if (align && (dot & (align - 1)))
3139 dot = (dot | (align - 1)) + 1;
3141 sec->header.sh_addr = dot;
3142 dot += sec->header.sh_size;
3148 static int obj_relocate(struct obj_file *f, ElfW(Addr) base)
3150 int i, n = f->header.e_shnum;
3153 /* Finalize the addresses of the sections. */
3156 for (i = 0; i < n; ++i)
3157 f->sections[i]->header.sh_addr += base;
3159 /* And iterate over all of the relocations. */
3161 for (i = 0; i < n; ++i) {
3162 struct obj_section *relsec, *symsec, *targsec, *strsec;
3163 ElfW(RelM) * rel, *relend;
3167 relsec = f->sections[i];
3168 if (relsec->header.sh_type != SHT_RELM)
3171 symsec = f->sections[relsec->header.sh_link];
3172 targsec = f->sections[relsec->header.sh_info];
3173 strsec = f->sections[symsec->header.sh_link];
3175 rel = (ElfW(RelM) *) relsec->contents;
3176 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
3177 symtab = (ElfW(Sym) *) symsec->contents;
3178 strtab = (const char *) strsec->contents;
3180 for (; rel < relend; ++rel) {
3181 ElfW(Addr) value = 0;
3182 struct obj_symbol *intsym = NULL;
3183 unsigned long symndx;
3184 ElfW(Sym) * extsym = 0;
3187 /* Attempt to find a value to use for this relocation. */
3189 symndx = ELF_R_SYM(rel->r_info);
3191 /* Note we've already checked for undefined symbols. */
3193 extsym = &symtab[symndx];
3194 if (ELF_ST_BIND(extsym->st_info) == STB_LOCAL) {
3195 /* Local symbols we look up in the local table to be sure
3196 we get the one that is really intended. */
3197 intsym = f->local_symtab[symndx];
3199 /* Others we look up in the hash table. */
3201 if (extsym->st_name)
3202 name = strtab + extsym->st_name;
3204 name = f->sections[extsym->st_shndx]->name;
3205 intsym = obj_find_symbol(f, name);
3208 value = obj_symbol_final_value(f, intsym);
3209 intsym->referenced = 1;
3211 #if SHT_RELM == SHT_RELA
3212 #if defined(__alpha__) && defined(AXP_BROKEN_GAS)
3213 /* Work around a nasty GAS bug, that is fixed as of 2.7.0.9. */
3214 if (!extsym || !extsym->st_name ||
3215 ELF_ST_BIND(extsym->st_info) != STB_LOCAL)
3217 value += rel->r_addend;
3221 switch (arch_apply_relocation
3222 (f, targsec, symsec, intsym, rel, value)
3227 case obj_reloc_overflow:
3228 errmsg = "Relocation overflow";
3230 case obj_reloc_dangerous:
3231 errmsg = "Dangerous relocation";
3233 case obj_reloc_unhandled:
3234 errmsg = "Unhandled relocation";
3237 bb_error_msg("%s of type %ld for %s", errmsg,
3238 (long) ELF_R_TYPE(rel->r_info),
3239 strtab + extsym->st_name);
3241 bb_error_msg("%s of type %ld", errmsg,
3242 (long) ELF_R_TYPE(rel->r_info));
3250 /* Finally, take care of the patches. */
3252 if (f->string_patches) {
3253 struct obj_string_patch *p;
3254 struct obj_section *strsec;
3255 ElfW(Addr) strsec_base;
3256 strsec = obj_find_section(f, ".kstrtab");
3257 strsec_base = strsec->header.sh_addr;
3259 for (p = f->string_patches; p; p = p->next) {
3260 struct obj_section *targsec = f->sections[p->reloc_secidx];
3261 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
3262 = strsec_base + p->string_offset;
3266 if (f->symbol_patches) {
3267 struct obj_symbol_patch *p;
3269 for (p = f->symbol_patches; p; p = p->next) {
3270 struct obj_section *targsec = f->sections[p->reloc_secidx];
3271 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
3272 = obj_symbol_final_value(f, p->sym);
3279 static int obj_create_image(struct obj_file *f, char *image)
3281 struct obj_section *sec;
3282 ElfW(Addr) base = f->baseaddr;
3284 for (sec = f->load_order; sec; sec = sec->load_next) {
3287 if (sec->contents == 0 || sec->header.sh_size == 0)
3290 secimg = image + (sec->header.sh_addr - base);
3292 /* Note that we allocated data for NOBITS sections earlier. */
3293 memcpy(secimg, sec->contents, sec->header.sh_size);
3299 /*======================================================================*/
3301 static struct obj_file *obj_load(FILE * fp, int loadprogbits)
3304 ElfW(Shdr) * section_headers;
3308 /* Read the file header. */
3310 f = arch_new_file();
3311 f->symbol_cmp = strcmp;
3312 f->symbol_hash = obj_elf_hash;
3313 f->load_order_search_start = &f->load_order;
3315 fseek(fp, 0, SEEK_SET);
3316 if (fread(&f->header, sizeof(f->header), 1, fp) != 1) {
3317 bb_perror_msg_and_die("error reading ELF header");
3320 if (f->header.e_ident[EI_MAG0] != ELFMAG0
3321 || f->header.e_ident[EI_MAG1] != ELFMAG1
3322 || f->header.e_ident[EI_MAG2] != ELFMAG2
3323 || f->header.e_ident[EI_MAG3] != ELFMAG3) {
3324 bb_error_msg_and_die("not an ELF file");
3326 if (f->header.e_ident[EI_CLASS] != ELFCLASSM
3327 || f->header.e_ident[EI_DATA] != (BB_BIG_ENDIAN
3328 ? ELFDATA2MSB : ELFDATA2LSB)
3329 || f->header.e_ident[EI_VERSION] != EV_CURRENT
3330 || !MATCH_MACHINE(f->header.e_machine)) {
3331 bb_error_msg_and_die("ELF file not for this architecture");
3333 if (f->header.e_type != ET_REL) {
3334 bb_error_msg_and_die("ELF file not a relocatable object");
3337 /* Read the section headers. */
3339 if (f->header.e_shentsize != sizeof(ElfW(Shdr))) {
3340 bb_error_msg_and_die("section header size mismatch: %lu != %lu",
3341 (unsigned long) f->header.e_shentsize,
3342 (unsigned long) sizeof(ElfW(Shdr)));
3345 shnum = f->header.e_shnum;
3346 f->sections = xmalloc(sizeof(struct obj_section *) * shnum);
3347 memset(f->sections, 0, sizeof(struct obj_section *) * shnum);
3349 section_headers = alloca(sizeof(ElfW(Shdr)) * shnum);
3350 fseek(fp, f->header.e_shoff, SEEK_SET);
3351 if (fread(section_headers, sizeof(ElfW(Shdr)), shnum, fp) != shnum) {
3352 bb_perror_msg_and_die("error reading ELF section headers");
3355 /* Read the section data. */
3357 for (i = 0; i < shnum; ++i) {
3358 struct obj_section *sec;
3360 f->sections[i] = sec = arch_new_section();
3362 sec->header = section_headers[i];
3365 if (sec->header.sh_size) {
3366 switch (sec->header.sh_type) {
3375 if (!loadprogbits) {
3376 sec->contents = NULL;
3383 if (sec->header.sh_size > 0) {
3384 sec->contents = xmalloc(sec->header.sh_size);
3385 fseek(fp, sec->header.sh_offset, SEEK_SET);
3386 if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
3387 bb_perror_msg_and_die("error reading ELF section data");
3390 sec->contents = NULL;
3394 #if SHT_RELM == SHT_REL
3396 bb_error_msg_and_die("RELA relocations not supported on this architecture");
3399 bb_error_msg_and_die("REL relocations not supported on this architecture");
3402 if (sec->header.sh_type >= SHT_LOPROC) {
3403 /* Assume processor specific section types are debug
3404 info and can safely be ignored. If this is ever not
3405 the case (Hello MIPS?), don't put ifdefs here but
3406 create an arch_load_proc_section(). */
3410 bb_error_msg_and_die("can't handle sections of type %ld",
3411 (long) sec->header.sh_type);
3416 /* Do what sort of interpretation as needed by each section. */
3418 shstrtab = f->sections[f->header.e_shstrndx]->contents;
3420 for (i = 0; i < shnum; ++i) {
3421 struct obj_section *sec = f->sections[i];
3422 sec->name = shstrtab + sec->header.sh_name;
3425 for (i = 0; i < shnum; ++i) {
3426 struct obj_section *sec = f->sections[i];
3428 /* .modinfo should be contents only but gcc has no attribute for that.
3429 * The kernel may have marked .modinfo as ALLOC, ignore this bit.
3431 if (strcmp(sec->name, ".modinfo") == 0)
3432 sec->header.sh_flags &= ~SHF_ALLOC;
3434 if (sec->header.sh_flags & SHF_ALLOC)
3435 obj_insert_section_load_order(f, sec);
3437 switch (sec->header.sh_type) {
3440 unsigned long nsym, j;
3444 if (sec->header.sh_entsize != sizeof(ElfW(Sym))) {
3445 bb_error_msg_and_die("symbol size mismatch: %lu != %lu",
3446 (unsigned long) sec->header.sh_entsize,
3447 (unsigned long) sizeof(ElfW(Sym)));
3450 nsym = sec->header.sh_size / sizeof(ElfW(Sym));
3451 strtab = f->sections[sec->header.sh_link]->contents;
3452 sym = (ElfW(Sym) *) sec->contents;
3454 /* Allocate space for a table of local symbols. */
3455 j = f->local_symtab_size = sec->header.sh_info;
3456 f->local_symtab = xzalloc(j * sizeof(struct obj_symbol *));
3458 /* Insert all symbols into the hash table. */
3459 for (j = 1, ++sym; j < nsym; ++j, ++sym) {
3460 ElfW(Addr) val = sym->st_value;
3463 name = strtab + sym->st_name;
3464 else if (sym->st_shndx < shnum)
3465 name = f->sections[sym->st_shndx]->name;
3468 #if defined(__SH5__)
3470 * For sh64 it is possible that the target of a branch
3471 * requires a mode switch (32 to 16 and back again).
3473 * This is implied by the lsb being set in the target
3474 * address for SHmedia mode and clear for SHcompact.
3476 val |= sym->st_other & 4;
3478 obj_add_symbol(f, name, j, sym->st_info, sym->st_shndx,
3485 if (sec->header.sh_entsize != sizeof(ElfW(RelM))) {
3486 bb_error_msg_and_die("relocation entry size mismatch: %lu != %lu",
3487 (unsigned long) sec->header.sh_entsize,
3488 (unsigned long) sizeof(ElfW(RelM)));
3491 /* XXX Relocation code from modutils-2.3.19 is not here.
3492 * Why? That's about 20 lines of code from obj/obj_load.c,
3493 * which gets done in a second pass through the sections.
3494 * This BusyBox insmod does similar work in obj_relocate(). */
3501 #if ENABLE_FEATURE_INSMOD_LOADINKMEM
3503 * load the unloaded sections directly into the memory allocated by
3504 * kernel for the module
3507 static int obj_load_progbits(FILE * fp, struct obj_file* f, char* imagebase)
3509 ElfW(Addr) base = f->baseaddr;
3510 struct obj_section* sec;
3512 for (sec = f->load_order; sec; sec = sec->load_next) {
3514 /* section already loaded? */
3515 if (sec->contents != NULL)
3518 if (sec->header.sh_size == 0)
3521 sec->contents = imagebase + (sec->header.sh_addr - base);
3522 fseek(fp, sec->header.sh_offset, SEEK_SET);
3523 if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
3524 bb_perror_msg("error reading ELF section data");
3533 static void hide_special_symbols(struct obj_file *f)
3535 static const char *const specials[] = {
3536 SPFX "cleanup_module",
3538 SPFX "kernel_version",
3542 struct obj_symbol *sym;
3543 const char *const *p;
3545 for (p = specials; *p; ++p) {
3546 sym = obj_find_symbol(f, *p);
3548 sym->info = ELF_ST_INFO(STB_LOCAL, ELF_ST_TYPE(sym->info));
3553 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
3554 static int obj_gpl_license(struct obj_file *f, const char **license)
3556 struct obj_section *sec;
3557 /* This list must match *exactly* the list of allowable licenses in
3558 * linux/include/linux/module.h. Checking for leading "GPL" will not
3559 * work, somebody will use "GPL sucks, this is proprietary".
3561 static const char *const gpl_licenses[] = {
3564 "GPL and additional rights",
3569 sec = obj_find_section(f, ".modinfo");
3571 const char *value, *ptr, *endptr;
3572 ptr = sec->contents;
3573 endptr = ptr + sec->header.sh_size;
3574 while (ptr < endptr) {
3575 value = strchr(ptr, '=');
3576 if (value && strncmp(ptr, "license", value-ptr) == 0) {
3580 for (i = 0; i < ARRAY_SIZE(gpl_licenses); ++i) {
3581 if (strcmp(value+1, gpl_licenses[i]) == 0)
3586 ptr = strchr(ptr, '\0');
3596 #define TAINT_FILENAME "/proc/sys/kernel/tainted"
3597 #define TAINT_PROPRIETORY_MODULE (1 << 0)
3598 #define TAINT_FORCED_MODULE (1 << 1)
3599 #define TAINT_UNSAFE_SMP (1 << 2)
3600 #define TAINT_URL "http://www.tux.org/lkml/#export-tainted"
3602 static void set_tainted(int fd, char *m_name,
3603 int kernel_has_tainted, int taint, const char *text1, const char *text2)
3605 static smallint printed_info;
3610 if (fd < 0 && !kernel_has_tainted)
3611 return; /* New modutils on old kernel */
3612 printf("Warning: loading %s will taint the kernel: %s%s\n",
3613 m_name, text1, text2);
3614 if (!printed_info) {
3615 printf(" See %s for information about tainted modules\n", TAINT_URL);
3619 read(fd, buf, sizeof(buf)-1);
3620 buf[sizeof(buf)-1] = '\0';
3621 oldval = strtoul(buf, NULL, 10);
3622 sprintf(buf, "%d\n", oldval | taint);
3623 write(fd, buf, strlen(buf));
3627 /* Check if loading this module will taint the kernel. */
3628 static void check_tainted_module(struct obj_file *f, char *m_name)
3630 static const char tainted_file[] ALIGN1 = TAINT_FILENAME;
3632 int fd, kernel_has_tainted;
3635 kernel_has_tainted = 1;
3636 fd = open(tainted_file, O_RDWR);
3638 if (errno == ENOENT)
3639 kernel_has_tainted = 0;
3640 else if (errno == EACCES)
3641 kernel_has_tainted = 1;
3643 perror(tainted_file);
3644 kernel_has_tainted = 0;
3648 switch (obj_gpl_license(f, &ptr)) {
3652 set_tainted(fd, m_name, kernel_has_tainted, TAINT_PROPRIETORY_MODULE, "no license", "");
3655 /* The module has a non-GPL license so we pretend that the
3656 * kernel always has a taint flag to get a warning even on
3657 * kernels without the proc flag.
3659 set_tainted(fd, m_name, 1, TAINT_PROPRIETORY_MODULE, "non-GPL license - ", ptr);
3662 set_tainted(fd, m_name, 1, TAINT_PROPRIETORY_MODULE, "Unexpected return from obj_gpl_license", "");
3666 if (flag_force_load)
3667 set_tainted(fd, m_name, 1, TAINT_FORCED_MODULE, "forced load", "");
3672 #else /* FEATURE_CHECK_TAINTED_MODULE */
3673 #define check_tainted_module(x, y) do { } while (0);
3674 #endif /* FEATURE_CHECK_TAINTED_MODULE */
3676 #if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
3677 /* add module source, timestamp, kernel version and a symbol for the
3678 * start of some sections. this info is used by ksymoops to do better
3682 get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
3684 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3685 return new_get_module_version(f, str);
3686 #else /* FEATURE_INSMOD_VERSION_CHECKING */
3687 strncpy(str, "???", sizeof(str));
3689 #endif /* FEATURE_INSMOD_VERSION_CHECKING */
3692 /* add module source, timestamp, kernel version and a symbol for the
3693 * start of some sections. this info is used by ksymoops to do better
3697 add_ksymoops_symbols(struct obj_file *f, const char *filename,
3700 static const char symprefix[] ALIGN1 = "__insmod_";
3701 static const char section_names[][8] = {
3709 struct obj_section *sec;
3710 struct obj_symbol *sym;
3711 char *name, *absolute_filename;
3712 char str[STRVERSIONLEN];
3713 int i, l, lm_name, lfilename, use_ksymtab, version;
3714 struct stat statbuf;
3716 /* WARNING: was using realpath, but replaced by readlink to stop using
3717 * lots of stack. But here it seems to be able to cause problems? */
3718 absolute_filename = xmalloc_readlink(filename);
3719 if (!absolute_filename)
3720 absolute_filename = xstrdup(filename);
3722 lm_name = strlen(m_name);
3723 lfilename = strlen(absolute_filename);
3725 /* add to ksymtab if it already exists or there is no ksymtab and other symbols
3726 * are not to be exported. otherwise leave ksymtab alone for now, the
3727 * "export all symbols" compatibility code will export these symbols later.
3729 use_ksymtab = obj_find_section(f, "__ksymtab") || flag_noexport;
3731 sec = obj_find_section(f, ".this");
3733 /* tag the module header with the object name, last modified
3734 * timestamp and module version. worst case for module version
3735 * is 0xffffff, decimal 16777215. putting all three fields in
3736 * one symbol is less readable but saves kernel space.
3738 l = sizeof(symprefix) + /* "__insmod_" */
3739 lm_name + /* module name */
3741 lfilename + /* object filename */
3743 2 * sizeof(statbuf.st_mtime) + /* mtime in hex */
3745 8 + /* version in dec */
3748 if (stat(absolute_filename, &statbuf) != 0)
3749 statbuf.st_mtime = 0;
3750 version = get_module_version(f, str); /* -1 if not found */
3751 snprintf(name, l, "%s%s_O%s_M%0*lX_V%d",
3752 symprefix, m_name, absolute_filename,
3753 (int)(2 * sizeof(statbuf.st_mtime)), statbuf.st_mtime,
3755 sym = obj_add_symbol(f, name, -1,
3756 ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3757 sec->idx, sec->header.sh_addr, 0);
3759 new_add_ksymtab(f, sym);
3761 free(absolute_filename);
3762 #ifdef _NOT_SUPPORTED_
3763 /* record where the persistent data is going, same address as previous symbol */
3766 l = sizeof(symprefix) + /* "__insmod_" */
3767 lm_name + /* module name */
3769 strlen(f->persist) + /* data store */
3772 snprintf(name, l, "%s%s_P%s",
3773 symprefix, m_name, f->persist);
3774 sym = obj_add_symbol(f, name, -1, ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3775 sec->idx, sec->header.sh_addr, 0);
3777 new_add_ksymtab(f, sym);
3779 #endif /* _NOT_SUPPORTED_ */
3780 /* tag the desired sections if size is non-zero */
3782 for (i = 0; i < ARRAY_SIZE(section_names); ++i) {
3783 sec = obj_find_section(f, section_names[i]);
3784 if (sec && sec->header.sh_size) {
3785 l = sizeof(symprefix) + /* "__insmod_" */
3786 lm_name + /* module name */
3788 strlen(sec->name) + /* section name */
3790 8 + /* length in dec */
3793 snprintf(name, l, "%s%s_S%s_L%ld",
3794 symprefix, m_name, sec->name,
3795 (long)sec->header.sh_size);
3796 sym = obj_add_symbol(f, name, -1, ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3797 sec->idx, sec->header.sh_addr, 0);
3799 new_add_ksymtab(f, sym);
3803 #endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
3805 #if ENABLE_FEATURE_INSMOD_LOAD_MAP
3806 static void print_load_map(struct obj_file *f)
3808 struct obj_section *sec;
3809 #if ENABLE_FEATURE_INSMOD_LOAD_MAP_FULL
3810 struct obj_symbol **all, **p;
3811 int i, nsyms, *loaded;
3812 struct obj_symbol *sym;
3814 /* Report on the section layout. */
3816 printf("Sections: Size %-*s Align\n",
3817 (int) (2 * sizeof(void *)), "Address");
3819 for (sec = f->load_order; sec; sec = sec->load_next) {
3823 for (a = -1, tmp = sec->header.sh_addralign; tmp; ++a)
3828 printf("%-15s %08lx %0*lx 2**%d\n",
3830 (long)sec->header.sh_size,
3831 (int) (2 * sizeof(void *)),
3832 (long)sec->header.sh_addr,
3835 #if ENABLE_FEATURE_INSMOD_LOAD_MAP_FULL
3836 /* Quick reference which section indicies are loaded. */
3838 i = f->header.e_shnum;
3839 loaded = alloca(sizeof(int) * i);
3841 loaded[i] = ((f->sections[i]->header.sh_flags & SHF_ALLOC) != 0);
3843 /* Collect the symbols we'll be listing. */
3845 for (nsyms = i = 0; i < HASH_BUCKETS; ++i)
3846 for (sym = f->symtab[i]; sym; sym = sym->next)
3847 if (sym->secidx <= SHN_HIRESERVE
3848 && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx]))
3851 all = alloca(nsyms * sizeof(struct obj_symbol *));
3853 for (i = 0, p = all; i < HASH_BUCKETS; ++i)
3854 for (sym = f->symtab[i]; sym; sym = sym->next)
3855 if (sym->secidx <= SHN_HIRESERVE
3856 && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx]))
3859 /* And list them. */
3860 printf("\nSymbols:\n");
3861 for (p = all; p < all + nsyms; ++p) {
3863 unsigned long value;
3866 if (sym->secidx == SHN_ABS) {
3869 } else if (sym->secidx == SHN_UNDEF) {
3873 sec = f->sections[sym->secidx];
3875 if (sec->header.sh_type == SHT_NOBITS)
3877 else if (sec->header.sh_flags & SHF_ALLOC) {
3878 if (sec->header.sh_flags & SHF_EXECINSTR)
3880 else if (sec->header.sh_flags & SHF_WRITE)
3885 value = sym->value + sec->header.sh_addr;
3888 if (ELF_ST_BIND(sym->info) == STB_LOCAL)
3889 type = tolower(type);
3891 printf("%0*lx %c %s\n", (int) (2 * sizeof(void *)), value,
3896 #else /* !FEATURE_INSMOD_LOAD_MAP */
3897 void print_load_map(struct obj_file *f);
3900 int insmod_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
3901 int insmod_main(int argc, char **argv)
3907 unsigned long m_size;
3911 char *m_name = NULL;
3912 int exit_status = EXIT_FAILURE;
3914 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3915 struct utsname uts_info;
3916 char m_strversion[STRVERSIONLEN];
3917 int m_version, m_crcs;
3919 #if ENABLE_FEATURE_CLEAN_UP
3925 struct utsname myuname;
3927 /* Parse any options */
3928 getopt32(argv, OPTION_STR, &opt_o);
3929 arg1 = argv[optind];
3930 if (option_mask32 & OPT_o) { // -o /* name the output module */
3932 m_name = xstrdup(opt_o);
3939 /* Grab the module name */
3940 tmp1 = xstrdup(arg1);
3941 tmp = basename(tmp1);
3944 if (uname(&myuname) == 0) {
3945 if (myuname.release[0] == '2') {
3946 k_version = myuname.release[2] - '0';
3950 #if ENABLE_FEATURE_2_6_MODULES
3951 if (k_version > 4 && len > 3 && tmp[len - 3] == '.'
3952 && tmp[len - 2] == 'k' && tmp[len - 1] == 'o'
3958 if (len > 2 && tmp[len - 2] == '.' && tmp[len - 1] == 'o') {
3964 #if ENABLE_FEATURE_2_6_MODULES
3966 m_fullName = xasprintf("%s.ko", tmp);
3969 m_fullName = xasprintf("%s.o", tmp);
3975 tmp1 = NULL; /* flag for free(m_name) before exit() */
3978 /* Get a filedesc for the module. Check that we have a complete path */
3979 if (stat(arg1, &st) < 0 || !S_ISREG(st.st_mode)
3980 || (fp = fopen(arg1, "r")) == NULL
3982 /* Hmm. Could not open it. First search under /lib/modules/`uname -r`,
3983 * but do not error out yet if we fail to find it... */
3984 if (k_version) { /* uname succeedd */
3988 tmdn = concat_path_file(_PATH_MODULES, myuname.release);
3989 /* Jump through hoops in case /lib/modules/`uname -r`
3990 * is a symlink. We do not want recursive_action to
3991 * follow symlinks, but we do want to follow the
3992 * /lib/modules/`uname -r` dir, So resolve it ourselves
3993 * if it is a link... */
3994 module_dir = xmalloc_readlink(tmdn);
3996 module_dir = xstrdup(tmdn);
3997 recursive_action(module_dir, ACTION_RECURSE,
3998 check_module_name_match, NULL, m_fullName, 0);
4003 /* Check if we have found anything yet */
4004 if (!m_filename || ((fp = fopen(m_filename, "r")) == NULL)) {
4010 module_dir = xmalloc_readlink(_PATH_MODULES);
4012 module_dir = xstrdup(_PATH_MODULES);
4013 /* No module found under /lib/modules/`uname -r`, this
4014 * time cast the net a bit wider. Search /lib/modules/ */
4015 r = recursive_action(module_dir, ACTION_RECURSE,
4016 check_module_name_match, NULL, m_fullName, 0);
4018 bb_error_msg_and_die("%s: module not found", m_fullName);
4020 if (m_filename == NULL
4021 || ((fp = fopen(m_filename, "r")) == NULL)
4023 bb_error_msg_and_die("%s: module not found", m_fullName);
4027 m_filename = xstrdup(arg1);
4030 printf("Using %s\n", m_filename);
4032 #if ENABLE_FEATURE_2_6_MODULES
4033 if (k_version > 4) {
4034 argv[optind] = m_filename;
4036 return insmod_ng_main(argc - optind, argv + optind);
4040 f = obj_load(fp, LOADBITS);
4042 if (get_modinfo_value(f, "kernel_version") == NULL)
4047 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
4048 /* Version correspondence? */
4050 if (uname(&uts_info) < 0)
4051 uts_info.release[0] = '\0';
4052 if (m_has_modinfo) {
4053 m_version = new_get_module_version(f, m_strversion);
4054 if (m_version == -1) {
4055 bb_error_msg_and_die("cannot find the kernel version the module was "
4060 if (strncmp(uts_info.release, m_strversion, STRVERSIONLEN) != 0) {
4061 bb_error_msg("%skernel-module version mismatch\n"
4062 "\t%s was compiled for kernel version %s\n"
4063 "\twhile this kernel is version %s",
4064 flag_force_load ? "warning: " : "",
4065 m_filename, m_strversion, uts_info.release);
4066 if (!flag_force_load)
4071 #endif /* FEATURE_INSMOD_VERSION_CHECKING */
4073 if (query_module(NULL, 0, NULL, 0, NULL))
4074 bb_error_msg_and_die("not configured to support old kernels");
4075 new_get_kernel_symbols();
4076 k_crcs = new_is_kernel_checksummed();
4078 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
4081 m_crcs = new_is_module_checksummed(f);
4083 if (m_crcs != k_crcs)
4084 obj_set_symbol_compare(f, ncv_strcmp, ncv_symbol_hash);
4085 #endif /* FEATURE_INSMOD_VERSION_CHECKING */
4087 /* Let the module know about the kernel symbols. */
4088 add_kernel_symbols(f);
4090 /* Allocate common symbols, symbol tables, and string tables. */
4092 new_create_this_module(f, m_name);
4093 obj_check_undefineds(f);
4094 obj_allocate_commons(f);
4095 check_tainted_module(f, m_name);
4097 /* done with the module name, on to the optional var=value arguments */
4099 if (optind < argc) {
4100 new_process_module_arguments(f, argc - optind, argv + optind);
4104 hide_special_symbols(f);
4106 #if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
4107 add_ksymoops_symbols(f, m_filename, m_name);
4108 #endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
4110 new_create_module_ksymtab(f);
4112 /* Find current size of the module */
4113 m_size = obj_load_size(f);
4115 m_addr = create_module(m_name, m_size);
4116 if (m_addr == -1) switch (errno) {
4118 bb_error_msg_and_die("a module named %s already exists", m_name);
4120 bb_error_msg_and_die("can't allocate kernel memory for module; needed %lu bytes",
4123 bb_perror_msg_and_die("create_module: %s", m_name);
4128 * the PROGBITS section was not loaded by the obj_load
4129 * now we can load them directly into the kernel memory
4131 if (!obj_load_progbits(fp, f, (char*)m_addr)) {
4132 delete_module(m_name);
4137 if (!obj_relocate(f, m_addr)) {
4138 delete_module(m_name);
4142 if (!new_init_module(m_name, f, m_size)) {
4143 delete_module(m_name);
4147 if (flag_print_load_map)
4150 exit_status = EXIT_SUCCESS;
4153 #if ENABLE_FEATURE_CLEAN_UP
4164 #endif /* ENABLE_FEATURE_2_4_MODULES */
4166 * End of big piece of 2.4-specific code
4170 #if ENABLE_FEATURE_2_6_MODULES
4172 #include <sys/mman.h>
4173 #include <asm/unistd.h>
4174 #include <sys/syscall.h>
4176 /* We use error numbers in a loose translation... */
4177 static const char *moderror(int err)
4181 return "invalid module format";
4183 return "unknown symbol in module";
4185 return "module has wrong symbol version";
4187 return "invalid parameters";
4189 return strerror(err);
4193 #if !ENABLE_FEATURE_2_4_MODULES
4194 int insmod_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
4195 int insmod_main(int argc, char **argv)
4197 static int insmod_ng_main(int argc, char **argv)
4204 char *filename, *options;
4210 /* Rest is options */
4211 options = xzalloc(1);
4214 options = xrealloc(options, optlen + 2 + strlen(*argv) + 2);
4215 /* Spaces handled by "" pairs, but no way of escaping quotes */
4216 optlen += sprintf(options + optlen, (strchr(*argv,' ') ? "\"%s\" " : "%s "), *argv);
4220 /* Any special reason why mmap? It isn't performace critical... */
4224 fd = xopen(filename, O_RDONLY);
4227 map = mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
4228 if (map == MAP_FAILED) {
4229 bb_perror_msg_and_die("cannot mmap '%s'", filename);
4232 /* map == NULL on Blackfin, probably on other MMU-less systems too. Workaround. */
4235 xread(fd, map, len);
4238 len = MAXINT(ssize_t);
4239 map = xmalloc_open_read_close(filename, &len);
4242 ret = syscall(__NR_init_module, map, len, options);
4244 bb_perror_msg_and_die("cannot insert '%s': %s (%li)",
4245 filename, moderror(errno), ret);