aboutsummaryrefslogtreecommitdiff
path: root/modutils/modutils-24.c
diff options
context:
space:
mode:
authorDenis Vlasenko <vda.linux@googlemail.com>2008-09-13 14:59:38 +0000
committerDenis Vlasenko <vda.linux@googlemail.com>2008-09-13 14:59:38 +0000
commitba1315d0fbe7fa43aa7481b5d6e92bd03b0152d5 (patch)
treeb5b295f5382bd71c6184539feabf0ba061897131 /modutils/modutils-24.c
parent4f3209b9d4b24ebe9b76e3bfe8ddd87af5228af9 (diff)
downloadbusybox-w32-ba1315d0fbe7fa43aa7481b5d6e92bd03b0152d5.tar.gz
busybox-w32-ba1315d0fbe7fa43aa7481b5d6e92bd03b0152d5.tar.bz2
busybox-w32-ba1315d0fbe7fa43aa7481b5d6e92bd03b0152d5.zip
modutils/*: rewrite by Timo Teras <timo.teras AT iki.fi>
- a lot faster (linear algorithmic complexity, smaller memory foot print) - a lot smaller (the old code was overly complicated) - loading of aliases is now module-init-tools compliant - blacklisting is done correctly (-b option added) - module argument quoting done right - depmod now correctly generates modules.symbols and modules.alias add/remove: 16/21 grow/shrink: 4/6 up/down: 6930/-9316 Total: -2386 bytes text data bss dec hex filename 806039 592 6680 813311 c68ff busybox_old 803498 592 6676 810766 c5f0e busybox_unstripped
Diffstat (limited to 'modutils/modutils-24.c')
-rw-r--r--modutils/modutils-24.c3936
1 files changed, 3936 insertions, 0 deletions
diff --git a/modutils/modutils-24.c b/modutils/modutils-24.c
new file mode 100644
index 000000000..2bc4bda92
--- /dev/null
+++ b/modutils/modutils-24.c
@@ -0,0 +1,3936 @@
1/* vi: set sw=4 ts=4: */
2/*
3 * Mini insmod implementation for busybox
4 *
5 * This version of insmod supports ARM, CRIS, H8/300, x86, ia64, x86_64,
6 * m68k, MIPS, PowerPC, S390, SH3/4/5, Sparc, v850e, and x86_64.
7 *
8 * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
9 * and Ron Alder <alder@lineo.com>
10 *
11 * Rodney Radford <rradford@mindspring.com> 17-Aug-2004.
12 * Added x86_64 support.
13 *
14 * Miles Bader <miles@gnu.org> added NEC V850E support.
15 *
16 * Modified by Bryan Rittmeyer <bryan@ixiacom.com> to support SH4
17 * and (theoretically) SH3. I have only tested SH4 in little endian mode.
18 *
19 * Modified by Alcove, Julien Gaulmin <julien.gaulmin@alcove.fr> and
20 * Nicolas Ferre <nicolas.ferre@alcove.fr> to support ARM7TDMI. Only
21 * very minor changes required to also work with StrongArm and presumably
22 * all ARM based systems.
23 *
24 * Yoshinori Sato <ysato@users.sourceforge.jp> 19-May-2004.
25 * added Renesas H8/300 support.
26 *
27 * Paul Mundt <lethal@linux-sh.org> 08-Aug-2003.
28 * Integrated support for sh64 (SH-5), from preliminary modutils
29 * patches from Benedict Gaster <benedict.gaster@superh.com>.
30 * Currently limited to support for 32bit ABI.
31 *
32 * Magnus Damm <damm@opensource.se> 22-May-2002.
33 * The plt and got code are now using the same structs.
34 * Added generic linked list code to fully support PowerPC.
35 * Replaced the mess in arch_apply_relocation() with architecture blocks.
36 * The arch_create_got() function got cleaned up with architecture blocks.
37 * These blocks should be easy maintain and sync with obj_xxx.c in modutils.
38 *
39 * Magnus Damm <damm@opensource.se> added PowerPC support 20-Feb-2001.
40 * PowerPC specific code stolen from modutils-2.3.16,
41 * written by Paul Mackerras, Copyright 1996, 1997 Linux International.
42 * I've only tested the code on mpc8xx platforms in big-endian mode.
43 * Did some cleanup and added USE_xxx_ENTRIES...
44 *
45 * Quinn Jensen <jensenq@lineo.com> added MIPS support 23-Feb-2001.
46 * based on modutils-2.4.2
47 * MIPS specific support for Elf loading and relocation.
48 * Copyright 1996, 1997 Linux International.
49 * Contributed by Ralf Baechle <ralf@gnu.ai.mit.edu>
50 *
51 * Based almost entirely on the Linux modutils-2.3.11 implementation.
52 * Copyright 1996, 1997 Linux International.
53 * New implementation contributed by Richard Henderson <rth@tamu.edu>
54 * Based on original work by Bjorn Ekwall <bj0rn@blox.se>
55 * Restructured (and partly rewritten) by:
56 * Bj�rn Ekwall <bj0rn@blox.se> February 1999
57 *
58 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
59 */
60
61#include "libbb.h"
62#include "modutils.h"
63#include <libgen.h>
64#include <sys/utsname.h>
65
66#if ENABLE_FEATURE_INSMOD_LOADINKMEM
67#define LOADBITS 0
68#else
69#define LOADBITS 1
70#endif
71
72/* Alpha */
73#if defined(__alpha__)
74#define MATCH_MACHINE(x) (x == EM_ALPHA)
75#define SHT_RELM SHT_RELA
76#define Elf64_RelM Elf64_Rela
77#define ELFCLASSM ELFCLASS64
78#endif
79
80/* ARM support */
81#if defined(__arm__)
82#define MATCH_MACHINE(x) (x == EM_ARM)
83#define SHT_RELM SHT_REL
84#define Elf32_RelM Elf32_Rel
85#define ELFCLASSM ELFCLASS32
86#define USE_PLT_ENTRIES
87#define PLT_ENTRY_SIZE 8
88#define USE_GOT_ENTRIES
89#define GOT_ENTRY_SIZE 8
90#define USE_SINGLE
91#endif
92
93/* blackfin */
94#if defined(BFIN)
95#define MATCH_MACHINE(x) (x == EM_BLACKFIN)
96#define SHT_RELM SHT_RELA
97#define Elf32_RelM Elf32_Rela
98#define ELFCLASSM ELFCLASS32
99#endif
100
101/* CRIS */
102#if defined(__cris__)
103#define MATCH_MACHINE(x) (x == EM_CRIS)
104#define SHT_RELM SHT_RELA
105#define Elf32_RelM Elf32_Rela
106#define ELFCLASSM ELFCLASS32
107#ifndef EM_CRIS
108#define EM_CRIS 76
109#define R_CRIS_NONE 0
110#define R_CRIS_32 3
111#endif
112#endif
113
114/* H8/300 */
115#if defined(__H8300H__) || defined(__H8300S__)
116#define MATCH_MACHINE(x) (x == EM_H8_300)
117#define SHT_RELM SHT_RELA
118#define Elf32_RelM Elf32_Rela
119#define ELFCLASSM ELFCLASS32
120#define USE_SINGLE
121#define SYMBOL_PREFIX "_"
122#endif
123
124/* PA-RISC / HP-PA */
125#if defined(__hppa__)
126#define MATCH_MACHINE(x) (x == EM_PARISC)
127#define SHT_RELM SHT_RELA
128#if defined(__LP64__)
129#define Elf64_RelM Elf64_Rela
130#define ELFCLASSM ELFCLASS64
131#else
132#define Elf32_RelM Elf32_Rela
133#define ELFCLASSM ELFCLASS32
134#endif
135#endif
136
137/* x86 */
138#if defined(__i386__)
139#ifndef EM_486
140#define MATCH_MACHINE(x) (x == EM_386)
141#else
142#define MATCH_MACHINE(x) (x == EM_386 || x == EM_486)
143#endif
144#define SHT_RELM SHT_REL
145#define Elf32_RelM Elf32_Rel
146#define ELFCLASSM ELFCLASS32
147#define USE_GOT_ENTRIES
148#define GOT_ENTRY_SIZE 4
149#define USE_SINGLE
150#endif
151
152/* IA64, aka Itanium */
153#if defined(__ia64__)
154#define MATCH_MACHINE(x) (x == EM_IA_64)
155#define SHT_RELM SHT_RELA
156#define Elf64_RelM Elf64_Rela
157#define ELFCLASSM ELFCLASS64
158#endif
159
160/* m68k */
161#if defined(__mc68000__)
162#define MATCH_MACHINE(x) (x == EM_68K)
163#define SHT_RELM SHT_RELA
164#define Elf32_RelM Elf32_Rela
165#define ELFCLASSM ELFCLASS32
166#define USE_GOT_ENTRIES
167#define GOT_ENTRY_SIZE 4
168#define USE_SINGLE
169#endif
170
171/* Microblaze */
172#if defined(__microblaze__)
173#define USE_SINGLE
174#include <linux/elf-em.h>
175#define MATCH_MACHINE(x) (x == EM_XILINX_MICROBLAZE)
176#define SHT_RELM SHT_RELA
177#define Elf32_RelM Elf32_Rela
178#define ELFCLASSM ELFCLASS32
179#endif
180
181/* MIPS */
182#if defined(__mips__)
183#define MATCH_MACHINE(x) (x == EM_MIPS || x == EM_MIPS_RS3_LE)
184#define SHT_RELM SHT_REL
185#define Elf32_RelM Elf32_Rel
186#define ELFCLASSM ELFCLASS32
187/* Account for ELF spec changes. */
188#ifndef EM_MIPS_RS3_LE
189#ifdef EM_MIPS_RS4_BE
190#define EM_MIPS_RS3_LE EM_MIPS_RS4_BE
191#else
192#define EM_MIPS_RS3_LE 10
193#endif
194#endif /* !EM_MIPS_RS3_LE */
195#define ARCHDATAM "__dbe_table"
196#endif
197
198/* Nios II */
199#if defined(__nios2__)
200#define MATCH_MACHINE(x) (x == EM_ALTERA_NIOS2)
201#define SHT_RELM SHT_RELA
202#define Elf32_RelM Elf32_Rela
203#define ELFCLASSM ELFCLASS32
204#endif
205
206/* PowerPC */
207#if defined(__powerpc64__)
208#define MATCH_MACHINE(x) (x == EM_PPC64)
209#define SHT_RELM SHT_RELA
210#define Elf64_RelM Elf64_Rela
211#define ELFCLASSM ELFCLASS64
212#elif defined(__powerpc__)
213#define MATCH_MACHINE(x) (x == EM_PPC)
214#define SHT_RELM SHT_RELA
215#define Elf32_RelM Elf32_Rela
216#define ELFCLASSM ELFCLASS32
217#define USE_PLT_ENTRIES
218#define PLT_ENTRY_SIZE 16
219#define USE_PLT_LIST
220#define LIST_ARCHTYPE ElfW(Addr)
221#define USE_LIST
222#define ARCHDATAM "__ftr_fixup"
223#endif
224
225/* S390 */
226#if defined(__s390__)
227#define MATCH_MACHINE(x) (x == EM_S390)
228#define SHT_RELM SHT_RELA
229#define Elf32_RelM Elf32_Rela
230#define ELFCLASSM ELFCLASS32
231#define USE_PLT_ENTRIES
232#define PLT_ENTRY_SIZE 8
233#define USE_GOT_ENTRIES
234#define GOT_ENTRY_SIZE 8
235#define USE_SINGLE
236#endif
237
238/* SuperH */
239#if defined(__sh__)
240#define MATCH_MACHINE(x) (x == EM_SH)
241#define SHT_RELM SHT_RELA
242#define Elf32_RelM Elf32_Rela
243#define ELFCLASSM ELFCLASS32
244#define USE_GOT_ENTRIES
245#define GOT_ENTRY_SIZE 4
246#define USE_SINGLE
247/* the SH changes have only been tested in =little endian= mode */
248/* I'm not sure about big endian, so let's warn: */
249#if defined(__sh__) && BB_BIG_ENDIAN
250# error insmod.c may require changes for use on big endian SH
251#endif
252/* it may or may not work on the SH1/SH2... Error on those also */
253#if ((!(defined(__SH3__) || defined(__SH4__) || defined(__SH5__)))) && (defined(__sh__))
254#error insmod.c may require changes for SH1 or SH2 use
255#endif
256#endif
257
258/* Sparc */
259#if defined(__sparc__)
260#define MATCH_MACHINE(x) (x == EM_SPARC)
261#define SHT_RELM SHT_RELA
262#define Elf32_RelM Elf32_Rela
263#define ELFCLASSM ELFCLASS32
264#endif
265
266/* v850e */
267#if defined(__v850e__)
268#define MATCH_MACHINE(x) ((x) == EM_V850 || (x) == EM_CYGNUS_V850)
269#define SHT_RELM SHT_RELA
270#define Elf32_RelM Elf32_Rela
271#define ELFCLASSM ELFCLASS32
272#define USE_PLT_ENTRIES
273#define PLT_ENTRY_SIZE 8
274#define USE_SINGLE
275#ifndef EM_CYGNUS_V850 /* grumble */
276#define EM_CYGNUS_V850 0x9080
277#endif
278#define SYMBOL_PREFIX "_"
279#endif
280
281/* X86_64 */
282#if defined(__x86_64__)
283#define MATCH_MACHINE(x) (x == EM_X86_64)
284#define SHT_RELM SHT_RELA
285#define USE_GOT_ENTRIES
286#define GOT_ENTRY_SIZE 8
287#define USE_SINGLE
288#define Elf64_RelM Elf64_Rela
289#define ELFCLASSM ELFCLASS64
290#endif
291
292#ifndef SHT_RELM
293#error Sorry, but insmod.c does not yet support this architecture...
294#endif
295
296
297//----------------------------------------------------------------------------
298//--------modutils module.h, lines 45-242
299//----------------------------------------------------------------------------
300
301/* Definitions for the Linux module syscall interface.
302 Copyright 1996, 1997 Linux International.
303
304 Contributed by Richard Henderson <rth@tamu.edu>
305
306 This file is part of the Linux modutils.
307
308 This program is free software; you can redistribute it and/or modify it
309 under the terms of the GNU General Public License as published by the
310 Free Software Foundation; either version 2 of the License, or (at your
311 option) any later version.
312
313 This program is distributed in the hope that it will be useful, but
314 WITHOUT ANY WARRANTY; without even the implied warranty of
315 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
316 General Public License for more details.
317
318 You should have received a copy of the GNU General Public License
319 along with this program; if not, write to the Free Software Foundation,
320 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
321
322
323#ifndef MODUTILS_MODULE_H
324
325/*======================================================================*/
326/* For sizeof() which are related to the module platform and not to the
327 environment isnmod is running in, use sizeof_xx instead of sizeof(xx). */
328
329#define tgt_sizeof_char sizeof(char)
330#define tgt_sizeof_short sizeof(short)
331#define tgt_sizeof_int sizeof(int)
332#define tgt_sizeof_long sizeof(long)
333#define tgt_sizeof_char_p sizeof(char *)
334#define tgt_sizeof_void_p sizeof(void *)
335#define tgt_long long
336
337#if defined(__sparc__) && !defined(__sparc_v9__) && defined(ARCH_sparc64)
338#undef tgt_sizeof_long
339#undef tgt_sizeof_char_p
340#undef tgt_sizeof_void_p
341#undef tgt_long
342enum {
343 tgt_sizeof_long = 8,
344 tgt_sizeof_char_p = 8,
345 tgt_sizeof_void_p = 8
346};
347#define tgt_long long long
348#endif
349
350/*======================================================================*/
351/* The structures used in Linux 2.1. */
352
353/* Note: new_module_symbol does not use tgt_long intentionally */
354struct new_module_symbol {
355 unsigned long value;
356 unsigned long name;
357};
358
359struct new_module_persist;
360
361struct new_module_ref {
362 unsigned tgt_long dep; /* kernel addresses */
363 unsigned tgt_long ref;
364 unsigned tgt_long next_ref;
365};
366
367struct new_module {
368 unsigned tgt_long size_of_struct; /* == sizeof(module) */
369 unsigned tgt_long next;
370 unsigned tgt_long name;
371 unsigned tgt_long size;
372
373 tgt_long usecount;
374 unsigned tgt_long flags; /* AUTOCLEAN et al */
375
376 unsigned nsyms;
377 unsigned ndeps;
378
379 unsigned tgt_long syms;
380 unsigned tgt_long deps;
381 unsigned tgt_long refs;
382 unsigned tgt_long init;
383 unsigned tgt_long cleanup;
384 unsigned tgt_long ex_table_start;
385 unsigned tgt_long ex_table_end;
386#ifdef __alpha__
387 unsigned tgt_long gp;
388#endif
389 /* Everything after here is extension. */
390 unsigned tgt_long persist_start;
391 unsigned tgt_long persist_end;
392 unsigned tgt_long can_unload;
393 unsigned tgt_long runsize;
394 const char *kallsyms_start; /* All symbols for kernel debugging */
395 const char *kallsyms_end;
396 const char *archdata_start; /* arch specific data for module */
397 const char *archdata_end;
398 const char *kernel_data; /* Reserved for kernel internal use */
399};
400
401#ifdef ARCHDATAM
402#define ARCHDATA_SEC_NAME ARCHDATAM
403#else
404#define ARCHDATA_SEC_NAME "__archdata"
405#endif
406#define KALLSYMS_SEC_NAME "__kallsyms"
407
408
409struct new_module_info {
410 unsigned long addr;
411 unsigned long size;
412 unsigned long flags;
413 long usecount;
414};
415
416/* Bits of module.flags. */
417enum {
418 NEW_MOD_RUNNING = 1,
419 NEW_MOD_DELETED = 2,
420 NEW_MOD_AUTOCLEAN = 4,
421 NEW_MOD_VISITED = 8,
422 NEW_MOD_USED_ONCE = 16
423};
424
425int init_module(const char *name, const struct new_module *);
426int query_module(const char *name, int which, void *buf,
427 size_t bufsize, size_t *ret);
428
429/* Values for query_module's which. */
430enum {
431 QM_MODULES = 1,
432 QM_DEPS = 2,
433 QM_REFS = 3,
434 QM_SYMBOLS = 4,
435 QM_INFO = 5
436};
437
438/*======================================================================*/
439/* The system calls unchanged between 2.0 and 2.1. */
440
441unsigned long create_module(const char *, size_t);
442int delete_module(const char *module, unsigned int flags);
443
444
445#endif /* module.h */
446
447//----------------------------------------------------------------------------
448//--------end of modutils module.h
449//----------------------------------------------------------------------------
450
451
452
453//----------------------------------------------------------------------------
454//--------modutils obj.h, lines 253-462
455//----------------------------------------------------------------------------
456
457/* Elf object file loading and relocation routines.
458 Copyright 1996, 1997 Linux International.
459
460 Contributed by Richard Henderson <rth@tamu.edu>
461
462 This file is part of the Linux modutils.
463
464 This program is free software; you can redistribute it and/or modify it
465 under the terms of the GNU General Public License as published by the
466 Free Software Foundation; either version 2 of the License, or (at your
467 option) any later version.
468
469 This program is distributed in the hope that it will be useful, but
470 WITHOUT ANY WARRANTY; without even the implied warranty of
471 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
472 General Public License for more details.
473
474 You should have received a copy of the GNU General Public License
475 along with this program; if not, write to the Free Software Foundation,
476 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
477
478
479#ifndef MODUTILS_OBJ_H
480
481/* The relocatable object is manipulated using elfin types. */
482
483#include <elf.h>
484#include <endian.h>
485
486#ifndef ElfW
487# if ELFCLASSM == ELFCLASS32
488# define ElfW(x) Elf32_ ## x
489# define ELFW(x) ELF32_ ## x
490# else
491# define ElfW(x) Elf64_ ## x
492# define ELFW(x) ELF64_ ## x
493# endif
494#endif
495
496/* For some reason this is missing from some ancient C libraries.... */
497#ifndef ELF32_ST_INFO
498# define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
499#endif
500
501#ifndef ELF64_ST_INFO
502# define ELF64_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
503#endif
504
505#define ELF_ST_BIND(info) ELFW(ST_BIND)(info)
506#define ELF_ST_TYPE(info) ELFW(ST_TYPE)(info)
507#define ELF_ST_INFO(bind, type) ELFW(ST_INFO)(bind, type)
508#define ELF_R_TYPE(val) ELFW(R_TYPE)(val)
509#define ELF_R_SYM(val) ELFW(R_SYM)(val)
510
511struct obj_string_patch;
512struct obj_symbol_patch;
513
514struct obj_section
515{
516 ElfW(Shdr) header;
517 const char *name;
518 char *contents;
519 struct obj_section *load_next;
520 int idx;
521};
522
523struct obj_symbol
524{
525 struct obj_symbol *next; /* hash table link */
526 const char *name;
527 unsigned long value;
528 unsigned long size;
529 int secidx; /* the defining section index/module */
530 int info;
531 int ksymidx; /* for export to the kernel symtab */
532 int referenced; /* actually used in the link */
533};
534
535/* Hardcode the hash table size. We shouldn't be needing so many
536 symbols that we begin to degrade performance, and we get a big win
537 by giving the compiler a constant divisor. */
538
539#define HASH_BUCKETS 521
540
541struct obj_file {
542 ElfW(Ehdr) header;
543 ElfW(Addr) baseaddr;
544 struct obj_section **sections;
545 struct obj_section *load_order;
546 struct obj_section **load_order_search_start;
547 struct obj_string_patch *string_patches;
548 struct obj_symbol_patch *symbol_patches;
549 int (*symbol_cmp)(const char *, const char *);
550 unsigned long (*symbol_hash)(const char *);
551 unsigned long local_symtab_size;
552 struct obj_symbol **local_symtab;
553 struct obj_symbol *symtab[HASH_BUCKETS];
554};
555
556enum obj_reloc {
557 obj_reloc_ok,
558 obj_reloc_overflow,
559 obj_reloc_dangerous,
560 obj_reloc_unhandled
561};
562
563struct obj_string_patch {
564 struct obj_string_patch *next;
565 int reloc_secidx;
566 ElfW(Addr) reloc_offset;
567 ElfW(Addr) string_offset;
568};
569
570struct obj_symbol_patch {
571 struct obj_symbol_patch *next;
572 int reloc_secidx;
573 ElfW(Addr) reloc_offset;
574 struct obj_symbol *sym;
575};
576
577
578/* Generic object manipulation routines. */
579
580static unsigned long obj_elf_hash(const char *);
581
582static unsigned long obj_elf_hash_n(const char *, unsigned long len);
583
584static struct obj_symbol *obj_find_symbol(struct obj_file *f,
585 const char *name);
586
587static ElfW(Addr) obj_symbol_final_value(struct obj_file *f,
588 struct obj_symbol *sym);
589
590#if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
591static void obj_set_symbol_compare(struct obj_file *f,
592 int (*cmp)(const char *, const char *),
593 unsigned long (*hash)(const char *));
594#endif
595
596static struct obj_section *obj_find_section(struct obj_file *f,
597 const char *name);
598
599static void obj_insert_section_load_order(struct obj_file *f,
600 struct obj_section *sec);
601
602static struct obj_section *obj_create_alloced_section(struct obj_file *f,
603 const char *name,
604 unsigned long align,
605 unsigned long size);
606
607static struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
608 const char *name,
609 unsigned long align,
610 unsigned long size);
611
612static void *obj_extend_section(struct obj_section *sec, unsigned long more);
613
614static void obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
615 const char *string);
616
617static void obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
618 struct obj_symbol *sym);
619
620static void obj_check_undefineds(struct obj_file *f);
621
622static void obj_allocate_commons(struct obj_file *f);
623
624static unsigned long obj_load_size(struct obj_file *f);
625
626static int obj_relocate(struct obj_file *f, ElfW(Addr) base);
627
628static struct obj_file *obj_load(FILE *f, int loadprogbits);
629
630static int obj_create_image(struct obj_file *f, char *image);
631
632/* Architecture specific manipulation routines. */
633
634static struct obj_file *arch_new_file(void);
635
636static struct obj_section *arch_new_section(void);
637
638static struct obj_symbol *arch_new_symbol(void);
639
640static enum obj_reloc arch_apply_relocation(struct obj_file *f,
641 struct obj_section *targsec,
642 /*struct obj_section *symsec,*/
643 struct obj_symbol *sym,
644 ElfW(RelM) *rel, ElfW(Addr) value);
645
646static void arch_create_got(struct obj_file *f);
647#if ENABLE_FEATURE_CHECK_TAINTED_MODULE
648static int obj_gpl_license(struct obj_file *f, const char **license);
649#endif /* FEATURE_CHECK_TAINTED_MODULE */
650#endif /* obj.h */
651//----------------------------------------------------------------------------
652//--------end of modutils obj.h
653//----------------------------------------------------------------------------
654
655
656/* SPFX is always a string, so it can be concatenated to string constants. */
657#ifdef SYMBOL_PREFIX
658#define SPFX SYMBOL_PREFIX
659#else
660#define SPFX ""
661#endif
662
663enum { STRVERSIONLEN = 64 };
664
665/*======================================================================*/
666
667#define flag_force_load (option_mask32 & INSMOD_OPT_FORCE)
668#define flag_autoclean (option_mask32 & INSMOD_OPT_KERNELD)
669#define flag_verbose (option_mask32 & INSMOD_OPT_VERBOSE)
670#define flag_quiet (option_mask32 & INSMOD_OPT_SILENT)
671#define flag_noexport (option_mask32 & INSMOD_OPT_NO_EXPORT)
672#define flag_print_load_map (option_mask32 & INSMOD_OPT_PRINT_MAP)
673
674/*======================================================================*/
675
676#if defined(USE_LIST)
677
678struct arch_list_entry
679{
680 struct arch_list_entry *next;
681 LIST_ARCHTYPE addend;
682 int offset;
683 int inited : 1;
684};
685
686#endif
687
688#if defined(USE_SINGLE)
689
690struct arch_single_entry
691{
692 int offset;
693 int inited : 1;
694 int allocated : 1;
695};
696
697#endif
698
699#if defined(__mips__)
700struct mips_hi16
701{
702 struct mips_hi16 *next;
703 ElfW(Addr) *addr;
704 ElfW(Addr) value;
705};
706#endif
707
708struct arch_file {
709 struct obj_file root;
710#if defined(USE_PLT_ENTRIES)
711 struct obj_section *plt;
712#endif
713#if defined(USE_GOT_ENTRIES)
714 struct obj_section *got;
715#endif
716#if defined(__mips__)
717 struct mips_hi16 *mips_hi16_list;
718#endif
719};
720
721struct arch_symbol {
722 struct obj_symbol root;
723#if defined(USE_PLT_ENTRIES)
724#if defined(USE_PLT_LIST)
725 struct arch_list_entry *pltent;
726#else
727 struct arch_single_entry pltent;
728#endif
729#endif
730#if defined(USE_GOT_ENTRIES)
731 struct arch_single_entry gotent;
732#endif
733};
734
735
736struct external_module {
737 const char *name;
738 ElfW(Addr) addr;
739 int used;
740 size_t nsyms;
741 struct new_module_symbol *syms;
742};
743
744static struct new_module_symbol *ksyms;
745static size_t nksyms;
746
747static struct external_module *ext_modules;
748static int n_ext_modules;
749static int n_ext_modules_used;
750
751/*======================================================================*/
752
753
754static struct obj_file *arch_new_file(void)
755{
756 struct arch_file *f;
757 f = xzalloc(sizeof(*f));
758 return &f->root; /* it's a first member */
759}
760
761static struct obj_section *arch_new_section(void)
762{
763 return xzalloc(sizeof(struct obj_section));
764}
765
766static struct obj_symbol *arch_new_symbol(void)
767{
768 struct arch_symbol *sym;
769 sym = xzalloc(sizeof(*sym));
770 return &sym->root;
771}
772
773static enum obj_reloc
774arch_apply_relocation(struct obj_file *f,
775 struct obj_section *targsec,
776 /*struct obj_section *symsec,*/
777 struct obj_symbol *sym,
778 ElfW(RelM) *rel, ElfW(Addr) v)
779{
780#if defined(__arm__) || defined(__i386__) || defined(__mc68000__) \
781 || defined(__sh__) || defined(__s390__) || defined(__x86_64__) \
782 || defined(__powerpc__) || defined(__mips__)
783 struct arch_file *ifile = (struct arch_file *) f;
784#endif
785 enum obj_reloc ret = obj_reloc_ok;
786 ElfW(Addr) *loc = (ElfW(Addr) *) (targsec->contents + rel->r_offset);
787#if defined(__arm__) || defined(__H8300H__) || defined(__H8300S__) \
788 || defined(__i386__) || defined(__mc68000__) || defined(__microblaze__) \
789 || defined(__mips__) || defined(__nios2__) || defined(__powerpc__) \
790 || defined(__s390__) || defined(__sh__) || defined(__x86_64__)
791 ElfW(Addr) dot = targsec->header.sh_addr + rel->r_offset;
792#endif
793#if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
794 struct arch_symbol *isym = (struct arch_symbol *) sym;
795#endif
796#if defined(__arm__) || defined(__i386__) || defined(__mc68000__) \
797 || defined(__sh__) || defined(__s390__)
798#if defined(USE_GOT_ENTRIES)
799 ElfW(Addr) got = ifile->got ? ifile->got->header.sh_addr : 0;
800#endif
801#endif
802#if defined(USE_PLT_ENTRIES)
803 ElfW(Addr) plt = ifile->plt ? ifile->plt->header.sh_addr : 0;
804 unsigned long *ip;
805# if defined(USE_PLT_LIST)
806 struct arch_list_entry *pe;
807# else
808 struct arch_single_entry *pe;
809# endif
810#endif
811
812 switch (ELF_R_TYPE(rel->r_info)) {
813
814#if defined(__arm__)
815
816 case R_ARM_NONE:
817 break;
818
819 case R_ARM_ABS32:
820 *loc += v;
821 break;
822
823 case R_ARM_GOT32:
824 goto bb_use_got;
825
826 case R_ARM_GOTPC:
827 /* relative reloc, always to _GLOBAL_OFFSET_TABLE_
828 * (which is .got) similar to branch,
829 * but is full 32 bits relative */
830
831 *loc += got - dot;
832 break;
833
834 case R_ARM_PC24:
835 case R_ARM_PLT32:
836 goto bb_use_plt;
837
838 case R_ARM_GOTOFF: /* address relative to the got */
839 *loc += v - got;
840 break;
841
842#elif defined(__cris__)
843
844 case R_CRIS_NONE:
845 break;
846
847 case R_CRIS_32:
848 /* CRIS keeps the relocation value in the r_addend field and
849 * should not use whats in *loc at all
850 */
851 *loc = v;
852 break;
853
854#elif defined(__H8300H__) || defined(__H8300S__)
855
856 case R_H8_DIR24R8:
857 loc = (ElfW(Addr) *)((ElfW(Addr))loc - 1);
858 *loc = (*loc & 0xff000000) | ((*loc & 0xffffff) + v);
859 break;
860 case R_H8_DIR24A8:
861 *loc += v;
862 break;
863 case R_H8_DIR32:
864 case R_H8_DIR32A16:
865 *loc += v;
866 break;
867 case R_H8_PCREL16:
868 v -= dot + 2;
869 if ((ElfW(Sword))v > 0x7fff ||
870 (ElfW(Sword))v < -(ElfW(Sword))0x8000)
871 ret = obj_reloc_overflow;
872 else
873 *(unsigned short *)loc = v;
874 break;
875 case R_H8_PCREL8:
876 v -= dot + 1;
877 if ((ElfW(Sword))v > 0x7f ||
878 (ElfW(Sword))v < -(ElfW(Sword))0x80)
879 ret = obj_reloc_overflow;
880 else
881 *(unsigned char *)loc = v;
882 break;
883
884#elif defined(__i386__)
885
886 case R_386_NONE:
887 break;
888
889 case R_386_32:
890 *loc += v;
891 break;
892
893 case R_386_PLT32:
894 case R_386_PC32:
895 case R_386_GOTOFF:
896 *loc += v - dot;
897 break;
898
899 case R_386_GLOB_DAT:
900 case R_386_JMP_SLOT:
901 *loc = v;
902 break;
903
904 case R_386_RELATIVE:
905 *loc += f->baseaddr;
906 break;
907
908 case R_386_GOTPC:
909 *loc += got - dot;
910 break;
911
912 case R_386_GOT32:
913 goto bb_use_got;
914 break;
915
916#elif defined(__microblaze__)
917 case R_MICROBLAZE_NONE:
918 case R_MICROBLAZE_64_NONE:
919 case R_MICROBLAZE_32_SYM_OP_SYM:
920 case R_MICROBLAZE_32_PCREL:
921 break;
922
923 case R_MICROBLAZE_64_PCREL: {
924 /* dot is the address of the current instruction.
925 * v is the target symbol address.
926 * So we need to extract the offset in the code,
927 * adding v, then subtrating the current address
928 * of this instruction.
929 * Ex: "IMM 0xFFFE bralid 0x0000" = "bralid 0xFFFE0000"
930 */
931
932 /* Get split offset stored in code */
933 unsigned int temp = (loc[0] & 0xFFFF) << 16 |
934 (loc[1] & 0xFFFF);
935
936 /* Adjust relative offset. -4 adjustment required
937 * because dot points to the IMM insn, but branch
938 * is computed relative to the branch instruction itself.
939 */
940 temp += v - dot - 4;
941
942 /* Store back into code */
943 loc[0] = (loc[0] & 0xFFFF0000) | temp >> 16;
944 loc[1] = (loc[1] & 0xFFFF0000) | (temp & 0xFFFF);
945
946 break;
947 }
948
949 case R_MICROBLAZE_32:
950 *loc += v;
951 break;
952
953 case R_MICROBLAZE_64: {
954 /* Get split pointer stored in code */
955 unsigned int temp1 = (loc[0] & 0xFFFF) << 16 |
956 (loc[1] & 0xFFFF);
957
958 /* Add reloc offset */
959 temp1+=v;
960
961 /* Store back into code */
962 loc[0] = (loc[0] & 0xFFFF0000) | temp1 >> 16;
963 loc[1] = (loc[1] & 0xFFFF0000) | (temp1 & 0xFFFF);
964
965 break;
966 }
967
968 case R_MICROBLAZE_32_PCREL_LO:
969 case R_MICROBLAZE_32_LO:
970 case R_MICROBLAZE_SRO32:
971 case R_MICROBLAZE_SRW32:
972 ret = obj_reloc_unhandled;
973 break;
974
975#elif defined(__mc68000__)
976
977 case R_68K_NONE:
978 break;
979
980 case R_68K_32:
981 *loc += v;
982 break;
983
984 case R_68K_8:
985 if (v > 0xff) {
986 ret = obj_reloc_overflow;
987 }
988 *(char *)loc = v;
989 break;
990
991 case R_68K_16:
992 if (v > 0xffff) {
993 ret = obj_reloc_overflow;
994 }
995 *(short *)loc = v;
996 break;
997
998 case R_68K_PC8:
999 v -= dot;
1000 if ((ElfW(Sword))v > 0x7f ||
1001 (ElfW(Sword))v < -(ElfW(Sword))0x80) {
1002 ret = obj_reloc_overflow;
1003 }
1004 *(char *)loc = v;
1005 break;
1006
1007 case R_68K_PC16:
1008 v -= dot;
1009 if ((ElfW(Sword))v > 0x7fff ||
1010 (ElfW(Sword))v < -(ElfW(Sword))0x8000) {
1011 ret = obj_reloc_overflow;
1012 }
1013 *(short *)loc = v;
1014 break;
1015
1016 case R_68K_PC32:
1017 *(int *)loc = v - dot;
1018 break;
1019
1020 case R_68K_GLOB_DAT:
1021 case R_68K_JMP_SLOT:
1022 *loc = v;
1023 break;
1024
1025 case R_68K_RELATIVE:
1026 *(int *)loc += f->baseaddr;
1027 break;
1028
1029 case R_68K_GOT32:
1030 goto bb_use_got;
1031
1032# ifdef R_68K_GOTOFF
1033 case R_68K_GOTOFF:
1034 *loc += v - got;
1035 break;
1036# endif
1037
1038#elif defined(__mips__)
1039
1040 case R_MIPS_NONE:
1041 break;
1042
1043 case R_MIPS_32:
1044 *loc += v;
1045 break;
1046
1047 case R_MIPS_26:
1048 if (v % 4)
1049 ret = obj_reloc_dangerous;
1050 if ((v & 0xf0000000) != ((dot + 4) & 0xf0000000))
1051 ret = obj_reloc_overflow;
1052 *loc =
1053 (*loc & ~0x03ffffff) | ((*loc + (v >> 2)) &
1054 0x03ffffff);
1055 break;
1056
1057 case R_MIPS_HI16:
1058 {
1059 struct mips_hi16 *n;
1060
1061 /* We cannot relocate this one now because we don't know the value
1062 of the carry we need to add. Save the information, and let LO16
1063 do the actual relocation. */
1064 n = xmalloc(sizeof *n);
1065 n->addr = loc;
1066 n->value = v;
1067 n->next = ifile->mips_hi16_list;
1068 ifile->mips_hi16_list = n;
1069 break;
1070 }
1071
1072 case R_MIPS_LO16:
1073 {
1074 unsigned long insnlo = *loc;
1075 ElfW(Addr) val, vallo;
1076
1077 /* Sign extend the addend we extract from the lo insn. */
1078 vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
1079
1080 if (ifile->mips_hi16_list != NULL) {
1081 struct mips_hi16 *l;
1082
1083 l = ifile->mips_hi16_list;
1084 while (l != NULL) {
1085 struct mips_hi16 *next;
1086 unsigned long insn;
1087
1088 /* Do the HI16 relocation. Note that we actually don't
1089 need to know anything about the LO16 itself, except where
1090 to find the low 16 bits of the addend needed by the LO16. */
1091 insn = *l->addr;
1092 val =
1093 ((insn & 0xffff) << 16) +
1094 vallo;
1095 val += v;
1096
1097 /* Account for the sign extension that will happen in the
1098 low bits. */
1099 val =
1100 ((val >> 16) +
1101 ((val & 0x8000) !=
1102 0)) & 0xffff;
1103
1104 insn = (insn & ~0xffff) | val;
1105 *l->addr = insn;
1106
1107 next = l->next;
1108 free(l);
1109 l = next;
1110 }
1111
1112 ifile->mips_hi16_list = NULL;
1113 }
1114
1115 /* Ok, we're done with the HI16 relocs. Now deal with the LO16. */
1116 val = v + vallo;
1117 insnlo = (insnlo & ~0xffff) | (val & 0xffff);
1118 *loc = insnlo;
1119 break;
1120 }
1121
1122#elif defined(__nios2__)
1123
1124 case R_NIOS2_NONE:
1125 break;
1126
1127 case R_NIOS2_BFD_RELOC_32:
1128 *loc += v;
1129 break;
1130
1131 case R_NIOS2_BFD_RELOC_16:
1132 if (v > 0xffff) {
1133 ret = obj_reloc_overflow;
1134 }
1135 *(short *)loc = v;
1136 break;
1137
1138 case R_NIOS2_BFD_RELOC_8:
1139 if (v > 0xff) {
1140 ret = obj_reloc_overflow;
1141 }
1142 *(char *)loc = v;
1143 break;
1144
1145 case R_NIOS2_S16:
1146 {
1147 Elf32_Addr word;
1148
1149 if ((Elf32_Sword)v > 0x7fff ||
1150 (Elf32_Sword)v < -(Elf32_Sword)0x8000) {
1151 ret = obj_reloc_overflow;
1152 }
1153
1154 word = *loc;
1155 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1156 (word & 0x3f);
1157 }
1158 break;
1159
1160 case R_NIOS2_U16:
1161 {
1162 Elf32_Addr word;
1163
1164 if (v > 0xffff) {
1165 ret = obj_reloc_overflow;
1166 }
1167
1168 word = *loc;
1169 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1170 (word & 0x3f);
1171 }
1172 break;
1173
1174 case R_NIOS2_PCREL16:
1175 {
1176 Elf32_Addr word;
1177
1178 v -= dot + 4;
1179 if ((Elf32_Sword)v > 0x7fff ||
1180 (Elf32_Sword)v < -(Elf32_Sword)0x8000) {
1181 ret = obj_reloc_overflow;
1182 }
1183
1184 word = *loc;
1185 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) | (word & 0x3f);
1186 }
1187 break;
1188
1189 case R_NIOS2_GPREL:
1190 {
1191 Elf32_Addr word, gp;
1192 /* get _gp */
1193 gp = obj_symbol_final_value(f, obj_find_symbol(f, SPFX "_gp"));
1194 v-=gp;
1195 if ((Elf32_Sword)v > 0x7fff ||
1196 (Elf32_Sword)v < -(Elf32_Sword)0x8000) {
1197 ret = obj_reloc_overflow;
1198 }
1199
1200 word = *loc;
1201 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) | (word & 0x3f);
1202 }
1203 break;
1204
1205 case R_NIOS2_CALL26:
1206 if (v & 3)
1207 ret = obj_reloc_dangerous;
1208 if ((v >> 28) != (dot >> 28))
1209 ret = obj_reloc_overflow;
1210 *loc = (*loc & 0x3f) | ((v >> 2) << 6);
1211 break;
1212
1213 case R_NIOS2_IMM5:
1214 {
1215 Elf32_Addr word;
1216
1217 if (v > 0x1f) {
1218 ret = obj_reloc_overflow;
1219 }
1220
1221 word = *loc & ~0x7c0;
1222 *loc = word | ((v & 0x1f) << 6);
1223 }
1224 break;
1225
1226 case R_NIOS2_IMM6:
1227 {
1228 Elf32_Addr word;
1229
1230 if (v > 0x3f) {
1231 ret = obj_reloc_overflow;
1232 }
1233
1234 word = *loc & ~0xfc0;
1235 *loc = word | ((v & 0x3f) << 6);
1236 }
1237 break;
1238
1239 case R_NIOS2_IMM8:
1240 {
1241 Elf32_Addr word;
1242
1243 if (v > 0xff) {
1244 ret = obj_reloc_overflow;
1245 }
1246
1247 word = *loc & ~0x3fc0;
1248 *loc = word | ((v & 0xff) << 6);
1249 }
1250 break;
1251
1252 case R_NIOS2_HI16:
1253 {
1254 Elf32_Addr word;
1255
1256 word = *loc;
1257 *loc = ((((word >> 22) << 16) | ((v >>16) & 0xffff)) << 6) |
1258 (word & 0x3f);
1259 }
1260 break;
1261
1262 case R_NIOS2_LO16:
1263 {
1264 Elf32_Addr word;
1265
1266 word = *loc;
1267 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1268 (word & 0x3f);
1269 }
1270 break;
1271
1272 case R_NIOS2_HIADJ16:
1273 {
1274 Elf32_Addr word1, word2;
1275
1276 word1 = *loc;
1277 word2 = ((v >> 16) + ((v >> 15) & 1)) & 0xffff;
1278 *loc = ((((word1 >> 22) << 16) | word2) << 6) |
1279 (word1 & 0x3f);
1280 }
1281 break;
1282
1283#elif defined(__powerpc64__)
1284 /* PPC64 needs a 2.6 kernel, 2.4 module relocation irrelevant */
1285
1286#elif defined(__powerpc__)
1287
1288 case R_PPC_ADDR16_HA:
1289 *(unsigned short *)loc = (v + 0x8000) >> 16;
1290 break;
1291
1292 case R_PPC_ADDR16_HI:
1293 *(unsigned short *)loc = v >> 16;
1294 break;
1295
1296 case R_PPC_ADDR16_LO:
1297 *(unsigned short *)loc = v;
1298 break;
1299
1300 case R_PPC_REL24:
1301 goto bb_use_plt;
1302
1303 case R_PPC_REL32:
1304 *loc = v - dot;
1305 break;
1306
1307 case R_PPC_ADDR32:
1308 *loc = v;
1309 break;
1310
1311#elif defined(__s390__)
1312
1313 case R_390_32:
1314 *(unsigned int *) loc += v;
1315 break;
1316 case R_390_16:
1317 *(unsigned short *) loc += v;
1318 break;
1319 case R_390_8:
1320 *(unsigned char *) loc += v;
1321 break;
1322
1323 case R_390_PC32:
1324 *(unsigned int *) loc += v - dot;
1325 break;
1326 case R_390_PC16DBL:
1327 *(unsigned short *) loc += (v - dot) >> 1;
1328 break;
1329 case R_390_PC16:
1330 *(unsigned short *) loc += v - dot;
1331 break;
1332
1333 case R_390_PLT32:
1334 case R_390_PLT16DBL:
1335 /* find the plt entry and initialize it. */
1336 pe = (struct arch_single_entry *) &isym->pltent;
1337 if (pe->inited == 0) {
1338 ip = (unsigned long *)(ifile->plt->contents + pe->offset);
1339 ip[0] = 0x0d105810; /* basr 1,0; lg 1,10(1); br 1 */
1340 ip[1] = 0x100607f1;
1341 if (ELF_R_TYPE(rel->r_info) == R_390_PLT16DBL)
1342 ip[2] = v - 2;
1343 else
1344 ip[2] = v;
1345 pe->inited = 1;
1346 }
1347
1348 /* Insert relative distance to target. */
1349 v = plt + pe->offset - dot;
1350 if (ELF_R_TYPE(rel->r_info) == R_390_PLT32)
1351 *(unsigned int *) loc = (unsigned int) v;
1352 else if (ELF_R_TYPE(rel->r_info) == R_390_PLT16DBL)
1353 *(unsigned short *) loc = (unsigned short) ((v + 2) >> 1);
1354 break;
1355
1356 case R_390_GLOB_DAT:
1357 case R_390_JMP_SLOT:
1358 *loc = v;
1359 break;
1360
1361 case R_390_RELATIVE:
1362 *loc += f->baseaddr;
1363 break;
1364
1365 case R_390_GOTPC:
1366 *(unsigned long *) loc += got - dot;
1367 break;
1368
1369 case R_390_GOT12:
1370 case R_390_GOT16:
1371 case R_390_GOT32:
1372 if (!isym->gotent.inited)
1373 {
1374 isym->gotent.inited = 1;
1375 *(ElfW(Addr) *)(ifile->got->contents + isym->gotent.offset) = v;
1376 }
1377 if (ELF_R_TYPE(rel->r_info) == R_390_GOT12)
1378 *(unsigned short *) loc |= (*(unsigned short *) loc + isym->gotent.offset) & 0xfff;
1379 else if (ELF_R_TYPE(rel->r_info) == R_390_GOT16)
1380 *(unsigned short *) loc += isym->gotent.offset;
1381 else if (ELF_R_TYPE(rel->r_info) == R_390_GOT32)
1382 *(unsigned int *) loc += isym->gotent.offset;
1383 break;
1384
1385# ifndef R_390_GOTOFF32
1386# define R_390_GOTOFF32 R_390_GOTOFF
1387# endif
1388 case R_390_GOTOFF32:
1389 *loc += v - got;
1390 break;
1391
1392#elif defined(__sh__)
1393
1394 case R_SH_NONE:
1395 break;
1396
1397 case R_SH_DIR32:
1398 *loc += v;
1399 break;
1400
1401 case R_SH_REL32:
1402 *loc += v - dot;
1403 break;
1404
1405 case R_SH_PLT32:
1406 *loc = v - dot;
1407 break;
1408
1409 case R_SH_GLOB_DAT:
1410 case R_SH_JMP_SLOT:
1411 *loc = v;
1412 break;
1413
1414 case R_SH_RELATIVE:
1415 *loc = f->baseaddr + rel->r_addend;
1416 break;
1417
1418 case R_SH_GOTPC:
1419 *loc = got - dot + rel->r_addend;
1420 break;
1421
1422 case R_SH_GOT32:
1423 goto bb_use_got;
1424
1425 case R_SH_GOTOFF:
1426 *loc = v - got;
1427 break;
1428
1429# if defined(__SH5__)
1430 case R_SH_IMM_MEDLOW16:
1431 case R_SH_IMM_LOW16:
1432 {
1433 ElfW(Addr) word;
1434
1435 if (ELF_R_TYPE(rel->r_info) == R_SH_IMM_MEDLOW16)
1436 v >>= 16;
1437
1438 /*
1439 * movi and shori have the format:
1440 *
1441 * | op | imm | reg | reserved |
1442 * 31..26 25..10 9.. 4 3 .. 0
1443 *
1444 * so we simply mask and or in imm.
1445 */
1446 word = *loc & ~0x3fffc00;
1447 word |= (v & 0xffff) << 10;
1448
1449 *loc = word;
1450
1451 break;
1452 }
1453
1454 case R_SH_IMM_MEDLOW16_PCREL:
1455 case R_SH_IMM_LOW16_PCREL:
1456 {
1457 ElfW(Addr) word;
1458
1459 word = *loc & ~0x3fffc00;
1460
1461 v -= dot;
1462
1463 if (ELF_R_TYPE(rel->r_info) == R_SH_IMM_MEDLOW16_PCREL)
1464 v >>= 16;
1465
1466 word |= (v & 0xffff) << 10;
1467
1468 *loc = word;
1469
1470 break;
1471 }
1472# endif /* __SH5__ */
1473
1474#elif defined(__v850e__)
1475
1476 case R_V850_NONE:
1477 break;
1478
1479 case R_V850_32:
1480 /* We write two shorts instead of a long because even
1481 32-bit insns only need half-word alignment, but
1482 32-bit data needs to be long-word aligned. */
1483 v += ((unsigned short *)loc)[0];
1484 v += ((unsigned short *)loc)[1] << 16;
1485 ((unsigned short *)loc)[0] = v & 0xffff;
1486 ((unsigned short *)loc)[1] = (v >> 16) & 0xffff;
1487 break;
1488
1489 case R_V850_22_PCREL:
1490 goto bb_use_plt;
1491
1492#elif defined(__x86_64__)
1493
1494 case R_X86_64_NONE:
1495 break;
1496
1497 case R_X86_64_64:
1498 *loc += v;
1499 break;
1500
1501 case R_X86_64_32:
1502 *(unsigned int *) loc += v;
1503 if (v > 0xffffffff)
1504 {
1505 ret = obj_reloc_overflow; /* Kernel module compiled without -mcmodel=kernel. */
1506 /* error("Possibly is module compiled without -mcmodel=kernel!"); */
1507 }
1508 break;
1509
1510 case R_X86_64_32S:
1511 *(signed int *) loc += v;
1512 break;
1513
1514 case R_X86_64_16:
1515 *(unsigned short *) loc += v;
1516 break;
1517
1518 case R_X86_64_8:
1519 *(unsigned char *) loc += v;
1520 break;
1521
1522 case R_X86_64_PC32:
1523 *(unsigned int *) loc += v - dot;
1524 break;
1525
1526 case R_X86_64_PC16:
1527 *(unsigned short *) loc += v - dot;
1528 break;
1529
1530 case R_X86_64_PC8:
1531 *(unsigned char *) loc += v - dot;
1532 break;
1533
1534 case R_X86_64_GLOB_DAT:
1535 case R_X86_64_JUMP_SLOT:
1536 *loc = v;
1537 break;
1538
1539 case R_X86_64_RELATIVE:
1540 *loc += f->baseaddr;
1541 break;
1542
1543 case R_X86_64_GOT32:
1544 case R_X86_64_GOTPCREL:
1545 goto bb_use_got;
1546# if 0
1547 if (!isym->gotent.reloc_done)
1548 {
1549 isym->gotent.reloc_done = 1;
1550 *(Elf64_Addr *)(ifile->got->contents + isym->gotent.offset) = v;
1551 }
1552 /* XXX are these really correct? */
1553 if (ELF64_R_TYPE(rel->r_info) == R_X86_64_GOTPCREL)
1554 *(unsigned int *) loc += v + isym->gotent.offset;
1555 else
1556 *loc += isym->gotent.offset;
1557 break;
1558# endif
1559
1560#else
1561# warning "no idea how to handle relocations on your arch"
1562#endif
1563
1564 default:
1565 printf("Warning: unhandled reloc %d\n",(int)ELF_R_TYPE(rel->r_info));
1566 ret = obj_reloc_unhandled;
1567 break;
1568
1569#if defined(USE_PLT_ENTRIES)
1570
1571bb_use_plt:
1572
1573 /* find the plt entry and initialize it if necessary */
1574
1575#if defined(USE_PLT_LIST)
1576 for (pe = isym->pltent; pe != NULL && pe->addend != rel->r_addend;)
1577 pe = pe->next;
1578#else
1579 pe = &isym->pltent;
1580#endif
1581
1582 if (! pe->inited) {
1583 ip = (unsigned long *) (ifile->plt->contents + pe->offset);
1584
1585 /* generate some machine code */
1586
1587#if defined(__arm__)
1588 ip[0] = 0xe51ff004; /* ldr pc,[pc,#-4] */
1589 ip[1] = v; /* sym@ */
1590#endif
1591#if defined(__powerpc__)
1592 ip[0] = 0x3d600000 + ((v + 0x8000) >> 16); /* lis r11,sym@ha */
1593 ip[1] = 0x396b0000 + (v & 0xffff); /* addi r11,r11,sym@l */
1594 ip[2] = 0x7d6903a6; /* mtctr r11 */
1595 ip[3] = 0x4e800420; /* bctr */
1596#endif
1597#if defined(__v850e__)
1598 /* We have to trash a register, so we assume that any control
1599 transfer more than 21-bits away must be a function call
1600 (so we can use a call-clobbered register). */
1601 ip[0] = 0x0621 + ((v & 0xffff) << 16); /* mov sym, r1 ... */
1602 ip[1] = ((v >> 16) & 0xffff) + 0x610000; /* ...; jmp r1 */
1603#endif
1604 pe->inited = 1;
1605 }
1606
1607 /* relative distance to target */
1608 v -= dot;
1609 /* if the target is too far away.... */
1610#if defined(__arm__) || defined(__powerpc__)
1611 if ((int)v < -0x02000000 || (int)v >= 0x02000000)
1612#elif defined(__v850e__)
1613 if ((ElfW(Sword))v > 0x1fffff || (ElfW(Sword))v < (ElfW(Sword))-0x200000)
1614#endif
1615 /* go via the plt */
1616 v = plt + pe->offset - dot;
1617
1618#if defined(__v850e__)
1619 if (v & 1)
1620#else
1621 if (v & 3)
1622#endif
1623 ret = obj_reloc_dangerous;
1624
1625 /* merge the offset into the instruction. */
1626#if defined(__arm__)
1627 /* Convert to words. */
1628 v >>= 2;
1629
1630 *loc = (*loc & ~0x00ffffff) | ((v + *loc) & 0x00ffffff);
1631#endif
1632#if defined(__powerpc__)
1633 *loc = (*loc & ~0x03fffffc) | (v & 0x03fffffc);
1634#endif
1635#if defined(__v850e__)
1636 /* We write two shorts instead of a long because even 32-bit insns
1637 only need half-word alignment, but the 32-bit data write needs
1638 to be long-word aligned. */
1639 ((unsigned short *)loc)[0] =
1640 (*(unsigned short *)loc & 0xffc0) /* opcode + reg */
1641 | ((v >> 16) & 0x3f); /* offs high part */
1642 ((unsigned short *)loc)[1] =
1643 (v & 0xffff); /* offs low part */
1644#endif
1645 break;
1646#endif /* USE_PLT_ENTRIES */
1647
1648#if defined(USE_GOT_ENTRIES)
1649bb_use_got:
1650
1651 /* needs an entry in the .got: set it, once */
1652 if (!isym->gotent.inited) {
1653 isym->gotent.inited = 1;
1654 *(ElfW(Addr) *) (ifile->got->contents + isym->gotent.offset) = v;
1655 }
1656 /* make the reloc with_respect_to_.got */
1657#if defined(__sh__)
1658 *loc += isym->gotent.offset + rel->r_addend;
1659#elif defined(__i386__) || defined(__arm__) || defined(__mc68000__)
1660 *loc += isym->gotent.offset;
1661#endif
1662 break;
1663
1664#endif /* USE_GOT_ENTRIES */
1665 }
1666
1667 return ret;
1668}
1669
1670
1671#if defined(USE_LIST)
1672
1673static int arch_list_add(ElfW(RelM) *rel, struct arch_list_entry **list,
1674 int offset, int size)
1675{
1676 struct arch_list_entry *pe;
1677
1678 for (pe = *list; pe != NULL; pe = pe->next) {
1679 if (pe->addend == rel->r_addend) {
1680 break;
1681 }
1682 }
1683
1684 if (pe == NULL) {
1685 pe = xmalloc(sizeof(struct arch_list_entry));
1686 pe->next = *list;
1687 pe->addend = rel->r_addend;
1688 pe->offset = offset;
1689 pe->inited = 0;
1690 *list = pe;
1691 return size;
1692 }
1693 return 0;
1694}
1695
1696#endif
1697
1698#if defined(USE_SINGLE)
1699
1700static int arch_single_init(/*ElfW(RelM) *rel,*/ struct arch_single_entry *single,
1701 int offset, int size)
1702{
1703 if (single->allocated == 0) {
1704 single->allocated = 1;
1705 single->offset = offset;
1706 single->inited = 0;
1707 return size;
1708 }
1709 return 0;
1710}
1711
1712#endif
1713
1714#if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
1715
1716static struct obj_section *arch_xsect_init(struct obj_file *f, const char *name,
1717 int offset, int size)
1718{
1719 struct obj_section *myrelsec = obj_find_section(f, name);
1720
1721 if (offset == 0) {
1722 offset += size;
1723 }
1724
1725 if (myrelsec) {
1726 obj_extend_section(myrelsec, offset);
1727 } else {
1728 myrelsec = obj_create_alloced_section(f, name,
1729 size, offset);
1730 }
1731
1732 return myrelsec;
1733}
1734
1735#endif
1736
1737static void arch_create_got(struct obj_file *f)
1738{
1739#if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
1740 struct arch_file *ifile = (struct arch_file *) f;
1741 int i;
1742#if defined(USE_GOT_ENTRIES)
1743 int got_offset = 0, got_needed = 0, got_allocate;
1744#endif
1745#if defined(USE_PLT_ENTRIES)
1746 int plt_offset = 0, plt_needed = 0, plt_allocate;
1747#endif
1748 struct obj_section *relsec, *symsec, *strsec;
1749 ElfW(RelM) *rel, *relend;
1750 ElfW(Sym) *symtab, *extsym;
1751 const char *strtab, *name;
1752 struct arch_symbol *intsym;
1753
1754 for (i = 0; i < f->header.e_shnum; ++i) {
1755 relsec = f->sections[i];
1756 if (relsec->header.sh_type != SHT_RELM)
1757 continue;
1758
1759 symsec = f->sections[relsec->header.sh_link];
1760 strsec = f->sections[symsec->header.sh_link];
1761
1762 rel = (ElfW(RelM) *) relsec->contents;
1763 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
1764 symtab = (ElfW(Sym) *) symsec->contents;
1765 strtab = (const char *) strsec->contents;
1766
1767 for (; rel < relend; ++rel) {
1768 extsym = &symtab[ELF_R_SYM(rel->r_info)];
1769
1770#if defined(USE_GOT_ENTRIES)
1771 got_allocate = 0;
1772#endif
1773#if defined(USE_PLT_ENTRIES)
1774 plt_allocate = 0;
1775#endif
1776
1777 switch (ELF_R_TYPE(rel->r_info)) {
1778#if defined(__arm__)
1779 case R_ARM_PC24:
1780 case R_ARM_PLT32:
1781 plt_allocate = 1;
1782 break;
1783
1784 case R_ARM_GOTOFF:
1785 case R_ARM_GOTPC:
1786 got_needed = 1;
1787 continue;
1788
1789 case R_ARM_GOT32:
1790 got_allocate = 1;
1791 break;
1792
1793#elif defined(__i386__)
1794 case R_386_GOTPC:
1795 case R_386_GOTOFF:
1796 got_needed = 1;
1797 continue;
1798
1799 case R_386_GOT32:
1800 got_allocate = 1;
1801 break;
1802
1803#elif defined(__powerpc__)
1804 case R_PPC_REL24:
1805 plt_allocate = 1;
1806 break;
1807
1808#elif defined(__mc68000__)
1809 case R_68K_GOT32:
1810 got_allocate = 1;
1811 break;
1812
1813#ifdef R_68K_GOTOFF
1814 case R_68K_GOTOFF:
1815 got_needed = 1;
1816 continue;
1817#endif
1818
1819#elif defined(__sh__)
1820 case R_SH_GOT32:
1821 got_allocate = 1;
1822 break;
1823
1824 case R_SH_GOTPC:
1825 case R_SH_GOTOFF:
1826 got_needed = 1;
1827 continue;
1828
1829#elif defined(__v850e__)
1830 case R_V850_22_PCREL:
1831 plt_needed = 1;
1832 break;
1833
1834#endif
1835 default:
1836 continue;
1837 }
1838
1839 if (extsym->st_name != 0) {
1840 name = strtab + extsym->st_name;
1841 } else {
1842 name = f->sections[extsym->st_shndx]->name;
1843 }
1844 intsym = (struct arch_symbol *) obj_find_symbol(f, name);
1845#if defined(USE_GOT_ENTRIES)
1846 if (got_allocate) {
1847 got_offset += arch_single_init(
1848 /*rel,*/ &intsym->gotent,
1849 got_offset, GOT_ENTRY_SIZE);
1850
1851 got_needed = 1;
1852 }
1853#endif
1854#if defined(USE_PLT_ENTRIES)
1855 if (plt_allocate) {
1856#if defined(USE_PLT_LIST)
1857 plt_offset += arch_list_add(
1858 rel, &intsym->pltent,
1859 plt_offset, PLT_ENTRY_SIZE);
1860#else
1861 plt_offset += arch_single_init(
1862 /*rel,*/ &intsym->pltent,
1863 plt_offset, PLT_ENTRY_SIZE);
1864#endif
1865 plt_needed = 1;
1866 }
1867#endif
1868 }
1869 }
1870
1871#if defined(USE_GOT_ENTRIES)
1872 if (got_needed) {
1873 ifile->got = arch_xsect_init(f, ".got", got_offset,
1874 GOT_ENTRY_SIZE);
1875 }
1876#endif
1877
1878#if defined(USE_PLT_ENTRIES)
1879 if (plt_needed) {
1880 ifile->plt = arch_xsect_init(f, ".plt", plt_offset,
1881 PLT_ENTRY_SIZE);
1882 }
1883#endif
1884
1885#endif /* defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES) */
1886}
1887
1888/*======================================================================*/
1889
1890/* Standard ELF hash function. */
1891static unsigned long obj_elf_hash_n(const char *name, unsigned long n)
1892{
1893 unsigned long h = 0;
1894 unsigned long g;
1895 unsigned char ch;
1896
1897 while (n > 0) {
1898 ch = *name++;
1899 h = (h << 4) + ch;
1900 g = (h & 0xf0000000);
1901 if (g != 0) {
1902 h ^= g >> 24;
1903 h &= ~g;
1904 }
1905 n--;
1906 }
1907 return h;
1908}
1909
1910static unsigned long obj_elf_hash(const char *name)
1911{
1912 return obj_elf_hash_n(name, strlen(name));
1913}
1914
1915#if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
1916/* String comparison for non-co-versioned kernel and module. */
1917
1918static int ncv_strcmp(const char *a, const char *b)
1919{
1920 size_t alen = strlen(a), blen = strlen(b);
1921
1922 if (blen == alen + 10 && b[alen] == '_' && b[alen + 1] == 'R')
1923 return strncmp(a, b, alen);
1924 else if (alen == blen + 10 && a[blen] == '_' && a[blen + 1] == 'R')
1925 return strncmp(a, b, blen);
1926 else
1927 return strcmp(a, b);
1928}
1929
1930/* String hashing for non-co-versioned kernel and module. Here
1931 we are simply forced to drop the crc from the hash. */
1932
1933static unsigned long ncv_symbol_hash(const char *str)
1934{
1935 size_t len = strlen(str);
1936 if (len > 10 && str[len - 10] == '_' && str[len - 9] == 'R')
1937 len -= 10;
1938 return obj_elf_hash_n(str, len);
1939}
1940
1941static void
1942obj_set_symbol_compare(struct obj_file *f,
1943 int (*cmp) (const char *, const char *),
1944 unsigned long (*hash) (const char *))
1945{
1946 if (cmp)
1947 f->symbol_cmp = cmp;
1948 if (hash) {
1949 struct obj_symbol *tmptab[HASH_BUCKETS], *sym, *next;
1950 int i;
1951
1952 f->symbol_hash = hash;
1953
1954 memcpy(tmptab, f->symtab, sizeof(tmptab));
1955 memset(f->symtab, 0, sizeof(f->symtab));
1956
1957 for (i = 0; i < HASH_BUCKETS; ++i)
1958 for (sym = tmptab[i]; sym; sym = next) {
1959 unsigned long h = hash(sym->name) % HASH_BUCKETS;
1960 next = sym->next;
1961 sym->next = f->symtab[h];
1962 f->symtab[h] = sym;
1963 }
1964 }
1965}
1966
1967#endif /* FEATURE_INSMOD_VERSION_CHECKING */
1968
1969static struct obj_symbol *
1970obj_add_symbol(struct obj_file *f, const char *name,
1971 unsigned long symidx, int info,
1972 int secidx, ElfW(Addr) value,
1973 unsigned long size)
1974{
1975 struct obj_symbol *sym;
1976 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
1977 int n_type = ELF_ST_TYPE(info);
1978 int n_binding = ELF_ST_BIND(info);
1979
1980 for (sym = f->symtab[hash]; sym; sym = sym->next) {
1981 if (f->symbol_cmp(sym->name, name) == 0) {
1982 int o_secidx = sym->secidx;
1983 int o_info = sym->info;
1984 int o_type = ELF_ST_TYPE(o_info);
1985 int o_binding = ELF_ST_BIND(o_info);
1986
1987 /* A redefinition! Is it legal? */
1988
1989 if (secidx == SHN_UNDEF)
1990 return sym;
1991 else if (o_secidx == SHN_UNDEF)
1992 goto found;
1993 else if (n_binding == STB_GLOBAL && o_binding == STB_LOCAL) {
1994 /* Cope with local and global symbols of the same name
1995 in the same object file, as might have been created
1996 by ld -r. The only reason locals are now seen at this
1997 level at all is so that we can do semi-sensible things
1998 with parameters. */
1999
2000 struct obj_symbol *nsym, **p;
2001
2002 nsym = arch_new_symbol();
2003 nsym->next = sym->next;
2004 nsym->ksymidx = -1;
2005
2006 /* Excise the old (local) symbol from the hash chain. */
2007 for (p = &f->symtab[hash]; *p != sym; p = &(*p)->next)
2008 continue;
2009 *p = sym = nsym;
2010 goto found;
2011 } else if (n_binding == STB_LOCAL) {
2012 /* Another symbol of the same name has already been defined.
2013 Just add this to the local table. */
2014 sym = arch_new_symbol();
2015 sym->next = NULL;
2016 sym->ksymidx = -1;
2017 f->local_symtab[symidx] = sym;
2018 goto found;
2019 } else if (n_binding == STB_WEAK)
2020 return sym;
2021 else if (o_binding == STB_WEAK)
2022 goto found;
2023 /* Don't unify COMMON symbols with object types the programmer
2024 doesn't expect. */
2025 else if (secidx == SHN_COMMON
2026 && (o_type == STT_NOTYPE || o_type == STT_OBJECT))
2027 return sym;
2028 else if (o_secidx == SHN_COMMON
2029 && (n_type == STT_NOTYPE || n_type == STT_OBJECT))
2030 goto found;
2031 else {
2032 /* Don't report an error if the symbol is coming from
2033 the kernel or some external module. */
2034 if (secidx <= SHN_HIRESERVE)
2035 bb_error_msg("%s multiply defined", name);
2036 return sym;
2037 }
2038 }
2039 }
2040
2041 /* Completely new symbol. */
2042 sym = arch_new_symbol();
2043 sym->next = f->symtab[hash];
2044 f->symtab[hash] = sym;
2045 sym->ksymidx = -1;
2046 if (ELF_ST_BIND(info) == STB_LOCAL && symidx != (unsigned long)(-1)) {
2047 if (symidx >= f->local_symtab_size)
2048 bb_error_msg("local symbol %s with index %ld exceeds local_symtab_size %ld",
2049 name, (long) symidx, (long) f->local_symtab_size);
2050 else
2051 f->local_symtab[symidx] = sym;
2052 }
2053
2054found:
2055 sym->name = name;
2056 sym->value = value;
2057 sym->size = size;
2058 sym->secidx = secidx;
2059 sym->info = info;
2060
2061 return sym;
2062}
2063
2064static struct obj_symbol *
2065obj_find_symbol(struct obj_file *f, const char *name)
2066{
2067 struct obj_symbol *sym;
2068 unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
2069
2070 for (sym = f->symtab[hash]; sym; sym = sym->next)
2071 if (f->symbol_cmp(sym->name, name) == 0)
2072 return sym;
2073
2074 return NULL;
2075}
2076
2077static ElfW(Addr) obj_symbol_final_value(struct obj_file * f, struct obj_symbol * sym)
2078{
2079 if (sym) {
2080 if (sym->secidx >= SHN_LORESERVE)
2081 return sym->value;
2082
2083 return sym->value + f->sections[sym->secidx]->header.sh_addr;
2084 } else {
2085 /* As a special case, a NULL sym has value zero. */
2086 return 0;
2087 }
2088}
2089
2090static struct obj_section *obj_find_section(struct obj_file *f, const char *name)
2091{
2092 int i, n = f->header.e_shnum;
2093
2094 for (i = 0; i < n; ++i)
2095 if (strcmp(f->sections[i]->name, name) == 0)
2096 return f->sections[i];
2097
2098 return NULL;
2099}
2100
2101static int obj_load_order_prio(struct obj_section *a)
2102{
2103 unsigned long af, ac;
2104
2105 af = a->header.sh_flags;
2106
2107 ac = 0;
2108 if (a->name[0] != '.' || strlen(a->name) != 10 ||
2109 strcmp(a->name + 5, ".init"))
2110 ac |= 32;
2111 if (af & SHF_ALLOC)
2112 ac |= 16;
2113 if (!(af & SHF_WRITE))
2114 ac |= 8;
2115 if (af & SHF_EXECINSTR)
2116 ac |= 4;
2117 if (a->header.sh_type != SHT_NOBITS)
2118 ac |= 2;
2119
2120 return ac;
2121}
2122
2123static void
2124obj_insert_section_load_order(struct obj_file *f, struct obj_section *sec)
2125{
2126 struct obj_section **p;
2127 int prio = obj_load_order_prio(sec);
2128 for (p = f->load_order_search_start; *p; p = &(*p)->load_next)
2129 if (obj_load_order_prio(*p) < prio)
2130 break;
2131 sec->load_next = *p;
2132 *p = sec;
2133}
2134
2135static struct obj_section *obj_create_alloced_section(struct obj_file *f,
2136 const char *name,
2137 unsigned long align,
2138 unsigned long size)
2139{
2140 int newidx = f->header.e_shnum++;
2141 struct obj_section *sec;
2142
2143 f->sections = xrealloc_vector(f->sections, 2, newidx);
2144 f->sections[newidx] = sec = arch_new_section();
2145
2146 sec->header.sh_type = SHT_PROGBITS;
2147 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2148 sec->header.sh_size = size;
2149 sec->header.sh_addralign = align;
2150 sec->name = name;
2151 sec->idx = newidx;
2152 if (size)
2153 sec->contents = xmalloc(size);
2154
2155 obj_insert_section_load_order(f, sec);
2156
2157 return sec;
2158}
2159
2160static struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
2161 const char *name,
2162 unsigned long align,
2163 unsigned long size)
2164{
2165 int newidx = f->header.e_shnum++;
2166 struct obj_section *sec;
2167
2168 f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
2169 f->sections[newidx] = sec = arch_new_section();
2170
2171 sec->header.sh_type = SHT_PROGBITS;
2172 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2173 sec->header.sh_size = size;
2174 sec->header.sh_addralign = align;
2175 sec->name = name;
2176 sec->idx = newidx;
2177 if (size)
2178 sec->contents = xmalloc(size);
2179
2180 sec->load_next = f->load_order;
2181 f->load_order = sec;
2182 if (f->load_order_search_start == &f->load_order)
2183 f->load_order_search_start = &sec->load_next;
2184
2185 return sec;
2186}
2187
2188static void *obj_extend_section(struct obj_section *sec, unsigned long more)
2189{
2190 unsigned long oldsize = sec->header.sh_size;
2191 if (more) {
2192 sec->header.sh_size += more;
2193 sec->contents = xrealloc(sec->contents, sec->header.sh_size);
2194 }
2195 return sec->contents + oldsize;
2196}
2197
2198
2199/* Conditionally add the symbols from the given symbol set to the
2200 new module. */
2201
2202static int
2203add_symbols_from( struct obj_file *f,
2204 int idx, struct new_module_symbol *syms, size_t nsyms)
2205{
2206 struct new_module_symbol *s;
2207 size_t i;
2208 int used = 0;
2209#ifdef SYMBOL_PREFIX
2210 char *name_buf = 0;
2211 size_t name_alloced_size = 0;
2212#endif
2213#if ENABLE_FEATURE_CHECK_TAINTED_MODULE
2214 int gpl;
2215
2216 gpl = obj_gpl_license(f, NULL) == 0;
2217#endif
2218 for (i = 0, s = syms; i < nsyms; ++i, ++s) {
2219 /* Only add symbols that are already marked external.
2220 If we override locals we may cause problems for
2221 argument initialization. We will also create a false
2222 dependency on the module. */
2223 struct obj_symbol *sym;
2224 char *name;
2225
2226 /* GPL licensed modules can use symbols exported with
2227 * EXPORT_SYMBOL_GPL, so ignore any GPLONLY_ prefix on the
2228 * exported names. Non-GPL modules never see any GPLONLY_
2229 * symbols so they cannot fudge it by adding the prefix on
2230 * their references.
2231 */
2232 if (strncmp((char *)s->name, "GPLONLY_", 8) == 0) {
2233#if ENABLE_FEATURE_CHECK_TAINTED_MODULE
2234 if (gpl)
2235 s->name += 8;
2236 else
2237#endif
2238 continue;
2239 }
2240 name = (char *)s->name;
2241
2242#ifdef SYMBOL_PREFIX
2243 /* Prepend SYMBOL_PREFIX to the symbol's name (the
2244 kernel exports `C names', but module object files
2245 reference `linker names'). */
2246 size_t extra = sizeof SYMBOL_PREFIX;
2247 size_t name_size = strlen(name) + extra;
2248 if (name_size > name_alloced_size) {
2249 name_alloced_size = name_size * 2;
2250 name_buf = alloca(name_alloced_size);
2251 }
2252 strcpy(name_buf, SYMBOL_PREFIX);
2253 strcpy(name_buf + extra - 1, name);
2254 name = name_buf;
2255#endif /* SYMBOL_PREFIX */
2256
2257 sym = obj_find_symbol(f, name);
2258 if (sym && !(ELF_ST_BIND(sym->info) == STB_LOCAL)) {
2259#ifdef SYMBOL_PREFIX
2260 /* Put NAME_BUF into more permanent storage. */
2261 name = xmalloc(name_size);
2262 strcpy(name, name_buf);
2263#endif
2264 sym = obj_add_symbol(f, name, -1,
2265 ELF_ST_INFO(STB_GLOBAL,
2266 STT_NOTYPE),
2267 idx, s->value, 0);
2268 /* Did our symbol just get installed? If so, mark the
2269 module as "used". */
2270 if (sym->secidx == idx)
2271 used = 1;
2272 }
2273 }
2274
2275 return used;
2276}
2277
2278static void add_kernel_symbols(struct obj_file *f)
2279{
2280 struct external_module *m;
2281 int i, nused = 0;
2282
2283 /* Add module symbols first. */
2284
2285 for (i = 0, m = ext_modules; i < n_ext_modules; ++i, ++m) {
2286 if (m->nsyms
2287 && add_symbols_from(f, SHN_HIRESERVE + 2 + i, m->syms, m->nsyms)
2288 ) {
2289 m->used = 1;
2290 ++nused;
2291 }
2292 }
2293
2294 n_ext_modules_used = nused;
2295
2296 /* And finally the symbols from the kernel proper. */
2297
2298 if (nksyms)
2299 add_symbols_from(f, SHN_HIRESERVE + 1, ksyms, nksyms);
2300}
2301
2302static char *get_modinfo_value(struct obj_file *f, const char *key)
2303{
2304 struct obj_section *sec;
2305 char *p, *v, *n, *ep;
2306 size_t klen = strlen(key);
2307
2308 sec = obj_find_section(f, ".modinfo");
2309 if (sec == NULL)
2310 return NULL;
2311 p = sec->contents;
2312 ep = p + sec->header.sh_size;
2313 while (p < ep) {
2314 v = strchr(p, '=');
2315 n = strchr(p, '\0');
2316 if (v) {
2317 if (p + klen == v && strncmp(p, key, klen) == 0)
2318 return v + 1;
2319 } else {
2320 if (p + klen == n && strcmp(p, key) == 0)
2321 return n;
2322 }
2323 p = n + 1;
2324 }
2325
2326 return NULL;
2327}
2328
2329
2330/*======================================================================*/
2331/* Functions relating to module loading after 2.1.18. */
2332
2333/* From Linux-2.6 sources */
2334/* You can use " around spaces, but can't escape ". */
2335/* Hyphens and underscores equivalent in parameter names. */
2336static char *next_arg(char *args, char **param, char **val)
2337{
2338 unsigned int i, equals = 0;
2339 int in_quote = 0, quoted = 0;
2340 char *next;
2341
2342 if (*args == '"') {
2343 args++;
2344 in_quote = 1;
2345 quoted = 1;
2346 }
2347
2348 for (i = 0; args[i]; i++) {
2349 if (args[i] == ' ' && !in_quote)
2350 break;
2351 if (equals == 0) {
2352 if (args[i] == '=')
2353 equals = i;
2354 }
2355 if (args[i] == '"')
2356 in_quote = !in_quote;
2357 }
2358
2359 *param = args;
2360 if (!equals)
2361 *val = NULL;
2362 else {
2363 args[equals] = '\0';
2364 *val = args + equals + 1;
2365
2366 /* Don't include quotes in value. */
2367 if (**val == '"') {
2368 (*val)++;
2369 if (args[i-1] == '"')
2370 args[i-1] = '\0';
2371 }
2372 if (quoted && args[i-1] == '"')
2373 args[i-1] = '\0';
2374 }
2375
2376 if (args[i]) {
2377 args[i] = '\0';
2378 next = args + i + 1;
2379 } else
2380 next = args + i;
2381
2382 /* Chew up trailing spaces. */
2383 return skip_whitespace(next);
2384}
2385
2386static void
2387new_process_module_arguments(struct obj_file *f, const char *options)
2388{
2389 char *xoptions, *pos;
2390 char *param, *val;
2391
2392 xoptions = pos = xstrdup(skip_whitespace(options));
2393 while (*pos) {
2394 unsigned long charssize = 0;
2395 char *tmp, *contents, *loc, *pinfo, *p;
2396 struct obj_symbol *sym;
2397 int min, max, n, len;
2398
2399 pos = next_arg(pos, &param, &val);
2400
2401 tmp = xasprintf("parm_%s", param);
2402 pinfo = get_modinfo_value(f, tmp);
2403 free(tmp);
2404 if (pinfo == NULL)
2405 bb_error_msg_and_die("invalid parameter %s", param);
2406
2407#ifdef SYMBOL_PREFIX
2408 tmp = xasprintf(SYMBOL_PREFIX "%s", param);
2409 sym = obj_find_symbol(f, tmp);
2410 free(tmp);
2411#else
2412 sym = obj_find_symbol(f, param);
2413#endif
2414
2415 /* Also check that the parameter was not resolved from the kernel. */
2416 if (sym == NULL || sym->secidx > SHN_HIRESERVE)
2417 bb_error_msg_and_die("symbol for parameter %s not found", param);
2418
2419 /* Number of parameters */
2420 if (isdigit(*pinfo)) {
2421 min = strtoul(pinfo, &pinfo, 10);
2422 if (*pinfo == '-')
2423 max = strtoul(pinfo + 1, &pinfo, 10);
2424 else
2425 max = min;
2426 } else
2427 min = max = 1;
2428
2429 contents = f->sections[sym->secidx]->contents;
2430 loc = contents + sym->value;
2431
2432 if (*pinfo == 'c') {
2433 if (!isdigit(*(pinfo + 1))) {
2434 bb_error_msg_and_die("parameter type 'c' for %s must be followed by"
2435 " the maximum size", param);
2436 }
2437 charssize = strtoul(pinfo + 1, (char **) NULL, 10);
2438 }
2439
2440 if (val == NULL) {
2441 if (*pinfo != 'b')
2442 bb_error_msg_and_die("argument expected for parameter %s", param);
2443 val = (char *) "1";
2444 }
2445
2446 /* Parse parameter values */
2447 n = 0;
2448 p = val;
2449 while (*p != 0) {
2450 if (++n > max)
2451 bb_error_msg_and_die("too many values for %s (max %d)", param, max);
2452
2453 switch (*pinfo) {
2454 case 's':
2455 len = strcspn(p, ",");
2456 p[len] = 0;
2457 obj_string_patch(f, sym->secidx,
2458 loc - contents, p);
2459 loc += tgt_sizeof_char_p;
2460 p += len;
2461 break;
2462 case 'c':
2463 len = strcspn(p, ",");
2464 p[len] = 0;
2465 if (len >= charssize)
2466 bb_error_msg_and_die("string too long for %s (max %ld)", param,
2467 charssize - 1);
2468 strcpy((char *) loc, p);
2469 loc += charssize;
2470 p += len;
2471 break;
2472 case 'b':
2473 *loc++ = strtoul(p, &p, 0);
2474 break;
2475 case 'h':
2476 *(short *) loc = strtoul(p, &p, 0);
2477 loc += tgt_sizeof_short;
2478 break;
2479 case 'i':
2480 *(int *) loc = strtoul(p, &p, 0);
2481 loc += tgt_sizeof_int;
2482 break;
2483 case 'l':
2484 *(long *) loc = strtoul(p, &p, 0);
2485 loc += tgt_sizeof_long;
2486 break;
2487 default:
2488 bb_error_msg_and_die("unknown parameter type '%c' for %s",
2489 *pinfo, param);
2490 }
2491
2492 p = skip_whitespace(p);
2493 if (*p != ',')
2494 break;
2495 p = skip_whitespace(p + 1);
2496 }
2497
2498 if (n < min)
2499 bb_error_msg_and_die("parameter %s requires at least %d arguments", param, min);
2500 if (*p != '\0')
2501 bb_error_msg_and_die("invalid argument syntax for %s", param);
2502 }
2503
2504 free(xoptions);
2505}
2506
2507#if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
2508static int new_is_module_checksummed(struct obj_file *f)
2509{
2510 const char *p = get_modinfo_value(f, "using_checksums");
2511 if (p)
2512 return xatoi(p);
2513 return 0;
2514}
2515
2516/* Get the module's kernel version in the canonical integer form. */
2517
2518static int
2519new_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
2520{
2521 char *p, *q;
2522 int a, b, c;
2523
2524 p = get_modinfo_value(f, "kernel_version");
2525 if (p == NULL)
2526 return -1;
2527 safe_strncpy(str, p, STRVERSIONLEN);
2528
2529 a = strtoul(p, &p, 10);
2530 if (*p != '.')
2531 return -1;
2532 b = strtoul(p + 1, &p, 10);
2533 if (*p != '.')
2534 return -1;
2535 c = strtoul(p + 1, &q, 10);
2536 if (p + 1 == q)
2537 return -1;
2538
2539 return a << 16 | b << 8 | c;
2540}
2541
2542#endif /* FEATURE_INSMOD_VERSION_CHECKING */
2543
2544
2545/* Fetch the loaded modules, and all currently exported symbols. */
2546
2547static void new_get_kernel_symbols(void)
2548{
2549 char *module_names, *mn;
2550 struct external_module *modules, *m;
2551 struct new_module_symbol *syms, *s;
2552 size_t ret, bufsize, nmod, nsyms, i, j;
2553
2554 /* Collect the loaded modules. */
2555
2556 bufsize = 256;
2557 module_names = xmalloc(bufsize);
2558
2559 retry_modules_load:
2560 if (query_module(NULL, QM_MODULES, module_names, bufsize, &ret)) {
2561 if (errno == ENOSPC && bufsize < ret) {
2562 bufsize = ret;
2563 module_names = xrealloc(module_names, bufsize);
2564 goto retry_modules_load;
2565 }
2566 bb_perror_msg_and_die("QM_MODULES");
2567 }
2568
2569 n_ext_modules = nmod = ret;
2570
2571 /* Collect the modules' symbols. */
2572
2573 if (nmod) {
2574 ext_modules = modules = xmalloc(nmod * sizeof(*modules));
2575 memset(modules, 0, nmod * sizeof(*modules));
2576 for (i = 0, mn = module_names, m = modules;
2577 i < nmod; ++i, ++m, mn += strlen(mn) + 1) {
2578 struct new_module_info info;
2579
2580 if (query_module(mn, QM_INFO, &info, sizeof(info), &ret)) {
2581 if (errno == ENOENT) {
2582 /* The module was removed out from underneath us. */
2583 continue;
2584 }
2585 bb_perror_msg_and_die("query_module: QM_INFO: %s", mn);
2586 }
2587
2588 bufsize = 1024;
2589 syms = xmalloc(bufsize);
2590 retry_mod_sym_load:
2591 if (query_module(mn, QM_SYMBOLS, syms, bufsize, &ret)) {
2592 switch (errno) {
2593 case ENOSPC:
2594 bufsize = ret;
2595 syms = xrealloc(syms, bufsize);
2596 goto retry_mod_sym_load;
2597 case ENOENT:
2598 /* The module was removed out from underneath us. */
2599 continue;
2600 default:
2601 bb_perror_msg_and_die("query_module: QM_SYMBOLS: %s", mn);
2602 }
2603 }
2604 nsyms = ret;
2605
2606 m->name = mn;
2607 m->addr = info.addr;
2608 m->nsyms = nsyms;
2609 m->syms = syms;
2610
2611 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2612 s->name += (unsigned long) syms;
2613 }
2614 }
2615 }
2616
2617 /* Collect the kernel's symbols. */
2618
2619 syms = xmalloc(bufsize = 16 * 1024);
2620 retry_kern_sym_load:
2621 if (query_module(NULL, QM_SYMBOLS, syms, bufsize, &ret)) {
2622 if (errno == ENOSPC && bufsize < ret) {
2623 bufsize = ret;
2624 syms = xrealloc(syms, bufsize);
2625 goto retry_kern_sym_load;
2626 }
2627 bb_perror_msg_and_die("kernel: QM_SYMBOLS");
2628 }
2629 nksyms = nsyms = ret;
2630 ksyms = syms;
2631
2632 for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2633 s->name += (unsigned long) syms;
2634 }
2635}
2636
2637
2638/* Return the kernel symbol checksum version, or zero if not used. */
2639
2640static int new_is_kernel_checksummed(void)
2641{
2642 struct new_module_symbol *s;
2643 size_t i;
2644
2645 /* Using_Versions is not the first symbol, but it should be in there. */
2646
2647 for (i = 0, s = ksyms; i < nksyms; ++i, ++s)
2648 if (strcmp((char *) s->name, "Using_Versions") == 0)
2649 return s->value;
2650
2651 return 0;
2652}
2653
2654
2655static void new_create_this_module(struct obj_file *f, const char *m_name)
2656{
2657 struct obj_section *sec;
2658
2659 sec = obj_create_alloced_section_first(f, ".this", tgt_sizeof_long,
2660 sizeof(struct new_module));
2661 memset(sec->contents, 0, sizeof(struct new_module));
2662
2663 obj_add_symbol(f, SPFX "__this_module", -1,
2664 ELF_ST_INFO(STB_LOCAL, STT_OBJECT), sec->idx, 0,
2665 sizeof(struct new_module));
2666
2667 obj_string_patch(f, sec->idx, offsetof(struct new_module, name),
2668 m_name);
2669}
2670
2671#if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
2672/* add an entry to the __ksymtab section, creating it if necessary */
2673static void new_add_ksymtab(struct obj_file *f, struct obj_symbol *sym)
2674{
2675 struct obj_section *sec;
2676 ElfW(Addr) ofs;
2677
2678 /* ensure __ksymtab is allocated, EXPORT_NOSYMBOLS creates a non-alloc section.
2679 * If __ksymtab is defined but not marked alloc, x out the first character
2680 * (no obj_delete routine) and create a new __ksymtab with the correct
2681 * characteristics.
2682 */
2683 sec = obj_find_section(f, "__ksymtab");
2684 if (sec && !(sec->header.sh_flags & SHF_ALLOC)) {
2685 *((char *)(sec->name)) = 'x'; /* override const */
2686 sec = NULL;
2687 }
2688 if (!sec)
2689 sec = obj_create_alloced_section(f, "__ksymtab",
2690 tgt_sizeof_void_p, 0);
2691 if (!sec)
2692 return;
2693 sec->header.sh_flags |= SHF_ALLOC;
2694 /* Empty section might be byte-aligned */
2695 sec->header.sh_addralign = tgt_sizeof_void_p;
2696 ofs = sec->header.sh_size;
2697 obj_symbol_patch(f, sec->idx, ofs, sym);
2698 obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p, sym->name);
2699 obj_extend_section(sec, 2 * tgt_sizeof_char_p);
2700}
2701#endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
2702
2703static int new_create_module_ksymtab(struct obj_file *f)
2704{
2705 struct obj_section *sec;
2706 int i;
2707
2708 /* We must always add the module references. */
2709
2710 if (n_ext_modules_used) {
2711 struct new_module_ref *dep;
2712 struct obj_symbol *tm;
2713
2714 sec = obj_create_alloced_section(f, ".kmodtab", tgt_sizeof_void_p,
2715 (sizeof(struct new_module_ref)
2716 * n_ext_modules_used));
2717 if (!sec)
2718 return 0;
2719
2720 tm = obj_find_symbol(f, SPFX "__this_module");
2721 dep = (struct new_module_ref *) sec->contents;
2722 for (i = 0; i < n_ext_modules; ++i)
2723 if (ext_modules[i].used) {
2724 dep->dep = ext_modules[i].addr;
2725 obj_symbol_patch(f, sec->idx,
2726 (char *) &dep->ref - sec->contents, tm);
2727 dep->next_ref = 0;
2728 ++dep;
2729 }
2730 }
2731
2732 if (!flag_noexport && !obj_find_section(f, "__ksymtab")) {
2733 size_t nsyms;
2734 int *loaded;
2735
2736 sec = obj_create_alloced_section(f, "__ksymtab", tgt_sizeof_void_p, 0);
2737
2738 /* We don't want to export symbols residing in sections that
2739 aren't loaded. There are a number of these created so that
2740 we make sure certain module options don't appear twice. */
2741
2742 loaded = alloca(sizeof(int) * (i = f->header.e_shnum));
2743 while (--i >= 0)
2744 loaded[i] = (f->sections[i]->header.sh_flags & SHF_ALLOC) != 0;
2745
2746 for (nsyms = i = 0; i < HASH_BUCKETS; ++i) {
2747 struct obj_symbol *sym;
2748 for (sym = f->symtab[i]; sym; sym = sym->next)
2749 if (ELF_ST_BIND(sym->info) != STB_LOCAL
2750 && sym->secidx <= SHN_HIRESERVE
2751 && (sym->secidx >= SHN_LORESERVE
2752 || loaded[sym->secidx])) {
2753 ElfW(Addr) ofs = nsyms * 2 * tgt_sizeof_void_p;
2754
2755 obj_symbol_patch(f, sec->idx, ofs, sym);
2756 obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p,
2757 sym->name);
2758
2759 nsyms++;
2760 }
2761 }
2762
2763 obj_extend_section(sec, nsyms * 2 * tgt_sizeof_char_p);
2764 }
2765
2766 return 1;
2767}
2768
2769
2770static int
2771new_init_module(const char *m_name, struct obj_file *f, unsigned long m_size)
2772{
2773 struct new_module *module;
2774 struct obj_section *sec;
2775 void *image;
2776 int ret;
2777 tgt_long m_addr;
2778
2779 sec = obj_find_section(f, ".this");
2780 if (!sec || !sec->contents) {
2781 bb_perror_msg_and_die("corrupt module %s?", m_name);
2782 }
2783 module = (struct new_module *) sec->contents;
2784 m_addr = sec->header.sh_addr;
2785
2786 module->size_of_struct = sizeof(*module);
2787 module->size = m_size;
2788 module->flags = flag_autoclean ? NEW_MOD_AUTOCLEAN : 0;
2789
2790 sec = obj_find_section(f, "__ksymtab");
2791 if (sec && sec->header.sh_size) {
2792 module->syms = sec->header.sh_addr;
2793 module->nsyms = sec->header.sh_size / (2 * tgt_sizeof_char_p);
2794 }
2795
2796 if (n_ext_modules_used) {
2797 sec = obj_find_section(f, ".kmodtab");
2798 module->deps = sec->header.sh_addr;
2799 module->ndeps = n_ext_modules_used;
2800 }
2801
2802 module->init =
2803 obj_symbol_final_value(f, obj_find_symbol(f, SPFX "init_module"));
2804 module->cleanup =
2805 obj_symbol_final_value(f, obj_find_symbol(f, SPFX "cleanup_module"));
2806
2807 sec = obj_find_section(f, "__ex_table");
2808 if (sec) {
2809 module->ex_table_start = sec->header.sh_addr;
2810 module->ex_table_end = sec->header.sh_addr + sec->header.sh_size;
2811 }
2812
2813 sec = obj_find_section(f, ".text.init");
2814 if (sec) {
2815 module->runsize = sec->header.sh_addr - m_addr;
2816 }
2817 sec = obj_find_section(f, ".data.init");
2818 if (sec) {
2819 if (!module->runsize ||
2820 module->runsize > sec->header.sh_addr - m_addr)
2821 module->runsize = sec->header.sh_addr - m_addr;
2822 }
2823 sec = obj_find_section(f, ARCHDATA_SEC_NAME);
2824 if (sec && sec->header.sh_size) {
2825 module->archdata_start = (void*)sec->header.sh_addr;
2826 module->archdata_end = module->archdata_start + sec->header.sh_size;
2827 }
2828 sec = obj_find_section(f, KALLSYMS_SEC_NAME);
2829 if (sec && sec->header.sh_size) {
2830 module->kallsyms_start = (void*)sec->header.sh_addr;
2831 module->kallsyms_end = module->kallsyms_start + sec->header.sh_size;
2832 }
2833
2834 /* Whew! All of the initialization is complete. Collect the final
2835 module image and give it to the kernel. */
2836
2837 image = xmalloc(m_size);
2838 obj_create_image(f, image);
2839
2840 ret = init_module(m_name, (struct new_module *) image);
2841 if (ret)
2842 bb_perror_msg("init_module: %s", m_name);
2843
2844 free(image);
2845
2846 return ret == 0;
2847}
2848
2849
2850/*======================================================================*/
2851
2852static void
2853obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2854 const char *string)
2855{
2856 struct obj_string_patch *p;
2857 struct obj_section *strsec;
2858 size_t len = strlen(string) + 1;
2859 char *loc;
2860
2861 p = xmalloc(sizeof(*p));
2862 p->next = f->string_patches;
2863 p->reloc_secidx = secidx;
2864 p->reloc_offset = offset;
2865 f->string_patches = p;
2866
2867 strsec = obj_find_section(f, ".kstrtab");
2868 if (strsec == NULL) {
2869 strsec = obj_create_alloced_section(f, ".kstrtab", 1, len);
2870 p->string_offset = 0;
2871 loc = strsec->contents;
2872 } else {
2873 p->string_offset = strsec->header.sh_size;
2874 loc = obj_extend_section(strsec, len);
2875 }
2876 memcpy(loc, string, len);
2877}
2878
2879static void
2880obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2881 struct obj_symbol *sym)
2882{
2883 struct obj_symbol_patch *p;
2884
2885 p = xmalloc(sizeof(*p));
2886 p->next = f->symbol_patches;
2887 p->reloc_secidx = secidx;
2888 p->reloc_offset = offset;
2889 p->sym = sym;
2890 f->symbol_patches = p;
2891}
2892
2893static void obj_check_undefineds(struct obj_file *f)
2894{
2895 unsigned i;
2896
2897 for (i = 0; i < HASH_BUCKETS; ++i) {
2898 struct obj_symbol *sym;
2899 for (sym = f->symtab[i]; sym; sym = sym->next)
2900 if (sym->secidx == SHN_UNDEF) {
2901 if (ELF_ST_BIND(sym->info) == STB_WEAK) {
2902 sym->secidx = SHN_ABS;
2903 sym->value = 0;
2904 } else {
2905 if (!flag_quiet)
2906 bb_error_msg_and_die("unresolved symbol %s", sym->name);
2907 }
2908 }
2909 }
2910}
2911
2912static void obj_allocate_commons(struct obj_file *f)
2913{
2914 struct common_entry {
2915 struct common_entry *next;
2916 struct obj_symbol *sym;
2917 } *common_head = NULL;
2918
2919 unsigned long i;
2920
2921 for (i = 0; i < HASH_BUCKETS; ++i) {
2922 struct obj_symbol *sym;
2923 for (sym = f->symtab[i]; sym; sym = sym->next)
2924 if (sym->secidx == SHN_COMMON) {
2925 /* Collect all COMMON symbols and sort them by size so as to
2926 minimize space wasted by alignment requirements. */
2927 {
2928 struct common_entry **p, *n;
2929 for (p = &common_head; *p; p = &(*p)->next)
2930 if (sym->size <= (*p)->sym->size)
2931 break;
2932
2933 n = alloca(sizeof(*n));
2934 n->next = *p;
2935 n->sym = sym;
2936 *p = n;
2937 }
2938 }
2939 }
2940
2941 for (i = 1; i < f->local_symtab_size; ++i) {
2942 struct obj_symbol *sym = f->local_symtab[i];
2943 if (sym && sym->secidx == SHN_COMMON) {
2944 struct common_entry **p, *n;
2945 for (p = &common_head; *p; p = &(*p)->next)
2946 if (sym == (*p)->sym)
2947 break;
2948 else if (sym->size < (*p)->sym->size) {
2949 n = alloca(sizeof(*n));
2950 n->next = *p;
2951 n->sym = sym;
2952 *p = n;
2953 break;
2954 }
2955 }
2956 }
2957
2958 if (common_head) {
2959 /* Find the bss section. */
2960 for (i = 0; i < f->header.e_shnum; ++i)
2961 if (f->sections[i]->header.sh_type == SHT_NOBITS)
2962 break;
2963
2964 /* If for some reason there hadn't been one, create one. */
2965 if (i == f->header.e_shnum) {
2966 struct obj_section *sec;
2967
2968 f->sections = xrealloc_vector(f->sections, 2, i);
2969 f->sections[i] = sec = arch_new_section();
2970 f->header.e_shnum = i + 1;
2971
2972 sec->header.sh_type = SHT_PROGBITS;
2973 sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2974 sec->name = ".bss";
2975 sec->idx = i;
2976 }
2977
2978 /* Allocate the COMMONS. */
2979 {
2980 ElfW(Addr) bss_size = f->sections[i]->header.sh_size;
2981 ElfW(Addr) max_align = f->sections[i]->header.sh_addralign;
2982 struct common_entry *c;
2983
2984 for (c = common_head; c; c = c->next) {
2985 ElfW(Addr) align = c->sym->value;
2986
2987 if (align > max_align)
2988 max_align = align;
2989 if (bss_size & (align - 1))
2990 bss_size = (bss_size | (align - 1)) + 1;
2991
2992 c->sym->secidx = i;
2993 c->sym->value = bss_size;
2994
2995 bss_size += c->sym->size;
2996 }
2997
2998 f->sections[i]->header.sh_size = bss_size;
2999 f->sections[i]->header.sh_addralign = max_align;
3000 }
3001 }
3002
3003 /* For the sake of patch relocation and parameter initialization,
3004 allocate zeroed data for NOBITS sections now. Note that after
3005 this we cannot assume NOBITS are really empty. */
3006 for (i = 0; i < f->header.e_shnum; ++i) {
3007 struct obj_section *s = f->sections[i];
3008 if (s->header.sh_type == SHT_NOBITS) {
3009 if (s->header.sh_size != 0)
3010 s->contents = memset(xmalloc(s->header.sh_size),
3011 0, s->header.sh_size);
3012 else
3013 s->contents = NULL;
3014
3015 s->header.sh_type = SHT_PROGBITS;
3016 }
3017 }
3018}
3019
3020static unsigned long obj_load_size(struct obj_file *f)
3021{
3022 unsigned long dot = 0;
3023 struct obj_section *sec;
3024
3025 /* Finalize the positions of the sections relative to one another. */
3026
3027 for (sec = f->load_order; sec; sec = sec->load_next) {
3028 ElfW(Addr) align;
3029
3030 align = sec->header.sh_addralign;
3031 if (align && (dot & (align - 1)))
3032 dot = (dot | (align - 1)) + 1;
3033
3034 sec->header.sh_addr = dot;
3035 dot += sec->header.sh_size;
3036 }
3037
3038 return dot;
3039}
3040
3041static int obj_relocate(struct obj_file *f, ElfW(Addr) base)
3042{
3043 int i, n = f->header.e_shnum;
3044 int ret = 1;
3045
3046 /* Finalize the addresses of the sections. */
3047
3048 f->baseaddr = base;
3049 for (i = 0; i < n; ++i)
3050 f->sections[i]->header.sh_addr += base;
3051
3052 /* And iterate over all of the relocations. */
3053
3054 for (i = 0; i < n; ++i) {
3055 struct obj_section *relsec, *symsec, *targsec, *strsec;
3056 ElfW(RelM) * rel, *relend;
3057 ElfW(Sym) * symtab;
3058 const char *strtab;
3059
3060 relsec = f->sections[i];
3061 if (relsec->header.sh_type != SHT_RELM)
3062 continue;
3063
3064 symsec = f->sections[relsec->header.sh_link];
3065 targsec = f->sections[relsec->header.sh_info];
3066 strsec = f->sections[symsec->header.sh_link];
3067
3068 rel = (ElfW(RelM) *) relsec->contents;
3069 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
3070 symtab = (ElfW(Sym) *) symsec->contents;
3071 strtab = (const char *) strsec->contents;
3072
3073 for (; rel < relend; ++rel) {
3074 ElfW(Addr) value = 0;
3075 struct obj_symbol *intsym = NULL;
3076 unsigned long symndx;
3077 ElfW(Sym) * extsym = 0;
3078 const char *errmsg;
3079
3080 /* Attempt to find a value to use for this relocation. */
3081
3082 symndx = ELF_R_SYM(rel->r_info);
3083 if (symndx) {
3084 /* Note we've already checked for undefined symbols. */
3085
3086 extsym = &symtab[symndx];
3087 if (ELF_ST_BIND(extsym->st_info) == STB_LOCAL) {
3088 /* Local symbols we look up in the local table to be sure
3089 we get the one that is really intended. */
3090 intsym = f->local_symtab[symndx];
3091 } else {
3092 /* Others we look up in the hash table. */
3093 const char *name;
3094 if (extsym->st_name)
3095 name = strtab + extsym->st_name;
3096 else
3097 name = f->sections[extsym->st_shndx]->name;
3098 intsym = obj_find_symbol(f, name);
3099 }
3100
3101 value = obj_symbol_final_value(f, intsym);
3102 intsym->referenced = 1;
3103 }
3104#if SHT_RELM == SHT_RELA
3105#if defined(__alpha__) && defined(AXP_BROKEN_GAS)
3106 /* Work around a nasty GAS bug, that is fixed as of 2.7.0.9. */
3107 if (!extsym || !extsym->st_name ||
3108 ELF_ST_BIND(extsym->st_info) != STB_LOCAL)
3109#endif
3110 value += rel->r_addend;
3111#endif
3112
3113 /* Do it! */
3114 switch (arch_apply_relocation
3115 (f, targsec, /*symsec,*/ intsym, rel, value)
3116 ) {
3117 case obj_reloc_ok:
3118 break;
3119
3120 case obj_reloc_overflow:
3121 errmsg = "Relocation overflow";
3122 goto bad_reloc;
3123 case obj_reloc_dangerous:
3124 errmsg = "Dangerous relocation";
3125 goto bad_reloc;
3126 case obj_reloc_unhandled:
3127 errmsg = "Unhandled relocation";
3128bad_reloc:
3129 if (extsym) {
3130 bb_error_msg("%s of type %ld for %s", errmsg,
3131 (long) ELF_R_TYPE(rel->r_info),
3132 strtab + extsym->st_name);
3133 } else {
3134 bb_error_msg("%s of type %ld", errmsg,
3135 (long) ELF_R_TYPE(rel->r_info));
3136 }
3137 ret = 0;
3138 break;
3139 }
3140 }
3141 }
3142
3143 /* Finally, take care of the patches. */
3144
3145 if (f->string_patches) {
3146 struct obj_string_patch *p;
3147 struct obj_section *strsec;
3148 ElfW(Addr) strsec_base;
3149 strsec = obj_find_section(f, ".kstrtab");
3150 strsec_base = strsec->header.sh_addr;
3151
3152 for (p = f->string_patches; p; p = p->next) {
3153 struct obj_section *targsec = f->sections[p->reloc_secidx];
3154 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
3155 = strsec_base + p->string_offset;
3156 }
3157 }
3158
3159 if (f->symbol_patches) {
3160 struct obj_symbol_patch *p;
3161
3162 for (p = f->symbol_patches; p; p = p->next) {
3163 struct obj_section *targsec = f->sections[p->reloc_secidx];
3164 *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
3165 = obj_symbol_final_value(f, p->sym);
3166 }
3167 }
3168
3169 return ret;
3170}
3171
3172static int obj_create_image(struct obj_file *f, char *image)
3173{
3174 struct obj_section *sec;
3175 ElfW(Addr) base = f->baseaddr;
3176
3177 for (sec = f->load_order; sec; sec = sec->load_next) {
3178 char *secimg;
3179
3180 if (sec->contents == 0 || sec->header.sh_size == 0)
3181 continue;
3182
3183 secimg = image + (sec->header.sh_addr - base);
3184
3185 /* Note that we allocated data for NOBITS sections earlier. */
3186 memcpy(secimg, sec->contents, sec->header.sh_size);
3187 }
3188
3189 return 1;
3190}
3191
3192/*======================================================================*/
3193
3194static struct obj_file *obj_load(FILE *fp, int loadprogbits UNUSED_PARAM)
3195{
3196 struct obj_file *f;
3197 ElfW(Shdr) * section_headers;
3198 size_t shnum, i;
3199 char *shstrtab;
3200
3201 /* Read the file header. */
3202
3203 f = arch_new_file();
3204 f->symbol_cmp = strcmp;
3205 f->symbol_hash = obj_elf_hash;
3206 f->load_order_search_start = &f->load_order;
3207
3208 fseek(fp, 0, SEEK_SET);
3209 if (fread(&f->header, sizeof(f->header), 1, fp) != 1) {
3210 bb_perror_msg_and_die("error reading ELF header");
3211 }
3212
3213 if (f->header.e_ident[EI_MAG0] != ELFMAG0
3214 || f->header.e_ident[EI_MAG1] != ELFMAG1
3215 || f->header.e_ident[EI_MAG2] != ELFMAG2
3216 || f->header.e_ident[EI_MAG3] != ELFMAG3) {
3217 bb_error_msg_and_die("not an ELF file");
3218 }
3219 if (f->header.e_ident[EI_CLASS] != ELFCLASSM
3220 || f->header.e_ident[EI_DATA] != (BB_BIG_ENDIAN
3221 ? ELFDATA2MSB : ELFDATA2LSB)
3222 || f->header.e_ident[EI_VERSION] != EV_CURRENT
3223 || !MATCH_MACHINE(f->header.e_machine)) {
3224 bb_error_msg_and_die("ELF file not for this architecture");
3225 }
3226 if (f->header.e_type != ET_REL) {
3227 bb_error_msg_and_die("ELF file not a relocatable object");
3228 }
3229
3230 /* Read the section headers. */
3231
3232 if (f->header.e_shentsize != sizeof(ElfW(Shdr))) {
3233 bb_error_msg_and_die("section header size mismatch: %lu != %lu",
3234 (unsigned long) f->header.e_shentsize,
3235 (unsigned long) sizeof(ElfW(Shdr)));
3236 }
3237
3238 shnum = f->header.e_shnum;
3239 f->sections = xmalloc(sizeof(struct obj_section *) * shnum);
3240 memset(f->sections, 0, sizeof(struct obj_section *) * shnum);
3241
3242 section_headers = alloca(sizeof(ElfW(Shdr)) * shnum);
3243 fseek(fp, f->header.e_shoff, SEEK_SET);
3244 if (fread(section_headers, sizeof(ElfW(Shdr)), shnum, fp) != shnum) {
3245 bb_perror_msg_and_die("error reading ELF section headers");
3246 }
3247
3248 /* Read the section data. */
3249
3250 for (i = 0; i < shnum; ++i) {
3251 struct obj_section *sec;
3252
3253 f->sections[i] = sec = arch_new_section();
3254
3255 sec->header = section_headers[i];
3256 sec->idx = i;
3257
3258 if (sec->header.sh_size) {
3259 switch (sec->header.sh_type) {
3260 case SHT_NULL:
3261 case SHT_NOTE:
3262 case SHT_NOBITS:
3263 /* ignore */
3264 break;
3265
3266 case SHT_PROGBITS:
3267#if LOADBITS
3268 if (!loadprogbits) {
3269 sec->contents = NULL;
3270 break;
3271 }
3272#endif
3273 case SHT_SYMTAB:
3274 case SHT_STRTAB:
3275 case SHT_RELM:
3276 if (sec->header.sh_size > 0) {
3277 sec->contents = xmalloc(sec->header.sh_size);
3278 fseek(fp, sec->header.sh_offset, SEEK_SET);
3279 if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
3280 bb_perror_msg_and_die("error reading ELF section data");
3281 }
3282 } else {
3283 sec->contents = NULL;
3284 }
3285 break;
3286
3287#if SHT_RELM == SHT_REL
3288 case SHT_RELA:
3289 bb_error_msg_and_die("RELA relocations not supported on this architecture");
3290#else
3291 case SHT_REL:
3292 bb_error_msg_and_die("REL relocations not supported on this architecture");
3293#endif
3294 default:
3295 if (sec->header.sh_type >= SHT_LOPROC) {
3296 /* Assume processor specific section types are debug
3297 info and can safely be ignored. If this is ever not
3298 the case (Hello MIPS?), don't put ifdefs here but
3299 create an arch_load_proc_section(). */
3300 break;
3301 }
3302
3303 bb_error_msg_and_die("can't handle sections of type %ld",
3304 (long) sec->header.sh_type);
3305 }
3306 }
3307 }
3308
3309 /* Do what sort of interpretation as needed by each section. */
3310
3311 shstrtab = f->sections[f->header.e_shstrndx]->contents;
3312
3313 for (i = 0; i < shnum; ++i) {
3314 struct obj_section *sec = f->sections[i];
3315 sec->name = shstrtab + sec->header.sh_name;
3316 }
3317
3318 for (i = 0; i < shnum; ++i) {
3319 struct obj_section *sec = f->sections[i];
3320
3321 /* .modinfo should be contents only but gcc has no attribute for that.
3322 * The kernel may have marked .modinfo as ALLOC, ignore this bit.
3323 */
3324 if (strcmp(sec->name, ".modinfo") == 0)
3325 sec->header.sh_flags &= ~SHF_ALLOC;
3326
3327 if (sec->header.sh_flags & SHF_ALLOC)
3328 obj_insert_section_load_order(f, sec);
3329
3330 switch (sec->header.sh_type) {
3331 case SHT_SYMTAB:
3332 {
3333 unsigned long nsym, j;
3334 char *strtab;
3335 ElfW(Sym) * sym;
3336
3337 if (sec->header.sh_entsize != sizeof(ElfW(Sym))) {
3338 bb_error_msg_and_die("symbol size mismatch: %lu != %lu",
3339 (unsigned long) sec->header.sh_entsize,
3340 (unsigned long) sizeof(ElfW(Sym)));
3341 }
3342
3343 nsym = sec->header.sh_size / sizeof(ElfW(Sym));
3344 strtab = f->sections[sec->header.sh_link]->contents;
3345 sym = (ElfW(Sym) *) sec->contents;
3346
3347 /* Allocate space for a table of local symbols. */
3348 j = f->local_symtab_size = sec->header.sh_info;
3349 f->local_symtab = xzalloc(j * sizeof(struct obj_symbol *));
3350
3351 /* Insert all symbols into the hash table. */
3352 for (j = 1, ++sym; j < nsym; ++j, ++sym) {
3353 ElfW(Addr) val = sym->st_value;
3354 const char *name;
3355 if (sym->st_name)
3356 name = strtab + sym->st_name;
3357 else if (sym->st_shndx < shnum)
3358 name = f->sections[sym->st_shndx]->name;
3359 else
3360 continue;
3361#if defined(__SH5__)
3362 /*
3363 * For sh64 it is possible that the target of a branch
3364 * requires a mode switch (32 to 16 and back again).
3365 *
3366 * This is implied by the lsb being set in the target
3367 * address for SHmedia mode and clear for SHcompact.
3368 */
3369 val |= sym->st_other & 4;
3370#endif
3371 obj_add_symbol(f, name, j, sym->st_info, sym->st_shndx,
3372 val, sym->st_size);
3373 }
3374 }
3375 break;
3376
3377 case SHT_RELM:
3378 if (sec->header.sh_entsize != sizeof(ElfW(RelM))) {
3379 bb_error_msg_and_die("relocation entry size mismatch: %lu != %lu",
3380 (unsigned long) sec->header.sh_entsize,
3381 (unsigned long) sizeof(ElfW(RelM)));
3382 }
3383 break;
3384 /* XXX Relocation code from modutils-2.3.19 is not here.
3385 * Why? That's about 20 lines of code from obj/obj_load.c,
3386 * which gets done in a second pass through the sections.
3387 * This BusyBox insmod does similar work in obj_relocate(). */
3388 }
3389 }
3390
3391 return f;
3392}
3393
3394#if ENABLE_FEATURE_INSMOD_LOADINKMEM
3395/*
3396 * load the unloaded sections directly into the memory allocated by
3397 * kernel for the module
3398 */
3399
3400static int obj_load_progbits(FILE *fp, struct obj_file *f, char *imagebase)
3401{
3402 ElfW(Addr) base = f->baseaddr;
3403 struct obj_section* sec;
3404
3405 for (sec = f->load_order; sec; sec = sec->load_next) {
3406
3407 /* section already loaded? */
3408 if (sec->contents != NULL)
3409 continue;
3410
3411 if (sec->header.sh_size == 0)
3412 continue;
3413
3414 sec->contents = imagebase + (sec->header.sh_addr - base);
3415 fseek(fp, sec->header.sh_offset, SEEK_SET);
3416 if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
3417 bb_perror_msg("error reading ELF section data");
3418 return 0;
3419 }
3420
3421 }
3422 return 1;
3423}
3424#endif
3425
3426static void hide_special_symbols(struct obj_file *f)
3427{
3428 static const char *const specials[] = {
3429 SPFX "cleanup_module",
3430 SPFX "init_module",
3431 SPFX "kernel_version",
3432 NULL
3433 };
3434
3435 struct obj_symbol *sym;
3436 const char *const *p;
3437
3438 for (p = specials; *p; ++p) {
3439 sym = obj_find_symbol(f, *p);
3440 if (sym != NULL)
3441 sym->info = ELF_ST_INFO(STB_LOCAL, ELF_ST_TYPE(sym->info));
3442 }
3443}
3444
3445
3446#if ENABLE_FEATURE_CHECK_TAINTED_MODULE
3447static int obj_gpl_license(struct obj_file *f, const char **license)
3448{
3449 struct obj_section *sec;
3450 /* This list must match *exactly* the list of allowable licenses in
3451 * linux/include/linux/module.h. Checking for leading "GPL" will not
3452 * work, somebody will use "GPL sucks, this is proprietary".
3453 */
3454 static const char *const gpl_licenses[] = {
3455 "GPL",
3456 "GPL v2",
3457 "GPL and additional rights",
3458 "Dual BSD/GPL",
3459 "Dual MPL/GPL"
3460 };
3461
3462 sec = obj_find_section(f, ".modinfo");
3463 if (sec) {
3464 const char *value, *ptr, *endptr;
3465 ptr = sec->contents;
3466 endptr = ptr + sec->header.sh_size;
3467 while (ptr < endptr) {
3468 value = strchr(ptr, '=');
3469 if (value && strncmp(ptr, "license", value-ptr) == 0) {
3470 unsigned i;
3471 if (license)
3472 *license = value+1;
3473 for (i = 0; i < ARRAY_SIZE(gpl_licenses); ++i) {
3474 if (strcmp(value+1, gpl_licenses[i]) == 0)
3475 return 0;
3476 }
3477 return 2;
3478 }
3479 ptr = strchr(ptr, '\0');
3480 if (ptr)
3481 ptr++;
3482 else
3483 ptr = endptr;
3484 }
3485 }
3486 return 1;
3487}
3488
3489#define TAINT_FILENAME "/proc/sys/kernel/tainted"
3490#define TAINT_PROPRIETORY_MODULE (1 << 0)
3491#define TAINT_FORCED_MODULE (1 << 1)
3492#define TAINT_UNSAFE_SMP (1 << 2)
3493#define TAINT_URL "http://www.tux.org/lkml/#export-tainted"
3494
3495static void set_tainted(int fd, const char *m_name,
3496 int kernel_has_tainted, int taint, const char *text1, const char *text2)
3497{
3498 static smallint printed_info;
3499
3500 char buf[80];
3501 int oldval;
3502
3503 if (fd < 0 && !kernel_has_tainted)
3504 return; /* New modutils on old kernel */
3505 printf("Warning: loading %s will taint the kernel: %s%s\n",
3506 m_name, text1, text2);
3507 if (!printed_info) {
3508 printf(" See %s for information about tainted modules\n", TAINT_URL);
3509 printed_info = 1;
3510 }
3511 if (fd >= 0) {
3512 read(fd, buf, sizeof(buf)-1);
3513 buf[sizeof(buf)-1] = '\0';
3514 oldval = strtoul(buf, NULL, 10);
3515 sprintf(buf, "%d\n", oldval | taint);
3516 write(fd, buf, strlen(buf));
3517 }
3518}
3519
3520/* Check if loading this module will taint the kernel. */
3521static void check_tainted_module(struct obj_file *f, const char *m_name)
3522{
3523 static const char tainted_file[] ALIGN1 = TAINT_FILENAME;
3524
3525 int fd, kernel_has_tainted;
3526 const char *ptr;
3527
3528 kernel_has_tainted = 1;
3529 fd = open(tainted_file, O_RDWR);
3530 if (fd < 0) {
3531 if (errno == ENOENT)
3532 kernel_has_tainted = 0;
3533 else if (errno == EACCES)
3534 kernel_has_tainted = 1;
3535 else {
3536 perror(tainted_file);
3537 kernel_has_tainted = 0;
3538 }
3539 }
3540
3541 switch (obj_gpl_license(f, &ptr)) {
3542 case 0:
3543 break;
3544 case 1:
3545 set_tainted(fd, m_name, kernel_has_tainted, TAINT_PROPRIETORY_MODULE, "no license", "");
3546 break;
3547 case 2:
3548 /* The module has a non-GPL license so we pretend that the
3549 * kernel always has a taint flag to get a warning even on
3550 * kernels without the proc flag.
3551 */
3552 set_tainted(fd, m_name, 1, TAINT_PROPRIETORY_MODULE, "non-GPL license - ", ptr);
3553 break;
3554 default:
3555 set_tainted(fd, m_name, 1, TAINT_PROPRIETORY_MODULE, "Unexpected return from obj_gpl_license", "");
3556 break;
3557 }
3558
3559 if (flag_force_load)
3560 set_tainted(fd, m_name, 1, TAINT_FORCED_MODULE, "forced load", "");
3561
3562 if (fd >= 0)
3563 close(fd);
3564}
3565#else /* FEATURE_CHECK_TAINTED_MODULE */
3566#define check_tainted_module(x, y) do { } while (0);
3567#endif /* FEATURE_CHECK_TAINTED_MODULE */
3568
3569#if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
3570/* add module source, timestamp, kernel version and a symbol for the
3571 * start of some sections. this info is used by ksymoops to do better
3572 * debugging.
3573 */
3574#if !ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3575#define get_module_version(f, str) get_module_version(str)
3576#endif
3577static int
3578get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
3579{
3580#if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3581 return new_get_module_version(f, str);
3582#else /* FEATURE_INSMOD_VERSION_CHECKING */
3583 strncpy(str, "???", sizeof(str));
3584 return -1;
3585#endif /* FEATURE_INSMOD_VERSION_CHECKING */
3586}
3587
3588/* add module source, timestamp, kernel version and a symbol for the
3589 * start of some sections. this info is used by ksymoops to do better
3590 * debugging.
3591 */
3592static void
3593add_ksymoops_symbols(struct obj_file *f, const char *filename,
3594 const char *m_name)
3595{
3596 static const char symprefix[] ALIGN1 = "__insmod_";
3597 static const char section_names[][8] = {
3598 ".text",
3599 ".rodata",
3600 ".data",
3601 ".bss",
3602 ".sbss"
3603 };
3604
3605 struct obj_section *sec;
3606 struct obj_symbol *sym;
3607 char *name, *absolute_filename;
3608 char str[STRVERSIONLEN];
3609 unsigned i;
3610 int l, lm_name, lfilename, use_ksymtab, version;
3611 struct stat statbuf;
3612
3613 /* WARNING: was using realpath, but replaced by readlink to stop using
3614 * lots of stack. But here it seems to be able to cause problems? */
3615 absolute_filename = xmalloc_readlink(filename);
3616 if (!absolute_filename)
3617 absolute_filename = xstrdup(filename);
3618
3619 lm_name = strlen(m_name);
3620 lfilename = strlen(absolute_filename);
3621
3622 /* add to ksymtab if it already exists or there is no ksymtab and other symbols
3623 * are not to be exported. otherwise leave ksymtab alone for now, the
3624 * "export all symbols" compatibility code will export these symbols later.
3625 */
3626 use_ksymtab = obj_find_section(f, "__ksymtab") || flag_noexport;
3627
3628 sec = obj_find_section(f, ".this");
3629 if (sec) {
3630 /* tag the module header with the object name, last modified
3631 * timestamp and module version. worst case for module version
3632 * is 0xffffff, decimal 16777215. putting all three fields in
3633 * one symbol is less readable but saves kernel space.
3634 */
3635 l = sizeof(symprefix) + /* "__insmod_" */
3636 lm_name + /* module name */
3637 2 + /* "_O" */
3638 lfilename + /* object filename */
3639 2 + /* "_M" */
3640 2 * sizeof(statbuf.st_mtime) + /* mtime in hex */
3641 2 + /* "_V" */
3642 8 + /* version in dec */
3643 1; /* nul */
3644 name = xmalloc(l);
3645 if (stat(absolute_filename, &statbuf) != 0)
3646 statbuf.st_mtime = 0;
3647 version = get_module_version(f, str); /* -1 if not found */
3648 snprintf(name, l, "%s%s_O%s_M%0*lX_V%d",
3649 symprefix, m_name, absolute_filename,
3650 (int)(2 * sizeof(statbuf.st_mtime)), statbuf.st_mtime,
3651 version);
3652 sym = obj_add_symbol(f, name, -1,
3653 ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3654 sec->idx, sec->header.sh_addr, 0);
3655 if (use_ksymtab)
3656 new_add_ksymtab(f, sym);
3657 }
3658 free(absolute_filename);
3659#ifdef _NOT_SUPPORTED_
3660 /* record where the persistent data is going, same address as previous symbol */
3661
3662 if (f->persist) {
3663 l = sizeof(symprefix) + /* "__insmod_" */
3664 lm_name + /* module name */
3665 2 + /* "_P" */
3666 strlen(f->persist) + /* data store */
3667 1; /* nul */
3668 name = xmalloc(l);
3669 snprintf(name, l, "%s%s_P%s",
3670 symprefix, m_name, f->persist);
3671 sym = obj_add_symbol(f, name, -1, ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3672 sec->idx, sec->header.sh_addr, 0);
3673 if (use_ksymtab)
3674 new_add_ksymtab(f, sym);
3675 }
3676#endif /* _NOT_SUPPORTED_ */
3677 /* tag the desired sections if size is non-zero */
3678
3679 for (i = 0; i < ARRAY_SIZE(section_names); ++i) {
3680 sec = obj_find_section(f, section_names[i]);
3681 if (sec && sec->header.sh_size) {
3682 l = sizeof(symprefix) + /* "__insmod_" */
3683 lm_name + /* module name */
3684 2 + /* "_S" */
3685 strlen(sec->name) + /* section name */
3686 2 + /* "_L" */
3687 8 + /* length in dec */
3688 1; /* nul */
3689 name = xmalloc(l);
3690 snprintf(name, l, "%s%s_S%s_L%ld",
3691 symprefix, m_name, sec->name,
3692 (long)sec->header.sh_size);
3693 sym = obj_add_symbol(f, name, -1, ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3694 sec->idx, sec->header.sh_addr, 0);
3695 if (use_ksymtab)
3696 new_add_ksymtab(f, sym);
3697 }
3698 }
3699}
3700#endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
3701
3702#if ENABLE_FEATURE_INSMOD_LOAD_MAP
3703static void print_load_map(struct obj_file *f)
3704{
3705 struct obj_section *sec;
3706#if ENABLE_FEATURE_INSMOD_LOAD_MAP_FULL
3707 struct obj_symbol **all, **p;
3708 int i, nsyms, *loaded;
3709 struct obj_symbol *sym;
3710#endif
3711 /* Report on the section layout. */
3712
3713 printf("Sections: Size %-*s Align\n",
3714 (int) (2 * sizeof(void *)), "Address");
3715
3716 for (sec = f->load_order; sec; sec = sec->load_next) {
3717 int a;
3718 unsigned long tmp;
3719
3720 for (a = -1, tmp = sec->header.sh_addralign; tmp; ++a)
3721 tmp >>= 1;
3722 if (a == -1)
3723 a = 0;
3724
3725 printf("%-15s %08lx %0*lx 2**%d\n",
3726 sec->name,
3727 (long)sec->header.sh_size,
3728 (int) (2 * sizeof(void *)),
3729 (long)sec->header.sh_addr,
3730 a);
3731 }
3732#if ENABLE_FEATURE_INSMOD_LOAD_MAP_FULL
3733 /* Quick reference which section indices are loaded. */
3734
3735 i = f->header.e_shnum;
3736 loaded = alloca(sizeof(int) * i);
3737 while (--i >= 0)
3738 loaded[i] = ((f->sections[i]->header.sh_flags & SHF_ALLOC) != 0);
3739
3740 /* Collect the symbols we'll be listing. */
3741
3742 for (nsyms = i = 0; i < HASH_BUCKETS; ++i)
3743 for (sym = f->symtab[i]; sym; sym = sym->next)
3744 if (sym->secidx <= SHN_HIRESERVE
3745 && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx]))
3746 ++nsyms;
3747
3748 all = alloca(nsyms * sizeof(struct obj_symbol *));
3749
3750 for (i = 0, p = all; i < HASH_BUCKETS; ++i)
3751 for (sym = f->symtab[i]; sym; sym = sym->next)
3752 if (sym->secidx <= SHN_HIRESERVE
3753 && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx]))
3754 *p++ = sym;
3755
3756 /* And list them. */
3757 printf("\nSymbols:\n");
3758 for (p = all; p < all + nsyms; ++p) {
3759 char type = '?';
3760 unsigned long value;
3761
3762 sym = *p;
3763 if (sym->secidx == SHN_ABS) {
3764 type = 'A';
3765 value = sym->value;
3766 } else if (sym->secidx == SHN_UNDEF) {
3767 type = 'U';
3768 value = 0;
3769 } else {
3770 sec = f->sections[sym->secidx];
3771
3772 if (sec->header.sh_type == SHT_NOBITS)
3773 type = 'B';
3774 else if (sec->header.sh_flags & SHF_ALLOC) {
3775 if (sec->header.sh_flags & SHF_EXECINSTR)
3776 type = 'T';
3777 else if (sec->header.sh_flags & SHF_WRITE)
3778 type = 'D';
3779 else
3780 type = 'R';
3781 }
3782 value = sym->value + sec->header.sh_addr;
3783 }
3784
3785 if (ELF_ST_BIND(sym->info) == STB_LOCAL)
3786 type = tolower(type);
3787
3788 printf("%0*lx %c %s\n", (int) (2 * sizeof(void *)), value,
3789 type, sym->name);
3790 }
3791#endif
3792}
3793#else /* !FEATURE_INSMOD_LOAD_MAP */
3794static void print_load_map(struct obj_file *f UNUSED_PARAM)
3795{
3796}
3797#endif
3798
3799int FAST_FUNC bb_init_module_24(const char *m_filename, const char *options UNUSED_PARAM)
3800{
3801 int k_crcs;
3802 unsigned long m_size;
3803 ElfW(Addr) m_addr;
3804 struct obj_file *f;
3805 struct utsname uts;
3806 int exit_status = EXIT_FAILURE;
3807 int m_has_modinfo;
3808 char *m_name;
3809#if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3810 char m_strversion[STRVERSIONLEN];
3811 int m_version, m_crcs;
3812#endif
3813 FILE *fp;
3814
3815 uname(&uts);
3816 fp = fopen_for_read(m_filename);
3817 if (fp == NULL)
3818 return EXIT_FAILURE;
3819
3820 m_name = xstrdup(bb_basename(m_filename));
3821 *strrchr(m_name, '.') = 0;
3822
3823 f = obj_load(fp, LOADBITS);
3824
3825 if (get_modinfo_value(f, "kernel_version") == NULL)
3826 m_has_modinfo = 0;
3827 else
3828 m_has_modinfo = 1;
3829
3830#if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3831 /* Version correspondence? */
3832 if (!flag_quiet) {
3833 if (m_has_modinfo) {
3834 m_version = new_get_module_version(f, m_strversion);
3835 if (m_version == -1) {
3836 bb_error_msg_and_die("cannot find the kernel version the module was "
3837 "compiled for");
3838 }
3839 }
3840
3841 if (strncmp(uts.release, m_strversion, STRVERSIONLEN) != 0) {
3842 bb_error_msg("%skernel-module version mismatch\n"
3843 "\t%s was compiled for kernel version %s\n"
3844 "\twhile this kernel is version %s",
3845 flag_force_load ? "warning: " : "",
3846 m_name, m_strversion, uts.release);
3847 if (!flag_force_load)
3848 goto out;
3849 }
3850 }
3851 k_crcs = 0;
3852#endif /* FEATURE_INSMOD_VERSION_CHECKING */
3853
3854 if (query_module(NULL, 0, NULL, 0, NULL))
3855 bb_error_msg_and_die("not configured to support old kernels");
3856 new_get_kernel_symbols();
3857 k_crcs = new_is_kernel_checksummed();
3858
3859#if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3860 m_crcs = 0;
3861 if (m_has_modinfo)
3862 m_crcs = new_is_module_checksummed(f);
3863
3864 if (m_crcs != k_crcs)
3865 obj_set_symbol_compare(f, ncv_strcmp, ncv_symbol_hash);
3866#endif /* FEATURE_INSMOD_VERSION_CHECKING */
3867
3868 /* Let the module know about the kernel symbols. */
3869 add_kernel_symbols(f);
3870
3871 /* Allocate common symbols, symbol tables, and string tables. */
3872
3873 new_create_this_module(f, m_name);
3874 obj_check_undefineds(f);
3875 obj_allocate_commons(f);
3876 check_tainted_module(f, m_name);
3877
3878 /* done with the module name, on to the optional var=value arguments */
3879 new_process_module_arguments(f, options);
3880
3881 arch_create_got(f);
3882 hide_special_symbols(f);
3883
3884#if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
3885 add_ksymoops_symbols(f, m_filename, m_name);
3886#endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
3887
3888 new_create_module_ksymtab(f);
3889
3890 /* Find current size of the module */
3891 m_size = obj_load_size(f);
3892
3893 m_addr = create_module(m_name, m_size);
3894 if (m_addr == (ElfW(Addr))(-1)) switch (errno) {
3895 case EEXIST:
3896 bb_error_msg_and_die("a module named %s already exists", m_name);
3897 case ENOMEM:
3898 bb_error_msg_and_die("can't allocate kernel memory for module; needed %lu bytes",
3899 m_size);
3900 default:
3901 bb_perror_msg_and_die("create_module: %s", m_name);
3902 }
3903
3904#if !LOADBITS
3905 /*
3906 * the PROGBITS section was not loaded by the obj_load
3907 * now we can load them directly into the kernel memory
3908 */
3909 if (!obj_load_progbits(fp, f, (char*)m_addr)) {
3910 delete_module(m_name, 0);
3911 goto out;
3912 }
3913#endif
3914
3915 if (!obj_relocate(f, m_addr)) {
3916 delete_module(m_name, 0);
3917 goto out;
3918 }
3919
3920 if (!new_init_module(m_name, f, m_size)) {
3921 delete_module(m_name, 0);
3922 goto out;
3923 }
3924
3925 if (flag_print_load_map)
3926 print_load_map(f);
3927
3928 exit_status = EXIT_SUCCESS;
3929
3930 out:
3931 if (fp)
3932 fclose(fp);
3933 free(m_name);
3934
3935 return exit_status;
3936}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-17 20:38:38 +0000