1 /* vi: set sw=4 ts=4: */
3 * Mini insmod implementation for busybox
4 * This version of insmod now supports x86, ARM, SH3/4, powerpc, and MIPS.
6 * Copyright (C) 1999,2000,2001 by Lineo, inc.
7 * Written by Erik Andersen <andersen@lineo.com>
8 * and Ron Alder <alder@lineo.com>
10 * Modified by Bryan Rittmeyer <bryan@ixiacom.com> to support SH4
11 * and (theoretically) SH3. I have only tested SH4 in little endian mode.
13 * Modified by Alcove, Julien Gaulmin <julien.gaulmin@alcove.fr> and
14 * Nicolas Ferre <nicolas.ferre@alcove.fr> to support ARM7TDMI. Only
15 * very minor changes required to also work with StrongArm and presumably
16 * all ARM based systems.
18 * Magnus Damm <damm@opensource.se> added PowerPC support 20-Feb-2001.
19 * PowerPC specific code stolen from modutils-2.3.16,
20 * written by Paul Mackerras, Copyright 1996, 1997 Linux International.
21 * I've only tested the code on mpc8xx platforms in big-endian mode.
22 * Did some cleanup and added BB_USE_xxx_ENTRIES...
24 * Quinn Jensen <jensenq@lineo.com> added MIPS support 23-Feb-2001.
25 * based on modutils-2.4.2
26 * MIPS specific support for Elf loading and relocation.
27 * Copyright 1996, 1997 Linux International.
28 * Contributed by Ralf Baechle <ralf@gnu.ai.mit.edu>
30 * Based almost entirely on the Linux modutils-2.3.11 implementation.
31 * Copyright 1996, 1997 Linux International.
32 * New implementation contributed by Richard Henderson <rth@tamu.edu>
33 * Based on original work by Bjorn Ekwall <bj0rn@blox.se>
34 * Restructured (and partly rewritten) by:
35 * Björn Ekwall <bj0rn@blox.se> February 1999
37 * This program is free software; you can redistribute it and/or modify
38 * it under the terms of the GNU General Public License as published by
39 * the Free Software Foundation; either version 2 of the License, or
40 * (at your option) any later version.
42 * This program is distributed in the hope that it will be useful,
43 * but WITHOUT ANY WARRANTY; without even the implied warranty of
44 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
45 * General Public License for more details.
47 * You should have received a copy of the GNU General Public License
48 * along with this program; if not, write to the Free Software
49 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
63 #include <sys/utsname.h>
66 #ifdef BB_FEATURE_NEW_MODULE_INTERFACE
67 # define new_sys_init_module init_module
69 # define old_sys_init_module init_module
72 #if defined(__powerpc__)
73 #define BB_USE_PLT_ENTRIES
74 #define BB_PLT_ENTRY_SIZE 16
78 #define BB_USE_PLT_ENTRIES
79 #define BB_PLT_ENTRY_SIZE 8
80 #define BB_USE_GOT_ENTRIES
81 #define BB_GOT_ENTRY_SIZE 8
85 #define BB_USE_GOT_ENTRIES
86 #define BB_GOT_ENTRY_SIZE 4
90 #define BB_USE_GOT_ENTRIES
91 #define BB_GOT_ENTRY_SIZE 4
98 //----------------------------------------------------------------------------
99 //--------modutils module.h, lines 45-242
100 //----------------------------------------------------------------------------
102 /* Definitions for the Linux module syscall interface.
103 Copyright 1996, 1997 Linux International.
105 Contributed by Richard Henderson <rth@tamu.edu>
107 This file is part of the Linux modutils.
109 This program is free software; you can redistribute it and/or modify it
110 under the terms of the GNU General Public License as published by the
111 Free Software Foundation; either version 2 of the License, or (at your
112 option) any later version.
114 This program is distributed in the hope that it will be useful, but
115 WITHOUT ANY WARRANTY; without even the implied warranty of
116 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
117 General Public License for more details.
119 You should have received a copy of the GNU General Public License
120 along with this program; if not, write to the Free Software Foundation,
121 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
124 #ifndef MODUTILS_MODULE_H
125 static const int MODUTILS_MODULE_H = 1;
127 #ident "$Id: insmod.c,v 1.61 2001/05/14 17:07:32 andersen Exp $"
129 /* This file contains the structures used by the 2.0 and 2.1 kernels.
130 We do not use the kernel headers directly because we do not wish
131 to be dependant on a particular kernel version to compile insmod. */
134 /*======================================================================*/
135 /* The structures used by Linux 2.0. */
137 /* The symbol format used by get_kernel_syms(2). */
138 struct old_kernel_sym
144 struct old_module_ref
146 unsigned long module; /* kernel addresses */
150 struct old_module_symbol
156 struct old_symbol_table
158 int size; /* total, including string table!!! */
161 struct old_module_symbol symbol[0]; /* actual size defined by n_symbols */
162 struct old_module_ref ref[0]; /* actual size defined by n_refs */
165 struct old_mod_routines
168 unsigned long cleanup;
174 unsigned long ref; /* the list of modules that refer to me */
175 unsigned long symtab;
177 int size; /* size of module in pages */
178 unsigned long addr; /* address of module */
180 unsigned long cleanup; /* cleanup routine */
183 /* Sent to init_module(2) or'ed into the code size parameter. */
184 static const int OLD_MOD_AUTOCLEAN = 0x40000000; /* big enough, but no sign problems... */
186 int get_kernel_syms(struct old_kernel_sym *);
187 int old_sys_init_module(const char *name, char *code, unsigned codesize,
188 struct old_mod_routines *, struct old_symbol_table *);
190 /*======================================================================*/
191 /* For sizeof() which are related to the module platform and not to the
192 environment isnmod is running in, use sizeof_xx instead of sizeof(xx). */
194 #define tgt_sizeof_char sizeof(char)
195 #define tgt_sizeof_short sizeof(short)
196 #define tgt_sizeof_int sizeof(int)
197 #define tgt_sizeof_long sizeof(long)
198 #define tgt_sizeof_char_p sizeof(char *)
199 #define tgt_sizeof_void_p sizeof(void *)
200 #define tgt_long long
202 #if defined(__sparc__) && !defined(__sparc_v9__) && defined(ARCH_sparc64)
203 #undef tgt_sizeof_long
204 #undef tgt_sizeof_char_p
205 #undef tgt_sizeof_void_p
207 static const int tgt_sizeof_long = 8;
208 static const int tgt_sizeof_char_p = 8;
209 static const int tgt_sizeof_void_p = 8;
210 #define tgt_long long long
213 /*======================================================================*/
214 /* The structures used in Linux 2.1. */
216 /* Note: new_module_symbol does not use tgt_long intentionally */
217 struct new_module_symbol
223 struct new_module_persist;
225 struct new_module_ref
227 unsigned tgt_long dep; /* kernel addresses */
228 unsigned tgt_long ref;
229 unsigned tgt_long next_ref;
234 unsigned tgt_long size_of_struct; /* == sizeof(module) */
235 unsigned tgt_long next;
236 unsigned tgt_long name;
237 unsigned tgt_long size;
240 unsigned tgt_long flags; /* AUTOCLEAN et al */
245 unsigned tgt_long syms;
246 unsigned tgt_long deps;
247 unsigned tgt_long refs;
248 unsigned tgt_long init;
249 unsigned tgt_long cleanup;
250 unsigned tgt_long ex_table_start;
251 unsigned tgt_long ex_table_end;
253 unsigned tgt_long gp;
255 /* Everything after here is extension. */
256 unsigned tgt_long persist_start;
257 unsigned tgt_long persist_end;
258 unsigned tgt_long can_unload;
259 unsigned tgt_long runsize;
262 struct new_module_info
270 /* Bits of module.flags. */
271 static const int NEW_MOD_RUNNING = 1;
272 static const int NEW_MOD_DELETED = 2;
273 static const int NEW_MOD_AUTOCLEAN = 4;
274 static const int NEW_MOD_VISITED = 8;
275 static const int NEW_MOD_USED_ONCE = 16;
277 int new_sys_init_module(const char *name, const struct new_module *);
278 int query_module(const char *name, int which, void *buf, size_t bufsize,
281 /* Values for query_module's which. */
283 static const int QM_MODULES = 1;
284 static const int QM_DEPS = 2;
285 static const int QM_REFS = 3;
286 static const int QM_SYMBOLS = 4;
287 static const int QM_INFO = 5;
289 /*======================================================================*/
290 /* The system calls unchanged between 2.0 and 2.1. */
292 unsigned long create_module(const char *, size_t);
293 int delete_module(const char *);
296 #endif /* module.h */
298 //----------------------------------------------------------------------------
299 //--------end of modutils module.h
300 //----------------------------------------------------------------------------
304 //----------------------------------------------------------------------------
305 //--------modutils obj.h, lines 253-462
306 //----------------------------------------------------------------------------
308 /* Elf object file loading and relocation routines.
309 Copyright 1996, 1997 Linux International.
311 Contributed by Richard Henderson <rth@tamu.edu>
313 This file is part of the Linux modutils.
315 This program is free software; you can redistribute it and/or modify it
316 under the terms of the GNU General Public License as published by the
317 Free Software Foundation; either version 2 of the License, or (at your
318 option) any later version.
320 This program is distributed in the hope that it will be useful, but
321 WITHOUT ANY WARRANTY; without even the implied warranty of
322 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
323 General Public License for more details.
325 You should have received a copy of the GNU General Public License
326 along with this program; if not, write to the Free Software Foundation,
327 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
330 #ifndef MODUTILS_OBJ_H
331 static const int MODUTILS_OBJ_H = 1;
333 #ident "$Id: insmod.c,v 1.61 2001/05/14 17:07:32 andersen Exp $"
335 /* The relocatable object is manipulated using elfin types. */
341 /* Machine-specific elf macros for i386 et al. */
343 /* the SH changes have only been tested on the SH4 in =little endian= mode */
344 /* I'm not sure about big endian, so let's warn: */
346 #if (defined(__SH4__) || defined(__SH3__)) && defined(__BIG_ENDIAN__)
347 #error insmod.c may require changes for use on big endian SH4/SH3
350 /* it may or may not work on the SH1/SH2... So let's error on those
352 #if (defined(__sh__) && (!(defined(__SH3__) || defined(__SH4__))))
353 #error insmod.c may require changes for non-SH3/SH4 use
356 #define ELFCLASSM ELFCLASS32
360 #define MATCH_MACHINE(x) (x == EM_SH)
361 #define SHT_RELM SHT_RELA
362 #define Elf32_RelM Elf32_Rela
363 #define ELFDATAM ELFDATA2LSB
365 #elif defined(__arm__)
367 #define MATCH_MACHINE(x) (x == EM_ARM)
368 #define SHT_RELM SHT_REL
369 #define Elf32_RelM Elf32_Rel
370 #define ELFDATAM ELFDATA2LSB
372 #elif defined(__powerpc__)
374 #define MATCH_MACHINE(x) (x == EM_PPC)
375 #define SHT_RELM SHT_RELA
376 #define Elf32_RelM Elf32_Rela
377 #define ELFDATAM ELFDATA2MSB
379 #elif defined(__mips__)
381 /* Account for ELF spec changes. */
382 #ifndef EM_MIPS_RS3_LE
383 #ifdef EM_MIPS_RS4_BE
384 #define EM_MIPS_RS3_LE EM_MIPS_RS4_BE
386 #define EM_MIPS_RS3_LE 10
388 #endif /* !EM_MIPS_RS3_LE */
390 #define MATCH_MACHINE(x) (x == EM_MIPS || x == EM_MIPS_RS3_LE)
391 #define SHT_RELM SHT_REL
392 #define Elf32_RelM Elf32_Rel
394 #define ELFDATAM ELFDATA2MSB
397 #define ELFDATAM ELFDATA2LSB
400 #elif defined(__i386__)
402 /* presumably we can use these for anything but the SH and ARM*/
403 /* this is the previous behavior, but it does result in
404 insmod.c being broken on anything except i386 */
406 #define MATCH_MACHINE(x) (x == EM_386)
408 #define MATCH_MACHINE(x) (x == EM_386 || x == EM_486)
411 #define SHT_RELM SHT_REL
412 #define Elf32_RelM Elf32_Rel
413 #define ELFDATAM ELFDATA2LSB
416 #error Sorry, but insmod.c does not yet support this architecture...
420 # if ELFCLASSM == ELFCLASS32
421 # define ElfW(x) Elf32_ ## x
422 # define ELFW(x) ELF32_ ## x
424 # define ElfW(x) Elf64_ ## x
425 # define ELFW(x) ELF64_ ## x
429 /* For some reason this is missing from libc5. */
430 #ifndef ELF32_ST_INFO
431 # define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
434 #ifndef ELF64_ST_INFO
435 # define ELF64_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
438 struct obj_string_patch;
439 struct obj_symbol_patch;
446 struct obj_section *load_next;
452 struct obj_symbol *next; /* hash table link */
456 int secidx; /* the defining section index/module */
458 int ksymidx; /* for export to the kernel symtab */
459 int referenced; /* actually used in the link */
462 /* Hardcode the hash table size. We shouldn't be needing so many
463 symbols that we begin to degrade performance, and we get a big win
464 by giving the compiler a constant divisor. */
466 #define HASH_BUCKETS 521
472 struct obj_section **sections;
473 struct obj_section *load_order;
474 struct obj_section **load_order_search_start;
475 struct obj_string_patch *string_patches;
476 struct obj_symbol_patch *symbol_patches;
477 int (*symbol_cmp)(const char *, const char *);
478 unsigned long (*symbol_hash)(const char *);
479 unsigned long local_symtab_size;
480 struct obj_symbol **local_symtab;
481 struct obj_symbol *symtab[HASH_BUCKETS];
492 struct obj_string_patch
494 struct obj_string_patch *next;
496 ElfW(Addr) reloc_offset;
497 ElfW(Addr) string_offset;
500 struct obj_symbol_patch
502 struct obj_symbol_patch *next;
504 ElfW(Addr) reloc_offset;
505 struct obj_symbol *sym;
509 /* Generic object manipulation routines. */
511 unsigned long obj_elf_hash(const char *);
513 unsigned long obj_elf_hash_n(const char *, unsigned long len);
515 struct obj_symbol *obj_add_symbol (struct obj_file *f, const char *name,
516 unsigned long symidx, int info, int secidx,
517 ElfW(Addr) value, unsigned long size);
519 struct obj_symbol *obj_find_symbol (struct obj_file *f,
522 ElfW(Addr) obj_symbol_final_value(struct obj_file *f,
523 struct obj_symbol *sym);
525 void obj_set_symbol_compare(struct obj_file *f,
526 int (*cmp)(const char *, const char *),
527 unsigned long (*hash)(const char *));
529 struct obj_section *obj_find_section (struct obj_file *f,
532 void obj_insert_section_load_order (struct obj_file *f,
533 struct obj_section *sec);
535 struct obj_section *obj_create_alloced_section (struct obj_file *f,
540 struct obj_section *obj_create_alloced_section_first (struct obj_file *f,
545 void *obj_extend_section (struct obj_section *sec, unsigned long more);
547 int obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
550 int obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
551 struct obj_symbol *sym);
553 int obj_check_undefineds(struct obj_file *f);
555 void obj_allocate_commons(struct obj_file *f);
557 unsigned long obj_load_size (struct obj_file *f);
559 int obj_relocate (struct obj_file *f, ElfW(Addr) base);
561 struct obj_file *obj_load(FILE *f);
563 int obj_create_image (struct obj_file *f, char *image);
565 /* Architecture specific manipulation routines. */
567 struct obj_file *arch_new_file (void);
569 struct obj_section *arch_new_section (void);
571 struct obj_symbol *arch_new_symbol (void);
573 enum obj_reloc arch_apply_relocation (struct obj_file *f,
574 struct obj_section *targsec,
575 struct obj_section *symsec,
576 struct obj_symbol *sym,
577 ElfW(RelM) *rel, ElfW(Addr) value);
579 int arch_create_got (struct obj_file *f);
582 int arch_init_module (struct obj_file *f, struct new_module *);
585 //----------------------------------------------------------------------------
586 //--------end of modutils obj.h
587 //----------------------------------------------------------------------------
593 #define _PATH_MODULES "/lib/modules"
594 static const int STRVERSIONLEN = 32;
596 /*======================================================================*/
598 int flag_force_load = 0;
599 int flag_autoclean = 0;
600 int flag_verbose = 0;
604 /*======================================================================*/
606 /* previously, these were named i386_* but since we could be
607 compiling for the sh, I've renamed them to the more general
608 arch_* These structures are the same between the x86 and SH,
609 and we can't support anything else right now anyway. In the
610 future maybe they should be #if defined'd */
616 #if defined(BB_USE_PLT_ENTRIES)
617 struct arch_plt_entry
621 int inited:1; /* has been set up */
625 #if defined(BB_USE_GOT_ENTRIES)
626 struct arch_got_entry {
628 unsigned offset_done:1;
629 unsigned reloc_done:1;
633 #if defined(__mips__)
636 struct mips_hi16 *next;
643 struct obj_file root;
644 #if defined(BB_USE_PLT_ENTRIES)
645 struct obj_section *plt;
647 #if defined(BB_USE_GOT_ENTRIES)
648 struct obj_section *got;
650 #if defined(__mips__)
651 struct mips_hi16 *mips_hi16_list;
656 struct obj_symbol root;
657 #if defined(BB_USE_PLT_ENTRIES)
658 struct arch_plt_entry pltent;
660 #if defined(BB_USE_GOT_ENTRIES)
661 struct arch_got_entry gotent;
666 struct external_module {
671 struct new_module_symbol *syms;
674 struct new_module_symbol *ksyms;
677 struct external_module *ext_modules;
679 int n_ext_modules_used;
680 extern int delete_module(const char *);
682 static char m_filename[FILENAME_MAX + 1];
683 static char m_fullName[FILENAME_MAX + 1];
687 /*======================================================================*/
690 static int check_module_name_match(const char *filename, struct stat *statbuf,
693 char *fullname = (char *) userdata;
695 if (fullname[0] == '\0')
698 char *tmp, *tmp1 = strdup(filename);
699 tmp = get_last_path_component(tmp1);
700 if (strcmp(tmp, fullname) == 0) {
702 /* Stop searching if we find a match */
703 safe_strncpy(m_filename, filename, sizeof(m_filename));
712 /*======================================================================*/
714 struct obj_file *arch_new_file(void)
717 f = xmalloc(sizeof(*f));
719 #if defined(BB_USE_PLT_ENTRIES)
722 #if defined(BB_USE_GOT_ENTRIES)
725 #if defined(__mips__)
726 f->mips_hi16_list = NULL;
732 struct obj_section *arch_new_section(void)
734 return xmalloc(sizeof(struct obj_section));
737 struct obj_symbol *arch_new_symbol(void)
739 struct arch_symbol *sym;
740 sym = xmalloc(sizeof(*sym));
742 #if defined(BB_USE_PLT_ENTRIES)
743 memset(&sym->pltent, 0, sizeof(sym->pltent));
745 #if defined(BB_USE_GOT_ENTRIES)
746 memset(&sym->gotent, 0, sizeof(sym->gotent));
753 arch_apply_relocation(struct obj_file *f,
754 struct obj_section *targsec,
755 struct obj_section *symsec,
756 struct obj_symbol *sym,
757 ElfW(RelM) *rel, ElfW(Addr) v)
759 struct arch_file *ifile = (struct arch_file *) f;
760 #if !(defined(__mips__))
761 struct arch_symbol *isym = (struct arch_symbol *) sym;
764 ElfW(Addr) *loc = (ElfW(Addr) *) (targsec->contents + rel->r_offset);
765 ElfW(Addr) dot = targsec->header.sh_addr + rel->r_offset;
766 #if defined(BB_USE_GOT_ENTRIES)
767 ElfW(Addr) got = ifile->got ? ifile->got->header.sh_addr : 0;
769 #if defined(BB_USE_PLT_ENTRIES)
770 ElfW(Addr) plt = ifile->plt ? ifile->plt->header.sh_addr : 0;
771 struct arch_plt_entry *pe;
774 enum obj_reloc ret = obj_reloc_ok;
776 switch (ELF32_R_TYPE(rel->r_info)) {
778 /* even though these constants seem to be the same for
779 the i386 and the sh, we "#if define" them for clarity
780 and in case that ever changes */
783 #elif defined(__arm__)
785 #elif defined(__i386__)
787 #elif defined(__powerpc__)
789 #elif defined(__mips__)
796 #elif defined(__arm__)
798 #elif defined(__i386__)
800 #elif defined(__powerpc__)
802 #elif defined(__mips__)
808 #if defined(__powerpc__)
809 case R_PPC_ADDR16_HA:
810 *(unsigned short *)loc = (v + 0x8000) >> 16;
813 case R_PPC_ADDR16_HI:
814 *(unsigned short *)loc = v >> 16;
817 case R_PPC_ADDR16_LO:
818 *(unsigned short *)loc = v;
822 #if defined(__mips__)
825 ret = obj_reloc_dangerous;
826 if ((v & 0xf0000000) != ((dot + 4) & 0xf0000000))
827 ret = obj_reloc_overflow;
829 (*loc & ~0x03ffffff) | ((*loc + (v >> 2)) &
837 /* We cannot relocate this one now because we don't know the value
838 of the carry we need to add. Save the information, and let LO16
839 do the actual relocation. */
840 n = (struct mips_hi16 *) xmalloc(sizeof *n);
843 n->next = ifile->mips_hi16_list;
844 ifile->mips_hi16_list = n;
850 unsigned long insnlo = *loc;
851 Elf32_Addr val, vallo;
853 /* Sign extend the addend we extract from the lo insn. */
854 vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
856 if (ifile->mips_hi16_list != NULL) {
859 l = ifile->mips_hi16_list;
861 struct mips_hi16 *next;
864 /* The value for the HI16 had best be the same. */
865 assert(v == l->value);
867 /* Do the HI16 relocation. Note that we actually don't
868 need to know anything about the LO16 itself, except where
869 to find the low 16 bits of the addend needed by the LO16. */
872 ((insn & 0xffff) << 16) +
876 /* Account for the sign extension that will happen in the
883 insn = (insn & ~0xffff) | val;
891 ifile->mips_hi16_list = NULL;
894 /* Ok, we're done with the HI16 relocs. Now deal with the LO16. */
896 insnlo = (insnlo & ~0xffff) | (val & 0xffff);
903 #elif defined(__sh__)
907 #elif defined(__i386__)
912 #elif defined(__powerpc__)
922 #elif defined(__i386__)
925 #if defined(BB_USE_PLT_ENTRIES)
931 #if defined(__powerpc__)
934 /* find the plt entry and initialize it if necessary */
935 assert(isym != NULL);
937 pe = (struct arch_plt_entry*) &isym->pltent;
940 ip = (unsigned long *) (ifile->plt->contents + pe->offset);
942 /* generate some machine code */
945 ip[0] = 0xe51ff004; /* ldr pc,[pc,#-4] */
946 ip[1] = v; /* sym@ */
948 #if defined(__powerpc__)
949 ip[0] = 0x3d600000 + ((v + 0x8000) >> 16); /* lis r11,sym@ha */
950 ip[1] = 0x396b0000 + (v & 0xffff); /* addi r11,r11,sym@l */
951 ip[2] = 0x7d6903a6; /* mtctr r11 */
952 ip[3] = 0x4e800420; /* bctr */
957 /* relative distance to target */
959 /* if the target is too far away.... */
960 if ((int)v < -0x02000000 || (int)v >= 0x02000000) {
962 v = plt + pe->offset - dot;
965 ret = obj_reloc_dangerous;
967 /* merge the offset into the instruction. */
969 /* Convert to words. */
972 *loc = (*loc & ~0x00ffffff) | ((v + *loc) & 0x00ffffff);
974 #if defined(__powerpc__)
975 *loc = (*loc & ~0x03fffffc) | (v & 0x03fffffc);
978 #endif /* BB_USE_PLT_ENTRIES */
981 #elif defined(__sh__)
986 #elif defined(__i386__)
994 #elif defined(__sh__)
996 *loc += f->baseaddr + rel->r_addend;
998 #elif defined(__i386__)
1000 *loc += f->baseaddr;
1004 #if defined(BB_USE_GOT_ENTRIES)
1008 #elif defined(__arm__)
1010 #elif defined(__i386__)
1015 *loc += got - dot + rel->r_addend;;
1016 #elif defined(__i386__) || defined(__arm__)
1023 #elif defined(__arm__)
1025 #elif defined(__i386__)
1028 assert(isym != NULL);
1029 /* needs an entry in the .got: set it, once */
1030 if (!isym->gotent.reloc_done) {
1031 isym->gotent.reloc_done = 1;
1032 *(ElfW(Addr) *) (ifile->got->contents + isym->gotent.offset) = v;
1034 /* make the reloc with_respect_to_.got */
1036 *loc += isym->gotent.offset + rel->r_addend;
1037 #elif defined(__i386__) || defined(__arm__)
1038 *loc += isym->gotent.offset;
1042 /* address relative to the got */
1045 #elif defined(__arm__)
1047 #elif defined(__i386__)
1054 #endif /* BB_USE_GOT_ENTRIES */
1057 printf("Warning: unhandled reloc %d\n",(int)ELF32_R_TYPE(rel->r_info));
1058 ret = obj_reloc_unhandled;
1065 int arch_create_got(struct obj_file *f)
1067 #if defined(BB_USE_GOT_ENTRIES) || defined(BB_USE_PLT_ENTRIES)
1068 struct arch_file *ifile = (struct arch_file *) f;
1070 #if defined(BB_USE_GOT_ENTRIES)
1071 int got_offset = 0, gotneeded = 0;
1073 #if defined(BB_USE_PLT_ENTRIES)
1074 int plt_offset = 0, pltneeded = 0;
1076 struct obj_section *relsec, *symsec, *strsec;
1077 ElfW(RelM) *rel, *relend;
1078 ElfW(Sym) *symtab, *extsym;
1079 const char *strtab, *name;
1080 struct arch_symbol *intsym;
1082 for (i = 0; i < f->header.e_shnum; ++i) {
1083 relsec = f->sections[i];
1084 if (relsec->header.sh_type != SHT_RELM)
1087 symsec = f->sections[relsec->header.sh_link];
1088 strsec = f->sections[symsec->header.sh_link];
1090 rel = (ElfW(RelM) *) relsec->contents;
1091 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
1092 symtab = (ElfW(Sym) *) symsec->contents;
1093 strtab = (const char *) strsec->contents;
1095 for (; rel < relend; ++rel) {
1096 extsym = &symtab[ELF32_R_SYM(rel->r_info)];
1098 switch (ELF32_R_TYPE(rel->r_info)) {
1099 #if defined(__arm__)
1102 #elif defined(__sh__)
1105 #elif defined(__i386__)
1110 #if defined(__powerpc__)
1116 #if defined(__arm__)
1125 if (got_offset == 0)
1127 #elif defined(__sh__)
1131 #elif defined(__i386__)
1141 if (extsym->st_name != 0) {
1142 name = strtab + extsym->st_name;
1144 name = f->sections[extsym->st_shndx]->name;
1146 intsym = (struct arch_symbol *) obj_find_symbol(f, name);
1147 #if defined(BB_USE_GOT_ENTRIES)
1148 if (!intsym->gotent.offset_done) {
1149 intsym->gotent.offset_done = 1;
1150 intsym->gotent.offset = got_offset;
1151 got_offset += BB_GOT_ENTRY_SIZE;
1154 #if defined(BB_USE_PLT_ENTRIES)
1155 if (pltneeded && intsym->pltent.allocated == 0) {
1156 intsym->pltent.allocated = 1;
1157 intsym->pltent.offset = plt_offset;
1158 plt_offset += BB_PLT_ENTRY_SIZE;
1159 intsym->pltent.inited = 0;
1166 #if defined(BB_USE_GOT_ENTRIES)
1168 struct obj_section* myrelsec = obj_find_section(f, ".got");
1171 obj_extend_section(myrelsec, got_offset);
1173 myrelsec = obj_create_alloced_section(f, ".got",
1179 ifile->got = myrelsec;
1183 #if defined(BB_USE_PLT_ENTRIES)
1185 ifile->plt = obj_create_alloced_section(f, ".plt",
1193 int arch_init_module(struct obj_file *f, struct new_module *mod)
1199 /*======================================================================*/
1201 /* Standard ELF hash function. */
1202 inline unsigned long obj_elf_hash_n(const char *name, unsigned long n)
1204 unsigned long h = 0;
1211 if ((g = (h & 0xf0000000)) != 0) {
1220 unsigned long obj_elf_hash(const char *name)
1222 return obj_elf_hash_n(name, strlen(name));
1225 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
1226 /* Get the kernel version in the canonical integer form. */
1228 static int get_kernel_version(char str[STRVERSIONLEN])
1230 struct utsname uts_info;
1234 if (uname(&uts_info) < 0)
1236 strncpy(str, uts_info.release, STRVERSIONLEN);
1237 p = uts_info.release;
1239 a = strtoul(p, &p, 10);
1242 b = strtoul(p + 1, &p, 10);
1245 c = strtoul(p + 1, &q, 10);
1249 return a << 16 | b << 8 | c;
1252 /* String comparison for non-co-versioned kernel and module. */
1254 static int ncv_strcmp(const char *a, const char *b)
1256 size_t alen = strlen(a), blen = strlen(b);
1258 if (blen == alen + 10 && b[alen] == '_' && b[alen + 1] == 'R')
1259 return strncmp(a, b, alen);
1260 else if (alen == blen + 10 && a[blen] == '_' && a[blen + 1] == 'R')
1261 return strncmp(a, b, blen);
1263 return strcmp(a, b);
1266 /* String hashing for non-co-versioned kernel and module. Here
1267 we are simply forced to drop the crc from the hash. */
1269 static unsigned long ncv_symbol_hash(const char *str)
1271 size_t len = strlen(str);
1272 if (len > 10 && str[len - 10] == '_' && str[len - 9] == 'R')
1274 return obj_elf_hash_n(str, len);
1278 obj_set_symbol_compare(struct obj_file *f,
1279 int (*cmp) (const char *, const char *),
1280 unsigned long (*hash) (const char *))
1283 f->symbol_cmp = cmp;
1285 struct obj_symbol *tmptab[HASH_BUCKETS], *sym, *next;
1288 f->symbol_hash = hash;
1290 memcpy(tmptab, f->symtab, sizeof(tmptab));
1291 memset(f->symtab, 0, sizeof(f->symtab));
1293 for (i = 0; i < HASH_BUCKETS; ++i)
1294 for (sym = tmptab[i]; sym; sym = next) {
1295 unsigned long h = hash(sym->name) % HASH_BUCKETS;
1297 sym->next = f->symtab[h];
1303 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
1306 struct obj_symbol *obj_add_symbol(struct obj_file *f, const char *name,
1307 unsigned long symidx, int info,
1308 int secidx, ElfW(Addr) value,
1311 struct obj_symbol *sym;
1312 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
1313 int n_type = ELFW(ST_TYPE) (info);
1314 int n_binding = ELFW(ST_BIND) (info);
1316 for (sym = f->symtab[hash]; sym; sym = sym->next)
1317 if (f->symbol_cmp(sym->name, name) == 0) {
1318 int o_secidx = sym->secidx;
1319 int o_info = sym->info;
1320 int o_type = ELFW(ST_TYPE) (o_info);
1321 int o_binding = ELFW(ST_BIND) (o_info);
1323 /* A redefinition! Is it legal? */
1325 if (secidx == SHN_UNDEF)
1327 else if (o_secidx == SHN_UNDEF)
1329 else if (n_binding == STB_GLOBAL && o_binding == STB_LOCAL) {
1330 /* Cope with local and global symbols of the same name
1331 in the same object file, as might have been created
1332 by ld -r. The only reason locals are now seen at this
1333 level at all is so that we can do semi-sensible things
1336 struct obj_symbol *nsym, **p;
1338 nsym = arch_new_symbol();
1339 nsym->next = sym->next;
1342 /* Excise the old (local) symbol from the hash chain. */
1343 for (p = &f->symtab[hash]; *p != sym; p = &(*p)->next)
1347 } else if (n_binding == STB_LOCAL) {
1348 /* Another symbol of the same name has already been defined.
1349 Just add this to the local table. */
1350 sym = arch_new_symbol();
1353 f->local_symtab[symidx] = sym;
1355 } else if (n_binding == STB_WEAK)
1357 else if (o_binding == STB_WEAK)
1359 /* Don't unify COMMON symbols with object types the programmer
1361 else if (secidx == SHN_COMMON
1362 && (o_type == STT_NOTYPE || o_type == STT_OBJECT))
1364 else if (o_secidx == SHN_COMMON
1365 && (n_type == STT_NOTYPE || n_type == STT_OBJECT))
1368 /* Don't report an error if the symbol is coming from
1369 the kernel or some external module. */
1370 if (secidx <= SHN_HIRESERVE)
1371 error_msg("%s multiply defined", name);
1376 /* Completely new symbol. */
1377 sym = arch_new_symbol();
1378 sym->next = f->symtab[hash];
1379 f->symtab[hash] = sym;
1382 if (ELFW(ST_BIND) (info) == STB_LOCAL)
1383 f->local_symtab[symidx] = sym;
1389 sym->secidx = secidx;
1395 struct obj_symbol *obj_find_symbol(struct obj_file *f, const char *name)
1397 struct obj_symbol *sym;
1398 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
1400 for (sym = f->symtab[hash]; sym; sym = sym->next)
1401 if (f->symbol_cmp(sym->name, name) == 0)
1408 obj_symbol_final_value(struct obj_file * f, struct obj_symbol * sym)
1411 if (sym->secidx >= SHN_LORESERVE)
1414 return sym->value + f->sections[sym->secidx]->header.sh_addr;
1416 /* As a special case, a NULL sym has value zero. */
1421 struct obj_section *obj_find_section(struct obj_file *f, const char *name)
1423 int i, n = f->header.e_shnum;
1425 for (i = 0; i < n; ++i)
1426 if (strcmp(f->sections[i]->name, name) == 0)
1427 return f->sections[i];
1432 static int obj_load_order_prio(struct obj_section *a)
1434 unsigned long af, ac;
1436 af = a->header.sh_flags;
1439 if (a->name[0] != '.' || strlen(a->name) != 10 ||
1440 strcmp(a->name + 5, ".init"))
1444 if (!(af & SHF_WRITE))
1446 if (af & SHF_EXECINSTR)
1448 if (a->header.sh_type != SHT_NOBITS)
1455 obj_insert_section_load_order(struct obj_file *f, struct obj_section *sec)
1457 struct obj_section **p;
1458 int prio = obj_load_order_prio(sec);
1459 for (p = f->load_order_search_start; *p; p = &(*p)->load_next)
1460 if (obj_load_order_prio(*p) < prio)
1462 sec->load_next = *p;
1466 struct obj_section *obj_create_alloced_section(struct obj_file *f,
1468 unsigned long align,
1471 int newidx = f->header.e_shnum++;
1472 struct obj_section *sec;
1474 f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
1475 f->sections[newidx] = sec = arch_new_section();
1477 memset(sec, 0, sizeof(*sec));
1478 sec->header.sh_type = SHT_PROGBITS;
1479 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
1480 sec->header.sh_size = size;
1481 sec->header.sh_addralign = align;
1485 sec->contents = xmalloc(size);
1487 obj_insert_section_load_order(f, sec);
1492 struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
1494 unsigned long align,
1497 int newidx = f->header.e_shnum++;
1498 struct obj_section *sec;
1500 f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
1501 f->sections[newidx] = sec = arch_new_section();
1503 memset(sec, 0, sizeof(*sec));
1504 sec->header.sh_type = SHT_PROGBITS;
1505 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
1506 sec->header.sh_size = size;
1507 sec->header.sh_addralign = align;
1511 sec->contents = xmalloc(size);
1513 sec->load_next = f->load_order;
1514 f->load_order = sec;
1515 if (f->load_order_search_start == &f->load_order)
1516 f->load_order_search_start = &sec->load_next;
1521 void *obj_extend_section(struct obj_section *sec, unsigned long more)
1523 unsigned long oldsize = sec->header.sh_size;
1525 sec->contents = xrealloc(sec->contents, sec->header.sh_size += more);
1527 return sec->contents + oldsize;
1532 /* Conditionally add the symbols from the given symbol set to the
1538 int idx, struct new_module_symbol *syms, size_t nsyms)
1540 struct new_module_symbol *s;
1544 for (i = 0, s = syms; i < nsyms; ++i, ++s) {
1546 /* Only add symbols that are already marked external. If we
1547 override locals we may cause problems for argument initialization.
1548 We will also create a false dependency on the module. */
1549 struct obj_symbol *sym;
1551 sym = obj_find_symbol(f, (char *) s->name);
1552 if (sym && !ELFW(ST_BIND) (sym->info) == STB_LOCAL) {
1553 sym = obj_add_symbol(f, (char *) s->name, -1,
1554 ELFW(ST_INFO) (STB_GLOBAL, STT_NOTYPE),
1556 /* Did our symbol just get installed? If so, mark the
1557 module as "used". */
1558 if (sym->secidx == idx)
1566 static void add_kernel_symbols(struct obj_file *f)
1568 struct external_module *m;
1571 /* Add module symbols first. */
1573 for (i = 0, m = ext_modules; i < n_ext_modules; ++i, ++m)
1575 && add_symbols_from(f, SHN_HIRESERVE + 2 + i, m->syms,
1576 m->nsyms)) m->used = 1, ++nused;
1578 n_ext_modules_used = nused;
1580 /* And finally the symbols from the kernel proper. */
1583 add_symbols_from(f, SHN_HIRESERVE + 1, ksyms, nksyms);
1586 static char *get_modinfo_value(struct obj_file *f, const char *key)
1588 struct obj_section *sec;
1589 char *p, *v, *n, *ep;
1590 size_t klen = strlen(key);
1592 sec = obj_find_section(f, ".modinfo");
1596 ep = p + sec->header.sh_size;
1599 n = strchr(p, '\0');
1601 if (p + klen == v && strncmp(p, key, klen) == 0)
1604 if (p + klen == n && strcmp(p, key) == 0)
1614 /*======================================================================*/
1615 /* Functions relating to module loading in pre 2.1 kernels. */
1618 old_process_module_arguments(struct obj_file *f, int argc, char **argv)
1622 struct obj_symbol *sym;
1626 if ((q = strchr(p, '=')) == NULL) {
1632 sym = obj_find_symbol(f, p);
1634 /* Also check that the parameter was not resolved from the kernel. */
1635 if (sym == NULL || sym->secidx > SHN_HIRESERVE) {
1636 error_msg("symbol for parameter %s not found", p);
1640 loc = (int *) (f->sections[sym->secidx]->contents + sym->value);
1642 /* Do C quoting if we begin with a ". */
1646 str = alloca(strlen(q));
1647 for (r = str, q++; *q != '"'; ++q, ++r) {
1649 error_msg("improperly terminated string argument for %s", p);
1651 } else if (*q == '\\')
1685 if (q[1] >= '0' && q[1] <= '7') {
1686 c = (c * 8) + *++q - '0';
1687 if (q[1] >= '0' && q[1] <= '7')
1688 c = (c * 8) + *++q - '0';
1701 obj_string_patch(f, sym->secidx, sym->value, str);
1702 } else if (*q >= '0' && *q <= '9') {
1704 *loc++ = strtoul(q, &q, 0);
1705 while (*q++ == ',');
1707 char *contents = f->sections[sym->secidx]->contents;
1708 char *myloc = contents + sym->value;
1709 char *r; /* To search for commas */
1711 /* Break the string with comas */
1712 while ((r = strchr(q, ',')) != (char *) NULL) {
1714 obj_string_patch(f, sym->secidx, myloc - contents, q);
1715 myloc += sizeof(char *);
1720 obj_string_patch(f, sym->secidx, myloc - contents, q);
1729 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
1730 static int old_is_module_checksummed(struct obj_file *f)
1732 return obj_find_symbol(f, "Using_Versions") != NULL;
1734 /* Get the module's kernel version in the canonical integer form. */
1737 old_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
1739 struct obj_symbol *sym;
1743 sym = obj_find_symbol(f, "kernel_version");
1747 p = f->sections[sym->secidx]->contents + sym->value;
1748 strncpy(str, p, STRVERSIONLEN);
1750 a = strtoul(p, &p, 10);
1753 b = strtoul(p + 1, &p, 10);
1756 c = strtoul(p + 1, &q, 10);
1760 return a << 16 | b << 8 | c;
1763 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
1765 #ifdef BB_FEATURE_OLD_MODULE_INTERFACE
1767 /* Fetch all the symbols and divvy them up as appropriate for the modules. */
1769 static int old_get_kernel_symbols(const char *m_name)
1771 struct old_kernel_sym *ks, *k;
1772 struct new_module_symbol *s;
1773 struct external_module *mod;
1774 int nks, nms, nmod, i;
1776 nks = get_kernel_syms(NULL);
1779 perror_msg("get_kernel_syms: %s", m_name);
1781 error_msg("No kernel symbols");
1785 ks = k = xmalloc(nks * sizeof(*ks));
1787 if (get_kernel_syms(ks) != nks) {
1788 perror("inconsistency with get_kernel_syms -- is someone else "
1789 "playing with modules?");
1794 /* Collect the module information. */
1799 while (k->name[0] == '#' && k->name[1]) {
1800 struct old_kernel_sym *k2;
1802 /* Find out how many symbols this module has. */
1803 for (k2 = k + 1; k2->name[0] != '#'; ++k2)
1807 mod = xrealloc(mod, (++nmod + 1) * sizeof(*mod));
1808 mod[nmod].name = k->name + 1;
1809 mod[nmod].addr = k->value;
1811 mod[nmod].nsyms = nms;
1812 mod[nmod].syms = s = (nms ? xmalloc(nms * sizeof(*s)) : NULL);
1814 for (i = 0, ++k; i < nms; ++i, ++s, ++k) {
1815 s->name = (unsigned long) k->name;
1816 s->value = k->value;
1823 n_ext_modules = nmod + 1;
1825 /* Now collect the symbols for the kernel proper. */
1827 if (k->name[0] == '#')
1830 nksyms = nms = nks - (k - ks);
1831 ksyms = s = (nms ? xmalloc(nms * sizeof(*s)) : NULL);
1833 for (i = 0; i < nms; ++i, ++s, ++k) {
1834 s->name = (unsigned long) k->name;
1835 s->value = k->value;
1841 /* Return the kernel symbol checksum version, or zero if not used. */
1843 static int old_is_kernel_checksummed(void)
1845 /* Using_Versions is the first symbol. */
1847 && strcmp((char *) ksyms[0].name,
1848 "Using_Versions") == 0) return ksyms[0].value;
1854 static int old_create_mod_use_count(struct obj_file *f)
1856 struct obj_section *sec;
1858 sec = obj_create_alloced_section_first(f, ".moduse", sizeof(long),
1861 obj_add_symbol(f, "mod_use_count_", -1,
1862 ELFW(ST_INFO) (STB_LOCAL, STT_OBJECT), sec->idx, 0,
1869 old_init_module(const char *m_name, struct obj_file *f,
1870 unsigned long m_size)
1873 struct old_mod_routines routines;
1874 struct old_symbol_table *symtab;
1877 /* Create the symbol table */
1879 int nsyms = 0, strsize = 0, total;
1881 /* Size things first... */
1884 for (i = 0; i < HASH_BUCKETS; ++i) {
1885 struct obj_symbol *sym;
1886 for (sym = f->symtab[i]; sym; sym = sym->next)
1887 if (ELFW(ST_BIND) (sym->info) != STB_LOCAL
1888 && sym->secidx <= SHN_HIRESERVE)
1890 sym->ksymidx = nsyms++;
1891 strsize += strlen(sym->name) + 1;
1896 total = (sizeof(struct old_symbol_table)
1897 + nsyms * sizeof(struct old_module_symbol)
1898 + n_ext_modules_used * sizeof(struct old_module_ref)
1900 symtab = xmalloc(total);
1901 symtab->size = total;
1902 symtab->n_symbols = nsyms;
1903 symtab->n_refs = n_ext_modules_used;
1905 if (flag_export && nsyms) {
1906 struct old_module_symbol *ksym;
1910 ksym = symtab->symbol;
1911 str = ((char *) ksym + nsyms * sizeof(struct old_module_symbol)
1912 + n_ext_modules_used * sizeof(struct old_module_ref));
1914 for (i = 0; i < HASH_BUCKETS; ++i) {
1915 struct obj_symbol *sym;
1916 for (sym = f->symtab[i]; sym; sym = sym->next)
1917 if (sym->ksymidx >= 0) {
1918 ksym->addr = obj_symbol_final_value(f, sym);
1920 (unsigned long) str - (unsigned long) symtab;
1922 strcpy(str, sym->name);
1923 str += strlen(sym->name) + 1;
1929 if (n_ext_modules_used) {
1930 struct old_module_ref *ref;
1933 ref = (struct old_module_ref *)
1934 ((char *) symtab->symbol + nsyms * sizeof(struct old_module_symbol));
1936 for (i = 0; i < n_ext_modules; ++i)
1937 if (ext_modules[i].used)
1938 ref++->module = ext_modules[i].addr;
1942 /* Fill in routines. */
1945 obj_symbol_final_value(f, obj_find_symbol(f, "init_module"));
1947 obj_symbol_final_value(f, obj_find_symbol(f, "cleanup_module"));
1949 /* Whew! All of the initialization is complete. Collect the final
1950 module image and give it to the kernel. */
1952 image = xmalloc(m_size);
1953 obj_create_image(f, image);
1955 /* image holds the complete relocated module, accounting correctly for
1956 mod_use_count. However the old module kernel support assume that
1957 it is receiving something which does not contain mod_use_count. */
1958 ret = old_sys_init_module(m_name, image + sizeof(long),
1959 m_size | (flag_autoclean ? OLD_MOD_AUTOCLEAN
1960 : 0), &routines, symtab);
1962 perror_msg("init_module: %s", m_name);
1972 #define old_create_mod_use_count(x) TRUE
1973 #define old_init_module(x, y, z) TRUE
1975 #endif /* BB_FEATURE_OLD_MODULE_INTERFACE */
1979 /*======================================================================*/
1980 /* Functions relating to module loading after 2.1.18. */
1983 new_process_module_arguments(struct obj_file *f, int argc, char **argv)
1987 struct obj_symbol *sym;
1988 char *contents, *loc;
1992 if ((q = strchr(p, '=')) == NULL) {
1997 key = alloca(q - p + 6);
1998 memcpy(key, "parm_", 5);
1999 memcpy(key + 5, p, q - p);
2002 p = get_modinfo_value(f, key);
2005 error_msg("invalid parameter %s", key);
2009 sym = obj_find_symbol(f, key);
2011 /* Also check that the parameter was not resolved from the kernel. */
2012 if (sym == NULL || sym->secidx > SHN_HIRESERVE) {
2013 error_msg("symbol for parameter %s not found", key);
2018 min = strtoul(p, &p, 10);
2020 max = strtoul(p + 1, &p, 10);
2026 contents = f->sections[sym->secidx]->contents;
2027 loc = contents + sym->value;
2031 if ((*p == 's') || (*p == 'c')) {
2034 /* Do C quoting if we begin with a ", else slurp the lot. */
2038 str = alloca(strlen(q));
2039 for (r = str, q++; *q != '"'; ++q, ++r) {
2041 error_msg("improperly terminated string argument for %s",
2044 } else if (*q == '\\')
2078 if (q[1] >= '0' && q[1] <= '7') {
2079 c = (c * 8) + *++q - '0';
2080 if (q[1] >= '0' && q[1] <= '7')
2081 c = (c * 8) + *++q - '0';
2098 /* In this case, the string is not quoted. We will break
2099 it using the coma (like for ints). If the user wants to
2100 include comas in a string, he just has to quote it */
2102 /* Search the next coma */
2106 if (r != (char *) NULL) {
2107 /* Recopy the current field */
2108 str = alloca(r - q + 1);
2109 memcpy(str, q, r - q);
2111 /* I don't know if it is usefull, as the previous case
2112 doesn't null terminate the string ??? */
2115 /* Keep next fields */
2126 obj_string_patch(f, sym->secidx, loc - contents, str);
2127 loc += tgt_sizeof_char_p;
2129 /* Array of chars (in fact, matrix !) */
2130 unsigned long charssize; /* size of each member */
2132 /* Get the size of each member */
2133 /* Probably we should do that outside the loop ? */
2134 if (!isdigit(*(p + 1))) {
2135 error_msg("parameter type 'c' for %s must be followed by"
2136 " the maximum size", key);
2139 charssize = strtoul(p + 1, (char **) NULL, 10);
2142 if (strlen(str) >= charssize) {
2143 error_msg("string too long for %s (max %ld)", key,
2148 /* Copy to location */
2149 strcpy((char *) loc, str);
2153 long v = strtoul(q, &q, 0);
2160 loc += tgt_sizeof_short;
2164 loc += tgt_sizeof_int;
2168 loc += tgt_sizeof_long;
2172 error_msg("unknown parameter type '%c' for %s", *p, key);
2187 goto retry_end_of_value;
2191 error_msg("too many values for %s (max %d)", key, max);
2198 error_msg("invalid argument syntax for %s", key);
2205 error_msg("too few values for %s (min %d)", key, min);
2215 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
2216 static int new_is_module_checksummed(struct obj_file *f)
2218 const char *p = get_modinfo_value(f, "using_checksums");
2225 /* Get the module's kernel version in the canonical integer form. */
2228 new_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
2233 p = get_modinfo_value(f, "kernel_version");
2236 strncpy(str, p, STRVERSIONLEN);
2238 a = strtoul(p, &p, 10);
2241 b = strtoul(p + 1, &p, 10);
2244 c = strtoul(p + 1, &q, 10);
2248 return a << 16 | b << 8 | c;
2251 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
2254 #ifdef BB_FEATURE_NEW_MODULE_INTERFACE
2256 /* Fetch the loaded modules, and all currently exported symbols. */
2258 static int new_get_kernel_symbols(void)
2260 char *module_names, *mn;
2261 struct external_module *modules, *m;
2262 struct new_module_symbol *syms, *s;
2263 size_t ret, bufsize, nmod, nsyms, i, j;
2265 /* Collect the loaded modules. */
2267 module_names = xmalloc(bufsize = 256);
2269 if (query_module(NULL, QM_MODULES, module_names, bufsize, &ret)) {
2270 if (errno == ENOSPC && bufsize < ret) {
2271 module_names = xrealloc(module_names, bufsize = ret);
2272 goto retry_modules_load;
2274 perror_msg("QM_MODULES");
2278 n_ext_modules = nmod = ret;
2280 /* Collect the modules' symbols. */
2283 ext_modules = modules = xmalloc(nmod * sizeof(*modules));
2284 memset(modules, 0, nmod * sizeof(*modules));
2285 for (i = 0, mn = module_names, m = modules;
2286 i < nmod; ++i, ++m, mn += strlen(mn) + 1) {
2287 struct new_module_info info;
2289 if (query_module(mn, QM_INFO, &info, sizeof(info), &ret)) {
2290 if (errno == ENOENT) {
2291 /* The module was removed out from underneath us. */
2294 perror_msg("query_module: QM_INFO: %s", mn);
2298 syms = xmalloc(bufsize = 1024);
2300 if (query_module(mn, QM_SYMBOLS, syms, bufsize, &ret)) {
2303 syms = xrealloc(syms, bufsize = ret);
2304 goto retry_mod_sym_load;
2306 /* The module was removed out from underneath us. */
2309 perror_msg("query_module: QM_SYMBOLS: %s", mn);
2316 m->addr = info.addr;
2320 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2321 s->name += (unsigned long) syms;
2326 /* Collect the kernel's symbols. */
2328 syms = xmalloc(bufsize = 16 * 1024);
2329 retry_kern_sym_load:
2330 if (query_module(NULL, QM_SYMBOLS, syms, bufsize, &ret)) {
2331 if (errno == ENOSPC && bufsize < ret) {
2332 syms = xrealloc(syms, bufsize = ret);
2333 goto retry_kern_sym_load;
2335 perror_msg("kernel: QM_SYMBOLS");
2338 nksyms = nsyms = ret;
2341 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2342 s->name += (unsigned long) syms;
2348 /* Return the kernel symbol checksum version, or zero if not used. */
2350 static int new_is_kernel_checksummed(void)
2352 struct new_module_symbol *s;
2355 /* Using_Versions is not the first symbol, but it should be in there. */
2357 for (i = 0, s = ksyms; i < nksyms; ++i, ++s)
2358 if (strcmp((char *) s->name, "Using_Versions") == 0)
2365 static int new_create_this_module(struct obj_file *f, const char *m_name)
2367 struct obj_section *sec;
2369 sec = obj_create_alloced_section_first(f, ".this", tgt_sizeof_long,
2370 sizeof(struct new_module));
2371 memset(sec->contents, 0, sizeof(struct new_module));
2373 obj_add_symbol(f, "__this_module", -1,
2374 ELFW(ST_INFO) (STB_LOCAL, STT_OBJECT), sec->idx, 0,
2375 sizeof(struct new_module));
2377 obj_string_patch(f, sec->idx, offsetof(struct new_module, name),
2384 static int new_create_module_ksymtab(struct obj_file *f)
2386 struct obj_section *sec;
2389 /* We must always add the module references. */
2391 if (n_ext_modules_used) {
2392 struct new_module_ref *dep;
2393 struct obj_symbol *tm;
2395 sec = obj_create_alloced_section(f, ".kmodtab", tgt_sizeof_void_p,
2396 (sizeof(struct new_module_ref)
2397 * n_ext_modules_used));
2401 tm = obj_find_symbol(f, "__this_module");
2402 dep = (struct new_module_ref *) sec->contents;
2403 for (i = 0; i < n_ext_modules; ++i)
2404 if (ext_modules[i].used) {
2405 dep->dep = ext_modules[i].addr;
2406 obj_symbol_patch(f, sec->idx,
2407 (char *) &dep->ref - sec->contents, tm);
2413 if (flag_export && !obj_find_section(f, "__ksymtab")) {
2418 obj_create_alloced_section(f, "__ksymtab", tgt_sizeof_void_p,
2421 /* We don't want to export symbols residing in sections that
2422 aren't loaded. There are a number of these created so that
2423 we make sure certain module options don't appear twice. */
2425 loaded = alloca(sizeof(int) * (i = f->header.e_shnum));
2427 loaded[i] = (f->sections[i]->header.sh_flags & SHF_ALLOC) != 0;
2429 for (nsyms = i = 0; i < HASH_BUCKETS; ++i) {
2430 struct obj_symbol *sym;
2431 for (sym = f->symtab[i]; sym; sym = sym->next)
2432 if (ELFW(ST_BIND) (sym->info) != STB_LOCAL
2433 && sym->secidx <= SHN_HIRESERVE
2434 && (sym->secidx >= SHN_LORESERVE
2435 || loaded[sym->secidx])) {
2436 ElfW(Addr) ofs = nsyms * 2 * tgt_sizeof_void_p;
2438 obj_symbol_patch(f, sec->idx, ofs, sym);
2439 obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p,
2446 obj_extend_section(sec, nsyms * 2 * tgt_sizeof_char_p);
2454 new_init_module(const char *m_name, struct obj_file *f,
2455 unsigned long m_size)
2457 struct new_module *module;
2458 struct obj_section *sec;
2463 sec = obj_find_section(f, ".this");
2464 if (!sec || !sec->contents) {
2465 perror_msg_and_die("corrupt module %s?",m_name);
2467 module = (struct new_module *) sec->contents;
2468 m_addr = sec->header.sh_addr;
2470 module->size_of_struct = sizeof(*module);
2471 module->size = m_size;
2472 module->flags = flag_autoclean ? NEW_MOD_AUTOCLEAN : 0;
2474 sec = obj_find_section(f, "__ksymtab");
2475 if (sec && sec->header.sh_size) {
2476 module->syms = sec->header.sh_addr;
2477 module->nsyms = sec->header.sh_size / (2 * tgt_sizeof_char_p);
2480 if (n_ext_modules_used) {
2481 sec = obj_find_section(f, ".kmodtab");
2482 module->deps = sec->header.sh_addr;
2483 module->ndeps = n_ext_modules_used;
2487 obj_symbol_final_value(f, obj_find_symbol(f, "init_module"));
2489 obj_symbol_final_value(f, obj_find_symbol(f, "cleanup_module"));
2491 sec = obj_find_section(f, "__ex_table");
2493 module->ex_table_start = sec->header.sh_addr;
2494 module->ex_table_end = sec->header.sh_addr + sec->header.sh_size;
2497 sec = obj_find_section(f, ".text.init");
2499 module->runsize = sec->header.sh_addr - m_addr;
2501 sec = obj_find_section(f, ".data.init");
2503 if (!module->runsize ||
2504 module->runsize > sec->header.sh_addr - m_addr)
2505 module->runsize = sec->header.sh_addr - m_addr;
2508 if (!arch_init_module(f, module))
2511 /* Whew! All of the initialization is complete. Collect the final
2512 module image and give it to the kernel. */
2514 image = xmalloc(m_size);
2515 obj_create_image(f, image);
2517 ret = new_sys_init_module(m_name, (struct new_module *) image);
2519 perror_msg("init_module: %s", m_name);
2528 #define new_init_module(x, y, z) TRUE
2529 #define new_create_this_module(x, y) 0
2530 #define new_create_module_ksymtab(x)
2531 #define query_module(v, w, x, y, z) -1
2533 #endif /* BB_FEATURE_NEW_MODULE_INTERFACE */
2536 /*======================================================================*/
2539 obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2542 struct obj_string_patch *p;
2543 struct obj_section *strsec;
2544 size_t len = strlen(string) + 1;
2547 p = xmalloc(sizeof(*p));
2548 p->next = f->string_patches;
2549 p->reloc_secidx = secidx;
2550 p->reloc_offset = offset;
2551 f->string_patches = p;
2553 strsec = obj_find_section(f, ".kstrtab");
2554 if (strsec == NULL) {
2555 strsec = obj_create_alloced_section(f, ".kstrtab", 1, len);
2556 p->string_offset = 0;
2557 loc = strsec->contents;
2559 p->string_offset = strsec->header.sh_size;
2560 loc = obj_extend_section(strsec, len);
2562 memcpy(loc, string, len);
2568 obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2569 struct obj_symbol *sym)
2571 struct obj_symbol_patch *p;
2573 p = xmalloc(sizeof(*p));
2574 p->next = f->symbol_patches;
2575 p->reloc_secidx = secidx;
2576 p->reloc_offset = offset;
2578 f->symbol_patches = p;
2583 int obj_check_undefineds(struct obj_file *f)
2588 for (i = 0; i < HASH_BUCKETS; ++i) {
2589 struct obj_symbol *sym;
2590 for (sym = f->symtab[i]; sym; sym = sym->next)
2591 if (sym->secidx == SHN_UNDEF) {
2592 if (ELFW(ST_BIND) (sym->info) == STB_WEAK) {
2593 sym->secidx = SHN_ABS;
2596 error_msg("unresolved symbol %s", sym->name);
2605 void obj_allocate_commons(struct obj_file *f)
2607 struct common_entry {
2608 struct common_entry *next;
2609 struct obj_symbol *sym;
2610 } *common_head = NULL;
2614 for (i = 0; i < HASH_BUCKETS; ++i) {
2615 struct obj_symbol *sym;
2616 for (sym = f->symtab[i]; sym; sym = sym->next)
2617 if (sym->secidx == SHN_COMMON) {
2618 /* Collect all COMMON symbols and sort them by size so as to
2619 minimize space wasted by alignment requirements. */
2621 struct common_entry **p, *n;
2622 for (p = &common_head; *p; p = &(*p)->next)
2623 if (sym->size <= (*p)->sym->size)
2626 n = alloca(sizeof(*n));
2634 for (i = 1; i < f->local_symtab_size; ++i) {
2635 struct obj_symbol *sym = f->local_symtab[i];
2636 if (sym && sym->secidx == SHN_COMMON) {
2637 struct common_entry **p, *n;
2638 for (p = &common_head; *p; p = &(*p)->next)
2639 if (sym == (*p)->sym)
2641 else if (sym->size < (*p)->sym->size) {
2642 n = alloca(sizeof(*n));
2652 /* Find the bss section. */
2653 for (i = 0; i < f->header.e_shnum; ++i)
2654 if (f->sections[i]->header.sh_type == SHT_NOBITS)
2657 /* If for some reason there hadn't been one, create one. */
2658 if (i == f->header.e_shnum) {
2659 struct obj_section *sec;
2661 f->sections = xrealloc(f->sections, (i + 1) * sizeof(sec));
2662 f->sections[i] = sec = arch_new_section();
2663 f->header.e_shnum = i + 1;
2665 memset(sec, 0, sizeof(*sec));
2666 sec->header.sh_type = SHT_PROGBITS;
2667 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2672 /* Allocate the COMMONS. */
2674 ElfW(Addr) bss_size = f->sections[i]->header.sh_size;
2675 ElfW(Addr) max_align = f->sections[i]->header.sh_addralign;
2676 struct common_entry *c;
2678 for (c = common_head; c; c = c->next) {
2679 ElfW(Addr) align = c->sym->value;
2681 if (align > max_align)
2683 if (bss_size & (align - 1))
2684 bss_size = (bss_size | (align - 1)) + 1;
2687 c->sym->value = bss_size;
2689 bss_size += c->sym->size;
2692 f->sections[i]->header.sh_size = bss_size;
2693 f->sections[i]->header.sh_addralign = max_align;
2697 /* For the sake of patch relocation and parameter initialization,
2698 allocate zeroed data for NOBITS sections now. Note that after
2699 this we cannot assume NOBITS are really empty. */
2700 for (i = 0; i < f->header.e_shnum; ++i) {
2701 struct obj_section *s = f->sections[i];
2702 if (s->header.sh_type == SHT_NOBITS) {
2703 if (s->header.sh_size != 0)
2704 s->contents = memset(xmalloc(s->header.sh_size),
2705 0, s->header.sh_size);
2709 s->header.sh_type = SHT_PROGBITS;
2714 unsigned long obj_load_size(struct obj_file *f)
2716 unsigned long dot = 0;
2717 struct obj_section *sec;
2719 /* Finalize the positions of the sections relative to one another. */
2721 for (sec = f->load_order; sec; sec = sec->load_next) {
2724 align = sec->header.sh_addralign;
2725 if (align && (dot & (align - 1)))
2726 dot = (dot | (align - 1)) + 1;
2728 sec->header.sh_addr = dot;
2729 dot += sec->header.sh_size;
2735 int obj_relocate(struct obj_file *f, ElfW(Addr) base)
2737 int i, n = f->header.e_shnum;
2740 /* Finalize the addresses of the sections. */
2743 for (i = 0; i < n; ++i)
2744 f->sections[i]->header.sh_addr += base;
2746 /* And iterate over all of the relocations. */
2748 for (i = 0; i < n; ++i) {
2749 struct obj_section *relsec, *symsec, *targsec, *strsec;
2750 ElfW(RelM) * rel, *relend;
2754 relsec = f->sections[i];
2755 if (relsec->header.sh_type != SHT_RELM)
2758 symsec = f->sections[relsec->header.sh_link];
2759 targsec = f->sections[relsec->header.sh_info];
2760 strsec = f->sections[symsec->header.sh_link];
2762 rel = (ElfW(RelM) *) relsec->contents;
2763 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
2764 symtab = (ElfW(Sym) *) symsec->contents;
2765 strtab = (const char *) strsec->contents;
2767 for (; rel < relend; ++rel) {
2768 ElfW(Addr) value = 0;
2769 struct obj_symbol *intsym = NULL;
2770 unsigned long symndx;
2771 ElfW(Sym) * extsym = 0;
2774 /* Attempt to find a value to use for this relocation. */
2776 symndx = ELFW(R_SYM) (rel->r_info);
2778 /* Note we've already checked for undefined symbols. */
2780 extsym = &symtab[symndx];
2781 if (ELFW(ST_BIND) (extsym->st_info) == STB_LOCAL) {
2782 /* Local symbols we look up in the local table to be sure
2783 we get the one that is really intended. */
2784 intsym = f->local_symtab[symndx];
2786 /* Others we look up in the hash table. */
2788 if (extsym->st_name)
2789 name = strtab + extsym->st_name;
2791 name = f->sections[extsym->st_shndx]->name;
2792 intsym = obj_find_symbol(f, name);
2795 value = obj_symbol_final_value(f, intsym);
2796 intsym->referenced = 1;
2798 #if SHT_RELM == SHT_RELA
2799 #if defined(__alpha__) && defined(AXP_BROKEN_GAS)
2800 /* Work around a nasty GAS bug, that is fixed as of 2.7.0.9. */
2801 if (!extsym || !extsym->st_name ||
2802 ELFW(ST_BIND) (extsym->st_info) != STB_LOCAL)
2804 value += rel->r_addend;
2808 switch (arch_apply_relocation
2809 (f, targsec, symsec, intsym, rel, value)) {
2813 case obj_reloc_overflow:
2814 errmsg = "Relocation overflow";
2816 case obj_reloc_dangerous:
2817 errmsg = "Dangerous relocation";
2819 case obj_reloc_unhandled:
2820 errmsg = "Unhandled relocation";
2823 error_msg("%s of type %ld for %s", errmsg,
2824 (long) ELFW(R_TYPE) (rel->r_info),
2825 strtab + extsym->st_name);
2827 error_msg("%s of type %ld", errmsg,
2828 (long) ELFW(R_TYPE) (rel->r_info));
2836 /* Finally, take care of the patches. */
2838 if (f->string_patches) {
2839 struct obj_string_patch *p;
2840 struct obj_section *strsec;
2841 ElfW(Addr) strsec_base;
2842 strsec = obj_find_section(f, ".kstrtab");
2843 strsec_base = strsec->header.sh_addr;
2845 for (p = f->string_patches; p; p = p->next) {
2846 struct obj_section *targsec = f->sections[p->reloc_secidx];
2847 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
2848 = strsec_base + p->string_offset;
2852 if (f->symbol_patches) {
2853 struct obj_symbol_patch *p;
2855 for (p = f->symbol_patches; p; p = p->next) {
2856 struct obj_section *targsec = f->sections[p->reloc_secidx];
2857 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
2858 = obj_symbol_final_value(f, p->sym);
2865 int obj_create_image(struct obj_file *f, char *image)
2867 struct obj_section *sec;
2868 ElfW(Addr) base = f->baseaddr;
2870 for (sec = f->load_order; sec; sec = sec->load_next) {
2873 if (sec->contents == 0 || sec->header.sh_size == 0)
2876 secimg = image + (sec->header.sh_addr - base);
2878 /* Note that we allocated data for NOBITS sections earlier. */
2879 memcpy(secimg, sec->contents, sec->header.sh_size);
2885 /*======================================================================*/
2887 struct obj_file *obj_load(FILE * fp)
2890 ElfW(Shdr) * section_headers;
2894 /* Read the file header. */
2896 f = arch_new_file();
2897 memset(f, 0, sizeof(*f));
2898 f->symbol_cmp = strcmp;
2899 f->symbol_hash = obj_elf_hash;
2900 f->load_order_search_start = &f->load_order;
2902 fseek(fp, 0, SEEK_SET);
2903 if (fread(&f->header, sizeof(f->header), 1, fp) != 1) {
2904 perror_msg("error reading ELF header");
2908 if (f->header.e_ident[EI_MAG0] != ELFMAG0
2909 || f->header.e_ident[EI_MAG1] != ELFMAG1
2910 || f->header.e_ident[EI_MAG2] != ELFMAG2
2911 || f->header.e_ident[EI_MAG3] != ELFMAG3) {
2912 error_msg("not an ELF file");
2915 if (f->header.e_ident[EI_CLASS] != ELFCLASSM
2916 || f->header.e_ident[EI_DATA] != ELFDATAM
2917 || f->header.e_ident[EI_VERSION] != EV_CURRENT
2918 || !MATCH_MACHINE(f->header.e_machine)) {
2919 error_msg("ELF file not for this architecture");
2922 if (f->header.e_type != ET_REL) {
2923 error_msg("ELF file not a relocatable object");
2927 /* Read the section headers. */
2929 if (f->header.e_shentsize != sizeof(ElfW(Shdr))) {
2930 error_msg("section header size mismatch: %lu != %lu",
2931 (unsigned long) f->header.e_shentsize,
2932 (unsigned long) sizeof(ElfW(Shdr)));
2936 shnum = f->header.e_shnum;
2937 f->sections = xmalloc(sizeof(struct obj_section *) * shnum);
2938 memset(f->sections, 0, sizeof(struct obj_section *) * shnum);
2940 section_headers = alloca(sizeof(ElfW(Shdr)) * shnum);
2941 fseek(fp, f->header.e_shoff, SEEK_SET);
2942 if (fread(section_headers, sizeof(ElfW(Shdr)), shnum, fp) != shnum) {
2943 perror_msg("error reading ELF section headers");
2947 /* Read the section data. */
2949 for (i = 0; i < shnum; ++i) {
2950 struct obj_section *sec;
2952 f->sections[i] = sec = arch_new_section();
2953 memset(sec, 0, sizeof(*sec));
2955 sec->header = section_headers[i];
2958 if(sec->header.sh_size) switch (sec->header.sh_type) {
2969 if (sec->header.sh_size > 0) {
2970 sec->contents = xmalloc(sec->header.sh_size);
2971 fseek(fp, sec->header.sh_offset, SEEK_SET);
2972 if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
2973 perror_msg("error reading ELF section data");
2977 sec->contents = NULL;
2981 #if SHT_RELM == SHT_REL
2983 error_msg("RELA relocations not supported on this architecture");
2987 error_msg("REL relocations not supported on this architecture");
2992 if (sec->header.sh_type >= SHT_LOPROC) {
2993 /* Assume processor specific section types are debug
2994 info and can safely be ignored. If this is ever not
2995 the case (Hello MIPS?), don't put ifdefs here but
2996 create an arch_load_proc_section(). */
3000 error_msg("can't handle sections of type %ld",
3001 (long) sec->header.sh_type);
3006 /* Do what sort of interpretation as needed by each section. */
3008 shstrtab = f->sections[f->header.e_shstrndx]->contents;
3010 for (i = 0; i < shnum; ++i) {
3011 struct obj_section *sec = f->sections[i];
3012 sec->name = shstrtab + sec->header.sh_name;
3015 for (i = 0; i < shnum; ++i) {
3016 struct obj_section *sec = f->sections[i];
3018 /* .modinfo should be contents only but gcc has no attribute for that.
3019 * The kernel may have marked .modinfo as ALLOC, ignore this bit.
3021 if (strcmp(sec->name, ".modinfo") == 0)
3022 sec->header.sh_flags &= ~SHF_ALLOC;
3024 if (sec->header.sh_flags & SHF_ALLOC)
3025 obj_insert_section_load_order(f, sec);
3027 switch (sec->header.sh_type) {
3030 unsigned long nsym, j;
3034 if (sec->header.sh_entsize != sizeof(ElfW(Sym))) {
3035 error_msg("symbol size mismatch: %lu != %lu",
3036 (unsigned long) sec->header.sh_entsize,
3037 (unsigned long) sizeof(ElfW(Sym)));
3041 nsym = sec->header.sh_size / sizeof(ElfW(Sym));
3042 strtab = f->sections[sec->header.sh_link]->contents;
3043 sym = (ElfW(Sym) *) sec->contents;
3045 /* Allocate space for a table of local symbols. */
3046 j = f->local_symtab_size = sec->header.sh_info;
3047 f->local_symtab = xcalloc(j, sizeof(struct obj_symbol *));
3049 /* Insert all symbols into the hash table. */
3050 for (j = 1, ++sym; j < nsym; ++j, ++sym) {
3053 name = strtab + sym->st_name;
3055 name = f->sections[sym->st_shndx]->name;
3057 obj_add_symbol(f, name, j, sym->st_info, sym->st_shndx,
3058 sym->st_value, sym->st_size);
3064 if (sec->header.sh_entsize != sizeof(ElfW(RelM))) {
3065 error_msg("relocation entry size mismatch: %lu != %lu",
3066 (unsigned long) sec->header.sh_entsize,
3067 (unsigned long) sizeof(ElfW(RelM)));
3071 /* XXX Relocation code from modutils-2.3.19 is not here.
3072 * Why? That's about 20 lines of code from obj/obj_load.c,
3073 * which gets done in a second pass through the sections.
3074 * This BusyBox insmod does similar work in obj_relocate(). */
3081 static void hide_special_symbols(struct obj_file *f)
3083 static const char *const specials[] = {
3090 struct obj_symbol *sym;
3091 const char *const *p;
3093 for (p = specials; *p; ++p)
3094 if ((sym = obj_find_symbol(f, *p)) != NULL)
3096 ELFW(ST_INFO) (STB_LOCAL, ELFW(ST_TYPE) (sym->info));
3101 extern int insmod_main( int argc, char **argv)
3108 unsigned long m_size;
3113 char m_name[FILENAME_MAX + 1] = "\0";
3114 int exit_status = EXIT_FAILURE;
3116 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
3118 char k_strversion[STRVERSIONLEN];
3119 char m_strversion[STRVERSIONLEN];
3124 /* Parse any options */
3125 while ((opt = getopt(argc, argv, "fkvxLo:")) > 0) {
3127 case 'f': /* force loading */
3128 flag_force_load = 1;
3130 case 'k': /* module loaded by kerneld, auto-cleanable */
3133 case 'v': /* verbose output */
3136 case 'x': /* do not export externs */
3139 case 'o': /* name the output module */
3140 strncpy(m_name, optarg, FILENAME_MAX);
3142 case 'L': /* Stub warning */
3143 /* This is needed for compatibility with modprobe.
3144 * In theory, this does locking, but we don't do
3145 * that. So be careful and plan your life around not
3146 * loading the same module 50 times concurrently. */
3153 if (argv[optind] == NULL) {
3157 /* Grab the module name */
3158 if ((tmp = strrchr(argv[optind], '/')) != NULL) {
3165 if (len > 2 && tmp[len - 2] == '.' && tmp[len - 1] == 'o')
3167 memcpy(m_fullName, tmp, len);
3168 m_fullName[len]='\0';
3169 if (*m_name == '\0') {
3170 strcpy(m_name, m_fullName);
3172 strcat(m_fullName, ".o");
3174 /* Get a filedesc for the module. Check we we have a complete path */
3175 if (stat(argv[optind], &st) < 0 || !S_ISREG(st.st_mode) ||
3176 (fp = fopen(argv[optind], "r")) == NULL) {
3177 struct utsname myuname;
3179 /* Hmm. Could not open it. First search under /lib/modules/`uname -r`,
3180 * but do not error out yet if we fail to find it... */
3181 if (uname(&myuname) == 0) {
3182 char module_dir[FILENAME_MAX];
3183 snprintf (module_dir, sizeof(module_dir), "%s/%s",
3184 _PATH_MODULES, myuname.release);
3185 recursive_action(module_dir, TRUE, FALSE, FALSE,
3186 check_module_name_match, 0, m_fullName);
3189 /* Check if we have found anything yet */
3190 if (m_filename[0] == '\0' || ((fp = fopen(m_filename, "r")) == NULL))
3192 /* No module found under /lib/modules/`uname -r`, this
3193 * time cast the net a bit wider. Search /lib/modules/ */
3194 if (recursive_action(_PATH_MODULES, TRUE, FALSE, FALSE,
3195 check_module_name_match, 0, m_fullName) == FALSE)
3197 if (m_filename[0] == '\0'
3198 || ((fp = fopen(m_filename, "r")) == NULL))
3200 error_msg("%s: no module by that name found", m_fullName);
3201 return EXIT_FAILURE;
3204 error_msg_and_die("%s: no module by that name found", m_fullName);
3207 safe_strncpy(m_filename, argv[optind], sizeof(m_filename));
3209 printf("Using %s\n", m_filename);
3211 if ((f = obj_load(fp)) == NULL)
3212 perror_msg_and_die("Could not load the module");
3214 if (get_modinfo_value(f, "kernel_version") == NULL)
3219 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
3220 /* Version correspondence? */
3222 k_version = get_kernel_version(k_strversion);
3223 if (m_has_modinfo) {
3224 m_version = new_get_module_version(f, m_strversion);
3226 m_version = old_get_module_version(f, m_strversion);
3227 if (m_version == -1) {
3228 error_msg("couldn't find the kernel version the module was "
3234 if (strncmp(k_strversion, m_strversion, STRVERSIONLEN) != 0) {
3235 if (flag_force_load) {
3236 error_msg("Warning: kernel-module version mismatch\n"
3237 "\t%s was compiled for kernel version %s\n"
3238 "\twhile this kernel is version %s",
3239 m_filename, m_strversion, k_strversion);
3241 error_msg("kernel-module version mismatch\n"
3242 "\t%s was compiled for kernel version %s\n"
3243 "\twhile this kernel is version %s.",
3244 m_filename, m_strversion, k_strversion);
3249 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
3251 k_new_syscalls = !query_module(NULL, 0, NULL, 0, NULL);
3253 if (k_new_syscalls) {
3254 #ifdef BB_FEATURE_NEW_MODULE_INTERFACE
3255 if (!new_get_kernel_symbols())
3257 k_crcs = new_is_kernel_checksummed();
3259 error_msg("Not configured to support new kernels");
3263 #ifdef BB_FEATURE_OLD_MODULE_INTERFACE
3264 if (!old_get_kernel_symbols(m_name))
3266 k_crcs = old_is_kernel_checksummed();
3268 error_msg("Not configured to support old kernels");
3273 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
3275 m_crcs = new_is_module_checksummed(f);
3277 m_crcs = old_is_module_checksummed(f);
3279 if (m_crcs != k_crcs)
3280 obj_set_symbol_compare(f, ncv_strcmp, ncv_symbol_hash);
3281 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
3283 /* Let the module know about the kernel symbols. */
3284 add_kernel_symbols(f);
3286 /* Allocate common symbols, symbol tables, and string tables. */
3289 ? !new_create_this_module(f, m_name)
3290 : !old_create_mod_use_count(f))
3295 if (!obj_check_undefineds(f)) {
3298 obj_allocate_commons(f);
3300 /* done with the module name, on to the optional var=value arguments */
3303 if (optind < argc) {
3305 ? !new_process_module_arguments(f, argc - optind, argv + optind)
3306 : !old_process_module_arguments(f, argc - optind, argv + optind))
3313 hide_special_symbols(f);
3316 new_create_module_ksymtab(f);
3318 /* Find current size of the module */
3319 m_size = obj_load_size(f);
3322 m_addr = create_module(m_name, m_size);
3323 if (m_addr==-1) switch (errno) {
3325 error_msg("A module named %s already exists", m_name);
3328 error_msg("Can't allocate kernel memory for module; needed %lu bytes",
3332 perror_msg("create_module: %s", m_name);
3336 if (!obj_relocate(f, m_addr)) {
3337 delete_module(m_name);
3342 ? !new_init_module(m_name, f, m_size)
3343 : !old_init_module(m_name, f, m_size))
3345 delete_module(m_name);
3349 exit_status = EXIT_SUCCESS;
3353 return(exit_status);