1 /* vi: set sw=4 ts=4: */
3 * Mini insmod implementation for busybox
5 * Copyright (C) 1999,2000 by Lineo, inc.
6 * Written by Erik Andersen <andersen@lineo.com>
7 * and Ron Alder <alder@lineo.com>
9 * Based almost entirely on the Linux modutils-2.3.11 implementation.
10 * Copyright 1996, 1997 Linux International.
11 * New implementation contributed by Richard Henderson <rth@tamu.edu>
12 * Based on original work by Bjorn Ekwall <bj0rn@blox.se>
13 * Restructured (and partly rewritten) by:
14 * Björn Ekwall <bj0rn@blox.se> February 1999
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 * General Public License for more details.
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
42 #include <sys/utsname.h>
44 //----------------------------------------------------------------------------
45 //--------modutils module.h, lines 45-242
46 //----------------------------------------------------------------------------
48 /* Definitions for the Linux module syscall interface.
49 Copyright 1996, 1997 Linux International.
51 Contributed by Richard Henderson <rth@tamu.edu>
53 This file is part of the Linux modutils.
55 This program is free software; you can redistribute it and/or modify it
56 under the terms of the GNU General Public License as published by the
57 Free Software Foundation; either version 2 of the License, or (at your
58 option) any later version.
60 This program is distributed in the hope that it will be useful, but
61 WITHOUT ANY WARRANTY; without even the implied warranty of
62 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
63 General Public License for more details.
65 You should have received a copy of the GNU General Public License
66 along with this program; if not, write to the Free Software Foundation,
67 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
70 #ifndef MODUTILS_MODULE_H
71 #define MODUTILS_MODULE_H 1
73 #ident "$Id: insmod.c,v 1.23 2000/09/22 00:38:07 andersen Exp $"
75 /* This file contains the structures used by the 2.0 and 2.1 kernels.
76 We do not use the kernel headers directly because we do not wish
77 to be dependant on a particular kernel version to compile insmod. */
80 /*======================================================================*/
81 /* The structures used by Linux 2.0. */
83 /* The symbol format used by get_kernel_syms(2). */
92 unsigned long module; /* kernel addresses */
96 struct old_module_symbol
102 struct old_symbol_table
104 int size; /* total, including string table!!! */
107 struct old_module_symbol symbol[0]; /* actual size defined by n_symbols */
108 struct old_module_ref ref[0]; /* actual size defined by n_refs */
111 struct old_mod_routines
114 unsigned long cleanup;
120 unsigned long ref; /* the list of modules that refer to me */
121 unsigned long symtab;
123 int size; /* size of module in pages */
124 unsigned long addr; /* address of module */
126 unsigned long cleanup; /* cleanup routine */
129 /* Sent to init_module(2) or'ed into the code size parameter. */
130 #define OLD_MOD_AUTOCLEAN 0x40000000 /* big enough, but no sign problems... */
132 int get_kernel_syms(struct old_kernel_sym *);
133 int old_sys_init_module(const char *name, char *code, unsigned codesize,
134 struct old_mod_routines *, struct old_symbol_table *);
136 /*======================================================================*/
137 /* For sizeof() which are related to the module platform and not to the
138 environment isnmod is running in, use sizeof_xx instead of sizeof(xx). */
140 #define tgt_sizeof_char sizeof(char)
141 #define tgt_sizeof_short sizeof(short)
142 #define tgt_sizeof_int sizeof(int)
143 #define tgt_sizeof_long sizeof(long)
144 #define tgt_sizeof_char_p sizeof(char *)
145 #define tgt_sizeof_void_p sizeof(void *)
146 #define tgt_long long
148 #if defined(__sparc__) && !defined(__sparc_v9__) && defined(ARCH_sparc64)
149 #undef tgt_sizeof_long
150 #undef tgt_sizeof_char_p
151 #undef tgt_sizeof_void_p
153 #define tgt_sizeof_long 8
154 #define tgt_sizeof_char_p 8
155 #define tgt_sizeof_void_p 8
156 #define tgt_long long long
159 /*======================================================================*/
160 /* The structures used in Linux 2.1. */
162 /* Note: new_module_symbol does not use tgt_long intentionally */
163 struct new_module_symbol
169 struct new_module_persist;
171 struct new_module_ref
173 unsigned tgt_long dep; /* kernel addresses */
174 unsigned tgt_long ref;
175 unsigned tgt_long next_ref;
180 unsigned tgt_long size_of_struct; /* == sizeof(module) */
181 unsigned tgt_long next;
182 unsigned tgt_long name;
183 unsigned tgt_long size;
186 unsigned tgt_long flags; /* AUTOCLEAN et al */
191 unsigned tgt_long syms;
192 unsigned tgt_long deps;
193 unsigned tgt_long refs;
194 unsigned tgt_long init;
195 unsigned tgt_long cleanup;
196 unsigned tgt_long ex_table_start;
197 unsigned tgt_long ex_table_end;
199 unsigned tgt_long gp;
201 /* Everything after here is extension. */
202 unsigned tgt_long persist_start;
203 unsigned tgt_long persist_end;
204 unsigned tgt_long can_unload;
205 unsigned tgt_long runsize;
208 struct new_module_info
216 /* Bits of module.flags. */
217 #define NEW_MOD_RUNNING 1
218 #define NEW_MOD_DELETED 2
219 #define NEW_MOD_AUTOCLEAN 4
220 #define NEW_MOD_VISITED 8
221 #define NEW_MOD_USED_ONCE 16
223 int new_sys_init_module(const char *name, const struct new_module *);
224 int query_module(const char *name, int which, void *buf, size_t bufsize,
227 /* Values for query_module's which. */
235 /*======================================================================*/
236 /* The system calls unchanged between 2.0 and 2.1. */
238 unsigned long create_module(const char *, size_t);
239 int delete_module(const char *);
242 #endif /* module.h */
244 //----------------------------------------------------------------------------
245 //--------end of modutils module.h
246 //----------------------------------------------------------------------------
250 //----------------------------------------------------------------------------
251 //--------modutils obj.h, lines 253-462
252 //----------------------------------------------------------------------------
254 /* Elf object file loading and relocation routines.
255 Copyright 1996, 1997 Linux International.
257 Contributed by Richard Henderson <rth@tamu.edu>
259 This file is part of the Linux modutils.
261 This program is free software; you can redistribute it and/or modify it
262 under the terms of the GNU General Public License as published by the
263 Free Software Foundation; either version 2 of the License, or (at your
264 option) any later version.
266 This program is distributed in the hope that it will be useful, but
267 WITHOUT ANY WARRANTY; without even the implied warranty of
268 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
269 General Public License for more details.
271 You should have received a copy of the GNU General Public License
272 along with this program; if not, write to the Free Software Foundation,
273 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
276 #ifndef MODUTILS_OBJ_H
277 #define MODUTILS_OBJ_H 1
279 #ident "$Id: insmod.c,v 1.23 2000/09/22 00:38:07 andersen Exp $"
281 /* The relocatable object is manipulated using elfin types. */
287 /* Machine-specific elf macros for i386 et al. */
289 #define ELFCLASSM ELFCLASS32
290 #define ELFDATAM ELFDATA2LSB
292 #define MATCH_MACHINE(x) (x == EM_386 || x == EM_486)
294 #define SHT_RELM SHT_REL
295 #define Elf32_RelM Elf32_Rel
299 # if ELFCLASSM == ELFCLASS32
300 # define ElfW(x) Elf32_ ## x
301 # define ELFW(x) ELF32_ ## x
303 # define ElfW(x) Elf64_ ## x
304 # define ELFW(x) ELF64_ ## x
308 /* For some reason this is missing from libc5. */
309 #ifndef ELF32_ST_INFO
310 # define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
313 #ifndef ELF64_ST_INFO
314 # define ELF64_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
317 struct obj_string_patch;
318 struct obj_symbol_patch;
325 struct obj_section *load_next;
331 struct obj_symbol *next; /* hash table link */
335 int secidx; /* the defining section index/module */
337 int ksymidx; /* for export to the kernel symtab */
338 int referenced; /* actually used in the link */
341 /* Hardcode the hash table size. We shouldn't be needing so many
342 symbols that we begin to degrade performance, and we get a big win
343 by giving the compiler a constant divisor. */
345 #define HASH_BUCKETS 521
351 struct obj_section **sections;
352 struct obj_section *load_order;
353 struct obj_section **load_order_search_start;
354 struct obj_string_patch *string_patches;
355 struct obj_symbol_patch *symbol_patches;
356 int (*symbol_cmp)(const char *, const char *);
357 unsigned long (*symbol_hash)(const char *);
358 unsigned long local_symtab_size;
359 struct obj_symbol **local_symtab;
360 struct obj_symbol *symtab[HASH_BUCKETS];
371 struct obj_string_patch
373 struct obj_string_patch *next;
375 ElfW(Addr) reloc_offset;
376 ElfW(Addr) string_offset;
379 struct obj_symbol_patch
381 struct obj_symbol_patch *next;
383 ElfW(Addr) reloc_offset;
384 struct obj_symbol *sym;
388 /* Generic object manipulation routines. */
390 unsigned long obj_elf_hash(const char *);
392 unsigned long obj_elf_hash_n(const char *, unsigned long len);
394 struct obj_symbol *obj_add_symbol (struct obj_file *f, const char *name,
395 unsigned long symidx, int info, int secidx,
396 ElfW(Addr) value, unsigned long size);
398 struct obj_symbol *obj_find_symbol (struct obj_file *f,
401 ElfW(Addr) obj_symbol_final_value(struct obj_file *f,
402 struct obj_symbol *sym);
404 void obj_set_symbol_compare(struct obj_file *f,
405 int (*cmp)(const char *, const char *),
406 unsigned long (*hash)(const char *));
408 struct obj_section *obj_find_section (struct obj_file *f,
411 void obj_insert_section_load_order (struct obj_file *f,
412 struct obj_section *sec);
414 struct obj_section *obj_create_alloced_section (struct obj_file *f,
419 struct obj_section *obj_create_alloced_section_first (struct obj_file *f,
424 void *obj_extend_section (struct obj_section *sec, unsigned long more);
426 int obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
429 int obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
430 struct obj_symbol *sym);
432 int obj_check_undefineds(struct obj_file *f);
434 void obj_allocate_commons(struct obj_file *f);
436 unsigned long obj_load_size (struct obj_file *f);
438 int obj_relocate (struct obj_file *f, ElfW(Addr) base);
440 struct obj_file *obj_load(FILE *f);
442 int obj_create_image (struct obj_file *f, char *image);
444 /* Architecture specific manipulation routines. */
446 struct obj_file *arch_new_file (void);
448 struct obj_section *arch_new_section (void);
450 struct obj_symbol *arch_new_symbol (void);
452 enum obj_reloc arch_apply_relocation (struct obj_file *f,
453 struct obj_section *targsec,
454 struct obj_section *symsec,
455 struct obj_symbol *sym,
456 ElfW(RelM) *rel, ElfW(Addr) value);
458 int arch_create_got (struct obj_file *f);
461 int arch_init_module (struct obj_file *f, struct new_module *);
464 //----------------------------------------------------------------------------
465 //--------end of modutils obj.h
466 //----------------------------------------------------------------------------
472 #define _PATH_MODULES "/lib/modules"
473 #define STRVERSIONLEN 32
475 #if !defined(BB_FEATURE_INSMOD_NEW_KERNEL) && !defined(BB_FEATURE_INSMOD_OLD_KERNEL)
476 #error "Must have ether BB_FEATURE_INSMOD_NEW_KERNEL or BB_FEATURE_INSMOD_OLD_KERNEL defined"
479 /*======================================================================*/
481 int flag_force_load = 0;
482 int flag_autoclean = 0;
483 int flag_verbose = 0;
487 /*======================================================================*/
489 struct i386_got_entry {
491 unsigned offset_done:1;
492 unsigned reloc_done:1;
496 struct obj_file root;
497 struct obj_section *got;
501 struct obj_symbol root;
502 struct i386_got_entry gotent;
507 struct external_module {
512 struct new_module_symbol *syms;
515 struct new_module_symbol *ksyms;
518 struct external_module *ext_modules;
520 int n_ext_modules_used;
524 /* Some firendly syscalls to cheer everyone's day... */
525 #define __NR_new_sys_init_module __NR_init_module
526 _syscall2(int, new_sys_init_module, const char *, name,
527 const struct new_module *, info)
528 #define __NR_old_sys_init_module __NR_init_module
529 _syscall5(int, old_sys_init_module, const char *, name, char *, code,
530 unsigned, codesize, struct old_mod_routines *, routines,
531 struct old_symbol_table *, symtab)
533 _syscall1(int, delete_module, const char *, name)
535 extern int delete_module(const char *);
538 #if defined(__i386__) || defined(__m68k__) || defined(__arm__)
539 /* Jump through hoops to fixup error return codes */
540 #define __NR__create_module __NR_create_module
541 static inline _syscall2(long, _create_module, const char *, name, size_t,
543 unsigned long create_module(const char *name, size_t size)
545 long ret = _create_module(name, size);
547 if (ret == -1 && errno > 125) {
554 _syscall2(unsigned long, create_module, const char *, name, size_t, size)
556 static char m_filename[BUFSIZ + 1] = "\0";
557 static char m_fullName[BUFSIZ + 1] = "\0";
559 /*======================================================================*/
562 static int findNamedModule(const char *fileName, struct stat *statbuf,
565 char *fullName = (char *) userDate;
568 if (fullName[0] == '\0')
571 char *tmp = strrchr(fileName, '/');
574 tmp = (char *) fileName;
577 if (check_wildcard_match(tmp, fullName) == TRUE) {
578 /* Stop searching if we find a match */
579 memcpy(m_filename, fileName, strlen(fileName)+1);
587 /*======================================================================*/
589 struct obj_file *arch_new_file(void)
592 f = xmalloc(sizeof(*f));
597 struct obj_section *arch_new_section(void)
599 return xmalloc(sizeof(struct obj_section));
602 struct obj_symbol *arch_new_symbol(void)
604 struct i386_symbol *sym;
605 sym = xmalloc(sizeof(*sym));
606 memset(&sym->gotent, 0, sizeof(sym->gotent));
610 arch_apply_relocation(struct obj_file *f,
611 struct obj_section *targsec,
612 struct obj_section *symsec,
613 struct obj_symbol *sym,
614 Elf32_Rel * rel, Elf32_Addr v)
616 struct i386_file *ifile = (struct i386_file *) f;
617 struct i386_symbol *isym = (struct i386_symbol *) sym;
619 Elf32_Addr *loc = (Elf32_Addr *) (targsec->contents + rel->r_offset);
620 Elf32_Addr dot = targsec->header.sh_addr + rel->r_offset;
621 Elf32_Addr got = ifile->got ? ifile->got->header.sh_addr : 0;
623 enum obj_reloc ret = obj_reloc_ok;
625 switch (ELF32_R_TYPE(rel->r_info)) {
653 assert(isym != NULL);
654 if (!isym->gotent.reloc_done) {
655 isym->gotent.reloc_done = 1;
656 *(Elf32_Addr *) (ifile->got->contents + isym->gotent.offset) =
659 *loc += isym->gotent.offset;
668 ret = obj_reloc_unhandled;
675 int arch_create_got(struct obj_file *f)
677 struct i386_file *ifile = (struct i386_file *) f;
678 int i, n, offset = 0, gotneeded = 0;
680 n = ifile->root.header.e_shnum;
681 for (i = 0; i < n; ++i) {
682 struct obj_section *relsec, *symsec, *strsec;
683 Elf32_Rel *rel, *relend;
687 relsec = ifile->root.sections[i];
688 if (relsec->header.sh_type != SHT_REL)
691 symsec = ifile->root.sections[relsec->header.sh_link];
692 strsec = ifile->root.sections[symsec->header.sh_link];
694 rel = (Elf32_Rel *) relsec->contents;
695 relend = rel + (relsec->header.sh_size / sizeof(Elf32_Rel));
696 symtab = (Elf32_Sym *) symsec->contents;
697 strtab = (const char *) strsec->contents;
699 for (; rel < relend; ++rel) {
701 struct i386_symbol *intsym;
704 switch (ELF32_R_TYPE(rel->r_info)) {
715 extsym = &symtab[ELF32_R_SYM(rel->r_info)];
717 name = strtab + extsym->st_name;
719 name = f->sections[extsym->st_shndx]->name;
721 (struct i386_symbol *) obj_find_symbol(&ifile->root, name);
723 if (!intsym->gotent.offset_done) {
724 intsym->gotent.offset_done = 1;
725 intsym->gotent.offset = offset;
731 if (offset > 0 || gotneeded)
733 obj_create_alloced_section(&ifile->root, ".got", 4, offset);
738 int arch_init_module(struct obj_file *f, struct new_module *mod)
744 /*======================================================================*/
746 /* Standard ELF hash function. */
747 inline unsigned long obj_elf_hash_n(const char *name, unsigned long n)
756 if ((g = (h & 0xf0000000)) != 0) {
765 unsigned long obj_elf_hash(const char *name)
767 return obj_elf_hash_n(name, strlen(name));
770 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
771 /* Get the kernel version in the canonical integer form. */
773 static int get_kernel_version(char str[STRVERSIONLEN])
775 struct utsname uts_info;
779 if (uname(&uts_info) < 0)
781 strncpy(str, uts_info.release, STRVERSIONLEN);
782 p = uts_info.release;
784 a = strtoul(p, &p, 10);
787 b = strtoul(p + 1, &p, 10);
790 c = strtoul(p + 1, &q, 10);
794 return a << 16 | b << 8 | c;
797 /* String comparison for non-co-versioned kernel and module. */
799 static int ncv_strcmp(const char *a, const char *b)
801 size_t alen = strlen(a), blen = strlen(b);
803 if (blen == alen + 10 && b[alen] == '_' && b[alen + 1] == 'R')
804 return strncmp(a, b, alen);
805 else if (alen == blen + 10 && a[blen] == '_' && a[blen + 1] == 'R')
806 return strncmp(a, b, blen);
811 /* String hashing for non-co-versioned kernel and module. Here
812 we are simply forced to drop the crc from the hash. */
814 static unsigned long ncv_symbol_hash(const char *str)
816 size_t len = strlen(str);
817 if (len > 10 && str[len - 10] == '_' && str[len - 9] == 'R')
819 return obj_elf_hash_n(str, len);
823 obj_set_symbol_compare(struct obj_file *f,
824 int (*cmp) (const char *, const char *),
825 unsigned long (*hash) (const char *))
830 struct obj_symbol *tmptab[HASH_BUCKETS], *sym, *next;
833 f->symbol_hash = hash;
835 memcpy(tmptab, f->symtab, sizeof(tmptab));
836 memset(f->symtab, 0, sizeof(f->symtab));
838 for (i = 0; i < HASH_BUCKETS; ++i)
839 for (sym = tmptab[i]; sym; sym = next) {
840 unsigned long h = hash(sym->name) % HASH_BUCKETS;
842 sym->next = f->symtab[h];
848 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
851 struct obj_symbol *obj_add_symbol(struct obj_file *f, const char *name,
852 unsigned long symidx, int info,
853 int secidx, ElfW(Addr) value,
856 struct obj_symbol *sym;
857 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
858 int n_type = ELFW(ST_TYPE) (info);
859 int n_binding = ELFW(ST_BIND) (info);
861 for (sym = f->symtab[hash]; sym; sym = sym->next)
862 if (f->symbol_cmp(sym->name, name) == 0) {
863 int o_secidx = sym->secidx;
864 int o_info = sym->info;
865 int o_type = ELFW(ST_TYPE) (o_info);
866 int o_binding = ELFW(ST_BIND) (o_info);
868 /* A redefinition! Is it legal? */
870 if (secidx == SHN_UNDEF)
872 else if (o_secidx == SHN_UNDEF)
874 else if (n_binding == STB_GLOBAL && o_binding == STB_LOCAL) {
875 /* Cope with local and global symbols of the same name
876 in the same object file, as might have been created
877 by ld -r. The only reason locals are now seen at this
878 level at all is so that we can do semi-sensible things
881 struct obj_symbol *nsym, **p;
883 nsym = arch_new_symbol();
884 nsym->next = sym->next;
887 /* Excise the old (local) symbol from the hash chain. */
888 for (p = &f->symtab[hash]; *p != sym; p = &(*p)->next)
892 } else if (n_binding == STB_LOCAL) {
893 /* Another symbol of the same name has already been defined.
894 Just add this to the local table. */
895 sym = arch_new_symbol();
898 f->local_symtab[symidx] = sym;
900 } else if (n_binding == STB_WEAK)
902 else if (o_binding == STB_WEAK)
904 /* Don't unify COMMON symbols with object types the programmer
906 else if (secidx == SHN_COMMON
907 && (o_type == STT_NOTYPE || o_type == STT_OBJECT))
909 else if (o_secidx == SHN_COMMON
910 && (n_type == STT_NOTYPE || n_type == STT_OBJECT))
913 /* Don't report an error if the symbol is coming from
914 the kernel or some external module. */
915 if (secidx <= SHN_HIRESERVE)
916 errorMsg("%s multiply defined\n", name);
921 /* Completely new symbol. */
922 sym = arch_new_symbol();
923 sym->next = f->symtab[hash];
924 f->symtab[hash] = sym;
927 if (ELFW(ST_BIND) (info) == STB_LOCAL)
928 f->local_symtab[symidx] = sym;
934 sym->secidx = secidx;
940 struct obj_symbol *obj_find_symbol(struct obj_file *f, const char *name)
942 struct obj_symbol *sym;
943 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
945 for (sym = f->symtab[hash]; sym; sym = sym->next)
946 if (f->symbol_cmp(sym->name, name) == 0)
953 obj_symbol_final_value(struct obj_file * f, struct obj_symbol * sym)
956 if (sym->secidx >= SHN_LORESERVE)
959 return sym->value + f->sections[sym->secidx]->header.sh_addr;
961 /* As a special case, a NULL sym has value zero. */
966 struct obj_section *obj_find_section(struct obj_file *f, const char *name)
968 int i, n = f->header.e_shnum;
970 for (i = 0; i < n; ++i)
971 if (strcmp(f->sections[i]->name, name) == 0)
972 return f->sections[i];
977 static int obj_load_order_prio(struct obj_section *a)
979 unsigned long af, ac;
981 af = a->header.sh_flags;
984 if (a->name[0] != '.' || strlen(a->name) != 10 ||
985 strcmp(a->name + 5, ".init"))
989 if (!(af & SHF_WRITE))
991 if (af & SHF_EXECINSTR)
993 if (a->header.sh_type != SHT_NOBITS)
1000 obj_insert_section_load_order(struct obj_file *f, struct obj_section *sec)
1002 struct obj_section **p;
1003 int prio = obj_load_order_prio(sec);
1004 for (p = f->load_order_search_start; *p; p = &(*p)->load_next)
1005 if (obj_load_order_prio(*p) < prio)
1007 sec->load_next = *p;
1011 struct obj_section *obj_create_alloced_section(struct obj_file *f,
1013 unsigned long align,
1016 int newidx = f->header.e_shnum++;
1017 struct obj_section *sec;
1019 f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
1020 f->sections[newidx] = sec = arch_new_section();
1022 memset(sec, 0, sizeof(*sec));
1023 sec->header.sh_type = SHT_PROGBITS;
1024 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
1025 sec->header.sh_size = size;
1026 sec->header.sh_addralign = align;
1030 sec->contents = xmalloc(size);
1032 obj_insert_section_load_order(f, sec);
1037 struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
1039 unsigned long align,
1042 int newidx = f->header.e_shnum++;
1043 struct obj_section *sec;
1045 f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
1046 f->sections[newidx] = sec = arch_new_section();
1048 memset(sec, 0, sizeof(*sec));
1049 sec->header.sh_type = SHT_PROGBITS;
1050 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
1051 sec->header.sh_size = size;
1052 sec->header.sh_addralign = align;
1056 sec->contents = xmalloc(size);
1058 sec->load_next = f->load_order;
1059 f->load_order = sec;
1060 if (f->load_order_search_start == &f->load_order)
1061 f->load_order_search_start = &sec->load_next;
1066 void *obj_extend_section(struct obj_section *sec, unsigned long more)
1068 unsigned long oldsize = sec->header.sh_size;
1069 sec->contents = xrealloc(sec->contents, sec->header.sh_size += more);
1070 return sec->contents + oldsize;
1075 /* Conditionally add the symbols from the given symbol set to the
1081 int idx, struct new_module_symbol *syms, size_t nsyms)
1083 struct new_module_symbol *s;
1087 for (i = 0, s = syms; i < nsyms; ++i, ++s) {
1089 /* Only add symbols that are already marked external. If we
1090 override locals we may cause problems for argument initialization.
1091 We will also create a false dependency on the module. */
1092 struct obj_symbol *sym;
1094 sym = obj_find_symbol(f, (char *) s->name);
1095 if (sym && !ELFW(ST_BIND) (sym->info) == STB_LOCAL) {
1096 sym = obj_add_symbol(f, (char *) s->name, -1,
1097 ELFW(ST_INFO) (STB_GLOBAL, STT_NOTYPE),
1099 /* Did our symbol just get installed? If so, mark the
1100 module as "used". */
1101 if (sym->secidx == idx)
1109 static void add_kernel_symbols(struct obj_file *f)
1111 struct external_module *m;
1114 /* Add module symbols first. */
1116 for (i = 0, m = ext_modules; i < n_ext_modules; ++i, ++m)
1118 && add_symbols_from(f, SHN_HIRESERVE + 2 + i, m->syms,
1119 m->nsyms)) m->used = 1, ++nused;
1121 n_ext_modules_used = nused;
1123 /* And finally the symbols from the kernel proper. */
1126 add_symbols_from(f, SHN_HIRESERVE + 1, ksyms, nksyms);
1129 static char *get_modinfo_value(struct obj_file *f, const char *key)
1131 struct obj_section *sec;
1132 char *p, *v, *n, *ep;
1133 size_t klen = strlen(key);
1135 sec = obj_find_section(f, ".modinfo");
1139 ep = p + sec->header.sh_size;
1142 n = strchr(p, '\0');
1144 if (p + klen == v && strncmp(p, key, klen) == 0)
1147 if (p + klen == n && strcmp(p, key) == 0)
1157 /*======================================================================*/
1158 /* Functions relating to module loading in pre 2.1 kernels. */
1161 old_process_module_arguments(struct obj_file *f, int argc, char **argv)
1165 struct obj_symbol *sym;
1169 if ((q = strchr(p, '=')) == NULL) {
1175 sym = obj_find_symbol(f, p);
1177 /* Also check that the parameter was not resolved from the kernel. */
1178 if (sym == NULL || sym->secidx > SHN_HIRESERVE) {
1179 errorMsg("symbol for parameter %s not found\n", p);
1183 loc = (int *) (f->sections[sym->secidx]->contents + sym->value);
1185 /* Do C quoting if we begin with a ". */
1189 str = alloca(strlen(q));
1190 for (r = str, q++; *q != '"'; ++q, ++r) {
1192 errorMsg("improperly terminated string argument for %s\n", p);
1194 } else if (*q == '\\')
1228 if (q[1] >= '0' && q[1] <= '7') {
1229 c = (c * 8) + *++q - '0';
1230 if (q[1] >= '0' && q[1] <= '7')
1231 c = (c * 8) + *++q - '0';
1244 obj_string_patch(f, sym->secidx, sym->value, str);
1245 } else if (*q >= '0' && *q <= '9') {
1247 *loc++ = strtoul(q, &q, 0);
1248 while (*q++ == ',');
1250 char *contents = f->sections[sym->secidx]->contents;
1251 char *loc = contents + sym->value;
1252 char *r; /* To search for commas */
1254 /* Break the string with comas */
1255 while ((r = strchr(q, ',')) != (char *) NULL) {
1257 obj_string_patch(f, sym->secidx, loc - contents, q);
1258 loc += sizeof(char *);
1263 obj_string_patch(f, sym->secidx, loc - contents, q);
1272 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
1273 static int old_is_module_checksummed(struct obj_file *f)
1275 return obj_find_symbol(f, "Using_Versions") != NULL;
1277 /* Get the module's kernel version in the canonical integer form. */
1280 old_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
1282 struct obj_symbol *sym;
1286 sym = obj_find_symbol(f, "kernel_version");
1290 p = f->sections[sym->secidx]->contents + sym->value;
1291 strncpy(str, p, STRVERSIONLEN);
1293 a = strtoul(p, &p, 10);
1296 b = strtoul(p + 1, &p, 10);
1299 c = strtoul(p + 1, &q, 10);
1303 return a << 16 | b << 8 | c;
1306 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
1308 #ifdef BB_FEATURE_INSMOD_OLD_KERNEL
1310 /* Fetch all the symbols and divvy them up as appropriate for the modules. */
1312 static int old_get_kernel_symbols(const char *m_name)
1314 struct old_kernel_sym *ks, *k;
1315 struct new_module_symbol *s;
1316 struct external_module *mod;
1317 int nks, nms, nmod, i;
1319 nks = get_kernel_syms(NULL);
1321 errorMsg("get_kernel_syms: %s: %s", m_name, strerror(errno));
1325 ks = k = xmalloc(nks * sizeof(*ks));
1327 if (get_kernel_syms(ks) != nks) {
1328 perror("inconsistency with get_kernel_syms -- is someone else "
1329 "playing with modules?");
1334 /* Collect the module information. */
1339 while (k->name[0] == '#' && k->name[1]) {
1340 struct old_kernel_sym *k2;
1341 struct new_module_symbol *s;
1343 /* Find out how many symbols this module has. */
1344 for (k2 = k + 1; k2->name[0] != '#'; ++k2)
1348 mod = xrealloc(mod, (++nmod + 1) * sizeof(*mod));
1349 mod[nmod].name = k->name + 1;
1350 mod[nmod].addr = k->value;
1352 mod[nmod].nsyms = nms;
1353 mod[nmod].syms = s = (nms ? xmalloc(nms * sizeof(*s)) : NULL);
1355 for (i = 0, ++k; i < nms; ++i, ++s, ++k) {
1356 s->name = (unsigned long) k->name;
1357 s->value = k->value;
1364 n_ext_modules = nmod + 1;
1366 /* Now collect the symbols for the kernel proper. */
1368 if (k->name[0] == '#')
1371 nksyms = nms = nks - (k - ks);
1372 ksyms = s = (nms ? xmalloc(nms * sizeof(*s)) : NULL);
1374 for (i = 0; i < nms; ++i, ++s, ++k) {
1375 s->name = (unsigned long) k->name;
1376 s->value = k->value;
1382 /* Return the kernel symbol checksum version, or zero if not used. */
1384 static int old_is_kernel_checksummed(void)
1386 /* Using_Versions is the first symbol. */
1388 && strcmp((char *) ksyms[0].name,
1389 "Using_Versions") == 0) return ksyms[0].value;
1395 static int old_create_mod_use_count(struct obj_file *f)
1397 struct obj_section *sec;
1399 sec = obj_create_alloced_section_first(f, ".moduse", sizeof(long),
1402 obj_add_symbol(f, "mod_use_count_", -1,
1403 ELFW(ST_INFO) (STB_LOCAL, STT_OBJECT), sec->idx, 0,
1410 old_init_module(const char *m_name, struct obj_file *f,
1411 unsigned long m_size)
1414 struct old_mod_routines routines;
1415 struct old_symbol_table *symtab;
1418 /* Create the symbol table */
1420 int nsyms = 0, strsize = 0, total;
1422 /* Size things first... */
1425 for (i = 0; i < HASH_BUCKETS; ++i) {
1426 struct obj_symbol *sym;
1427 for (sym = f->symtab[i]; sym; sym = sym->next)
1428 if (ELFW(ST_BIND) (sym->info) != STB_LOCAL
1429 && sym->secidx <= SHN_HIRESERVE)
1431 sym->ksymidx = nsyms++;
1432 strsize += strlen(sym->name) + 1;
1437 total = (sizeof(struct old_symbol_table)
1438 + nsyms * sizeof(struct old_module_symbol)
1439 + n_ext_modules_used * sizeof(struct old_module_ref)
1441 symtab = xmalloc(total);
1442 symtab->size = total;
1443 symtab->n_symbols = nsyms;
1444 symtab->n_refs = n_ext_modules_used;
1446 if (flag_export && nsyms) {
1447 struct old_module_symbol *ksym;
1451 ksym = symtab->symbol;
1452 str = ((char *) ksym + nsyms * sizeof(struct old_module_symbol)
1453 + n_ext_modules_used * sizeof(struct old_module_ref));
1455 for (i = 0; i < HASH_BUCKETS; ++i) {
1456 struct obj_symbol *sym;
1457 for (sym = f->symtab[i]; sym; sym = sym->next)
1458 if (sym->ksymidx >= 0) {
1459 ksym->addr = obj_symbol_final_value(f, sym);
1461 (unsigned long) str - (unsigned long) symtab;
1463 str = stpcpy(str, sym->name) + 1;
1469 if (n_ext_modules_used) {
1470 struct old_module_ref *ref;
1473 ref = (struct old_module_ref *)
1474 ((char *) symtab->symbol + nsyms * sizeof(struct old_module_symbol));
1476 for (i = 0; i < n_ext_modules; ++i)
1477 if (ext_modules[i].used)
1478 ref++->module = ext_modules[i].addr;
1482 /* Fill in routines. */
1485 obj_symbol_final_value(f, obj_find_symbol(f, "init_module"));
1487 obj_symbol_final_value(f, obj_find_symbol(f, "cleanup_module"));
1489 /* Whew! All of the initialization is complete. Collect the final
1490 module image and give it to the kernel. */
1492 image = xmalloc(m_size);
1493 obj_create_image(f, image);
1495 /* image holds the complete relocated module, accounting correctly for
1496 mod_use_count. However the old module kernel support assume that
1497 it is receiving something which does not contain mod_use_count. */
1498 ret = old_sys_init_module(m_name, image + sizeof(long),
1499 m_size | (flag_autoclean ? OLD_MOD_AUTOCLEAN
1500 : 0), &routines, symtab);
1502 errorMsg("init_module: %s: %s", m_name, strerror(errno));
1512 #define old_create_mod_use_count(x) TRUE
1513 #define old_init_module(x, y, z) TRUE
1515 #endif /* BB_FEATURE_INSMOD_OLD_KERNEL */
1519 /*======================================================================*/
1520 /* Functions relating to module loading after 2.1.18. */
1523 new_process_module_arguments(struct obj_file *f, int argc, char **argv)
1527 struct obj_symbol *sym;
1528 char *contents, *loc;
1532 if ((q = strchr(p, '=')) == NULL) {
1537 key = alloca(q - p + 6);
1538 memcpy(key, "parm_", 5);
1539 memcpy(key + 5, p, q - p);
1542 p = get_modinfo_value(f, key);
1545 errorMsg("invalid parameter %s\n", key);
1549 sym = obj_find_symbol(f, key);
1551 /* Also check that the parameter was not resolved from the kernel. */
1552 if (sym == NULL || sym->secidx > SHN_HIRESERVE) {
1553 errorMsg("symbol for parameter %s not found\n", key);
1558 min = strtoul(p, &p, 10);
1560 max = strtoul(p + 1, &p, 10);
1566 contents = f->sections[sym->secidx]->contents;
1567 loc = contents + sym->value;
1571 if ((*p == 's') || (*p == 'c')) {
1574 /* Do C quoting if we begin with a ", else slurp the lot. */
1578 str = alloca(strlen(q));
1579 for (r = str, q++; *q != '"'; ++q, ++r) {
1581 errorMsg("improperly terminated string argument for %s\n",
1584 } else if (*q == '\\')
1618 if (q[1] >= '0' && q[1] <= '7') {
1619 c = (c * 8) + *++q - '0';
1620 if (q[1] >= '0' && q[1] <= '7')
1621 c = (c * 8) + *++q - '0';
1638 /* In this case, the string is not quoted. We will break
1639 it using the coma (like for ints). If the user wants to
1640 include comas in a string, he just has to quote it */
1642 /* Search the next coma */
1646 if (r != (char *) NULL) {
1647 /* Recopy the current field */
1648 str = alloca(r - q + 1);
1649 memcpy(str, q, r - q);
1651 /* I don't know if it is usefull, as the previous case
1652 doesn't null terminate the string ??? */
1655 /* Keep next fields */
1666 obj_string_patch(f, sym->secidx, loc - contents, str);
1667 loc += tgt_sizeof_char_p;
1669 /* Array of chars (in fact, matrix !) */
1670 unsigned long charssize; /* size of each member */
1672 /* Get the size of each member */
1673 /* Probably we should do that outside the loop ? */
1674 if (!isdigit(*(p + 1))) {
1675 errorMsg("parameter type 'c' for %s must be followed by"
1676 " the maximum size\n", key);
1679 charssize = strtoul(p + 1, (char **) NULL, 10);
1682 if (strlen(str) >= charssize) {
1683 errorMsg("string too long for %s (max %ld)\n", key,
1688 /* Copy to location */
1689 strcpy((char *) loc, str);
1693 long v = strtoul(q, &q, 0);
1700 loc += tgt_sizeof_short;
1704 loc += tgt_sizeof_int;
1708 loc += tgt_sizeof_long;
1712 errorMsg("unknown parameter type '%c' for %s\n", *p, key);
1727 goto retry_end_of_value;
1731 errorMsg("too many values for %s (max %d)\n", key, max);
1738 errorMsg("invalid argument syntax for %s\n", key);
1745 errorMsg("too few values for %s (min %d)\n", key, min);
1755 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
1756 static int new_is_module_checksummed(struct obj_file *f)
1758 const char *p = get_modinfo_value(f, "using_checksums");
1765 /* Get the module's kernel version in the canonical integer form. */
1768 new_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
1773 p = get_modinfo_value(f, "kernel_version");
1776 strncpy(str, p, STRVERSIONLEN);
1778 a = strtoul(p, &p, 10);
1781 b = strtoul(p + 1, &p, 10);
1784 c = strtoul(p + 1, &q, 10);
1788 return a << 16 | b << 8 | c;
1791 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
1794 #ifdef BB_FEATURE_INSMOD_NEW_KERNEL
1796 /* Fetch the loaded modules, and all currently exported symbols. */
1798 static int new_get_kernel_symbols(void)
1800 char *module_names, *mn;
1801 struct external_module *modules, *m;
1802 struct new_module_symbol *syms, *s;
1803 size_t ret, bufsize, nmod, nsyms, i, j;
1805 /* Collect the loaded modules. */
1807 module_names = xmalloc(bufsize = 256);
1809 if (query_module(NULL, QM_MODULES, module_names, bufsize, &ret)) {
1810 if (errno == ENOSPC) {
1811 module_names = xrealloc(module_names, bufsize = ret);
1812 goto retry_modules_load;
1814 errorMsg("QM_MODULES: %s", strerror(errno));
1818 n_ext_modules = nmod = ret;
1819 ext_modules = modules = xmalloc(nmod * sizeof(*modules));
1820 memset(modules, 0, nmod * sizeof(*modules));
1822 /* Collect the modules' symbols. */
1824 for (i = 0, mn = module_names, m = modules;
1825 i < nmod; ++i, ++m, mn += strlen(mn) + 1) {
1826 struct new_module_info info;
1828 if (query_module(mn, QM_INFO, &info, sizeof(info), &ret)) {
1829 if (errno == ENOENT) {
1830 /* The module was removed out from underneath us. */
1833 errorMsg("query_module: QM_INFO: %s: %s", mn, strerror(errno));
1837 syms = xmalloc(bufsize = 1024);
1839 if (query_module(mn, QM_SYMBOLS, syms, bufsize, &ret)) {
1842 syms = xrealloc(syms, bufsize = ret);
1843 goto retry_mod_sym_load;
1845 /* The module was removed out from underneath us. */
1848 errorMsg("query_module: QM_SYMBOLS: %s: %s", mn, strerror(errno));
1855 m->addr = info.addr;
1859 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
1860 s->name += (unsigned long) syms;
1864 /* Collect the kernel's symbols. */
1866 syms = xmalloc(bufsize = 16 * 1024);
1867 retry_kern_sym_load:
1868 if (query_module(NULL, QM_SYMBOLS, syms, bufsize, &ret)) {
1869 if (errno == ENOSPC) {
1870 syms = xrealloc(syms, bufsize = ret);
1871 goto retry_kern_sym_load;
1873 errorMsg("kernel: QM_SYMBOLS: %s", strerror(errno));
1876 nksyms = nsyms = ret;
1879 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
1880 s->name += (unsigned long) syms;
1886 /* Return the kernel symbol checksum version, or zero if not used. */
1888 static int new_is_kernel_checksummed(void)
1890 struct new_module_symbol *s;
1893 /* Using_Versions is not the first symbol, but it should be in there. */
1895 for (i = 0, s = ksyms; i < nksyms; ++i, ++s)
1896 if (strcmp((char *) s->name, "Using_Versions") == 0)
1903 static int new_create_this_module(struct obj_file *f, const char *m_name)
1905 struct obj_section *sec;
1907 sec = obj_create_alloced_section_first(f, ".this", tgt_sizeof_long,
1908 sizeof(struct new_module));
1909 memset(sec->contents, 0, sizeof(struct new_module));
1911 obj_add_symbol(f, "__this_module", -1,
1912 ELFW(ST_INFO) (STB_LOCAL, STT_OBJECT), sec->idx, 0,
1913 sizeof(struct new_module));
1915 obj_string_patch(f, sec->idx, offsetof(struct new_module, name),
1922 static int new_create_module_ksymtab(struct obj_file *f)
1924 struct obj_section *sec;
1927 /* We must always add the module references. */
1929 if (n_ext_modules_used) {
1930 struct new_module_ref *dep;
1931 struct obj_symbol *tm;
1933 sec = obj_create_alloced_section(f, ".kmodtab", tgt_sizeof_void_p,
1934 (sizeof(struct new_module_ref)
1935 * n_ext_modules_used));
1939 tm = obj_find_symbol(f, "__this_module");
1940 dep = (struct new_module_ref *) sec->contents;
1941 for (i = 0; i < n_ext_modules; ++i)
1942 if (ext_modules[i].used) {
1943 dep->dep = ext_modules[i].addr;
1944 obj_symbol_patch(f, sec->idx,
1945 (char *) &dep->ref - sec->contents, tm);
1951 if (flag_export && !obj_find_section(f, "__ksymtab")) {
1956 obj_create_alloced_section(f, "__ksymtab", tgt_sizeof_void_p,
1959 /* We don't want to export symbols residing in sections that
1960 aren't loaded. There are a number of these created so that
1961 we make sure certain module options don't appear twice. */
1963 loaded = alloca(sizeof(int) * (i = f->header.e_shnum));
1965 loaded[i] = (f->sections[i]->header.sh_flags & SHF_ALLOC) != 0;
1967 for (nsyms = i = 0; i < HASH_BUCKETS; ++i) {
1968 struct obj_symbol *sym;
1969 for (sym = f->symtab[i]; sym; sym = sym->next)
1970 if (ELFW(ST_BIND) (sym->info) != STB_LOCAL
1971 && sym->secidx <= SHN_HIRESERVE
1972 && (sym->secidx >= SHN_LORESERVE
1973 || loaded[sym->secidx])) {
1974 ElfW(Addr) ofs = nsyms * 2 * tgt_sizeof_void_p;
1976 obj_symbol_patch(f, sec->idx, ofs, sym);
1977 obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p,
1984 obj_extend_section(sec, nsyms * 2 * tgt_sizeof_char_p);
1992 new_init_module(const char *m_name, struct obj_file *f,
1993 unsigned long m_size)
1995 struct new_module *module;
1996 struct obj_section *sec;
2001 sec = obj_find_section(f, ".this");
2002 module = (struct new_module *) sec->contents;
2003 m_addr = sec->header.sh_addr;
2005 module->size_of_struct = sizeof(*module);
2006 module->size = m_size;
2007 module->flags = flag_autoclean ? NEW_MOD_AUTOCLEAN : 0;
2009 sec = obj_find_section(f, "__ksymtab");
2010 if (sec && sec->header.sh_size) {
2011 module->syms = sec->header.sh_addr;
2012 module->nsyms = sec->header.sh_size / (2 * tgt_sizeof_char_p);
2015 if (n_ext_modules_used) {
2016 sec = obj_find_section(f, ".kmodtab");
2017 module->deps = sec->header.sh_addr;
2018 module->ndeps = n_ext_modules_used;
2022 obj_symbol_final_value(f, obj_find_symbol(f, "init_module"));
2024 obj_symbol_final_value(f, obj_find_symbol(f, "cleanup_module"));
2026 sec = obj_find_section(f, "__ex_table");
2028 module->ex_table_start = sec->header.sh_addr;
2029 module->ex_table_end = sec->header.sh_addr + sec->header.sh_size;
2032 sec = obj_find_section(f, ".text.init");
2034 module->runsize = sec->header.sh_addr - m_addr;
2036 sec = obj_find_section(f, ".data.init");
2038 if (!module->runsize ||
2039 module->runsize > sec->header.sh_addr - m_addr)
2040 module->runsize = sec->header.sh_addr - m_addr;
2043 if (!arch_init_module(f, module))
2046 /* Whew! All of the initialization is complete. Collect the final
2047 module image and give it to the kernel. */
2049 image = xmalloc(m_size);
2050 obj_create_image(f, image);
2052 ret = new_sys_init_module(m_name, (struct new_module *) image);
2054 errorMsg("init_module: %s: %s", m_name, strerror(errno));
2063 #define new_init_module(x, y, z) TRUE
2064 #define new_create_this_module(x, y) 0
2065 #define new_create_module_ksymtab(x)
2067 #endif /* BB_FEATURE_INSMOD_OLD_KERNEL */
2070 /*======================================================================*/
2073 obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2076 struct obj_string_patch *p;
2077 struct obj_section *strsec;
2078 size_t len = strlen(string) + 1;
2081 p = xmalloc(sizeof(*p));
2082 p->next = f->string_patches;
2083 p->reloc_secidx = secidx;
2084 p->reloc_offset = offset;
2085 f->string_patches = p;
2087 strsec = obj_find_section(f, ".kstrtab");
2088 if (strsec == NULL) {
2089 strsec = obj_create_alloced_section(f, ".kstrtab", 1, len);
2090 p->string_offset = 0;
2091 loc = strsec->contents;
2093 p->string_offset = strsec->header.sh_size;
2094 loc = obj_extend_section(strsec, len);
2096 memcpy(loc, string, len);
2102 obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2103 struct obj_symbol *sym)
2105 struct obj_symbol_patch *p;
2107 p = xmalloc(sizeof(*p));
2108 p->next = f->symbol_patches;
2109 p->reloc_secidx = secidx;
2110 p->reloc_offset = offset;
2112 f->symbol_patches = p;
2117 int obj_check_undefineds(struct obj_file *f)
2122 for (i = 0; i < HASH_BUCKETS; ++i) {
2123 struct obj_symbol *sym;
2124 for (sym = f->symtab[i]; sym; sym = sym->next)
2125 if (sym->secidx == SHN_UNDEF) {
2126 if (ELFW(ST_BIND) (sym->info) == STB_WEAK) {
2127 sym->secidx = SHN_ABS;
2130 errorMsg("unresolved symbol %s\n", sym->name);
2139 void obj_allocate_commons(struct obj_file *f)
2141 struct common_entry {
2142 struct common_entry *next;
2143 struct obj_symbol *sym;
2144 } *common_head = NULL;
2148 for (i = 0; i < HASH_BUCKETS; ++i) {
2149 struct obj_symbol *sym;
2150 for (sym = f->symtab[i]; sym; sym = sym->next)
2151 if (sym->secidx == SHN_COMMON) {
2152 /* Collect all COMMON symbols and sort them by size so as to
2153 minimize space wasted by alignment requirements. */
2155 struct common_entry **p, *n;
2156 for (p = &common_head; *p; p = &(*p)->next)
2157 if (sym->size <= (*p)->sym->size)
2160 n = alloca(sizeof(*n));
2168 for (i = 1; i < f->local_symtab_size; ++i) {
2169 struct obj_symbol *sym = f->local_symtab[i];
2170 if (sym && sym->secidx == SHN_COMMON) {
2171 struct common_entry **p, *n;
2172 for (p = &common_head; *p; p = &(*p)->next)
2173 if (sym == (*p)->sym)
2175 else if (sym->size < (*p)->sym->size) {
2176 n = alloca(sizeof(*n));
2186 /* Find the bss section. */
2187 for (i = 0; i < f->header.e_shnum; ++i)
2188 if (f->sections[i]->header.sh_type == SHT_NOBITS)
2191 /* If for some reason there hadn't been one, create one. */
2192 if (i == f->header.e_shnum) {
2193 struct obj_section *sec;
2195 f->sections = xrealloc(f->sections, (i + 1) * sizeof(sec));
2196 f->sections[i] = sec = arch_new_section();
2197 f->header.e_shnum = i + 1;
2199 memset(sec, 0, sizeof(*sec));
2200 sec->header.sh_type = SHT_PROGBITS;
2201 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2206 /* Allocate the COMMONS. */
2208 ElfW(Addr) bss_size = f->sections[i]->header.sh_size;
2209 ElfW(Addr) max_align = f->sections[i]->header.sh_addralign;
2210 struct common_entry *c;
2212 for (c = common_head; c; c = c->next) {
2213 ElfW(Addr) align = c->sym->value;
2215 if (align > max_align)
2217 if (bss_size & (align - 1))
2218 bss_size = (bss_size | (align - 1)) + 1;
2221 c->sym->value = bss_size;
2223 bss_size += c->sym->size;
2226 f->sections[i]->header.sh_size = bss_size;
2227 f->sections[i]->header.sh_addralign = max_align;
2231 /* For the sake of patch relocation and parameter initialization,
2232 allocate zeroed data for NOBITS sections now. Note that after
2233 this we cannot assume NOBITS are really empty. */
2234 for (i = 0; i < f->header.e_shnum; ++i) {
2235 struct obj_section *s = f->sections[i];
2236 if (s->header.sh_type == SHT_NOBITS) {
2237 s->contents = memset(xmalloc(s->header.sh_size),
2238 0, s->header.sh_size);
2239 s->header.sh_type = SHT_PROGBITS;
2244 unsigned long obj_load_size(struct obj_file *f)
2246 unsigned long dot = 0;
2247 struct obj_section *sec;
2249 /* Finalize the positions of the sections relative to one another. */
2251 for (sec = f->load_order; sec; sec = sec->load_next) {
2254 align = sec->header.sh_addralign;
2255 if (align && (dot & (align - 1)))
2256 dot = (dot | (align - 1)) + 1;
2258 sec->header.sh_addr = dot;
2259 dot += sec->header.sh_size;
2265 int obj_relocate(struct obj_file *f, ElfW(Addr) base)
2267 int i, n = f->header.e_shnum;
2270 /* Finalize the addresses of the sections. */
2273 for (i = 0; i < n; ++i)
2274 f->sections[i]->header.sh_addr += base;
2276 /* And iterate over all of the relocations. */
2278 for (i = 0; i < n; ++i) {
2279 struct obj_section *relsec, *symsec, *targsec, *strsec;
2280 ElfW(RelM) * rel, *relend;
2284 relsec = f->sections[i];
2285 if (relsec->header.sh_type != SHT_RELM)
2288 symsec = f->sections[relsec->header.sh_link];
2289 targsec = f->sections[relsec->header.sh_info];
2290 strsec = f->sections[symsec->header.sh_link];
2292 rel = (ElfW(RelM) *) relsec->contents;
2293 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
2294 symtab = (ElfW(Sym) *) symsec->contents;
2295 strtab = (const char *) strsec->contents;
2297 for (; rel < relend; ++rel) {
2298 ElfW(Addr) value = 0;
2299 struct obj_symbol *intsym = NULL;
2300 unsigned long symndx;
2301 ElfW(Sym) * extsym = 0;
2304 /* Attempt to find a value to use for this relocation. */
2306 symndx = ELFW(R_SYM) (rel->r_info);
2308 /* Note we've already checked for undefined symbols. */
2310 extsym = &symtab[symndx];
2311 if (ELFW(ST_BIND) (extsym->st_info) == STB_LOCAL) {
2312 /* Local symbols we look up in the local table to be sure
2313 we get the one that is really intended. */
2314 intsym = f->local_symtab[symndx];
2316 /* Others we look up in the hash table. */
2318 if (extsym->st_name)
2319 name = strtab + extsym->st_name;
2321 name = f->sections[extsym->st_shndx]->name;
2322 intsym = obj_find_symbol(f, name);
2325 value = obj_symbol_final_value(f, intsym);
2326 intsym->referenced = 1;
2328 #if SHT_RELM == SHT_RELA
2329 #if defined(__alpha__) && defined(AXP_BROKEN_GAS)
2330 /* Work around a nasty GAS bug, that is fixed as of 2.7.0.9. */
2331 if (!extsym || !extsym->st_name ||
2332 ELFW(ST_BIND) (extsym->st_info) != STB_LOCAL)
2334 value += rel->r_addend;
2338 switch (arch_apply_relocation
2339 (f, targsec, symsec, intsym, rel, value)) {
2343 case obj_reloc_overflow:
2344 errmsg = "Relocation overflow";
2346 case obj_reloc_dangerous:
2347 errmsg = "Dangerous relocation";
2349 case obj_reloc_unhandled:
2350 errmsg = "Unhandled relocation";
2353 errorMsg("%s of type %ld for %s\n", errmsg,
2354 (long) ELFW(R_TYPE) (rel->r_info),
2355 strtab + extsym->st_name);
2357 errorMsg("%s of type %ld\n", errmsg,
2358 (long) ELFW(R_TYPE) (rel->r_info));
2366 /* Finally, take care of the patches. */
2368 if (f->string_patches) {
2369 struct obj_string_patch *p;
2370 struct obj_section *strsec;
2371 ElfW(Addr) strsec_base;
2372 strsec = obj_find_section(f, ".kstrtab");
2373 strsec_base = strsec->header.sh_addr;
2375 for (p = f->string_patches; p; p = p->next) {
2376 struct obj_section *targsec = f->sections[p->reloc_secidx];
2377 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
2378 = strsec_base + p->string_offset;
2382 if (f->symbol_patches) {
2383 struct obj_symbol_patch *p;
2385 for (p = f->symbol_patches; p; p = p->next) {
2386 struct obj_section *targsec = f->sections[p->reloc_secidx];
2387 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
2388 = obj_symbol_final_value(f, p->sym);
2395 int obj_create_image(struct obj_file *f, char *image)
2397 struct obj_section *sec;
2398 ElfW(Addr) base = f->baseaddr;
2400 for (sec = f->load_order; sec; sec = sec->load_next) {
2403 if (sec->header.sh_size == 0)
2406 secimg = image + (sec->header.sh_addr - base);
2408 /* Note that we allocated data for NOBITS sections earlier. */
2409 memcpy(secimg, sec->contents, sec->header.sh_size);
2415 /*======================================================================*/
2417 struct obj_file *obj_load(FILE * fp)
2420 ElfW(Shdr) * section_headers;
2424 /* Read the file header. */
2426 f = arch_new_file();
2427 memset(f, 0, sizeof(*f));
2428 f->symbol_cmp = strcmp;
2429 f->symbol_hash = obj_elf_hash;
2430 f->load_order_search_start = &f->load_order;
2432 fseek(fp, 0, SEEK_SET);
2433 if (fread(&f->header, sizeof(f->header), 1, fp) != 1) {
2434 errorMsg("error reading ELF header: %s", strerror(errno));
2438 if (f->header.e_ident[EI_MAG0] != ELFMAG0
2439 || f->header.e_ident[EI_MAG1] != ELFMAG1
2440 || f->header.e_ident[EI_MAG2] != ELFMAG2
2441 || f->header.e_ident[EI_MAG3] != ELFMAG3) {
2442 errorMsg("not an ELF file\n");
2445 if (f->header.e_ident[EI_CLASS] != ELFCLASSM
2446 || f->header.e_ident[EI_DATA] != ELFDATAM
2447 || f->header.e_ident[EI_VERSION] != EV_CURRENT
2448 || !MATCH_MACHINE(f->header.e_machine)) {
2449 errorMsg("ELF file not for this architecture\n");
2452 if (f->header.e_type != ET_REL) {
2453 errorMsg("ELF file not a relocatable object\n");
2457 /* Read the section headers. */
2459 if (f->header.e_shentsize != sizeof(ElfW(Shdr))) {
2460 errorMsg("section header size mismatch: %lu != %lu\n",
2461 (unsigned long) f->header.e_shentsize,
2462 (unsigned long) sizeof(ElfW(Shdr)));
2466 shnum = f->header.e_shnum;
2467 f->sections = xmalloc(sizeof(struct obj_section *) * shnum);
2468 memset(f->sections, 0, sizeof(struct obj_section *) * shnum);
2470 section_headers = alloca(sizeof(ElfW(Shdr)) * shnum);
2471 fseek(fp, f->header.e_shoff, SEEK_SET);
2472 if (fread(section_headers, sizeof(ElfW(Shdr)), shnum, fp) != shnum) {
2473 errorMsg("error reading ELF section headers: %s", strerror(errno));
2477 /* Read the section data. */
2479 for (i = 0; i < shnum; ++i) {
2480 struct obj_section *sec;
2482 f->sections[i] = sec = arch_new_section();
2483 memset(sec, 0, sizeof(*sec));
2485 sec->header = section_headers[i];
2488 switch (sec->header.sh_type) {
2499 if (sec->header.sh_size > 0) {
2500 sec->contents = xmalloc(sec->header.sh_size);
2501 fseek(fp, sec->header.sh_offset, SEEK_SET);
2502 if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
2503 errorMsg("error reading ELF section data: %s", strerror(errno));
2507 sec->contents = NULL;
2511 #if SHT_RELM == SHT_REL
2513 errorMsg("RELA relocations not supported on this architecture\n");
2517 errorMsg("REL relocations not supported on this architecture\n");
2522 if (sec->header.sh_type >= SHT_LOPROC) {
2523 /* Assume processor specific section types are debug
2524 info and can safely be ignored. If this is ever not
2525 the case (Hello MIPS?), don't put ifdefs here but
2526 create an arch_load_proc_section(). */
2530 errorMsg("can't handle sections of type %ld\n",
2531 (long) sec->header.sh_type);
2536 /* Do what sort of interpretation as needed by each section. */
2538 shstrtab = f->sections[f->header.e_shstrndx]->contents;
2540 for (i = 0; i < shnum; ++i) {
2541 struct obj_section *sec = f->sections[i];
2542 sec->name = shstrtab + sec->header.sh_name;
2545 for (i = 0; i < shnum; ++i) {
2546 struct obj_section *sec = f->sections[i];
2548 if (sec->header.sh_flags & SHF_ALLOC)
2549 obj_insert_section_load_order(f, sec);
2551 switch (sec->header.sh_type) {
2554 unsigned long nsym, j;
2558 if (sec->header.sh_entsize != sizeof(ElfW(Sym))) {
2559 errorMsg("symbol size mismatch: %lu != %lu\n",
2560 (unsigned long) sec->header.sh_entsize,
2561 (unsigned long) sizeof(ElfW(Sym)));
2565 nsym = sec->header.sh_size / sizeof(ElfW(Sym));
2566 strtab = f->sections[sec->header.sh_link]->contents;
2567 sym = (ElfW(Sym) *) sec->contents;
2569 /* Allocate space for a table of local symbols. */
2570 j = f->local_symtab_size = sec->header.sh_info;
2571 f->local_symtab = xmalloc(j *=
2572 sizeof(struct obj_symbol *));
2573 memset(f->local_symtab, 0, j);
2575 /* Insert all symbols into the hash table. */
2576 for (j = 1, ++sym; j < nsym; ++j, ++sym) {
2579 name = strtab + sym->st_name;
2581 name = f->sections[sym->st_shndx]->name;
2583 obj_add_symbol(f, name, j, sym->st_info, sym->st_shndx,
2584 sym->st_value, sym->st_size);
2590 if (sec->header.sh_entsize != sizeof(ElfW(RelM))) {
2591 errorMsg("relocation entry size mismatch: %lu != %lu\n",
2592 (unsigned long) sec->header.sh_entsize,
2593 (unsigned long) sizeof(ElfW(RelM)));
2603 static void hide_special_symbols(struct obj_file *f)
2605 static const char *const specials[] = {
2612 struct obj_symbol *sym;
2613 const char *const *p;
2615 for (p = specials; *p; ++p)
2616 if ((sym = obj_find_symbol(f, *p)) != NULL)
2618 ELFW(ST_INFO) (STB_LOCAL, ELFW(ST_TYPE) (sym->info));
2623 extern int insmod_main( int argc, char **argv)
2629 unsigned long m_size;
2633 char m_name[BUFSIZ + 1] = "\0";
2634 int exit_status = FALSE;
2636 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
2638 char k_strversion[STRVERSIONLEN];
2639 char m_strversion[STRVERSIONLEN];
2646 usage(insmod_usage);
2649 /* Parse any options */
2650 while (--argc > 0 && **(++argv) == '-') {
2651 while (*(++(*argv))) {
2653 case 'f': /* force loading */
2654 flag_force_load = 1;
2656 case 'k': /* module loaded by kerneld, auto-cleanable */
2659 case 'v': /* verbose output */
2662 case 'x': /* do not export externs */
2666 usage(insmod_usage);
2672 usage(insmod_usage);
2674 /* Grab the module name */
2675 if ((tmp = strrchr(*argv, '/')) != NULL) {
2682 if (len > 2 && tmp[len - 2] == '.' && tmp[len - 1] == 'o')
2684 memcpy(m_name, tmp, len);
2685 strcpy(m_fullName, m_name);
2686 strcat(m_fullName, ".o");
2688 /* Get a filedesc for the module */
2689 if ((fp = fopen(*argv, "r")) == NULL) {
2690 /* Hmpf. Could not open it. Search through _PATH_MODULES to find a module named m_name */
2691 if (recursiveAction(_PATH_MODULES, TRUE, FALSE, FALSE,
2692 findNamedModule, 0, m_fullName) == FALSE)
2694 if (m_filename[0] == '\0'
2695 || ((fp = fopen(m_filename, "r")) == NULL))
2697 errorMsg("No module named '%s' found in '%s'\n", m_fullName, _PATH_MODULES);
2701 fatalError("No module named '%s' found in '%s'\n", m_fullName, _PATH_MODULES);
2703 memcpy(m_filename, *argv, strlen(*argv));
2706 if ((f = obj_load(fp)) == NULL) {
2707 perror("Could not load the module\n");
2711 if (get_modinfo_value(f, "kernel_version") == NULL)
2716 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
2717 /* Version correspondence? */
2719 k_version = get_kernel_version(k_strversion);
2720 if (m_has_modinfo) {
2721 m_version = new_get_module_version(f, m_strversion);
2723 m_version = old_get_module_version(f, m_strversion);
2724 if (m_version == -1) {
2725 errorMsg("couldn't find the kernel version the module was "
2731 if (strncmp(k_strversion, m_strversion, STRVERSIONLEN) != 0) {
2732 if (flag_force_load) {
2733 errorMsg("Warning: kernel-module version mismatch\n"
2734 "\t%s was compiled for kernel version %s\n"
2735 "\twhile this kernel is version %s\n",
2736 m_filename, m_strversion, k_strversion);
2738 errorMsg("kernel-module version mismatch\n"
2739 "\t%s was compiled for kernel version %s\n"
2740 "\twhile this kernel is version %s.\n",
2741 m_filename, m_strversion, k_strversion);
2746 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
2748 k_new_syscalls = !query_module(NULL, 0, NULL, 0, NULL);
2750 if (k_new_syscalls) {
2751 #ifdef BB_FEATURE_INSMOD_NEW_KERNEL
2752 if (!new_get_kernel_symbols())
2754 k_crcs = new_is_kernel_checksummed();
2756 errorMsg("Not configured to support new kernels\n");
2760 #ifdef BB_FEATURE_INSMOD_OLD_KERNEL
2761 if (!old_get_kernel_symbols(m_name))
2763 k_crcs = old_is_kernel_checksummed();
2765 errorMsg("Not configured to support old kernels\n");
2770 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
2772 m_crcs = new_is_module_checksummed(f);
2774 m_crcs = old_is_module_checksummed(f);
2776 if (m_crcs != k_crcs)
2777 obj_set_symbol_compare(f, ncv_strcmp, ncv_symbol_hash);
2778 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
2780 /* Let the module know about the kernel symbols. */
2781 add_kernel_symbols(f);
2783 /* Allocate common symbols, symbol tables, and string tables. */
2786 ? !new_create_this_module(f, m_name)
2787 : !old_create_mod_use_count(f))
2792 if (!obj_check_undefineds(f)) {
2795 obj_allocate_commons(f);
2797 if (optind < argc) {
2799 ? !new_process_module_arguments(f, argc - optind, argv + optind)
2800 : !old_process_module_arguments(f, argc - optind, argv + optind))
2807 hide_special_symbols(f);
2810 new_create_module_ksymtab(f);
2812 /* Find current size of the module */
2813 m_size = obj_load_size(f);
2817 m_addr = create_module(m_name, m_size);
2822 errorMsg("A module named %s already exists\n", m_name);
2825 errorMsg("Can't allocate kernel memory for module; needed %lu bytes\n",
2829 errorMsg("create_module: %s: %s", m_name, strerror(errno));
2833 if (!obj_relocate(f, m_addr)) {
2834 delete_module(m_name);
2839 ? !new_init_module(m_name, f, m_size)
2840 : !old_init_module(m_name, f, m_size))
2842 delete_module(m_name);
2850 return(exit_status);