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 CONFIG_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 * This program is free software; you can redistribute it and/or modify
59 * it under the terms of the GNU General Public License as published by
60 * the Free Software Foundation; either version 2 of the License, or
61 * (at your option) any later version.
63 * This program is distributed in the hope that it will be useful,
64 * but WITHOUT ANY WARRANTY; without even the implied warranty of
65 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
66 * General Public License for more details.
68 * You should have received a copy of the GNU General Public License
69 * along with this program; if not, write to the Free Software
70 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
85 #include <sys/utsname.h>
88 #if !defined(CONFIG_FEATURE_2_4_MODULES) && \
89 !defined(CONFIG_FEATURE_2_6_MODULES)
90 #define CONFIG_FEATURE_2_4_MODULES
93 #if !defined(CONFIG_FEATURE_2_4_MODULES)
94 #define insmod_ng_main insmod_main
97 #if defined(CONFIG_FEATURE_2_6_MODULES)
98 extern int insmod_ng_main( int argc, char **argv);
102 #if defined(CONFIG_FEATURE_2_4_MODULES)
105 #ifdef CONFIG_FEATURE_INSMOD_LOADINKMEM
113 #if defined(__alpha__)
114 #define MATCH_MACHINE(x) (x == EM_ALPHA)
115 #define SHT_RELM SHT_RELA
116 #define Elf64_RelM Elf64_Rela
117 #define ELFCLASSM ELFCLASS64
122 #define MATCH_MACHINE(x) (x == EM_ARM)
123 #define SHT_RELM SHT_REL
124 #define Elf32_RelM Elf32_Rel
125 #define ELFCLASSM ELFCLASS32
126 #define CONFIG_USE_PLT_ENTRIES
127 #define CONFIG_PLT_ENTRY_SIZE 8
128 #define CONFIG_USE_GOT_ENTRIES
129 #define CONFIG_GOT_ENTRY_SIZE 8
130 #define CONFIG_USE_SINGLE
134 #if defined(__cris__)
135 #define MATCH_MACHINE(x) (x == EM_CRIS)
136 #define SHT_RELM SHT_RELA
137 #define Elf32_RelM Elf32_Rela
138 #define ELFCLASSM ELFCLASS32
141 #define R_CRIS_NONE 0
147 #if defined(__H8300H__) || defined(__H8300S__)
148 #define MATCH_MACHINE(x) (x == EM_H8_300)
149 #define SHT_RELM SHT_RELA
150 #define Elf32_RelM Elf32_Rela
151 #define ELFCLASSM ELFCLASS32
152 #define CONFIG_USE_SINGLE
153 #define SYMBOL_PREFIX "_"
156 /* PA-RISC / HP-PA */
157 #if defined(__hppa__)
158 #define MATCH_MACHINE(x) (x == EM_PARISC)
159 #define SHT_RELM SHT_RELA
160 #if defined(__LP64__)
161 #define Elf64_RelM Elf64_Rela
162 #define ELFCLASSM ELFCLASS64
164 #define Elf32_RelM Elf32_Rela
165 #define ELFCLASSM ELFCLASS32
170 #if defined(__i386__)
172 #define MATCH_MACHINE(x) (x == EM_386)
174 #define MATCH_MACHINE(x) (x == EM_386 || x == EM_486)
176 #define SHT_RELM SHT_REL
177 #define Elf32_RelM Elf32_Rel
178 #define ELFCLASSM ELFCLASS32
179 #define CONFIG_USE_GOT_ENTRIES
180 #define CONFIG_GOT_ENTRY_SIZE 4
181 #define CONFIG_USE_SINGLE
184 /* IA64, aka Itanium */
185 #if defined(__ia64__)
186 #define MATCH_MACHINE(x) (x == EM_IA_64)
187 #define SHT_RELM SHT_RELA
188 #define Elf64_RelM Elf64_Rela
189 #define ELFCLASSM ELFCLASS64
193 #if defined(__mc68000__)
194 #define MATCH_MACHINE(x) (x == EM_68K)
195 #define SHT_RELM SHT_RELA
196 #define Elf32_RelM Elf32_Rela
197 #define ELFCLASSM ELFCLASS32
198 #define CONFIG_USE_GOT_ENTRIES
199 #define CONFIG_GOT_ENTRY_SIZE 4
200 #define CONFIG_USE_SINGLE
204 #if defined(__mips__)
205 #define MATCH_MACHINE(x) (x == EM_MIPS || x == EM_MIPS_RS3_LE)
206 #define SHT_RELM SHT_REL
207 #define Elf32_RelM Elf32_Rel
208 #define ELFCLASSM ELFCLASS32
209 /* Account for ELF spec changes. */
210 #ifndef EM_MIPS_RS3_LE
211 #ifdef EM_MIPS_RS4_BE
212 #define EM_MIPS_RS3_LE EM_MIPS_RS4_BE
214 #define EM_MIPS_RS3_LE 10
216 #endif /* !EM_MIPS_RS3_LE */
217 #define ARCHDATAM "__dbe_table"
221 #if defined(__nios2__)
222 #define MATCH_MACHINE(x) (x == EM_ALTERA_NIOS2)
223 #define SHT_RELM SHT_RELA
224 #define Elf32_RelM Elf32_Rela
225 #define ELFCLASSM ELFCLASS32
229 #if defined(__powerpc64__)
230 #define MATCH_MACHINE(x) (x == EM_PPC64)
231 #define SHT_RELM SHT_RELA
232 #define Elf64_RelM Elf64_Rela
233 #define ELFCLASSM ELFCLASS64
234 #elif defined(__powerpc__)
235 #define MATCH_MACHINE(x) (x == EM_PPC)
236 #define SHT_RELM SHT_RELA
237 #define Elf32_RelM Elf32_Rela
238 #define ELFCLASSM ELFCLASS32
239 #define CONFIG_USE_PLT_ENTRIES
240 #define CONFIG_PLT_ENTRY_SIZE 16
241 #define CONFIG_USE_PLT_LIST
242 #define CONFIG_LIST_ARCHTYPE ElfW(Addr)
243 #define CONFIG_USE_LIST
244 #define ARCHDATAM "__ftr_fixup"
248 #if defined(__s390__)
249 #define MATCH_MACHINE(x) (x == EM_S390)
250 #define SHT_RELM SHT_RELA
251 #define Elf32_RelM Elf32_Rela
252 #define ELFCLASSM ELFCLASS32
253 #define CONFIG_USE_PLT_ENTRIES
254 #define CONFIG_PLT_ENTRY_SIZE 8
255 #define CONFIG_USE_GOT_ENTRIES
256 #define CONFIG_GOT_ENTRY_SIZE 8
257 #define CONFIG_USE_SINGLE
262 #define MATCH_MACHINE(x) (x == EM_SH)
263 #define SHT_RELM SHT_RELA
264 #define Elf32_RelM Elf32_Rela
265 #define ELFCLASSM ELFCLASS32
266 #define CONFIG_USE_GOT_ENTRIES
267 #define CONFIG_GOT_ENTRY_SIZE 4
268 #define CONFIG_USE_SINGLE
269 /* the SH changes have only been tested in =little endian= mode */
270 /* I'm not sure about big endian, so let's warn: */
271 #if defined(__sh__) && BB_BIG_ENDIAN
272 # error insmod.c may require changes for use on big endian SH
274 /* it may or may not work on the SH1/SH2... Error on those also */
275 #if ((!(defined(__SH3__) || defined(__SH4__) || defined(__SH5__)))) && (defined(__sh__))
276 #error insmod.c may require changes for SH1 or SH2 use
281 #if defined(__sparc__)
282 #define MATCH_MACHINE(x) (x == EM_SPARC)
283 #define SHT_RELM SHT_RELA
284 #define Elf32_RelM Elf32_Rela
285 #define ELFCLASSM ELFCLASS32
289 #if defined (__v850e__)
290 #define MATCH_MACHINE(x) ((x) == EM_V850 || (x) == EM_CYGNUS_V850)
291 #define SHT_RELM SHT_RELA
292 #define Elf32_RelM Elf32_Rela
293 #define ELFCLASSM ELFCLASS32
294 #define CONFIG_USE_PLT_ENTRIES
295 #define CONFIG_PLT_ENTRY_SIZE 8
296 #define CONFIG_USE_SINGLE
297 #ifndef EM_CYGNUS_V850 /* grumble */
298 #define EM_CYGNUS_V850 0x9080
300 #define SYMBOL_PREFIX "_"
304 #if defined(__x86_64__)
305 #define MATCH_MACHINE(x) (x == EM_X86_64)
306 #define SHT_RELM SHT_RELA
307 #define CONFIG_USE_GOT_ENTRIES
308 #define CONFIG_GOT_ENTRY_SIZE 8
309 #define CONFIG_USE_SINGLE
310 #define Elf64_RelM Elf64_Rela
311 #define ELFCLASSM ELFCLASS64
315 #error Sorry, but insmod.c does not yet support this architecture...
319 //----------------------------------------------------------------------------
320 //--------modutils module.h, lines 45-242
321 //----------------------------------------------------------------------------
323 /* Definitions for the Linux module syscall interface.
324 Copyright 1996, 1997 Linux International.
326 Contributed by Richard Henderson <rth@tamu.edu>
328 This file is part of the Linux modutils.
330 This program is free software; you can redistribute it and/or modify it
331 under the terms of the GNU General Public License as published by the
332 Free Software Foundation; either version 2 of the License, or (at your
333 option) any later version.
335 This program is distributed in the hope that it will be useful, but
336 WITHOUT ANY WARRANTY; without even the implied warranty of
337 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
338 General Public License for more details.
340 You should have received a copy of the GNU General Public License
341 along with this program; if not, write to the Free Software Foundation,
342 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
345 #ifndef MODUTILS_MODULE_H
346 /* Why? static const int MODUTILS_MODULE_H = 1;*/
348 #ident "$Id: insmod.c,v 1.126 2004/12/26 09:13:32 vapier Exp $"
350 /*======================================================================*/
351 /* For sizeof() which are related to the module platform and not to the
352 environment isnmod is running in, use sizeof_xx instead of sizeof(xx). */
354 #define tgt_sizeof_char sizeof(char)
355 #define tgt_sizeof_short sizeof(short)
356 #define tgt_sizeof_int sizeof(int)
357 #define tgt_sizeof_long sizeof(long)
358 #define tgt_sizeof_char_p sizeof(char *)
359 #define tgt_sizeof_void_p sizeof(void *)
360 #define tgt_long long
362 #if defined(__sparc__) && !defined(__sparc_v9__) && defined(ARCH_sparc64)
363 #undef tgt_sizeof_long
364 #undef tgt_sizeof_char_p
365 #undef tgt_sizeof_void_p
369 tgt_sizeof_char_p = 8,
370 tgt_sizeof_void_p = 8
372 #define tgt_long long long
375 /*======================================================================*/
376 /* The structures used in Linux 2.1. */
378 /* Note: new_module_symbol does not use tgt_long intentionally */
379 struct new_module_symbol
385 struct new_module_persist;
387 struct new_module_ref
389 unsigned tgt_long dep; /* kernel addresses */
390 unsigned tgt_long ref;
391 unsigned tgt_long next_ref;
396 unsigned tgt_long size_of_struct; /* == sizeof(module) */
397 unsigned tgt_long next;
398 unsigned tgt_long name;
399 unsigned tgt_long size;
402 unsigned tgt_long flags; /* AUTOCLEAN et al */
407 unsigned tgt_long syms;
408 unsigned tgt_long deps;
409 unsigned tgt_long refs;
410 unsigned tgt_long init;
411 unsigned tgt_long cleanup;
412 unsigned tgt_long ex_table_start;
413 unsigned tgt_long ex_table_end;
415 unsigned tgt_long gp;
417 /* Everything after here is extension. */
418 unsigned tgt_long persist_start;
419 unsigned tgt_long persist_end;
420 unsigned tgt_long can_unload;
421 unsigned tgt_long runsize;
422 const char *kallsyms_start; /* All symbols for kernel debugging */
423 const char *kallsyms_end;
424 const char *archdata_start; /* arch specific data for module */
425 const char *archdata_end;
426 const char *kernel_data; /* Reserved for kernel internal use */
430 #define ARCHDATA_SEC_NAME ARCHDATAM
432 #define ARCHDATA_SEC_NAME "__archdata"
434 #define KALLSYMS_SEC_NAME "__kallsyms"
437 struct new_module_info
445 /* Bits of module.flags. */
449 NEW_MOD_AUTOCLEAN = 4,
451 NEW_MOD_USED_ONCE = 16
454 int init_module(const char *name, const struct new_module *);
455 int query_module(const char *name, int which, void *buf,
456 size_t bufsize, size_t *ret);
458 /* Values for query_module's which. */
467 /*======================================================================*/
468 /* The system calls unchanged between 2.0 and 2.1. */
470 unsigned long create_module(const char *, size_t);
471 int delete_module(const char *);
474 #endif /* module.h */
476 //----------------------------------------------------------------------------
477 //--------end of modutils module.h
478 //----------------------------------------------------------------------------
482 //----------------------------------------------------------------------------
483 //--------modutils obj.h, lines 253-462
484 //----------------------------------------------------------------------------
486 /* Elf object file loading and relocation routines.
487 Copyright 1996, 1997 Linux International.
489 Contributed by Richard Henderson <rth@tamu.edu>
491 This file is part of the Linux modutils.
493 This program is free software; you can redistribute it and/or modify it
494 under the terms of the GNU General Public License as published by the
495 Free Software Foundation; either version 2 of the License, or (at your
496 option) any later version.
498 This program is distributed in the hope that it will be useful, but
499 WITHOUT ANY WARRANTY; without even the implied warranty of
500 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
501 General Public License for more details.
503 You should have received a copy of the GNU General Public License
504 along with this program; if not, write to the Free Software Foundation,
505 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
508 #ifndef MODUTILS_OBJ_H
509 /* Why? static const int MODUTILS_OBJ_H = 1; */
511 #ident "$Id: insmod.c,v 1.126 2004/12/26 09:13:32 vapier Exp $"
513 /* The relocatable object is manipulated using elfin types. */
520 # if ELFCLASSM == ELFCLASS32
521 # define ElfW(x) Elf32_ ## x
522 # define ELFW(x) ELF32_ ## x
524 # define ElfW(x) Elf64_ ## x
525 # define ELFW(x) ELF64_ ## x
529 /* For some reason this is missing from some ancient C libraries.... */
530 #ifndef ELF32_ST_INFO
531 # define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
534 #ifndef ELF64_ST_INFO
535 # define ELF64_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
538 #define ELF_ST_BIND(info) ELFW(ST_BIND)(info)
539 #define ELF_ST_TYPE(info) ELFW(ST_TYPE)(info)
540 #define ELF_ST_INFO(bind, type) ELFW(ST_INFO)(bind, type)
541 #define ELF_R_TYPE(val) ELFW(R_TYPE)(val)
542 #define ELF_R_SYM(val) ELFW(R_SYM)(val)
544 struct obj_string_patch;
545 struct obj_symbol_patch;
552 struct obj_section *load_next;
558 struct obj_symbol *next; /* hash table link */
562 int secidx; /* the defining section index/module */
564 int ksymidx; /* for export to the kernel symtab */
565 int referenced; /* actually used in the link */
568 /* Hardcode the hash table size. We shouldn't be needing so many
569 symbols that we begin to degrade performance, and we get a big win
570 by giving the compiler a constant divisor. */
572 #define HASH_BUCKETS 521
578 struct obj_section **sections;
579 struct obj_section *load_order;
580 struct obj_section **load_order_search_start;
581 struct obj_string_patch *string_patches;
582 struct obj_symbol_patch *symbol_patches;
583 int (*symbol_cmp)(const char *, const char *);
584 unsigned long (*symbol_hash)(const char *);
585 unsigned long local_symtab_size;
586 struct obj_symbol **local_symtab;
587 struct obj_symbol *symtab[HASH_BUCKETS];
598 struct obj_string_patch
600 struct obj_string_patch *next;
602 ElfW(Addr) reloc_offset;
603 ElfW(Addr) string_offset;
606 struct obj_symbol_patch
608 struct obj_symbol_patch *next;
610 ElfW(Addr) reloc_offset;
611 struct obj_symbol *sym;
615 /* Generic object manipulation routines. */
617 static unsigned long obj_elf_hash(const char *);
619 static unsigned long obj_elf_hash_n(const char *, unsigned long len);
621 static struct obj_symbol *obj_find_symbol (struct obj_file *f,
624 static ElfW(Addr) obj_symbol_final_value(struct obj_file *f,
625 struct obj_symbol *sym);
627 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
628 static void obj_set_symbol_compare(struct obj_file *f,
629 int (*cmp)(const char *, const char *),
630 unsigned long (*hash)(const char *));
633 static struct obj_section *obj_find_section (struct obj_file *f,
636 static void obj_insert_section_load_order (struct obj_file *f,
637 struct obj_section *sec);
639 static struct obj_section *obj_create_alloced_section (struct obj_file *f,
644 static struct obj_section *obj_create_alloced_section_first (struct obj_file *f,
649 static void *obj_extend_section (struct obj_section *sec, unsigned long more);
651 static int obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
654 static int obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
655 struct obj_symbol *sym);
657 static int obj_check_undefineds(struct obj_file *f);
659 static void obj_allocate_commons(struct obj_file *f);
661 static unsigned long obj_load_size (struct obj_file *f);
663 static int obj_relocate (struct obj_file *f, ElfW(Addr) base);
665 static struct obj_file *obj_load(FILE *f, int loadprogbits);
667 static int obj_create_image (struct obj_file *f, char *image);
669 /* Architecture specific manipulation routines. */
671 static struct obj_file *arch_new_file (void);
673 static struct obj_section *arch_new_section (void);
675 static struct obj_symbol *arch_new_symbol (void);
677 static enum obj_reloc arch_apply_relocation (struct obj_file *f,
678 struct obj_section *targsec,
679 struct obj_section *symsec,
680 struct obj_symbol *sym,
681 ElfW(RelM) *rel, ElfW(Addr) value);
683 static void arch_create_got (struct obj_file *f);
685 static int obj_gpl_license(struct obj_file *f, const char **license);
688 //----------------------------------------------------------------------------
689 //--------end of modutils obj.h
690 //----------------------------------------------------------------------------
693 /* SPFX is always a string, so it can be concatenated to string constants. */
695 #define SPFX SYMBOL_PREFIX
701 #define _PATH_MODULES "/lib/modules"
702 enum { STRVERSIONLEN = 32 };
704 /*======================================================================*/
706 static int flag_force_load = 0;
707 static int flag_autoclean = 0;
708 static int flag_verbose = 0;
709 static int flag_quiet = 0;
710 static int flag_export = 1;
713 /*======================================================================*/
715 #if defined(CONFIG_USE_LIST)
717 struct arch_list_entry
719 struct arch_list_entry *next;
720 CONFIG_LIST_ARCHTYPE addend;
727 #if defined(CONFIG_USE_SINGLE)
729 struct arch_single_entry
738 #if defined(__mips__)
741 struct mips_hi16 *next;
748 struct obj_file root;
749 #if defined(CONFIG_USE_PLT_ENTRIES)
750 struct obj_section *plt;
752 #if defined(CONFIG_USE_GOT_ENTRIES)
753 struct obj_section *got;
755 #if defined(__mips__)
756 struct mips_hi16 *mips_hi16_list;
761 struct obj_symbol root;
762 #if defined(CONFIG_USE_PLT_ENTRIES)
763 #if defined(CONFIG_USE_PLT_LIST)
764 struct arch_list_entry *pltent;
766 struct arch_single_entry pltent;
769 #if defined(CONFIG_USE_GOT_ENTRIES)
770 struct arch_single_entry gotent;
775 struct external_module {
780 struct new_module_symbol *syms;
783 static struct new_module_symbol *ksyms;
784 static size_t nksyms;
786 static struct external_module *ext_modules;
787 static int n_ext_modules;
788 static int n_ext_modules_used;
789 extern int delete_module(const char *);
791 static char *m_filename;
792 static char *m_fullName;
796 /*======================================================================*/
799 static int check_module_name_match(const char *filename, struct stat *statbuf,
802 char *fullname = (char *) userdata;
804 if (fullname[0] == '\0')
807 char *tmp, *tmp1 = bb_xstrdup(filename);
808 tmp = bb_get_last_path_component(tmp1);
809 if (strcmp(tmp, fullname) == 0) {
811 /* Stop searching if we find a match */
812 m_filename = bb_xstrdup(filename);
821 /*======================================================================*/
823 static struct obj_file *arch_new_file(void)
826 f = xmalloc(sizeof(*f));
828 memset(f, 0, sizeof(*f));
833 static struct obj_section *arch_new_section(void)
835 return xmalloc(sizeof(struct obj_section));
838 static struct obj_symbol *arch_new_symbol(void)
840 struct arch_symbol *sym;
841 sym = xmalloc(sizeof(*sym));
843 memset(sym, 0, sizeof(*sym));
848 static enum obj_reloc
849 arch_apply_relocation(struct obj_file *f,
850 struct obj_section *targsec,
851 struct obj_section *symsec,
852 struct obj_symbol *sym,
853 ElfW(RelM) *rel, ElfW(Addr) v)
855 struct arch_file *ifile = (struct arch_file *) f;
856 enum obj_reloc ret = obj_reloc_ok;
857 ElfW(Addr) *loc = (ElfW(Addr) *) (targsec->contents + rel->r_offset);
858 ElfW(Addr) dot = targsec->header.sh_addr + rel->r_offset;
859 #if defined(CONFIG_USE_GOT_ENTRIES) || defined(CONFIG_USE_PLT_ENTRIES)
860 struct arch_symbol *isym = (struct arch_symbol *) sym;
862 #if defined(__arm__) || defined(__i386__) || defined(__mc68000__) || defined(__sh__) || defined(__s390__)
863 #if defined(CONFIG_USE_GOT_ENTRIES)
864 ElfW(Addr) got = ifile->got ? ifile->got->header.sh_addr : 0;
867 #if defined(CONFIG_USE_PLT_ENTRIES)
868 ElfW(Addr) plt = ifile->plt ? ifile->plt->header.sh_addr : 0;
870 # if defined(CONFIG_USE_PLT_LIST)
871 struct arch_list_entry *pe;
873 struct arch_single_entry *pe;
877 switch (ELF_R_TYPE(rel->r_info)) {
892 /* relative reloc, always to _GLOBAL_OFFSET_TABLE_
893 * (which is .got) similar to branch,
894 * but is full 32 bits relative */
904 case R_ARM_GOTOFF: /* address relative to the got */
909 #elif defined(__cris__)
915 /* CRIS keeps the relocation value in the r_addend field and
916 * should not use whats in *loc at all
921 #elif defined(__H8300H__) || defined(__H8300S__)
924 loc = (ElfW(Addr) *)((ElfW(Addr))loc - 1);
925 *loc = (*loc & 0xff000000) | ((*loc & 0xffffff) + v);
936 if ((ElfW(Sword))v > 0x7fff ||
937 (ElfW(Sword))v < -(ElfW(Sword))0x8000)
938 ret = obj_reloc_overflow;
940 *(unsigned short *)loc = v;
944 if ((ElfW(Sword))v > 0x7f ||
945 (ElfW(Sword))v < -(ElfW(Sword))0x80)
946 ret = obj_reloc_overflow;
948 *(unsigned char *)loc = v;
951 #elif defined(__i386__)
987 #elif defined(__mc68000__)
998 ret = obj_reloc_overflow;
1005 ret = obj_reloc_overflow;
1012 if ((ElfW(Sword))v > 0x7f ||
1013 (ElfW(Sword))v < -(ElfW(Sword))0x80) {
1014 ret = obj_reloc_overflow;
1021 if ((ElfW(Sword))v > 0x7fff ||
1022 (ElfW(Sword))v < -(ElfW(Sword))0x8000) {
1023 ret = obj_reloc_overflow;
1029 *(int *)loc = v - dot;
1032 case R_68K_GLOB_DAT:
1033 case R_68K_JMP_SLOT:
1037 case R_68K_RELATIVE:
1038 *(int *)loc += f->baseaddr;
1044 # ifdef R_68K_GOTOFF
1051 #elif defined(__mips__)
1062 ret = obj_reloc_dangerous;
1063 if ((v & 0xf0000000) != ((dot + 4) & 0xf0000000))
1064 ret = obj_reloc_overflow;
1066 (*loc & ~0x03ffffff) | ((*loc + (v >> 2)) &
1072 struct mips_hi16 *n;
1074 /* We cannot relocate this one now because we don't know the value
1075 of the carry we need to add. Save the information, and let LO16
1076 do the actual relocation. */
1077 n = (struct mips_hi16 *) xmalloc(sizeof *n);
1080 n->next = ifile->mips_hi16_list;
1081 ifile->mips_hi16_list = n;
1087 unsigned long insnlo = *loc;
1088 ElfW(Addr) val, vallo;
1090 /* Sign extend the addend we extract from the lo insn. */
1091 vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
1093 if (ifile->mips_hi16_list != NULL) {
1094 struct mips_hi16 *l;
1096 l = ifile->mips_hi16_list;
1098 struct mips_hi16 *next;
1101 /* The value for the HI16 had best be the same. */
1102 assert(v == l->value);
1104 /* Do the HI16 relocation. Note that we actually don't
1105 need to know anything about the LO16 itself, except where
1106 to find the low 16 bits of the addend needed by the LO16. */
1109 ((insn & 0xffff) << 16) +
1113 /* Account for the sign extension that will happen in the
1120 insn = (insn & ~0xffff) | val;
1128 ifile->mips_hi16_list = NULL;
1131 /* Ok, we're done with the HI16 relocs. Now deal with the LO16. */
1133 insnlo = (insnlo & ~0xffff) | (val & 0xffff);
1138 #elif defined(__nios2__)
1143 case R_NIOS2_BFD_RELOC_32:
1147 case R_NIOS2_BFD_RELOC_16:
1149 ret = obj_reloc_overflow;
1154 case R_NIOS2_BFD_RELOC_8:
1156 ret = obj_reloc_overflow;
1165 if ((Elf32_Sword)v > 0x7fff ||
1166 (Elf32_Sword)v < -(Elf32_Sword)0x8000) {
1167 ret = obj_reloc_overflow;
1171 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1181 ret = obj_reloc_overflow;
1185 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1190 case R_NIOS2_PCREL16:
1195 if ((Elf32_Sword)v > 0x7fff ||
1196 (Elf32_Sword)v < -(Elf32_Sword)0x8000) {
1197 ret = obj_reloc_overflow;
1201 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) | (word & 0x3f);
1207 Elf32_Addr word, gp;
1209 gp = obj_symbol_final_value(f, obj_find_symbol(f, SPFX "_gp"));
1211 if ((Elf32_Sword)v > 0x7fff ||
1212 (Elf32_Sword)v < -(Elf32_Sword)0x8000) {
1213 ret = obj_reloc_overflow;
1217 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) | (word & 0x3f);
1221 case R_NIOS2_CALL26:
1223 ret = obj_reloc_dangerous;
1224 if ((v >> 28) != (dot >> 28))
1225 ret = obj_reloc_overflow;
1226 *loc = (*loc & 0x3f) | ((v >> 2) << 6);
1234 ret = obj_reloc_overflow;
1237 word = *loc & ~0x7c0;
1238 *loc = word | ((v & 0x1f) << 6);
1247 ret = obj_reloc_overflow;
1250 word = *loc & ~0xfc0;
1251 *loc = word | ((v & 0x3f) << 6);
1260 ret = obj_reloc_overflow;
1263 word = *loc & ~0x3fc0;
1264 *loc = word | ((v & 0xff) << 6);
1273 *loc = ((((word >> 22) << 16) | ((v >>16) & 0xffff)) << 6) |
1283 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1288 case R_NIOS2_HIADJ16:
1290 Elf32_Addr word1, word2;
1293 word2 = ((v >> 16) + ((v >> 15) & 1)) & 0xffff;
1294 *loc = ((((word1 >> 22) << 16) | word2) << 6) |
1299 #elif defined(__powerpc64__)
1300 /* PPC64 needs a 2.6 kernel, 2.4 module relocation irrelevant */
1302 #elif defined(__powerpc__)
1304 case R_PPC_ADDR16_HA:
1305 *(unsigned short *)loc = (v + 0x8000) >> 16;
1308 case R_PPC_ADDR16_HI:
1309 *(unsigned short *)loc = v >> 16;
1312 case R_PPC_ADDR16_LO:
1313 *(unsigned short *)loc = v;
1327 #elif defined(__s390__)
1330 *(unsigned int *) loc += v;
1333 *(unsigned short *) loc += v;
1336 *(unsigned char *) loc += v;
1340 *(unsigned int *) loc += v - dot;
1343 *(unsigned short *) loc += (v - dot) >> 1;
1346 *(unsigned short *) loc += v - dot;
1350 case R_390_PLT16DBL:
1351 /* find the plt entry and initialize it. */
1352 assert(isym != NULL);
1353 pe = (struct arch_single_entry *) &isym->pltent;
1354 assert(pe->allocated);
1355 if (pe->inited == 0) {
1356 ip = (unsigned long *)(ifile->plt->contents + pe->offset);
1357 ip[0] = 0x0d105810; /* basr 1,0; lg 1,10(1); br 1 */
1359 if (ELF_R_TYPE(rel->r_info) == R_390_PLT16DBL)
1366 /* Insert relative distance to target. */
1367 v = plt + pe->offset - dot;
1368 if (ELF_R_TYPE(rel->r_info) == R_390_PLT32)
1369 *(unsigned int *) loc = (unsigned int) v;
1370 else if (ELF_R_TYPE(rel->r_info) == R_390_PLT16DBL)
1371 *(unsigned short *) loc = (unsigned short) ((v + 2) >> 1);
1374 case R_390_GLOB_DAT:
1375 case R_390_JMP_SLOT:
1379 case R_390_RELATIVE:
1380 *loc += f->baseaddr;
1385 *(unsigned long *) loc += got - dot;
1391 assert(isym != NULL);
1393 if (!isym->gotent.inited)
1395 isym->gotent.inited = 1;
1396 *(ElfW(Addr) *)(ifile->got->contents + isym->gotent.offset) = v;
1398 if (ELF_R_TYPE(rel->r_info) == R_390_GOT12)
1399 *(unsigned short *) loc |= (*(unsigned short *) loc + isym->gotent.offset) & 0xfff;
1400 else if (ELF_R_TYPE(rel->r_info) == R_390_GOT16)
1401 *(unsigned short *) loc += isym->gotent.offset;
1402 else if (ELF_R_TYPE(rel->r_info) == R_390_GOT32)
1403 *(unsigned int *) loc += isym->gotent.offset;
1406 # ifndef R_390_GOTOFF32
1407 # define R_390_GOTOFF32 R_390_GOTOFF
1409 case R_390_GOTOFF32:
1414 #elif defined(__sh__)
1437 *loc = f->baseaddr + rel->r_addend;
1442 *loc = got - dot + rel->r_addend;
1453 # if defined(__SH5__)
1454 case R_SH_IMM_MEDLOW16:
1455 case R_SH_IMM_LOW16:
1459 if (ELF_R_TYPE(rel->r_info) == R_SH_IMM_MEDLOW16)
1463 * movi and shori have the format:
1465 * | op | imm | reg | reserved |
1466 * 31..26 25..10 9.. 4 3 .. 0
1468 * so we simply mask and or in imm.
1470 word = *loc & ~0x3fffc00;
1471 word |= (v & 0xffff) << 10;
1478 case R_SH_IMM_MEDLOW16_PCREL:
1479 case R_SH_IMM_LOW16_PCREL:
1483 word = *loc & ~0x3fffc00;
1487 if (ELF_R_TYPE(rel->r_info) == R_SH_IMM_MEDLOW16_PCREL)
1490 word |= (v & 0xffff) << 10;
1496 # endif /* __SH5__ */
1498 #elif defined (__v850e__)
1504 /* We write two shorts instead of a long because even
1505 32-bit insns only need half-word alignment, but
1506 32-bit data needs to be long-word aligned. */
1507 v += ((unsigned short *)loc)[0];
1508 v += ((unsigned short *)loc)[1] << 16;
1509 ((unsigned short *)loc)[0] = v & 0xffff;
1510 ((unsigned short *)loc)[1] = (v >> 16) & 0xffff;
1513 case R_V850_22_PCREL:
1516 #elif defined(__x86_64__)
1526 *(unsigned int *) loc += v;
1529 ret = obj_reloc_overflow; /* Kernel module compiled without -mcmodel=kernel. */
1530 /* error("Possibly is module compiled without -mcmodel=kernel!"); */
1535 *(signed int *) loc += v;
1539 *(unsigned short *) loc += v;
1543 *(unsigned char *) loc += v;
1547 *(unsigned int *) loc += v - dot;
1551 *(unsigned short *) loc += v - dot;
1555 *(unsigned char *) loc += v - dot;
1558 case R_X86_64_GLOB_DAT:
1559 case R_X86_64_JUMP_SLOT:
1563 case R_X86_64_RELATIVE:
1564 *loc += f->baseaddr;
1567 case R_X86_64_GOT32:
1568 case R_X86_64_GOTPCREL:
1571 assert(isym != NULL);
1572 if (!isym->gotent.reloc_done)
1574 isym->gotent.reloc_done = 1;
1575 *(Elf64_Addr *)(ifile->got->contents + isym->gotent.offset) = v;
1577 /* XXX are these really correct? */
1578 if (ELF64_R_TYPE(rel->r_info) == R_X86_64_GOTPCREL)
1579 *(unsigned int *) loc += v + isym->gotent.offset;
1581 *loc += isym->gotent.offset;
1586 # warning "no idea how to handle relocations on your arch"
1590 printf("Warning: unhandled reloc %d\n",(int)ELF_R_TYPE(rel->r_info));
1591 ret = obj_reloc_unhandled;
1594 #if defined(CONFIG_USE_PLT_ENTRIES)
1598 /* find the plt entry and initialize it if necessary */
1599 assert(isym != NULL);
1601 #if defined(CONFIG_USE_PLT_LIST)
1602 for (pe = isym->pltent; pe != NULL && pe->addend != rel->r_addend;)
1610 ip = (unsigned long *) (ifile->plt->contents + pe->offset);
1612 /* generate some machine code */
1614 #if defined(__arm__)
1615 ip[0] = 0xe51ff004; /* ldr pc,[pc,#-4] */
1616 ip[1] = v; /* sym@ */
1618 #if defined(__powerpc__)
1619 ip[0] = 0x3d600000 + ((v + 0x8000) >> 16); /* lis r11,sym@ha */
1620 ip[1] = 0x396b0000 + (v & 0xffff); /* addi r11,r11,sym@l */
1621 ip[2] = 0x7d6903a6; /* mtctr r11 */
1622 ip[3] = 0x4e800420; /* bctr */
1624 #if defined (__v850e__)
1625 /* We have to trash a register, so we assume that any control
1626 transfer more than 21-bits away must be a function call
1627 (so we can use a call-clobbered register). */
1628 ip[0] = 0x0621 + ((v & 0xffff) << 16); /* mov sym, r1 ... */
1629 ip[1] = ((v >> 16) & 0xffff) + 0x610000; /* ...; jmp r1 */
1634 /* relative distance to target */
1636 /* if the target is too far away.... */
1637 #if defined (__arm__) || defined (__powerpc__)
1638 if ((int)v < -0x02000000 || (int)v >= 0x02000000)
1639 #elif defined (__v850e__)
1640 if ((ElfW(Sword))v > 0x1fffff || (ElfW(Sword))v < (ElfW(Sword))-0x200000)
1642 /* go via the plt */
1643 v = plt + pe->offset - dot;
1645 #if defined (__v850e__)
1650 ret = obj_reloc_dangerous;
1652 /* merge the offset into the instruction. */
1653 #if defined(__arm__)
1654 /* Convert to words. */
1657 *loc = (*loc & ~0x00ffffff) | ((v + *loc) & 0x00ffffff);
1659 #if defined(__powerpc__)
1660 *loc = (*loc & ~0x03fffffc) | (v & 0x03fffffc);
1662 #if defined (__v850e__)
1663 /* We write two shorts instead of a long because even 32-bit insns
1664 only need half-word alignment, but the 32-bit data write needs
1665 to be long-word aligned. */
1666 ((unsigned short *)loc)[0] =
1667 (*(unsigned short *)loc & 0xffc0) /* opcode + reg */
1668 | ((v >> 16) & 0x3f); /* offs high part */
1669 ((unsigned short *)loc)[1] =
1670 (v & 0xffff); /* offs low part */
1673 #endif /* CONFIG_USE_PLT_ENTRIES */
1675 #if defined(CONFIG_USE_GOT_ENTRIES)
1678 assert(isym != NULL);
1679 /* needs an entry in the .got: set it, once */
1680 if (!isym->gotent.inited) {
1681 isym->gotent.inited = 1;
1682 *(ElfW(Addr) *) (ifile->got->contents + isym->gotent.offset) = v;
1684 /* make the reloc with_respect_to_.got */
1686 *loc += isym->gotent.offset + rel->r_addend;
1687 #elif defined(__i386__) || defined(__arm__) || defined(__mc68000__)
1688 *loc += isym->gotent.offset;
1692 #endif /* CONFIG_USE_GOT_ENTRIES */
1699 #if defined(CONFIG_USE_LIST)
1701 static int arch_list_add(ElfW(RelM) *rel, struct arch_list_entry **list,
1702 int offset, int size)
1704 struct arch_list_entry *pe;
1706 for (pe = *list; pe != NULL; pe = pe->next) {
1707 if (pe->addend == rel->r_addend) {
1713 pe = xmalloc(sizeof(struct arch_list_entry));
1715 pe->addend = rel->r_addend;
1716 pe->offset = offset;
1726 #if defined(CONFIG_USE_SINGLE)
1728 static int arch_single_init(ElfW(RelM) *rel, struct arch_single_entry *single,
1729 int offset, int size)
1731 if (single->allocated == 0) {
1732 single->allocated = 1;
1733 single->offset = offset;
1742 #if defined(CONFIG_USE_GOT_ENTRIES) || defined(CONFIG_USE_PLT_ENTRIES)
1744 static struct obj_section *arch_xsect_init(struct obj_file *f, char *name,
1745 int offset, int size)
1747 struct obj_section *myrelsec = obj_find_section(f, name);
1754 obj_extend_section(myrelsec, offset);
1756 myrelsec = obj_create_alloced_section(f, name,
1766 static void arch_create_got(struct obj_file *f)
1768 #if defined(CONFIG_USE_GOT_ENTRIES) || defined(CONFIG_USE_PLT_ENTRIES)
1769 struct arch_file *ifile = (struct arch_file *) f;
1771 #if defined(CONFIG_USE_GOT_ENTRIES)
1772 int got_offset = 0, got_needed = 0, got_allocate;
1774 #if defined(CONFIG_USE_PLT_ENTRIES)
1775 int plt_offset = 0, plt_needed = 0, plt_allocate;
1777 struct obj_section *relsec, *symsec, *strsec;
1778 ElfW(RelM) *rel, *relend;
1779 ElfW(Sym) *symtab, *extsym;
1780 const char *strtab, *name;
1781 struct arch_symbol *intsym;
1783 for (i = 0; i < f->header.e_shnum; ++i) {
1784 relsec = f->sections[i];
1785 if (relsec->header.sh_type != SHT_RELM)
1788 symsec = f->sections[relsec->header.sh_link];
1789 strsec = f->sections[symsec->header.sh_link];
1791 rel = (ElfW(RelM) *) relsec->contents;
1792 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
1793 symtab = (ElfW(Sym) *) symsec->contents;
1794 strtab = (const char *) strsec->contents;
1796 for (; rel < relend; ++rel) {
1797 extsym = &symtab[ELF_R_SYM(rel->r_info)];
1799 #if defined(CONFIG_USE_GOT_ENTRIES)
1802 #if defined(CONFIG_USE_PLT_ENTRIES)
1806 switch (ELF_R_TYPE(rel->r_info)) {
1807 #if defined(__arm__)
1822 #elif defined(__i386__)
1832 #elif defined(__powerpc__)
1837 #elif defined(__mc68000__)
1848 #elif defined(__sh__)
1858 #elif defined (__v850e__)
1859 case R_V850_22_PCREL:
1868 if (extsym->st_name != 0) {
1869 name = strtab + extsym->st_name;
1871 name = f->sections[extsym->st_shndx]->name;
1873 intsym = (struct arch_symbol *) obj_find_symbol(f, name);
1874 #if defined(CONFIG_USE_GOT_ENTRIES)
1876 got_offset += arch_single_init(
1877 rel, &intsym->gotent,
1878 got_offset, CONFIG_GOT_ENTRY_SIZE);
1883 #if defined(CONFIG_USE_PLT_ENTRIES)
1885 #if defined(CONFIG_USE_PLT_LIST)
1886 plt_offset += arch_list_add(
1887 rel, &intsym->pltent,
1888 plt_offset, CONFIG_PLT_ENTRY_SIZE);
1890 plt_offset += arch_single_init(
1891 rel, &intsym->pltent,
1892 plt_offset, CONFIG_PLT_ENTRY_SIZE);
1900 #if defined(CONFIG_USE_GOT_ENTRIES)
1902 ifile->got = arch_xsect_init(f, ".got", got_offset,
1903 CONFIG_GOT_ENTRY_SIZE);
1907 #if defined(CONFIG_USE_PLT_ENTRIES)
1909 ifile->plt = arch_xsect_init(f, ".plt", plt_offset,
1910 CONFIG_PLT_ENTRY_SIZE);
1914 #endif /* defined(CONFIG_USE_GOT_ENTRIES) || defined(CONFIG_USE_PLT_ENTRIES) */
1917 /*======================================================================*/
1919 /* Standard ELF hash function. */
1920 static inline unsigned long obj_elf_hash_n(const char *name, unsigned long n)
1922 unsigned long h = 0;
1929 if ((g = (h & 0xf0000000)) != 0) {
1938 static unsigned long obj_elf_hash(const char *name)
1940 return obj_elf_hash_n(name, strlen(name));
1943 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
1944 /* String comparison for non-co-versioned kernel and module. */
1946 static int ncv_strcmp(const char *a, const char *b)
1948 size_t alen = strlen(a), blen = strlen(b);
1950 if (blen == alen + 10 && b[alen] == '_' && b[alen + 1] == 'R')
1951 return strncmp(a, b, alen);
1952 else if (alen == blen + 10 && a[blen] == '_' && a[blen + 1] == 'R')
1953 return strncmp(a, b, blen);
1955 return strcmp(a, b);
1958 /* String hashing for non-co-versioned kernel and module. Here
1959 we are simply forced to drop the crc from the hash. */
1961 static unsigned long ncv_symbol_hash(const char *str)
1963 size_t len = strlen(str);
1964 if (len > 10 && str[len - 10] == '_' && str[len - 9] == 'R')
1966 return obj_elf_hash_n(str, len);
1970 obj_set_symbol_compare(struct obj_file *f,
1971 int (*cmp) (const char *, const char *),
1972 unsigned long (*hash) (const char *))
1975 f->symbol_cmp = cmp;
1977 struct obj_symbol *tmptab[HASH_BUCKETS], *sym, *next;
1980 f->symbol_hash = hash;
1982 memcpy(tmptab, f->symtab, sizeof(tmptab));
1983 memset(f->symtab, 0, sizeof(f->symtab));
1985 for (i = 0; i < HASH_BUCKETS; ++i)
1986 for (sym = tmptab[i]; sym; sym = next) {
1987 unsigned long h = hash(sym->name) % HASH_BUCKETS;
1989 sym->next = f->symtab[h];
1995 #endif /* CONFIG_FEATURE_INSMOD_VERSION_CHECKING */
1997 static struct obj_symbol *
1998 obj_add_symbol(struct obj_file *f, const char *name,
1999 unsigned long symidx, int info,
2000 int secidx, ElfW(Addr) value,
2003 struct obj_symbol *sym;
2004 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
2005 int n_type = ELF_ST_TYPE(info);
2006 int n_binding = ELF_ST_BIND(info);
2008 for (sym = f->symtab[hash]; sym; sym = sym->next)
2009 if (f->symbol_cmp(sym->name, name) == 0) {
2010 int o_secidx = sym->secidx;
2011 int o_info = sym->info;
2012 int o_type = ELF_ST_TYPE(o_info);
2013 int o_binding = ELF_ST_BIND(o_info);
2015 /* A redefinition! Is it legal? */
2017 if (secidx == SHN_UNDEF)
2019 else if (o_secidx == SHN_UNDEF)
2021 else if (n_binding == STB_GLOBAL && o_binding == STB_LOCAL) {
2022 /* Cope with local and global symbols of the same name
2023 in the same object file, as might have been created
2024 by ld -r. The only reason locals are now seen at this
2025 level at all is so that we can do semi-sensible things
2028 struct obj_symbol *nsym, **p;
2030 nsym = arch_new_symbol();
2031 nsym->next = sym->next;
2034 /* Excise the old (local) symbol from the hash chain. */
2035 for (p = &f->symtab[hash]; *p != sym; p = &(*p)->next)
2039 } else if (n_binding == STB_LOCAL) {
2040 /* Another symbol of the same name has already been defined.
2041 Just add this to the local table. */
2042 sym = arch_new_symbol();
2045 f->local_symtab[symidx] = sym;
2047 } else if (n_binding == STB_WEAK)
2049 else if (o_binding == STB_WEAK)
2051 /* Don't unify COMMON symbols with object types the programmer
2053 else if (secidx == SHN_COMMON
2054 && (o_type == STT_NOTYPE || o_type == STT_OBJECT))
2056 else if (o_secidx == SHN_COMMON
2057 && (n_type == STT_NOTYPE || n_type == STT_OBJECT))
2060 /* Don't report an error if the symbol is coming from
2061 the kernel or some external module. */
2062 if (secidx <= SHN_HIRESERVE)
2063 bb_error_msg("%s multiply defined", name);
2068 /* Completely new symbol. */
2069 sym = arch_new_symbol();
2070 sym->next = f->symtab[hash];
2071 f->symtab[hash] = sym;
2074 if (ELF_ST_BIND(info) == STB_LOCAL && symidx != -1) {
2075 if (symidx >= f->local_symtab_size)
2076 bb_error_msg("local symbol %s with index %ld exceeds local_symtab_size %ld",
2077 name, (long) symidx, (long) f->local_symtab_size);
2079 f->local_symtab[symidx] = sym;
2086 sym->secidx = secidx;
2092 static struct obj_symbol *
2093 obj_find_symbol(struct obj_file *f, const char *name)
2095 struct obj_symbol *sym;
2096 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
2098 for (sym = f->symtab[hash]; sym; sym = sym->next)
2099 if (f->symbol_cmp(sym->name, name) == 0)
2106 obj_symbol_final_value(struct obj_file * f, struct obj_symbol * sym)
2109 if (sym->secidx >= SHN_LORESERVE)
2112 return sym->value + f->sections[sym->secidx]->header.sh_addr;
2114 /* As a special case, a NULL sym has value zero. */
2119 static struct obj_section *obj_find_section(struct obj_file *f, const char *name)
2121 int i, n = f->header.e_shnum;
2123 for (i = 0; i < n; ++i)
2124 if (strcmp(f->sections[i]->name, name) == 0)
2125 return f->sections[i];
2130 static int obj_load_order_prio(struct obj_section *a)
2132 unsigned long af, ac;
2134 af = a->header.sh_flags;
2137 if (a->name[0] != '.' || strlen(a->name) != 10 ||
2138 strcmp(a->name + 5, ".init"))
2142 if (!(af & SHF_WRITE))
2144 if (af & SHF_EXECINSTR)
2146 if (a->header.sh_type != SHT_NOBITS)
2153 obj_insert_section_load_order(struct obj_file *f, struct obj_section *sec)
2155 struct obj_section **p;
2156 int prio = obj_load_order_prio(sec);
2157 for (p = f->load_order_search_start; *p; p = &(*p)->load_next)
2158 if (obj_load_order_prio(*p) < prio)
2160 sec->load_next = *p;
2164 static struct obj_section *obj_create_alloced_section(struct obj_file *f,
2166 unsigned long align,
2169 int newidx = f->header.e_shnum++;
2170 struct obj_section *sec;
2172 f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
2173 f->sections[newidx] = sec = arch_new_section();
2175 memset(sec, 0, sizeof(*sec));
2176 sec->header.sh_type = SHT_PROGBITS;
2177 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2178 sec->header.sh_size = size;
2179 sec->header.sh_addralign = align;
2183 sec->contents = xmalloc(size);
2185 obj_insert_section_load_order(f, sec);
2190 static struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
2192 unsigned long align,
2195 int newidx = f->header.e_shnum++;
2196 struct obj_section *sec;
2198 f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
2199 f->sections[newidx] = sec = arch_new_section();
2201 memset(sec, 0, sizeof(*sec));
2202 sec->header.sh_type = SHT_PROGBITS;
2203 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2204 sec->header.sh_size = size;
2205 sec->header.sh_addralign = align;
2209 sec->contents = xmalloc(size);
2211 sec->load_next = f->load_order;
2212 f->load_order = sec;
2213 if (f->load_order_search_start == &f->load_order)
2214 f->load_order_search_start = &sec->load_next;
2219 static void *obj_extend_section(struct obj_section *sec, unsigned long more)
2221 unsigned long oldsize = sec->header.sh_size;
2223 sec->contents = xrealloc(sec->contents, sec->header.sh_size += more);
2225 return sec->contents + oldsize;
2229 /* Conditionally add the symbols from the given symbol set to the
2233 add_symbols_from( struct obj_file *f,
2234 int idx, struct new_module_symbol *syms, size_t nsyms)
2236 struct new_module_symbol *s;
2239 #ifdef SYMBOL_PREFIX
2241 size_t name_alloced_size = 0;
2243 #ifdef CONFIG_FEATURE_CHECK_TAINTED_MODULE
2246 gpl = obj_gpl_license(f, NULL) == 0;
2248 for (i = 0, s = syms; i < nsyms; ++i, ++s) {
2249 /* Only add symbols that are already marked external.
2250 If we override locals we may cause problems for
2251 argument initialization. We will also create a false
2252 dependency on the module. */
2253 struct obj_symbol *sym;
2256 /* GPL licensed modules can use symbols exported with
2257 * EXPORT_SYMBOL_GPL, so ignore any GPLONLY_ prefix on the
2258 * exported names. Non-GPL modules never see any GPLONLY_
2259 * symbols so they cannot fudge it by adding the prefix on
2262 if (strncmp((char *)s->name, "GPLONLY_", 8) == 0) {
2263 #ifdef CONFIG_FEATURE_CHECK_TAINTED_MODULE
2270 name = (char *)s->name;
2272 #ifdef SYMBOL_PREFIX
2273 /* Prepend SYMBOL_PREFIX to the symbol's name (the
2274 kernel exports `C names', but module object files
2275 reference `linker names'). */
2276 size_t extra = sizeof SYMBOL_PREFIX;
2277 size_t name_size = strlen (name) + extra;
2278 if (name_size > name_alloced_size) {
2279 name_alloced_size = name_size * 2;
2280 name_buf = alloca (name_alloced_size);
2282 strcpy (name_buf, SYMBOL_PREFIX);
2283 strcpy (name_buf + extra - 1, name);
2285 #endif /* SYMBOL_PREFIX */
2287 sym = obj_find_symbol(f, name);
2288 if (sym && !(ELF_ST_BIND(sym->info) == STB_LOCAL)) {
2289 #ifdef SYMBOL_PREFIX
2290 /* Put NAME_BUF into more permanent storage. */
2291 name = xmalloc (name_size);
2292 strcpy (name, name_buf);
2294 sym = obj_add_symbol(f, name, -1,
2295 ELF_ST_INFO(STB_GLOBAL,
2298 /* Did our symbol just get installed? If so, mark the
2299 module as "used". */
2300 if (sym->secidx == idx)
2308 static void add_kernel_symbols(struct obj_file *f)
2310 struct external_module *m;
2313 /* Add module symbols first. */
2315 for (i = 0, m = ext_modules; i < n_ext_modules; ++i, ++m)
2317 && add_symbols_from(f, SHN_HIRESERVE + 2 + i, m->syms,
2318 m->nsyms)) m->used = 1, ++nused;
2320 n_ext_modules_used = nused;
2322 /* And finally the symbols from the kernel proper. */
2325 add_symbols_from(f, SHN_HIRESERVE + 1, ksyms, nksyms);
2328 static char *get_modinfo_value(struct obj_file *f, const char *key)
2330 struct obj_section *sec;
2331 char *p, *v, *n, *ep;
2332 size_t klen = strlen(key);
2334 sec = obj_find_section(f, ".modinfo");
2338 ep = p + sec->header.sh_size;
2341 n = strchr(p, '\0');
2343 if (p + klen == v && strncmp(p, key, klen) == 0)
2346 if (p + klen == n && strcmp(p, key) == 0)
2356 /*======================================================================*/
2357 /* Functions relating to module loading after 2.1.18. */
2360 new_process_module_arguments(struct obj_file *f, int argc, char **argv)
2363 char *p, *q, *key, *sym_name;
2364 struct obj_symbol *sym;
2365 char *contents, *loc;
2369 if ((q = strchr(p, '=')) == NULL) {
2374 key = alloca(q - p + 6);
2375 memcpy(key, "parm_", 5);
2376 memcpy(key + 5, p, q - p);
2379 p = get_modinfo_value(f, key);
2382 bb_error_msg("invalid parameter %s", key);
2386 #ifdef SYMBOL_PREFIX
2387 sym_name = alloca (strlen (key) + sizeof SYMBOL_PREFIX);
2388 strcpy (sym_name, SYMBOL_PREFIX);
2389 strcat (sym_name, key);
2393 sym = obj_find_symbol(f, sym_name);
2395 /* Also check that the parameter was not resolved from the kernel. */
2396 if (sym == NULL || sym->secidx > SHN_HIRESERVE) {
2397 bb_error_msg("symbol for parameter %s not found", key);
2402 min = strtoul(p, &p, 10);
2404 max = strtoul(p + 1, &p, 10);
2410 contents = f->sections[sym->secidx]->contents;
2411 loc = contents + sym->value;
2415 if ((*p == 's') || (*p == 'c')) {
2418 /* Do C quoting if we begin with a ", else slurp the lot. */
2422 str = alloca(strlen(q));
2423 for (r = str, q++; *q != '"'; ++q, ++r) {
2425 bb_error_msg("improperly terminated string argument for %s",
2428 } else if (*q == '\\')
2462 if (q[1] >= '0' && q[1] <= '7') {
2463 c = (c * 8) + *++q - '0';
2464 if (q[1] >= '0' && q[1] <= '7')
2465 c = (c * 8) + *++q - '0';
2482 /* In this case, the string is not quoted. We will break
2483 it using the coma (like for ints). If the user wants to
2484 include comas in a string, he just has to quote it */
2486 /* Search the next coma */
2490 if (r != (char *) NULL) {
2491 /* Recopy the current field */
2492 str = alloca(r - q + 1);
2493 memcpy(str, q, r - q);
2495 /* I don't know if it is useful, as the previous case
2496 doesn't nul terminate the string ??? */
2499 /* Keep next fields */
2510 obj_string_patch(f, sym->secidx, loc - contents, str);
2511 loc += tgt_sizeof_char_p;
2513 /* Array of chars (in fact, matrix !) */
2514 unsigned long charssize; /* size of each member */
2516 /* Get the size of each member */
2517 /* Probably we should do that outside the loop ? */
2518 if (!isdigit(*(p + 1))) {
2519 bb_error_msg("parameter type 'c' for %s must be followed by"
2520 " the maximum size", key);
2523 charssize = strtoul(p + 1, (char **) NULL, 10);
2526 if (strlen(str) >= charssize) {
2527 bb_error_msg("string too long for %s (max %ld)", key,
2532 /* Copy to location */
2533 strcpy((char *) loc, str);
2537 long v = strtoul(q, &q, 0);
2544 loc += tgt_sizeof_short;
2548 loc += tgt_sizeof_int;
2552 loc += tgt_sizeof_long;
2556 bb_error_msg("unknown parameter type '%c' for %s", *p, key);
2571 goto retry_end_of_value;
2575 bb_error_msg("too many values for %s (max %d)", key, max);
2582 bb_error_msg("invalid argument syntax for %s", key);
2589 bb_error_msg("too few values for %s (min %d)", key, min);
2599 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
2600 static int new_is_module_checksummed(struct obj_file *f)
2602 const char *p = get_modinfo_value(f, "using_checksums");
2609 /* Get the module's kernel version in the canonical integer form. */
2612 new_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
2617 p = get_modinfo_value(f, "kernel_version");
2620 safe_strncpy(str, p, STRVERSIONLEN);
2622 a = strtoul(p, &p, 10);
2625 b = strtoul(p + 1, &p, 10);
2628 c = strtoul(p + 1, &q, 10);
2632 return a << 16 | b << 8 | c;
2635 #endif /* CONFIG_FEATURE_INSMOD_VERSION_CHECKING */
2638 /* Fetch the loaded modules, and all currently exported symbols. */
2640 static int new_get_kernel_symbols(void)
2642 char *module_names, *mn;
2643 struct external_module *modules, *m;
2644 struct new_module_symbol *syms, *s;
2645 size_t ret, bufsize, nmod, nsyms, i, j;
2647 /* Collect the loaded modules. */
2649 module_names = xmalloc(bufsize = 256);
2651 if (query_module(NULL, QM_MODULES, module_names, bufsize, &ret)) {
2652 if (errno == ENOSPC && bufsize < ret) {
2653 module_names = xrealloc(module_names, bufsize = ret);
2654 goto retry_modules_load;
2656 bb_perror_msg("QM_MODULES");
2660 n_ext_modules = nmod = ret;
2662 /* Collect the modules' symbols. */
2665 ext_modules = modules = xmalloc(nmod * sizeof(*modules));
2666 memset(modules, 0, nmod * sizeof(*modules));
2667 for (i = 0, mn = module_names, m = modules;
2668 i < nmod; ++i, ++m, mn += strlen(mn) + 1) {
2669 struct new_module_info info;
2671 if (query_module(mn, QM_INFO, &info, sizeof(info), &ret)) {
2672 if (errno == ENOENT) {
2673 /* The module was removed out from underneath us. */
2676 bb_perror_msg("query_module: QM_INFO: %s", mn);
2680 syms = xmalloc(bufsize = 1024);
2682 if (query_module(mn, QM_SYMBOLS, syms, bufsize, &ret)) {
2685 syms = xrealloc(syms, bufsize = ret);
2686 goto retry_mod_sym_load;
2688 /* The module was removed out from underneath us. */
2691 bb_perror_msg("query_module: QM_SYMBOLS: %s", mn);
2698 m->addr = info.addr;
2702 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2703 s->name += (unsigned long) syms;
2708 /* Collect the kernel's symbols. */
2710 syms = xmalloc(bufsize = 16 * 1024);
2711 retry_kern_sym_load:
2712 if (query_module(NULL, QM_SYMBOLS, syms, bufsize, &ret)) {
2713 if (errno == ENOSPC && bufsize < ret) {
2714 syms = xrealloc(syms, bufsize = ret);
2715 goto retry_kern_sym_load;
2717 bb_perror_msg("kernel: QM_SYMBOLS");
2720 nksyms = nsyms = ret;
2723 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2724 s->name += (unsigned long) syms;
2730 /* Return the kernel symbol checksum version, or zero if not used. */
2732 static int new_is_kernel_checksummed(void)
2734 struct new_module_symbol *s;
2737 /* Using_Versions is not the first symbol, but it should be in there. */
2739 for (i = 0, s = ksyms; i < nksyms; ++i, ++s)
2740 if (strcmp((char *) s->name, "Using_Versions") == 0)
2747 static int new_create_this_module(struct obj_file *f, const char *m_name)
2749 struct obj_section *sec;
2751 sec = obj_create_alloced_section_first(f, ".this", tgt_sizeof_long,
2752 sizeof(struct new_module));
2753 memset(sec->contents, 0, sizeof(struct new_module));
2755 obj_add_symbol(f, SPFX "__this_module", -1,
2756 ELF_ST_INFO(STB_LOCAL, STT_OBJECT), sec->idx, 0,
2757 sizeof(struct new_module));
2759 obj_string_patch(f, sec->idx, offsetof(struct new_module, name),
2765 #ifdef CONFIG_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
2766 /* add an entry to the __ksymtab section, creating it if necessary */
2767 static void new_add_ksymtab(struct obj_file *f, struct obj_symbol *sym)
2769 struct obj_section *sec;
2772 /* ensure __ksymtab is allocated, EXPORT_NOSYMBOLS creates a non-alloc section.
2773 * If __ksymtab is defined but not marked alloc, x out the first character
2774 * (no obj_delete routine) and create a new __ksymtab with the correct
2777 sec = obj_find_section(f, "__ksymtab");
2778 if (sec && !(sec->header.sh_flags & SHF_ALLOC)) {
2779 *((char *)(sec->name)) = 'x'; /* override const */
2783 sec = obj_create_alloced_section(f, "__ksymtab",
2784 tgt_sizeof_void_p, 0);
2787 sec->header.sh_flags |= SHF_ALLOC;
2788 sec->header.sh_addralign = tgt_sizeof_void_p; /* Empty section might
2790 ofs = sec->header.sh_size;
2791 obj_symbol_patch(f, sec->idx, ofs, sym);
2792 obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p, sym->name);
2793 obj_extend_section(sec, 2 * tgt_sizeof_char_p);
2795 #endif /* CONFIG_FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
2797 static int new_create_module_ksymtab(struct obj_file *f)
2799 struct obj_section *sec;
2802 /* We must always add the module references. */
2804 if (n_ext_modules_used) {
2805 struct new_module_ref *dep;
2806 struct obj_symbol *tm;
2808 sec = obj_create_alloced_section(f, ".kmodtab", tgt_sizeof_void_p,
2809 (sizeof(struct new_module_ref)
2810 * n_ext_modules_used));
2814 tm = obj_find_symbol(f, SPFX "__this_module");
2815 dep = (struct new_module_ref *) sec->contents;
2816 for (i = 0; i < n_ext_modules; ++i)
2817 if (ext_modules[i].used) {
2818 dep->dep = ext_modules[i].addr;
2819 obj_symbol_patch(f, sec->idx,
2820 (char *) &dep->ref - sec->contents, tm);
2826 if (flag_export && !obj_find_section(f, "__ksymtab")) {
2831 obj_create_alloced_section(f, "__ksymtab", tgt_sizeof_void_p,
2834 /* We don't want to export symbols residing in sections that
2835 aren't loaded. There are a number of these created so that
2836 we make sure certain module options don't appear twice. */
2838 loaded = alloca(sizeof(int) * (i = f->header.e_shnum));
2840 loaded[i] = (f->sections[i]->header.sh_flags & SHF_ALLOC) != 0;
2842 for (nsyms = i = 0; i < HASH_BUCKETS; ++i) {
2843 struct obj_symbol *sym;
2844 for (sym = f->symtab[i]; sym; sym = sym->next)
2845 if (ELF_ST_BIND(sym->info) != STB_LOCAL
2846 && sym->secidx <= SHN_HIRESERVE
2847 && (sym->secidx >= SHN_LORESERVE
2848 || loaded[sym->secidx])) {
2849 ElfW(Addr) ofs = nsyms * 2 * tgt_sizeof_void_p;
2851 obj_symbol_patch(f, sec->idx, ofs, sym);
2852 obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p,
2859 obj_extend_section(sec, nsyms * 2 * tgt_sizeof_char_p);
2867 new_init_module(const char *m_name, struct obj_file *f, unsigned long m_size)
2869 struct new_module *module;
2870 struct obj_section *sec;
2875 sec = obj_find_section(f, ".this");
2876 if (!sec || !sec->contents) {
2877 bb_perror_msg_and_die("corrupt module %s?",m_name);
2879 module = (struct new_module *) sec->contents;
2880 m_addr = sec->header.sh_addr;
2882 module->size_of_struct = sizeof(*module);
2883 module->size = m_size;
2884 module->flags = flag_autoclean ? NEW_MOD_AUTOCLEAN : 0;
2886 sec = obj_find_section(f, "__ksymtab");
2887 if (sec && sec->header.sh_size) {
2888 module->syms = sec->header.sh_addr;
2889 module->nsyms = sec->header.sh_size / (2 * tgt_sizeof_char_p);
2892 if (n_ext_modules_used) {
2893 sec = obj_find_section(f, ".kmodtab");
2894 module->deps = sec->header.sh_addr;
2895 module->ndeps = n_ext_modules_used;
2899 obj_symbol_final_value(f, obj_find_symbol(f, SPFX "init_module"));
2901 obj_symbol_final_value(f, obj_find_symbol(f, SPFX "cleanup_module"));
2903 sec = obj_find_section(f, "__ex_table");
2905 module->ex_table_start = sec->header.sh_addr;
2906 module->ex_table_end = sec->header.sh_addr + sec->header.sh_size;
2909 sec = obj_find_section(f, ".text.init");
2911 module->runsize = sec->header.sh_addr - m_addr;
2913 sec = obj_find_section(f, ".data.init");
2915 if (!module->runsize ||
2916 module->runsize > sec->header.sh_addr - m_addr)
2917 module->runsize = sec->header.sh_addr - m_addr;
2919 sec = obj_find_section(f, ARCHDATA_SEC_NAME);
2920 if (sec && sec->header.sh_size) {
2921 module->archdata_start = (void*)sec->header.sh_addr;
2922 module->archdata_end = module->archdata_start + sec->header.sh_size;
2924 sec = obj_find_section(f, KALLSYMS_SEC_NAME);
2925 if (sec && sec->header.sh_size) {
2926 module->kallsyms_start = (void*)sec->header.sh_addr;
2927 module->kallsyms_end = module->kallsyms_start + sec->header.sh_size;
2930 /* Whew! All of the initialization is complete. Collect the final
2931 module image and give it to the kernel. */
2933 image = xmalloc(m_size);
2934 obj_create_image(f, image);
2936 ret = init_module(m_name, (struct new_module *) image);
2938 bb_perror_msg("init_module: %s", m_name);
2946 /*======================================================================*/
2949 obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2952 struct obj_string_patch *p;
2953 struct obj_section *strsec;
2954 size_t len = strlen(string) + 1;
2957 p = xmalloc(sizeof(*p));
2958 p->next = f->string_patches;
2959 p->reloc_secidx = secidx;
2960 p->reloc_offset = offset;
2961 f->string_patches = p;
2963 strsec = obj_find_section(f, ".kstrtab");
2964 if (strsec == NULL) {
2965 strsec = obj_create_alloced_section(f, ".kstrtab", 1, len);
2966 p->string_offset = 0;
2967 loc = strsec->contents;
2969 p->string_offset = strsec->header.sh_size;
2970 loc = obj_extend_section(strsec, len);
2972 memcpy(loc, string, len);
2978 obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2979 struct obj_symbol *sym)
2981 struct obj_symbol_patch *p;
2983 p = xmalloc(sizeof(*p));
2984 p->next = f->symbol_patches;
2985 p->reloc_secidx = secidx;
2986 p->reloc_offset = offset;
2988 f->symbol_patches = p;
2993 static int obj_check_undefineds(struct obj_file *f)
2998 for (i = 0; i < HASH_BUCKETS; ++i) {
2999 struct obj_symbol *sym;
3000 for (sym = f->symtab[i]; sym; sym = sym->next)
3001 if (sym->secidx == SHN_UNDEF) {
3002 if (ELF_ST_BIND(sym->info) == STB_WEAK) {
3003 sym->secidx = SHN_ABS;
3007 bb_error_msg("unresolved symbol %s", sym->name);
3017 static void obj_allocate_commons(struct obj_file *f)
3019 struct common_entry {
3020 struct common_entry *next;
3021 struct obj_symbol *sym;
3022 } *common_head = NULL;
3026 for (i = 0; i < HASH_BUCKETS; ++i) {
3027 struct obj_symbol *sym;
3028 for (sym = f->symtab[i]; sym; sym = sym->next)
3029 if (sym->secidx == SHN_COMMON) {
3030 /* Collect all COMMON symbols and sort them by size so as to
3031 minimize space wasted by alignment requirements. */
3033 struct common_entry **p, *n;
3034 for (p = &common_head; *p; p = &(*p)->next)
3035 if (sym->size <= (*p)->sym->size)
3038 n = alloca(sizeof(*n));
3046 for (i = 1; i < f->local_symtab_size; ++i) {
3047 struct obj_symbol *sym = f->local_symtab[i];
3048 if (sym && sym->secidx == SHN_COMMON) {
3049 struct common_entry **p, *n;
3050 for (p = &common_head; *p; p = &(*p)->next)
3051 if (sym == (*p)->sym)
3053 else if (sym->size < (*p)->sym->size) {
3054 n = alloca(sizeof(*n));
3064 /* Find the bss section. */
3065 for (i = 0; i < f->header.e_shnum; ++i)
3066 if (f->sections[i]->header.sh_type == SHT_NOBITS)
3069 /* If for some reason there hadn't been one, create one. */
3070 if (i == f->header.e_shnum) {
3071 struct obj_section *sec;
3073 f->sections = xrealloc(f->sections, (i + 1) * sizeof(sec));
3074 f->sections[i] = sec = arch_new_section();
3075 f->header.e_shnum = i + 1;
3077 memset(sec, 0, sizeof(*sec));
3078 sec->header.sh_type = SHT_PROGBITS;
3079 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
3084 /* Allocate the COMMONS. */
3086 ElfW(Addr) bss_size = f->sections[i]->header.sh_size;
3087 ElfW(Addr) max_align = f->sections[i]->header.sh_addralign;
3088 struct common_entry *c;
3090 for (c = common_head; c; c = c->next) {
3091 ElfW(Addr) align = c->sym->value;
3093 if (align > max_align)
3095 if (bss_size & (align - 1))
3096 bss_size = (bss_size | (align - 1)) + 1;
3099 c->sym->value = bss_size;
3101 bss_size += c->sym->size;
3104 f->sections[i]->header.sh_size = bss_size;
3105 f->sections[i]->header.sh_addralign = max_align;
3109 /* For the sake of patch relocation and parameter initialization,
3110 allocate zeroed data for NOBITS sections now. Note that after
3111 this we cannot assume NOBITS are really empty. */
3112 for (i = 0; i < f->header.e_shnum; ++i) {
3113 struct obj_section *s = f->sections[i];
3114 if (s->header.sh_type == SHT_NOBITS) {
3115 if (s->header.sh_size != 0)
3116 s->contents = memset(xmalloc(s->header.sh_size),
3117 0, s->header.sh_size);
3121 s->header.sh_type = SHT_PROGBITS;
3126 static unsigned long obj_load_size(struct obj_file *f)
3128 unsigned long dot = 0;
3129 struct obj_section *sec;
3131 /* Finalize the positions of the sections relative to one another. */
3133 for (sec = f->load_order; sec; sec = sec->load_next) {
3136 align = sec->header.sh_addralign;
3137 if (align && (dot & (align - 1)))
3138 dot = (dot | (align - 1)) + 1;
3140 sec->header.sh_addr = dot;
3141 dot += sec->header.sh_size;
3147 static int obj_relocate(struct obj_file *f, ElfW(Addr) base)
3149 int i, n = f->header.e_shnum;
3152 /* Finalize the addresses of the sections. */
3155 for (i = 0; i < n; ++i)
3156 f->sections[i]->header.sh_addr += base;
3158 /* And iterate over all of the relocations. */
3160 for (i = 0; i < n; ++i) {
3161 struct obj_section *relsec, *symsec, *targsec, *strsec;
3162 ElfW(RelM) * rel, *relend;
3166 relsec = f->sections[i];
3167 if (relsec->header.sh_type != SHT_RELM)
3170 symsec = f->sections[relsec->header.sh_link];
3171 targsec = f->sections[relsec->header.sh_info];
3172 strsec = f->sections[symsec->header.sh_link];
3174 rel = (ElfW(RelM) *) relsec->contents;
3175 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
3176 symtab = (ElfW(Sym) *) symsec->contents;
3177 strtab = (const char *) strsec->contents;
3179 for (; rel < relend; ++rel) {
3180 ElfW(Addr) value = 0;
3181 struct obj_symbol *intsym = NULL;
3182 unsigned long symndx;
3183 ElfW(Sym) * extsym = 0;
3186 /* Attempt to find a value to use for this relocation. */
3188 symndx = ELF_R_SYM(rel->r_info);
3190 /* Note we've already checked for undefined symbols. */
3192 extsym = &symtab[symndx];
3193 if (ELF_ST_BIND(extsym->st_info) == STB_LOCAL) {
3194 /* Local symbols we look up in the local table to be sure
3195 we get the one that is really intended. */
3196 intsym = f->local_symtab[symndx];
3198 /* Others we look up in the hash table. */
3200 if (extsym->st_name)
3201 name = strtab + extsym->st_name;
3203 name = f->sections[extsym->st_shndx]->name;
3204 intsym = obj_find_symbol(f, name);
3207 value = obj_symbol_final_value(f, intsym);
3208 intsym->referenced = 1;
3210 #if SHT_RELM == SHT_RELA
3211 #if defined(__alpha__) && defined(AXP_BROKEN_GAS)
3212 /* Work around a nasty GAS bug, that is fixed as of 2.7.0.9. */
3213 if (!extsym || !extsym->st_name ||
3214 ELF_ST_BIND(extsym->st_info) != STB_LOCAL)
3216 value += rel->r_addend;
3220 switch (arch_apply_relocation
3221 (f, targsec, symsec, intsym, rel, value)) {
3225 case obj_reloc_overflow:
3226 errmsg = "Relocation overflow";
3228 case obj_reloc_dangerous:
3229 errmsg = "Dangerous relocation";
3231 case obj_reloc_unhandled:
3232 errmsg = "Unhandled relocation";
3235 bb_error_msg("%s of type %ld for %s", errmsg,
3236 (long) ELF_R_TYPE(rel->r_info),
3237 strtab + extsym->st_name);
3239 bb_error_msg("%s of type %ld", errmsg,
3240 (long) ELF_R_TYPE(rel->r_info));
3248 /* Finally, take care of the patches. */
3250 if (f->string_patches) {
3251 struct obj_string_patch *p;
3252 struct obj_section *strsec;
3253 ElfW(Addr) strsec_base;
3254 strsec = obj_find_section(f, ".kstrtab");
3255 strsec_base = strsec->header.sh_addr;
3257 for (p = f->string_patches; p; p = p->next) {
3258 struct obj_section *targsec = f->sections[p->reloc_secidx];
3259 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
3260 = strsec_base + p->string_offset;
3264 if (f->symbol_patches) {
3265 struct obj_symbol_patch *p;
3267 for (p = f->symbol_patches; p; p = p->next) {
3268 struct obj_section *targsec = f->sections[p->reloc_secidx];
3269 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
3270 = obj_symbol_final_value(f, p->sym);
3277 static int obj_create_image(struct obj_file *f, char *image)
3279 struct obj_section *sec;
3280 ElfW(Addr) base = f->baseaddr;
3282 for (sec = f->load_order; sec; sec = sec->load_next) {
3285 if (sec->contents == 0 || sec->header.sh_size == 0)
3288 secimg = image + (sec->header.sh_addr - base);
3290 /* Note that we allocated data for NOBITS sections earlier. */
3291 memcpy(secimg, sec->contents, sec->header.sh_size);
3297 /*======================================================================*/
3299 static struct obj_file *obj_load(FILE * fp, int loadprogbits)
3302 ElfW(Shdr) * section_headers;
3306 /* Read the file header. */
3308 f = arch_new_file();
3309 memset(f, 0, sizeof(*f));
3310 f->symbol_cmp = strcmp;
3311 f->symbol_hash = obj_elf_hash;
3312 f->load_order_search_start = &f->load_order;
3314 fseek(fp, 0, SEEK_SET);
3315 if (fread(&f->header, sizeof(f->header), 1, fp) != 1) {
3316 bb_perror_msg("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("not an ELF file");
3327 if (f->header.e_ident[EI_CLASS] != ELFCLASSM
3328 || f->header.e_ident[EI_DATA] != (BB_BIG_ENDIAN
3329 ? ELFDATA2MSB : ELFDATA2LSB)
3330 || f->header.e_ident[EI_VERSION] != EV_CURRENT
3331 || !MATCH_MACHINE(f->header.e_machine)) {
3332 bb_error_msg("ELF file not for this architecture");
3335 if (f->header.e_type != ET_REL) {
3336 bb_error_msg("ELF file not a relocatable object");
3340 /* Read the section headers. */
3342 if (f->header.e_shentsize != sizeof(ElfW(Shdr))) {
3343 bb_error_msg("section header size mismatch: %lu != %lu",
3344 (unsigned long) f->header.e_shentsize,
3345 (unsigned long) sizeof(ElfW(Shdr)));
3349 shnum = f->header.e_shnum;
3350 f->sections = xmalloc(sizeof(struct obj_section *) * shnum);
3351 memset(f->sections, 0, sizeof(struct obj_section *) * shnum);
3353 section_headers = alloca(sizeof(ElfW(Shdr)) * shnum);
3354 fseek(fp, f->header.e_shoff, SEEK_SET);
3355 if (fread(section_headers, sizeof(ElfW(Shdr)), shnum, fp) != shnum) {
3356 bb_perror_msg("error reading ELF section headers");
3360 /* Read the section data. */
3362 for (i = 0; i < shnum; ++i) {
3363 struct obj_section *sec;
3365 f->sections[i] = sec = arch_new_section();
3366 memset(sec, 0, sizeof(*sec));
3368 sec->header = section_headers[i];
3371 if(sec->header.sh_size) switch (sec->header.sh_type) {
3380 if (!loadprogbits) {
3381 sec->contents = NULL;
3388 if (sec->header.sh_size > 0) {
3389 sec->contents = xmalloc(sec->header.sh_size);
3390 fseek(fp, sec->header.sh_offset, SEEK_SET);
3391 if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
3392 bb_perror_msg("error reading ELF section data");
3396 sec->contents = NULL;
3400 #if SHT_RELM == SHT_REL
3402 bb_error_msg("RELA relocations not supported on this architecture");
3406 bb_error_msg("REL relocations not supported on this architecture");
3411 if (sec->header.sh_type >= SHT_LOPROC) {
3412 /* Assume processor specific section types are debug
3413 info and can safely be ignored. If this is ever not
3414 the case (Hello MIPS?), don't put ifdefs here but
3415 create an arch_load_proc_section(). */
3419 bb_error_msg("can't handle sections of type %ld",
3420 (long) sec->header.sh_type);
3425 /* Do what sort of interpretation as needed by each section. */
3427 shstrtab = f->sections[f->header.e_shstrndx]->contents;
3429 for (i = 0; i < shnum; ++i) {
3430 struct obj_section *sec = f->sections[i];
3431 sec->name = shstrtab + sec->header.sh_name;
3434 for (i = 0; i < shnum; ++i) {
3435 struct obj_section *sec = f->sections[i];
3437 /* .modinfo should be contents only but gcc has no attribute for that.
3438 * The kernel may have marked .modinfo as ALLOC, ignore this bit.
3440 if (strcmp(sec->name, ".modinfo") == 0)
3441 sec->header.sh_flags &= ~SHF_ALLOC;
3443 if (sec->header.sh_flags & SHF_ALLOC)
3444 obj_insert_section_load_order(f, sec);
3446 switch (sec->header.sh_type) {
3449 unsigned long nsym, j;
3453 if (sec->header.sh_entsize != sizeof(ElfW(Sym))) {
3454 bb_error_msg("symbol size mismatch: %lu != %lu",
3455 (unsigned long) sec->header.sh_entsize,
3456 (unsigned long) sizeof(ElfW(Sym)));
3460 nsym = sec->header.sh_size / sizeof(ElfW(Sym));
3461 strtab = f->sections[sec->header.sh_link]->contents;
3462 sym = (ElfW(Sym) *) sec->contents;
3464 /* Allocate space for a table of local symbols. */
3465 j = f->local_symtab_size = sec->header.sh_info;
3466 f->local_symtab = xcalloc(j, sizeof(struct obj_symbol *));
3468 /* Insert all symbols into the hash table. */
3469 for (j = 1, ++sym; j < nsym; ++j, ++sym) {
3470 ElfW(Addr) val = sym->st_value;
3473 name = strtab + sym->st_name;
3474 else if (sym->st_shndx < shnum)
3475 name = f->sections[sym->st_shndx]->name;
3479 #if defined(__SH5__)
3481 * For sh64 it is possible that the target of a branch
3482 * requires a mode switch (32 to 16 and back again).
3484 * This is implied by the lsb being set in the target
3485 * address for SHmedia mode and clear for SHcompact.
3487 val |= sym->st_other & 4;
3490 obj_add_symbol(f, name, j, sym->st_info, sym->st_shndx,
3497 if (sec->header.sh_entsize != sizeof(ElfW(RelM))) {
3498 bb_error_msg("relocation entry size mismatch: %lu != %lu",
3499 (unsigned long) sec->header.sh_entsize,
3500 (unsigned long) sizeof(ElfW(RelM)));
3504 /* XXX Relocation code from modutils-2.3.19 is not here.
3505 * Why? That's about 20 lines of code from obj/obj_load.c,
3506 * which gets done in a second pass through the sections.
3507 * This BusyBox insmod does similar work in obj_relocate(). */
3514 #ifdef CONFIG_FEATURE_INSMOD_LOADINKMEM
3516 * load the unloaded sections directly into the memory allocated by
3517 * kernel for the module
3520 static int obj_load_progbits(FILE * fp, struct obj_file* f, char* imagebase)
3522 ElfW(Addr) base = f->baseaddr;
3523 struct obj_section* sec;
3525 for (sec = f->load_order; sec; sec = sec->load_next) {
3527 /* section already loaded? */
3528 if (sec->contents != NULL)
3531 if (sec->header.sh_size == 0)
3534 sec->contents = imagebase + (sec->header.sh_addr - base);
3535 fseek(fp, sec->header.sh_offset, SEEK_SET);
3536 if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
3537 bb_error_msg("error reading ELF section data: %s\n", strerror(errno));
3546 static void hide_special_symbols(struct obj_file *f)
3548 static const char *const specials[] = {
3549 SPFX "cleanup_module",
3551 SPFX "kernel_version",
3555 struct obj_symbol *sym;
3556 const char *const *p;
3558 for (p = specials; *p; ++p)
3559 if ((sym = obj_find_symbol(f, *p)) != NULL)
3561 ELF_ST_INFO(STB_LOCAL, ELF_ST_TYPE(sym->info));
3565 #ifdef CONFIG_FEATURE_CHECK_TAINTED_MODULE
3566 static int obj_gpl_license(struct obj_file *f, const char **license)
3568 struct obj_section *sec;
3569 /* This list must match *exactly* the list of allowable licenses in
3570 * linux/include/linux/module.h. Checking for leading "GPL" will not
3571 * work, somebody will use "GPL sucks, this is proprietary".
3573 static const char * const gpl_licenses[] = {
3576 "GPL and additional rights",
3581 if ((sec = obj_find_section(f, ".modinfo"))) {
3582 const char *value, *ptr, *endptr;
3583 ptr = sec->contents;
3584 endptr = ptr + sec->header.sh_size;
3585 while (ptr < endptr) {
3586 if ((value = strchr(ptr, '=')) && strncmp(ptr, "license", value-ptr) == 0) {
3590 for (i = 0; i < sizeof(gpl_licenses)/sizeof(gpl_licenses[0]); ++i) {
3591 if (strcmp(value+1, gpl_licenses[i]) == 0)
3596 if (strchr(ptr, '\0'))
3597 ptr = strchr(ptr, '\0') + 1;
3605 #define TAINT_FILENAME "/proc/sys/kernel/tainted"
3606 #define TAINT_PROPRIETORY_MODULE (1<<0)
3607 #define TAINT_FORCED_MODULE (1<<1)
3608 #define TAINT_UNSAFE_SMP (1<<2)
3609 #define TAINT_URL "http://www.tux.org/lkml/#export-tainted"
3611 static void set_tainted(struct obj_file *f, int fd, char *m_name,
3612 int kernel_has_tainted, int taint, const char *text1, const char *text2)
3616 static int first = 1;
3617 if (fd < 0 && !kernel_has_tainted)
3618 return; /* New modutils on old kernel */
3619 printf("Warning: loading %s will taint the kernel: %s%s\n",
3620 m_name, text1, text2);
3622 printf(" See %s for information about tainted modules\n", TAINT_URL);
3626 read(fd, buf, sizeof(buf)-1);
3627 buf[sizeof(buf)-1] = '\0';
3628 oldval = strtoul(buf, NULL, 10);
3629 sprintf(buf, "%d\n", oldval | taint);
3630 write(fd, buf, strlen(buf));
3634 /* Check if loading this module will taint the kernel. */
3635 static void check_tainted_module(struct obj_file *f, char *m_name)
3637 static const char tainted_file[] = TAINT_FILENAME;
3638 int fd, kernel_has_tainted;
3641 kernel_has_tainted = 1;
3642 if ((fd = open(tainted_file, O_RDWR)) < 0) {
3643 if (errno == ENOENT)
3644 kernel_has_tainted = 0;
3645 else if (errno == EACCES)
3646 kernel_has_tainted = 1;
3648 perror(tainted_file);
3649 kernel_has_tainted = 0;
3653 switch (obj_gpl_license(f, &ptr)) {
3657 set_tainted(f, fd, m_name, kernel_has_tainted, TAINT_PROPRIETORY_MODULE, "no license", "");
3660 /* The module has a non-GPL license so we pretend that the
3661 * kernel always has a taint flag to get a warning even on
3662 * kernels without the proc flag.
3664 set_tainted(f, fd, m_name, 1, TAINT_PROPRIETORY_MODULE, "non-GPL license - ", ptr);
3667 set_tainted(f, fd, m_name, 1, TAINT_PROPRIETORY_MODULE, "Unexpected return from obj_gpl_license", "");
3671 if (flag_force_load)
3672 set_tainted(f, fd, m_name, 1, TAINT_FORCED_MODULE, "forced load", "");
3677 #else /* CONFIG_FEATURE_CHECK_TAINTED_MODULE */
3678 #define check_tainted_module(x, y) do { } while(0);
3679 #endif /* CONFIG_FEATURE_CHECK_TAINTED_MODULE */
3681 #ifdef CONFIG_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
3682 /* add module source, timestamp, kernel version and a symbol for the
3683 * start of some sections. this info is used by ksymoops to do better
3687 get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
3689 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
3690 return new_get_module_version(f, str);
3691 #else /* CONFIG_FEATURE_INSMOD_VERSION_CHECKING */
3692 strncpy(str, "???", sizeof(str));
3694 #endif /* CONFIG_FEATURE_INSMOD_VERSION_CHECKING */
3697 /* add module source, timestamp, kernel version and a symbol for the
3698 * start of some sections. this info is used by ksymoops to do better
3702 add_ksymoops_symbols(struct obj_file *f, const char *filename,
3705 static const char symprefix[] = "__insmod_";
3706 struct obj_section *sec;
3707 struct obj_symbol *sym;
3708 char *name, *absolute_filename;
3709 char str[STRVERSIONLEN], real[PATH_MAX];
3710 int i, l, lm_name, lfilename, use_ksymtab, version;
3711 struct stat statbuf;
3713 static const char *section_names[] = {
3721 if (realpath(filename, real)) {
3722 absolute_filename = bb_xstrdup(real);
3725 int save_errno = errno;
3726 bb_error_msg("cannot get realpath for %s", filename);
3729 absolute_filename = bb_xstrdup(filename);
3732 lm_name = strlen(m_name);
3733 lfilename = strlen(absolute_filename);
3735 /* add to ksymtab if it already exists or there is no ksymtab and other symbols
3736 * are not to be exported. otherwise leave ksymtab alone for now, the
3737 * "export all symbols" compatibility code will export these symbols later.
3739 use_ksymtab = obj_find_section(f, "__ksymtab") || !flag_export;
3741 if ((sec = obj_find_section(f, ".this"))) {
3742 /* tag the module header with the object name, last modified
3743 * timestamp and module version. worst case for module version
3744 * is 0xffffff, decimal 16777215. putting all three fields in
3745 * one symbol is less readable but saves kernel space.
3747 l = sizeof(symprefix)+ /* "__insmod_" */
3748 lm_name+ /* module name */
3750 lfilename+ /* object filename */
3752 2*sizeof(statbuf.st_mtime)+ /* mtime in hex */
3754 8+ /* version in dec */
3757 if (stat(absolute_filename, &statbuf) != 0)
3758 statbuf.st_mtime = 0;
3759 version = get_module_version(f, str); /* -1 if not found */
3760 snprintf(name, l, "%s%s_O%s_M%0*lX_V%d",
3761 symprefix, m_name, absolute_filename,
3762 (int)(2*sizeof(statbuf.st_mtime)), statbuf.st_mtime,
3764 sym = obj_add_symbol(f, name, -1,
3765 ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3766 sec->idx, sec->header.sh_addr, 0);
3768 new_add_ksymtab(f, sym);
3770 free(absolute_filename);
3771 #ifdef _NOT_SUPPORTED_
3772 /* record where the persistent data is going, same address as previous symbol */
3775 l = sizeof(symprefix)+ /* "__insmod_" */
3776 lm_name+ /* module name */
3778 strlen(f->persist)+ /* data store */
3781 snprintf(name, l, "%s%s_P%s",
3782 symprefix, m_name, f->persist);
3783 sym = obj_add_symbol(f, name, -1, ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3784 sec->idx, sec->header.sh_addr, 0);
3786 new_add_ksymtab(f, sym);
3788 #endif /* _NOT_SUPPORTED_ */
3789 /* tag the desired sections if size is non-zero */
3791 for (i = 0; i < sizeof(section_names)/sizeof(section_names[0]); ++i) {
3792 if ((sec = obj_find_section(f, section_names[i])) &&
3793 sec->header.sh_size) {
3794 l = sizeof(symprefix)+ /* "__insmod_" */
3795 lm_name+ /* module name */
3797 strlen(sec->name)+ /* section name */
3799 8+ /* length in dec */
3802 snprintf(name, l, "%s%s_S%s_L%ld",
3803 symprefix, m_name, sec->name,
3804 (long)sec->header.sh_size);
3805 sym = obj_add_symbol(f, name, -1, ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3806 sec->idx, sec->header.sh_addr, 0);
3808 new_add_ksymtab(f, sym);
3812 #endif /* CONFIG_FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
3814 #ifdef CONFIG_FEATURE_INSMOD_LOAD_MAP
3815 static void print_load_map(struct obj_file *f)
3817 struct obj_symbol *sym;
3818 struct obj_symbol **all, **p;
3819 struct obj_section *sec;
3820 int i, nsyms, *loaded;
3822 /* Report on the section layout. */
3824 printf("Sections: Size %-*s Align\n",
3825 (int) (2 * sizeof(void *)), "Address");
3827 for (sec = f->load_order; sec; sec = sec->load_next) {
3831 for (a = -1, tmp = sec->header.sh_addralign; tmp; ++a)
3836 printf("%-15s %08lx %0*lx 2**%d\n",
3838 (long)sec->header.sh_size,
3839 (int) (2 * sizeof(void *)),
3840 (long)sec->header.sh_addr,
3843 #ifdef CONFIG_FEATURE_INSMOD_LOAD_MAP_FULL
3844 /* Quick reference which section indicies are loaded. */
3846 loaded = alloca(sizeof(int) * (i = f->header.e_shnum));
3848 loaded[i] = (f->sections[i]->header.sh_flags & SHF_ALLOC) != 0;
3850 /* Collect the symbols we'll be listing. */
3852 for (nsyms = i = 0; i < HASH_BUCKETS; ++i)
3853 for (sym = f->symtab[i]; sym; sym = sym->next)
3854 if (sym->secidx <= SHN_HIRESERVE
3855 && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx]))
3858 all = alloca(nsyms * sizeof(struct obj_symbol *));
3860 for (i = 0, p = all; i < HASH_BUCKETS; ++i)
3861 for (sym = f->symtab[i]; sym; sym = sym->next)
3862 if (sym->secidx <= SHN_HIRESERVE
3863 && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx]))
3866 /* And list them. */
3867 printf("\nSymbols:\n");
3868 for (p = all; p < all + nsyms; ++p) {
3870 unsigned long value;
3873 if (sym->secidx == SHN_ABS) {
3876 } else if (sym->secidx == SHN_UNDEF) {
3880 sec = f->sections[sym->secidx];
3882 if (sec->header.sh_type == SHT_NOBITS)
3884 else if (sec->header.sh_flags & SHF_ALLOC) {
3885 if (sec->header.sh_flags & SHF_EXECINSTR)
3887 else if (sec->header.sh_flags & SHF_WRITE)
3892 value = sym->value + sec->header.sh_addr;
3895 if (ELF_ST_BIND(sym->info) == STB_LOCAL)
3896 type = tolower(type);
3898 printf("%0*lx %c %s\n", (int) (2 * sizeof(void *)), value,
3906 int insmod_main( int argc, char **argv)
3912 unsigned long m_size;
3917 int exit_status = EXIT_FAILURE;
3919 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
3920 struct utsname uts_info;
3921 char m_strversion[STRVERSIONLEN];
3922 int m_version, m_crcs;
3924 #ifdef CONFIG_FEATURE_CLEAN_UP
3929 #ifdef CONFIG_FEATURE_INSMOD_LOAD_MAP
3930 int flag_print_load_map = 0;
3933 struct utsname myuname;
3935 /* Parse any options */
3936 #ifdef CONFIG_FEATURE_INSMOD_LOAD_MAP
3937 while ((opt = getopt(argc, argv, "fkqsvxmLo:")) > 0)
3939 while ((opt = getopt(argc, argv, "fkqsvxLo:")) > 0)
3943 case 'f': /* force loading */
3944 flag_force_load = 1;
3946 case 'k': /* module loaded by kerneld, auto-cleanable */
3949 case 's': /* log to syslog */
3950 /* log to syslog -- not supported */
3951 /* but kernel needs this for request_module(), */
3952 /* as this calls: modprobe -k -s -- <module> */
3953 /* so silently ignore this flag */
3955 case 'v': /* verbose output */
3958 case 'q': /* silent */
3961 case 'x': /* do not export externs */
3964 case 'o': /* name the output module */
3966 m_name = bb_xstrdup(optarg);
3968 case 'L': /* Stub warning */
3969 /* This is needed for compatibility with modprobe.
3970 * In theory, this does locking, but we don't do
3971 * that. So be careful and plan your life around not
3972 * loading the same module 50 times concurrently. */
3974 #ifdef CONFIG_FEATURE_INSMOD_LOAD_MAP
3975 case 'm': /* print module load map */
3976 flag_print_load_map = 1;
3984 if (argv[optind] == NULL) {
3988 /* Grab the module name */
3989 tmp1 = bb_xstrdup(argv[optind]);
3990 tmp = basename(tmp1);
3993 if (uname(&myuname) == 0) {
3994 if (myuname.release[0] == '2') {
3995 k_version = myuname.release[2] - '0';
3999 #if defined(CONFIG_FEATURE_2_6_MODULES)
4000 if (k_version > 4 && len > 3 && tmp[len - 3] == '.' &&
4001 tmp[len - 2] == 'k' && tmp[len - 1] == 'o') {
4007 if (len > 2 && tmp[len - 2] == '.' && tmp[len - 1] == 'o') {
4013 #if defined(CONFIG_FEATURE_2_6_MODULES)
4015 m_fullName = bb_xasprintf("%s.ko", tmp);
4018 m_fullName = bb_xasprintf("%s.o", tmp);
4024 tmp1 = 0; /* flag for free(m_name) before exit() */
4027 /* Get a filedesc for the module. Check we we have a complete path */
4028 if (stat(argv[optind], &st) < 0 || !S_ISREG(st.st_mode) ||
4029 (fp = fopen(argv[optind], "r")) == NULL) {
4030 /* Hmm. Could not open it. First search under /lib/modules/`uname -r`,
4031 * but do not error out yet if we fail to find it... */
4032 if (k_version) { /* uname succeedd */
4035 char real_module_dir[FILENAME_MAX];
4037 tmdn = concat_path_file(_PATH_MODULES, myuname.release);
4038 /* Jump through hoops in case /lib/modules/`uname -r`
4039 * is a symlink. We do not want recursive_action to
4040 * follow symlinks, but we do want to follow the
4041 * /lib/modules/`uname -r` dir, So resolve it ourselves
4042 * if it is a link... */
4043 if (realpath (tmdn, real_module_dir) == NULL)
4046 module_dir = real_module_dir;
4047 recursive_action(module_dir, TRUE, FALSE, FALSE,
4048 check_module_name_match, 0, m_fullName);
4052 /* Check if we have found anything yet */
4053 if (m_filename == 0 || ((fp = fopen(m_filename, "r")) == NULL))
4055 char module_dir[FILENAME_MAX];
4059 if (realpath (_PATH_MODULES, module_dir) == NULL)
4060 strcpy(module_dir, _PATH_MODULES);
4061 /* No module found under /lib/modules/`uname -r`, this
4062 * time cast the net a bit wider. Search /lib/modules/ */
4063 if (! recursive_action(module_dir, TRUE, FALSE, FALSE,
4064 check_module_name_match, 0, m_fullName))
4067 || ((fp = fopen(m_filename, "r")) == NULL))
4069 bb_error_msg("%s: no module by that name found", m_fullName);
4073 bb_error_msg_and_die("%s: no module by that name found", m_fullName);
4076 m_filename = bb_xstrdup(argv[optind]);
4079 printf("Using %s\n", m_filename);
4081 #ifdef CONFIG_FEATURE_2_6_MODULES
4085 argv[optind + 1] = m_filename;
4086 return insmod_ng_main(argc - optind, argv + optind);
4090 if ((f = obj_load(fp, LOADBITS)) == NULL)
4091 bb_perror_msg_and_die("Could not load the module");
4093 if (get_modinfo_value(f, "kernel_version") == NULL)
4098 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
4099 /* Version correspondence? */
4101 if (uname(&uts_info) < 0)
4102 uts_info.release[0] = '\0';
4103 if (m_has_modinfo) {
4104 m_version = new_get_module_version(f, m_strversion);
4105 if (m_version == -1) {
4106 bb_error_msg("couldn't find the kernel version the module was "
4112 if (strncmp(uts_info.release, m_strversion, STRVERSIONLEN) != 0) {
4113 if (flag_force_load) {
4114 bb_error_msg("Warning: kernel-module version mismatch\n"
4115 "\t%s was compiled for kernel version %s\n"
4116 "\twhile this kernel is version %s",
4117 m_filename, m_strversion, uts_info.release);
4119 bb_error_msg("kernel-module version mismatch\n"
4120 "\t%s was compiled for kernel version %s\n"
4121 "\twhile this kernel is version %s.",
4122 m_filename, m_strversion, uts_info.release);
4128 #endif /* CONFIG_FEATURE_INSMOD_VERSION_CHECKING */
4130 if (!query_module(NULL, 0, NULL, 0, NULL)) {
4131 if (!new_get_kernel_symbols())
4133 k_crcs = new_is_kernel_checksummed();
4135 bb_error_msg("Not configured to support old kernels");
4139 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
4142 m_crcs = new_is_module_checksummed(f);
4144 if (m_crcs != k_crcs)
4145 obj_set_symbol_compare(f, ncv_strcmp, ncv_symbol_hash);
4146 #endif /* CONFIG_FEATURE_INSMOD_VERSION_CHECKING */
4148 /* Let the module know about the kernel symbols. */
4149 add_kernel_symbols(f);
4151 /* Allocate common symbols, symbol tables, and string tables. */
4153 if (!new_create_this_module(f, m_name))
4158 if (!obj_check_undefineds(f)) {
4161 obj_allocate_commons(f);
4162 check_tainted_module(f, m_name);
4164 /* done with the module name, on to the optional var=value arguments */
4167 if (optind < argc) {
4168 if (!new_process_module_arguments(f, argc - optind, argv + optind))
4175 hide_special_symbols(f);
4177 #ifdef CONFIG_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
4178 add_ksymoops_symbols(f, m_filename, m_name);
4179 #endif /* CONFIG_FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
4181 new_create_module_ksymtab(f);
4183 /* Find current size of the module */
4184 m_size = obj_load_size(f);
4187 m_addr = create_module(m_name, m_size);
4188 if (m_addr == -1) switch (errno) {
4190 bb_error_msg("A module named %s already exists", m_name);
4193 bb_error_msg("Can't allocate kernel memory for module; needed %lu bytes",
4197 bb_perror_msg("create_module: %s", m_name);
4203 * the PROGBITS section was not loaded by the obj_load
4204 * now we can load them directly into the kernel memory
4206 if (!obj_load_progbits(fp, f, (char*)m_addr)) {
4207 delete_module(m_name);
4212 if (!obj_relocate(f, m_addr)) {
4213 delete_module(m_name);
4217 if (!new_init_module(m_name, f, m_size))
4219 delete_module(m_name);
4223 #ifdef CONFIG_FEATURE_INSMOD_LOAD_MAP
4224 if(flag_print_load_map)
4228 exit_status = EXIT_SUCCESS;
4231 #ifdef CONFIG_FEATURE_CLEAN_UP
4240 return(exit_status);
4247 #ifdef CONFIG_FEATURE_2_6_MODULES
4249 #include <sys/mman.h>
4250 #include <asm/unistd.h>
4251 #include <sys/syscall.h>
4253 /* We use error numbers in a loose translation... */
4254 static const char *moderror(int err)
4258 return "Invalid module format";
4260 return "Unknown symbol in module";
4262 return "Module has wrong symbol version";
4264 return "Invalid parameters";
4266 return strerror(err);
4270 int insmod_ng_main( int argc, char **argv)
4278 char *filename, *options = bb_xstrdup("");
4286 /* Rest is options */
4287 for (i = 2; i < argc; i++) {
4288 options = xrealloc(options, strlen(options) + 2 + strlen(argv[i]) + 2);
4289 /* Spaces handled by "" pairs, but no way of escaping quotes */
4290 if (strchr(argv[i], ' ')) {
4291 strcat(options, "\"");
4292 strcat(options, argv[i]);
4293 strcat(options, "\"");
4295 strcat(options, argv[i]);
4297 strcat(options, " ");
4300 if ((fd = open(filename, O_RDONLY, 0)) < 0) {
4301 bb_perror_msg_and_die("cannot open module `%s'", filename);
4306 map = mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
4307 if (map == MAP_FAILED) {
4308 bb_perror_msg_and_die("cannot mmap `%s'", filename);
4311 ret = syscall(__NR_init_module, map, len, options);
4313 bb_perror_msg_and_die("cannot insert `%s': %s (%li)",
4314 filename, moderror(errno), ret);