blob: 48958d3cec9e38473ff3296f7f6bf4d5db41612a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* Postprocess module symbol versions
2 *
3 * Copyright 2003 Kai Germaschewski
4 * Copyright 2002-2004 Rusty Russell, IBM Corporation
Sam Ravnborgdf578e72008-01-11 19:17:15 +01005 * Copyright 2006-2008 Sam Ravnborg
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 * Based in part on module-init-tools/depmod.c,file2alias
7 *
8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference.
10 *
11 * Usage: modpost vmlinux module1.o module2.o ...
12 */
13
Mathieu Desnoyersb2e3e652008-02-13 15:03:39 -080014#define _GNU_SOURCE
15#include <stdio.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <ctype.h>
Andrew Morton5003bab2010-08-11 00:42:26 -070017#include <string.h>
Rusty Russell712f9b42013-04-04 17:37:38 +103018#include <limits.h>
Rusty Russelld4ef1c32013-04-04 17:37:32 +103019#include <stdbool.h>
Guenter Roeckeed380f2013-09-23 15:23:54 +093020#include <errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include "modpost.h"
Linus Torvalds5a865c02009-12-17 07:23:42 -080022#include "../../include/generated/autoconf.h"
Sam Ravnborgb817f6f2006-06-09 21:53:55 +020023#include "../../include/linux/license.h"
Rusty Russellb92021b2013-03-15 15:04:17 +103024#include "../../include/linux/export.h"
Alan Jenkins9e1b9b82009-11-07 21:03:54 +000025
Linus Torvalds1da177e2005-04-16 15:20:36 -070026/* Are we using CONFIG_MODVERSIONS? */
Mathias Krause7a3ee752014-08-27 20:28:53 +093027static int modversions = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070028/* Warn about undefined symbols? (do so if we have vmlinux) */
Mathias Krause7a3ee752014-08-27 20:28:53 +093029static int have_vmlinux = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070030/* Is CONFIG_MODULE_SRCVERSION_ALL set? */
31static int all_versions = 0;
Sam Ravnborg040fcc82006-01-28 22:15:55 +010032/* If we are modposting external module set to 1 */
33static int external_module = 0;
Sam Ravnborg8d8d8282007-07-20 22:36:56 +020034/* Warn about section mismatch in vmlinux if set to 1 */
35static int vmlinux_section_warnings = 1;
Kirill Korotaevc53ddac2006-09-07 13:08:54 -070036/* Only warn about unresolved symbols */
37static int warn_unresolved = 0;
Ram Paibd5cbce2006-06-08 22:12:53 -070038/* How a symbol is exported */
Sam Ravnborg588ccd72008-01-24 21:12:37 +010039static int sec_mismatch_count = 0;
40static int sec_mismatch_verbose = 1;
Nicolas Boichat47490ec2015-10-06 09:44:42 +103041static int sec_mismatch_fatal = 0;
Guenter Roeckeed380f2013-09-23 15:23:54 +093042/* ignore missing files */
43static int ignore_missing_files;
Sam Ravnborg588ccd72008-01-24 21:12:37 +010044
Sam Ravnborgc96fca22006-07-01 11:44:23 +020045enum export {
46 export_plain, export_unused, export_gpl,
47 export_unused_gpl, export_gpl_future, export_unknown
48};
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
Andi Kleen6d9a89e2007-11-22 03:43:08 +010050#define PRINTF __attribute__ ((format (printf, 1, 2)))
51
52PRINTF void fatal(const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -070053{
54 va_list arglist;
55
56 fprintf(stderr, "FATAL: ");
57
58 va_start(arglist, fmt);
59 vfprintf(stderr, fmt, arglist);
60 va_end(arglist);
61
62 exit(1);
63}
64
Andi Kleen6d9a89e2007-11-22 03:43:08 +010065PRINTF void warn(const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -070066{
67 va_list arglist;
68
69 fprintf(stderr, "WARNING: ");
70
71 va_start(arglist, fmt);
72 vfprintf(stderr, fmt, arglist);
73 va_end(arglist);
74}
75
Andi Kleen6d9a89e2007-11-22 03:43:08 +010076PRINTF void merror(const char *fmt, ...)
Matthew Wilcox2a116652006-10-07 05:35:32 -060077{
78 va_list arglist;
79
80 fprintf(stderr, "ERROR: ");
81
82 va_start(arglist, fmt);
83 vfprintf(stderr, fmt, arglist);
84 va_end(arglist);
85}
86
Rusty Russelld4ef1c32013-04-04 17:37:32 +103087static inline bool strends(const char *str, const char *postfix)
88{
89 if (strlen(str) < strlen(postfix))
90 return false;
91
92 return strcmp(str + strlen(str) - strlen(postfix), postfix) == 0;
93}
94
Sam Ravnborg040fcc82006-01-28 22:15:55 +010095static int is_vmlinux(const char *modname)
96{
97 const char *myname;
98
Sam Ravnborgdf578e72008-01-11 19:17:15 +010099 myname = strrchr(modname, '/');
100 if (myname)
Sam Ravnborg040fcc82006-01-28 22:15:55 +0100101 myname++;
102 else
103 myname = modname;
104
Sam Ravnborg741f98f2007-07-17 10:54:06 +0200105 return (strcmp(myname, "vmlinux") == 0) ||
106 (strcmp(myname, "vmlinux.o") == 0);
Sam Ravnborg040fcc82006-01-28 22:15:55 +0100107}
108
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109void *do_nofail(void *ptr, const char *expr)
110{
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100111 if (!ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 fatal("modpost: Memory allocation failure: %s.\n", expr);
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100113
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 return ptr;
115}
116
117/* A list of all modules we processed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118static struct module *modules;
119
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100120static struct module *find_module(char *modname)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121{
122 struct module *mod;
123
124 for (mod = modules; mod; mod = mod->next)
125 if (strcmp(mod->name, modname) == 0)
126 break;
127 return mod;
128}
129
Rusty Russelld4ef1c32013-04-04 17:37:32 +1030130static struct module *new_module(const char *modname)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131{
132 struct module *mod;
Rusty Russelld4ef1c32013-04-04 17:37:32 +1030133 char *p;
Sam Ravnborg62070fa2006-03-03 16:46:04 +0100134
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 mod = NOFAIL(malloc(sizeof(*mod)));
136 memset(mod, 0, sizeof(*mod));
137 p = NOFAIL(strdup(modname));
138
139 /* strip trailing .o */
Rusty Russelld4ef1c32013-04-04 17:37:32 +1030140 if (strends(p, ".o")) {
141 p[strlen(p) - 2] = '\0';
142 mod->is_dot_o = 1;
143 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
145 /* add to list */
146 mod->name = p;
Sam Ravnborgb817f6f2006-06-09 21:53:55 +0200147 mod->gpl_compatible = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 mod->next = modules;
149 modules = mod;
150
151 return mod;
152}
153
154/* A hash of all exported symbols,
155 * struct symbol is also used for lists of unresolved symbols */
156
157#define SYMBOL_HASH_SIZE 1024
158
159struct symbol {
160 struct symbol *next;
161 struct module *module;
162 unsigned int crc;
163 int crc_valid;
164 unsigned int weak:1;
Sam Ravnborg040fcc82006-01-28 22:15:55 +0100165 unsigned int vmlinux:1; /* 1 if symbol is defined in vmlinux */
166 unsigned int kernel:1; /* 1 if symbol is from kernel
167 * (only for external modules) **/
Rusty Russellb6568b12013-11-07 12:09:13 +1030168 unsigned int preloaded:1; /* 1 if symbol from Module.symvers, or crc */
Ram Paibd5cbce2006-06-08 22:12:53 -0700169 enum export export; /* Type of export */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 char name[0];
171};
172
173static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
174
175/* This is based on the hash agorithm from gdbm, via tdb */
176static inline unsigned int tdb_hash(const char *name)
177{
178 unsigned value; /* Used to compute the hash value. */
179 unsigned i; /* Used to cycle through random values. */
180
181 /* Set the initial value from the key size. */
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100182 for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
184
185 return (1103515243 * value + 12345);
186}
187
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100188/**
189 * Allocate a new symbols for use in the hash of exported symbols or
190 * the list of unresolved symbols per module
191 **/
192static struct symbol *alloc_symbol(const char *name, unsigned int weak,
193 struct symbol *next)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194{
195 struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
196
197 memset(s, 0, sizeof(*s));
198 strcpy(s->name, name);
199 s->weak = weak;
200 s->next = next;
201 return s;
202}
203
204/* For the hash of exported symbols */
Ram Paibd5cbce2006-06-08 22:12:53 -0700205static struct symbol *new_symbol(const char *name, struct module *module,
206 enum export export)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207{
208 unsigned int hash;
209 struct symbol *new;
210
211 hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
212 new = symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
213 new->module = module;
Ram Paibd5cbce2006-06-08 22:12:53 -0700214 new->export = export;
Sam Ravnborg040fcc82006-01-28 22:15:55 +0100215 return new;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216}
217
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100218static struct symbol *find_symbol(const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219{
220 struct symbol *s;
221
222 /* For our purposes, .foo matches foo. PPC64 needs this. */
223 if (name[0] == '.')
224 name++;
225
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100226 for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 if (strcmp(s->name, name) == 0)
228 return s;
229 }
230 return NULL;
231}
232
Mathias Krause7a3ee752014-08-27 20:28:53 +0930233static const struct {
Ram Paibd5cbce2006-06-08 22:12:53 -0700234 const char *str;
235 enum export export;
236} export_list[] = {
237 { .str = "EXPORT_SYMBOL", .export = export_plain },
Sam Ravnborgc96fca22006-07-01 11:44:23 +0200238 { .str = "EXPORT_UNUSED_SYMBOL", .export = export_unused },
Ram Paibd5cbce2006-06-08 22:12:53 -0700239 { .str = "EXPORT_SYMBOL_GPL", .export = export_gpl },
Sam Ravnborgc96fca22006-07-01 11:44:23 +0200240 { .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },
Ram Paibd5cbce2006-06-08 22:12:53 -0700241 { .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },
242 { .str = "(unknown)", .export = export_unknown },
243};
244
245
246static const char *export_str(enum export ex)
247{
248 return export_list[ex].str;
249}
250
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100251static enum export export_no(const char *s)
Ram Paibd5cbce2006-06-08 22:12:53 -0700252{
253 int i;
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100254
Sam Ravnborg534b89a2006-07-01 10:10:19 +0200255 if (!s)
256 return export_unknown;
Ram Paibd5cbce2006-06-08 22:12:53 -0700257 for (i = 0; export_list[i].export != export_unknown; i++) {
258 if (strcmp(export_list[i].str, s) == 0)
259 return export_list[i].export;
260 }
261 return export_unknown;
262}
263
Alessio Igor Bogani62a26352011-07-14 08:51:16 +0200264static const char *sec_name(struct elf_info *elf, int secindex);
265
266#define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0)
267
268static enum export export_from_secname(struct elf_info *elf, unsigned int sec)
269{
270 const char *secname = sec_name(elf, sec);
271
272 if (strstarts(secname, "___ksymtab+"))
273 return export_plain;
274 else if (strstarts(secname, "___ksymtab_unused+"))
275 return export_unused;
276 else if (strstarts(secname, "___ksymtab_gpl+"))
277 return export_gpl;
278 else if (strstarts(secname, "___ksymtab_unused_gpl+"))
279 return export_unused_gpl;
280 else if (strstarts(secname, "___ksymtab_gpl_future+"))
281 return export_gpl_future;
282 else
283 return export_unknown;
284}
285
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200286static enum export export_from_sec(struct elf_info *elf, unsigned int sec)
Ram Paibd5cbce2006-06-08 22:12:53 -0700287{
288 if (sec == elf->export_sec)
289 return export_plain;
Sam Ravnborgc96fca22006-07-01 11:44:23 +0200290 else if (sec == elf->export_unused_sec)
291 return export_unused;
Ram Paibd5cbce2006-06-08 22:12:53 -0700292 else if (sec == elf->export_gpl_sec)
293 return export_gpl;
Sam Ravnborgc96fca22006-07-01 11:44:23 +0200294 else if (sec == elf->export_unused_gpl_sec)
295 return export_unused_gpl;
Ram Paibd5cbce2006-06-08 22:12:53 -0700296 else if (sec == elf->export_gpl_future_sec)
297 return export_gpl_future;
298 else
299 return export_unknown;
300}
301
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100302/**
303 * Add an exported symbol - it may have already been added without a
304 * CRC, in this case just update the CRC
305 **/
Ram Paibd5cbce2006-06-08 22:12:53 -0700306static struct symbol *sym_add_exported(const char *name, struct module *mod,
307 enum export export)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308{
309 struct symbol *s = find_symbol(name);
310
311 if (!s) {
Ram Paibd5cbce2006-06-08 22:12:53 -0700312 s = new_symbol(name, mod, export);
Sam Ravnborg8e70c452006-01-28 22:22:33 +0100313 } else {
314 if (!s->preloaded) {
Sam Ravnborg7b75b132006-03-05 13:48:58 +0100315 warn("%s: '%s' exported twice. Previous export "
Sam Ravnborg8e70c452006-01-28 22:22:33 +0100316 "was in %s%s\n", mod->name, name,
317 s->module->name,
318 is_vmlinux(s->module->name) ?"":".ko");
Trent Piepho4b219602007-10-11 16:40:10 -0700319 } else {
Paul Bollebaec30e2014-04-16 18:05:35 +0200320 /* In case Module.symvers was out of date */
Trent Piepho4b219602007-10-11 16:40:10 -0700321 s->module = mod;
Sam Ravnborg8e70c452006-01-28 22:22:33 +0100322 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 }
Sam Ravnborg8e70c452006-01-28 22:22:33 +0100324 s->preloaded = 0;
Sam Ravnborg040fcc82006-01-28 22:15:55 +0100325 s->vmlinux = is_vmlinux(mod->name);
326 s->kernel = 0;
Ram Paibd5cbce2006-06-08 22:12:53 -0700327 s->export = export;
Sam Ravnborg040fcc82006-01-28 22:15:55 +0100328 return s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329}
330
Sam Ravnborg040fcc82006-01-28 22:15:55 +0100331static void sym_update_crc(const char *name, struct module *mod,
Ram Paibd5cbce2006-06-08 22:12:53 -0700332 unsigned int crc, enum export export)
Sam Ravnborg040fcc82006-01-28 22:15:55 +0100333{
334 struct symbol *s = find_symbol(name);
335
Rusty Russellb6568b12013-11-07 12:09:13 +1030336 if (!s) {
Ram Paibd5cbce2006-06-08 22:12:53 -0700337 s = new_symbol(name, mod, export);
Rusty Russellb6568b12013-11-07 12:09:13 +1030338 /* Don't complain when we find it later. */
339 s->preloaded = 1;
340 }
Sam Ravnborg040fcc82006-01-28 22:15:55 +0100341 s->crc = crc;
342 s->crc_valid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343}
344
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100345void *grab_file(const char *filename, unsigned long *size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346{
347 struct stat st;
Jesper Juhleb3d5cc2012-05-23 22:28:49 +0930348 void *map = MAP_FAILED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 int fd;
350
351 fd = open(filename, O_RDONLY);
Jesper Juhleb3d5cc2012-05-23 22:28:49 +0930352 if (fd < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 return NULL;
Jesper Juhleb3d5cc2012-05-23 22:28:49 +0930354 if (fstat(fd, &st))
355 goto failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
357 *size = st.st_size;
358 map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359
Jesper Juhleb3d5cc2012-05-23 22:28:49 +0930360failed:
361 close(fd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 if (map == MAP_FAILED)
363 return NULL;
364 return map;
365}
366
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100367/**
368 * Return a copy of the next line in a mmap'ed file.
369 * spaces in the beginning of the line is trimmed away.
370 * Return a pointer to a static buffer.
371 **/
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100372char *get_next_line(unsigned long *pos, void *file, unsigned long size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373{
374 static char line[4096];
375 int skip = 1;
376 size_t len = 0;
377 signed char *p = (signed char *)file + *pos;
378 char *s = line;
379
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100380 for (; *pos < size ; (*pos)++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 if (skip && isspace(*p)) {
382 p++;
383 continue;
384 }
385 skip = 0;
386 if (*p != '\n' && (*pos < size)) {
387 len++;
388 *s++ = *p++;
389 if (len > 4095)
390 break; /* Too long, stop */
391 } else {
392 /* End of string */
393 *s = '\0';
394 return line;
395 }
396 }
397 /* End of buffer */
398 return NULL;
399}
400
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100401void release_file(void *file, unsigned long size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402{
403 munmap(file, size);
404}
405
Sam Ravnborg85bd2fd2007-02-26 15:33:52 +0100406static int parse_elf(struct elf_info *info, const char *filename)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407{
408 unsigned int i;
Sam Ravnborg85bd2fd2007-02-26 15:33:52 +0100409 Elf_Ehdr *hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 Elf_Shdr *sechdrs;
411 Elf_Sym *sym;
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200412 const char *secstrings;
413 unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414
415 hdr = grab_file(filename, &info->size);
416 if (!hdr) {
Guenter Roeckeed380f2013-09-23 15:23:54 +0930417 if (ignore_missing_files) {
418 fprintf(stderr, "%s: %s (ignored)\n", filename,
419 strerror(errno));
420 return 0;
421 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 perror(filename);
Sam Ravnborg6803dc02006-06-24 23:46:54 +0200423 exit(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 }
425 info->hdr = hdr;
Sam Ravnborg85bd2fd2007-02-26 15:33:52 +0100426 if (info->size < sizeof(*hdr)) {
427 /* file too small, assume this is an empty .o file */
428 return 0;
429 }
430 /* Is this a valid ELF file? */
431 if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
432 (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
433 (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
434 (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
435 /* Not an ELF file - silently ignore it */
436 return 0;
437 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 /* Fix endianness in ELF header */
Anders Kaseorg7d875a02009-05-03 22:02:55 +0200439 hdr->e_type = TO_NATIVE(hdr->e_type);
440 hdr->e_machine = TO_NATIVE(hdr->e_machine);
441 hdr->e_version = TO_NATIVE(hdr->e_version);
442 hdr->e_entry = TO_NATIVE(hdr->e_entry);
443 hdr->e_phoff = TO_NATIVE(hdr->e_phoff);
444 hdr->e_shoff = TO_NATIVE(hdr->e_shoff);
445 hdr->e_flags = TO_NATIVE(hdr->e_flags);
446 hdr->e_ehsize = TO_NATIVE(hdr->e_ehsize);
447 hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
448 hdr->e_phnum = TO_NATIVE(hdr->e_phnum);
449 hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
450 hdr->e_shnum = TO_NATIVE(hdr->e_shnum);
451 hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 sechdrs = (void *)hdr + hdr->e_shoff;
453 info->sechdrs = sechdrs;
454
Petr Stetiara83710e2007-08-27 12:15:07 +0200455 /* Check if file offset is correct */
456 if (hdr->e_shoff > info->size) {
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100457 fatal("section header offset=%lu in file '%s' is bigger than "
458 "filesize=%lu\n", (unsigned long)hdr->e_shoff,
459 filename, info->size);
Petr Stetiara83710e2007-08-27 12:15:07 +0200460 return 0;
461 }
462
Anders Kaseorg68457562011-05-19 16:55:27 -0600463 if (hdr->e_shnum == SHN_UNDEF) {
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200464 /*
465 * There are more than 64k sections,
466 * read count from .sh_size.
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200467 */
468 info->num_sections = TO_NATIVE(sechdrs[0].sh_size);
469 }
470 else {
471 info->num_sections = hdr->e_shnum;
472 }
473 if (hdr->e_shstrndx == SHN_XINDEX) {
Anders Kaseorg68457562011-05-19 16:55:27 -0600474 info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link);
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200475 }
476 else {
477 info->secindex_strings = hdr->e_shstrndx;
478 }
479
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 /* Fix endianness in section headers */
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200481 for (i = 0; i < info->num_sections; i++) {
Anders Kaseorg7d875a02009-05-03 22:02:55 +0200482 sechdrs[i].sh_name = TO_NATIVE(sechdrs[i].sh_name);
483 sechdrs[i].sh_type = TO_NATIVE(sechdrs[i].sh_type);
484 sechdrs[i].sh_flags = TO_NATIVE(sechdrs[i].sh_flags);
485 sechdrs[i].sh_addr = TO_NATIVE(sechdrs[i].sh_addr);
486 sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);
487 sechdrs[i].sh_size = TO_NATIVE(sechdrs[i].sh_size);
488 sechdrs[i].sh_link = TO_NATIVE(sechdrs[i].sh_link);
489 sechdrs[i].sh_info = TO_NATIVE(sechdrs[i].sh_info);
490 sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
491 sechdrs[i].sh_entsize = TO_NATIVE(sechdrs[i].sh_entsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 }
493 /* Find symbol table. */
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200494 secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
495 for (i = 1; i < info->num_sections; i++) {
Ram Paibd5cbce2006-06-08 22:12:53 -0700496 const char *secname;
Tejun Heo56fc82c2009-02-06 00:48:02 +0900497 int nobits = sechdrs[i].sh_type == SHT_NOBITS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
Tejun Heo56fc82c2009-02-06 00:48:02 +0900499 if (!nobits && sechdrs[i].sh_offset > info->size) {
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100500 fatal("%s is truncated. sechdrs[i].sh_offset=%lu > "
501 "sizeof(*hrd)=%zu\n", filename,
502 (unsigned long)sechdrs[i].sh_offset,
503 sizeof(*hdr));
Sam Ravnborg85bd2fd2007-02-26 15:33:52 +0100504 return 0;
505 }
Ram Paibd5cbce2006-06-08 22:12:53 -0700506 secname = secstrings + sechdrs[i].sh_name;
507 if (strcmp(secname, ".modinfo") == 0) {
Tejun Heo56fc82c2009-02-06 00:48:02 +0900508 if (nobits)
509 fatal("%s has NOBITS .modinfo\n", filename);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
511 info->modinfo_len = sechdrs[i].sh_size;
Ram Paibd5cbce2006-06-08 22:12:53 -0700512 } else if (strcmp(secname, "__ksymtab") == 0)
513 info->export_sec = i;
Sam Ravnborgc96fca22006-07-01 11:44:23 +0200514 else if (strcmp(secname, "__ksymtab_unused") == 0)
515 info->export_unused_sec = i;
Ram Paibd5cbce2006-06-08 22:12:53 -0700516 else if (strcmp(secname, "__ksymtab_gpl") == 0)
517 info->export_gpl_sec = i;
Sam Ravnborgc96fca22006-07-01 11:44:23 +0200518 else if (strcmp(secname, "__ksymtab_unused_gpl") == 0)
519 info->export_unused_gpl_sec = i;
Ram Paibd5cbce2006-06-08 22:12:53 -0700520 else if (strcmp(secname, "__ksymtab_gpl_future") == 0)
521 info->export_gpl_future_sec = i;
522
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200523 if (sechdrs[i].sh_type == SHT_SYMTAB) {
524 unsigned int sh_link_idx;
525 symtab_idx = i;
526 info->symtab_start = (void *)hdr +
527 sechdrs[i].sh_offset;
528 info->symtab_stop = (void *)hdr +
529 sechdrs[i].sh_offset + sechdrs[i].sh_size;
Anders Kaseorg68457562011-05-19 16:55:27 -0600530 sh_link_idx = sechdrs[i].sh_link;
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200531 info->strtab = (void *)hdr +
532 sechdrs[sh_link_idx].sh_offset;
533 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200535 /* 32bit section no. table? ("more than 64k sections") */
536 if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
537 symtab_shndx_idx = i;
538 info->symtab_shndx_start = (void *)hdr +
539 sechdrs[i].sh_offset;
540 info->symtab_shndx_stop = (void *)hdr +
541 sechdrs[i].sh_offset + sechdrs[i].sh_size;
542 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 }
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100544 if (!info->symtab_start)
Sam Ravnborgcb805142006-01-28 16:57:26 +0100545 fatal("%s has no symtab?\n", filename);
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100546
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 /* Fix endianness in symbols */
548 for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
549 sym->st_shndx = TO_NATIVE(sym->st_shndx);
550 sym->st_name = TO_NATIVE(sym->st_name);
551 sym->st_value = TO_NATIVE(sym->st_value);
552 sym->st_size = TO_NATIVE(sym->st_size);
553 }
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200554
555 if (symtab_shndx_idx != ~0U) {
556 Elf32_Word *p;
Anders Kaseorg68457562011-05-19 16:55:27 -0600557 if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200558 fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
Anders Kaseorg68457562011-05-19 16:55:27 -0600559 filename, sechdrs[symtab_shndx_idx].sh_link,
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200560 symtab_idx);
561 /* Fix endianness */
562 for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
563 p++)
564 *p = TO_NATIVE(*p);
565 }
566
Sam Ravnborg85bd2fd2007-02-26 15:33:52 +0100567 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568}
569
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100570static void parse_elf_finish(struct elf_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571{
572 release_file(info->hdr, info->size);
573}
574
Sam Ravnborg4d7365d2008-06-12 15:02:55 +0200575static int ignore_undef_symbol(struct elf_info *info, const char *symname)
576{
577 /* ignore __this_module, it will be resolved shortly */
Rusty Russellb92021b2013-03-15 15:04:17 +1030578 if (strcmp(symname, VMLINUX_SYMBOL_STR(__this_module)) == 0)
Sam Ravnborg4d7365d2008-06-12 15:02:55 +0200579 return 1;
580 /* ignore global offset table */
581 if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
582 return 1;
583 if (info->hdr->e_machine == EM_PPC)
584 /* Special register function linked on all modules during final link of .ko */
585 if (strncmp(symname, "_restgpr_", sizeof("_restgpr_") - 1) == 0 ||
586 strncmp(symname, "_savegpr_", sizeof("_savegpr_") - 1) == 0 ||
587 strncmp(symname, "_rest32gpr_", sizeof("_rest32gpr_") - 1) == 0 ||
Andreas Schwab8fe9c932013-12-30 15:31:17 +0100588 strncmp(symname, "_save32gpr_", sizeof("_save32gpr_") - 1) == 0 ||
589 strncmp(symname, "_restvr_", sizeof("_restvr_") - 1) == 0 ||
590 strncmp(symname, "_savevr_", sizeof("_savevr_") - 1) == 0)
Sam Ravnborg4d7365d2008-06-12 15:02:55 +0200591 return 1;
Stephen Rothwell7fca5dc2010-06-29 20:08:42 +0000592 if (info->hdr->e_machine == EM_PPC64)
593 /* Special register function linked on all modules during final link of .ko */
594 if (strncmp(symname, "_restgpr0_", sizeof("_restgpr0_") - 1) == 0 ||
Andreas Schwab8fe9c932013-12-30 15:31:17 +0100595 strncmp(symname, "_savegpr0_", sizeof("_savegpr0_") - 1) == 0 ||
596 strncmp(symname, "_restvr_", sizeof("_restvr_") - 1) == 0 ||
Alan Modrac1536932016-01-15 20:52:22 +1100597 strncmp(symname, "_savevr_", sizeof("_savevr_") - 1) == 0 ||
598 strcmp(symname, ".TOC.") == 0)
Stephen Rothwell7fca5dc2010-06-29 20:08:42 +0000599 return 1;
Sam Ravnborg4d7365d2008-06-12 15:02:55 +0200600 /* Do not ignore this symbol */
601 return 0;
602}
603
Rusty Russellb92021b2013-03-15 15:04:17 +1030604#define CRC_PFX VMLINUX_SYMBOL_STR(__crc_)
605#define KSYMTAB_PFX VMLINUX_SYMBOL_STR(__ksymtab_)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100607static void handle_modversions(struct module *mod, struct elf_info *info,
608 Elf_Sym *sym, const char *symname)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609{
610 unsigned int crc;
Alessio Igor Bogani62a26352011-07-14 08:51:16 +0200611 enum export export;
612
Frank Rowand258f7422012-04-09 17:59:03 -0700613 if ((!is_vmlinux(mod->name) || mod->is_dot_o) &&
614 strncmp(symname, "__ksymtab", 9) == 0)
Alessio Igor Bogani62a26352011-07-14 08:51:16 +0200615 export = export_from_secname(info, get_secindex(info, sym));
616 else
617 export = export_from_sec(info, get_secindex(info, sym));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
Andi Kleenb5064652013-11-12 15:08:38 -0800619 /* CRC'd symbol */
620 if (strncmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) {
621 crc = (unsigned int) sym->st_value;
622 sym_update_crc(symname + strlen(CRC_PFX), mod, crc,
623 export);
624 }
625
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 switch (sym->st_shndx) {
627 case SHN_COMMON:
Andi Kleenef178f92014-02-08 09:01:17 +0100628 if (!strncmp(symname, "__gnu_lto_", sizeof("__gnu_lto_")-1)) {
629 /* Should warn here, but modpost runs before the linker */
630 } else
631 warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 case SHN_UNDEF:
634 /* undefined symbol */
635 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
636 ELF_ST_BIND(sym->st_info) != STB_WEAK)
637 break;
Sam Ravnborg4d7365d2008-06-12 15:02:55 +0200638 if (ignore_undef_symbol(info, symname))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 break;
Ben Colline8d529012005-08-19 13:44:57 -0700640/* cope with newer glibc (2.3.4 or higher) STT_ definition in elf.h */
641#if defined(STT_REGISTER) || defined(STT_SPARC_REGISTER)
642/* add compatibility with older glibc */
643#ifndef STT_SPARC_REGISTER
644#define STT_SPARC_REGISTER STT_REGISTER
645#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 if (info->hdr->e_machine == EM_SPARC ||
647 info->hdr->e_machine == EM_SPARCV9) {
648 /* Ignore register directives. */
Ben Colline8d529012005-08-19 13:44:57 -0700649 if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 break;
Sam Ravnborg62070fa2006-03-03 16:46:04 +0100651 if (symname[0] == '.') {
652 char *munged = strdup(symname);
653 munged[0] = '_';
654 munged[1] = toupper(munged[1]);
655 symname = munged;
656 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 }
658#endif
Sam Ravnborg62070fa2006-03-03 16:46:04 +0100659
Rusty Russellb92021b2013-03-15 15:04:17 +1030660#ifdef CONFIG_HAVE_UNDERSCORE_SYMBOL_PREFIX
661 if (symname[0] != '_')
662 break;
663 else
664 symname++;
665#endif
666 mod->unres = alloc_symbol(symname,
667 ELF_ST_BIND(sym->st_info) == STB_WEAK,
668 mod->unres);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 break;
670 default:
671 /* All exported symbols */
Michal Marek8d995132009-12-12 12:02:24 +0100672 if (strncmp(symname, KSYMTAB_PFX, strlen(KSYMTAB_PFX)) == 0) {
Ram Paibd5cbce2006-06-08 22:12:53 -0700673 sym_add_exported(symname + strlen(KSYMTAB_PFX), mod,
674 export);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 }
Rusty Russellb92021b2013-03-15 15:04:17 +1030676 if (strcmp(symname, VMLINUX_SYMBOL_STR(init_module)) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 mod->has_init = 1;
Rusty Russellb92021b2013-03-15 15:04:17 +1030678 if (strcmp(symname, VMLINUX_SYMBOL_STR(cleanup_module)) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 mod->has_cleanup = 1;
680 break;
681 }
682}
683
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100684/**
685 * Parse tag=value strings from .modinfo section
686 **/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687static char *next_string(char *string, unsigned long *secsize)
688{
689 /* Skip non-zero chars */
690 while (string[0]) {
691 string++;
692 if ((*secsize)-- <= 1)
693 return NULL;
694 }
695
696 /* Skip any zero padding. */
697 while (!string[0]) {
698 string++;
699 if ((*secsize)-- <= 1)
700 return NULL;
701 }
702 return string;
703}
704
Sam Ravnborgb817f6f2006-06-09 21:53:55 +0200705static char *get_next_modinfo(void *modinfo, unsigned long modinfo_len,
706 const char *tag, char *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707{
708 char *p;
709 unsigned int taglen = strlen(tag);
710 unsigned long size = modinfo_len;
711
Sam Ravnborgb817f6f2006-06-09 21:53:55 +0200712 if (info) {
713 size -= info - (char *)modinfo;
714 modinfo = next_string(info, &size);
715 }
716
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 for (p = modinfo; p; p = next_string(p, &size)) {
718 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
719 return p + taglen + 1;
720 }
721 return NULL;
722}
723
Sam Ravnborgb817f6f2006-06-09 21:53:55 +0200724static char *get_modinfo(void *modinfo, unsigned long modinfo_len,
725 const char *tag)
726
727{
728 return get_next_modinfo(modinfo, modinfo_len, tag, NULL);
729}
730
Sam Ravnborg93684d32006-02-19 11:53:35 +0100731/**
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +0100732 * Test if string s ends in string sub
733 * return 0 if match
734 **/
735static int strrcmp(const char *s, const char *sub)
736{
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100737 int slen, sublen;
Sam Ravnborg62070fa2006-03-03 16:46:04 +0100738
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +0100739 if (!s || !sub)
740 return 1;
Sam Ravnborg62070fa2006-03-03 16:46:04 +0100741
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +0100742 slen = strlen(s);
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100743 sublen = strlen(sub);
Sam Ravnborg62070fa2006-03-03 16:46:04 +0100744
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +0100745 if ((slen == 0) || (sublen == 0))
746 return 1;
747
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100748 if (sublen > slen)
749 return 1;
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +0100750
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100751 return memcmp(s + slen - sublen, sub, sublen);
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +0100752}
753
Sam Ravnborgff13f922008-01-23 19:54:27 +0100754static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
755{
Sam Ravnborg58fb0d42008-01-23 21:13:50 +0100756 if (sym)
757 return elf->strtab + sym->st_name;
758 else
Sam Ravnborgf6667512008-02-06 21:51:18 +0100759 return "(unknown)";
Sam Ravnborgff13f922008-01-23 19:54:27 +0100760}
761
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200762static const char *sec_name(struct elf_info *elf, int secindex)
Sam Ravnborgff13f922008-01-23 19:54:27 +0100763{
764 Elf_Shdr *sechdrs = elf->sechdrs;
765 return (void *)elf->hdr +
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200766 elf->sechdrs[elf->secindex_strings].sh_offset +
767 sechdrs[secindex].sh_name;
Sam Ravnborgff13f922008-01-23 19:54:27 +0100768}
769
770static const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr)
771{
772 return (void *)elf->hdr +
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200773 elf->sechdrs[elf->secindex_strings].sh_offset +
774 sechdr->sh_name;
Sam Ravnborgff13f922008-01-23 19:54:27 +0100775}
776
Sam Ravnborg10668222008-01-13 22:21:31 +0100777/* The pattern is an array of simple patterns.
778 * "foo" will match an exact string equal to "foo"
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100779 * "*foo" will match a string that ends with "foo"
Sam Ravnborg10668222008-01-13 22:21:31 +0100780 * "foo*" will match a string that begins with "foo"
Paul Gortmaker09c20c02015-04-20 10:20:26 +0930781 * "*foo*" will match a string that contains "foo"
Sam Ravnborg10668222008-01-13 22:21:31 +0100782 */
Trevor Keith5c725132009-09-22 16:43:38 -0700783static int match(const char *sym, const char * const pat[])
Sam Ravnborg10668222008-01-13 22:21:31 +0100784{
785 const char *p;
786 while (*pat) {
787 p = *pat++;
788 const char *endp = p + strlen(p) - 1;
789
Paul Gortmaker09c20c02015-04-20 10:20:26 +0930790 /* "*foo*" */
791 if (*p == '*' && *endp == '*') {
792 char *here, *bare = strndup(p + 1, strlen(p) - 2);
793
794 here = strstr(sym, bare);
795 free(bare);
796 if (here != NULL)
797 return 1;
798 }
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100799 /* "*foo" */
Paul Gortmaker09c20c02015-04-20 10:20:26 +0930800 else if (*p == '*') {
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100801 if (strrcmp(sym, p + 1) == 0)
802 return 1;
803 }
Sam Ravnborg10668222008-01-13 22:21:31 +0100804 /* "foo*" */
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100805 else if (*endp == '*') {
Sam Ravnborg10668222008-01-13 22:21:31 +0100806 if (strncmp(sym, p, strlen(p) - 1) == 0)
807 return 1;
808 }
Sam Ravnborg10668222008-01-13 22:21:31 +0100809 /* no wildcards */
810 else {
811 if (strcmp(p, sym) == 0)
812 return 1;
813 }
814 }
815 /* no match */
816 return 0;
817}
818
Sam Ravnborg10668222008-01-13 22:21:31 +0100819/* sections that we do not want to do full section mismatch check on */
Mathias Krause7a3ee752014-08-27 20:28:53 +0930820static const char *const section_white_list[] =
Sam Ravnborg4391ed62009-05-04 13:05:26 +0200821{
822 ".comment*",
823 ".debug*",
Chen Gang4d10c222013-08-20 15:33:19 +0930824 ".cranges", /* sh64 */
H.J. Lu11215842010-12-15 17:11:22 -0800825 ".zdebug*", /* Compressed debug sections. */
David Howells019fca82010-08-12 16:54:47 +0100826 ".GCC-command-line", /* mn10300 */
Jonathan Kliegman76b27642012-10-04 16:32:19 -0400827 ".GCC.command.line", /* record-gcc-switches, non mn10300 */
Sam Ravnborg4391ed62009-05-04 13:05:26 +0200828 ".mdebug*", /* alpha, score, mips etc. */
829 ".pdr", /* alpha, score, mips etc. */
830 ".stab*",
831 ".note*",
832 ".got*",
833 ".toc*",
Max Filippovaf42e972012-09-17 05:44:38 +0400834 ".xt.prop", /* xtensa */
835 ".xt.lit", /* xtensa */
Vineet Guptaf2e207f2013-01-21 17:18:57 +1030836 ".arcextmap*", /* arc */
837 ".gnu.linkonce.arcext*", /* arc : modules */
Noam Camusd1189c62015-10-26 19:51:46 +1030838 ".cmem*", /* EZchip */
839 ".fmt_slot*", /* EZchip */
Andi Kleenef178f92014-02-08 09:01:17 +0100840 ".gnu.lto*",
Sam Ravnborg4391ed62009-05-04 13:05:26 +0200841 NULL
842};
Sam Ravnborg10668222008-01-13 22:21:31 +0100843
Sam Ravnborge241a632008-01-28 20:13:13 +0100844/*
Anders Kaseorgb614a692009-04-23 16:49:33 -0400845 * This is used to find sections missing the SHF_ALLOC flag.
Sam Ravnborge241a632008-01-28 20:13:13 +0100846 * The cause of this is often a section specified in assembler
Anders Kaseorgb614a692009-04-23 16:49:33 -0400847 * without "ax" / "aw".
Sam Ravnborge241a632008-01-28 20:13:13 +0100848 */
Anders Kaseorgb614a692009-04-23 16:49:33 -0400849static void check_section(const char *modname, struct elf_info *elf,
Masahiro Yamadabb66fc62014-06-10 19:08:13 +0900850 Elf_Shdr *sechdr)
Sam Ravnborge241a632008-01-28 20:13:13 +0100851{
Anders Kaseorgb614a692009-04-23 16:49:33 -0400852 const char *sec = sech_name(elf, sechdr);
Sam Ravnborge241a632008-01-28 20:13:13 +0100853
Anders Kaseorgb614a692009-04-23 16:49:33 -0400854 if (sechdr->sh_type == SHT_PROGBITS &&
855 !(sechdr->sh_flags & SHF_ALLOC) &&
856 !match(sec, section_white_list)) {
857 warn("%s (%s): unexpected non-allocatable section.\n"
858 "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
859 "Note that for example <linux/init.h> contains\n"
860 "section definitions for use in .S files.\n\n",
861 modname, sec);
Sam Ravnborge241a632008-01-28 20:13:13 +0100862 }
Sam Ravnborge241a632008-01-28 20:13:13 +0100863}
864
865
866
Sam Ravnborgeb8f6892008-01-20 20:07:28 +0100867#define ALL_INIT_DATA_SECTIONS \
Rasmus Villemoesa0d8f802014-07-27 07:28:01 +0930868 ".init.setup", ".init.rodata", ".meminit.rodata", \
869 ".init.data", ".meminit.data"
Sam Ravnborgeb8f6892008-01-20 20:07:28 +0100870#define ALL_EXIT_DATA_SECTIONS \
Rasmus Villemoesa0d8f802014-07-27 07:28:01 +0930871 ".exit.data", ".memexit.data"
Sam Ravnborg10668222008-01-13 22:21:31 +0100872
Sam Ravnborgeb8f6892008-01-20 20:07:28 +0100873#define ALL_INIT_TEXT_SECTIONS \
Rasmus Villemoesa0d8f802014-07-27 07:28:01 +0930874 ".init.text", ".meminit.text"
Sam Ravnborgeb8f6892008-01-20 20:07:28 +0100875#define ALL_EXIT_TEXT_SECTIONS \
Rasmus Villemoesa0d8f802014-07-27 07:28:01 +0930876 ".exit.text", ".memexit.text"
Sam Ravnborg10668222008-01-13 22:21:31 +0100877
Sebastian Andrzej Siewiorbb15d8d2012-06-03 20:48:17 +0200878#define ALL_PCI_INIT_SECTIONS \
Rasmus Villemoesa0d8f802014-07-27 07:28:01 +0930879 ".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
880 ".pci_fixup_enable", ".pci_fixup_resume", \
881 ".pci_fixup_resume_early", ".pci_fixup_suspend"
Sebastian Andrzej Siewiorbb15d8d2012-06-03 20:48:17 +0200882
Paul Gortmakere24f66282013-06-19 19:30:48 -0400883#define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS
884#define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS
Uwe Kleine-König4a31a222010-01-29 12:04:26 +0100885
886#define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
887#define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
Sam Ravnborg10668222008-01-13 22:21:31 +0100888
Rasmus Villemoesa0d8f802014-07-27 07:28:01 +0930889#define DATA_SECTIONS ".data", ".data.rel"
Quentin Casasnovas157d1972015-04-13 20:42:52 +0930890#define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \
891 ".kprobes.text"
Quentin Casasnovas52dc0592015-04-13 20:52:53 +0930892#define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
Chris Metcalf673c2c32015-07-08 17:07:41 -0400893 ".fixup", ".entry.text", ".exception.text", ".text.*", \
894 ".coldtext"
Sam Ravnborg10668222008-01-13 22:21:31 +0100895
Jan Beulichfd6c3a82009-03-12 10:58:33 +0000896#define INIT_SECTIONS ".init.*"
Jan Beulichfd6c3a82009-03-12 10:58:33 +0000897#define MEM_INIT_SECTIONS ".meminit.*"
Sam Ravnborgeb8f6892008-01-20 20:07:28 +0100898
Jan Beulichfd6c3a82009-03-12 10:58:33 +0000899#define EXIT_SECTIONS ".exit.*"
Jan Beulichfd6c3a82009-03-12 10:58:33 +0000900#define MEM_EXIT_SECTIONS ".memexit.*"
Sam Ravnborgeb8f6892008-01-20 20:07:28 +0100901
Quentin Casasnovas52dc0592015-04-13 20:52:53 +0930902#define ALL_TEXT_SECTIONS ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
903 TEXT_SECTIONS, OTHER_TEXT_SECTIONS
904
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100905/* init data sections */
Mathias Krause7a3ee752014-08-27 20:28:53 +0930906static const char *const init_data_sections[] =
907 { ALL_INIT_DATA_SECTIONS, NULL };
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100908
909/* all init sections */
Mathias Krause7a3ee752014-08-27 20:28:53 +0930910static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100911
912/* All init and exit sections (code + data) */
Mathias Krause7a3ee752014-08-27 20:28:53 +0930913static const char *const init_exit_sections[] =
Sam Ravnborgeb8f6892008-01-20 20:07:28 +0100914 {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100915
Paul Gortmaker4a3893d2015-04-20 10:20:40 +0930916/* all text sections */
917static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
918
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100919/* data section */
Mathias Krause7a3ee752014-08-27 20:28:53 +0930920static const char *const data_sections[] = { DATA_SECTIONS, NULL };
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100921
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100922
923/* symbols in .data that may refer to init/exit sections */
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +0100924#define DEFAULT_SYMBOL_WHITE_LIST \
925 "*driver", \
926 "*_template", /* scsi uses *_template a lot */ \
927 "*_timer", /* arm uses ops structures named _timer a lot */ \
928 "*_sht", /* scsi also used *_sht to some extent */ \
929 "*_ops", \
930 "*_probe", \
931 "*_probe_one", \
932 "*_console"
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100933
Mathias Krause7a3ee752014-08-27 20:28:53 +0930934static const char *const head_sections[] = { ".head.text*", NULL };
935static const char *const linker_symbols[] =
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100936 { "__init_begin", "_sinittext", "_einittext", NULL };
Paul Gortmaker4a3893d2015-04-20 10:20:40 +0930937static const char *const optim_symbols[] = { "*.constprop.*", NULL };
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100938
Sam Ravnborg588ccd72008-01-24 21:12:37 +0100939enum mismatch {
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +0100940 TEXT_TO_ANY_INIT,
941 DATA_TO_ANY_INIT,
942 TEXT_TO_ANY_EXIT,
943 DATA_TO_ANY_EXIT,
944 XXXINIT_TO_SOME_INIT,
945 XXXEXIT_TO_SOME_EXIT,
946 ANY_INIT_TO_ANY_EXIT,
947 ANY_EXIT_TO_ANY_INIT,
Sam Ravnborg588ccd72008-01-24 21:12:37 +0100948 EXPORT_TO_INIT_EXIT,
Quentin Casasnovas52dc0592015-04-13 20:52:53 +0930949 EXTABLE_TO_NON_TEXT,
Sam Ravnborg588ccd72008-01-24 21:12:37 +0100950};
951
Quentin Casasnovase5d8f592015-04-13 20:55:15 +0930952/**
953 * Describe how to match sections on different criterias:
954 *
955 * @fromsec: Array of sections to be matched.
956 *
957 * @bad_tosec: Relocations applied to a section in @fromsec to a section in
958 * this array is forbidden (black-list). Can be empty.
959 *
960 * @good_tosec: Relocations applied to a section in @fromsec must be
961 * targetting sections in this array (white-list). Can be empty.
962 *
963 * @mismatch: Type of mismatch.
964 *
965 * @symbol_white_list: Do not match a relocation to a symbol in this list
966 * even if it is targetting a section in @bad_to_sec.
967 *
968 * @handler: Specific handler to call when a match is found. If NULL,
969 * default_mismatch_handler() will be called.
970 *
971 */
Sam Ravnborg10668222008-01-13 22:21:31 +0100972struct sectioncheck {
973 const char *fromsec[20];
Quentin Casasnovas050e57f2015-04-13 20:41:04 +0930974 const char *bad_tosec[20];
975 const char *good_tosec[20];
Sam Ravnborg588ccd72008-01-24 21:12:37 +0100976 enum mismatch mismatch;
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +0100977 const char *symbol_white_list[20];
Quentin Casasnovas644e8f12015-04-13 20:43:17 +0930978 void (*handler)(const char *modname, struct elf_info *elf,
979 const struct sectioncheck* const mismatch,
980 Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
981
Sam Ravnborg10668222008-01-13 22:21:31 +0100982};
983
Quentin Casasnovas52dc0592015-04-13 20:52:53 +0930984static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
985 const struct sectioncheck* const mismatch,
986 Elf_Rela *r, Elf_Sym *sym,
987 const char *fromsec);
988
Mathias Krause7a3ee752014-08-27 20:28:53 +0930989static const struct sectioncheck sectioncheck[] = {
Sam Ravnborg10668222008-01-13 22:21:31 +0100990/* Do not reference init/exit code/data from
991 * normal code and data
992 */
993{
Sam Ravnborg588ccd72008-01-24 21:12:37 +0100994 .fromsec = { TEXT_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +0930995 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +0100996 .mismatch = TEXT_TO_ANY_INIT,
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +0100997 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
Sam Ravnborg588ccd72008-01-24 21:12:37 +0100998},
999{
1000 .fromsec = { DATA_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301001 .bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001002 .mismatch = DATA_TO_ANY_INIT,
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +01001003 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001004},
1005{
Uwe Kleine-König0db252452010-01-30 21:14:23 +01001006 .fromsec = { DATA_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301007 .bad_tosec = { INIT_SECTIONS, NULL },
Uwe Kleine-König0db252452010-01-30 21:14:23 +01001008 .mismatch = DATA_TO_ANY_INIT,
1009 .symbol_white_list = {
1010 "*_template", "*_timer", "*_sht", "*_ops",
1011 "*_probe", "*_probe_one", "*_console", NULL
1012 },
1013},
1014{
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001015 .fromsec = { TEXT_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301016 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001017 .mismatch = TEXT_TO_ANY_EXIT,
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +01001018 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001019},
1020{
1021 .fromsec = { DATA_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301022 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001023 .mismatch = DATA_TO_ANY_EXIT,
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +01001024 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
Sam Ravnborgeb8f6892008-01-20 20:07:28 +01001025},
Paul Gortmakere24f66282013-06-19 19:30:48 -04001026/* Do not reference init code/data from meminit code/data */
Sam Ravnborgeb8f6892008-01-20 20:07:28 +01001027{
Uwe Kleine-König4a31a222010-01-29 12:04:26 +01001028 .fromsec = { ALL_XXXINIT_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301029 .bad_tosec = { INIT_SECTIONS, NULL },
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001030 .mismatch = XXXINIT_TO_SOME_INIT,
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +01001031 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
Sam Ravnborgeb8f6892008-01-20 20:07:28 +01001032},
Paul Gortmakere24f66282013-06-19 19:30:48 -04001033/* Do not reference exit code/data from memexit code/data */
Sam Ravnborgeb8f6892008-01-20 20:07:28 +01001034{
Uwe Kleine-König4a31a222010-01-29 12:04:26 +01001035 .fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301036 .bad_tosec = { EXIT_SECTIONS, NULL },
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001037 .mismatch = XXXEXIT_TO_SOME_EXIT,
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +01001038 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
Sam Ravnborg10668222008-01-13 22:21:31 +01001039},
1040/* Do not use exit code/data from init code */
1041{
Sam Ravnborgeb8f6892008-01-20 20:07:28 +01001042 .fromsec = { ALL_INIT_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301043 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001044 .mismatch = ANY_INIT_TO_ANY_EXIT,
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +01001045 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
Sam Ravnborg10668222008-01-13 22:21:31 +01001046},
1047/* Do not use init code/data from exit code */
1048{
Sam Ravnborgeb8f6892008-01-20 20:07:28 +01001049 .fromsec = { ALL_EXIT_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301050 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001051 .mismatch = ANY_EXIT_TO_ANY_INIT,
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +01001052 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
Sam Ravnborg10668222008-01-13 22:21:31 +01001053},
Sebastian Andrzej Siewiorbb15d8d2012-06-03 20:48:17 +02001054{
1055 .fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301056 .bad_tosec = { INIT_SECTIONS, NULL },
Sebastian Andrzej Siewiorbb15d8d2012-06-03 20:48:17 +02001057 .mismatch = ANY_INIT_TO_ANY_EXIT,
1058 .symbol_white_list = { NULL },
1059},
Sam Ravnborg10668222008-01-13 22:21:31 +01001060/* Do not export init/exit functions or data */
1061{
1062 .fromsec = { "__ksymtab*", NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301063 .bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +01001064 .mismatch = EXPORT_TO_INIT_EXIT,
1065 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
Quentin Casasnovas52dc0592015-04-13 20:52:53 +09301066},
1067{
1068 .fromsec = { "__ex_table", NULL },
1069 /* If you're adding any new black-listed sections in here, consider
1070 * adding a special 'printer' for them in scripts/check_extable.
1071 */
1072 .bad_tosec = { ".altinstr_replacement", NULL },
1073 .good_tosec = {ALL_TEXT_SECTIONS , NULL},
1074 .mismatch = EXTABLE_TO_NON_TEXT,
1075 .handler = extable_mismatch_handler,
Sam Ravnborg10668222008-01-13 22:21:31 +01001076}
1077};
1078
Uwe Kleine-König0d2a6362010-01-30 16:56:20 +01001079static const struct sectioncheck *section_mismatch(
1080 const char *fromsec, const char *tosec)
Sam Ravnborg10668222008-01-13 22:21:31 +01001081{
1082 int i;
1083 int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
1084 const struct sectioncheck *check = &sectioncheck[0];
1085
Quentin Casasnovasc5c34392015-04-16 13:16:41 +09301086 /*
1087 * The target section could be the SHT_NUL section when we're
1088 * handling relocations to un-resolved symbols, trying to match it
1089 * doesn't make much sense and causes build failures on parisc and
1090 * mn10300 architectures.
1091 */
1092 if (*tosec == '\0')
1093 return NULL;
1094
Sam Ravnborg10668222008-01-13 22:21:31 +01001095 for (i = 0; i < elems; i++) {
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301096 if (match(fromsec, check->fromsec)) {
1097 if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
1098 return check;
1099 if (check->good_tosec[0] && !match(tosec, check->good_tosec))
1100 return check;
1101 }
Sam Ravnborg10668222008-01-13 22:21:31 +01001102 check++;
1103 }
Uwe Kleine-König0d2a6362010-01-30 16:56:20 +01001104 return NULL;
Sam Ravnborg10668222008-01-13 22:21:31 +01001105}
1106
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001107/**
1108 * Whitelist to allow certain references to pass with no warning.
Sam Ravnborg0e0d3142007-05-17 20:14:48 +02001109 *
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001110 * Pattern 1:
1111 * If a module parameter is declared __initdata and permissions=0
1112 * then this is legal despite the warning generated.
1113 * We cannot see value of permissions here, so just ignore
1114 * this pattern.
1115 * The pattern is identified by:
1116 * tosec = .init.data
Sam Ravnborg9209aed2006-03-05 00:16:26 +01001117 * fromsec = .data*
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001118 * atsym =__param*
Sam Ravnborg62070fa2006-03-03 16:46:04 +01001119 *
Rusty Russell6a841522010-08-11 23:04:16 -06001120 * Pattern 1a:
1121 * module_param_call() ops can refer to __init set function if permissions=0
1122 * The pattern is identified by:
1123 * tosec = .init.text
1124 * fromsec = .data*
1125 * atsym = __param_ops_*
1126 *
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001127 * Pattern 2:
Randy Dunlap72ee59b2006-04-15 11:17:12 -07001128 * Many drivers utilise a *driver container with references to
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001129 * add, remove, probe functions etc.
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001130 * the pattern is identified by:
Sam Ravnborg83cda2b2007-07-25 21:52:31 +02001131 * tosec = init or exit section
1132 * fromsec = data section
Sam Ravnborgdf578e72008-01-11 19:17:15 +01001133 * atsym = *driver, *_template, *_sht, *_ops, *_probe,
1134 * *probe_one, *_console, *_timer
Vivek Goyalee6a8542007-01-11 01:52:44 +01001135 *
1136 * Pattern 3:
Sam Ravnborgc9939712009-04-26 11:17:42 +02001137 * Whitelist all references from .head.text to any init section
Sam Ravnborg9bf8cb92007-02-26 17:49:06 +01001138 *
Sam Ravnborg1d8af552007-06-03 00:41:22 +02001139 * Pattern 4:
Vivek Goyalee6a8542007-01-11 01:52:44 +01001140 * Some symbols belong to init section but still it is ok to reference
1141 * these from non-init sections as these symbols don't have any memory
1142 * allocated for them and symbol address and value are same. So even
1143 * if init section is freed, its ok to reference those symbols.
1144 * For ex. symbols marking the init section boundaries.
1145 * This pattern is identified by
1146 * refsymname = __init_begin, _sinittext, _einittext
Sam Ravnborg9bf8cb92007-02-26 17:49:06 +01001147 *
Paul Gortmaker4a3893d2015-04-20 10:20:40 +09301148 * Pattern 5:
1149 * GCC may optimize static inlines when fed constant arg(s) resulting
1150 * in functions like cpumask_empty() -- generating an associated symbol
1151 * cpumask_empty.constprop.3 that appears in the audit. If the const that
1152 * is passed in comes from __init, like say nmi_ipi_mask, we get a
1153 * meaningless section warning. May need to add isra symbols too...
1154 * This pattern is identified by
1155 * tosec = init section
1156 * fromsec = text section
1157 * refsymname = *.constprop.*
1158 *
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001159 **/
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +01001160static int secref_whitelist(const struct sectioncheck *mismatch,
1161 const char *fromsec, const char *fromsym,
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001162 const char *tosec, const char *tosym)
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001163{
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001164 /* Check for pattern 1 */
Sam Ravnborg6c5bd232008-01-20 10:43:27 +01001165 if (match(tosec, init_data_sections) &&
1166 match(fromsec, data_sections) &&
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001167 (strncmp(fromsym, "__param", strlen("__param")) == 0))
1168 return 0;
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001169
Rusty Russell6a841522010-08-11 23:04:16 -06001170 /* Check for pattern 1a */
1171 if (strcmp(tosec, ".init.text") == 0 &&
1172 match(fromsec, data_sections) &&
1173 (strncmp(fromsym, "__param_ops_", strlen("__param_ops_")) == 0))
1174 return 0;
1175
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001176 /* Check for pattern 2 */
Sam Ravnborg6c5bd232008-01-20 10:43:27 +01001177 if (match(tosec, init_exit_sections) &&
1178 match(fromsec, data_sections) &&
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +01001179 match(fromsym, mismatch->symbol_white_list))
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001180 return 0;
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001181
Sam Ravnborg9bf8cb92007-02-26 17:49:06 +01001182 /* Check for pattern 3 */
Sam Ravnborg6c5bd232008-01-20 10:43:27 +01001183 if (match(fromsec, head_sections) &&
1184 match(tosec, init_sections))
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001185 return 0;
Sam Ravnborg9bf8cb92007-02-26 17:49:06 +01001186
Sam Ravnborg1d8af552007-06-03 00:41:22 +02001187 /* Check for pattern 4 */
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001188 if (match(tosym, linker_symbols))
1189 return 0;
Sam Ravnborg9bf8cb92007-02-26 17:49:06 +01001190
Paul Gortmaker4a3893d2015-04-20 10:20:40 +09301191 /* Check for pattern 5 */
1192 if (match(fromsec, text_sections) &&
1193 match(tosec, init_sections) &&
1194 match(fromsym, optim_symbols))
1195 return 0;
1196
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001197 return 1;
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001198}
1199
1200/**
Sam Ravnborg93684d32006-02-19 11:53:35 +01001201 * Find symbol based on relocation record info.
1202 * In some cases the symbol supplied is a valid symbol so
1203 * return refsym. If st_name != 0 we assume this is a valid symbol.
1204 * In other cases the symbol needs to be looked up in the symbol table
1205 * based on section and address.
1206 * **/
Sam Ravnborg9ad21c32008-01-18 21:04:34 +01001207static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
Sam Ravnborg93684d32006-02-19 11:53:35 +01001208 Elf_Sym *relsym)
1209{
1210 Elf_Sym *sym;
Sam Ravnborg9ad21c32008-01-18 21:04:34 +01001211 Elf_Sym *near = NULL;
1212 Elf64_Sword distance = 20;
1213 Elf64_Sword d;
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +02001214 unsigned int relsym_secindex;
Sam Ravnborg93684d32006-02-19 11:53:35 +01001215
1216 if (relsym->st_name != 0)
1217 return relsym;
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +02001218
1219 relsym_secindex = get_secindex(elf, relsym);
Sam Ravnborg93684d32006-02-19 11:53:35 +01001220 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +02001221 if (get_secindex(elf, sym) != relsym_secindex)
Sam Ravnborg93684d32006-02-19 11:53:35 +01001222 continue;
Atsushi Nemotoae4ac122007-05-22 18:27:39 +09001223 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1224 continue;
Sam Ravnborg93684d32006-02-19 11:53:35 +01001225 if (sym->st_value == addr)
1226 return sym;
Sam Ravnborg9ad21c32008-01-18 21:04:34 +01001227 /* Find a symbol nearby - addr are maybe negative */
1228 d = sym->st_value - addr;
1229 if (d < 0)
1230 d = addr - sym->st_value;
1231 if (d < distance) {
1232 distance = d;
1233 near = sym;
1234 }
Sam Ravnborg93684d32006-02-19 11:53:35 +01001235 }
Sam Ravnborg9ad21c32008-01-18 21:04:34 +01001236 /* We need a close match */
1237 if (distance < 20)
1238 return near;
1239 else
1240 return NULL;
Sam Ravnborg93684d32006-02-19 11:53:35 +01001241}
1242
David Brownellda68d612007-02-20 13:58:16 -08001243static inline int is_arm_mapping_symbol(const char *str)
1244{
Kyle McMartin6c34f1f2014-09-16 22:37:18 +01001245 return str[0] == '$' && strchr("axtd", str[1])
David Brownellda68d612007-02-20 13:58:16 -08001246 && (str[2] == '\0' || str[2] == '.');
1247}
1248
1249/*
1250 * If there's no name there, ignore it; likewise, ignore it if it's
1251 * one of the magic symbols emitted used by current ARM tools.
1252 *
1253 * Otherwise if find_symbols_between() returns those symbols, they'll
1254 * fail the whitelist tests and cause lots of false alarms ... fixable
1255 * only by merging __exit and __init sections into __text, bloating
1256 * the kernel (which is especially evil on embedded platforms).
1257 */
1258static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1259{
1260 const char *name = elf->strtab + sym->st_name;
1261
1262 if (!name || !strlen(name))
1263 return 0;
1264 return !is_arm_mapping_symbol(name);
1265}
1266
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001267/*
Sam Ravnborg43c74d12006-03-05 12:02:46 +01001268 * Find symbols before or equal addr and after addr - in the section sec.
1269 * If we find two symbols with equal offset prefer one with a valid name.
1270 * The ELF format may have a better way to detect what type of symbol
1271 * it is, but this works for now.
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001272 **/
Sam Ravnborg157c23c2008-01-22 21:44:32 +01001273static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1274 const char *sec)
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001275{
1276 Elf_Sym *sym;
Sam Ravnborg157c23c2008-01-22 21:44:32 +01001277 Elf_Sym *near = NULL;
Sam Ravnborg157c23c2008-01-22 21:44:32 +01001278 Elf_Addr distance = ~0;
Sam Ravnborg62070fa2006-03-03 16:46:04 +01001279
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001280 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1281 const char *symsec;
1282
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +02001283 if (is_shndx_special(sym->st_shndx))
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001284 continue;
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +02001285 symsec = sec_name(elf, get_secindex(elf, sym));
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001286 if (strcmp(symsec, sec) != 0)
1287 continue;
David Brownellda68d612007-02-20 13:58:16 -08001288 if (!is_valid_name(elf, sym))
1289 continue;
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001290 if (sym->st_value <= addr) {
Sam Ravnborg157c23c2008-01-22 21:44:32 +01001291 if ((addr - sym->st_value) < distance) {
1292 distance = addr - sym->st_value;
1293 near = sym;
1294 } else if ((addr - sym->st_value) == distance) {
1295 near = sym;
Sam Ravnborg43c74d12006-03-05 12:02:46 +01001296 }
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001297 }
1298 }
Sam Ravnborg157c23c2008-01-22 21:44:32 +01001299 return near;
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001300}
1301
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001302/*
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001303 * Convert a section name to the function/data attribute
1304 * .init.text => __init
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001305 * .memexitconst => __memconst
1306 * etc.
Andy Shevchenkocbcf14a92010-08-17 13:36:40 +03001307 *
1308 * The memory of returned value has been allocated on a heap. The user of this
1309 * method should free it after usage.
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001310*/
1311static char *sec2annotation(const char *s)
1312{
1313 if (match(s, init_exit_sections)) {
1314 char *p = malloc(20);
1315 char *r = p;
1316
1317 *p++ = '_';
1318 *p++ = '_';
1319 if (*s == '.')
1320 s++;
1321 while (*s && *s != '.')
1322 *p++ = *s++;
1323 *p = '\0';
1324 if (*s == '.')
1325 s++;
1326 if (strstr(s, "rodata") != NULL)
1327 strcat(p, "const ");
1328 else if (strstr(s, "data") != NULL)
1329 strcat(p, "data ");
1330 else
1331 strcat(p, " ");
Andy Shevchenkocbcf14a92010-08-17 13:36:40 +03001332 return r;
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001333 } else {
Andrew Morton5003bab2010-08-11 00:42:26 -07001334 return strdup("");
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001335 }
1336}
1337
1338static int is_function(Elf_Sym *sym)
1339{
1340 if (sym)
1341 return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1342 else
Sam Ravnborgf6667512008-02-06 21:51:18 +01001343 return -1;
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001344}
1345
Randy Dunlap00759c0e2011-03-15 14:13:47 -07001346static void print_section_list(const char * const list[20])
1347{
1348 const char *const *s = list;
1349
1350 while (*s) {
1351 fprintf(stderr, "%s", *s);
1352 s++;
1353 if (*s)
1354 fprintf(stderr, ", ");
1355 }
1356 fprintf(stderr, "\n");
1357}
1358
Quentin Casasnovas356ad532015-04-13 20:43:34 +09301359static inline void get_pretty_name(int is_func, const char** name, const char** name_p)
1360{
1361 switch (is_func) {
1362 case 0: *name = "variable"; *name_p = ""; break;
1363 case 1: *name = "function"; *name_p = "()"; break;
1364 default: *name = "(unknown reference)"; *name_p = ""; break;
1365 }
1366}
1367
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001368/*
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001369 * Print a warning about a section mismatch.
1370 * Try to find symbols near it so user can find it.
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001371 * Check whitelist before warning - it may be a false positive.
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001372 */
Uwe Kleine-König0d2a6362010-01-30 16:56:20 +01001373static void report_sec_mismatch(const char *modname,
1374 const struct sectioncheck *mismatch,
Masahiro Yamadabb66fc62014-06-10 19:08:13 +09001375 const char *fromsec,
1376 unsigned long long fromaddr,
1377 const char *fromsym,
1378 int from_is_func,
1379 const char *tosec, const char *tosym,
1380 int to_is_func)
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001381{
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001382 const char *from, *from_p;
1383 const char *to, *to_p;
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001384 char *prl_from;
1385 char *prl_to;
Sam Ravnborgf6667512008-02-06 21:51:18 +01001386
Sam Ravnborge5f95c82008-02-02 18:57:18 +01001387 sec_mismatch_count++;
1388 if (!sec_mismatch_verbose)
1389 return;
1390
Quentin Casasnovas356ad532015-04-13 20:43:34 +09301391 get_pretty_name(from_is_func, &from, &from_p);
1392 get_pretty_name(to_is_func, &to, &to_p);
1393
Geert Uytterhoeven7c0ac492008-02-05 11:38:49 +01001394 warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1395 "to the %s %s:%s%s\n",
1396 modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
1397 tosym, to_p);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001398
Uwe Kleine-König0d2a6362010-01-30 16:56:20 +01001399 switch (mismatch->mismatch) {
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001400 case TEXT_TO_ANY_INIT:
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001401 prl_from = sec2annotation(fromsec);
1402 prl_to = sec2annotation(tosec);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001403 fprintf(stderr,
Sam Ravnborgf6667512008-02-06 21:51:18 +01001404 "The function %s%s() references\n"
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001405 "the %s %s%s%s.\n"
1406 "This is often because %s lacks a %s\n"
1407 "annotation or the annotation of %s is wrong.\n",
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001408 prl_from, fromsym,
1409 to, prl_to, tosym, to_p,
1410 fromsym, prl_to, tosym);
1411 free(prl_from);
1412 free(prl_to);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001413 break;
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001414 case DATA_TO_ANY_INIT: {
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001415 prl_to = sec2annotation(tosec);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001416 fprintf(stderr,
1417 "The variable %s references\n"
1418 "the %s %s%s%s\n"
1419 "If the reference is valid then annotate the\n"
Sam Ravnborg8b8b76c2009-06-06 00:18:05 +02001420 "variable with __init* or __refdata (see linux/init.h) "
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001421 "or name the variable:\n",
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001422 fromsym, to, prl_to, tosym, to_p);
Randy Dunlap00759c0e2011-03-15 14:13:47 -07001423 print_section_list(mismatch->symbol_white_list);
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001424 free(prl_to);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001425 break;
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001426 }
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001427 case TEXT_TO_ANY_EXIT:
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001428 prl_to = sec2annotation(tosec);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001429 fprintf(stderr,
1430 "The function %s() references a %s in an exit section.\n"
1431 "Often the %s %s%s has valid usage outside the exit section\n"
1432 "and the fix is to remove the %sannotation of %s.\n",
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001433 fromsym, to, to, tosym, to_p, prl_to, tosym);
1434 free(prl_to);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001435 break;
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001436 case DATA_TO_ANY_EXIT: {
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001437 prl_to = sec2annotation(tosec);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001438 fprintf(stderr,
1439 "The variable %s references\n"
1440 "the %s %s%s%s\n"
1441 "If the reference is valid then annotate the\n"
1442 "variable with __exit* (see linux/init.h) or "
1443 "name the variable:\n",
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001444 fromsym, to, prl_to, tosym, to_p);
Randy Dunlap00759c0e2011-03-15 14:13:47 -07001445 print_section_list(mismatch->symbol_white_list);
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001446 free(prl_to);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001447 break;
1448 }
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001449 case XXXINIT_TO_SOME_INIT:
1450 case XXXEXIT_TO_SOME_EXIT:
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001451 prl_from = sec2annotation(fromsec);
1452 prl_to = sec2annotation(tosec);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001453 fprintf(stderr,
1454 "The %s %s%s%s references\n"
1455 "a %s %s%s%s.\n"
1456 "If %s is only used by %s then\n"
1457 "annotate %s with a matching annotation.\n",
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001458 from, prl_from, fromsym, from_p,
1459 to, prl_to, tosym, to_p,
Geert Uytterhoevenb1d26752008-02-17 14:12:10 +01001460 tosym, fromsym, tosym);
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001461 free(prl_from);
1462 free(prl_to);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001463 break;
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001464 case ANY_INIT_TO_ANY_EXIT:
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001465 prl_from = sec2annotation(fromsec);
1466 prl_to = sec2annotation(tosec);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001467 fprintf(stderr,
1468 "The %s %s%s%s references\n"
1469 "a %s %s%s%s.\n"
1470 "This is often seen when error handling "
1471 "in the init function\n"
1472 "uses functionality in the exit path.\n"
1473 "The fix is often to remove the %sannotation of\n"
1474 "%s%s so it may be used outside an exit section.\n",
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001475 from, prl_from, fromsym, from_p,
1476 to, prl_to, tosym, to_p,
Andrew Morton5003bab2010-08-11 00:42:26 -07001477 prl_to, tosym, to_p);
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001478 free(prl_from);
1479 free(prl_to);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001480 break;
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001481 case ANY_EXIT_TO_ANY_INIT:
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001482 prl_from = sec2annotation(fromsec);
1483 prl_to = sec2annotation(tosec);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001484 fprintf(stderr,
1485 "The %s %s%s%s references\n"
1486 "a %s %s%s%s.\n"
1487 "This is often seen when error handling "
1488 "in the exit function\n"
1489 "uses functionality in the init path.\n"
1490 "The fix is often to remove the %sannotation of\n"
1491 "%s%s so it may be used outside an init section.\n",
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001492 from, prl_from, fromsym, from_p,
1493 to, prl_to, tosym, to_p,
1494 prl_to, tosym, to_p);
1495 free(prl_from);
1496 free(prl_to);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001497 break;
1498 case EXPORT_TO_INIT_EXIT:
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001499 prl_to = sec2annotation(tosec);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001500 fprintf(stderr,
1501 "The symbol %s is exported and annotated %s\n"
1502 "Fix this by removing the %sannotation of %s "
1503 "or drop the export.\n",
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001504 tosym, prl_to, prl_to, tosym);
1505 free(prl_to);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001506 break;
Quentin Casasnovas52dc0592015-04-13 20:52:53 +09301507 case EXTABLE_TO_NON_TEXT:
1508 fatal("There's a special handler for this mismatch type, "
1509 "we should never get here.");
1510 break;
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001511 }
1512 fprintf(stderr, "\n");
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001513}
1514
Quentin Casasnovas644e8f12015-04-13 20:43:17 +09301515static void default_mismatch_handler(const char *modname, struct elf_info *elf,
1516 const struct sectioncheck* const mismatch,
1517 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1518{
1519 const char *tosec;
1520 Elf_Sym *to;
1521 Elf_Sym *from;
1522 const char *tosym;
1523 const char *fromsym;
1524
Quentin Casasnovas644e8f12015-04-13 20:43:17 +09301525 from = find_elf_symbol2(elf, r->r_offset, fromsec);
1526 fromsym = sym_name(elf, from);
Quentin Casasnovas644e8f12015-04-13 20:43:17 +09301527
1528 if (!strncmp(fromsym, "reference___initcall",
1529 sizeof("reference___initcall")-1))
1530 return;
1531
Quentin Casasnovasc7a65e02015-04-13 20:43:45 +09301532 tosec = sec_name(elf, get_secindex(elf, sym));
1533 to = find_elf_symbol(elf, r->r_addend, sym);
1534 tosym = sym_name(elf, to);
1535
Quentin Casasnovas644e8f12015-04-13 20:43:17 +09301536 /* check whitelist - we may ignore it */
1537 if (secref_whitelist(mismatch,
1538 fromsec, fromsym, tosec, tosym)) {
1539 report_sec_mismatch(modname, mismatch,
1540 fromsec, r->r_offset, fromsym,
1541 is_function(from), tosec, tosym,
1542 is_function(to));
1543 }
1544}
1545
Quentin Casasnovas52dc0592015-04-13 20:52:53 +09301546static int is_executable_section(struct elf_info* elf, unsigned int section_index)
1547{
1548 if (section_index > elf->num_sections)
1549 fatal("section_index is outside elf->num_sections!\n");
1550
1551 return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR);
1552}
1553
1554/*
1555 * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
1556 * to know the sizeof(struct exception_table_entry) for the target architecture.
1557 */
1558static unsigned int extable_entry_size = 0;
Quentin Casasnovase84048a2015-04-16 13:05:36 +09301559static void find_extable_entry_size(const char* const sec, const Elf_Rela* r)
Quentin Casasnovas52dc0592015-04-13 20:52:53 +09301560{
1561 /*
1562 * If we're currently checking the second relocation within __ex_table,
1563 * that relocation offset tells us the offsetof(struct
1564 * exception_table_entry, fixup) which is equal to sizeof(struct
1565 * exception_table_entry) divided by two. We use that to our advantage
1566 * since there's no portable way to get that size as every architecture
1567 * seems to go with different sized types. Not pretty but better than
1568 * hard-coding the size for every architecture..
1569 */
Quentin Casasnovase84048a2015-04-16 13:05:36 +09301570 if (!extable_entry_size)
Quentin Casasnovas52dc0592015-04-13 20:52:53 +09301571 extable_entry_size = r->r_offset * 2;
1572}
Quentin Casasnovase84048a2015-04-16 13:05:36 +09301573
Quentin Casasnovas52dc0592015-04-13 20:52:53 +09301574static inline bool is_extable_fault_address(Elf_Rela *r)
1575{
Quentin Casasnovasd3df4de2015-04-16 13:03:32 +09301576 /*
1577 * extable_entry_size is only discovered after we've handled the
1578 * _second_ relocation in __ex_table, so only abort when we're not
1579 * handling the first reloc and extable_entry_size is zero.
1580 */
1581 if (r->r_offset && extable_entry_size == 0)
Quentin Casasnovas52dc0592015-04-13 20:52:53 +09301582 fatal("extable_entry size hasn't been discovered!\n");
1583
1584 return ((r->r_offset == 0) ||
1585 (r->r_offset % extable_entry_size == 0));
1586}
1587
Quentin Casasnovase84048a2015-04-16 13:05:36 +09301588#define is_second_extable_reloc(Start, Cur, Sec) \
1589 (((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
1590
Quentin Casasnovas52dc0592015-04-13 20:52:53 +09301591static void report_extable_warnings(const char* modname, struct elf_info* elf,
1592 const struct sectioncheck* const mismatch,
1593 Elf_Rela* r, Elf_Sym* sym,
1594 const char* fromsec, const char* tosec)
1595{
1596 Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec);
1597 const char* fromsym_name = sym_name(elf, fromsym);
1598 Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym);
1599 const char* tosym_name = sym_name(elf, tosym);
1600 const char* from_pretty_name;
1601 const char* from_pretty_name_p;
1602 const char* to_pretty_name;
1603 const char* to_pretty_name_p;
1604
1605 get_pretty_name(is_function(fromsym),
1606 &from_pretty_name, &from_pretty_name_p);
1607 get_pretty_name(is_function(tosym),
1608 &to_pretty_name, &to_pretty_name_p);
1609
1610 warn("%s(%s+0x%lx): Section mismatch in reference"
1611 " from the %s %s%s to the %s %s:%s%s\n",
1612 modname, fromsec, (long)r->r_offset, from_pretty_name,
1613 fromsym_name, from_pretty_name_p,
1614 to_pretty_name, tosec, tosym_name, to_pretty_name_p);
1615
1616 if (!match(tosec, mismatch->bad_tosec) &&
1617 is_executable_section(elf, get_secindex(elf, sym)))
1618 fprintf(stderr,
1619 "The relocation at %s+0x%lx references\n"
1620 "section \"%s\" which is not in the list of\n"
1621 "authorized sections. If you're adding a new section\n"
1622 "and/or if this reference is valid, add \"%s\" to the\n"
1623 "list of authorized sections to jump to on fault.\n"
1624 "This can be achieved by adding \"%s\" to \n"
1625 "OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1626 fromsec, (long)r->r_offset, tosec, tosec, tosec);
1627}
1628
1629static void extable_mismatch_handler(const char* modname, struct elf_info *elf,
1630 const struct sectioncheck* const mismatch,
1631 Elf_Rela* r, Elf_Sym* sym,
1632 const char *fromsec)
1633{
1634 const char* tosec = sec_name(elf, get_secindex(elf, sym));
1635
1636 sec_mismatch_count++;
1637
1638 if (sec_mismatch_verbose)
1639 report_extable_warnings(modname, elf, mismatch, r, sym,
1640 fromsec, tosec);
1641
1642 if (match(tosec, mismatch->bad_tosec))
1643 fatal("The relocation at %s+0x%lx references\n"
1644 "section \"%s\" which is black-listed.\n"
1645 "Something is seriously wrong and should be fixed.\n"
1646 "You might get more information about where this is\n"
1647 "coming from by using scripts/check_extable.sh %s\n",
1648 fromsec, (long)r->r_offset, tosec, modname);
1649 else if (!is_executable_section(elf, get_secindex(elf, sym))) {
1650 if (is_extable_fault_address(r))
1651 fatal("The relocation at %s+0x%lx references\n"
1652 "section \"%s\" which is not executable, IOW\n"
1653 "it is not possible for the kernel to fault\n"
1654 "at that address. Something is seriously wrong\n"
1655 "and should be fixed.\n",
1656 fromsec, (long)r->r_offset, tosec);
1657 else
1658 fatal("The relocation at %s+0x%lx references\n"
1659 "section \"%s\" which is not executable, IOW\n"
1660 "the kernel will fault if it ever tries to\n"
1661 "jump to it. Something is seriously wrong\n"
1662 "and should be fixed.\n",
1663 fromsec, (long)r->r_offset, tosec);
1664 }
1665}
1666
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001667static void check_section_mismatch(const char *modname, struct elf_info *elf,
Masahiro Yamadabb66fc62014-06-10 19:08:13 +09001668 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001669{
Quentin Casasnovas644e8f12015-04-13 20:43:17 +09301670 const char *tosec = sec_name(elf, get_secindex(elf, sym));;
1671 const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec);
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001672
Uwe Kleine-König0d2a6362010-01-30 16:56:20 +01001673 if (mismatch) {
Quentin Casasnovas644e8f12015-04-13 20:43:17 +09301674 if (mismatch->handler)
1675 mismatch->handler(modname, elf, mismatch,
1676 r, sym, fromsec);
1677 else
1678 default_mismatch_handler(modname, elf, mismatch,
1679 r, sym, fromsec);
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001680 }
1681}
1682
Atsushi Nemotoae4ac122007-05-22 18:27:39 +09001683static unsigned int *reloc_location(struct elf_info *elf,
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001684 Elf_Shdr *sechdr, Elf_Rela *r)
Atsushi Nemotoae4ac122007-05-22 18:27:39 +09001685{
1686 Elf_Shdr *sechdrs = elf->sechdrs;
Anders Kaseorg68457562011-05-19 16:55:27 -06001687 int section = sechdr->sh_info;
Atsushi Nemotoae4ac122007-05-22 18:27:39 +09001688
1689 return (void *)elf->hdr + sechdrs[section].sh_offset +
Olof Johansson731ece42010-12-10 02:09:23 -06001690 r->r_offset;
Atsushi Nemotoae4ac122007-05-22 18:27:39 +09001691}
1692
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001693static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
Atsushi Nemotoae4ac122007-05-22 18:27:39 +09001694{
1695 unsigned int r_typ = ELF_R_TYPE(r->r_info);
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001696 unsigned int *location = reloc_location(elf, sechdr, r);
Atsushi Nemotoae4ac122007-05-22 18:27:39 +09001697
1698 switch (r_typ) {
1699 case R_386_32:
1700 r->r_addend = TO_NATIVE(*location);
1701 break;
1702 case R_386_PC32:
1703 r->r_addend = TO_NATIVE(*location) + 4;
1704 /* For CONFIG_RELOCATABLE=y */
1705 if (elf->hdr->e_type == ET_EXEC)
1706 r->r_addend += r->r_offset;
1707 break;
1708 }
1709 return 0;
1710}
1711
Tony Lindgren6e2e3402012-02-14 21:58:56 +01001712#ifndef R_ARM_CALL
1713#define R_ARM_CALL 28
1714#endif
1715#ifndef R_ARM_JUMP24
1716#define R_ARM_JUMP24 29
1717#endif
1718
David A. Longc9698e52014-02-14 22:41:18 +01001719#ifndef R_ARM_THM_CALL
1720#define R_ARM_THM_CALL 10
1721#endif
1722#ifndef R_ARM_THM_JUMP24
1723#define R_ARM_THM_JUMP24 30
1724#endif
1725#ifndef R_ARM_THM_JUMP19
1726#define R_ARM_THM_JUMP19 51
1727#endif
1728
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001729static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
Sam Ravnborg56a974f2007-07-16 22:39:35 +02001730{
1731 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1732
1733 switch (r_typ) {
1734 case R_ARM_ABS32:
1735 /* From ARM ABI: (S + A) | T */
Sam Ravnborgdf578e72008-01-11 19:17:15 +01001736 r->r_addend = (int)(long)
Masahiro Yamadabb66fc62014-06-10 19:08:13 +09001737 (elf->symtab_start + ELF_R_SYM(r->r_info));
Sam Ravnborg56a974f2007-07-16 22:39:35 +02001738 break;
1739 case R_ARM_PC24:
Tony Lindgren6e2e3402012-02-14 21:58:56 +01001740 case R_ARM_CALL:
1741 case R_ARM_JUMP24:
David A. Longc9698e52014-02-14 22:41:18 +01001742 case R_ARM_THM_CALL:
1743 case R_ARM_THM_JUMP24:
1744 case R_ARM_THM_JUMP19:
Sam Ravnborg56a974f2007-07-16 22:39:35 +02001745 /* From ARM ABI: ((S + A) | T) - P */
Sam Ravnborgdf578e72008-01-11 19:17:15 +01001746 r->r_addend = (int)(long)(elf->hdr +
Masahiro Yamadabb66fc62014-06-10 19:08:13 +09001747 sechdr->sh_offset +
1748 (r->r_offset - sechdr->sh_addr));
Sam Ravnborg56a974f2007-07-16 22:39:35 +02001749 break;
1750 default:
1751 return 1;
1752 }
1753 return 0;
1754}
1755
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001756static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
Atsushi Nemotoae4ac122007-05-22 18:27:39 +09001757{
1758 unsigned int r_typ = ELF_R_TYPE(r->r_info);
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001759 unsigned int *location = reloc_location(elf, sechdr, r);
Atsushi Nemotoae4ac122007-05-22 18:27:39 +09001760 unsigned int inst;
1761
1762 if (r_typ == R_MIPS_HI16)
1763 return 1; /* skip this */
1764 inst = TO_NATIVE(*location);
1765 switch (r_typ) {
1766 case R_MIPS_LO16:
1767 r->r_addend = inst & 0xffff;
1768 break;
1769 case R_MIPS_26:
1770 r->r_addend = (inst & 0x03ffffff) << 2;
1771 break;
1772 case R_MIPS_32:
1773 r->r_addend = inst;
1774 break;
1775 }
1776 return 0;
1777}
1778
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001779static void section_rela(const char *modname, struct elf_info *elf,
Masahiro Yamadabb66fc62014-06-10 19:08:13 +09001780 Elf_Shdr *sechdr)
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001781{
1782 Elf_Sym *sym;
1783 Elf_Rela *rela;
1784 Elf_Rela r;
1785 unsigned int r_sym;
1786 const char *fromsec;
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001787
Sam Ravnborgff13f922008-01-23 19:54:27 +01001788 Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001789 Elf_Rela *stop = (void *)start + sechdr->sh_size;
1790
Sam Ravnborgff13f922008-01-23 19:54:27 +01001791 fromsec = sech_name(elf, sechdr);
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001792 fromsec += strlen(".rela");
1793 /* if from section (name) is know good then skip it */
Anders Kaseorgb614a692009-04-23 16:49:33 -04001794 if (match(fromsec, section_white_list))
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001795 return;
Sam Ravnborge241a632008-01-28 20:13:13 +01001796
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001797 for (rela = start; rela < stop; rela++) {
1798 r.r_offset = TO_NATIVE(rela->r_offset);
1799#if KERNEL_ELFCLASS == ELFCLASS64
Sam Ravnborgff13f922008-01-23 19:54:27 +01001800 if (elf->hdr->e_machine == EM_MIPS) {
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001801 unsigned int r_typ;
1802 r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1803 r_sym = TO_NATIVE(r_sym);
1804 r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1805 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1806 } else {
1807 r.r_info = TO_NATIVE(rela->r_info);
1808 r_sym = ELF_R_SYM(r.r_info);
1809 }
1810#else
1811 r.r_info = TO_NATIVE(rela->r_info);
1812 r_sym = ELF_R_SYM(r.r_info);
1813#endif
1814 r.r_addend = TO_NATIVE(rela->r_addend);
1815 sym = elf->symtab_start + r_sym;
1816 /* Skip special sections */
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +02001817 if (is_shndx_special(sym->st_shndx))
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001818 continue;
Quentin Casasnovase84048a2015-04-16 13:05:36 +09301819 if (is_second_extable_reloc(start, rela, fromsec))
1820 find_extable_entry_size(fromsec, &r);
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001821 check_section_mismatch(modname, elf, &r, sym, fromsec);
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001822 }
1823}
1824
1825static void section_rel(const char *modname, struct elf_info *elf,
Masahiro Yamadabb66fc62014-06-10 19:08:13 +09001826 Elf_Shdr *sechdr)
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001827{
1828 Elf_Sym *sym;
1829 Elf_Rel *rel;
1830 Elf_Rela r;
1831 unsigned int r_sym;
1832 const char *fromsec;
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001833
Sam Ravnborgff13f922008-01-23 19:54:27 +01001834 Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001835 Elf_Rel *stop = (void *)start + sechdr->sh_size;
1836
Sam Ravnborgff13f922008-01-23 19:54:27 +01001837 fromsec = sech_name(elf, sechdr);
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001838 fromsec += strlen(".rel");
1839 /* if from section (name) is know good then skip it */
Anders Kaseorgb614a692009-04-23 16:49:33 -04001840 if (match(fromsec, section_white_list))
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001841 return;
1842
1843 for (rel = start; rel < stop; rel++) {
1844 r.r_offset = TO_NATIVE(rel->r_offset);
1845#if KERNEL_ELFCLASS == ELFCLASS64
Sam Ravnborgff13f922008-01-23 19:54:27 +01001846 if (elf->hdr->e_machine == EM_MIPS) {
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001847 unsigned int r_typ;
1848 r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1849 r_sym = TO_NATIVE(r_sym);
1850 r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1851 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1852 } else {
1853 r.r_info = TO_NATIVE(rel->r_info);
1854 r_sym = ELF_R_SYM(r.r_info);
1855 }
1856#else
1857 r.r_info = TO_NATIVE(rel->r_info);
1858 r_sym = ELF_R_SYM(r.r_info);
1859#endif
1860 r.r_addend = 0;
Sam Ravnborgff13f922008-01-23 19:54:27 +01001861 switch (elf->hdr->e_machine) {
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001862 case EM_386:
1863 if (addend_386_rel(elf, sechdr, &r))
1864 continue;
1865 break;
1866 case EM_ARM:
1867 if (addend_arm_rel(elf, sechdr, &r))
1868 continue;
1869 break;
1870 case EM_MIPS:
1871 if (addend_mips_rel(elf, sechdr, &r))
1872 continue;
1873 break;
1874 }
1875 sym = elf->symtab_start + r_sym;
1876 /* Skip special sections */
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +02001877 if (is_shndx_special(sym->st_shndx))
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001878 continue;
Quentin Casasnovase84048a2015-04-16 13:05:36 +09301879 if (is_second_extable_reloc(start, rel, fromsec))
1880 find_extable_entry_size(fromsec, &r);
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001881 check_section_mismatch(modname, elf, &r, sym, fromsec);
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001882 }
1883}
1884
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001885/**
1886 * A module includes a number of sections that are discarded
1887 * either when loaded or when used as built-in.
1888 * For loaded modules all functions marked __init and all data
Uwe Kleine-Königb5950762010-11-01 15:38:34 -04001889 * marked __initdata will be discarded when the module has been initialized.
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001890 * Likewise for modules used built-in the sections marked __exit
1891 * are discarded because __exit marked function are supposed to be called
Ben Dooks32be1d22008-07-29 22:33:44 -07001892 * only when a module is unloaded which never happens for built-in modules.
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001893 * The check_sec_ref() function traverses all relocation records
1894 * to find all references to a section that reference a section that will
1895 * be discarded and warns about it.
1896 **/
1897static void check_sec_ref(struct module *mod, const char *modname,
Masahiro Yamadabb66fc62014-06-10 19:08:13 +09001898 struct elf_info *elf)
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001899{
1900 int i;
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001901 Elf_Shdr *sechdrs = elf->sechdrs;
Sam Ravnborg62070fa2006-03-03 16:46:04 +01001902
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001903 /* Walk through all sections */
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +02001904 for (i = 0; i < elf->num_sections; i++) {
Anders Kaseorgb614a692009-04-23 16:49:33 -04001905 check_section(modname, elf, &elf->sechdrs[i]);
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001906 /* We want to process only relocation sections and not .init */
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001907 if (sechdrs[i].sh_type == SHT_RELA)
Sam Ravnborg10668222008-01-13 22:21:31 +01001908 section_rela(modname, elf, &elf->sechdrs[i]);
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001909 else if (sechdrs[i].sh_type == SHT_REL)
Sam Ravnborg10668222008-01-13 22:21:31 +01001910 section_rel(modname, elf, &elf->sechdrs[i]);
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001911 }
1912}
1913
Andi Kleen7d02b492014-02-08 09:01:12 +01001914static char *remove_dot(char *s)
1915{
Michal Nazarewiczfcd38ed2014-07-27 07:27:01 +09301916 size_t n = strcspn(s, ".");
Andi Kleen7d02b492014-02-08 09:01:12 +01001917
Michal Nazarewiczfcd38ed2014-07-27 07:27:01 +09301918 if (n && s[n]) {
1919 size_t m = strspn(s + n + 1, "0123456789");
1920 if (m && (s[n + m] == '.' || s[n + m] == 0))
Andi Kleen7d02b492014-02-08 09:01:12 +01001921 s[n] = 0;
1922 }
1923 return s;
1924}
1925
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01001926static void read_symbols(char *modname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927{
1928 const char *symname;
1929 char *version;
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02001930 char *license;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931 struct module *mod;
1932 struct elf_info info = { };
1933 Elf_Sym *sym;
1934
Sam Ravnborg85bd2fd2007-02-26 15:33:52 +01001935 if (!parse_elf(&info, modname))
1936 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937
1938 mod = new_module(modname);
1939
1940 /* When there's no vmlinux, don't print warnings about
1941 * unresolved symbols (since there'll be too many ;) */
1942 if (is_vmlinux(modname)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 have_vmlinux = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944 mod->skip = 1;
1945 }
1946
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02001947 license = get_modinfo(info.modinfo, info.modinfo_len, "license");
Sam Ravnborg2fa36562008-04-26 21:07:26 +02001948 if (info.modinfo && !license && !is_vmlinux(modname))
1949 warn("modpost: missing MODULE_LICENSE() in %s\n"
1950 "see include/linux/module.h for "
1951 "more information\n", modname);
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02001952 while (license) {
1953 if (license_is_gpl_compatible(license))
1954 mod->gpl_compatible = 1;
1955 else {
1956 mod->gpl_compatible = 0;
1957 break;
1958 }
1959 license = get_next_modinfo(info.modinfo, info.modinfo_len,
1960 "license", license);
1961 }
1962
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
Andi Kleen7d02b492014-02-08 09:01:12 +01001964 symname = remove_dot(info.strtab + sym->st_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965
1966 handle_modversions(mod, &info, sym, symname);
1967 handle_moddevtable(mod, &info, sym, symname);
1968 }
Sam Ravnborgd1f25e62008-01-17 21:17:42 +01001969 if (!is_vmlinux(modname) ||
Sam Ravnborg10668222008-01-13 22:21:31 +01001970 (is_vmlinux(modname) && vmlinux_section_warnings))
1971 check_sec_ref(mod, modname, &info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972
1973 version = get_modinfo(info.modinfo, info.modinfo_len, "version");
1974 if (version)
1975 maybe_frob_rcs_version(modname, version, info.modinfo,
1976 version - (char *)info.hdr);
1977 if (version || (all_versions && !is_vmlinux(modname)))
1978 get_src_version(modname, mod->srcversion,
1979 sizeof(mod->srcversion)-1);
1980
1981 parse_elf_finish(&info);
1982
Rusty Russell8c8ef422009-03-31 13:05:34 -06001983 /* Our trick to get versioning for module struct etc. - it's
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984 * never passed as an argument to an exported function, so
1985 * the automatic versioning doesn't pick it up, but it's really
1986 * important anyhow */
1987 if (modversions)
Rusty Russell8c8ef422009-03-31 13:05:34 -06001988 mod->unres = alloc_symbol("module_layout", 0, mod->unres);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989}
1990
Rusty Russell712f9b42013-04-04 17:37:38 +10301991static void read_symbols_from_files(const char *filename)
1992{
1993 FILE *in = stdin;
1994 char fname[PATH_MAX];
1995
1996 if (strcmp(filename, "-") != 0) {
1997 in = fopen(filename, "r");
1998 if (!in)
1999 fatal("Can't open filenames file %s: %m", filename);
2000 }
2001
2002 while (fgets(fname, PATH_MAX, in) != NULL) {
2003 if (strends(fname, "\n"))
2004 fname[strlen(fname)-1] = '\0';
2005 read_symbols(fname);
2006 }
2007
2008 if (in != stdin)
2009 fclose(in);
2010}
2011
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012#define SZ 500
2013
2014/* We first write the generated file into memory using the
2015 * following helper, then compare to the file on disk and
2016 * only update the later if anything changed */
2017
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01002018void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
2019 const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020{
2021 char tmp[SZ];
2022 int len;
2023 va_list ap;
Sam Ravnborg62070fa2006-03-03 16:46:04 +01002024
Linus Torvalds1da177e2005-04-16 15:20:36 -07002025 va_start(ap, fmt);
2026 len = vsnprintf(tmp, SZ, fmt, ap);
Sam Ravnborg7670f022006-03-16 23:04:08 -08002027 buf_write(buf, tmp, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028 va_end(ap);
2029}
2030
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01002031void buf_write(struct buffer *buf, const char *s, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032{
2033 if (buf->size - buf->pos < len) {
Sam Ravnborg7670f022006-03-16 23:04:08 -08002034 buf->size += len + SZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035 buf->p = realloc(buf->p, buf->size);
2036 }
2037 strncpy(buf->p + buf->pos, s, len);
2038 buf->pos += len;
2039}
2040
Sam Ravnborgc96fca22006-07-01 11:44:23 +02002041static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
2042{
2043 const char *e = is_vmlinux(m) ?"":".ko";
2044
2045 switch (exp) {
2046 case export_gpl:
2047 fatal("modpost: GPL-incompatible module %s%s "
2048 "uses GPL-only symbol '%s'\n", m, e, s);
2049 break;
2050 case export_unused_gpl:
2051 fatal("modpost: GPL-incompatible module %s%s "
2052 "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s);
2053 break;
2054 case export_gpl_future:
2055 warn("modpost: GPL-incompatible module %s%s "
2056 "uses future GPL-only symbol '%s'\n", m, e, s);
2057 break;
2058 case export_plain:
2059 case export_unused:
2060 case export_unknown:
2061 /* ignore */
2062 break;
2063 }
2064}
2065
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002066static void check_for_unused(enum export exp, const char *m, const char *s)
Sam Ravnborgc96fca22006-07-01 11:44:23 +02002067{
2068 const char *e = is_vmlinux(m) ?"":".ko";
2069
2070 switch (exp) {
2071 case export_unused:
2072 case export_unused_gpl:
2073 warn("modpost: module %s%s "
2074 "uses symbol '%s' marked UNUSED\n", m, e, s);
2075 break;
2076 default:
2077 /* ignore */
2078 break;
2079 }
2080}
2081
2082static void check_exports(struct module *mod)
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02002083{
2084 struct symbol *s, *exp;
2085
2086 for (s = mod->unres; s; s = s->next) {
Andrew Morton6449bd62006-06-09 20:45:06 -07002087 const char *basename;
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02002088 exp = find_symbol(s->name);
2089 if (!exp || exp->module == mod)
2090 continue;
Andrew Morton6449bd62006-06-09 20:45:06 -07002091 basename = strrchr(mod->name, '/');
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02002092 if (basename)
2093 basename++;
Sam Ravnborgc96fca22006-07-01 11:44:23 +02002094 else
2095 basename = mod->name;
2096 if (!mod->gpl_compatible)
2097 check_for_gpl_usage(exp->export, basename, exp->name);
2098 check_for_unused(exp->export, basename, exp->name);
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002099 }
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02002100}
2101
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01002102/**
2103 * Header for the generated file
2104 **/
2105static void add_header(struct buffer *b, struct module *mod)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106{
2107 buf_printf(b, "#include <linux/module.h>\n");
2108 buf_printf(b, "#include <linux/vermagic.h>\n");
2109 buf_printf(b, "#include <linux/compiler.h>\n");
2110 buf_printf(b, "\n");
2111 buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
2112 buf_printf(b, "\n");
Andi Kleene0f244c2013-10-23 10:57:58 +10302113 buf_printf(b, "__visible struct module __this_module\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114 buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n");
Greg Kroah-Hartman3c7ec942012-04-25 11:10:15 -07002115 buf_printf(b, "\t.name = KBUILD_MODNAME,\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116 if (mod->has_init)
Greg Kroah-Hartman3c7ec942012-04-25 11:10:15 -07002117 buf_printf(b, "\t.init = init_module,\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118 if (mod->has_cleanup)
2119 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
Greg Kroah-Hartman3c7ec942012-04-25 11:10:15 -07002120 "\t.exit = cleanup_module,\n"
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121 "#endif\n");
Greg Kroah-Hartman3c7ec942012-04-25 11:10:15 -07002122 buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123 buf_printf(b, "};\n");
2124}
2125
Ben Hutchings2449b8b2011-10-24 15:12:28 +02002126static void add_intree_flag(struct buffer *b, int is_intree)
2127{
2128 if (is_intree)
2129 buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
2130}
2131
Trevor Keith5c725132009-09-22 16:43:38 -07002132static void add_staging_flag(struct buffer *b, const char *name)
Greg Kroah-Hartmana9860bf2008-09-24 14:46:44 -07002133{
2134 static const char *staging_dir = "drivers/staging";
2135
2136 if (strncmp(staging_dir, name, strlen(staging_dir)) == 0)
2137 buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
2138}
2139
Takashi Iwai5cfb2032015-08-08 15:16:20 +09302140/* In kernel, this size is defined in linux/module.h;
2141 * here we use Elf_Addr instead of long for covering cross-compile
2142 */
2143#define MODULE_NAME_LEN (64 - sizeof(Elf_Addr))
2144
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01002145/**
2146 * Record CRCs for unresolved symbols
2147 **/
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002148static int add_versions(struct buffer *b, struct module *mod)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149{
2150 struct symbol *s, *exp;
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002151 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002152
2153 for (s = mod->unres; s; s = s->next) {
2154 exp = find_symbol(s->name);
2155 if (!exp || exp->module == mod) {
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002156 if (have_vmlinux && !s->weak) {
Matthew Wilcox2a116652006-10-07 05:35:32 -06002157 if (warn_unresolved) {
2158 warn("\"%s\" [%s.ko] undefined!\n",
2159 s->name, mod->name);
2160 } else {
2161 merror("\"%s\" [%s.ko] undefined!\n",
Masahiro Yamadabb66fc62014-06-10 19:08:13 +09002162 s->name, mod->name);
Matthew Wilcox2a116652006-10-07 05:35:32 -06002163 err = 1;
2164 }
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002165 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166 continue;
2167 }
2168 s->module = exp->module;
2169 s->crc_valid = exp->crc_valid;
2170 s->crc = exp->crc;
2171 }
2172
2173 if (!modversions)
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002174 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175
2176 buf_printf(b, "\n");
2177 buf_printf(b, "static const struct modversion_info ____versions[]\n");
Adrian Bunk3ff6eec2008-01-24 22:16:20 +01002178 buf_printf(b, "__used\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179 buf_printf(b, "__attribute__((section(\"__versions\"))) = {\n");
2180
2181 for (s = mod->unres; s; s = s->next) {
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002182 if (!s->module)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184 if (!s->crc_valid) {
Sam Ravnborgcb805142006-01-28 16:57:26 +01002185 warn("\"%s\" [%s.ko] has no CRC!\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186 s->name, mod->name);
2187 continue;
2188 }
Takashi Iwai5cfb2032015-08-08 15:16:20 +09302189 if (strlen(s->name) >= MODULE_NAME_LEN) {
2190 merror("too long symbol \"%s\" [%s.ko]\n",
2191 s->name, mod->name);
2192 err = 1;
2193 break;
2194 }
James Hogana53a11f32013-04-29 11:36:59 +09302195 buf_printf(b, "\t{ %#8x, __VMLINUX_SYMBOL_STR(%s) },\n",
James Hogana4b6a772013-03-18 19:38:56 +10302196 s->crc, s->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197 }
2198
2199 buf_printf(b, "};\n");
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002200
2201 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202}
2203
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01002204static void add_depends(struct buffer *b, struct module *mod,
2205 struct module *modules)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206{
2207 struct symbol *s;
2208 struct module *m;
2209 int first = 1;
2210
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002211 for (m = modules; m; m = m->next)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212 m->seen = is_vmlinux(m->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213
2214 buf_printf(b, "\n");
2215 buf_printf(b, "static const char __module_depends[]\n");
Adrian Bunk3ff6eec2008-01-24 22:16:20 +01002216 buf_printf(b, "__used\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217 buf_printf(b, "__attribute__((section(\".modinfo\"))) =\n");
2218 buf_printf(b, "\"depends=");
2219 for (s = mod->unres; s; s = s->next) {
Sam Ravnborga61b2df2007-02-26 19:46:52 +01002220 const char *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221 if (!s->module)
2222 continue;
2223
2224 if (s->module->seen)
2225 continue;
2226
2227 s->module->seen = 1;
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002228 p = strrchr(s->module->name, '/');
2229 if (p)
Sam Ravnborga61b2df2007-02-26 19:46:52 +01002230 p++;
2231 else
2232 p = s->module->name;
2233 buf_printf(b, "%s%s", first ? "" : ",", p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234 first = 0;
2235 }
2236 buf_printf(b, "\";\n");
2237}
2238
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01002239static void add_srcversion(struct buffer *b, struct module *mod)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240{
2241 if (mod->srcversion[0]) {
2242 buf_printf(b, "\n");
2243 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
2244 mod->srcversion);
2245 }
2246}
2247
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01002248static void write_if_changed(struct buffer *b, const char *fname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249{
2250 char *tmp;
2251 FILE *file;
2252 struct stat st;
2253
2254 file = fopen(fname, "r");
2255 if (!file)
2256 goto write;
2257
2258 if (fstat(fileno(file), &st) < 0)
2259 goto close_write;
2260
2261 if (st.st_size != b->pos)
2262 goto close_write;
2263
2264 tmp = NOFAIL(malloc(b->pos));
2265 if (fread(tmp, 1, b->pos, file) != b->pos)
2266 goto free_write;
2267
2268 if (memcmp(tmp, b->p, b->pos) != 0)
2269 goto free_write;
2270
2271 free(tmp);
2272 fclose(file);
2273 return;
2274
2275 free_write:
2276 free(tmp);
2277 close_write:
2278 fclose(file);
2279 write:
2280 file = fopen(fname, "w");
2281 if (!file) {
2282 perror(fname);
2283 exit(1);
2284 }
2285 if (fwrite(b->p, 1, b->pos, file) != b->pos) {
2286 perror(fname);
2287 exit(1);
2288 }
2289 fclose(file);
2290}
2291
Ram Paibd5cbce2006-06-08 22:12:53 -07002292/* parse Module.symvers file. line format:
Sam Ravnborg534b89a2006-07-01 10:10:19 +02002293 * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something]
Ram Paibd5cbce2006-06-08 22:12:53 -07002294 **/
Sam Ravnborg040fcc82006-01-28 22:15:55 +01002295static void read_dump(const char *fname, unsigned int kernel)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296{
2297 unsigned long size, pos = 0;
2298 void *file = grab_file(fname, &size);
2299 char *line;
2300
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002301 if (!file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302 /* No symbol versions, silently ignore */
2303 return;
2304
2305 while ((line = get_next_line(&pos, file, size))) {
Sam Ravnborg534b89a2006-07-01 10:10:19 +02002306 char *symname, *modname, *d, *export, *end;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307 unsigned int crc;
2308 struct module *mod;
Sam Ravnborg040fcc82006-01-28 22:15:55 +01002309 struct symbol *s;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002310
2311 if (!(symname = strchr(line, '\t')))
2312 goto fail;
2313 *symname++ = '\0';
2314 if (!(modname = strchr(symname, '\t')))
2315 goto fail;
2316 *modname++ = '\0';
Laurent Riffard9ac545b2006-06-11 08:02:06 +02002317 if ((export = strchr(modname, '\t')) != NULL)
Ram Paibd5cbce2006-06-08 22:12:53 -07002318 *export++ = '\0';
Sam Ravnborg534b89a2006-07-01 10:10:19 +02002319 if (export && ((end = strchr(export, '\t')) != NULL))
2320 *end = '\0';
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321 crc = strtoul(line, &d, 16);
2322 if (*symname == '\0' || *modname == '\0' || *d != '\0')
2323 goto fail;
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002324 mod = find_module(modname);
2325 if (!mod) {
2326 if (is_vmlinux(modname))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327 have_vmlinux = 1;
Jan Beulich0fa3a882009-03-12 12:28:30 +00002328 mod = new_module(modname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329 mod->skip = 1;
2330 }
Ram Paibd5cbce2006-06-08 22:12:53 -07002331 s = sym_add_exported(symname, mod, export_no(export));
Sam Ravnborg8e70c452006-01-28 22:22:33 +01002332 s->kernel = kernel;
2333 s->preloaded = 1;
Ram Paibd5cbce2006-06-08 22:12:53 -07002334 sym_update_crc(symname, mod, crc, export_no(export));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335 }
Christian Engelmayer2ee41e62014-04-28 11:34:32 +09302336 release_file(file, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337 return;
2338fail:
Christian Engelmayer2ee41e62014-04-28 11:34:32 +09302339 release_file(file, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340 fatal("parse error in symbol dump file\n");
2341}
2342
Sam Ravnborg040fcc82006-01-28 22:15:55 +01002343/* For normal builds always dump all symbols.
2344 * For external modules only dump symbols
2345 * that are not read from kernel Module.symvers.
2346 **/
2347static int dump_sym(struct symbol *sym)
2348{
2349 if (!external_module)
2350 return 1;
2351 if (sym->vmlinux || sym->kernel)
2352 return 0;
2353 return 1;
2354}
Sam Ravnborg62070fa2006-03-03 16:46:04 +01002355
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01002356static void write_dump(const char *fname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002357{
2358 struct buffer buf = { };
2359 struct symbol *symbol;
2360 int n;
2361
2362 for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
2363 symbol = symbolhash[n];
2364 while (symbol) {
Sam Ravnborg040fcc82006-01-28 22:15:55 +01002365 if (dump_sym(symbol))
Ram Paibd5cbce2006-06-08 22:12:53 -07002366 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\n",
Sam Ravnborg62070fa2006-03-03 16:46:04 +01002367 symbol->crc, symbol->name,
Ram Paibd5cbce2006-06-08 22:12:53 -07002368 symbol->module->name,
2369 export_str(symbol->export));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370 symbol = symbol->next;
2371 }
2372 }
2373 write_if_changed(&buf, fname);
2374}
2375
Richard Hacker2d04b5a2008-02-28 09:40:52 +01002376struct ext_sym_list {
2377 struct ext_sym_list *next;
2378 const char *file;
2379};
2380
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01002381int main(int argc, char **argv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002382{
2383 struct module *mod;
2384 struct buffer buf = { };
Sam Ravnborg040fcc82006-01-28 22:15:55 +01002385 char *kernel_read = NULL, *module_read = NULL;
Rusty Russell712f9b42013-04-04 17:37:38 +10302386 char *dump_write = NULL, *files_source = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387 int opt;
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002388 int err;
Richard Hacker2d04b5a2008-02-28 09:40:52 +01002389 struct ext_sym_list *extsym_iter;
2390 struct ext_sym_list *extsym_start = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391
Nicolas Boichat47490ec2015-10-06 09:44:42 +10302392 while ((opt = getopt(argc, argv, "i:I:e:mnsST:o:awM:K:E")) != -1) {
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002393 switch (opt) {
2394 case 'i':
2395 kernel_read = optarg;
2396 break;
2397 case 'I':
2398 module_read = optarg;
2399 external_module = 1;
2400 break;
Richard Hacker2d04b5a2008-02-28 09:40:52 +01002401 case 'e':
2402 external_module = 1;
2403 extsym_iter =
2404 NOFAIL(malloc(sizeof(*extsym_iter)));
2405 extsym_iter->next = extsym_start;
2406 extsym_iter->file = optarg;
2407 extsym_start = extsym_iter;
2408 break;
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002409 case 'm':
2410 modversions = 1;
2411 break;
Guenter Roeckeed380f2013-09-23 15:23:54 +09302412 case 'n':
2413 ignore_missing_files = 1;
2414 break;
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002415 case 'o':
2416 dump_write = optarg;
2417 break;
2418 case 'a':
2419 all_versions = 1;
2420 break;
2421 case 's':
2422 vmlinux_section_warnings = 0;
2423 break;
Sam Ravnborg588ccd72008-01-24 21:12:37 +01002424 case 'S':
2425 sec_mismatch_verbose = 0;
2426 break;
Rusty Russell712f9b42013-04-04 17:37:38 +10302427 case 'T':
2428 files_source = optarg;
2429 break;
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002430 case 'w':
2431 warn_unresolved = 1;
2432 break;
Nicolas Boichat47490ec2015-10-06 09:44:42 +10302433 case 'E':
2434 sec_mismatch_fatal = 1;
2435 break;
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002436 default:
2437 exit(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002438 }
2439 }
2440
Sam Ravnborg040fcc82006-01-28 22:15:55 +01002441 if (kernel_read)
2442 read_dump(kernel_read, 1);
2443 if (module_read)
2444 read_dump(module_read, 0);
Richard Hacker2d04b5a2008-02-28 09:40:52 +01002445 while (extsym_start) {
2446 read_dump(extsym_start->file, 0);
2447 extsym_iter = extsym_start->next;
2448 free(extsym_start);
2449 extsym_start = extsym_iter;
2450 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002451
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002452 while (optind < argc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453 read_symbols(argv[optind++]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454
Rusty Russell712f9b42013-04-04 17:37:38 +10302455 if (files_source)
2456 read_symbols_from_files(files_source);
2457
Linus Torvalds1da177e2005-04-16 15:20:36 -07002458 for (mod = modules; mod; mod = mod->next) {
2459 if (mod->skip)
2460 continue;
Sam Ravnborgc96fca22006-07-01 11:44:23 +02002461 check_exports(mod);
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02002462 }
2463
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002464 err = 0;
2465
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02002466 for (mod = modules; mod; mod = mod->next) {
Mathias Kraused93e1712014-08-27 20:28:56 +09302467 char fname[PATH_MAX];
Andi Kleen666ab412007-11-22 03:43:10 +01002468
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02002469 if (mod->skip)
2470 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002471
2472 buf.pos = 0;
2473
2474 add_header(&buf, mod);
Ben Hutchings2449b8b2011-10-24 15:12:28 +02002475 add_intree_flag(&buf, !external_module);
Greg Kroah-Hartmana9860bf2008-09-24 14:46:44 -07002476 add_staging_flag(&buf, mod->name);
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002477 err |= add_versions(&buf, mod);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002478 add_depends(&buf, mod, modules);
2479 add_moddevtable(&buf, mod);
2480 add_srcversion(&buf, mod);
2481
2482 sprintf(fname, "%s.mod.c", mod->name);
2483 write_if_changed(&buf, fname);
2484 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002485 if (dump_write)
2486 write_dump(dump_write);
Nicolas Boichat47490ec2015-10-06 09:44:42 +10302487 if (sec_mismatch_count) {
2488 if (!sec_mismatch_verbose) {
2489 warn("modpost: Found %d section mismatch(es).\n"
2490 "To see full details build your kernel with:\n"
2491 "'make CONFIG_DEBUG_SECTION_MISMATCH=y'\n",
2492 sec_mismatch_count);
2493 }
2494 if (sec_mismatch_fatal) {
2495 fatal("modpost: Section mismatches detected.\n"
2496 "Set CONFIG_SECTION_MISMATCH_WARN_ONLY=y to allow them.\n");
2497 }
2498 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002500 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002501}