1 /* vi: set sw=4 ts=4: */
3 * Mini insmod implementation for busybox
5 * Copyright (C) 1999,2000,2001 by Lineo, inc.
6 * Written by Erik Andersen <andersen@lineo.com>
7 * and Ron Alder <alder@lineo.com>
9 * Modified by Bryan Rittmeyer <bryan@ixiacom.com> to support SH4
10 * and (theoretically) SH3. I have only tested SH4 in little endian mode.
12 * Modified by Alcove, Julien Gaulmin <julien.gaulmin@alcove.fr> and
13 * Nicolas Ferre <nicolas.ferre@alcove.fr> to support ARM7TDMI. Only
14 * very minor changes required to also work with StrongArm and presumably
15 * all ARM based systems.
17 * Based almost entirely on the Linux modutils-2.3.11 implementation.
18 * Copyright 1996, 1997 Linux International.
19 * New implementation contributed by Richard Henderson <rth@tamu.edu>
20 * Based on original work by Bjorn Ekwall <bj0rn@blox.se>
21 * Restructured (and partly rewritten) by:
22 * Björn Ekwall <bj0rn@blox.se> February 1999
24 * This program is free software; you can redistribute it and/or modify
25 * it under the terms of the GNU General Public License as published by
26 * the Free Software Foundation; either version 2 of the License, or
27 * (at your option) any later version.
29 * This program is distributed in the hope that it will be useful,
30 * but WITHOUT ANY WARRANTY; without even the implied warranty of
31 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
32 * General Public License for more details.
34 * You should have received a copy of the GNU General Public License
35 * along with this program; if not, write to the Free Software
36 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
50 #include <sys/utsname.h>
51 #include <sys/syscall.h>
52 #include <linux/unistd.h>
55 //----------------------------------------------------------------------------
56 //--------modutils module.h, lines 45-242
57 //----------------------------------------------------------------------------
59 /* Definitions for the Linux module syscall interface.
60 Copyright 1996, 1997 Linux International.
62 Contributed by Richard Henderson <rth@tamu.edu>
64 This file is part of the Linux modutils.
66 This program is free software; you can redistribute it and/or modify it
67 under the terms of the GNU General Public License as published by the
68 Free Software Foundation; either version 2 of the License, or (at your
69 option) any later version.
71 This program is distributed in the hope that it will be useful, but
72 WITHOUT ANY WARRANTY; without even the implied warranty of
73 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
74 General Public License for more details.
76 You should have received a copy of the GNU General Public License
77 along with this program; if not, write to the Free Software Foundation,
78 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
81 #ifndef MODUTILS_MODULE_H
82 static const int MODUTILS_MODULE_H = 1;
84 #ident "$Id: insmod.c,v 1.48 2001/02/20 06:14:07 andersen Exp $"
86 /* This file contains the structures used by the 2.0 and 2.1 kernels.
87 We do not use the kernel headers directly because we do not wish
88 to be dependant on a particular kernel version to compile insmod. */
91 /*======================================================================*/
92 /* The structures used by Linux 2.0. */
94 /* The symbol format used by get_kernel_syms(2). */
101 struct old_module_ref
103 unsigned long module; /* kernel addresses */
107 struct old_module_symbol
113 struct old_symbol_table
115 int size; /* total, including string table!!! */
118 struct old_module_symbol symbol[0]; /* actual size defined by n_symbols */
119 struct old_module_ref ref[0]; /* actual size defined by n_refs */
122 struct old_mod_routines
125 unsigned long cleanup;
131 unsigned long ref; /* the list of modules that refer to me */
132 unsigned long symtab;
134 int size; /* size of module in pages */
135 unsigned long addr; /* address of module */
137 unsigned long cleanup; /* cleanup routine */
140 /* Sent to init_module(2) or'ed into the code size parameter. */
141 static const int OLD_MOD_AUTOCLEAN = 0x40000000; /* big enough, but no sign problems... */
143 int get_kernel_syms(struct old_kernel_sym *);
144 int old_sys_init_module(const char *name, char *code, unsigned codesize,
145 struct old_mod_routines *, struct old_symbol_table *);
147 /*======================================================================*/
148 /* For sizeof() which are related to the module platform and not to the
149 environment isnmod is running in, use sizeof_xx instead of sizeof(xx). */
151 #define tgt_sizeof_char sizeof(char)
152 #define tgt_sizeof_short sizeof(short)
153 #define tgt_sizeof_int sizeof(int)
154 #define tgt_sizeof_long sizeof(long)
155 #define tgt_sizeof_char_p sizeof(char *)
156 #define tgt_sizeof_void_p sizeof(void *)
157 #define tgt_long long
159 #if defined(__sparc__) && !defined(__sparc_v9__) && defined(ARCH_sparc64)
160 #undef tgt_sizeof_long
161 #undef tgt_sizeof_char_p
162 #undef tgt_sizeof_void_p
164 static const int tgt_sizeof_long = 8;
165 static const int tgt_sizeof_char_p = 8;
166 static const int tgt_sizeof_void_p = 8;
167 #define tgt_long long long
170 /*======================================================================*/
171 /* The structures used in Linux 2.1. */
173 /* Note: new_module_symbol does not use tgt_long intentionally */
174 struct new_module_symbol
180 struct new_module_persist;
182 struct new_module_ref
184 unsigned tgt_long dep; /* kernel addresses */
185 unsigned tgt_long ref;
186 unsigned tgt_long next_ref;
191 unsigned tgt_long size_of_struct; /* == sizeof(module) */
192 unsigned tgt_long next;
193 unsigned tgt_long name;
194 unsigned tgt_long size;
197 unsigned tgt_long flags; /* AUTOCLEAN et al */
202 unsigned tgt_long syms;
203 unsigned tgt_long deps;
204 unsigned tgt_long refs;
205 unsigned tgt_long init;
206 unsigned tgt_long cleanup;
207 unsigned tgt_long ex_table_start;
208 unsigned tgt_long ex_table_end;
210 unsigned tgt_long gp;
212 /* Everything after here is extension. */
213 unsigned tgt_long persist_start;
214 unsigned tgt_long persist_end;
215 unsigned tgt_long can_unload;
216 unsigned tgt_long runsize;
219 struct new_module_info
227 /* Bits of module.flags. */
228 static const int NEW_MOD_RUNNING = 1;
229 static const int NEW_MOD_DELETED = 2;
230 static const int NEW_MOD_AUTOCLEAN = 4;
231 static const int NEW_MOD_VISITED = 8;
232 static const int NEW_MOD_USED_ONCE = 16;
234 int new_sys_init_module(const char *name, const struct new_module *);
235 int query_module(const char *name, int which, void *buf, size_t bufsize,
238 /* Values for query_module's which. */
240 static const int QM_MODULES = 1;
241 static const int QM_DEPS = 2;
242 static const int QM_REFS = 3;
243 static const int QM_SYMBOLS = 4;
244 static const int QM_INFO = 5;
246 /*======================================================================*/
247 /* The system calls unchanged between 2.0 and 2.1. */
249 unsigned long create_module(const char *, size_t);
250 int delete_module(const char *);
253 #endif /* module.h */
255 //----------------------------------------------------------------------------
256 //--------end of modutils module.h
257 //----------------------------------------------------------------------------
261 //----------------------------------------------------------------------------
262 //--------modutils obj.h, lines 253-462
263 //----------------------------------------------------------------------------
265 /* Elf object file loading and relocation routines.
266 Copyright 1996, 1997 Linux International.
268 Contributed by Richard Henderson <rth@tamu.edu>
270 This file is part of the Linux modutils.
272 This program is free software; you can redistribute it and/or modify it
273 under the terms of the GNU General Public License as published by the
274 Free Software Foundation; either version 2 of the License, or (at your
275 option) any later version.
277 This program is distributed in the hope that it will be useful, but
278 WITHOUT ANY WARRANTY; without even the implied warranty of
279 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
280 General Public License for more details.
282 You should have received a copy of the GNU General Public License
283 along with this program; if not, write to the Free Software Foundation,
284 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
287 #ifndef MODUTILS_OBJ_H
288 static const int MODUTILS_OBJ_H = 1;
290 #ident "$Id: insmod.c,v 1.48 2001/02/20 06:14:07 andersen Exp $"
292 /* The relocatable object is manipulated using elfin types. */
298 /* Machine-specific elf macros for i386 et al. */
300 /* the SH changes have only been tested on the SH4 in =little endian= mode */
301 /* I'm not sure about big endian, so let's warn: */
303 #if (defined(__SH4__) || defined(__SH3__)) && defined(__BIG_ENDIAN__)
304 #error insmod.c may require changes for use on big endian SH4/SH3
307 /* it may or may not work on the SH1/SH2... So let's error on those
309 #if (defined(__sh__) && (!(defined(__SH3__) || defined(__SH4__))))
310 #error insmod.c may require changes for non-SH3/SH4 use
313 #define ELFCLASSM ELFCLASS32
314 #define ELFDATAM ELFDATA2LSB
320 #define MATCH_MACHINE(x) (x == EM_SH)
321 #define SHT_RELM SHT_RELA
322 #define Elf32_RelM Elf32_Rela
324 #elif defined(__arm__)
326 #define MATCH_MACHINE(x) (x == EM_ARM)
327 #define SHT_RELM SHT_REL
328 #define Elf32_RelM Elf32_Rel
330 #elif defined(__i386__)
332 /* presumably we can use these for anything but the SH and ARM*/
333 /* this is the previous behavior, but it does result in
334 insmod.c being broken on anything except i386 */
336 #define MATCH_MACHINE(x) (x == EM_386)
338 #define MATCH_MACHINE(x) (x == EM_386 || x == EM_486)
341 #define SHT_RELM SHT_REL
342 #define Elf32_RelM Elf32_Rel
345 #error Sorry, but insmod.c does not yet support this architecture...
349 # if ELFCLASSM == ELFCLASS32
350 # define ElfW(x) Elf32_ ## x
351 # define ELFW(x) ELF32_ ## x
353 # define ElfW(x) Elf64_ ## x
354 # define ELFW(x) ELF64_ ## x
358 /* For some reason this is missing from libc5. */
359 #ifndef ELF32_ST_INFO
360 # define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
363 #ifndef ELF64_ST_INFO
364 # define ELF64_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
367 struct obj_string_patch;
368 struct obj_symbol_patch;
375 struct obj_section *load_next;
381 struct obj_symbol *next; /* hash table link */
385 int secidx; /* the defining section index/module */
387 int ksymidx; /* for export to the kernel symtab */
388 int referenced; /* actually used in the link */
391 /* Hardcode the hash table size. We shouldn't be needing so many
392 symbols that we begin to degrade performance, and we get a big win
393 by giving the compiler a constant divisor. */
395 #define HASH_BUCKETS 521
401 struct obj_section **sections;
402 struct obj_section *load_order;
403 struct obj_section **load_order_search_start;
404 struct obj_string_patch *string_patches;
405 struct obj_symbol_patch *symbol_patches;
406 int (*symbol_cmp)(const char *, const char *);
407 unsigned long (*symbol_hash)(const char *);
408 unsigned long local_symtab_size;
409 struct obj_symbol **local_symtab;
410 struct obj_symbol *symtab[HASH_BUCKETS];
421 struct obj_string_patch
423 struct obj_string_patch *next;
425 ElfW(Addr) reloc_offset;
426 ElfW(Addr) string_offset;
429 struct obj_symbol_patch
431 struct obj_symbol_patch *next;
433 ElfW(Addr) reloc_offset;
434 struct obj_symbol *sym;
438 /* Generic object manipulation routines. */
440 unsigned long obj_elf_hash(const char *);
442 unsigned long obj_elf_hash_n(const char *, unsigned long len);
444 struct obj_symbol *obj_add_symbol (struct obj_file *f, const char *name,
445 unsigned long symidx, int info, int secidx,
446 ElfW(Addr) value, unsigned long size);
448 struct obj_symbol *obj_find_symbol (struct obj_file *f,
451 ElfW(Addr) obj_symbol_final_value(struct obj_file *f,
452 struct obj_symbol *sym);
454 void obj_set_symbol_compare(struct obj_file *f,
455 int (*cmp)(const char *, const char *),
456 unsigned long (*hash)(const char *));
458 struct obj_section *obj_find_section (struct obj_file *f,
461 void obj_insert_section_load_order (struct obj_file *f,
462 struct obj_section *sec);
464 struct obj_section *obj_create_alloced_section (struct obj_file *f,
469 struct obj_section *obj_create_alloced_section_first (struct obj_file *f,
474 void *obj_extend_section (struct obj_section *sec, unsigned long more);
476 int obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
479 int obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
480 struct obj_symbol *sym);
482 int obj_check_undefineds(struct obj_file *f);
484 void obj_allocate_commons(struct obj_file *f);
486 unsigned long obj_load_size (struct obj_file *f);
488 int obj_relocate (struct obj_file *f, ElfW(Addr) base);
490 struct obj_file *obj_load(FILE *f);
492 int obj_create_image (struct obj_file *f, char *image);
494 /* Architecture specific manipulation routines. */
496 struct obj_file *arch_new_file (void);
498 struct obj_section *arch_new_section (void);
500 struct obj_symbol *arch_new_symbol (void);
502 enum obj_reloc arch_apply_relocation (struct obj_file *f,
503 struct obj_section *targsec,
504 struct obj_section *symsec,
505 struct obj_symbol *sym,
506 ElfW(RelM) *rel, ElfW(Addr) value);
508 int arch_create_got (struct obj_file *f);
511 int arch_init_module (struct obj_file *f, struct new_module *);
514 //----------------------------------------------------------------------------
515 //--------end of modutils obj.h
516 //----------------------------------------------------------------------------
522 #define _PATH_MODULES "/lib/modules"
523 static const int STRVERSIONLEN = 32;
525 /*======================================================================*/
527 int flag_force_load = 0;
528 int flag_autoclean = 0;
529 int flag_verbose = 0;
533 /*======================================================================*/
535 /* previously, these were named i386_* but since we could be
536 compiling for the sh, I've renamed them to the more general
537 arch_* These structures are the same between the x86 and SH,
538 and we can't support anything else right now anyway. In the
539 future maybe they should be #if defined'd */
548 int inited:1; /* has been set up */
552 struct arch_got_entry {
554 unsigned offset_done:1;
555 unsigned reloc_done:1;
559 struct obj_file root;
561 struct obj_section *plt;
563 struct obj_section *got;
567 struct obj_symbol root;
569 struct arm_plt_entry pltent;
571 struct arch_got_entry gotent;
575 struct external_module {
580 struct new_module_symbol *syms;
583 struct new_module_symbol *ksyms;
586 struct external_module *ext_modules;
588 int n_ext_modules_used;
592 /* Some firendly syscalls to cheer everyone's day... */
593 #define __NR_new_sys_init_module __NR_init_module
594 _syscall2(int, new_sys_init_module, const char *, name,
595 const struct new_module *, info)
596 #define __NR_old_sys_init_module __NR_init_module
597 _syscall5(int, old_sys_init_module, const char *, name, char *, code,
598 unsigned, codesize, struct old_mod_routines *, routines,
599 struct old_symbol_table *, symtab)
601 _syscall1(int, delete_module, const char *, name)
603 extern int delete_module(const char *);
606 /* This is kind of troublesome. See, we don't actually support
607 the m68k or the arm the same way we support i386 and (now)
608 sh. In doing my SH patch, I just assumed that whatever works
609 for i386 also works for m68k and arm since currently insmod.c
610 does nothing special for them. If this isn't true, the below
611 line is rather misleading IMHO, and someone should either
612 change it or add more proper architecture-dependent support
615 -- Bryan Rittmeyer <bryan@ixiacom.com> */
617 #ifdef BB_FEATURE_OLD_MODULE_INTERFACE
618 _syscall1(int, get_kernel_syms, struct old_kernel_sym *, ks)
621 #if defined(__i386__) || defined(__m68k__) || defined(__arm__)
622 /* Jump through hoops to fixup error return codes */
623 #define __NR__create_module __NR_create_module
624 static inline _syscall2(long, _create_module, const char *, name, size_t,
626 unsigned long create_module(const char *name, size_t size)
628 long ret = _create_module(name, size);
630 if (ret == -1 && errno > 125) {
637 _syscall2(unsigned long, create_module, const char *, name, size_t, size)
639 static char m_filename[BUFSIZ + 1] = "\0";
640 static char m_fullName[BUFSIZ + 1] = "\0";
642 /*======================================================================*/
645 static int findNamedModule(const char *fileName, struct stat *statbuf,
648 char *fullName = (char *) userDate;
651 if (fullName[0] == '\0')
654 char *tmp = strrchr((char *) fileName, '/');
657 tmp = (char *) fileName;
660 if (check_wildcard_match(tmp, fullName) == TRUE) {
661 /* Stop searching if we find a match */
662 memcpy(m_filename, fileName, strlen(fileName)+1);
670 /*======================================================================*/
672 struct obj_file *arch_new_file(void)
675 f = xmalloc(sizeof(*f));
680 struct obj_section *arch_new_section(void)
682 return xmalloc(sizeof(struct obj_section));
685 struct obj_symbol *arch_new_symbol(void)
687 struct arch_symbol *sym;
688 sym = xmalloc(sizeof(*sym));
689 memset(&sym->gotent, 0, sizeof(sym->gotent));
694 arch_apply_relocation(struct obj_file *f,
695 struct obj_section *targsec,
696 struct obj_section *symsec,
697 struct obj_symbol *sym,
698 ElfW(RelM) *rel, ElfW(Addr) v)
700 struct arch_file *ifile = (struct arch_file *) f;
701 struct arch_symbol *isym = (struct arch_symbol *) sym;
703 ElfW(Addr) *loc = (ElfW(Addr) *) (targsec->contents + rel->r_offset);
704 ElfW(Addr) dot = targsec->header.sh_addr + rel->r_offset;
705 ElfW(Addr) got = ifile->got ? ifile->got->header.sh_addr : 0;
707 ElfW(Addr) plt = ifile->plt ? ifile->plt->header.sh_addr : 0;
709 struct arm_plt_entry *pe;
713 enum obj_reloc ret = obj_reloc_ok;
715 switch (ELF32_R_TYPE(rel->r_info)) {
717 /* even though these constants seem to be the same for
718 the i386 and the sh, we "#if define" them for clarity
719 and in case that ever changes */
722 #elif defined(__arm__)
724 #elif defined(__i386__)
731 #elif defined(__arm__)
733 #elif defined(__i386__)
740 #elif defined(__sh__)
744 #elif defined(__i386__)
755 #elif defined(__arm__)
758 /* find the plt entry and initialize it if necessary */
759 assert(isym != NULL);
760 pe = (struct arm_plt_entry*) &isym->pltent;
762 ip = (unsigned long *) (ifile->plt->contents + pe->offset);
763 ip[0] = 0xe51ff004; /* ldr pc,[pc,#-4] */
764 ip[1] = v; /* sym@ */
768 /* relative distance to target */
770 /* if the target is too far away.... */
771 if ((int)v < -0x02000000 || (int)v >= 0x02000000) {
773 v = plt + pe->offset - dot;
776 ret = obj_reloc_dangerous;
778 /* Convert to words. */
781 /* merge the offset into the instruction. */
782 *loc = (*loc & ~0x00ffffff) | ((v + *loc) & 0x00ffffff);
784 #elif defined(__i386__)
789 #elif defined(__sh__)
794 #elif defined(__i386__)
802 #elif defined(__sh__)
804 *loc += f->baseaddr + rel->r_addend;
806 #elif defined(__i386__)
814 #elif defined(__arm__)
816 #elif defined(__i386__)
821 *loc += got - dot + rel->r_addend;;
822 #elif defined(__i386__) || defined(__arm__)
829 #elif defined(__arm__)
831 #elif defined(__i386__)
834 assert(isym != NULL);
835 /* needs an entry in the .got: set it, once */
836 if (!isym->gotent.reloc_done) {
837 isym->gotent.reloc_done = 1;
838 *(ElfW(Addr) *) (ifile->got->contents + isym->gotent.offset) = v;
840 /* make the reloc with_respect_to_.got */
842 *loc += isym->gotent.offset + rel->r_addend;
843 #elif defined(__i386__) || defined(__arm__)
844 *loc += isym->gotent.offset;
848 /* address relative to the got */
851 #elif defined(__arm__)
853 #elif defined(__i386__)
861 printf("Warning: unhandled reloc %d\n",(int)ELF32_R_TYPE(rel->r_info));
862 ret = obj_reloc_unhandled;
869 int arch_create_got(struct obj_file *f)
871 struct arch_file *ifile = (struct arch_file *) f;
872 int i, got_offset = 0, gotneeded = 0;
874 int plt_offset = 0, pltneeded = 0;
876 struct obj_section *relsec, *symsec, *strsec;
877 ElfW(RelM) *rel, *relend;
878 ElfW(Sym) *symtab, *extsym;
879 const char *strtab, *name;
880 struct arch_symbol *intsym;
882 for (i = 0; i < f->header.e_shnum; ++i) {
883 relsec = f->sections[i];
884 if (relsec->header.sh_type != SHT_RELM)
887 symsec = f->sections[relsec->header.sh_link];
888 strsec = f->sections[symsec->header.sh_link];
890 rel = (ElfW(RelM) *) relsec->contents;
891 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
892 symtab = (ElfW(Sym) *) symsec->contents;
893 strtab = (const char *) strsec->contents;
895 for (; rel < relend; ++rel) {
896 extsym = &symtab[ELF32_R_SYM(rel->r_info)];
898 switch (ELF32_R_TYPE(rel->r_info)) {
901 #elif defined(__sh__)
903 #elif defined(__i386__)
919 #elif defined(__sh__)
923 #elif defined(__i386__)
933 if (extsym->st_name != 0) {
934 name = strtab + extsym->st_name;
936 name = f->sections[extsym->st_shndx]->name;
938 intsym = (struct arch_symbol *) obj_find_symbol(f, name);
940 if (!intsym->gotent.offset_done) {
941 intsym->gotent.offset_done = 1;
942 intsym->gotent.offset = got_offset;
946 if (pltneeded && intsym->pltent.allocated == 0) {
947 intsym->pltent.allocated = 1;
948 intsym->pltent.offset = plt_offset;
950 intsym->pltent.inited = 0;
959 struct obj_section* relsec = obj_find_section(f, ".got");
962 obj_extend_section(relsec, got_offset);
964 relsec = obj_create_alloced_section(f, ".got", 8, got_offset);
972 ifile->plt = obj_create_alloced_section(f, ".plt", 8, plt_offset);
974 if (got_offset > 0 || gotneeded)
975 ifile->got = obj_create_alloced_section(f, ".got", 4, got_offset);
981 int arch_init_module(struct obj_file *f, struct new_module *mod)
987 /*======================================================================*/
989 /* Standard ELF hash function. */
990 inline unsigned long obj_elf_hash_n(const char *name, unsigned long n)
999 if ((g = (h & 0xf0000000)) != 0) {
1008 unsigned long obj_elf_hash(const char *name)
1010 return obj_elf_hash_n(name, strlen(name));
1013 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
1014 /* Get the kernel version in the canonical integer form. */
1016 static int get_kernel_version(char str[STRVERSIONLEN])
1018 struct utsname uts_info;
1022 if (uname(&uts_info) < 0)
1024 strncpy(str, uts_info.release, STRVERSIONLEN);
1025 p = uts_info.release;
1027 a = strtoul(p, &p, 10);
1030 b = strtoul(p + 1, &p, 10);
1033 c = strtoul(p + 1, &q, 10);
1037 return a << 16 | b << 8 | c;
1040 /* String comparison for non-co-versioned kernel and module. */
1042 static int ncv_strcmp(const char *a, const char *b)
1044 size_t alen = strlen(a), blen = strlen(b);
1046 if (blen == alen + 10 && b[alen] == '_' && b[alen + 1] == 'R')
1047 return strncmp(a, b, alen);
1048 else if (alen == blen + 10 && a[blen] == '_' && a[blen + 1] == 'R')
1049 return strncmp(a, b, blen);
1051 return strcmp(a, b);
1054 /* String hashing for non-co-versioned kernel and module. Here
1055 we are simply forced to drop the crc from the hash. */
1057 static unsigned long ncv_symbol_hash(const char *str)
1059 size_t len = strlen(str);
1060 if (len > 10 && str[len - 10] == '_' && str[len - 9] == 'R')
1062 return obj_elf_hash_n(str, len);
1066 obj_set_symbol_compare(struct obj_file *f,
1067 int (*cmp) (const char *, const char *),
1068 unsigned long (*hash) (const char *))
1071 f->symbol_cmp = cmp;
1073 struct obj_symbol *tmptab[HASH_BUCKETS], *sym, *next;
1076 f->symbol_hash = hash;
1078 memcpy(tmptab, f->symtab, sizeof(tmptab));
1079 memset(f->symtab, 0, sizeof(f->symtab));
1081 for (i = 0; i < HASH_BUCKETS; ++i)
1082 for (sym = tmptab[i]; sym; sym = next) {
1083 unsigned long h = hash(sym->name) % HASH_BUCKETS;
1085 sym->next = f->symtab[h];
1091 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
1094 struct obj_symbol *obj_add_symbol(struct obj_file *f, const char *name,
1095 unsigned long symidx, int info,
1096 int secidx, ElfW(Addr) value,
1099 struct obj_symbol *sym;
1100 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
1101 int n_type = ELFW(ST_TYPE) (info);
1102 int n_binding = ELFW(ST_BIND) (info);
1104 for (sym = f->symtab[hash]; sym; sym = sym->next)
1105 if (f->symbol_cmp(sym->name, name) == 0) {
1106 int o_secidx = sym->secidx;
1107 int o_info = sym->info;
1108 int o_type = ELFW(ST_TYPE) (o_info);
1109 int o_binding = ELFW(ST_BIND) (o_info);
1111 /* A redefinition! Is it legal? */
1113 if (secidx == SHN_UNDEF)
1115 else if (o_secidx == SHN_UNDEF)
1117 else if (n_binding == STB_GLOBAL && o_binding == STB_LOCAL) {
1118 /* Cope with local and global symbols of the same name
1119 in the same object file, as might have been created
1120 by ld -r. The only reason locals are now seen at this
1121 level at all is so that we can do semi-sensible things
1124 struct obj_symbol *nsym, **p;
1126 nsym = arch_new_symbol();
1127 nsym->next = sym->next;
1130 /* Excise the old (local) symbol from the hash chain. */
1131 for (p = &f->symtab[hash]; *p != sym; p = &(*p)->next)
1135 } else if (n_binding == STB_LOCAL) {
1136 /* Another symbol of the same name has already been defined.
1137 Just add this to the local table. */
1138 sym = arch_new_symbol();
1141 f->local_symtab[symidx] = sym;
1143 } else if (n_binding == STB_WEAK)
1145 else if (o_binding == STB_WEAK)
1147 /* Don't unify COMMON symbols with object types the programmer
1149 else if (secidx == SHN_COMMON
1150 && (o_type == STT_NOTYPE || o_type == STT_OBJECT))
1152 else if (o_secidx == SHN_COMMON
1153 && (n_type == STT_NOTYPE || n_type == STT_OBJECT))
1156 /* Don't report an error if the symbol is coming from
1157 the kernel or some external module. */
1158 if (secidx <= SHN_HIRESERVE)
1159 error_msg("%s multiply defined", name);
1164 /* Completely new symbol. */
1165 sym = arch_new_symbol();
1166 sym->next = f->symtab[hash];
1167 f->symtab[hash] = sym;
1170 if (ELFW(ST_BIND) (info) == STB_LOCAL)
1171 f->local_symtab[symidx] = sym;
1177 sym->secidx = secidx;
1183 struct obj_symbol *obj_find_symbol(struct obj_file *f, const char *name)
1185 struct obj_symbol *sym;
1186 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
1188 for (sym = f->symtab[hash]; sym; sym = sym->next)
1189 if (f->symbol_cmp(sym->name, name) == 0)
1196 obj_symbol_final_value(struct obj_file * f, struct obj_symbol * sym)
1199 if (sym->secidx >= SHN_LORESERVE)
1202 return sym->value + f->sections[sym->secidx]->header.sh_addr;
1204 /* As a special case, a NULL sym has value zero. */
1209 struct obj_section *obj_find_section(struct obj_file *f, const char *name)
1211 int i, n = f->header.e_shnum;
1213 for (i = 0; i < n; ++i)
1214 if (strcmp(f->sections[i]->name, name) == 0)
1215 return f->sections[i];
1220 static int obj_load_order_prio(struct obj_section *a)
1222 unsigned long af, ac;
1224 af = a->header.sh_flags;
1227 if (a->name[0] != '.' || strlen(a->name) != 10 ||
1228 strcmp(a->name + 5, ".init"))
1232 if (!(af & SHF_WRITE))
1234 if (af & SHF_EXECINSTR)
1236 if (a->header.sh_type != SHT_NOBITS)
1243 obj_insert_section_load_order(struct obj_file *f, struct obj_section *sec)
1245 struct obj_section **p;
1246 int prio = obj_load_order_prio(sec);
1247 for (p = f->load_order_search_start; *p; p = &(*p)->load_next)
1248 if (obj_load_order_prio(*p) < prio)
1250 sec->load_next = *p;
1254 struct obj_section *obj_create_alloced_section(struct obj_file *f,
1256 unsigned long align,
1259 int newidx = f->header.e_shnum++;
1260 struct obj_section *sec;
1262 f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
1263 f->sections[newidx] = sec = arch_new_section();
1265 memset(sec, 0, sizeof(*sec));
1266 sec->header.sh_type = SHT_PROGBITS;
1267 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
1268 sec->header.sh_size = size;
1269 sec->header.sh_addralign = align;
1273 sec->contents = xmalloc(size);
1275 obj_insert_section_load_order(f, sec);
1280 struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
1282 unsigned long align,
1285 int newidx = f->header.e_shnum++;
1286 struct obj_section *sec;
1288 f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
1289 f->sections[newidx] = sec = arch_new_section();
1291 memset(sec, 0, sizeof(*sec));
1292 sec->header.sh_type = SHT_PROGBITS;
1293 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
1294 sec->header.sh_size = size;
1295 sec->header.sh_addralign = align;
1299 sec->contents = xmalloc(size);
1301 sec->load_next = f->load_order;
1302 f->load_order = sec;
1303 if (f->load_order_search_start == &f->load_order)
1304 f->load_order_search_start = &sec->load_next;
1309 void *obj_extend_section(struct obj_section *sec, unsigned long more)
1311 unsigned long oldsize = sec->header.sh_size;
1312 sec->contents = xrealloc(sec->contents, sec->header.sh_size += more);
1313 return sec->contents + oldsize;
1318 /* Conditionally add the symbols from the given symbol set to the
1324 int idx, struct new_module_symbol *syms, size_t nsyms)
1326 struct new_module_symbol *s;
1330 for (i = 0, s = syms; i < nsyms; ++i, ++s) {
1332 /* Only add symbols that are already marked external. If we
1333 override locals we may cause problems for argument initialization.
1334 We will also create a false dependency on the module. */
1335 struct obj_symbol *sym;
1337 sym = obj_find_symbol(f, (char *) s->name);
1338 if (sym && !ELFW(ST_BIND) (sym->info) == STB_LOCAL) {
1339 sym = obj_add_symbol(f, (char *) s->name, -1,
1340 ELFW(ST_INFO) (STB_GLOBAL, STT_NOTYPE),
1342 /* Did our symbol just get installed? If so, mark the
1343 module as "used". */
1344 if (sym->secidx == idx)
1352 static void add_kernel_symbols(struct obj_file *f)
1354 struct external_module *m;
1357 /* Add module symbols first. */
1359 for (i = 0, m = ext_modules; i < n_ext_modules; ++i, ++m)
1361 && add_symbols_from(f, SHN_HIRESERVE + 2 + i, m->syms,
1362 m->nsyms)) m->used = 1, ++nused;
1364 n_ext_modules_used = nused;
1366 /* And finally the symbols from the kernel proper. */
1369 add_symbols_from(f, SHN_HIRESERVE + 1, ksyms, nksyms);
1372 static char *get_modinfo_value(struct obj_file *f, const char *key)
1374 struct obj_section *sec;
1375 char *p, *v, *n, *ep;
1376 size_t klen = strlen(key);
1378 sec = obj_find_section(f, ".modinfo");
1382 ep = p + sec->header.sh_size;
1385 n = strchr(p, '\0');
1387 if (p + klen == v && strncmp(p, key, klen) == 0)
1390 if (p + klen == n && strcmp(p, key) == 0)
1400 /*======================================================================*/
1401 /* Functions relating to module loading in pre 2.1 kernels. */
1404 old_process_module_arguments(struct obj_file *f, int argc, char **argv)
1408 struct obj_symbol *sym;
1412 if ((q = strchr(p, '=')) == NULL) {
1418 sym = obj_find_symbol(f, p);
1420 /* Also check that the parameter was not resolved from the kernel. */
1421 if (sym == NULL || sym->secidx > SHN_HIRESERVE) {
1422 error_msg("symbol for parameter %s not found", p);
1426 loc = (int *) (f->sections[sym->secidx]->contents + sym->value);
1428 /* Do C quoting if we begin with a ". */
1432 str = alloca(strlen(q));
1433 for (r = str, q++; *q != '"'; ++q, ++r) {
1435 error_msg("improperly terminated string argument for %s", p);
1437 } else if (*q == '\\')
1471 if (q[1] >= '0' && q[1] <= '7') {
1472 c = (c * 8) + *++q - '0';
1473 if (q[1] >= '0' && q[1] <= '7')
1474 c = (c * 8) + *++q - '0';
1487 obj_string_patch(f, sym->secidx, sym->value, str);
1488 } else if (*q >= '0' && *q <= '9') {
1490 *loc++ = strtoul(q, &q, 0);
1491 while (*q++ == ',');
1493 char *contents = f->sections[sym->secidx]->contents;
1494 char *loc = contents + sym->value;
1495 char *r; /* To search for commas */
1497 /* Break the string with comas */
1498 while ((r = strchr(q, ',')) != (char *) NULL) {
1500 obj_string_patch(f, sym->secidx, loc - contents, q);
1501 loc += sizeof(char *);
1506 obj_string_patch(f, sym->secidx, loc - contents, q);
1515 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
1516 static int old_is_module_checksummed(struct obj_file *f)
1518 return obj_find_symbol(f, "Using_Versions") != NULL;
1520 /* Get the module's kernel version in the canonical integer form. */
1523 old_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
1525 struct obj_symbol *sym;
1529 sym = obj_find_symbol(f, "kernel_version");
1533 p = f->sections[sym->secidx]->contents + sym->value;
1534 strncpy(str, p, STRVERSIONLEN);
1536 a = strtoul(p, &p, 10);
1539 b = strtoul(p + 1, &p, 10);
1542 c = strtoul(p + 1, &q, 10);
1546 return a << 16 | b << 8 | c;
1549 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
1551 #ifdef BB_FEATURE_OLD_MODULE_INTERFACE
1553 /* Fetch all the symbols and divvy them up as appropriate for the modules. */
1555 static int old_get_kernel_symbols(const char *m_name)
1557 struct old_kernel_sym *ks, *k;
1558 struct new_module_symbol *s;
1559 struct external_module *mod;
1560 int nks, nms, nmod, i;
1562 nks = get_kernel_syms(NULL);
1564 perror_msg("get_kernel_syms: %s", m_name);
1568 ks = k = xmalloc(nks * sizeof(*ks));
1570 if (get_kernel_syms(ks) != nks) {
1571 perror("inconsistency with get_kernel_syms -- is someone else "
1572 "playing with modules?");
1577 /* Collect the module information. */
1582 while (k->name[0] == '#' && k->name[1]) {
1583 struct old_kernel_sym *k2;
1584 struct new_module_symbol *s;
1586 /* Find out how many symbols this module has. */
1587 for (k2 = k + 1; k2->name[0] != '#'; ++k2)
1591 mod = xrealloc(mod, (++nmod + 1) * sizeof(*mod));
1592 mod[nmod].name = k->name + 1;
1593 mod[nmod].addr = k->value;
1595 mod[nmod].nsyms = nms;
1596 mod[nmod].syms = s = (nms ? xmalloc(nms * sizeof(*s)) : NULL);
1598 for (i = 0, ++k; i < nms; ++i, ++s, ++k) {
1599 s->name = (unsigned long) k->name;
1600 s->value = k->value;
1607 n_ext_modules = nmod + 1;
1609 /* Now collect the symbols for the kernel proper. */
1611 if (k->name[0] == '#')
1614 nksyms = nms = nks - (k - ks);
1615 ksyms = s = (nms ? xmalloc(nms * sizeof(*s)) : NULL);
1617 for (i = 0; i < nms; ++i, ++s, ++k) {
1618 s->name = (unsigned long) k->name;
1619 s->value = k->value;
1625 /* Return the kernel symbol checksum version, or zero if not used. */
1627 static int old_is_kernel_checksummed(void)
1629 /* Using_Versions is the first symbol. */
1631 && strcmp((char *) ksyms[0].name,
1632 "Using_Versions") == 0) return ksyms[0].value;
1638 static int old_create_mod_use_count(struct obj_file *f)
1640 struct obj_section *sec;
1642 sec = obj_create_alloced_section_first(f, ".moduse", sizeof(long),
1645 obj_add_symbol(f, "mod_use_count_", -1,
1646 ELFW(ST_INFO) (STB_LOCAL, STT_OBJECT), sec->idx, 0,
1653 old_init_module(const char *m_name, struct obj_file *f,
1654 unsigned long m_size)
1657 struct old_mod_routines routines;
1658 struct old_symbol_table *symtab;
1661 /* Create the symbol table */
1663 int nsyms = 0, strsize = 0, total;
1665 /* Size things first... */
1668 for (i = 0; i < HASH_BUCKETS; ++i) {
1669 struct obj_symbol *sym;
1670 for (sym = f->symtab[i]; sym; sym = sym->next)
1671 if (ELFW(ST_BIND) (sym->info) != STB_LOCAL
1672 && sym->secidx <= SHN_HIRESERVE)
1674 sym->ksymidx = nsyms++;
1675 strsize += strlen(sym->name) + 1;
1680 total = (sizeof(struct old_symbol_table)
1681 + nsyms * sizeof(struct old_module_symbol)
1682 + n_ext_modules_used * sizeof(struct old_module_ref)
1684 symtab = xmalloc(total);
1685 symtab->size = total;
1686 symtab->n_symbols = nsyms;
1687 symtab->n_refs = n_ext_modules_used;
1689 if (flag_export && nsyms) {
1690 struct old_module_symbol *ksym;
1694 ksym = symtab->symbol;
1695 str = ((char *) ksym + nsyms * sizeof(struct old_module_symbol)
1696 + n_ext_modules_used * sizeof(struct old_module_ref));
1698 for (i = 0; i < HASH_BUCKETS; ++i) {
1699 struct obj_symbol *sym;
1700 for (sym = f->symtab[i]; sym; sym = sym->next)
1701 if (sym->ksymidx >= 0) {
1702 ksym->addr = obj_symbol_final_value(f, sym);
1704 (unsigned long) str - (unsigned long) symtab;
1706 strcpy(str, sym->name);
1707 str += strlen(sym->name) + 1;
1713 if (n_ext_modules_used) {
1714 struct old_module_ref *ref;
1717 ref = (struct old_module_ref *)
1718 ((char *) symtab->symbol + nsyms * sizeof(struct old_module_symbol));
1720 for (i = 0; i < n_ext_modules; ++i)
1721 if (ext_modules[i].used)
1722 ref++->module = ext_modules[i].addr;
1726 /* Fill in routines. */
1729 obj_symbol_final_value(f, obj_find_symbol(f, "init_module"));
1731 obj_symbol_final_value(f, obj_find_symbol(f, "cleanup_module"));
1733 /* Whew! All of the initialization is complete. Collect the final
1734 module image and give it to the kernel. */
1736 image = xmalloc(m_size);
1737 obj_create_image(f, image);
1739 /* image holds the complete relocated module, accounting correctly for
1740 mod_use_count. However the old module kernel support assume that
1741 it is receiving something which does not contain mod_use_count. */
1742 ret = old_sys_init_module(m_name, image + sizeof(long),
1743 m_size | (flag_autoclean ? OLD_MOD_AUTOCLEAN
1744 : 0), &routines, symtab);
1746 perror_msg("init_module: %s", m_name);
1756 #define old_create_mod_use_count(x) TRUE
1757 #define old_init_module(x, y, z) TRUE
1759 #endif /* BB_FEATURE_OLD_MODULE_INTERFACE */
1763 /*======================================================================*/
1764 /* Functions relating to module loading after 2.1.18. */
1767 new_process_module_arguments(struct obj_file *f, int argc, char **argv)
1771 struct obj_symbol *sym;
1772 char *contents, *loc;
1776 if ((q = strchr(p, '=')) == NULL) {
1781 key = alloca(q - p + 6);
1782 memcpy(key, "parm_", 5);
1783 memcpy(key + 5, p, q - p);
1786 p = get_modinfo_value(f, key);
1789 error_msg("invalid parameter %s", key);
1793 sym = obj_find_symbol(f, key);
1795 /* Also check that the parameter was not resolved from the kernel. */
1796 if (sym == NULL || sym->secidx > SHN_HIRESERVE) {
1797 error_msg("symbol for parameter %s not found", key);
1802 min = strtoul(p, &p, 10);
1804 max = strtoul(p + 1, &p, 10);
1810 contents = f->sections[sym->secidx]->contents;
1811 loc = contents + sym->value;
1815 if ((*p == 's') || (*p == 'c')) {
1818 /* Do C quoting if we begin with a ", else slurp the lot. */
1822 str = alloca(strlen(q));
1823 for (r = str, q++; *q != '"'; ++q, ++r) {
1825 error_msg("improperly terminated string argument for %s",
1828 } else if (*q == '\\')
1862 if (q[1] >= '0' && q[1] <= '7') {
1863 c = (c * 8) + *++q - '0';
1864 if (q[1] >= '0' && q[1] <= '7')
1865 c = (c * 8) + *++q - '0';
1882 /* In this case, the string is not quoted. We will break
1883 it using the coma (like for ints). If the user wants to
1884 include comas in a string, he just has to quote it */
1886 /* Search the next coma */
1890 if (r != (char *) NULL) {
1891 /* Recopy the current field */
1892 str = alloca(r - q + 1);
1893 memcpy(str, q, r - q);
1895 /* I don't know if it is usefull, as the previous case
1896 doesn't null terminate the string ??? */
1899 /* Keep next fields */
1910 obj_string_patch(f, sym->secidx, loc - contents, str);
1911 loc += tgt_sizeof_char_p;
1913 /* Array of chars (in fact, matrix !) */
1914 unsigned long charssize; /* size of each member */
1916 /* Get the size of each member */
1917 /* Probably we should do that outside the loop ? */
1918 if (!isdigit(*(p + 1))) {
1919 error_msg("parameter type 'c' for %s must be followed by"
1920 " the maximum size", key);
1923 charssize = strtoul(p + 1, (char **) NULL, 10);
1926 if (strlen(str) >= charssize) {
1927 error_msg("string too long for %s (max %ld)", key,
1932 /* Copy to location */
1933 strcpy((char *) loc, str);
1937 long v = strtoul(q, &q, 0);
1944 loc += tgt_sizeof_short;
1948 loc += tgt_sizeof_int;
1952 loc += tgt_sizeof_long;
1956 error_msg("unknown parameter type '%c' for %s", *p, key);
1971 goto retry_end_of_value;
1975 error_msg("too many values for %s (max %d)", key, max);
1982 error_msg("invalid argument syntax for %s", key);
1989 error_msg("too few values for %s (min %d)", key, min);
1999 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
2000 static int new_is_module_checksummed(struct obj_file *f)
2002 const char *p = get_modinfo_value(f, "using_checksums");
2009 /* Get the module's kernel version in the canonical integer form. */
2012 new_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
2017 p = get_modinfo_value(f, "kernel_version");
2020 strncpy(str, p, STRVERSIONLEN);
2022 a = strtoul(p, &p, 10);
2025 b = strtoul(p + 1, &p, 10);
2028 c = strtoul(p + 1, &q, 10);
2032 return a << 16 | b << 8 | c;
2035 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
2038 #ifdef BB_FEATURE_NEW_MODULE_INTERFACE
2040 /* Fetch the loaded modules, and all currently exported symbols. */
2042 static int new_get_kernel_symbols(void)
2044 char *module_names, *mn;
2045 struct external_module *modules, *m;
2046 struct new_module_symbol *syms, *s;
2047 size_t ret, bufsize, nmod, nsyms, i, j;
2049 /* Collect the loaded modules. */
2051 module_names = xmalloc(bufsize = 256);
2053 if (query_module(NULL, QM_MODULES, module_names, bufsize, &ret)) {
2054 if (errno == ENOSPC) {
2055 module_names = xrealloc(module_names, bufsize = ret);
2056 goto retry_modules_load;
2058 perror_msg("QM_MODULES");
2062 n_ext_modules = nmod = ret;
2063 ext_modules = modules = xmalloc(nmod * sizeof(*modules));
2064 memset(modules, 0, nmod * sizeof(*modules));
2066 /* Collect the modules' symbols. */
2068 for (i = 0, mn = module_names, m = modules;
2069 i < nmod; ++i, ++m, mn += strlen(mn) + 1) {
2070 struct new_module_info info;
2072 if (query_module(mn, QM_INFO, &info, sizeof(info), &ret)) {
2073 if (errno == ENOENT) {
2074 /* The module was removed out from underneath us. */
2077 perror_msg("query_module: QM_INFO: %s", mn);
2081 syms = xmalloc(bufsize = 1024);
2083 if (query_module(mn, QM_SYMBOLS, syms, bufsize, &ret)) {
2086 syms = xrealloc(syms, bufsize = ret);
2087 goto retry_mod_sym_load;
2089 /* The module was removed out from underneath us. */
2092 perror_msg("query_module: QM_SYMBOLS: %s", mn);
2099 m->addr = info.addr;
2103 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2104 s->name += (unsigned long) syms;
2108 /* Collect the kernel's symbols. */
2110 syms = xmalloc(bufsize = 16 * 1024);
2111 retry_kern_sym_load:
2112 if (query_module(NULL, QM_SYMBOLS, syms, bufsize, &ret)) {
2113 if (errno == ENOSPC) {
2114 syms = xrealloc(syms, bufsize = ret);
2115 goto retry_kern_sym_load;
2117 perror_msg("kernel: QM_SYMBOLS");
2120 nksyms = nsyms = ret;
2123 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2124 s->name += (unsigned long) syms;
2130 /* Return the kernel symbol checksum version, or zero if not used. */
2132 static int new_is_kernel_checksummed(void)
2134 struct new_module_symbol *s;
2137 /* Using_Versions is not the first symbol, but it should be in there. */
2139 for (i = 0, s = ksyms; i < nksyms; ++i, ++s)
2140 if (strcmp((char *) s->name, "Using_Versions") == 0)
2147 static int new_create_this_module(struct obj_file *f, const char *m_name)
2149 struct obj_section *sec;
2151 sec = obj_create_alloced_section_first(f, ".this", tgt_sizeof_long,
2152 sizeof(struct new_module));
2153 memset(sec->contents, 0, sizeof(struct new_module));
2155 obj_add_symbol(f, "__this_module", -1,
2156 ELFW(ST_INFO) (STB_LOCAL, STT_OBJECT), sec->idx, 0,
2157 sizeof(struct new_module));
2159 obj_string_patch(f, sec->idx, offsetof(struct new_module, name),
2166 static int new_create_module_ksymtab(struct obj_file *f)
2168 struct obj_section *sec;
2171 /* We must always add the module references. */
2173 if (n_ext_modules_used) {
2174 struct new_module_ref *dep;
2175 struct obj_symbol *tm;
2177 sec = obj_create_alloced_section(f, ".kmodtab", tgt_sizeof_void_p,
2178 (sizeof(struct new_module_ref)
2179 * n_ext_modules_used));
2183 tm = obj_find_symbol(f, "__this_module");
2184 dep = (struct new_module_ref *) sec->contents;
2185 for (i = 0; i < n_ext_modules; ++i)
2186 if (ext_modules[i].used) {
2187 dep->dep = ext_modules[i].addr;
2188 obj_symbol_patch(f, sec->idx,
2189 (char *) &dep->ref - sec->contents, tm);
2195 if (flag_export && !obj_find_section(f, "__ksymtab")) {
2200 obj_create_alloced_section(f, "__ksymtab", tgt_sizeof_void_p,
2203 /* We don't want to export symbols residing in sections that
2204 aren't loaded. There are a number of these created so that
2205 we make sure certain module options don't appear twice. */
2207 loaded = alloca(sizeof(int) * (i = f->header.e_shnum));
2209 loaded[i] = (f->sections[i]->header.sh_flags & SHF_ALLOC) != 0;
2211 for (nsyms = i = 0; i < HASH_BUCKETS; ++i) {
2212 struct obj_symbol *sym;
2213 for (sym = f->symtab[i]; sym; sym = sym->next)
2214 if (ELFW(ST_BIND) (sym->info) != STB_LOCAL
2215 && sym->secidx <= SHN_HIRESERVE
2216 && (sym->secidx >= SHN_LORESERVE
2217 || loaded[sym->secidx])) {
2218 ElfW(Addr) ofs = nsyms * 2 * tgt_sizeof_void_p;
2220 obj_symbol_patch(f, sec->idx, ofs, sym);
2221 obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p,
2228 obj_extend_section(sec, nsyms * 2 * tgt_sizeof_char_p);
2236 new_init_module(const char *m_name, struct obj_file *f,
2237 unsigned long m_size)
2239 struct new_module *module;
2240 struct obj_section *sec;
2245 sec = obj_find_section(f, ".this");
2246 module = (struct new_module *) sec->contents;
2247 m_addr = sec->header.sh_addr;
2249 module->size_of_struct = sizeof(*module);
2250 module->size = m_size;
2251 module->flags = flag_autoclean ? NEW_MOD_AUTOCLEAN : 0;
2253 sec = obj_find_section(f, "__ksymtab");
2254 if (sec && sec->header.sh_size) {
2255 module->syms = sec->header.sh_addr;
2256 module->nsyms = sec->header.sh_size / (2 * tgt_sizeof_char_p);
2259 if (n_ext_modules_used) {
2260 sec = obj_find_section(f, ".kmodtab");
2261 module->deps = sec->header.sh_addr;
2262 module->ndeps = n_ext_modules_used;
2266 obj_symbol_final_value(f, obj_find_symbol(f, "init_module"));
2268 obj_symbol_final_value(f, obj_find_symbol(f, "cleanup_module"));
2270 sec = obj_find_section(f, "__ex_table");
2272 module->ex_table_start = sec->header.sh_addr;
2273 module->ex_table_end = sec->header.sh_addr + sec->header.sh_size;
2276 sec = obj_find_section(f, ".text.init");
2278 module->runsize = sec->header.sh_addr - m_addr;
2280 sec = obj_find_section(f, ".data.init");
2282 if (!module->runsize ||
2283 module->runsize > sec->header.sh_addr - m_addr)
2284 module->runsize = sec->header.sh_addr - m_addr;
2287 if (!arch_init_module(f, module))
2290 /* Whew! All of the initialization is complete. Collect the final
2291 module image and give it to the kernel. */
2293 image = xmalloc(m_size);
2294 obj_create_image(f, image);
2296 ret = new_sys_init_module(m_name, (struct new_module *) image);
2298 perror_msg("init_module: %s", m_name);
2307 #define new_init_module(x, y, z) TRUE
2308 #define new_create_this_module(x, y) 0
2309 #define new_create_module_ksymtab(x)
2310 #define query_module(v, w, x, y, z) -1
2312 #endif /* BB_FEATURE_NEW_MODULE_INTERFACE */
2315 /*======================================================================*/
2318 obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2321 struct obj_string_patch *p;
2322 struct obj_section *strsec;
2323 size_t len = strlen(string) + 1;
2326 p = xmalloc(sizeof(*p));
2327 p->next = f->string_patches;
2328 p->reloc_secidx = secidx;
2329 p->reloc_offset = offset;
2330 f->string_patches = p;
2332 strsec = obj_find_section(f, ".kstrtab");
2333 if (strsec == NULL) {
2334 strsec = obj_create_alloced_section(f, ".kstrtab", 1, len);
2335 p->string_offset = 0;
2336 loc = strsec->contents;
2338 p->string_offset = strsec->header.sh_size;
2339 loc = obj_extend_section(strsec, len);
2341 memcpy(loc, string, len);
2347 obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2348 struct obj_symbol *sym)
2350 struct obj_symbol_patch *p;
2352 p = xmalloc(sizeof(*p));
2353 p->next = f->symbol_patches;
2354 p->reloc_secidx = secidx;
2355 p->reloc_offset = offset;
2357 f->symbol_patches = p;
2362 int obj_check_undefineds(struct obj_file *f)
2367 for (i = 0; i < HASH_BUCKETS; ++i) {
2368 struct obj_symbol *sym;
2369 for (sym = f->symtab[i]; sym; sym = sym->next)
2370 if (sym->secidx == SHN_UNDEF) {
2371 if (ELFW(ST_BIND) (sym->info) == STB_WEAK) {
2372 sym->secidx = SHN_ABS;
2375 error_msg("unresolved symbol %s", sym->name);
2384 void obj_allocate_commons(struct obj_file *f)
2386 struct common_entry {
2387 struct common_entry *next;
2388 struct obj_symbol *sym;
2389 } *common_head = NULL;
2393 for (i = 0; i < HASH_BUCKETS; ++i) {
2394 struct obj_symbol *sym;
2395 for (sym = f->symtab[i]; sym; sym = sym->next)
2396 if (sym->secidx == SHN_COMMON) {
2397 /* Collect all COMMON symbols and sort them by size so as to
2398 minimize space wasted by alignment requirements. */
2400 struct common_entry **p, *n;
2401 for (p = &common_head; *p; p = &(*p)->next)
2402 if (sym->size <= (*p)->sym->size)
2405 n = alloca(sizeof(*n));
2413 for (i = 1; i < f->local_symtab_size; ++i) {
2414 struct obj_symbol *sym = f->local_symtab[i];
2415 if (sym && sym->secidx == SHN_COMMON) {
2416 struct common_entry **p, *n;
2417 for (p = &common_head; *p; p = &(*p)->next)
2418 if (sym == (*p)->sym)
2420 else if (sym->size < (*p)->sym->size) {
2421 n = alloca(sizeof(*n));
2431 /* Find the bss section. */
2432 for (i = 0; i < f->header.e_shnum; ++i)
2433 if (f->sections[i]->header.sh_type == SHT_NOBITS)
2436 /* If for some reason there hadn't been one, create one. */
2437 if (i == f->header.e_shnum) {
2438 struct obj_section *sec;
2440 f->sections = xrealloc(f->sections, (i + 1) * sizeof(sec));
2441 f->sections[i] = sec = arch_new_section();
2442 f->header.e_shnum = i + 1;
2444 memset(sec, 0, sizeof(*sec));
2445 sec->header.sh_type = SHT_PROGBITS;
2446 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2451 /* Allocate the COMMONS. */
2453 ElfW(Addr) bss_size = f->sections[i]->header.sh_size;
2454 ElfW(Addr) max_align = f->sections[i]->header.sh_addralign;
2455 struct common_entry *c;
2457 for (c = common_head; c; c = c->next) {
2458 ElfW(Addr) align = c->sym->value;
2460 if (align > max_align)
2462 if (bss_size & (align - 1))
2463 bss_size = (bss_size | (align - 1)) + 1;
2466 c->sym->value = bss_size;
2468 bss_size += c->sym->size;
2471 f->sections[i]->header.sh_size = bss_size;
2472 f->sections[i]->header.sh_addralign = max_align;
2476 /* For the sake of patch relocation and parameter initialization,
2477 allocate zeroed data for NOBITS sections now. Note that after
2478 this we cannot assume NOBITS are really empty. */
2479 for (i = 0; i < f->header.e_shnum; ++i) {
2480 struct obj_section *s = f->sections[i];
2481 if (s->header.sh_type == SHT_NOBITS) {
2482 if (s->header.sh_size != 0)
2483 s->contents = memset(xmalloc(s->header.sh_size),
2484 0, s->header.sh_size);
2488 s->header.sh_type = SHT_PROGBITS;
2493 unsigned long obj_load_size(struct obj_file *f)
2495 unsigned long dot = 0;
2496 struct obj_section *sec;
2498 /* Finalize the positions of the sections relative to one another. */
2500 for (sec = f->load_order; sec; sec = sec->load_next) {
2503 align = sec->header.sh_addralign;
2504 if (align && (dot & (align - 1)))
2505 dot = (dot | (align - 1)) + 1;
2507 sec->header.sh_addr = dot;
2508 dot += sec->header.sh_size;
2514 int obj_relocate(struct obj_file *f, ElfW(Addr) base)
2516 int i, n = f->header.e_shnum;
2519 /* Finalize the addresses of the sections. */
2522 for (i = 0; i < n; ++i)
2523 f->sections[i]->header.sh_addr += base;
2525 /* And iterate over all of the relocations. */
2527 for (i = 0; i < n; ++i) {
2528 struct obj_section *relsec, *symsec, *targsec, *strsec;
2529 ElfW(RelM) * rel, *relend;
2533 relsec = f->sections[i];
2534 if (relsec->header.sh_type != SHT_RELM)
2537 symsec = f->sections[relsec->header.sh_link];
2538 targsec = f->sections[relsec->header.sh_info];
2539 strsec = f->sections[symsec->header.sh_link];
2541 rel = (ElfW(RelM) *) relsec->contents;
2542 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
2543 symtab = (ElfW(Sym) *) symsec->contents;
2544 strtab = (const char *) strsec->contents;
2546 for (; rel < relend; ++rel) {
2547 ElfW(Addr) value = 0;
2548 struct obj_symbol *intsym = NULL;
2549 unsigned long symndx;
2550 ElfW(Sym) * extsym = 0;
2553 /* Attempt to find a value to use for this relocation. */
2555 symndx = ELFW(R_SYM) (rel->r_info);
2557 /* Note we've already checked for undefined symbols. */
2559 extsym = &symtab[symndx];
2560 if (ELFW(ST_BIND) (extsym->st_info) == STB_LOCAL) {
2561 /* Local symbols we look up in the local table to be sure
2562 we get the one that is really intended. */
2563 intsym = f->local_symtab[symndx];
2565 /* Others we look up in the hash table. */
2567 if (extsym->st_name)
2568 name = strtab + extsym->st_name;
2570 name = f->sections[extsym->st_shndx]->name;
2571 intsym = obj_find_symbol(f, name);
2574 value = obj_symbol_final_value(f, intsym);
2575 intsym->referenced = 1;
2577 #if SHT_RELM == SHT_RELA
2578 #if defined(__alpha__) && defined(AXP_BROKEN_GAS)
2579 /* Work around a nasty GAS bug, that is fixed as of 2.7.0.9. */
2580 if (!extsym || !extsym->st_name ||
2581 ELFW(ST_BIND) (extsym->st_info) != STB_LOCAL)
2583 value += rel->r_addend;
2587 switch (arch_apply_relocation
2588 (f, targsec, symsec, intsym, rel, value)) {
2592 case obj_reloc_overflow:
2593 errmsg = "Relocation overflow";
2595 case obj_reloc_dangerous:
2596 errmsg = "Dangerous relocation";
2598 case obj_reloc_unhandled:
2599 errmsg = "Unhandled relocation";
2602 error_msg("%s of type %ld for %s", errmsg,
2603 (long) ELFW(R_TYPE) (rel->r_info),
2604 strtab + extsym->st_name);
2606 error_msg("%s of type %ld", errmsg,
2607 (long) ELFW(R_TYPE) (rel->r_info));
2615 /* Finally, take care of the patches. */
2617 if (f->string_patches) {
2618 struct obj_string_patch *p;
2619 struct obj_section *strsec;
2620 ElfW(Addr) strsec_base;
2621 strsec = obj_find_section(f, ".kstrtab");
2622 strsec_base = strsec->header.sh_addr;
2624 for (p = f->string_patches; p; p = p->next) {
2625 struct obj_section *targsec = f->sections[p->reloc_secidx];
2626 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
2627 = strsec_base + p->string_offset;
2631 if (f->symbol_patches) {
2632 struct obj_symbol_patch *p;
2634 for (p = f->symbol_patches; p; p = p->next) {
2635 struct obj_section *targsec = f->sections[p->reloc_secidx];
2636 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
2637 = obj_symbol_final_value(f, p->sym);
2644 int obj_create_image(struct obj_file *f, char *image)
2646 struct obj_section *sec;
2647 ElfW(Addr) base = f->baseaddr;
2649 for (sec = f->load_order; sec; sec = sec->load_next) {
2652 if (sec->header.sh_size == 0)
2655 secimg = image + (sec->header.sh_addr - base);
2657 /* Note that we allocated data for NOBITS sections earlier. */
2658 memcpy(secimg, sec->contents, sec->header.sh_size);
2664 /*======================================================================*/
2666 struct obj_file *obj_load(FILE * fp)
2669 ElfW(Shdr) * section_headers;
2673 /* Read the file header. */
2675 f = arch_new_file();
2676 memset(f, 0, sizeof(*f));
2677 f->symbol_cmp = strcmp;
2678 f->symbol_hash = obj_elf_hash;
2679 f->load_order_search_start = &f->load_order;
2681 fseek(fp, 0, SEEK_SET);
2682 if (fread(&f->header, sizeof(f->header), 1, fp) != 1) {
2683 perror_msg("error reading ELF header");
2687 if (f->header.e_ident[EI_MAG0] != ELFMAG0
2688 || f->header.e_ident[EI_MAG1] != ELFMAG1
2689 || f->header.e_ident[EI_MAG2] != ELFMAG2
2690 || f->header.e_ident[EI_MAG3] != ELFMAG3) {
2691 error_msg("not an ELF file");
2694 if (f->header.e_ident[EI_CLASS] != ELFCLASSM
2695 || f->header.e_ident[EI_DATA] != ELFDATAM
2696 || f->header.e_ident[EI_VERSION] != EV_CURRENT
2697 || !MATCH_MACHINE(f->header.e_machine)) {
2698 error_msg("ELF file not for this architecture");
2701 if (f->header.e_type != ET_REL) {
2702 error_msg("ELF file not a relocatable object");
2706 /* Read the section headers. */
2708 if (f->header.e_shentsize != sizeof(ElfW(Shdr))) {
2709 error_msg("section header size mismatch: %lu != %lu",
2710 (unsigned long) f->header.e_shentsize,
2711 (unsigned long) sizeof(ElfW(Shdr)));
2715 shnum = f->header.e_shnum;
2716 f->sections = xmalloc(sizeof(struct obj_section *) * shnum);
2717 memset(f->sections, 0, sizeof(struct obj_section *) * shnum);
2719 section_headers = alloca(sizeof(ElfW(Shdr)) * shnum);
2720 fseek(fp, f->header.e_shoff, SEEK_SET);
2721 if (fread(section_headers, sizeof(ElfW(Shdr)), shnum, fp) != shnum) {
2722 perror_msg("error reading ELF section headers");
2726 /* Read the section data. */
2728 for (i = 0; i < shnum; ++i) {
2729 struct obj_section *sec;
2731 f->sections[i] = sec = arch_new_section();
2732 memset(sec, 0, sizeof(*sec));
2734 sec->header = section_headers[i];
2737 switch (sec->header.sh_type) {
2748 if (sec->header.sh_size > 0) {
2749 sec->contents = xmalloc(sec->header.sh_size);
2750 fseek(fp, sec->header.sh_offset, SEEK_SET);
2751 if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
2752 perror_msg("error reading ELF section data");
2756 sec->contents = NULL;
2760 #if SHT_RELM == SHT_REL
2762 error_msg("RELA relocations not supported on this architecture");
2766 error_msg("REL relocations not supported on this architecture");
2771 if (sec->header.sh_type >= SHT_LOPROC) {
2772 /* Assume processor specific section types are debug
2773 info and can safely be ignored. If this is ever not
2774 the case (Hello MIPS?), don't put ifdefs here but
2775 create an arch_load_proc_section(). */
2779 error_msg("can't handle sections of type %ld",
2780 (long) sec->header.sh_type);
2785 /* Do what sort of interpretation as needed by each section. */
2787 shstrtab = f->sections[f->header.e_shstrndx]->contents;
2789 for (i = 0; i < shnum; ++i) {
2790 struct obj_section *sec = f->sections[i];
2791 sec->name = shstrtab + sec->header.sh_name;
2794 for (i = 0; i < shnum; ++i) {
2795 struct obj_section *sec = f->sections[i];
2797 if (sec->header.sh_flags & SHF_ALLOC)
2798 obj_insert_section_load_order(f, sec);
2800 switch (sec->header.sh_type) {
2803 unsigned long nsym, j;
2807 if (sec->header.sh_entsize != sizeof(ElfW(Sym))) {
2808 error_msg("symbol size mismatch: %lu != %lu",
2809 (unsigned long) sec->header.sh_entsize,
2810 (unsigned long) sizeof(ElfW(Sym)));
2814 nsym = sec->header.sh_size / sizeof(ElfW(Sym));
2815 strtab = f->sections[sec->header.sh_link]->contents;
2816 sym = (ElfW(Sym) *) sec->contents;
2818 /* Allocate space for a table of local symbols. */
2819 j = f->local_symtab_size = sec->header.sh_info;
2820 f->local_symtab = xmalloc(j *=
2821 sizeof(struct obj_symbol *));
2822 memset(f->local_symtab, 0, j);
2824 /* Insert all symbols into the hash table. */
2825 for (j = 1, ++sym; j < nsym; ++j, ++sym) {
2828 name = strtab + sym->st_name;
2830 name = f->sections[sym->st_shndx]->name;
2832 obj_add_symbol(f, name, j, sym->st_info, sym->st_shndx,
2833 sym->st_value, sym->st_size);
2839 if (sec->header.sh_entsize != sizeof(ElfW(RelM))) {
2840 error_msg("relocation entry size mismatch: %lu != %lu",
2841 (unsigned long) sec->header.sh_entsize,
2842 (unsigned long) sizeof(ElfW(RelM)));
2852 static void hide_special_symbols(struct obj_file *f)
2854 static const char *const specials[] = {
2861 struct obj_symbol *sym;
2862 const char *const *p;
2864 for (p = specials; *p; ++p)
2865 if ((sym = obj_find_symbol(f, *p)) != NULL)
2867 ELFW(ST_INFO) (STB_LOCAL, ELFW(ST_TYPE) (sym->info));
2872 extern int insmod_main( int argc, char **argv)
2879 unsigned long m_size;
2884 char m_name[BUFSIZ + 1] = "\0";
2885 int exit_status = EXIT_FAILURE;
2887 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
2889 char k_strversion[STRVERSIONLEN];
2890 char m_strversion[STRVERSIONLEN];
2895 /* Parse any options */
2896 while ((opt = getopt(argc, argv, "fkvxLo:")) > 0) {
2898 case 'f': /* force loading */
2899 flag_force_load = 1;
2901 case 'k': /* module loaded by kerneld, auto-cleanable */
2904 case 'v': /* verbose output */
2907 case 'x': /* do not export externs */
2910 case 'o': /* name the output module */
2911 strncpy(m_name, optarg, BUFSIZ);
2913 case 'L': /* Stub warning */
2914 /* This is needed for compatibility with modprobe.
2915 * In theory, this does locking, but we don't do
2916 * that. So be careful and plan your life around not
2917 * loading the same module 50 times concurrently. */
2924 if (argv[optind] == NULL) {
2928 /* Grab the module name */
2929 if ((tmp = strrchr(argv[optind], '/')) != NULL) {
2936 if (len > 2 && tmp[len - 2] == '.' && tmp[len - 1] == 'o')
2938 strncpy(m_fullName, tmp, len);
2939 if (*m_name == '\0') {
2940 strcpy(m_name, m_fullName);
2942 strcat(m_fullName, ".o");
2944 /* Get a filedesc for the module */
2945 if (stat(argv[optind], &st) < 0 || !S_ISREG(st.st_mode) ||
2946 (fp = fopen(argv[optind], "r")) == NULL) {
2947 /* Hmpf. Could not open it. Search through _PATH_MODULES to find a module named m_name */
2948 if (recursive_action(_PATH_MODULES, TRUE, FALSE, FALSE,
2949 findNamedModule, 0, m_fullName) == FALSE)
2951 if (m_filename[0] == '\0'
2952 || ((fp = fopen(m_filename, "r")) == NULL))
2954 error_msg("No module named '%s' found in '%s'", m_fullName, _PATH_MODULES);
2955 return EXIT_FAILURE;
2958 error_msg_and_die("No module named '%s' found in '%s'", m_fullName, _PATH_MODULES);
2960 memcpy(m_filename, argv[optind], strlen(argv[optind]));
2963 if ((f = obj_load(fp)) == NULL)
2964 perror_msg_and_die("Could not load the module");
2966 if (get_modinfo_value(f, "kernel_version") == NULL)
2971 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
2972 /* Version correspondence? */
2974 k_version = get_kernel_version(k_strversion);
2975 if (m_has_modinfo) {
2976 m_version = new_get_module_version(f, m_strversion);
2978 m_version = old_get_module_version(f, m_strversion);
2979 if (m_version == -1) {
2980 error_msg("couldn't find the kernel version the module was "
2986 if (strncmp(k_strversion, m_strversion, STRVERSIONLEN) != 0) {
2987 if (flag_force_load) {
2988 error_msg("Warning: kernel-module version mismatch\n"
2989 "\t%s was compiled for kernel version %s\n"
2990 "\twhile this kernel is version %s",
2991 m_filename, m_strversion, k_strversion);
2993 error_msg("kernel-module version mismatch\n"
2994 "\t%s was compiled for kernel version %s\n"
2995 "\twhile this kernel is version %s.",
2996 m_filename, m_strversion, k_strversion);
3001 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
3003 k_new_syscalls = !query_module(NULL, 0, NULL, 0, NULL);
3005 if (k_new_syscalls) {
3006 #ifdef BB_FEATURE_NEW_MODULE_INTERFACE
3007 if (!new_get_kernel_symbols())
3009 k_crcs = new_is_kernel_checksummed();
3011 error_msg("Not configured to support new kernels");
3015 #ifdef BB_FEATURE_OLD_MODULE_INTERFACE
3016 if (!old_get_kernel_symbols(m_name))
3018 k_crcs = old_is_kernel_checksummed();
3020 error_msg("Not configured to support old kernels");
3025 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
3027 m_crcs = new_is_module_checksummed(f);
3029 m_crcs = old_is_module_checksummed(f);
3031 if (m_crcs != k_crcs)
3032 obj_set_symbol_compare(f, ncv_strcmp, ncv_symbol_hash);
3033 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
3035 /* Let the module know about the kernel symbols. */
3036 add_kernel_symbols(f);
3038 /* Allocate common symbols, symbol tables, and string tables. */
3041 ? !new_create_this_module(f, m_name)
3042 : !old_create_mod_use_count(f))
3047 if (!obj_check_undefineds(f)) {
3050 obj_allocate_commons(f);
3052 /* done with the module name, on to the optional var=value arguments */
3055 if (optind < argc) {
3057 ? !new_process_module_arguments(f, argc - optind, argv + optind)
3058 : !old_process_module_arguments(f, argc - optind, argv + optind))
3065 hide_special_symbols(f);
3068 new_create_module_ksymtab(f);
3070 /* Find current size of the module */
3071 m_size = obj_load_size(f);
3074 m_addr = create_module(m_name, m_size);
3075 if (m_addr==-1) switch (errno) {
3077 error_msg("A module named %s already exists", m_name);
3080 error_msg("Can't allocate kernel memory for module; needed %lu bytes",
3084 perror_msg("create_module: %s", m_name);
3088 if (!obj_relocate(f, m_addr)) {
3089 delete_module(m_name);
3094 ? !new_init_module(m_name, f, m_size)
3095 : !old_init_module(m_name, f, m_size))
3097 delete_module(m_name);
3101 exit_status = EXIT_SUCCESS;
3105 return(exit_status);