Context Navigation

modutils-24.c@ 3232

Visit:

Last change on this file since 3232 was 3232, checked in by Bruno Cornec, 10 years ago
Update mindi-busybox to 1.21.1
Property svn:eol-style set to `native`
File size: 94.9 KB

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

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: MondoRescue/branches/3.2/mindi-busybox/modutils/modutils-24.c@ 3232

Download in other formats: