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
41 #include <sys/utsname.h>
42 #include <sys/syscall.h>
43 #include <linux/unistd.h>
45 //----------------------------------------------------------------------------
46 //--------modutils module.h, lines 45-242
47 //----------------------------------------------------------------------------
49 /* Definitions for the Linux module syscall interface.
50 Copyright 1996, 1997 Linux International.
52 Contributed by Richard Henderson <rth@tamu.edu>
54 This file is part of the Linux modutils.
56 This program is free software; you can redistribute it and/or modify it
57 under the terms of the GNU General Public License as published by the
58 Free Software Foundation; either version 2 of the License, or (at your
59 option) any later version.
61 This program is distributed in the hope that it will be useful, but
62 WITHOUT ANY WARRANTY; without even the implied warranty of
63 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
64 General Public License for more details.
66 You should have received a copy of the GNU General Public License
67 along with this program; if not, write to the Free Software Foundation,
68 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
71 #ifndef MODUTILS_MODULE_H
72 #define MODUTILS_MODULE_H 1
74 #ident "$Id: insmod.c,v 1.12 2000/07/08 18:55:24 andersen Exp $"
76 /* This file contains the structures used by the 2.0 and 2.1 kernels.
77 We do not use the kernel headers directly because we do not wish
78 to be dependant on a particular kernel version to compile insmod. */
81 /*======================================================================*/
82 /* The structures used by Linux 2.0. */
84 /* The symbol format used by get_kernel_syms(2). */
93 unsigned long module; /* kernel addresses */
97 struct old_module_symbol
103 struct old_symbol_table
105 int size; /* total, including string table!!! */
108 struct old_module_symbol symbol[0]; /* actual size defined by n_symbols */
109 struct old_module_ref ref[0]; /* actual size defined by n_refs */
112 struct old_mod_routines
115 unsigned long cleanup;
121 unsigned long ref; /* the list of modules that refer to me */
122 unsigned long symtab;
124 int size; /* size of module in pages */
125 unsigned long addr; /* address of module */
127 unsigned long cleanup; /* cleanup routine */
130 /* Sent to init_module(2) or'ed into the code size parameter. */
131 #define OLD_MOD_AUTOCLEAN 0x40000000 /* big enough, but no sign problems... */
133 int get_kernel_syms(struct old_kernel_sym *);
134 int old_sys_init_module(const char *name, char *code, unsigned codesize,
135 struct old_mod_routines *, struct old_symbol_table *);
137 /*======================================================================*/
138 /* For sizeof() which are related to the module platform and not to the
139 environment isnmod is running in, use sizeof_xx instead of sizeof(xx). */
141 #define tgt_sizeof_char sizeof(char)
142 #define tgt_sizeof_short sizeof(short)
143 #define tgt_sizeof_int sizeof(int)
144 #define tgt_sizeof_long sizeof(long)
145 #define tgt_sizeof_char_p sizeof(char *)
146 #define tgt_sizeof_void_p sizeof(void *)
147 #define tgt_long long
149 #if defined(__sparc__) && !defined(__sparc_v9__) && defined(ARCH_sparc64)
150 #undef tgt_sizeof_long
151 #undef tgt_sizeof_char_p
152 #undef tgt_sizeof_void_p
154 #define tgt_sizeof_long 8
155 #define tgt_sizeof_char_p 8
156 #define tgt_sizeof_void_p 8
157 #define tgt_long long long
160 /*======================================================================*/
161 /* The structures used in Linux 2.1. */
163 /* Note: new_module_symbol does not use tgt_long intentionally */
164 struct new_module_symbol
170 struct new_module_persist;
172 struct new_module_ref
174 unsigned tgt_long dep; /* kernel addresses */
175 unsigned tgt_long ref;
176 unsigned tgt_long next_ref;
181 unsigned tgt_long size_of_struct; /* == sizeof(module) */
182 unsigned tgt_long next;
183 unsigned tgt_long name;
184 unsigned tgt_long size;
187 unsigned tgt_long flags; /* AUTOCLEAN et al */
192 unsigned tgt_long syms;
193 unsigned tgt_long deps;
194 unsigned tgt_long refs;
195 unsigned tgt_long init;
196 unsigned tgt_long cleanup;
197 unsigned tgt_long ex_table_start;
198 unsigned tgt_long ex_table_end;
200 unsigned tgt_long gp;
202 /* Everything after here is extension. */
203 unsigned tgt_long persist_start;
204 unsigned tgt_long persist_end;
205 unsigned tgt_long can_unload;
206 unsigned tgt_long runsize;
209 struct new_module_info
217 /* Bits of module.flags. */
218 #define NEW_MOD_RUNNING 1
219 #define NEW_MOD_DELETED 2
220 #define NEW_MOD_AUTOCLEAN 4
221 #define NEW_MOD_VISITED 8
222 #define NEW_MOD_USED_ONCE 16
224 int new_sys_init_module(const char *name, const struct new_module *);
225 int query_module(const char *name, int which, void *buf, size_t bufsize,
228 /* Values for query_module's which. */
236 /*======================================================================*/
237 /* The system calls unchanged between 2.0 and 2.1. */
239 unsigned long create_module(const char *, size_t);
240 int delete_module(const char *);
243 #endif /* module.h */
245 //----------------------------------------------------------------------------
246 //--------end of modutils module.h
247 //----------------------------------------------------------------------------
251 //----------------------------------------------------------------------------
252 //--------modutils obj.h, lines 253-462
253 //----------------------------------------------------------------------------
255 /* Elf object file loading and relocation routines.
256 Copyright 1996, 1997 Linux International.
258 Contributed by Richard Henderson <rth@tamu.edu>
260 This file is part of the Linux modutils.
262 This program is free software; you can redistribute it and/or modify it
263 under the terms of the GNU General Public License as published by the
264 Free Software Foundation; either version 2 of the License, or (at your
265 option) any later version.
267 This program is distributed in the hope that it will be useful, but
268 WITHOUT ANY WARRANTY; without even the implied warranty of
269 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
270 General Public License for more details.
272 You should have received a copy of the GNU General Public License
273 along with this program; if not, write to the Free Software Foundation,
274 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
277 #ifndef MODUTILS_OBJ_H
278 #define MODUTILS_OBJ_H 1
280 #ident "$Id: insmod.c,v 1.12 2000/07/08 18:55:24 andersen Exp $"
282 /* The relocatable object is manipulated using elfin types. */
288 /* Machine-specific elf macros for i386 et al. */
290 #define ELFCLASSM ELFCLASS32
291 #define ELFDATAM ELFDATA2LSB
293 #define MATCH_MACHINE(x) (x == EM_386 || x == EM_486)
295 #define SHT_RELM SHT_REL
296 #define Elf32_RelM Elf32_Rel
300 # if ELFCLASSM == ELFCLASS32
301 # define ElfW(x) Elf32_ ## x
302 # define ELFW(x) ELF32_ ## x
304 # define ElfW(x) Elf64_ ## x
305 # define ELFW(x) ELF64_ ## x
309 /* For some reason this is missing from libc5. */
310 #ifndef ELF32_ST_INFO
311 # define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
314 #ifndef ELF64_ST_INFO
315 # define ELF64_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
318 struct obj_string_patch;
319 struct obj_symbol_patch;
326 struct obj_section *load_next;
332 struct obj_symbol *next; /* hash table link */
336 int secidx; /* the defining section index/module */
338 int ksymidx; /* for export to the kernel symtab */
339 int referenced; /* actually used in the link */
342 /* Hardcode the hash table size. We shouldn't be needing so many
343 symbols that we begin to degrade performance, and we get a big win
344 by giving the compiler a constant divisor. */
346 #define HASH_BUCKETS 521
352 struct obj_section **sections;
353 struct obj_section *load_order;
354 struct obj_section **load_order_search_start;
355 struct obj_string_patch *string_patches;
356 struct obj_symbol_patch *symbol_patches;
357 int (*symbol_cmp)(const char *, const char *);
358 unsigned long (*symbol_hash)(const char *);
359 unsigned long local_symtab_size;
360 struct obj_symbol **local_symtab;
361 struct obj_symbol *symtab[HASH_BUCKETS];
372 struct obj_string_patch
374 struct obj_string_patch *next;
376 ElfW(Addr) reloc_offset;
377 ElfW(Addr) string_offset;
380 struct obj_symbol_patch
382 struct obj_symbol_patch *next;
384 ElfW(Addr) reloc_offset;
385 struct obj_symbol *sym;
389 /* Generic object manipulation routines. */
391 unsigned long obj_elf_hash(const char *);
393 unsigned long obj_elf_hash_n(const char *, unsigned long len);
395 struct obj_symbol *obj_add_symbol (struct obj_file *f, const char *name,
396 unsigned long symidx, int info, int secidx,
397 ElfW(Addr) value, unsigned long size);
399 struct obj_symbol *obj_find_symbol (struct obj_file *f,
402 ElfW(Addr) obj_symbol_final_value(struct obj_file *f,
403 struct obj_symbol *sym);
405 void obj_set_symbol_compare(struct obj_file *f,
406 int (*cmp)(const char *, const char *),
407 unsigned long (*hash)(const char *));
409 struct obj_section *obj_find_section (struct obj_file *f,
412 void obj_insert_section_load_order (struct obj_file *f,
413 struct obj_section *sec);
415 struct obj_section *obj_create_alloced_section (struct obj_file *f,
420 struct obj_section *obj_create_alloced_section_first (struct obj_file *f,
425 void *obj_extend_section (struct obj_section *sec, unsigned long more);
427 int obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
430 int obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
431 struct obj_symbol *sym);
433 int obj_check_undefineds(struct obj_file *f);
435 void obj_allocate_commons(struct obj_file *f);
437 unsigned long obj_load_size (struct obj_file *f);
439 int obj_relocate (struct obj_file *f, ElfW(Addr) base);
441 struct obj_file *obj_load(FILE *f);
443 int obj_create_image (struct obj_file *f, char *image);
445 /* Architecture specific manipulation routines. */
447 struct obj_file *arch_new_file (void);
449 struct obj_section *arch_new_section (void);
451 struct obj_symbol *arch_new_symbol (void);
453 enum obj_reloc arch_apply_relocation (struct obj_file *f,
454 struct obj_section *targsec,
455 struct obj_section *symsec,
456 struct obj_symbol *sym,
457 ElfW(RelM) *rel, ElfW(Addr) value);
459 int arch_create_got (struct obj_file *f);
462 int arch_init_module (struct obj_file *f, struct new_module *);
465 //----------------------------------------------------------------------------
466 //--------end of modutils obj.h
467 //----------------------------------------------------------------------------
473 #define _PATH_MODULES "/lib/modules"
474 #define STRVERSIONLEN 32
476 #if !defined(BB_FEATURE_INSMOD_NEW_KERNEL) && !defined(BB_FEATURE_INSMOD_OLD_KERNEL)
477 #error "Must have ether BB_FEATURE_INSMOD_NEW_KERNEL or BB_FEATURE_INSMOD_OLD_KERNEL defined"
480 /*======================================================================*/
482 int flag_force_load = 0;
483 int flag_autoclean = 0;
484 int flag_verbose = 0;
488 /*======================================================================*/
490 struct i386_got_entry {
492 unsigned offset_done:1;
493 unsigned reloc_done:1;
497 struct obj_file root;
498 struct obj_section *got;
502 struct obj_symbol root;
503 struct i386_got_entry gotent;
508 struct external_module {
513 struct new_module_symbol *syms;
516 struct new_module_symbol *ksyms;
519 struct external_module *ext_modules;
521 int n_ext_modules_used;
525 /* Some firendly syscalls to cheer everyone's day... */
526 #define __NR_new_sys_init_module __NR_init_module
527 _syscall2(int, new_sys_init_module, const char *, name,
528 const struct new_module *, info)
529 #define __NR_old_sys_init_module __NR_init_module
530 _syscall5(int, old_sys_init_module, const char *, name, char *, code,
531 unsigned, codesize, struct old_mod_routines *, routines,
532 struct old_symbol_table *, symtab)
533 #ifndef __NR_query_module
534 #define __NR_query_module 167
536 _syscall5(int, query_module, const char *, name, int, which,
537 void *, buf, size_t, bufsize, size_t*, ret);
539 _syscall1(int, delete_module, const char *, name)
541 extern int delete_module(const char *);
544 #if defined(__i386__) || defined(__m68k__) || defined(__arm__)
545 /* Jump through hoops to fixup error return codes */
546 #define __NR__create_module __NR_create_module
547 static inline _syscall2(long, _create_module, const char *, name, size_t,
549 unsigned long create_module(const char *name, size_t size)
551 long ret = _create_module(name, size);
553 if (ret == -1 && errno > 125) {
560 _syscall2(unsigned long, create_module, const char *, name, size_t, size)
562 static char m_filename[BUFSIZ + 1] = "\0";
563 static char m_fullName[BUFSIZ + 1] = "\0";
564 static const char insmod_usage[] =
565 "insmod [OPTION]... MODULE [symbol=value]...\n"
566 #ifndef BB_FEATURE_TRIVIAL_HELP
567 "\nLoads the specified kernel modules into the kernel.\n\n"
569 "\t-f\tForce module to load into the wrong kernel version.\n"
570 "\t-k\tMake module autoclean-able.\n"
571 "\t-v\tverbose output\n" "\t-x\tdo not export externs\n"
575 /*======================================================================*/
577 void *xrealloc(void *old, size_t size)
579 void *ptr = realloc(old, size);
581 perror("Out of memory");
588 static int findNamedModule(const char *fileName, struct stat *statbuf,
591 char *fullName = (char *) userDate;
594 if (fullName[0] == '\0')
597 char *tmp = strrchr(fileName, '/');
600 tmp = (char *) fileName;
603 if (check_wildcard_match(tmp, fullName) == TRUE) {
604 /* Stop searching if we find a match */
605 memcpy(m_filename, fileName, strlen(fileName));
613 /*======================================================================*/
615 struct obj_file *arch_new_file(void)
618 f = xmalloc(sizeof(*f));
623 struct obj_section *arch_new_section(void)
625 return xmalloc(sizeof(struct obj_section));
628 struct obj_symbol *arch_new_symbol(void)
630 struct i386_symbol *sym;
631 sym = xmalloc(sizeof(*sym));
632 memset(&sym->gotent, 0, sizeof(sym->gotent));
636 arch_apply_relocation(struct obj_file *f,
637 struct obj_section *targsec,
638 struct obj_section *symsec,
639 struct obj_symbol *sym,
640 Elf32_Rel * rel, Elf32_Addr v)
642 struct i386_file *ifile = (struct i386_file *) f;
643 struct i386_symbol *isym = (struct i386_symbol *) sym;
645 Elf32_Addr *loc = (Elf32_Addr *) (targsec->contents + rel->r_offset);
646 Elf32_Addr dot = targsec->header.sh_addr + rel->r_offset;
647 Elf32_Addr got = ifile->got ? ifile->got->header.sh_addr : 0;
649 enum obj_reloc ret = obj_reloc_ok;
651 switch (ELF32_R_TYPE(rel->r_info)) {
679 assert(isym != NULL);
680 if (!isym->gotent.reloc_done) {
681 isym->gotent.reloc_done = 1;
682 *(Elf32_Addr *) (ifile->got->contents + isym->gotent.offset) =
685 *loc += isym->gotent.offset;
694 ret = obj_reloc_unhandled;
701 int arch_create_got(struct obj_file *f)
703 struct i386_file *ifile = (struct i386_file *) f;
704 int i, n, offset = 0, gotneeded = 0;
706 n = ifile->root.header.e_shnum;
707 for (i = 0; i < n; ++i) {
708 struct obj_section *relsec, *symsec, *strsec;
709 Elf32_Rel *rel, *relend;
713 relsec = ifile->root.sections[i];
714 if (relsec->header.sh_type != SHT_REL)
717 symsec = ifile->root.sections[relsec->header.sh_link];
718 strsec = ifile->root.sections[symsec->header.sh_link];
720 rel = (Elf32_Rel *) relsec->contents;
721 relend = rel + (relsec->header.sh_size / sizeof(Elf32_Rel));
722 symtab = (Elf32_Sym *) symsec->contents;
723 strtab = (const char *) strsec->contents;
725 for (; rel < relend; ++rel) {
727 struct i386_symbol *intsym;
730 switch (ELF32_R_TYPE(rel->r_info)) {
741 extsym = &symtab[ELF32_R_SYM(rel->r_info)];
743 name = strtab + extsym->st_name;
745 name = f->sections[extsym->st_shndx]->name;
747 (struct i386_symbol *) obj_find_symbol(&ifile->root, name);
749 if (!intsym->gotent.offset_done) {
750 intsym->gotent.offset_done = 1;
751 intsym->gotent.offset = offset;
757 if (offset > 0 || gotneeded)
759 obj_create_alloced_section(&ifile->root, ".got", 4, offset);
764 int arch_init_module(struct obj_file *f, struct new_module *mod)
770 /*======================================================================*/
772 /* Standard ELF hash function. */
773 inline unsigned long obj_elf_hash_n(const char *name, unsigned long n)
782 if ((g = (h & 0xf0000000)) != 0) {
791 unsigned long obj_elf_hash(const char *name)
793 return obj_elf_hash_n(name, strlen(name));
796 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
797 /* Get the kernel version in the canonical integer form. */
799 static int get_kernel_version(char str[STRVERSIONLEN])
801 struct utsname uts_info;
805 if (uname(&uts_info) < 0)
807 strncpy(str, uts_info.release, STRVERSIONLEN);
808 p = uts_info.release;
810 a = strtoul(p, &p, 10);
813 b = strtoul(p + 1, &p, 10);
816 c = strtoul(p + 1, &q, 10);
820 return a << 16 | b << 8 | c;
823 /* String comparison for non-co-versioned kernel and module. */
825 static int ncv_strcmp(const char *a, const char *b)
827 size_t alen = strlen(a), blen = strlen(b);
829 if (blen == alen + 10 && b[alen] == '_' && b[alen + 1] == 'R')
830 return strncmp(a, b, alen);
831 else if (alen == blen + 10 && a[blen] == '_' && a[blen + 1] == 'R')
832 return strncmp(a, b, blen);
837 /* String hashing for non-co-versioned kernel and module. Here
838 we are simply forced to drop the crc from the hash. */
840 static unsigned long ncv_symbol_hash(const char *str)
842 size_t len = strlen(str);
843 if (len > 10 && str[len - 10] == '_' && str[len - 9] == 'R')
845 return obj_elf_hash_n(str, len);
849 obj_set_symbol_compare(struct obj_file *f,
850 int (*cmp) (const char *, const char *),
851 unsigned long (*hash) (const char *))
856 struct obj_symbol *tmptab[HASH_BUCKETS], *sym, *next;
859 f->symbol_hash = hash;
861 memcpy(tmptab, f->symtab, sizeof(tmptab));
862 memset(f->symtab, 0, sizeof(f->symtab));
864 for (i = 0; i < HASH_BUCKETS; ++i)
865 for (sym = tmptab[i]; sym; sym = next) {
866 unsigned long h = hash(sym->name) % HASH_BUCKETS;
868 sym->next = f->symtab[h];
874 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
877 struct obj_symbol *obj_add_symbol(struct obj_file *f, const char *name,
878 unsigned long symidx, int info,
879 int secidx, ElfW(Addr) value,
882 struct obj_symbol *sym;
883 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
884 int n_type = ELFW(ST_TYPE) (info);
885 int n_binding = ELFW(ST_BIND) (info);
887 for (sym = f->symtab[hash]; sym; sym = sym->next)
888 if (f->symbol_cmp(sym->name, name) == 0) {
889 int o_secidx = sym->secidx;
890 int o_info = sym->info;
891 int o_type = ELFW(ST_TYPE) (o_info);
892 int o_binding = ELFW(ST_BIND) (o_info);
894 /* A redefinition! Is it legal? */
896 if (secidx == SHN_UNDEF)
898 else if (o_secidx == SHN_UNDEF)
900 else if (n_binding == STB_GLOBAL && o_binding == STB_LOCAL) {
901 /* Cope with local and global symbols of the same name
902 in the same object file, as might have been created
903 by ld -r. The only reason locals are now seen at this
904 level at all is so that we can do semi-sensible things
907 struct obj_symbol *nsym, **p;
909 nsym = arch_new_symbol();
910 nsym->next = sym->next;
913 /* Excise the old (local) symbol from the hash chain. */
914 for (p = &f->symtab[hash]; *p != sym; p = &(*p)->next)
918 } else if (n_binding == STB_LOCAL) {
919 /* Another symbol of the same name has already been defined.
920 Just add this to the local table. */
921 sym = arch_new_symbol();
924 f->local_symtab[symidx] = sym;
926 } else if (n_binding == STB_WEAK)
928 else if (o_binding == STB_WEAK)
930 /* Don't unify COMMON symbols with object types the programmer
932 else if (secidx == SHN_COMMON
933 && (o_type == STT_NOTYPE || o_type == STT_OBJECT))
935 else if (o_secidx == SHN_COMMON
936 && (n_type == STT_NOTYPE || n_type == STT_OBJECT))
939 /* Don't report an error if the symbol is coming from
940 the kernel or some external module. */
941 if (secidx <= SHN_HIRESERVE)
942 fprintf(stderr, "%s multiply defined\n", name);
947 /* Completely new symbol. */
948 sym = arch_new_symbol();
949 sym->next = f->symtab[hash];
950 f->symtab[hash] = sym;
953 if (ELFW(ST_BIND) (info) == STB_LOCAL)
954 f->local_symtab[symidx] = sym;
960 sym->secidx = secidx;
966 struct obj_symbol *obj_find_symbol(struct obj_file *f, const char *name)
968 struct obj_symbol *sym;
969 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
971 for (sym = f->symtab[hash]; sym; sym = sym->next)
972 if (f->symbol_cmp(sym->name, name) == 0)
979 obj_symbol_final_value(struct obj_file * f, struct obj_symbol * sym)
982 if (sym->secidx >= SHN_LORESERVE)
985 return sym->value + f->sections[sym->secidx]->header.sh_addr;
987 /* As a special case, a NULL sym has value zero. */
992 struct obj_section *obj_find_section(struct obj_file *f, const char *name)
994 int i, n = f->header.e_shnum;
996 for (i = 0; i < n; ++i)
997 if (strcmp(f->sections[i]->name, name) == 0)
998 return f->sections[i];
1003 static int obj_load_order_prio(struct obj_section *a)
1005 unsigned long af, ac;
1007 af = a->header.sh_flags;
1010 if (a->name[0] != '.' || strlen(a->name) != 10 ||
1011 strcmp(a->name + 5, ".init"))
1015 if (!(af & SHF_WRITE))
1017 if (af & SHF_EXECINSTR)
1019 if (a->header.sh_type != SHT_NOBITS)
1026 obj_insert_section_load_order(struct obj_file *f, struct obj_section *sec)
1028 struct obj_section **p;
1029 int prio = obj_load_order_prio(sec);
1030 for (p = f->load_order_search_start; *p; p = &(*p)->load_next)
1031 if (obj_load_order_prio(*p) < prio)
1033 sec->load_next = *p;
1037 struct obj_section *obj_create_alloced_section(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 obj_insert_section_load_order(f, sec);
1063 struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
1065 unsigned long align,
1068 int newidx = f->header.e_shnum++;
1069 struct obj_section *sec;
1071 f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
1072 f->sections[newidx] = sec = arch_new_section();
1074 memset(sec, 0, sizeof(*sec));
1075 sec->header.sh_type = SHT_PROGBITS;
1076 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
1077 sec->header.sh_size = size;
1078 sec->header.sh_addralign = align;
1082 sec->contents = xmalloc(size);
1084 sec->load_next = f->load_order;
1085 f->load_order = sec;
1086 if (f->load_order_search_start == &f->load_order)
1087 f->load_order_search_start = &sec->load_next;
1092 void *obj_extend_section(struct obj_section *sec, unsigned long more)
1094 unsigned long oldsize = sec->header.sh_size;
1095 sec->contents = xrealloc(sec->contents, sec->header.sh_size += more);
1096 return sec->contents + oldsize;
1101 /* Conditionally add the symbols from the given symbol set to the
1107 int idx, struct new_module_symbol *syms, size_t nsyms)
1109 struct new_module_symbol *s;
1113 for (i = 0, s = syms; i < nsyms; ++i, ++s) {
1115 /* Only add symbols that are already marked external. If we
1116 override locals we may cause problems for argument initialization.
1117 We will also create a false dependency on the module. */
1118 struct obj_symbol *sym;
1120 sym = obj_find_symbol(f, (char *) s->name);
1121 if (sym && !ELFW(ST_BIND) (sym->info) == STB_LOCAL) {
1122 sym = obj_add_symbol(f, (char *) s->name, -1,
1123 ELFW(ST_INFO) (STB_GLOBAL, STT_NOTYPE),
1125 /* Did our symbol just get installed? If so, mark the
1126 module as "used". */
1127 if (sym->secidx == idx)
1135 static void add_kernel_symbols(struct obj_file *f)
1137 struct external_module *m;
1138 size_t i, nused = 0;
1140 /* Add module symbols first. */
1142 for (i = 0, m = ext_modules; i < n_ext_modules; ++i, ++m)
1144 && add_symbols_from(f, SHN_HIRESERVE + 2 + i, m->syms,
1145 m->nsyms)) m->used = 1, ++nused;
1147 n_ext_modules_used = nused;
1149 /* And finally the symbols from the kernel proper. */
1152 add_symbols_from(f, SHN_HIRESERVE + 1, ksyms, nksyms);
1155 static char *get_modinfo_value(struct obj_file *f, const char *key)
1157 struct obj_section *sec;
1158 char *p, *v, *n, *ep;
1159 size_t klen = strlen(key);
1161 sec = obj_find_section(f, ".modinfo");
1165 ep = p + sec->header.sh_size;
1168 n = strchr(p, '\0');
1170 if (v - p == klen && strncmp(p, key, klen) == 0)
1173 if (n - p == klen && strcmp(p, key) == 0)
1183 /*======================================================================*/
1184 /* Functions relating to module loading in pre 2.1 kernels. */
1187 old_process_module_arguments(struct obj_file *f, int argc, char **argv)
1191 struct obj_symbol *sym;
1195 if ((q = strchr(p, '=')) == NULL) {
1201 sym = obj_find_symbol(f, p);
1203 /* Also check that the parameter was not resolved from the kernel. */
1204 if (sym == NULL || sym->secidx > SHN_HIRESERVE) {
1205 fprintf(stderr, "symbol for parameter %s not found\n", p);
1209 loc = (int *) (f->sections[sym->secidx]->contents + sym->value);
1211 /* Do C quoting if we begin with a ". */
1215 str = alloca(strlen(q));
1216 for (r = str, q++; *q != '"'; ++q, ++r) {
1218 fprintf(stderr, "improperly terminated string argument for %s\n", p);
1220 } else if (*q == '\\')
1254 if (q[1] >= '0' && q[1] <= '7') {
1255 c = (c * 8) + *++q - '0';
1256 if (q[1] >= '0' && q[1] <= '7')
1257 c = (c * 8) + *++q - '0';
1270 obj_string_patch(f, sym->secidx, sym->value, str);
1271 } else if (*q >= '0' && *q <= '9') {
1273 *loc++ = strtoul(q, &q, 0);
1274 while (*q++ == ',');
1276 char *contents = f->sections[sym->secidx]->contents;
1277 char *loc = contents + sym->value;
1278 char *r; /* To search for commas */
1280 /* Break the string with comas */
1281 while ((r = strchr(q, ',')) != (char *) NULL) {
1283 obj_string_patch(f, sym->secidx, loc - contents, q);
1284 loc += sizeof(char *);
1289 obj_string_patch(f, sym->secidx, loc - contents, q);
1298 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
1299 static int old_is_module_checksummed(struct obj_file *f)
1301 return obj_find_symbol(f, "Using_Versions") != NULL;
1303 /* Get the module's kernel version in the canonical integer form. */
1306 old_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
1308 struct obj_symbol *sym;
1312 sym = obj_find_symbol(f, "kernel_version");
1316 p = f->sections[sym->secidx]->contents + sym->value;
1317 strncpy(str, p, STRVERSIONLEN);
1319 a = strtoul(p, &p, 10);
1322 b = strtoul(p + 1, &p, 10);
1325 c = strtoul(p + 1, &q, 10);
1329 return a << 16 | b << 8 | c;
1332 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
1334 #ifdef BB_FEATURE_INSMOD_OLD_KERNEL
1336 /* Fetch all the symbols and divvy them up as appropriate for the modules. */
1338 static int old_get_kernel_symbols(void)
1340 struct old_kernel_sym *ks, *k;
1341 struct new_module_symbol *s;
1342 struct external_module *mod;
1343 int nks, nms, nmod, i;
1345 nks = get_kernel_syms(NULL);
1347 errorMsg("get_kernel_syms: %s: %s", m_name, strerror(errno));
1351 ks = k = xmalloc(nks * sizeof(*ks));
1353 if (get_kernel_syms(ks) != nks) {
1354 perror("inconsistency with get_kernel_syms -- is someone else "
1355 "playing with modules?");
1360 /* Collect the module information. */
1365 while (k->name[0] == '#' && k->name[1]) {
1366 struct old_kernel_sym *k2;
1367 struct new_module_symbol *s;
1369 /* Find out how many symbols this module has. */
1370 for (k2 = k + 1; k2->name[0] != '#'; ++k2)
1374 mod = xrealloc(mod, (++nmod + 1) * sizeof(*mod));
1375 mod[nmod].name = k->name + 1;
1376 mod[nmod].addr = k->value;
1378 mod[nmod].nsyms = nms;
1379 mod[nmod].syms = s = (nms ? xmalloc(nms * sizeof(*s)) : NULL);
1381 for (i = 0, ++k; i < nms; ++i, ++s, ++k) {
1382 s->name = (unsigned long) k->name;
1383 s->value = k->value;
1390 n_ext_modules = nmod + 1;
1392 /* Now collect the symbols for the kernel proper. */
1394 if (k->name[0] == '#')
1397 nksyms = nms = nks - (k - ks);
1398 ksyms = s = (nms ? xmalloc(nms * sizeof(*s)) : NULL);
1400 for (i = 0; i < nms; ++i, ++s, ++k) {
1401 s->name = (unsigned long) k->name;
1402 s->value = k->value;
1408 /* Return the kernel symbol checksum version, or zero if not used. */
1410 static int old_is_kernel_checksummed(void)
1412 /* Using_Versions is the first symbol. */
1414 && strcmp((char *) ksyms[0].name,
1415 "Using_Versions") == 0) return ksyms[0].value;
1421 static int old_create_mod_use_count(struct obj_file *f)
1423 struct obj_section *sec;
1425 sec = obj_create_alloced_section_first(f, ".moduse", sizeof(long),
1428 obj_add_symbol(f, "mod_use_count_", -1,
1429 ELFW(ST_INFO) (STB_LOCAL, STT_OBJECT), sec->idx, 0,
1436 old_init_module(const char *m_name, struct obj_file *f,
1437 unsigned long m_size)
1440 struct old_mod_routines routines;
1441 struct old_symbol_table *symtab;
1444 /* Create the symbol table */
1446 int nsyms = 0, strsize = 0, total;
1448 /* Size things first... */
1451 for (i = 0; i < HASH_BUCKETS; ++i) {
1452 struct obj_symbol *sym;
1453 for (sym = f->symtab[i]; sym; sym = sym->next)
1454 if (ELFW(ST_BIND) (sym->info) != STB_LOCAL
1455 && sym->secidx <= SHN_HIRESERVE)
1457 sym->ksymidx = nsyms++;
1458 strsize += strlen(sym->name) + 1;
1463 total = (sizeof(struct old_symbol_table)
1464 + nsyms * sizeof(struct old_module_symbol)
1465 + n_ext_modules_used * sizeof(struct old_module_ref)
1467 symtab = xmalloc(total);
1468 symtab->size = total;
1469 symtab->n_symbols = nsyms;
1470 symtab->n_refs = n_ext_modules_used;
1472 if (flag_export && nsyms) {
1473 struct old_module_symbol *ksym;
1477 ksym = symtab->symbol;
1478 str = ((char *) ksym + nsyms * sizeof(struct old_module_symbol)
1479 + n_ext_modules_used * sizeof(struct old_module_ref));
1481 for (i = 0; i < HASH_BUCKETS; ++i) {
1482 struct obj_symbol *sym;
1483 for (sym = f->symtab[i]; sym; sym = sym->next)
1484 if (sym->ksymidx >= 0) {
1485 ksym->addr = obj_symbol_final_value(f, sym);
1487 (unsigned long) str - (unsigned long) symtab;
1489 str = stpcpy(str, sym->name) + 1;
1495 if (n_ext_modules_used) {
1496 struct old_module_ref *ref;
1499 ref = (struct old_module_ref *)
1500 ((char *) symtab->symbol + nsyms * sizeof(struct old_module_symbol));
1502 for (i = 0; i < n_ext_modules; ++i)
1503 if (ext_modules[i].used)
1504 ref++->module = ext_modules[i].addr;
1508 /* Fill in routines. */
1511 obj_symbol_final_value(f, obj_find_symbol(f, "init_module"));
1513 obj_symbol_final_value(f, obj_find_symbol(f, "cleanup_module"));
1515 /* Whew! All of the initialization is complete. Collect the final
1516 module image and give it to the kernel. */
1518 image = xmalloc(m_size);
1519 obj_create_image(f, image);
1521 /* image holds the complete relocated module, accounting correctly for
1522 mod_use_count. However the old module kernel support assume that
1523 it is receiving something which does not contain mod_use_count. */
1524 ret = old_sys_init_module(m_name, image + sizeof(long),
1525 m_size | (flag_autoclean ? OLD_MOD_AUTOCLEAN
1526 : 0), &routines, symtab);
1528 errorMsg("init_module: %s: %s", m_name, strerror(errno));
1538 #define old_create_mod_use_count(x) TRUE
1539 #define old_init_module(x, y, z) TRUE
1541 #endif /* BB_FEATURE_INSMOD_OLD_KERNEL */
1545 /*======================================================================*/
1546 /* Functions relating to module loading after 2.1.18. */
1549 new_process_module_arguments(struct obj_file *f, int argc, char **argv)
1553 struct obj_symbol *sym;
1554 char *contents, *loc;
1558 if ((q = strchr(p, '=')) == NULL) {
1563 key = alloca(q - p + 6);
1564 memcpy(key, "parm_", 5);
1565 memcpy(key + 5, p, q - p);
1568 p = get_modinfo_value(f, key);
1571 fprintf(stderr, "invalid parameter %s\n", key);
1575 sym = obj_find_symbol(f, key);
1577 /* Also check that the parameter was not resolved from the kernel. */
1578 if (sym == NULL || sym->secidx > SHN_HIRESERVE) {
1579 fprintf(stderr, "symbol for parameter %s not found\n", key);
1584 min = strtoul(p, &p, 10);
1586 max = strtoul(p + 1, &p, 10);
1592 contents = f->sections[sym->secidx]->contents;
1593 loc = contents + sym->value;
1597 if ((*p == 's') || (*p == 'c')) {
1600 /* Do C quoting if we begin with a ", else slurp the lot. */
1604 str = alloca(strlen(q));
1605 for (r = str, q++; *q != '"'; ++q, ++r) {
1608 "improperly terminated string argument for %s\n",
1611 } else if (*q == '\\')
1645 if (q[1] >= '0' && q[1] <= '7') {
1646 c = (c * 8) + *++q - '0';
1647 if (q[1] >= '0' && q[1] <= '7')
1648 c = (c * 8) + *++q - '0';
1665 /* In this case, the string is not quoted. We will break
1666 it using the coma (like for ints). If the user wants to
1667 include comas in a string, he just has to quote it */
1669 /* Search the next coma */
1673 if (r != (char *) NULL) {
1674 /* Recopy the current field */
1675 str = alloca(r - q + 1);
1676 memcpy(str, q, r - q);
1678 /* I don't know if it is usefull, as the previous case
1679 doesn't null terminate the string ??? */
1682 /* Keep next fields */
1693 obj_string_patch(f, sym->secidx, loc - contents, str);
1694 loc += tgt_sizeof_char_p;
1696 /* Array of chars (in fact, matrix !) */
1697 long charssize; /* size of each member */
1699 /* Get the size of each member */
1700 /* Probably we should do that outside the loop ? */
1701 if (!isdigit(*(p + 1))) {
1703 "parameter type 'c' for %s must be followed by"
1704 " the maximum size\n", key);
1707 charssize = strtoul(p + 1, (char **) NULL, 10);
1710 if (strlen(str) >= charssize) {
1712 "string too long for %s (max %ld)\n", key,
1717 /* Copy to location */
1718 strcpy((char *) loc, str);
1722 long v = strtoul(q, &q, 0);
1729 loc += tgt_sizeof_short;
1733 loc += tgt_sizeof_int;
1737 loc += tgt_sizeof_long;
1741 fprintf(stderr, "unknown parameter type '%c' for %s\n",
1757 goto retry_end_of_value;
1761 fprintf(stderr, "too many values for %s (max %d)\n",
1769 fprintf(stderr, "invalid argument syntax for %s\n", key);
1776 fprintf(stderr, "too few values for %s (min %d)\n", key, min);
1786 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
1787 static int new_is_module_checksummed(struct obj_file *f)
1789 const char *p = get_modinfo_value(f, "using_checksums");
1796 /* Get the module's kernel version in the canonical integer form. */
1799 new_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
1804 p = get_modinfo_value(f, "kernel_version");
1807 strncpy(str, p, STRVERSIONLEN);
1809 a = strtoul(p, &p, 10);
1812 b = strtoul(p + 1, &p, 10);
1815 c = strtoul(p + 1, &q, 10);
1819 return a << 16 | b << 8 | c;
1822 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
1825 #ifdef BB_FEATURE_INSMOD_NEW_KERNEL
1827 /* Fetch the loaded modules, and all currently exported symbols. */
1829 static int new_get_kernel_symbols(void)
1831 char *module_names, *mn;
1832 struct external_module *modules, *m;
1833 struct new_module_symbol *syms, *s;
1834 size_t ret, bufsize, nmod, nsyms, i, j;
1836 /* Collect the loaded modules. */
1838 module_names = xmalloc(bufsize = 256);
1840 if (query_module(NULL, QM_MODULES, module_names, bufsize, &ret)) {
1841 if (errno == ENOSPC) {
1842 module_names = xrealloc(module_names, bufsize = ret);
1843 goto retry_modules_load;
1845 errorMsg("QM_MODULES: %s", strerror(errno));
1849 n_ext_modules = nmod = ret;
1850 ext_modules = modules = xmalloc(nmod * sizeof(*modules));
1851 memset(modules, 0, nmod * sizeof(*modules));
1853 /* Collect the modules' symbols. */
1855 for (i = 0, mn = module_names, m = modules;
1856 i < nmod; ++i, ++m, mn += strlen(mn) + 1) {
1857 struct new_module_info info;
1859 if (query_module(mn, QM_INFO, &info, sizeof(info), &ret)) {
1860 if (errno == ENOENT) {
1861 /* The module was removed out from underneath us. */
1864 errorMsg("query_module: QM_INFO: %s: %s", mn, strerror(errno));
1868 syms = xmalloc(bufsize = 1024);
1870 if (query_module(mn, QM_SYMBOLS, syms, bufsize, &ret)) {
1873 syms = xrealloc(syms, bufsize = ret);
1874 goto retry_mod_sym_load;
1876 /* The module was removed out from underneath us. */
1879 errorMsg("query_module: QM_SYMBOLS: %s: %s", mn, strerror(errno));
1886 m->addr = info.addr;
1890 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
1891 s->name += (unsigned long) syms;
1895 /* Collect the kernel's symbols. */
1897 syms = xmalloc(bufsize = 16 * 1024);
1898 retry_kern_sym_load:
1899 if (query_module(NULL, QM_SYMBOLS, syms, bufsize, &ret)) {
1900 if (errno == ENOSPC) {
1901 syms = xrealloc(syms, bufsize = ret);
1902 goto retry_kern_sym_load;
1904 errorMsg("kernel: QM_SYMBOLS: %s", strerror(errno));
1907 nksyms = nsyms = ret;
1910 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
1911 s->name += (unsigned long) syms;
1917 /* Return the kernel symbol checksum version, or zero if not used. */
1919 static int new_is_kernel_checksummed(void)
1921 struct new_module_symbol *s;
1924 /* Using_Versions is not the first symbol, but it should be in there. */
1926 for (i = 0, s = ksyms; i < nksyms; ++i, ++s)
1927 if (strcmp((char *) s->name, "Using_Versions") == 0)
1934 static int new_create_this_module(struct obj_file *f, const char *m_name)
1936 struct obj_section *sec;
1938 sec = obj_create_alloced_section_first(f, ".this", tgt_sizeof_long,
1939 sizeof(struct new_module));
1940 memset(sec->contents, 0, sizeof(struct new_module));
1942 obj_add_symbol(f, "__this_module", -1,
1943 ELFW(ST_INFO) (STB_LOCAL, STT_OBJECT), sec->idx, 0,
1944 sizeof(struct new_module));
1946 obj_string_patch(f, sec->idx, offsetof(struct new_module, name),
1953 static int new_create_module_ksymtab(struct obj_file *f)
1955 struct obj_section *sec;
1958 /* We must always add the module references. */
1960 if (n_ext_modules_used) {
1961 struct new_module_ref *dep;
1962 struct obj_symbol *tm;
1964 sec = obj_create_alloced_section(f, ".kmodtab", tgt_sizeof_void_p,
1965 (sizeof(struct new_module_ref)
1966 * n_ext_modules_used));
1970 tm = obj_find_symbol(f, "__this_module");
1971 dep = (struct new_module_ref *) sec->contents;
1972 for (i = 0; i < n_ext_modules; ++i)
1973 if (ext_modules[i].used) {
1974 dep->dep = ext_modules[i].addr;
1975 obj_symbol_patch(f, sec->idx,
1976 (char *) &dep->ref - sec->contents, tm);
1982 if (flag_export && !obj_find_section(f, "__ksymtab")) {
1987 obj_create_alloced_section(f, "__ksymtab", tgt_sizeof_void_p,
1990 /* We don't want to export symbols residing in sections that
1991 aren't loaded. There are a number of these created so that
1992 we make sure certain module options don't appear twice. */
1994 loaded = alloca(sizeof(int) * (i = f->header.e_shnum));
1996 loaded[i] = (f->sections[i]->header.sh_flags & SHF_ALLOC) != 0;
1998 for (nsyms = i = 0; i < HASH_BUCKETS; ++i) {
1999 struct obj_symbol *sym;
2000 for (sym = f->symtab[i]; sym; sym = sym->next)
2001 if (ELFW(ST_BIND) (sym->info) != STB_LOCAL
2002 && sym->secidx <= SHN_HIRESERVE
2003 && (sym->secidx >= SHN_LORESERVE
2004 || loaded[sym->secidx])) {
2005 ElfW(Addr) ofs = nsyms * 2 * tgt_sizeof_void_p;
2007 obj_symbol_patch(f, sec->idx, ofs, sym);
2008 obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p,
2015 obj_extend_section(sec, nsyms * 2 * tgt_sizeof_char_p);
2023 new_init_module(const char *m_name, struct obj_file *f,
2024 unsigned long m_size)
2026 struct new_module *module;
2027 struct obj_section *sec;
2032 sec = obj_find_section(f, ".this");
2033 module = (struct new_module *) sec->contents;
2034 m_addr = sec->header.sh_addr;
2036 module->size_of_struct = sizeof(*module);
2037 module->size = m_size;
2038 module->flags = flag_autoclean ? NEW_MOD_AUTOCLEAN : 0;
2040 sec = obj_find_section(f, "__ksymtab");
2041 if (sec && sec->header.sh_size) {
2042 module->syms = sec->header.sh_addr;
2043 module->nsyms = sec->header.sh_size / (2 * tgt_sizeof_char_p);
2046 if (n_ext_modules_used) {
2047 sec = obj_find_section(f, ".kmodtab");
2048 module->deps = sec->header.sh_addr;
2049 module->ndeps = n_ext_modules_used;
2053 obj_symbol_final_value(f, obj_find_symbol(f, "init_module"));
2055 obj_symbol_final_value(f, obj_find_symbol(f, "cleanup_module"));
2057 sec = obj_find_section(f, "__ex_table");
2059 module->ex_table_start = sec->header.sh_addr;
2060 module->ex_table_end = sec->header.sh_addr + sec->header.sh_size;
2063 sec = obj_find_section(f, ".text.init");
2065 module->runsize = sec->header.sh_addr - m_addr;
2067 sec = obj_find_section(f, ".data.init");
2069 if (!module->runsize ||
2070 module->runsize > sec->header.sh_addr - m_addr)
2071 module->runsize = sec->header.sh_addr - m_addr;
2074 if (!arch_init_module(f, module))
2077 /* Whew! All of the initialization is complete. Collect the final
2078 module image and give it to the kernel. */
2080 image = xmalloc(m_size);
2081 obj_create_image(f, image);
2083 ret = new_sys_init_module(m_name, (struct new_module *) image);
2085 errorMsg("init_module: %s: %s", m_name, strerror(errno));
2094 #define new_init_module(x, y, z) TRUE
2095 #define new_create_this_module(x, y) 0
2096 #define new_create_module_ksymtab(x)
2098 #endif /* BB_FEATURE_INSMOD_OLD_KERNEL */
2101 /*======================================================================*/
2104 obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2107 struct obj_string_patch *p;
2108 struct obj_section *strsec;
2109 size_t len = strlen(string) + 1;
2112 p = xmalloc(sizeof(*p));
2113 p->next = f->string_patches;
2114 p->reloc_secidx = secidx;
2115 p->reloc_offset = offset;
2116 f->string_patches = p;
2118 strsec = obj_find_section(f, ".kstrtab");
2119 if (strsec == NULL) {
2120 strsec = obj_create_alloced_section(f, ".kstrtab", 1, len);
2121 p->string_offset = 0;
2122 loc = strsec->contents;
2124 p->string_offset = strsec->header.sh_size;
2125 loc = obj_extend_section(strsec, len);
2127 memcpy(loc, string, len);
2133 obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2134 struct obj_symbol *sym)
2136 struct obj_symbol_patch *p;
2138 p = xmalloc(sizeof(*p));
2139 p->next = f->symbol_patches;
2140 p->reloc_secidx = secidx;
2141 p->reloc_offset = offset;
2143 f->symbol_patches = p;
2148 int obj_check_undefineds(struct obj_file *f)
2153 for (i = 0; i < HASH_BUCKETS; ++i) {
2154 struct obj_symbol *sym;
2155 for (sym = f->symtab[i]; sym; sym = sym->next)
2156 if (sym->secidx == SHN_UNDEF) {
2157 if (ELFW(ST_BIND) (sym->info) == STB_WEAK) {
2158 sym->secidx = SHN_ABS;
2161 fprintf(stderr, "unresolved symbol %s\n", sym->name);
2170 void obj_allocate_commons(struct obj_file *f)
2172 struct common_entry {
2173 struct common_entry *next;
2174 struct obj_symbol *sym;
2175 } *common_head = NULL;
2179 for (i = 0; i < HASH_BUCKETS; ++i) {
2180 struct obj_symbol *sym;
2181 for (sym = f->symtab[i]; sym; sym = sym->next)
2182 if (sym->secidx == SHN_COMMON) {
2183 /* Collect all COMMON symbols and sort them by size so as to
2184 minimize space wasted by alignment requirements. */
2186 struct common_entry **p, *n;
2187 for (p = &common_head; *p; p = &(*p)->next)
2188 if (sym->size <= (*p)->sym->size)
2191 n = alloca(sizeof(*n));
2199 for (i = 1; i < f->local_symtab_size; ++i) {
2200 struct obj_symbol *sym = f->local_symtab[i];
2201 if (sym && sym->secidx == SHN_COMMON) {
2202 struct common_entry **p, *n;
2203 for (p = &common_head; *p; p = &(*p)->next)
2204 if (sym == (*p)->sym)
2206 else if (sym->size < (*p)->sym->size) {
2207 n = alloca(sizeof(*n));
2217 /* Find the bss section. */
2218 for (i = 0; i < f->header.e_shnum; ++i)
2219 if (f->sections[i]->header.sh_type == SHT_NOBITS)
2222 /* If for some reason there hadn't been one, create one. */
2223 if (i == f->header.e_shnum) {
2224 struct obj_section *sec;
2226 f->sections = xrealloc(f->sections, (i + 1) * sizeof(sec));
2227 f->sections[i] = sec = arch_new_section();
2228 f->header.e_shnum = i + 1;
2230 memset(sec, 0, sizeof(*sec));
2231 sec->header.sh_type = SHT_PROGBITS;
2232 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2237 /* Allocate the COMMONS. */
2239 ElfW(Addr) bss_size = f->sections[i]->header.sh_size;
2240 ElfW(Addr) max_align = f->sections[i]->header.sh_addralign;
2241 struct common_entry *c;
2243 for (c = common_head; c; c = c->next) {
2244 ElfW(Addr) align = c->sym->value;
2246 if (align > max_align)
2248 if (bss_size & (align - 1))
2249 bss_size = (bss_size | (align - 1)) + 1;
2252 c->sym->value = bss_size;
2254 bss_size += c->sym->size;
2257 f->sections[i]->header.sh_size = bss_size;
2258 f->sections[i]->header.sh_addralign = max_align;
2262 /* For the sake of patch relocation and parameter initialization,
2263 allocate zeroed data for NOBITS sections now. Note that after
2264 this we cannot assume NOBITS are really empty. */
2265 for (i = 0; i < f->header.e_shnum; ++i) {
2266 struct obj_section *s = f->sections[i];
2267 if (s->header.sh_type == SHT_NOBITS) {
2268 s->contents = memset(xmalloc(s->header.sh_size),
2269 0, s->header.sh_size);
2270 s->header.sh_type = SHT_PROGBITS;
2275 unsigned long obj_load_size(struct obj_file *f)
2277 unsigned long dot = 0;
2278 struct obj_section *sec;
2280 /* Finalize the positions of the sections relative to one another. */
2282 for (sec = f->load_order; sec; sec = sec->load_next) {
2285 align = sec->header.sh_addralign;
2286 if (align && (dot & (align - 1)))
2287 dot = (dot | (align - 1)) + 1;
2289 sec->header.sh_addr = dot;
2290 dot += sec->header.sh_size;
2296 int obj_relocate(struct obj_file *f, ElfW(Addr) base)
2298 int i, n = f->header.e_shnum;
2301 /* Finalize the addresses of the sections. */
2304 for (i = 0; i < n; ++i)
2305 f->sections[i]->header.sh_addr += base;
2307 /* And iterate over all of the relocations. */
2309 for (i = 0; i < n; ++i) {
2310 struct obj_section *relsec, *symsec, *targsec, *strsec;
2311 ElfW(RelM) * rel, *relend;
2315 relsec = f->sections[i];
2316 if (relsec->header.sh_type != SHT_RELM)
2319 symsec = f->sections[relsec->header.sh_link];
2320 targsec = f->sections[relsec->header.sh_info];
2321 strsec = f->sections[symsec->header.sh_link];
2323 rel = (ElfW(RelM) *) relsec->contents;
2324 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
2325 symtab = (ElfW(Sym) *) symsec->contents;
2326 strtab = (const char *) strsec->contents;
2328 for (; rel < relend; ++rel) {
2329 ElfW(Addr) value = 0;
2330 struct obj_symbol *intsym = NULL;
2331 unsigned long symndx;
2332 ElfW(Sym) * extsym = 0;
2335 /* Attempt to find a value to use for this relocation. */
2337 symndx = ELFW(R_SYM) (rel->r_info);
2339 /* Note we've already checked for undefined symbols. */
2341 extsym = &symtab[symndx];
2342 if (ELFW(ST_BIND) (extsym->st_info) == STB_LOCAL) {
2343 /* Local symbols we look up in the local table to be sure
2344 we get the one that is really intended. */
2345 intsym = f->local_symtab[symndx];
2347 /* Others we look up in the hash table. */
2349 if (extsym->st_name)
2350 name = strtab + extsym->st_name;
2352 name = f->sections[extsym->st_shndx]->name;
2353 intsym = obj_find_symbol(f, name);
2356 value = obj_symbol_final_value(f, intsym);
2357 intsym->referenced = 1;
2359 #if SHT_RELM == SHT_RELA
2360 #if defined(__alpha__) && defined(AXP_BROKEN_GAS)
2361 /* Work around a nasty GAS bug, that is fixed as of 2.7.0.9. */
2362 if (!extsym || !extsym->st_name ||
2363 ELFW(ST_BIND) (extsym->st_info) != STB_LOCAL)
2365 value += rel->r_addend;
2369 switch (arch_apply_relocation
2370 (f, targsec, symsec, intsym, rel, value)) {
2374 case obj_reloc_overflow:
2375 errmsg = "Relocation overflow";
2377 case obj_reloc_dangerous:
2378 errmsg = "Dangerous relocation";
2380 case obj_reloc_unhandled:
2381 errmsg = "Unhandled relocation";
2384 fprintf(stderr, "%s of type %ld for %s\n", errmsg,
2385 (long) ELFW(R_TYPE) (rel->r_info),
2386 strtab + extsym->st_name);
2388 fprintf(stderr, "%s of type %ld\n", errmsg,
2389 (long) ELFW(R_TYPE) (rel->r_info));
2397 /* Finally, take care of the patches. */
2399 if (f->string_patches) {
2400 struct obj_string_patch *p;
2401 struct obj_section *strsec;
2402 ElfW(Addr) strsec_base;
2403 strsec = obj_find_section(f, ".kstrtab");
2404 strsec_base = strsec->header.sh_addr;
2406 for (p = f->string_patches; p; p = p->next) {
2407 struct obj_section *targsec = f->sections[p->reloc_secidx];
2408 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
2409 = strsec_base + p->string_offset;
2413 if (f->symbol_patches) {
2414 struct obj_symbol_patch *p;
2416 for (p = f->symbol_patches; p; p = p->next) {
2417 struct obj_section *targsec = f->sections[p->reloc_secidx];
2418 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
2419 = obj_symbol_final_value(f, p->sym);
2426 int obj_create_image(struct obj_file *f, char *image)
2428 struct obj_section *sec;
2429 ElfW(Addr) base = f->baseaddr;
2431 for (sec = f->load_order; sec; sec = sec->load_next) {
2434 if (sec->header.sh_size == 0)
2437 secimg = image + (sec->header.sh_addr - base);
2439 /* Note that we allocated data for NOBITS sections earlier. */
2440 memcpy(secimg, sec->contents, sec->header.sh_size);
2446 /*======================================================================*/
2448 struct obj_file *obj_load(FILE * fp)
2451 ElfW(Shdr) * section_headers;
2455 /* Read the file header. */
2457 f = arch_new_file();
2458 memset(f, 0, sizeof(*f));
2459 f->symbol_cmp = strcmp;
2460 f->symbol_hash = obj_elf_hash;
2461 f->load_order_search_start = &f->load_order;
2463 fseek(fp, 0, SEEK_SET);
2464 if (fread(&f->header, sizeof(f->header), 1, fp) != 1) {
2465 errorMsg("error reading ELF header: %s", strerror(errno));
2469 if (f->header.e_ident[EI_MAG0] != ELFMAG0
2470 || f->header.e_ident[EI_MAG1] != ELFMAG1
2471 || f->header.e_ident[EI_MAG2] != ELFMAG2
2472 || f->header.e_ident[EI_MAG3] != ELFMAG3) {
2473 fprintf(stderr, "not an ELF file\n");
2476 if (f->header.e_ident[EI_CLASS] != ELFCLASSM
2477 || f->header.e_ident[EI_DATA] != ELFDATAM
2478 || f->header.e_ident[EI_VERSION] != EV_CURRENT
2479 || !MATCH_MACHINE(f->header.e_machine)) {
2480 fprintf(stderr, "ELF file not for this architecture\n");
2483 if (f->header.e_type != ET_REL) {
2484 fprintf(stderr, "ELF file not a relocatable object\n");
2488 /* Read the section headers. */
2490 if (f->header.e_shentsize != sizeof(ElfW(Shdr))) {
2491 fprintf(stderr, "section header size mismatch: %lu != %lu\n",
2492 (unsigned long) f->header.e_shentsize,
2493 (unsigned long) sizeof(ElfW(Shdr)));
2497 shnum = f->header.e_shnum;
2498 f->sections = xmalloc(sizeof(struct obj_section *) * shnum);
2499 memset(f->sections, 0, sizeof(struct obj_section *) * shnum);
2501 section_headers = alloca(sizeof(ElfW(Shdr)) * shnum);
2502 fseek(fp, f->header.e_shoff, SEEK_SET);
2503 if (fread(section_headers, sizeof(ElfW(Shdr)), shnum, fp) != shnum) {
2504 errorMsg("error reading ELF section headers: %s", strerror(errno));
2508 /* Read the section data. */
2510 for (i = 0; i < shnum; ++i) {
2511 struct obj_section *sec;
2513 f->sections[i] = sec = arch_new_section();
2514 memset(sec, 0, sizeof(*sec));
2516 sec->header = section_headers[i];
2519 switch (sec->header.sh_type) {
2530 if (sec->header.sh_size > 0) {
2531 sec->contents = xmalloc(sec->header.sh_size);
2532 fseek(fp, sec->header.sh_offset, SEEK_SET);
2533 if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
2534 errorMsg("error reading ELF section data: %s", strerror(errno));
2538 sec->contents = NULL;
2542 #if SHT_RELM == SHT_REL
2545 "RELA relocations not supported on this architecture\n");
2550 "REL relocations not supported on this architecture\n");
2555 if (sec->header.sh_type >= SHT_LOPROC) {
2556 /* Assume processor specific section types are debug
2557 info and can safely be ignored. If this is ever not
2558 the case (Hello MIPS?), don't put ifdefs here but
2559 create an arch_load_proc_section(). */
2563 fprintf(stderr, "can't handle sections of type %ld\n",
2564 (long) sec->header.sh_type);
2569 /* Do what sort of interpretation as needed by each section. */
2571 shstrtab = f->sections[f->header.e_shstrndx]->contents;
2573 for (i = 0; i < shnum; ++i) {
2574 struct obj_section *sec = f->sections[i];
2575 sec->name = shstrtab + sec->header.sh_name;
2578 for (i = 0; i < shnum; ++i) {
2579 struct obj_section *sec = f->sections[i];
2581 if (sec->header.sh_flags & SHF_ALLOC)
2582 obj_insert_section_load_order(f, sec);
2584 switch (sec->header.sh_type) {
2587 unsigned long nsym, j;
2591 if (sec->header.sh_entsize != sizeof(ElfW(Sym))) {
2592 fprintf(stderr, "symbol size mismatch: %lu != %lu\n",
2593 (unsigned long) sec->header.sh_entsize,
2594 (unsigned long) sizeof(ElfW(Sym)));
2598 nsym = sec->header.sh_size / sizeof(ElfW(Sym));
2599 strtab = f->sections[sec->header.sh_link]->contents;
2600 sym = (ElfW(Sym) *) sec->contents;
2602 /* Allocate space for a table of local symbols. */
2603 j = f->local_symtab_size = sec->header.sh_info;
2604 f->local_symtab = xmalloc(j *=
2605 sizeof(struct obj_symbol *));
2606 memset(f->local_symtab, 0, j);
2608 /* Insert all symbols into the hash table. */
2609 for (j = 1, ++sym; j < nsym; ++j, ++sym) {
2612 name = strtab + sym->st_name;
2614 name = f->sections[sym->st_shndx]->name;
2616 obj_add_symbol(f, name, j, sym->st_info, sym->st_shndx,
2617 sym->st_value, sym->st_size);
2623 if (sec->header.sh_entsize != sizeof(ElfW(RelM))) {
2625 "relocation entry size mismatch: %lu != %lu\n",
2626 (unsigned long) sec->header.sh_entsize,
2627 (unsigned long) sizeof(ElfW(RelM)));
2637 static void hide_special_symbols(struct obj_file *f)
2639 static const char *const specials[] = {
2646 struct obj_symbol *sym;
2647 const char *const *p;
2649 for (p = specials; *p; ++p)
2650 if ((sym = obj_find_symbol(f, *p)) != NULL)
2652 ELFW(ST_INFO) (STB_LOCAL, ELFW(ST_TYPE) (sym->info));
2657 extern int insmod_main( int argc, char **argv)
2663 unsigned long m_size;
2667 char m_name[BUFSIZ + 1] = "\0";
2668 int exit_status = FALSE;
2670 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
2672 char k_strversion[STRVERSIONLEN];
2673 char m_strversion[STRVERSIONLEN];
2680 usage(insmod_usage);
2683 /* Parse any options */
2684 while (--argc > 0 && **(++argv) == '-') {
2685 while (*(++(*argv))) {
2687 case 'f': /* force loading */
2688 flag_force_load = 1;
2690 case 'k': /* module loaded by kerneld, auto-cleanable */
2693 case 'v': /* verbose output */
2696 case 'x': /* do not export externs */
2700 usage(insmod_usage);
2706 usage(insmod_usage);
2708 /* Grab the module name */
2709 if ((tmp = strrchr(*argv, '/')) != NULL) {
2716 if (len > 2 && tmp[len - 2] == '.' && tmp[len - 1] == 'o')
2718 memcpy(m_name, tmp, len);
2719 strcpy(m_fullName, m_name);
2720 strcat(m_fullName, ".o");
2722 /* Get a filedesc for the module */
2723 if ((fp = fopen(*argv, "r")) == NULL) {
2724 /* Hmpf. Could not open it. Search through _PATH_MODULES to find a module named m_name */
2725 if (recursiveAction(_PATH_MODULES, TRUE, FALSE, FALSE,
2726 findNamedModule, 0, m_fullName) == TRUE)
2728 if (m_filename[0] == '\0'
2729 || ((fp = fopen(m_filename, "r")) == NULL))
2731 errorMsg("No module named '%s' found in '%s'\n", m_fullName, _PATH_MODULES);
2736 memcpy(m_filename, *argv, strlen(*argv));
2739 if ((f = obj_load(fp)) == NULL) {
2740 perror("Could not load the module\n");
2744 if (get_modinfo_value(f, "kernel_version") == NULL)
2749 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
2750 /* Version correspondence? */
2752 k_version = get_kernel_version(k_strversion);
2753 if (m_has_modinfo) {
2754 m_version = new_get_module_version(f, m_strversion);
2756 m_version = old_get_module_version(f, m_strversion);
2757 if (m_version == -1) {
2759 "couldn't find the kernel version the module was compiled for\n");
2764 if (strncmp(k_strversion, m_strversion, STRVERSIONLEN) != 0) {
2765 if (flag_force_load) {
2766 fprintf(stderr, "Warning: kernel-module version mismatch\n"
2767 "\t%s was compiled for kernel version %s\n"
2768 "\twhile this kernel is version %s\n",
2769 m_filename, m_strversion, k_strversion);
2771 fprintf(stderr, "kernel-module version mismatch\n"
2772 "\t%s was compiled for kernel version %s\n"
2773 "\twhile this kernel is version %s.\n",
2774 m_filename, m_strversion, k_strversion);
2779 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
2781 k_new_syscalls = !query_module(NULL, 0, NULL, 0, NULL);
2783 if (k_new_syscalls) {
2784 #ifdef BB_FEATURE_INSMOD_NEW_KERNEL
2785 if (!new_get_kernel_symbols())
2787 k_crcs = new_is_kernel_checksummed();
2789 fprintf(stderr, "Not configured to support new kernels\n");
2793 #ifdef BB_FEATURE_INSMOD_OLD_KERNEL
2794 if (!old_get_kernel_symbols())
2796 k_crcs = old_is_kernel_checksummed();
2798 fprintf(stderr, "Not configured to support old kernels\n");
2803 #ifdef BB_FEATURE_INSMOD_VERSION_CHECKING
2805 m_crcs = new_is_module_checksummed(f);
2807 m_crcs = old_is_module_checksummed(f);
2809 if (m_crcs != k_crcs)
2810 obj_set_symbol_compare(f, ncv_strcmp, ncv_symbol_hash);
2811 #endif /* BB_FEATURE_INSMOD_VERSION_CHECKING */
2813 /* Let the module know about the kernel symbols. */
2814 add_kernel_symbols(f);
2816 /* Allocate common symbols, symbol tables, and string tables. */
2819 ? !new_create_this_module(f, m_name)
2820 : !old_create_mod_use_count(f))
2825 if (!obj_check_undefineds(f)) {
2828 obj_allocate_commons(f);
2830 if (optind < argc) {
2832 ? !new_process_module_arguments(f, argc - optind, argv + optind)
2833 : !old_process_module_arguments(f, argc - optind, argv + optind))
2840 hide_special_symbols(f);
2843 new_create_module_ksymtab(f);
2845 /* Find current size of the module */
2846 m_size = obj_load_size(f);
2850 m_addr = create_module(m_name, m_size);
2855 fprintf(stderr, "A module named %s already exists\n", m_name);
2859 "Can't allocate kernel memory for module; needed %lu bytes\n",
2863 errorMsg("create_module: %s: %s", m_name, strerror(errno));
2867 if (!obj_relocate(f, m_addr)) {
2868 delete_module(m_name);
2873 ? !new_init_module(m_name, f, m_size)
2874 : !old_init_module(m_name, f, m_size))
2876 delete_module(m_name);
2884 return(exit_status);