path: root/modutils/modutils-24.c (plain)
blob: 9ce91351dbc3eb352c5ce31639741d94b5df14a2

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