blob: 12d3db3bd46b491542090cd2db01637754467e99 [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;
Guenter Roeckeed380f2013-09-23 15:23:54 +093041/* ignore missing files */
42static int ignore_missing_files;
Sam Ravnborg588ccd72008-01-24 21:12:37 +010043
Sam Ravnborgc96fca22006-07-01 11:44:23 +020044enum export {
45 export_plain, export_unused, export_gpl,
46 export_unused_gpl, export_gpl_future, export_unknown
47};
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
Andi Kleen6d9a89e2007-11-22 03:43:08 +010049#define PRINTF __attribute__ ((format (printf, 1, 2)))
50
51PRINTF void fatal(const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -070052{
53 va_list arglist;
54
55 fprintf(stderr, "FATAL: ");
56
57 va_start(arglist, fmt);
58 vfprintf(stderr, fmt, arglist);
59 va_end(arglist);
60
61 exit(1);
62}
63
Andi Kleen6d9a89e2007-11-22 03:43:08 +010064PRINTF void warn(const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -070065{
66 va_list arglist;
67
68 fprintf(stderr, "WARNING: ");
69
70 va_start(arglist, fmt);
71 vfprintf(stderr, fmt, arglist);
72 va_end(arglist);
73}
74
Andi Kleen6d9a89e2007-11-22 03:43:08 +010075PRINTF void merror(const char *fmt, ...)
Matthew Wilcox2a116652006-10-07 05:35:32 -060076{
77 va_list arglist;
78
79 fprintf(stderr, "ERROR: ");
80
81 va_start(arglist, fmt);
82 vfprintf(stderr, fmt, arglist);
83 va_end(arglist);
84}
85
Rusty Russelld4ef1c32013-04-04 17:37:32 +103086static inline bool strends(const char *str, const char *postfix)
87{
88 if (strlen(str) < strlen(postfix))
89 return false;
90
91 return strcmp(str + strlen(str) - strlen(postfix), postfix) == 0;
92}
93
Sam Ravnborg040fcc82006-01-28 22:15:55 +010094static int is_vmlinux(const char *modname)
95{
96 const char *myname;
97
Sam Ravnborgdf578e72008-01-11 19:17:15 +010098 myname = strrchr(modname, '/');
99 if (myname)
Sam Ravnborg040fcc82006-01-28 22:15:55 +0100100 myname++;
101 else
102 myname = modname;
103
Sam Ravnborg741f98f2007-07-17 10:54:06 +0200104 return (strcmp(myname, "vmlinux") == 0) ||
105 (strcmp(myname, "vmlinux.o") == 0);
Sam Ravnborg040fcc82006-01-28 22:15:55 +0100106}
107
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108void *do_nofail(void *ptr, const char *expr)
109{
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100110 if (!ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 fatal("modpost: Memory allocation failure: %s.\n", expr);
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100112
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 return ptr;
114}
115
116/* A list of all modules we processed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117static struct module *modules;
118
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100119static struct module *find_module(char *modname)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120{
121 struct module *mod;
122
123 for (mod = modules; mod; mod = mod->next)
124 if (strcmp(mod->name, modname) == 0)
125 break;
126 return mod;
127}
128
Rusty Russelld4ef1c32013-04-04 17:37:32 +1030129static struct module *new_module(const char *modname)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130{
131 struct module *mod;
Rusty Russelld4ef1c32013-04-04 17:37:32 +1030132 char *p;
Sam Ravnborg62070fa2006-03-03 16:46:04 +0100133
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 mod = NOFAIL(malloc(sizeof(*mod)));
135 memset(mod, 0, sizeof(*mod));
136 p = NOFAIL(strdup(modname));
137
138 /* strip trailing .o */
Rusty Russelld4ef1c32013-04-04 17:37:32 +1030139 if (strends(p, ".o")) {
140 p[strlen(p) - 2] = '\0';
141 mod->is_dot_o = 1;
142 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143
144 /* add to list */
145 mod->name = p;
Sam Ravnborgb817f6f2006-06-09 21:53:55 +0200146 mod->gpl_compatible = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 mod->next = modules;
148 modules = mod;
149
150 return mod;
151}
152
153/* A hash of all exported symbols,
154 * struct symbol is also used for lists of unresolved symbols */
155
156#define SYMBOL_HASH_SIZE 1024
157
158struct symbol {
159 struct symbol *next;
160 struct module *module;
161 unsigned int crc;
162 int crc_valid;
163 unsigned int weak:1;
Sam Ravnborg040fcc82006-01-28 22:15:55 +0100164 unsigned int vmlinux:1; /* 1 if symbol is defined in vmlinux */
165 unsigned int kernel:1; /* 1 if symbol is from kernel
166 * (only for external modules) **/
Rusty Russellb6568b12013-11-07 12:09:13 +1030167 unsigned int preloaded:1; /* 1 if symbol from Module.symvers, or crc */
Ram Paibd5cbce2006-06-08 22:12:53 -0700168 enum export export; /* Type of export */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 char name[0];
170};
171
172static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
173
174/* This is based on the hash agorithm from gdbm, via tdb */
175static inline unsigned int tdb_hash(const char *name)
176{
177 unsigned value; /* Used to compute the hash value. */
178 unsigned i; /* Used to cycle through random values. */
179
180 /* Set the initial value from the key size. */
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100181 for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
183
184 return (1103515243 * value + 12345);
185}
186
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100187/**
188 * Allocate a new symbols for use in the hash of exported symbols or
189 * the list of unresolved symbols per module
190 **/
191static struct symbol *alloc_symbol(const char *name, unsigned int weak,
192 struct symbol *next)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193{
194 struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
195
196 memset(s, 0, sizeof(*s));
197 strcpy(s->name, name);
198 s->weak = weak;
199 s->next = next;
200 return s;
201}
202
203/* For the hash of exported symbols */
Ram Paibd5cbce2006-06-08 22:12:53 -0700204static struct symbol *new_symbol(const char *name, struct module *module,
205 enum export export)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206{
207 unsigned int hash;
208 struct symbol *new;
209
210 hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
211 new = symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
212 new->module = module;
Ram Paibd5cbce2006-06-08 22:12:53 -0700213 new->export = export;
Sam Ravnborg040fcc82006-01-28 22:15:55 +0100214 return new;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215}
216
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100217static struct symbol *find_symbol(const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218{
219 struct symbol *s;
220
221 /* For our purposes, .foo matches foo. PPC64 needs this. */
222 if (name[0] == '.')
223 name++;
224
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100225 for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 if (strcmp(s->name, name) == 0)
227 return s;
228 }
229 return NULL;
230}
231
Mathias Krause7a3ee752014-08-27 20:28:53 +0930232static const struct {
Ram Paibd5cbce2006-06-08 22:12:53 -0700233 const char *str;
234 enum export export;
235} export_list[] = {
236 { .str = "EXPORT_SYMBOL", .export = export_plain },
Sam Ravnborgc96fca22006-07-01 11:44:23 +0200237 { .str = "EXPORT_UNUSED_SYMBOL", .export = export_unused },
Ram Paibd5cbce2006-06-08 22:12:53 -0700238 { .str = "EXPORT_SYMBOL_GPL", .export = export_gpl },
Sam Ravnborgc96fca22006-07-01 11:44:23 +0200239 { .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },
Ram Paibd5cbce2006-06-08 22:12:53 -0700240 { .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },
241 { .str = "(unknown)", .export = export_unknown },
242};
243
244
245static const char *export_str(enum export ex)
246{
247 return export_list[ex].str;
248}
249
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100250static enum export export_no(const char *s)
Ram Paibd5cbce2006-06-08 22:12:53 -0700251{
252 int i;
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100253
Sam Ravnborg534b89a2006-07-01 10:10:19 +0200254 if (!s)
255 return export_unknown;
Ram Paibd5cbce2006-06-08 22:12:53 -0700256 for (i = 0; export_list[i].export != export_unknown; i++) {
257 if (strcmp(export_list[i].str, s) == 0)
258 return export_list[i].export;
259 }
260 return export_unknown;
261}
262
Alessio Igor Bogani62a26352011-07-14 08:51:16 +0200263static const char *sec_name(struct elf_info *elf, int secindex);
264
265#define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0)
266
267static enum export export_from_secname(struct elf_info *elf, unsigned int sec)
268{
269 const char *secname = sec_name(elf, sec);
270
271 if (strstarts(secname, "___ksymtab+"))
272 return export_plain;
273 else if (strstarts(secname, "___ksymtab_unused+"))
274 return export_unused;
275 else if (strstarts(secname, "___ksymtab_gpl+"))
276 return export_gpl;
277 else if (strstarts(secname, "___ksymtab_unused_gpl+"))
278 return export_unused_gpl;
279 else if (strstarts(secname, "___ksymtab_gpl_future+"))
280 return export_gpl_future;
281 else
282 return export_unknown;
283}
284
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200285static enum export export_from_sec(struct elf_info *elf, unsigned int sec)
Ram Paibd5cbce2006-06-08 22:12:53 -0700286{
287 if (sec == elf->export_sec)
288 return export_plain;
Sam Ravnborgc96fca22006-07-01 11:44:23 +0200289 else if (sec == elf->export_unused_sec)
290 return export_unused;
Ram Paibd5cbce2006-06-08 22:12:53 -0700291 else if (sec == elf->export_gpl_sec)
292 return export_gpl;
Sam Ravnborgc96fca22006-07-01 11:44:23 +0200293 else if (sec == elf->export_unused_gpl_sec)
294 return export_unused_gpl;
Ram Paibd5cbce2006-06-08 22:12:53 -0700295 else if (sec == elf->export_gpl_future_sec)
296 return export_gpl_future;
297 else
298 return export_unknown;
299}
300
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100301/**
302 * Add an exported symbol - it may have already been added without a
303 * CRC, in this case just update the CRC
304 **/
Ram Paibd5cbce2006-06-08 22:12:53 -0700305static struct symbol *sym_add_exported(const char *name, struct module *mod,
306 enum export export)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307{
308 struct symbol *s = find_symbol(name);
309
310 if (!s) {
Ram Paibd5cbce2006-06-08 22:12:53 -0700311 s = new_symbol(name, mod, export);
Sam Ravnborg8e70c452006-01-28 22:22:33 +0100312 } else {
313 if (!s->preloaded) {
Sam Ravnborg7b75b132006-03-05 13:48:58 +0100314 warn("%s: '%s' exported twice. Previous export "
Sam Ravnborg8e70c452006-01-28 22:22:33 +0100315 "was in %s%s\n", mod->name, name,
316 s->module->name,
317 is_vmlinux(s->module->name) ?"":".ko");
Trent Piepho4b219602007-10-11 16:40:10 -0700318 } else {
Paul Bollebaec30e2014-04-16 18:05:35 +0200319 /* In case Module.symvers was out of date */
Trent Piepho4b219602007-10-11 16:40:10 -0700320 s->module = mod;
Sam Ravnborg8e70c452006-01-28 22:22:33 +0100321 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 }
Sam Ravnborg8e70c452006-01-28 22:22:33 +0100323 s->preloaded = 0;
Sam Ravnborg040fcc82006-01-28 22:15:55 +0100324 s->vmlinux = is_vmlinux(mod->name);
325 s->kernel = 0;
Ram Paibd5cbce2006-06-08 22:12:53 -0700326 s->export = export;
Sam Ravnborg040fcc82006-01-28 22:15:55 +0100327 return s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328}
329
Sam Ravnborg040fcc82006-01-28 22:15:55 +0100330static void sym_update_crc(const char *name, struct module *mod,
Ram Paibd5cbce2006-06-08 22:12:53 -0700331 unsigned int crc, enum export export)
Sam Ravnborg040fcc82006-01-28 22:15:55 +0100332{
333 struct symbol *s = find_symbol(name);
334
Rusty Russellb6568b12013-11-07 12:09:13 +1030335 if (!s) {
Ram Paibd5cbce2006-06-08 22:12:53 -0700336 s = new_symbol(name, mod, export);
Rusty Russellb6568b12013-11-07 12:09:13 +1030337 /* Don't complain when we find it later. */
338 s->preloaded = 1;
339 }
Sam Ravnborg040fcc82006-01-28 22:15:55 +0100340 s->crc = crc;
341 s->crc_valid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342}
343
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100344void *grab_file(const char *filename, unsigned long *size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345{
346 struct stat st;
Jesper Juhleb3d5cc2012-05-23 22:28:49 +0930347 void *map = MAP_FAILED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 int fd;
349
350 fd = open(filename, O_RDONLY);
Jesper Juhleb3d5cc2012-05-23 22:28:49 +0930351 if (fd < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 return NULL;
Jesper Juhleb3d5cc2012-05-23 22:28:49 +0930353 if (fstat(fd, &st))
354 goto failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
356 *size = st.st_size;
357 map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358
Jesper Juhleb3d5cc2012-05-23 22:28:49 +0930359failed:
360 close(fd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 if (map == MAP_FAILED)
362 return NULL;
363 return map;
364}
365
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100366/**
367 * Return a copy of the next line in a mmap'ed file.
368 * spaces in the beginning of the line is trimmed away.
369 * Return a pointer to a static buffer.
370 **/
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100371char *get_next_line(unsigned long *pos, void *file, unsigned long size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372{
373 static char line[4096];
374 int skip = 1;
375 size_t len = 0;
376 signed char *p = (signed char *)file + *pos;
377 char *s = line;
378
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100379 for (; *pos < size ; (*pos)++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 if (skip && isspace(*p)) {
381 p++;
382 continue;
383 }
384 skip = 0;
385 if (*p != '\n' && (*pos < size)) {
386 len++;
387 *s++ = *p++;
388 if (len > 4095)
389 break; /* Too long, stop */
390 } else {
391 /* End of string */
392 *s = '\0';
393 return line;
394 }
395 }
396 /* End of buffer */
397 return NULL;
398}
399
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100400void release_file(void *file, unsigned long size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401{
402 munmap(file, size);
403}
404
Sam Ravnborg85bd2fd2007-02-26 15:33:52 +0100405static int parse_elf(struct elf_info *info, const char *filename)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406{
407 unsigned int i;
Sam Ravnborg85bd2fd2007-02-26 15:33:52 +0100408 Elf_Ehdr *hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 Elf_Shdr *sechdrs;
410 Elf_Sym *sym;
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200411 const char *secstrings;
412 unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413
414 hdr = grab_file(filename, &info->size);
415 if (!hdr) {
Guenter Roeckeed380f2013-09-23 15:23:54 +0930416 if (ignore_missing_files) {
417 fprintf(stderr, "%s: %s (ignored)\n", filename,
418 strerror(errno));
419 return 0;
420 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 perror(filename);
Sam Ravnborg6803dc02006-06-24 23:46:54 +0200422 exit(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 }
424 info->hdr = hdr;
Sam Ravnborg85bd2fd2007-02-26 15:33:52 +0100425 if (info->size < sizeof(*hdr)) {
426 /* file too small, assume this is an empty .o file */
427 return 0;
428 }
429 /* Is this a valid ELF file? */
430 if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
431 (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
432 (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
433 (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
434 /* Not an ELF file - silently ignore it */
435 return 0;
436 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 /* Fix endianness in ELF header */
Anders Kaseorg7d875a02009-05-03 22:02:55 +0200438 hdr->e_type = TO_NATIVE(hdr->e_type);
439 hdr->e_machine = TO_NATIVE(hdr->e_machine);
440 hdr->e_version = TO_NATIVE(hdr->e_version);
441 hdr->e_entry = TO_NATIVE(hdr->e_entry);
442 hdr->e_phoff = TO_NATIVE(hdr->e_phoff);
443 hdr->e_shoff = TO_NATIVE(hdr->e_shoff);
444 hdr->e_flags = TO_NATIVE(hdr->e_flags);
445 hdr->e_ehsize = TO_NATIVE(hdr->e_ehsize);
446 hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
447 hdr->e_phnum = TO_NATIVE(hdr->e_phnum);
448 hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
449 hdr->e_shnum = TO_NATIVE(hdr->e_shnum);
450 hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 sechdrs = (void *)hdr + hdr->e_shoff;
452 info->sechdrs = sechdrs;
453
Petr Stetiara83710e2007-08-27 12:15:07 +0200454 /* Check if file offset is correct */
455 if (hdr->e_shoff > info->size) {
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100456 fatal("section header offset=%lu in file '%s' is bigger than "
457 "filesize=%lu\n", (unsigned long)hdr->e_shoff,
458 filename, info->size);
Petr Stetiara83710e2007-08-27 12:15:07 +0200459 return 0;
460 }
461
Anders Kaseorg68457562011-05-19 16:55:27 -0600462 if (hdr->e_shnum == SHN_UNDEF) {
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200463 /*
464 * There are more than 64k sections,
465 * read count from .sh_size.
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200466 */
467 info->num_sections = TO_NATIVE(sechdrs[0].sh_size);
468 }
469 else {
470 info->num_sections = hdr->e_shnum;
471 }
472 if (hdr->e_shstrndx == SHN_XINDEX) {
Anders Kaseorg68457562011-05-19 16:55:27 -0600473 info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link);
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200474 }
475 else {
476 info->secindex_strings = hdr->e_shstrndx;
477 }
478
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 /* Fix endianness in section headers */
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200480 for (i = 0; i < info->num_sections; i++) {
Anders Kaseorg7d875a02009-05-03 22:02:55 +0200481 sechdrs[i].sh_name = TO_NATIVE(sechdrs[i].sh_name);
482 sechdrs[i].sh_type = TO_NATIVE(sechdrs[i].sh_type);
483 sechdrs[i].sh_flags = TO_NATIVE(sechdrs[i].sh_flags);
484 sechdrs[i].sh_addr = TO_NATIVE(sechdrs[i].sh_addr);
485 sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);
486 sechdrs[i].sh_size = TO_NATIVE(sechdrs[i].sh_size);
487 sechdrs[i].sh_link = TO_NATIVE(sechdrs[i].sh_link);
488 sechdrs[i].sh_info = TO_NATIVE(sechdrs[i].sh_info);
489 sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
490 sechdrs[i].sh_entsize = TO_NATIVE(sechdrs[i].sh_entsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 }
492 /* Find symbol table. */
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200493 secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
494 for (i = 1; i < info->num_sections; i++) {
Ram Paibd5cbce2006-06-08 22:12:53 -0700495 const char *secname;
Tejun Heo56fc82c2009-02-06 00:48:02 +0900496 int nobits = sechdrs[i].sh_type == SHT_NOBITS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
Tejun Heo56fc82c2009-02-06 00:48:02 +0900498 if (!nobits && sechdrs[i].sh_offset > info->size) {
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100499 fatal("%s is truncated. sechdrs[i].sh_offset=%lu > "
500 "sizeof(*hrd)=%zu\n", filename,
501 (unsigned long)sechdrs[i].sh_offset,
502 sizeof(*hdr));
Sam Ravnborg85bd2fd2007-02-26 15:33:52 +0100503 return 0;
504 }
Ram Paibd5cbce2006-06-08 22:12:53 -0700505 secname = secstrings + sechdrs[i].sh_name;
506 if (strcmp(secname, ".modinfo") == 0) {
Tejun Heo56fc82c2009-02-06 00:48:02 +0900507 if (nobits)
508 fatal("%s has NOBITS .modinfo\n", filename);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
510 info->modinfo_len = sechdrs[i].sh_size;
Ram Paibd5cbce2006-06-08 22:12:53 -0700511 } else if (strcmp(secname, "__ksymtab") == 0)
512 info->export_sec = i;
Sam Ravnborgc96fca22006-07-01 11:44:23 +0200513 else if (strcmp(secname, "__ksymtab_unused") == 0)
514 info->export_unused_sec = i;
Ram Paibd5cbce2006-06-08 22:12:53 -0700515 else if (strcmp(secname, "__ksymtab_gpl") == 0)
516 info->export_gpl_sec = i;
Sam Ravnborgc96fca22006-07-01 11:44:23 +0200517 else if (strcmp(secname, "__ksymtab_unused_gpl") == 0)
518 info->export_unused_gpl_sec = i;
Ram Paibd5cbce2006-06-08 22:12:53 -0700519 else if (strcmp(secname, "__ksymtab_gpl_future") == 0)
520 info->export_gpl_future_sec = i;
521
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200522 if (sechdrs[i].sh_type == SHT_SYMTAB) {
523 unsigned int sh_link_idx;
524 symtab_idx = i;
525 info->symtab_start = (void *)hdr +
526 sechdrs[i].sh_offset;
527 info->symtab_stop = (void *)hdr +
528 sechdrs[i].sh_offset + sechdrs[i].sh_size;
Anders Kaseorg68457562011-05-19 16:55:27 -0600529 sh_link_idx = sechdrs[i].sh_link;
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200530 info->strtab = (void *)hdr +
531 sechdrs[sh_link_idx].sh_offset;
532 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200534 /* 32bit section no. table? ("more than 64k sections") */
535 if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
536 symtab_shndx_idx = i;
537 info->symtab_shndx_start = (void *)hdr +
538 sechdrs[i].sh_offset;
539 info->symtab_shndx_stop = (void *)hdr +
540 sechdrs[i].sh_offset + sechdrs[i].sh_size;
541 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 }
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100543 if (!info->symtab_start)
Sam Ravnborgcb805142006-01-28 16:57:26 +0100544 fatal("%s has no symtab?\n", filename);
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100545
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 /* Fix endianness in symbols */
547 for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
548 sym->st_shndx = TO_NATIVE(sym->st_shndx);
549 sym->st_name = TO_NATIVE(sym->st_name);
550 sym->st_value = TO_NATIVE(sym->st_value);
551 sym->st_size = TO_NATIVE(sym->st_size);
552 }
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200553
554 if (symtab_shndx_idx != ~0U) {
555 Elf32_Word *p;
Anders Kaseorg68457562011-05-19 16:55:27 -0600556 if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200557 fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
Anders Kaseorg68457562011-05-19 16:55:27 -0600558 filename, sechdrs[symtab_shndx_idx].sh_link,
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200559 symtab_idx);
560 /* Fix endianness */
561 for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
562 p++)
563 *p = TO_NATIVE(*p);
564 }
565
Sam Ravnborg85bd2fd2007-02-26 15:33:52 +0100566 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567}
568
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100569static void parse_elf_finish(struct elf_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570{
571 release_file(info->hdr, info->size);
572}
573
Sam Ravnborg4d7365d2008-06-12 15:02:55 +0200574static int ignore_undef_symbol(struct elf_info *info, const char *symname)
575{
576 /* ignore __this_module, it will be resolved shortly */
Rusty Russellb92021b2013-03-15 15:04:17 +1030577 if (strcmp(symname, VMLINUX_SYMBOL_STR(__this_module)) == 0)
Sam Ravnborg4d7365d2008-06-12 15:02:55 +0200578 return 1;
579 /* ignore global offset table */
580 if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
581 return 1;
582 if (info->hdr->e_machine == EM_PPC)
583 /* Special register function linked on all modules during final link of .ko */
584 if (strncmp(symname, "_restgpr_", sizeof("_restgpr_") - 1) == 0 ||
585 strncmp(symname, "_savegpr_", sizeof("_savegpr_") - 1) == 0 ||
586 strncmp(symname, "_rest32gpr_", sizeof("_rest32gpr_") - 1) == 0 ||
Andreas Schwab8fe9c932013-12-30 15:31:17 +0100587 strncmp(symname, "_save32gpr_", sizeof("_save32gpr_") - 1) == 0 ||
588 strncmp(symname, "_restvr_", sizeof("_restvr_") - 1) == 0 ||
589 strncmp(symname, "_savevr_", sizeof("_savevr_") - 1) == 0)
Sam Ravnborg4d7365d2008-06-12 15:02:55 +0200590 return 1;
Stephen Rothwell7fca5dc2010-06-29 20:08:42 +0000591 if (info->hdr->e_machine == EM_PPC64)
592 /* Special register function linked on all modules during final link of .ko */
593 if (strncmp(symname, "_restgpr0_", sizeof("_restgpr0_") - 1) == 0 ||
Andreas Schwab8fe9c932013-12-30 15:31:17 +0100594 strncmp(symname, "_savegpr0_", sizeof("_savegpr0_") - 1) == 0 ||
595 strncmp(symname, "_restvr_", sizeof("_restvr_") - 1) == 0 ||
596 strncmp(symname, "_savevr_", sizeof("_savevr_") - 1) == 0)
Stephen Rothwell7fca5dc2010-06-29 20:08:42 +0000597 return 1;
Sam Ravnborg4d7365d2008-06-12 15:02:55 +0200598 /* Do not ignore this symbol */
599 return 0;
600}
601
Rusty Russellb92021b2013-03-15 15:04:17 +1030602#define CRC_PFX VMLINUX_SYMBOL_STR(__crc_)
603#define KSYMTAB_PFX VMLINUX_SYMBOL_STR(__ksymtab_)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100605static void handle_modversions(struct module *mod, struct elf_info *info,
606 Elf_Sym *sym, const char *symname)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607{
608 unsigned int crc;
Alessio Igor Bogani62a26352011-07-14 08:51:16 +0200609 enum export export;
610
Frank Rowand258f7422012-04-09 17:59:03 -0700611 if ((!is_vmlinux(mod->name) || mod->is_dot_o) &&
612 strncmp(symname, "__ksymtab", 9) == 0)
Alessio Igor Bogani62a26352011-07-14 08:51:16 +0200613 export = export_from_secname(info, get_secindex(info, sym));
614 else
615 export = export_from_sec(info, get_secindex(info, sym));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
Andi Kleenb5064652013-11-12 15:08:38 -0800617 /* CRC'd symbol */
618 if (strncmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) {
619 crc = (unsigned int) sym->st_value;
620 sym_update_crc(symname + strlen(CRC_PFX), mod, crc,
621 export);
622 }
623
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 switch (sym->st_shndx) {
625 case SHN_COMMON:
Andi Kleenef178f92014-02-08 09:01:17 +0100626 if (!strncmp(symname, "__gnu_lto_", sizeof("__gnu_lto_")-1)) {
627 /* Should warn here, but modpost runs before the linker */
628 } else
629 warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 case SHN_UNDEF:
632 /* undefined symbol */
633 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
634 ELF_ST_BIND(sym->st_info) != STB_WEAK)
635 break;
Sam Ravnborg4d7365d2008-06-12 15:02:55 +0200636 if (ignore_undef_symbol(info, symname))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 break;
Ben Colline8d529012005-08-19 13:44:57 -0700638/* cope with newer glibc (2.3.4 or higher) STT_ definition in elf.h */
639#if defined(STT_REGISTER) || defined(STT_SPARC_REGISTER)
640/* add compatibility with older glibc */
641#ifndef STT_SPARC_REGISTER
642#define STT_SPARC_REGISTER STT_REGISTER
643#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 if (info->hdr->e_machine == EM_SPARC ||
645 info->hdr->e_machine == EM_SPARCV9) {
646 /* Ignore register directives. */
Ben Colline8d529012005-08-19 13:44:57 -0700647 if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 break;
Sam Ravnborg62070fa2006-03-03 16:46:04 +0100649 if (symname[0] == '.') {
650 char *munged = strdup(symname);
651 munged[0] = '_';
652 munged[1] = toupper(munged[1]);
653 symname = munged;
654 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 }
656#endif
Sam Ravnborg62070fa2006-03-03 16:46:04 +0100657
Rusty Russellb92021b2013-03-15 15:04:17 +1030658#ifdef CONFIG_HAVE_UNDERSCORE_SYMBOL_PREFIX
659 if (symname[0] != '_')
660 break;
661 else
662 symname++;
663#endif
664 mod->unres = alloc_symbol(symname,
665 ELF_ST_BIND(sym->st_info) == STB_WEAK,
666 mod->unres);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 break;
668 default:
669 /* All exported symbols */
Michal Marek8d995132009-12-12 12:02:24 +0100670 if (strncmp(symname, KSYMTAB_PFX, strlen(KSYMTAB_PFX)) == 0) {
Ram Paibd5cbce2006-06-08 22:12:53 -0700671 sym_add_exported(symname + strlen(KSYMTAB_PFX), mod,
672 export);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 }
Rusty Russellb92021b2013-03-15 15:04:17 +1030674 if (strcmp(symname, VMLINUX_SYMBOL_STR(init_module)) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 mod->has_init = 1;
Rusty Russellb92021b2013-03-15 15:04:17 +1030676 if (strcmp(symname, VMLINUX_SYMBOL_STR(cleanup_module)) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 mod->has_cleanup = 1;
678 break;
679 }
680}
681
Sam Ravnborg5c3ead82006-01-28 17:19:35 +0100682/**
683 * Parse tag=value strings from .modinfo section
684 **/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685static char *next_string(char *string, unsigned long *secsize)
686{
687 /* Skip non-zero chars */
688 while (string[0]) {
689 string++;
690 if ((*secsize)-- <= 1)
691 return NULL;
692 }
693
694 /* Skip any zero padding. */
695 while (!string[0]) {
696 string++;
697 if ((*secsize)-- <= 1)
698 return NULL;
699 }
700 return string;
701}
702
Sam Ravnborgb817f6f2006-06-09 21:53:55 +0200703static char *get_next_modinfo(void *modinfo, unsigned long modinfo_len,
704 const char *tag, char *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705{
706 char *p;
707 unsigned int taglen = strlen(tag);
708 unsigned long size = modinfo_len;
709
Sam Ravnborgb817f6f2006-06-09 21:53:55 +0200710 if (info) {
711 size -= info - (char *)modinfo;
712 modinfo = next_string(info, &size);
713 }
714
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 for (p = modinfo; p; p = next_string(p, &size)) {
716 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
717 return p + taglen + 1;
718 }
719 return NULL;
720}
721
Sam Ravnborgb817f6f2006-06-09 21:53:55 +0200722static char *get_modinfo(void *modinfo, unsigned long modinfo_len,
723 const char *tag)
724
725{
726 return get_next_modinfo(modinfo, modinfo_len, tag, NULL);
727}
728
Sam Ravnborg93684d32006-02-19 11:53:35 +0100729/**
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +0100730 * Test if string s ends in string sub
731 * return 0 if match
732 **/
733static int strrcmp(const char *s, const char *sub)
734{
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100735 int slen, sublen;
Sam Ravnborg62070fa2006-03-03 16:46:04 +0100736
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +0100737 if (!s || !sub)
738 return 1;
Sam Ravnborg62070fa2006-03-03 16:46:04 +0100739
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +0100740 slen = strlen(s);
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100741 sublen = strlen(sub);
Sam Ravnborg62070fa2006-03-03 16:46:04 +0100742
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +0100743 if ((slen == 0) || (sublen == 0))
744 return 1;
745
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100746 if (sublen > slen)
747 return 1;
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +0100748
Sam Ravnborgdf578e72008-01-11 19:17:15 +0100749 return memcmp(s + slen - sublen, sub, sublen);
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +0100750}
751
Sam Ravnborgff13f922008-01-23 19:54:27 +0100752static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
753{
Sam Ravnborg58fb0d42008-01-23 21:13:50 +0100754 if (sym)
755 return elf->strtab + sym->st_name;
756 else
Sam Ravnborgf6667512008-02-06 21:51:18 +0100757 return "(unknown)";
Sam Ravnborgff13f922008-01-23 19:54:27 +0100758}
759
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200760static const char *sec_name(struct elf_info *elf, int secindex)
Sam Ravnborgff13f922008-01-23 19:54:27 +0100761{
762 Elf_Shdr *sechdrs = elf->sechdrs;
763 return (void *)elf->hdr +
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200764 elf->sechdrs[elf->secindex_strings].sh_offset +
765 sechdrs[secindex].sh_name;
Sam Ravnborgff13f922008-01-23 19:54:27 +0100766}
767
768static const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr)
769{
770 return (void *)elf->hdr +
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +0200771 elf->sechdrs[elf->secindex_strings].sh_offset +
772 sechdr->sh_name;
Sam Ravnborgff13f922008-01-23 19:54:27 +0100773}
774
Sam Ravnborg10668222008-01-13 22:21:31 +0100775/* The pattern is an array of simple patterns.
776 * "foo" will match an exact string equal to "foo"
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100777 * "*foo" will match a string that ends with "foo"
Sam Ravnborg10668222008-01-13 22:21:31 +0100778 * "foo*" will match a string that begins with "foo"
Paul Gortmaker09c20c02015-04-20 10:20:26 +0930779 * "*foo*" will match a string that contains "foo"
Sam Ravnborg10668222008-01-13 22:21:31 +0100780 */
Trevor Keith5c725132009-09-22 16:43:38 -0700781static int match(const char *sym, const char * const pat[])
Sam Ravnborg10668222008-01-13 22:21:31 +0100782{
783 const char *p;
784 while (*pat) {
785 p = *pat++;
786 const char *endp = p + strlen(p) - 1;
787
Paul Gortmaker09c20c02015-04-20 10:20:26 +0930788 /* "*foo*" */
789 if (*p == '*' && *endp == '*') {
790 char *here, *bare = strndup(p + 1, strlen(p) - 2);
791
792 here = strstr(sym, bare);
793 free(bare);
794 if (here != NULL)
795 return 1;
796 }
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100797 /* "*foo" */
Paul Gortmaker09c20c02015-04-20 10:20:26 +0930798 else if (*p == '*') {
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100799 if (strrcmp(sym, p + 1) == 0)
800 return 1;
801 }
Sam Ravnborg10668222008-01-13 22:21:31 +0100802 /* "foo*" */
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100803 else if (*endp == '*') {
Sam Ravnborg10668222008-01-13 22:21:31 +0100804 if (strncmp(sym, p, strlen(p) - 1) == 0)
805 return 1;
806 }
Sam Ravnborg10668222008-01-13 22:21:31 +0100807 /* no wildcards */
808 else {
809 if (strcmp(p, sym) == 0)
810 return 1;
811 }
812 }
813 /* no match */
814 return 0;
815}
816
Sam Ravnborg10668222008-01-13 22:21:31 +0100817/* sections that we do not want to do full section mismatch check on */
Mathias Krause7a3ee752014-08-27 20:28:53 +0930818static const char *const section_white_list[] =
Sam Ravnborg4391ed62009-05-04 13:05:26 +0200819{
820 ".comment*",
821 ".debug*",
Chen Gang4d10c222013-08-20 15:33:19 +0930822 ".cranges", /* sh64 */
H.J. Lu11215842010-12-15 17:11:22 -0800823 ".zdebug*", /* Compressed debug sections. */
David Howells019fca82010-08-12 16:54:47 +0100824 ".GCC-command-line", /* mn10300 */
Jonathan Kliegman76b27642012-10-04 16:32:19 -0400825 ".GCC.command.line", /* record-gcc-switches, non mn10300 */
Sam Ravnborg4391ed62009-05-04 13:05:26 +0200826 ".mdebug*", /* alpha, score, mips etc. */
827 ".pdr", /* alpha, score, mips etc. */
828 ".stab*",
829 ".note*",
830 ".got*",
831 ".toc*",
Max Filippovaf42e972012-09-17 05:44:38 +0400832 ".xt.prop", /* xtensa */
833 ".xt.lit", /* xtensa */
Vineet Guptaf2e207f2013-01-21 17:18:57 +1030834 ".arcextmap*", /* arc */
835 ".gnu.linkonce.arcext*", /* arc : modules */
Andi Kleenef178f92014-02-08 09:01:17 +0100836 ".gnu.lto*",
Sam Ravnborg4391ed62009-05-04 13:05:26 +0200837 NULL
838};
Sam Ravnborg10668222008-01-13 22:21:31 +0100839
Sam Ravnborge241a632008-01-28 20:13:13 +0100840/*
Anders Kaseorgb614a692009-04-23 16:49:33 -0400841 * This is used to find sections missing the SHF_ALLOC flag.
Sam Ravnborge241a632008-01-28 20:13:13 +0100842 * The cause of this is often a section specified in assembler
Anders Kaseorgb614a692009-04-23 16:49:33 -0400843 * without "ax" / "aw".
Sam Ravnborge241a632008-01-28 20:13:13 +0100844 */
Anders Kaseorgb614a692009-04-23 16:49:33 -0400845static void check_section(const char *modname, struct elf_info *elf,
Masahiro Yamadabb66fc62014-06-10 19:08:13 +0900846 Elf_Shdr *sechdr)
Sam Ravnborge241a632008-01-28 20:13:13 +0100847{
Anders Kaseorgb614a692009-04-23 16:49:33 -0400848 const char *sec = sech_name(elf, sechdr);
Sam Ravnborge241a632008-01-28 20:13:13 +0100849
Anders Kaseorgb614a692009-04-23 16:49:33 -0400850 if (sechdr->sh_type == SHT_PROGBITS &&
851 !(sechdr->sh_flags & SHF_ALLOC) &&
852 !match(sec, section_white_list)) {
853 warn("%s (%s): unexpected non-allocatable section.\n"
854 "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
855 "Note that for example <linux/init.h> contains\n"
856 "section definitions for use in .S files.\n\n",
857 modname, sec);
Sam Ravnborge241a632008-01-28 20:13:13 +0100858 }
Sam Ravnborge241a632008-01-28 20:13:13 +0100859}
860
861
862
Sam Ravnborgeb8f6892008-01-20 20:07:28 +0100863#define ALL_INIT_DATA_SECTIONS \
Rasmus Villemoesa0d8f802014-07-27 07:28:01 +0930864 ".init.setup", ".init.rodata", ".meminit.rodata", \
865 ".init.data", ".meminit.data"
Sam Ravnborgeb8f6892008-01-20 20:07:28 +0100866#define ALL_EXIT_DATA_SECTIONS \
Rasmus Villemoesa0d8f802014-07-27 07:28:01 +0930867 ".exit.data", ".memexit.data"
Sam Ravnborg10668222008-01-13 22:21:31 +0100868
Sam Ravnborgeb8f6892008-01-20 20:07:28 +0100869#define ALL_INIT_TEXT_SECTIONS \
Rasmus Villemoesa0d8f802014-07-27 07:28:01 +0930870 ".init.text", ".meminit.text"
Sam Ravnborgeb8f6892008-01-20 20:07:28 +0100871#define ALL_EXIT_TEXT_SECTIONS \
Rasmus Villemoesa0d8f802014-07-27 07:28:01 +0930872 ".exit.text", ".memexit.text"
Sam Ravnborg10668222008-01-13 22:21:31 +0100873
Sebastian Andrzej Siewiorbb15d8d2012-06-03 20:48:17 +0200874#define ALL_PCI_INIT_SECTIONS \
Rasmus Villemoesa0d8f802014-07-27 07:28:01 +0930875 ".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
876 ".pci_fixup_enable", ".pci_fixup_resume", \
877 ".pci_fixup_resume_early", ".pci_fixup_suspend"
Sebastian Andrzej Siewiorbb15d8d2012-06-03 20:48:17 +0200878
Paul Gortmakere24f66282013-06-19 19:30:48 -0400879#define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS
880#define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS
Uwe Kleine-König4a31a222010-01-29 12:04:26 +0100881
882#define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
883#define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
Sam Ravnborg10668222008-01-13 22:21:31 +0100884
Rasmus Villemoesa0d8f802014-07-27 07:28:01 +0930885#define DATA_SECTIONS ".data", ".data.rel"
Quentin Casasnovas157d1972015-04-13 20:42:52 +0930886#define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \
887 ".kprobes.text"
Quentin Casasnovas52dc0592015-04-13 20:52:53 +0930888#define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
Chris Metcalf673c2c32015-07-08 17:07:41 -0400889 ".fixup", ".entry.text", ".exception.text", ".text.*", \
890 ".coldtext"
Sam Ravnborg10668222008-01-13 22:21:31 +0100891
Jan Beulichfd6c3a82009-03-12 10:58:33 +0000892#define INIT_SECTIONS ".init.*"
Jan Beulichfd6c3a82009-03-12 10:58:33 +0000893#define MEM_INIT_SECTIONS ".meminit.*"
Sam Ravnborgeb8f6892008-01-20 20:07:28 +0100894
Jan Beulichfd6c3a82009-03-12 10:58:33 +0000895#define EXIT_SECTIONS ".exit.*"
Jan Beulichfd6c3a82009-03-12 10:58:33 +0000896#define MEM_EXIT_SECTIONS ".memexit.*"
Sam Ravnborgeb8f6892008-01-20 20:07:28 +0100897
Quentin Casasnovas52dc0592015-04-13 20:52:53 +0930898#define ALL_TEXT_SECTIONS ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
899 TEXT_SECTIONS, OTHER_TEXT_SECTIONS
900
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100901/* init data sections */
Mathias Krause7a3ee752014-08-27 20:28:53 +0930902static const char *const init_data_sections[] =
903 { ALL_INIT_DATA_SECTIONS, NULL };
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100904
905/* all init sections */
Mathias Krause7a3ee752014-08-27 20:28:53 +0930906static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100907
908/* All init and exit sections (code + data) */
Mathias Krause7a3ee752014-08-27 20:28:53 +0930909static const char *const init_exit_sections[] =
Sam Ravnborgeb8f6892008-01-20 20:07:28 +0100910 {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100911
Paul Gortmaker4a3893d2015-04-20 10:20:40 +0930912/* all text sections */
913static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
914
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100915/* data section */
Mathias Krause7a3ee752014-08-27 20:28:53 +0930916static const char *const data_sections[] = { DATA_SECTIONS, NULL };
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100917
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100918
919/* symbols in .data that may refer to init/exit sections */
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +0100920#define DEFAULT_SYMBOL_WHITE_LIST \
921 "*driver", \
922 "*_template", /* scsi uses *_template a lot */ \
923 "*_timer", /* arm uses ops structures named _timer a lot */ \
924 "*_sht", /* scsi also used *_sht to some extent */ \
925 "*_ops", \
926 "*_probe", \
927 "*_probe_one", \
928 "*_console"
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100929
Mathias Krause7a3ee752014-08-27 20:28:53 +0930930static const char *const head_sections[] = { ".head.text*", NULL };
931static const char *const linker_symbols[] =
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100932 { "__init_begin", "_sinittext", "_einittext", NULL };
Paul Gortmaker4a3893d2015-04-20 10:20:40 +0930933static const char *const optim_symbols[] = { "*.constprop.*", NULL };
Sam Ravnborg6c5bd232008-01-20 10:43:27 +0100934
Sam Ravnborg588ccd72008-01-24 21:12:37 +0100935enum mismatch {
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +0100936 TEXT_TO_ANY_INIT,
937 DATA_TO_ANY_INIT,
938 TEXT_TO_ANY_EXIT,
939 DATA_TO_ANY_EXIT,
940 XXXINIT_TO_SOME_INIT,
941 XXXEXIT_TO_SOME_EXIT,
942 ANY_INIT_TO_ANY_EXIT,
943 ANY_EXIT_TO_ANY_INIT,
Sam Ravnborg588ccd72008-01-24 21:12:37 +0100944 EXPORT_TO_INIT_EXIT,
Quentin Casasnovas52dc0592015-04-13 20:52:53 +0930945 EXTABLE_TO_NON_TEXT,
Sam Ravnborg588ccd72008-01-24 21:12:37 +0100946};
947
Quentin Casasnovase5d8f592015-04-13 20:55:15 +0930948/**
949 * Describe how to match sections on different criterias:
950 *
951 * @fromsec: Array of sections to be matched.
952 *
953 * @bad_tosec: Relocations applied to a section in @fromsec to a section in
954 * this array is forbidden (black-list). Can be empty.
955 *
956 * @good_tosec: Relocations applied to a section in @fromsec must be
957 * targetting sections in this array (white-list). Can be empty.
958 *
959 * @mismatch: Type of mismatch.
960 *
961 * @symbol_white_list: Do not match a relocation to a symbol in this list
962 * even if it is targetting a section in @bad_to_sec.
963 *
964 * @handler: Specific handler to call when a match is found. If NULL,
965 * default_mismatch_handler() will be called.
966 *
967 */
Sam Ravnborg10668222008-01-13 22:21:31 +0100968struct sectioncheck {
969 const char *fromsec[20];
Quentin Casasnovas050e57f2015-04-13 20:41:04 +0930970 const char *bad_tosec[20];
971 const char *good_tosec[20];
Sam Ravnborg588ccd72008-01-24 21:12:37 +0100972 enum mismatch mismatch;
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +0100973 const char *symbol_white_list[20];
Quentin Casasnovas644e8f12015-04-13 20:43:17 +0930974 void (*handler)(const char *modname, struct elf_info *elf,
975 const struct sectioncheck* const mismatch,
976 Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
977
Sam Ravnborg10668222008-01-13 22:21:31 +0100978};
979
Quentin Casasnovas52dc0592015-04-13 20:52:53 +0930980static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
981 const struct sectioncheck* const mismatch,
982 Elf_Rela *r, Elf_Sym *sym,
983 const char *fromsec);
984
Mathias Krause7a3ee752014-08-27 20:28:53 +0930985static const struct sectioncheck sectioncheck[] = {
Sam Ravnborg10668222008-01-13 22:21:31 +0100986/* Do not reference init/exit code/data from
987 * normal code and data
988 */
989{
Sam Ravnborg588ccd72008-01-24 21:12:37 +0100990 .fromsec = { TEXT_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +0930991 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +0100992 .mismatch = TEXT_TO_ANY_INIT,
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +0100993 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
Sam Ravnborg588ccd72008-01-24 21:12:37 +0100994},
995{
996 .fromsec = { DATA_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +0930997 .bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +0100998 .mismatch = DATA_TO_ANY_INIT,
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +0100999 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001000},
1001{
Uwe Kleine-König0db252452010-01-30 21:14:23 +01001002 .fromsec = { DATA_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301003 .bad_tosec = { INIT_SECTIONS, NULL },
Uwe Kleine-König0db252452010-01-30 21:14:23 +01001004 .mismatch = DATA_TO_ANY_INIT,
1005 .symbol_white_list = {
1006 "*_template", "*_timer", "*_sht", "*_ops",
1007 "*_probe", "*_probe_one", "*_console", NULL
1008 },
1009},
1010{
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001011 .fromsec = { TEXT_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301012 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001013 .mismatch = TEXT_TO_ANY_EXIT,
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +01001014 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001015},
1016{
1017 .fromsec = { DATA_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301018 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001019 .mismatch = DATA_TO_ANY_EXIT,
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +01001020 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
Sam Ravnborgeb8f6892008-01-20 20:07:28 +01001021},
Paul Gortmakere24f66282013-06-19 19:30:48 -04001022/* Do not reference init code/data from meminit code/data */
Sam Ravnborgeb8f6892008-01-20 20:07:28 +01001023{
Uwe Kleine-König4a31a222010-01-29 12:04:26 +01001024 .fromsec = { ALL_XXXINIT_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301025 .bad_tosec = { INIT_SECTIONS, NULL },
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001026 .mismatch = XXXINIT_TO_SOME_INIT,
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +01001027 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
Sam Ravnborgeb8f6892008-01-20 20:07:28 +01001028},
Paul Gortmakere24f66282013-06-19 19:30:48 -04001029/* Do not reference exit code/data from memexit code/data */
Sam Ravnborgeb8f6892008-01-20 20:07:28 +01001030{
Uwe Kleine-König4a31a222010-01-29 12:04:26 +01001031 .fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301032 .bad_tosec = { EXIT_SECTIONS, NULL },
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001033 .mismatch = XXXEXIT_TO_SOME_EXIT,
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +01001034 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
Sam Ravnborg10668222008-01-13 22:21:31 +01001035},
1036/* Do not use exit code/data from init code */
1037{
Sam Ravnborgeb8f6892008-01-20 20:07:28 +01001038 .fromsec = { ALL_INIT_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301039 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001040 .mismatch = ANY_INIT_TO_ANY_EXIT,
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +01001041 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
Sam Ravnborg10668222008-01-13 22:21:31 +01001042},
1043/* Do not use init code/data from exit code */
1044{
Sam Ravnborgeb8f6892008-01-20 20:07:28 +01001045 .fromsec = { ALL_EXIT_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301046 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001047 .mismatch = ANY_EXIT_TO_ANY_INIT,
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +01001048 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
Sam Ravnborg10668222008-01-13 22:21:31 +01001049},
Sebastian Andrzej Siewiorbb15d8d2012-06-03 20:48:17 +02001050{
1051 .fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301052 .bad_tosec = { INIT_SECTIONS, NULL },
Sebastian Andrzej Siewiorbb15d8d2012-06-03 20:48:17 +02001053 .mismatch = ANY_INIT_TO_ANY_EXIT,
1054 .symbol_white_list = { NULL },
1055},
Sam Ravnborg10668222008-01-13 22:21:31 +01001056/* Do not export init/exit functions or data */
1057{
1058 .fromsec = { "__ksymtab*", NULL },
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301059 .bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +01001060 .mismatch = EXPORT_TO_INIT_EXIT,
1061 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
Quentin Casasnovas52dc0592015-04-13 20:52:53 +09301062},
1063{
1064 .fromsec = { "__ex_table", NULL },
1065 /* If you're adding any new black-listed sections in here, consider
1066 * adding a special 'printer' for them in scripts/check_extable.
1067 */
1068 .bad_tosec = { ".altinstr_replacement", NULL },
1069 .good_tosec = {ALL_TEXT_SECTIONS , NULL},
1070 .mismatch = EXTABLE_TO_NON_TEXT,
1071 .handler = extable_mismatch_handler,
Sam Ravnborg10668222008-01-13 22:21:31 +01001072}
1073};
1074
Uwe Kleine-König0d2a6362010-01-30 16:56:20 +01001075static const struct sectioncheck *section_mismatch(
1076 const char *fromsec, const char *tosec)
Sam Ravnborg10668222008-01-13 22:21:31 +01001077{
1078 int i;
1079 int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
1080 const struct sectioncheck *check = &sectioncheck[0];
1081
Quentin Casasnovasc5c34392015-04-16 13:16:41 +09301082 /*
1083 * The target section could be the SHT_NUL section when we're
1084 * handling relocations to un-resolved symbols, trying to match it
1085 * doesn't make much sense and causes build failures on parisc and
1086 * mn10300 architectures.
1087 */
1088 if (*tosec == '\0')
1089 return NULL;
1090
Sam Ravnborg10668222008-01-13 22:21:31 +01001091 for (i = 0; i < elems; i++) {
Quentin Casasnovas050e57f2015-04-13 20:41:04 +09301092 if (match(fromsec, check->fromsec)) {
1093 if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
1094 return check;
1095 if (check->good_tosec[0] && !match(tosec, check->good_tosec))
1096 return check;
1097 }
Sam Ravnborg10668222008-01-13 22:21:31 +01001098 check++;
1099 }
Uwe Kleine-König0d2a6362010-01-30 16:56:20 +01001100 return NULL;
Sam Ravnborg10668222008-01-13 22:21:31 +01001101}
1102
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001103/**
1104 * Whitelist to allow certain references to pass with no warning.
Sam Ravnborg0e0d3142007-05-17 20:14:48 +02001105 *
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001106 * Pattern 1:
1107 * If a module parameter is declared __initdata and permissions=0
1108 * then this is legal despite the warning generated.
1109 * We cannot see value of permissions here, so just ignore
1110 * this pattern.
1111 * The pattern is identified by:
1112 * tosec = .init.data
Sam Ravnborg9209aed2006-03-05 00:16:26 +01001113 * fromsec = .data*
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001114 * atsym =__param*
Sam Ravnborg62070fa2006-03-03 16:46:04 +01001115 *
Rusty Russell6a841522010-08-11 23:04:16 -06001116 * Pattern 1a:
1117 * module_param_call() ops can refer to __init set function if permissions=0
1118 * The pattern is identified by:
1119 * tosec = .init.text
1120 * fromsec = .data*
1121 * atsym = __param_ops_*
1122 *
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001123 * Pattern 2:
Randy Dunlap72ee59b2006-04-15 11:17:12 -07001124 * Many drivers utilise a *driver container with references to
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001125 * add, remove, probe functions etc.
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001126 * the pattern is identified by:
Sam Ravnborg83cda2b2007-07-25 21:52:31 +02001127 * tosec = init or exit section
1128 * fromsec = data section
Sam Ravnborgdf578e72008-01-11 19:17:15 +01001129 * atsym = *driver, *_template, *_sht, *_ops, *_probe,
1130 * *probe_one, *_console, *_timer
Vivek Goyalee6a8542007-01-11 01:52:44 +01001131 *
1132 * Pattern 3:
Sam Ravnborgc9939712009-04-26 11:17:42 +02001133 * Whitelist all references from .head.text to any init section
Sam Ravnborg9bf8cb92007-02-26 17:49:06 +01001134 *
Sam Ravnborg1d8af552007-06-03 00:41:22 +02001135 * Pattern 4:
Vivek Goyalee6a8542007-01-11 01:52:44 +01001136 * Some symbols belong to init section but still it is ok to reference
1137 * these from non-init sections as these symbols don't have any memory
1138 * allocated for them and symbol address and value are same. So even
1139 * if init section is freed, its ok to reference those symbols.
1140 * For ex. symbols marking the init section boundaries.
1141 * This pattern is identified by
1142 * refsymname = __init_begin, _sinittext, _einittext
Sam Ravnborg9bf8cb92007-02-26 17:49:06 +01001143 *
Paul Gortmaker4a3893d2015-04-20 10:20:40 +09301144 * Pattern 5:
1145 * GCC may optimize static inlines when fed constant arg(s) resulting
1146 * in functions like cpumask_empty() -- generating an associated symbol
1147 * cpumask_empty.constprop.3 that appears in the audit. If the const that
1148 * is passed in comes from __init, like say nmi_ipi_mask, we get a
1149 * meaningless section warning. May need to add isra symbols too...
1150 * This pattern is identified by
1151 * tosec = init section
1152 * fromsec = text section
1153 * refsymname = *.constprop.*
1154 *
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001155 **/
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +01001156static int secref_whitelist(const struct sectioncheck *mismatch,
1157 const char *fromsec, const char *fromsym,
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001158 const char *tosec, const char *tosym)
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001159{
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001160 /* Check for pattern 1 */
Sam Ravnborg6c5bd232008-01-20 10:43:27 +01001161 if (match(tosec, init_data_sections) &&
1162 match(fromsec, data_sections) &&
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001163 (strncmp(fromsym, "__param", strlen("__param")) == 0))
1164 return 0;
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001165
Rusty Russell6a841522010-08-11 23:04:16 -06001166 /* Check for pattern 1a */
1167 if (strcmp(tosec, ".init.text") == 0 &&
1168 match(fromsec, data_sections) &&
1169 (strncmp(fromsym, "__param_ops_", strlen("__param_ops_")) == 0))
1170 return 0;
1171
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001172 /* Check for pattern 2 */
Sam Ravnborg6c5bd232008-01-20 10:43:27 +01001173 if (match(tosec, init_exit_sections) &&
1174 match(fromsec, data_sections) &&
Uwe Kleine-Königaf92a822010-01-30 20:52:50 +01001175 match(fromsym, mismatch->symbol_white_list))
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001176 return 0;
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001177
Sam Ravnborg9bf8cb92007-02-26 17:49:06 +01001178 /* Check for pattern 3 */
Sam Ravnborg6c5bd232008-01-20 10:43:27 +01001179 if (match(fromsec, head_sections) &&
1180 match(tosec, init_sections))
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001181 return 0;
Sam Ravnborg9bf8cb92007-02-26 17:49:06 +01001182
Sam Ravnborg1d8af552007-06-03 00:41:22 +02001183 /* Check for pattern 4 */
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001184 if (match(tosym, linker_symbols))
1185 return 0;
Sam Ravnborg9bf8cb92007-02-26 17:49:06 +01001186
Paul Gortmaker4a3893d2015-04-20 10:20:40 +09301187 /* Check for pattern 5 */
1188 if (match(fromsec, text_sections) &&
1189 match(tosec, init_sections) &&
1190 match(fromsym, optim_symbols))
1191 return 0;
1192
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001193 return 1;
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001194}
1195
1196/**
Sam Ravnborg93684d32006-02-19 11:53:35 +01001197 * Find symbol based on relocation record info.
1198 * In some cases the symbol supplied is a valid symbol so
1199 * return refsym. If st_name != 0 we assume this is a valid symbol.
1200 * In other cases the symbol needs to be looked up in the symbol table
1201 * based on section and address.
1202 * **/
Sam Ravnborg9ad21c32008-01-18 21:04:34 +01001203static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
Sam Ravnborg93684d32006-02-19 11:53:35 +01001204 Elf_Sym *relsym)
1205{
1206 Elf_Sym *sym;
Sam Ravnborg9ad21c32008-01-18 21:04:34 +01001207 Elf_Sym *near = NULL;
1208 Elf64_Sword distance = 20;
1209 Elf64_Sword d;
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +02001210 unsigned int relsym_secindex;
Sam Ravnborg93684d32006-02-19 11:53:35 +01001211
1212 if (relsym->st_name != 0)
1213 return relsym;
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +02001214
1215 relsym_secindex = get_secindex(elf, relsym);
Sam Ravnborg93684d32006-02-19 11:53:35 +01001216 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +02001217 if (get_secindex(elf, sym) != relsym_secindex)
Sam Ravnborg93684d32006-02-19 11:53:35 +01001218 continue;
Atsushi Nemotoae4ac122007-05-22 18:27:39 +09001219 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1220 continue;
Sam Ravnborg93684d32006-02-19 11:53:35 +01001221 if (sym->st_value == addr)
1222 return sym;
Sam Ravnborg9ad21c32008-01-18 21:04:34 +01001223 /* Find a symbol nearby - addr are maybe negative */
1224 d = sym->st_value - addr;
1225 if (d < 0)
1226 d = addr - sym->st_value;
1227 if (d < distance) {
1228 distance = d;
1229 near = sym;
1230 }
Sam Ravnborg93684d32006-02-19 11:53:35 +01001231 }
Sam Ravnborg9ad21c32008-01-18 21:04:34 +01001232 /* We need a close match */
1233 if (distance < 20)
1234 return near;
1235 else
1236 return NULL;
Sam Ravnborg93684d32006-02-19 11:53:35 +01001237}
1238
David Brownellda68d612007-02-20 13:58:16 -08001239static inline int is_arm_mapping_symbol(const char *str)
1240{
Kyle McMartin6c34f1f2014-09-16 22:37:18 +01001241 return str[0] == '$' && strchr("axtd", str[1])
David Brownellda68d612007-02-20 13:58:16 -08001242 && (str[2] == '\0' || str[2] == '.');
1243}
1244
1245/*
1246 * If there's no name there, ignore it; likewise, ignore it if it's
1247 * one of the magic symbols emitted used by current ARM tools.
1248 *
1249 * Otherwise if find_symbols_between() returns those symbols, they'll
1250 * fail the whitelist tests and cause lots of false alarms ... fixable
1251 * only by merging __exit and __init sections into __text, bloating
1252 * the kernel (which is especially evil on embedded platforms).
1253 */
1254static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1255{
1256 const char *name = elf->strtab + sym->st_name;
1257
1258 if (!name || !strlen(name))
1259 return 0;
1260 return !is_arm_mapping_symbol(name);
1261}
1262
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001263/*
Sam Ravnborg43c74d12006-03-05 12:02:46 +01001264 * Find symbols before or equal addr and after addr - in the section sec.
1265 * If we find two symbols with equal offset prefer one with a valid name.
1266 * The ELF format may have a better way to detect what type of symbol
1267 * it is, but this works for now.
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001268 **/
Sam Ravnborg157c23c2008-01-22 21:44:32 +01001269static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1270 const char *sec)
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001271{
1272 Elf_Sym *sym;
Sam Ravnborg157c23c2008-01-22 21:44:32 +01001273 Elf_Sym *near = NULL;
Sam Ravnborg157c23c2008-01-22 21:44:32 +01001274 Elf_Addr distance = ~0;
Sam Ravnborg62070fa2006-03-03 16:46:04 +01001275
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001276 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1277 const char *symsec;
1278
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +02001279 if (is_shndx_special(sym->st_shndx))
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001280 continue;
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +02001281 symsec = sec_name(elf, get_secindex(elf, sym));
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001282 if (strcmp(symsec, sec) != 0)
1283 continue;
David Brownellda68d612007-02-20 13:58:16 -08001284 if (!is_valid_name(elf, sym))
1285 continue;
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001286 if (sym->st_value <= addr) {
Sam Ravnborg157c23c2008-01-22 21:44:32 +01001287 if ((addr - sym->st_value) < distance) {
1288 distance = addr - sym->st_value;
1289 near = sym;
1290 } else if ((addr - sym->st_value) == distance) {
1291 near = sym;
Sam Ravnborg43c74d12006-03-05 12:02:46 +01001292 }
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001293 }
1294 }
Sam Ravnborg157c23c2008-01-22 21:44:32 +01001295 return near;
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001296}
1297
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001298/*
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001299 * Convert a section name to the function/data attribute
1300 * .init.text => __init
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001301 * .memexitconst => __memconst
1302 * etc.
Andy Shevchenkocbcf14a92010-08-17 13:36:40 +03001303 *
1304 * The memory of returned value has been allocated on a heap. The user of this
1305 * method should free it after usage.
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001306*/
1307static char *sec2annotation(const char *s)
1308{
1309 if (match(s, init_exit_sections)) {
1310 char *p = malloc(20);
1311 char *r = p;
1312
1313 *p++ = '_';
1314 *p++ = '_';
1315 if (*s == '.')
1316 s++;
1317 while (*s && *s != '.')
1318 *p++ = *s++;
1319 *p = '\0';
1320 if (*s == '.')
1321 s++;
1322 if (strstr(s, "rodata") != NULL)
1323 strcat(p, "const ");
1324 else if (strstr(s, "data") != NULL)
1325 strcat(p, "data ");
1326 else
1327 strcat(p, " ");
Andy Shevchenkocbcf14a92010-08-17 13:36:40 +03001328 return r;
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001329 } else {
Andrew Morton5003bab2010-08-11 00:42:26 -07001330 return strdup("");
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001331 }
1332}
1333
1334static int is_function(Elf_Sym *sym)
1335{
1336 if (sym)
1337 return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1338 else
Sam Ravnborgf6667512008-02-06 21:51:18 +01001339 return -1;
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001340}
1341
Randy Dunlap00759c0e2011-03-15 14:13:47 -07001342static void print_section_list(const char * const list[20])
1343{
1344 const char *const *s = list;
1345
1346 while (*s) {
1347 fprintf(stderr, "%s", *s);
1348 s++;
1349 if (*s)
1350 fprintf(stderr, ", ");
1351 }
1352 fprintf(stderr, "\n");
1353}
1354
Quentin Casasnovas356ad532015-04-13 20:43:34 +09301355static inline void get_pretty_name(int is_func, const char** name, const char** name_p)
1356{
1357 switch (is_func) {
1358 case 0: *name = "variable"; *name_p = ""; break;
1359 case 1: *name = "function"; *name_p = "()"; break;
1360 default: *name = "(unknown reference)"; *name_p = ""; break;
1361 }
1362}
1363
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001364/*
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001365 * Print a warning about a section mismatch.
1366 * Try to find symbols near it so user can find it.
Sam Ravnborg4c8fbca2006-02-26 22:18:11 +01001367 * Check whitelist before warning - it may be a false positive.
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001368 */
Uwe Kleine-König0d2a6362010-01-30 16:56:20 +01001369static void report_sec_mismatch(const char *modname,
1370 const struct sectioncheck *mismatch,
Masahiro Yamadabb66fc62014-06-10 19:08:13 +09001371 const char *fromsec,
1372 unsigned long long fromaddr,
1373 const char *fromsym,
1374 int from_is_func,
1375 const char *tosec, const char *tosym,
1376 int to_is_func)
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001377{
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001378 const char *from, *from_p;
1379 const char *to, *to_p;
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001380 char *prl_from;
1381 char *prl_to;
Sam Ravnborgf6667512008-02-06 21:51:18 +01001382
Sam Ravnborge5f95c82008-02-02 18:57:18 +01001383 sec_mismatch_count++;
1384 if (!sec_mismatch_verbose)
1385 return;
1386
Quentin Casasnovas356ad532015-04-13 20:43:34 +09301387 get_pretty_name(from_is_func, &from, &from_p);
1388 get_pretty_name(to_is_func, &to, &to_p);
1389
Geert Uytterhoeven7c0ac492008-02-05 11:38:49 +01001390 warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1391 "to the %s %s:%s%s\n",
1392 modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
1393 tosym, to_p);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001394
Uwe Kleine-König0d2a6362010-01-30 16:56:20 +01001395 switch (mismatch->mismatch) {
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001396 case TEXT_TO_ANY_INIT:
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001397 prl_from = sec2annotation(fromsec);
1398 prl_to = sec2annotation(tosec);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001399 fprintf(stderr,
Sam Ravnborgf6667512008-02-06 21:51:18 +01001400 "The function %s%s() references\n"
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001401 "the %s %s%s%s.\n"
1402 "This is often because %s lacks a %s\n"
1403 "annotation or the annotation of %s is wrong.\n",
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001404 prl_from, fromsym,
1405 to, prl_to, tosym, to_p,
1406 fromsym, prl_to, tosym);
1407 free(prl_from);
1408 free(prl_to);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001409 break;
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001410 case DATA_TO_ANY_INIT: {
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001411 prl_to = sec2annotation(tosec);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001412 fprintf(stderr,
1413 "The variable %s references\n"
1414 "the %s %s%s%s\n"
1415 "If the reference is valid then annotate the\n"
Sam Ravnborg8b8b76c2009-06-06 00:18:05 +02001416 "variable with __init* or __refdata (see linux/init.h) "
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001417 "or name the variable:\n",
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001418 fromsym, to, prl_to, tosym, to_p);
Randy Dunlap00759c0e2011-03-15 14:13:47 -07001419 print_section_list(mismatch->symbol_white_list);
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001420 free(prl_to);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001421 break;
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001422 }
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001423 case TEXT_TO_ANY_EXIT:
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001424 prl_to = sec2annotation(tosec);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001425 fprintf(stderr,
1426 "The function %s() references a %s in an exit section.\n"
1427 "Often the %s %s%s has valid usage outside the exit section\n"
1428 "and the fix is to remove the %sannotation of %s.\n",
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001429 fromsym, to, to, tosym, to_p, prl_to, tosym);
1430 free(prl_to);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001431 break;
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001432 case DATA_TO_ANY_EXIT: {
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001433 prl_to = sec2annotation(tosec);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001434 fprintf(stderr,
1435 "The variable %s references\n"
1436 "the %s %s%s%s\n"
1437 "If the reference is valid then annotate the\n"
1438 "variable with __exit* (see linux/init.h) or "
1439 "name the variable:\n",
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001440 fromsym, to, prl_to, tosym, to_p);
Randy Dunlap00759c0e2011-03-15 14:13:47 -07001441 print_section_list(mismatch->symbol_white_list);
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001442 free(prl_to);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001443 break;
1444 }
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001445 case XXXINIT_TO_SOME_INIT:
1446 case XXXEXIT_TO_SOME_EXIT:
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001447 prl_from = sec2annotation(fromsec);
1448 prl_to = sec2annotation(tosec);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001449 fprintf(stderr,
1450 "The %s %s%s%s references\n"
1451 "a %s %s%s%s.\n"
1452 "If %s is only used by %s then\n"
1453 "annotate %s with a matching annotation.\n",
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001454 from, prl_from, fromsym, from_p,
1455 to, prl_to, tosym, to_p,
Geert Uytterhoevenb1d26752008-02-17 14:12:10 +01001456 tosym, fromsym, tosym);
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001457 free(prl_from);
1458 free(prl_to);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001459 break;
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001460 case ANY_INIT_TO_ANY_EXIT:
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001461 prl_from = sec2annotation(fromsec);
1462 prl_to = sec2annotation(tosec);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001463 fprintf(stderr,
1464 "The %s %s%s%s references\n"
1465 "a %s %s%s%s.\n"
1466 "This is often seen when error handling "
1467 "in the init function\n"
1468 "uses functionality in the exit path.\n"
1469 "The fix is often to remove the %sannotation of\n"
1470 "%s%s so it may be used outside an exit section.\n",
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001471 from, prl_from, fromsym, from_p,
1472 to, prl_to, tosym, to_p,
Andrew Morton5003bab2010-08-11 00:42:26 -07001473 prl_to, tosym, to_p);
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001474 free(prl_from);
1475 free(prl_to);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001476 break;
Uwe Kleine-Königbbd3f4f2010-01-30 16:35:47 +01001477 case ANY_EXIT_TO_ANY_INIT:
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001478 prl_from = sec2annotation(fromsec);
1479 prl_to = sec2annotation(tosec);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001480 fprintf(stderr,
1481 "The %s %s%s%s references\n"
1482 "a %s %s%s%s.\n"
1483 "This is often seen when error handling "
1484 "in the exit function\n"
1485 "uses functionality in the init path.\n"
1486 "The fix is often to remove the %sannotation of\n"
1487 "%s%s so it may be used outside an init section.\n",
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001488 from, prl_from, fromsym, from_p,
1489 to, prl_to, tosym, to_p,
1490 prl_to, tosym, to_p);
1491 free(prl_from);
1492 free(prl_to);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001493 break;
1494 case EXPORT_TO_INIT_EXIT:
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001495 prl_to = sec2annotation(tosec);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001496 fprintf(stderr,
1497 "The symbol %s is exported and annotated %s\n"
1498 "Fix this by removing the %sannotation of %s "
1499 "or drop the export.\n",
Alexey Fomenko37ed19d2010-08-09 17:20:24 -07001500 tosym, prl_to, prl_to, tosym);
1501 free(prl_to);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001502 break;
Quentin Casasnovas52dc0592015-04-13 20:52:53 +09301503 case EXTABLE_TO_NON_TEXT:
1504 fatal("There's a special handler for this mismatch type, "
1505 "we should never get here.");
1506 break;
Sam Ravnborg588ccd72008-01-24 21:12:37 +01001507 }
1508 fprintf(stderr, "\n");
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001509}
1510
Quentin Casasnovas644e8f12015-04-13 20:43:17 +09301511static void default_mismatch_handler(const char *modname, struct elf_info *elf,
1512 const struct sectioncheck* const mismatch,
1513 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1514{
1515 const char *tosec;
1516 Elf_Sym *to;
1517 Elf_Sym *from;
1518 const char *tosym;
1519 const char *fromsym;
1520
Quentin Casasnovas644e8f12015-04-13 20:43:17 +09301521 from = find_elf_symbol2(elf, r->r_offset, fromsec);
1522 fromsym = sym_name(elf, from);
Quentin Casasnovas644e8f12015-04-13 20:43:17 +09301523
1524 if (!strncmp(fromsym, "reference___initcall",
1525 sizeof("reference___initcall")-1))
1526 return;
1527
Quentin Casasnovasc7a65e02015-04-13 20:43:45 +09301528 tosec = sec_name(elf, get_secindex(elf, sym));
1529 to = find_elf_symbol(elf, r->r_addend, sym);
1530 tosym = sym_name(elf, to);
1531
Quentin Casasnovas644e8f12015-04-13 20:43:17 +09301532 /* check whitelist - we may ignore it */
1533 if (secref_whitelist(mismatch,
1534 fromsec, fromsym, tosec, tosym)) {
1535 report_sec_mismatch(modname, mismatch,
1536 fromsec, r->r_offset, fromsym,
1537 is_function(from), tosec, tosym,
1538 is_function(to));
1539 }
1540}
1541
Quentin Casasnovas52dc0592015-04-13 20:52:53 +09301542static int is_executable_section(struct elf_info* elf, unsigned int section_index)
1543{
1544 if (section_index > elf->num_sections)
1545 fatal("section_index is outside elf->num_sections!\n");
1546
1547 return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR);
1548}
1549
1550/*
1551 * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
1552 * to know the sizeof(struct exception_table_entry) for the target architecture.
1553 */
1554static unsigned int extable_entry_size = 0;
Quentin Casasnovase84048a2015-04-16 13:05:36 +09301555static void find_extable_entry_size(const char* const sec, const Elf_Rela* r)
Quentin Casasnovas52dc0592015-04-13 20:52:53 +09301556{
1557 /*
1558 * If we're currently checking the second relocation within __ex_table,
1559 * that relocation offset tells us the offsetof(struct
1560 * exception_table_entry, fixup) which is equal to sizeof(struct
1561 * exception_table_entry) divided by two. We use that to our advantage
1562 * since there's no portable way to get that size as every architecture
1563 * seems to go with different sized types. Not pretty but better than
1564 * hard-coding the size for every architecture..
1565 */
Quentin Casasnovase84048a2015-04-16 13:05:36 +09301566 if (!extable_entry_size)
Quentin Casasnovas52dc0592015-04-13 20:52:53 +09301567 extable_entry_size = r->r_offset * 2;
1568}
Quentin Casasnovase84048a2015-04-16 13:05:36 +09301569
Quentin Casasnovas52dc0592015-04-13 20:52:53 +09301570static inline bool is_extable_fault_address(Elf_Rela *r)
1571{
Quentin Casasnovasd3df4de2015-04-16 13:03:32 +09301572 /*
1573 * extable_entry_size is only discovered after we've handled the
1574 * _second_ relocation in __ex_table, so only abort when we're not
1575 * handling the first reloc and extable_entry_size is zero.
1576 */
1577 if (r->r_offset && extable_entry_size == 0)
Quentin Casasnovas52dc0592015-04-13 20:52:53 +09301578 fatal("extable_entry size hasn't been discovered!\n");
1579
1580 return ((r->r_offset == 0) ||
1581 (r->r_offset % extable_entry_size == 0));
1582}
1583
Quentin Casasnovase84048a2015-04-16 13:05:36 +09301584#define is_second_extable_reloc(Start, Cur, Sec) \
1585 (((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
1586
Quentin Casasnovas52dc0592015-04-13 20:52:53 +09301587static void report_extable_warnings(const char* modname, struct elf_info* elf,
1588 const struct sectioncheck* const mismatch,
1589 Elf_Rela* r, Elf_Sym* sym,
1590 const char* fromsec, const char* tosec)
1591{
1592 Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec);
1593 const char* fromsym_name = sym_name(elf, fromsym);
1594 Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym);
1595 const char* tosym_name = sym_name(elf, tosym);
1596 const char* from_pretty_name;
1597 const char* from_pretty_name_p;
1598 const char* to_pretty_name;
1599 const char* to_pretty_name_p;
1600
1601 get_pretty_name(is_function(fromsym),
1602 &from_pretty_name, &from_pretty_name_p);
1603 get_pretty_name(is_function(tosym),
1604 &to_pretty_name, &to_pretty_name_p);
1605
1606 warn("%s(%s+0x%lx): Section mismatch in reference"
1607 " from the %s %s%s to the %s %s:%s%s\n",
1608 modname, fromsec, (long)r->r_offset, from_pretty_name,
1609 fromsym_name, from_pretty_name_p,
1610 to_pretty_name, tosec, tosym_name, to_pretty_name_p);
1611
1612 if (!match(tosec, mismatch->bad_tosec) &&
1613 is_executable_section(elf, get_secindex(elf, sym)))
1614 fprintf(stderr,
1615 "The relocation at %s+0x%lx references\n"
1616 "section \"%s\" which is not in the list of\n"
1617 "authorized sections. If you're adding a new section\n"
1618 "and/or if this reference is valid, add \"%s\" to the\n"
1619 "list of authorized sections to jump to on fault.\n"
1620 "This can be achieved by adding \"%s\" to \n"
1621 "OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1622 fromsec, (long)r->r_offset, tosec, tosec, tosec);
1623}
1624
1625static void extable_mismatch_handler(const char* modname, struct elf_info *elf,
1626 const struct sectioncheck* const mismatch,
1627 Elf_Rela* r, Elf_Sym* sym,
1628 const char *fromsec)
1629{
1630 const char* tosec = sec_name(elf, get_secindex(elf, sym));
1631
1632 sec_mismatch_count++;
1633
1634 if (sec_mismatch_verbose)
1635 report_extable_warnings(modname, elf, mismatch, r, sym,
1636 fromsec, tosec);
1637
1638 if (match(tosec, mismatch->bad_tosec))
1639 fatal("The relocation at %s+0x%lx references\n"
1640 "section \"%s\" which is black-listed.\n"
1641 "Something is seriously wrong and should be fixed.\n"
1642 "You might get more information about where this is\n"
1643 "coming from by using scripts/check_extable.sh %s\n",
1644 fromsec, (long)r->r_offset, tosec, modname);
1645 else if (!is_executable_section(elf, get_secindex(elf, sym))) {
1646 if (is_extable_fault_address(r))
1647 fatal("The relocation at %s+0x%lx references\n"
1648 "section \"%s\" which is not executable, IOW\n"
1649 "it is not possible for the kernel to fault\n"
1650 "at that address. Something is seriously wrong\n"
1651 "and should be fixed.\n",
1652 fromsec, (long)r->r_offset, tosec);
1653 else
1654 fatal("The relocation at %s+0x%lx references\n"
1655 "section \"%s\" which is not executable, IOW\n"
1656 "the kernel will fault if it ever tries to\n"
1657 "jump to it. Something is seriously wrong\n"
1658 "and should be fixed.\n",
1659 fromsec, (long)r->r_offset, tosec);
1660 }
1661}
1662
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001663static void check_section_mismatch(const char *modname, struct elf_info *elf,
Masahiro Yamadabb66fc62014-06-10 19:08:13 +09001664 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001665{
Quentin Casasnovas644e8f12015-04-13 20:43:17 +09301666 const char *tosec = sec_name(elf, get_secindex(elf, sym));;
1667 const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec);
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001668
Uwe Kleine-König0d2a6362010-01-30 16:56:20 +01001669 if (mismatch) {
Quentin Casasnovas644e8f12015-04-13 20:43:17 +09301670 if (mismatch->handler)
1671 mismatch->handler(modname, elf, mismatch,
1672 r, sym, fromsec);
1673 else
1674 default_mismatch_handler(modname, elf, mismatch,
1675 r, sym, fromsec);
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001676 }
1677}
1678
Atsushi Nemotoae4ac122007-05-22 18:27:39 +09001679static unsigned int *reloc_location(struct elf_info *elf,
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001680 Elf_Shdr *sechdr, Elf_Rela *r)
Atsushi Nemotoae4ac122007-05-22 18:27:39 +09001681{
1682 Elf_Shdr *sechdrs = elf->sechdrs;
Anders Kaseorg68457562011-05-19 16:55:27 -06001683 int section = sechdr->sh_info;
Atsushi Nemotoae4ac122007-05-22 18:27:39 +09001684
1685 return (void *)elf->hdr + sechdrs[section].sh_offset +
Olof Johansson731ece42010-12-10 02:09:23 -06001686 r->r_offset;
Atsushi Nemotoae4ac122007-05-22 18:27:39 +09001687}
1688
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001689static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
Atsushi Nemotoae4ac122007-05-22 18:27:39 +09001690{
1691 unsigned int r_typ = ELF_R_TYPE(r->r_info);
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001692 unsigned int *location = reloc_location(elf, sechdr, r);
Atsushi Nemotoae4ac122007-05-22 18:27:39 +09001693
1694 switch (r_typ) {
1695 case R_386_32:
1696 r->r_addend = TO_NATIVE(*location);
1697 break;
1698 case R_386_PC32:
1699 r->r_addend = TO_NATIVE(*location) + 4;
1700 /* For CONFIG_RELOCATABLE=y */
1701 if (elf->hdr->e_type == ET_EXEC)
1702 r->r_addend += r->r_offset;
1703 break;
1704 }
1705 return 0;
1706}
1707
Tony Lindgren6e2e3402012-02-14 21:58:56 +01001708#ifndef R_ARM_CALL
1709#define R_ARM_CALL 28
1710#endif
1711#ifndef R_ARM_JUMP24
1712#define R_ARM_JUMP24 29
1713#endif
1714
David A. Longc9698e52014-02-14 22:41:18 +01001715#ifndef R_ARM_THM_CALL
1716#define R_ARM_THM_CALL 10
1717#endif
1718#ifndef R_ARM_THM_JUMP24
1719#define R_ARM_THM_JUMP24 30
1720#endif
1721#ifndef R_ARM_THM_JUMP19
1722#define R_ARM_THM_JUMP19 51
1723#endif
1724
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001725static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
Sam Ravnborg56a974f2007-07-16 22:39:35 +02001726{
1727 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1728
1729 switch (r_typ) {
1730 case R_ARM_ABS32:
1731 /* From ARM ABI: (S + A) | T */
Sam Ravnborgdf578e72008-01-11 19:17:15 +01001732 r->r_addend = (int)(long)
Masahiro Yamadabb66fc62014-06-10 19:08:13 +09001733 (elf->symtab_start + ELF_R_SYM(r->r_info));
Sam Ravnborg56a974f2007-07-16 22:39:35 +02001734 break;
1735 case R_ARM_PC24:
Tony Lindgren6e2e3402012-02-14 21:58:56 +01001736 case R_ARM_CALL:
1737 case R_ARM_JUMP24:
David A. Longc9698e52014-02-14 22:41:18 +01001738 case R_ARM_THM_CALL:
1739 case R_ARM_THM_JUMP24:
1740 case R_ARM_THM_JUMP19:
Sam Ravnborg56a974f2007-07-16 22:39:35 +02001741 /* From ARM ABI: ((S + A) | T) - P */
Sam Ravnborgdf578e72008-01-11 19:17:15 +01001742 r->r_addend = (int)(long)(elf->hdr +
Masahiro Yamadabb66fc62014-06-10 19:08:13 +09001743 sechdr->sh_offset +
1744 (r->r_offset - sechdr->sh_addr));
Sam Ravnborg56a974f2007-07-16 22:39:35 +02001745 break;
1746 default:
1747 return 1;
1748 }
1749 return 0;
1750}
1751
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001752static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
Atsushi Nemotoae4ac122007-05-22 18:27:39 +09001753{
1754 unsigned int r_typ = ELF_R_TYPE(r->r_info);
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001755 unsigned int *location = reloc_location(elf, sechdr, r);
Atsushi Nemotoae4ac122007-05-22 18:27:39 +09001756 unsigned int inst;
1757
1758 if (r_typ == R_MIPS_HI16)
1759 return 1; /* skip this */
1760 inst = TO_NATIVE(*location);
1761 switch (r_typ) {
1762 case R_MIPS_LO16:
1763 r->r_addend = inst & 0xffff;
1764 break;
1765 case R_MIPS_26:
1766 r->r_addend = (inst & 0x03ffffff) << 2;
1767 break;
1768 case R_MIPS_32:
1769 r->r_addend = inst;
1770 break;
1771 }
1772 return 0;
1773}
1774
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001775static void section_rela(const char *modname, struct elf_info *elf,
Masahiro Yamadabb66fc62014-06-10 19:08:13 +09001776 Elf_Shdr *sechdr)
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001777{
1778 Elf_Sym *sym;
1779 Elf_Rela *rela;
1780 Elf_Rela r;
1781 unsigned int r_sym;
1782 const char *fromsec;
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001783
Sam Ravnborgff13f922008-01-23 19:54:27 +01001784 Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001785 Elf_Rela *stop = (void *)start + sechdr->sh_size;
1786
Sam Ravnborgff13f922008-01-23 19:54:27 +01001787 fromsec = sech_name(elf, sechdr);
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001788 fromsec += strlen(".rela");
1789 /* if from section (name) is know good then skip it */
Anders Kaseorgb614a692009-04-23 16:49:33 -04001790 if (match(fromsec, section_white_list))
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001791 return;
Sam Ravnborge241a632008-01-28 20:13:13 +01001792
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001793 for (rela = start; rela < stop; rela++) {
1794 r.r_offset = TO_NATIVE(rela->r_offset);
1795#if KERNEL_ELFCLASS == ELFCLASS64
Sam Ravnborgff13f922008-01-23 19:54:27 +01001796 if (elf->hdr->e_machine == EM_MIPS) {
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001797 unsigned int r_typ;
1798 r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1799 r_sym = TO_NATIVE(r_sym);
1800 r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1801 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1802 } else {
1803 r.r_info = TO_NATIVE(rela->r_info);
1804 r_sym = ELF_R_SYM(r.r_info);
1805 }
1806#else
1807 r.r_info = TO_NATIVE(rela->r_info);
1808 r_sym = ELF_R_SYM(r.r_info);
1809#endif
1810 r.r_addend = TO_NATIVE(rela->r_addend);
1811 sym = elf->symtab_start + r_sym;
1812 /* Skip special sections */
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +02001813 if (is_shndx_special(sym->st_shndx))
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001814 continue;
Quentin Casasnovase84048a2015-04-16 13:05:36 +09301815 if (is_second_extable_reloc(start, rela, fromsec))
1816 find_extable_entry_size(fromsec, &r);
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001817 check_section_mismatch(modname, elf, &r, sym, fromsec);
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001818 }
1819}
1820
1821static void section_rel(const char *modname, struct elf_info *elf,
Masahiro Yamadabb66fc62014-06-10 19:08:13 +09001822 Elf_Shdr *sechdr)
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001823{
1824 Elf_Sym *sym;
1825 Elf_Rel *rel;
1826 Elf_Rela r;
1827 unsigned int r_sym;
1828 const char *fromsec;
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001829
Sam Ravnborgff13f922008-01-23 19:54:27 +01001830 Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001831 Elf_Rel *stop = (void *)start + sechdr->sh_size;
1832
Sam Ravnborgff13f922008-01-23 19:54:27 +01001833 fromsec = sech_name(elf, sechdr);
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001834 fromsec += strlen(".rel");
1835 /* if from section (name) is know good then skip it */
Anders Kaseorgb614a692009-04-23 16:49:33 -04001836 if (match(fromsec, section_white_list))
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001837 return;
1838
1839 for (rel = start; rel < stop; rel++) {
1840 r.r_offset = TO_NATIVE(rel->r_offset);
1841#if KERNEL_ELFCLASS == ELFCLASS64
Sam Ravnborgff13f922008-01-23 19:54:27 +01001842 if (elf->hdr->e_machine == EM_MIPS) {
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001843 unsigned int r_typ;
1844 r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1845 r_sym = TO_NATIVE(r_sym);
1846 r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1847 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1848 } else {
1849 r.r_info = TO_NATIVE(rel->r_info);
1850 r_sym = ELF_R_SYM(r.r_info);
1851 }
1852#else
1853 r.r_info = TO_NATIVE(rel->r_info);
1854 r_sym = ELF_R_SYM(r.r_info);
1855#endif
1856 r.r_addend = 0;
Sam Ravnborgff13f922008-01-23 19:54:27 +01001857 switch (elf->hdr->e_machine) {
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001858 case EM_386:
1859 if (addend_386_rel(elf, sechdr, &r))
1860 continue;
1861 break;
1862 case EM_ARM:
1863 if (addend_arm_rel(elf, sechdr, &r))
1864 continue;
1865 break;
1866 case EM_MIPS:
1867 if (addend_mips_rel(elf, sechdr, &r))
1868 continue;
1869 break;
1870 }
1871 sym = elf->symtab_start + r_sym;
1872 /* Skip special sections */
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +02001873 if (is_shndx_special(sym->st_shndx))
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001874 continue;
Quentin Casasnovase84048a2015-04-16 13:05:36 +09301875 if (is_second_extable_reloc(start, rel, fromsec))
1876 find_extable_entry_size(fromsec, &r);
Sam Ravnborg58fb0d42008-01-23 21:13:50 +01001877 check_section_mismatch(modname, elf, &r, sym, fromsec);
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001878 }
1879}
1880
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001881/**
1882 * A module includes a number of sections that are discarded
1883 * either when loaded or when used as built-in.
1884 * For loaded modules all functions marked __init and all data
Uwe Kleine-Königb5950762010-11-01 15:38:34 -04001885 * marked __initdata will be discarded when the module has been initialized.
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001886 * Likewise for modules used built-in the sections marked __exit
1887 * are discarded because __exit marked function are supposed to be called
Ben Dooks32be1d22008-07-29 22:33:44 -07001888 * only when a module is unloaded which never happens for built-in modules.
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001889 * The check_sec_ref() function traverses all relocation records
1890 * to find all references to a section that reference a section that will
1891 * be discarded and warns about it.
1892 **/
1893static void check_sec_ref(struct module *mod, const char *modname,
Masahiro Yamadabb66fc62014-06-10 19:08:13 +09001894 struct elf_info *elf)
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001895{
1896 int i;
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001897 Elf_Shdr *sechdrs = elf->sechdrs;
Sam Ravnborg62070fa2006-03-03 16:46:04 +01001898
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001899 /* Walk through all sections */
Denys Vlasenko1ce53ad2010-07-29 01:47:53 +02001900 for (i = 0; i < elf->num_sections; i++) {
Anders Kaseorgb614a692009-04-23 16:49:33 -04001901 check_section(modname, elf, &elf->sechdrs[i]);
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001902 /* We want to process only relocation sections and not .init */
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001903 if (sechdrs[i].sh_type == SHT_RELA)
Sam Ravnborg10668222008-01-13 22:21:31 +01001904 section_rela(modname, elf, &elf->sechdrs[i]);
Sam Ravnborg5b24c072008-01-18 21:49:29 +01001905 else if (sechdrs[i].sh_type == SHT_REL)
Sam Ravnborg10668222008-01-13 22:21:31 +01001906 section_rel(modname, elf, &elf->sechdrs[i]);
Sam Ravnborgb39927c2006-02-17 22:42:02 +01001907 }
1908}
1909
Andi Kleen7d02b492014-02-08 09:01:12 +01001910static char *remove_dot(char *s)
1911{
Michal Nazarewiczfcd38ed2014-07-27 07:27:01 +09301912 size_t n = strcspn(s, ".");
Andi Kleen7d02b492014-02-08 09:01:12 +01001913
Michal Nazarewiczfcd38ed2014-07-27 07:27:01 +09301914 if (n && s[n]) {
1915 size_t m = strspn(s + n + 1, "0123456789");
1916 if (m && (s[n + m] == '.' || s[n + m] == 0))
Andi Kleen7d02b492014-02-08 09:01:12 +01001917 s[n] = 0;
1918 }
1919 return s;
1920}
1921
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01001922static void read_symbols(char *modname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923{
1924 const char *symname;
1925 char *version;
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02001926 char *license;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927 struct module *mod;
1928 struct elf_info info = { };
1929 Elf_Sym *sym;
1930
Sam Ravnborg85bd2fd2007-02-26 15:33:52 +01001931 if (!parse_elf(&info, modname))
1932 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933
1934 mod = new_module(modname);
1935
1936 /* When there's no vmlinux, don't print warnings about
1937 * unresolved symbols (since there'll be too many ;) */
1938 if (is_vmlinux(modname)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 have_vmlinux = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 mod->skip = 1;
1941 }
1942
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02001943 license = get_modinfo(info.modinfo, info.modinfo_len, "license");
Sam Ravnborg2fa36562008-04-26 21:07:26 +02001944 if (info.modinfo && !license && !is_vmlinux(modname))
1945 warn("modpost: missing MODULE_LICENSE() in %s\n"
1946 "see include/linux/module.h for "
1947 "more information\n", modname);
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02001948 while (license) {
1949 if (license_is_gpl_compatible(license))
1950 mod->gpl_compatible = 1;
1951 else {
1952 mod->gpl_compatible = 0;
1953 break;
1954 }
1955 license = get_next_modinfo(info.modinfo, info.modinfo_len,
1956 "license", license);
1957 }
1958
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
Andi Kleen7d02b492014-02-08 09:01:12 +01001960 symname = remove_dot(info.strtab + sym->st_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961
1962 handle_modversions(mod, &info, sym, symname);
1963 handle_moddevtable(mod, &info, sym, symname);
1964 }
Sam Ravnborgd1f25e62008-01-17 21:17:42 +01001965 if (!is_vmlinux(modname) ||
Sam Ravnborg10668222008-01-13 22:21:31 +01001966 (is_vmlinux(modname) && vmlinux_section_warnings))
1967 check_sec_ref(mod, modname, &info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968
1969 version = get_modinfo(info.modinfo, info.modinfo_len, "version");
1970 if (version)
1971 maybe_frob_rcs_version(modname, version, info.modinfo,
1972 version - (char *)info.hdr);
1973 if (version || (all_versions && !is_vmlinux(modname)))
1974 get_src_version(modname, mod->srcversion,
1975 sizeof(mod->srcversion)-1);
1976
1977 parse_elf_finish(&info);
1978
Rusty Russell8c8ef422009-03-31 13:05:34 -06001979 /* Our trick to get versioning for module struct etc. - it's
Linus Torvalds1da177e2005-04-16 15:20:36 -07001980 * never passed as an argument to an exported function, so
1981 * the automatic versioning doesn't pick it up, but it's really
1982 * important anyhow */
1983 if (modversions)
Rusty Russell8c8ef422009-03-31 13:05:34 -06001984 mod->unres = alloc_symbol("module_layout", 0, mod->unres);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985}
1986
Rusty Russell712f9b42013-04-04 17:37:38 +10301987static void read_symbols_from_files(const char *filename)
1988{
1989 FILE *in = stdin;
1990 char fname[PATH_MAX];
1991
1992 if (strcmp(filename, "-") != 0) {
1993 in = fopen(filename, "r");
1994 if (!in)
1995 fatal("Can't open filenames file %s: %m", filename);
1996 }
1997
1998 while (fgets(fname, PATH_MAX, in) != NULL) {
1999 if (strends(fname, "\n"))
2000 fname[strlen(fname)-1] = '\0';
2001 read_symbols(fname);
2002 }
2003
2004 if (in != stdin)
2005 fclose(in);
2006}
2007
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008#define SZ 500
2009
2010/* We first write the generated file into memory using the
2011 * following helper, then compare to the file on disk and
2012 * only update the later if anything changed */
2013
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01002014void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
2015 const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016{
2017 char tmp[SZ];
2018 int len;
2019 va_list ap;
Sam Ravnborg62070fa2006-03-03 16:46:04 +01002020
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021 va_start(ap, fmt);
2022 len = vsnprintf(tmp, SZ, fmt, ap);
Sam Ravnborg7670f022006-03-16 23:04:08 -08002023 buf_write(buf, tmp, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024 va_end(ap);
2025}
2026
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01002027void buf_write(struct buffer *buf, const char *s, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028{
2029 if (buf->size - buf->pos < len) {
Sam Ravnborg7670f022006-03-16 23:04:08 -08002030 buf->size += len + SZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031 buf->p = realloc(buf->p, buf->size);
2032 }
2033 strncpy(buf->p + buf->pos, s, len);
2034 buf->pos += len;
2035}
2036
Sam Ravnborgc96fca22006-07-01 11:44:23 +02002037static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
2038{
2039 const char *e = is_vmlinux(m) ?"":".ko";
2040
2041 switch (exp) {
2042 case export_gpl:
2043 fatal("modpost: GPL-incompatible module %s%s "
2044 "uses GPL-only symbol '%s'\n", m, e, s);
2045 break;
2046 case export_unused_gpl:
2047 fatal("modpost: GPL-incompatible module %s%s "
2048 "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s);
2049 break;
2050 case export_gpl_future:
2051 warn("modpost: GPL-incompatible module %s%s "
2052 "uses future GPL-only symbol '%s'\n", m, e, s);
2053 break;
2054 case export_plain:
2055 case export_unused:
2056 case export_unknown:
2057 /* ignore */
2058 break;
2059 }
2060}
2061
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002062static void check_for_unused(enum export exp, const char *m, const char *s)
Sam Ravnborgc96fca22006-07-01 11:44:23 +02002063{
2064 const char *e = is_vmlinux(m) ?"":".ko";
2065
2066 switch (exp) {
2067 case export_unused:
2068 case export_unused_gpl:
2069 warn("modpost: module %s%s "
2070 "uses symbol '%s' marked UNUSED\n", m, e, s);
2071 break;
2072 default:
2073 /* ignore */
2074 break;
2075 }
2076}
2077
2078static void check_exports(struct module *mod)
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02002079{
2080 struct symbol *s, *exp;
2081
2082 for (s = mod->unres; s; s = s->next) {
Andrew Morton6449bd62006-06-09 20:45:06 -07002083 const char *basename;
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02002084 exp = find_symbol(s->name);
2085 if (!exp || exp->module == mod)
2086 continue;
Andrew Morton6449bd62006-06-09 20:45:06 -07002087 basename = strrchr(mod->name, '/');
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02002088 if (basename)
2089 basename++;
Sam Ravnborgc96fca22006-07-01 11:44:23 +02002090 else
2091 basename = mod->name;
2092 if (!mod->gpl_compatible)
2093 check_for_gpl_usage(exp->export, basename, exp->name);
2094 check_for_unused(exp->export, basename, exp->name);
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002095 }
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02002096}
2097
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01002098/**
2099 * Header for the generated file
2100 **/
2101static void add_header(struct buffer *b, struct module *mod)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102{
2103 buf_printf(b, "#include <linux/module.h>\n");
2104 buf_printf(b, "#include <linux/vermagic.h>\n");
2105 buf_printf(b, "#include <linux/compiler.h>\n");
2106 buf_printf(b, "\n");
2107 buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
2108 buf_printf(b, "\n");
Andi Kleene0f244c2013-10-23 10:57:58 +10302109 buf_printf(b, "__visible struct module __this_module\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110 buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n");
Greg Kroah-Hartman3c7ec942012-04-25 11:10:15 -07002111 buf_printf(b, "\t.name = KBUILD_MODNAME,\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112 if (mod->has_init)
Greg Kroah-Hartman3c7ec942012-04-25 11:10:15 -07002113 buf_printf(b, "\t.init = init_module,\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114 if (mod->has_cleanup)
2115 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
Greg Kroah-Hartman3c7ec942012-04-25 11:10:15 -07002116 "\t.exit = cleanup_module,\n"
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117 "#endif\n");
Greg Kroah-Hartman3c7ec942012-04-25 11:10:15 -07002118 buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119 buf_printf(b, "};\n");
2120}
2121
Ben Hutchings2449b8b2011-10-24 15:12:28 +02002122static void add_intree_flag(struct buffer *b, int is_intree)
2123{
2124 if (is_intree)
2125 buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
2126}
2127
Trevor Keith5c725132009-09-22 16:43:38 -07002128static void add_staging_flag(struct buffer *b, const char *name)
Greg Kroah-Hartmana9860bf2008-09-24 14:46:44 -07002129{
2130 static const char *staging_dir = "drivers/staging";
2131
2132 if (strncmp(staging_dir, name, strlen(staging_dir)) == 0)
2133 buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
2134}
2135
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01002136/**
2137 * Record CRCs for unresolved symbols
2138 **/
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002139static int add_versions(struct buffer *b, struct module *mod)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140{
2141 struct symbol *s, *exp;
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002142 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143
2144 for (s = mod->unres; s; s = s->next) {
2145 exp = find_symbol(s->name);
2146 if (!exp || exp->module == mod) {
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002147 if (have_vmlinux && !s->weak) {
Matthew Wilcox2a116652006-10-07 05:35:32 -06002148 if (warn_unresolved) {
2149 warn("\"%s\" [%s.ko] undefined!\n",
2150 s->name, mod->name);
2151 } else {
2152 merror("\"%s\" [%s.ko] undefined!\n",
Masahiro Yamadabb66fc62014-06-10 19:08:13 +09002153 s->name, mod->name);
Matthew Wilcox2a116652006-10-07 05:35:32 -06002154 err = 1;
2155 }
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002156 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157 continue;
2158 }
2159 s->module = exp->module;
2160 s->crc_valid = exp->crc_valid;
2161 s->crc = exp->crc;
2162 }
2163
2164 if (!modversions)
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002165 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166
2167 buf_printf(b, "\n");
2168 buf_printf(b, "static const struct modversion_info ____versions[]\n");
Adrian Bunk3ff6eec2008-01-24 22:16:20 +01002169 buf_printf(b, "__used\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170 buf_printf(b, "__attribute__((section(\"__versions\"))) = {\n");
2171
2172 for (s = mod->unres; s; s = s->next) {
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002173 if (!s->module)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175 if (!s->crc_valid) {
Sam Ravnborgcb805142006-01-28 16:57:26 +01002176 warn("\"%s\" [%s.ko] has no CRC!\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 s->name, mod->name);
2178 continue;
2179 }
James Hogana53a11f32013-04-29 11:36:59 +09302180 buf_printf(b, "\t{ %#8x, __VMLINUX_SYMBOL_STR(%s) },\n",
James Hogana4b6a772013-03-18 19:38:56 +10302181 s->crc, s->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182 }
2183
2184 buf_printf(b, "};\n");
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002185
2186 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187}
2188
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01002189static void add_depends(struct buffer *b, struct module *mod,
2190 struct module *modules)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191{
2192 struct symbol *s;
2193 struct module *m;
2194 int first = 1;
2195
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002196 for (m = modules; m; m = m->next)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197 m->seen = is_vmlinux(m->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198
2199 buf_printf(b, "\n");
2200 buf_printf(b, "static const char __module_depends[]\n");
Adrian Bunk3ff6eec2008-01-24 22:16:20 +01002201 buf_printf(b, "__used\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202 buf_printf(b, "__attribute__((section(\".modinfo\"))) =\n");
2203 buf_printf(b, "\"depends=");
2204 for (s = mod->unres; s; s = s->next) {
Sam Ravnborga61b2df2007-02-26 19:46:52 +01002205 const char *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206 if (!s->module)
2207 continue;
2208
2209 if (s->module->seen)
2210 continue;
2211
2212 s->module->seen = 1;
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002213 p = strrchr(s->module->name, '/');
2214 if (p)
Sam Ravnborga61b2df2007-02-26 19:46:52 +01002215 p++;
2216 else
2217 p = s->module->name;
2218 buf_printf(b, "%s%s", first ? "" : ",", p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002219 first = 0;
2220 }
2221 buf_printf(b, "\";\n");
2222}
2223
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01002224static void add_srcversion(struct buffer *b, struct module *mod)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225{
2226 if (mod->srcversion[0]) {
2227 buf_printf(b, "\n");
2228 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
2229 mod->srcversion);
2230 }
2231}
2232
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01002233static void write_if_changed(struct buffer *b, const char *fname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234{
2235 char *tmp;
2236 FILE *file;
2237 struct stat st;
2238
2239 file = fopen(fname, "r");
2240 if (!file)
2241 goto write;
2242
2243 if (fstat(fileno(file), &st) < 0)
2244 goto close_write;
2245
2246 if (st.st_size != b->pos)
2247 goto close_write;
2248
2249 tmp = NOFAIL(malloc(b->pos));
2250 if (fread(tmp, 1, b->pos, file) != b->pos)
2251 goto free_write;
2252
2253 if (memcmp(tmp, b->p, b->pos) != 0)
2254 goto free_write;
2255
2256 free(tmp);
2257 fclose(file);
2258 return;
2259
2260 free_write:
2261 free(tmp);
2262 close_write:
2263 fclose(file);
2264 write:
2265 file = fopen(fname, "w");
2266 if (!file) {
2267 perror(fname);
2268 exit(1);
2269 }
2270 if (fwrite(b->p, 1, b->pos, file) != b->pos) {
2271 perror(fname);
2272 exit(1);
2273 }
2274 fclose(file);
2275}
2276
Ram Paibd5cbce2006-06-08 22:12:53 -07002277/* parse Module.symvers file. line format:
Sam Ravnborg534b89a2006-07-01 10:10:19 +02002278 * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something]
Ram Paibd5cbce2006-06-08 22:12:53 -07002279 **/
Sam Ravnborg040fcc82006-01-28 22:15:55 +01002280static void read_dump(const char *fname, unsigned int kernel)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281{
2282 unsigned long size, pos = 0;
2283 void *file = grab_file(fname, &size);
2284 char *line;
2285
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002286 if (!file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287 /* No symbol versions, silently ignore */
2288 return;
2289
2290 while ((line = get_next_line(&pos, file, size))) {
Sam Ravnborg534b89a2006-07-01 10:10:19 +02002291 char *symname, *modname, *d, *export, *end;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002292 unsigned int crc;
2293 struct module *mod;
Sam Ravnborg040fcc82006-01-28 22:15:55 +01002294 struct symbol *s;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295
2296 if (!(symname = strchr(line, '\t')))
2297 goto fail;
2298 *symname++ = '\0';
2299 if (!(modname = strchr(symname, '\t')))
2300 goto fail;
2301 *modname++ = '\0';
Laurent Riffard9ac545b2006-06-11 08:02:06 +02002302 if ((export = strchr(modname, '\t')) != NULL)
Ram Paibd5cbce2006-06-08 22:12:53 -07002303 *export++ = '\0';
Sam Ravnborg534b89a2006-07-01 10:10:19 +02002304 if (export && ((end = strchr(export, '\t')) != NULL))
2305 *end = '\0';
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306 crc = strtoul(line, &d, 16);
2307 if (*symname == '\0' || *modname == '\0' || *d != '\0')
2308 goto fail;
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002309 mod = find_module(modname);
2310 if (!mod) {
2311 if (is_vmlinux(modname))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002312 have_vmlinux = 1;
Jan Beulich0fa3a882009-03-12 12:28:30 +00002313 mod = new_module(modname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314 mod->skip = 1;
2315 }
Ram Paibd5cbce2006-06-08 22:12:53 -07002316 s = sym_add_exported(symname, mod, export_no(export));
Sam Ravnborg8e70c452006-01-28 22:22:33 +01002317 s->kernel = kernel;
2318 s->preloaded = 1;
Ram Paibd5cbce2006-06-08 22:12:53 -07002319 sym_update_crc(symname, mod, crc, export_no(export));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320 }
Christian Engelmayer2ee41e62014-04-28 11:34:32 +09302321 release_file(file, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322 return;
2323fail:
Christian Engelmayer2ee41e62014-04-28 11:34:32 +09302324 release_file(file, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325 fatal("parse error in symbol dump file\n");
2326}
2327
Sam Ravnborg040fcc82006-01-28 22:15:55 +01002328/* For normal builds always dump all symbols.
2329 * For external modules only dump symbols
2330 * that are not read from kernel Module.symvers.
2331 **/
2332static int dump_sym(struct symbol *sym)
2333{
2334 if (!external_module)
2335 return 1;
2336 if (sym->vmlinux || sym->kernel)
2337 return 0;
2338 return 1;
2339}
Sam Ravnborg62070fa2006-03-03 16:46:04 +01002340
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01002341static void write_dump(const char *fname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002342{
2343 struct buffer buf = { };
2344 struct symbol *symbol;
2345 int n;
2346
2347 for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
2348 symbol = symbolhash[n];
2349 while (symbol) {
Sam Ravnborg040fcc82006-01-28 22:15:55 +01002350 if (dump_sym(symbol))
Ram Paibd5cbce2006-06-08 22:12:53 -07002351 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\n",
Sam Ravnborg62070fa2006-03-03 16:46:04 +01002352 symbol->crc, symbol->name,
Ram Paibd5cbce2006-06-08 22:12:53 -07002353 symbol->module->name,
2354 export_str(symbol->export));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002355 symbol = symbol->next;
2356 }
2357 }
2358 write_if_changed(&buf, fname);
2359}
2360
Richard Hacker2d04b5a2008-02-28 09:40:52 +01002361struct ext_sym_list {
2362 struct ext_sym_list *next;
2363 const char *file;
2364};
2365
Sam Ravnborg5c3ead82006-01-28 17:19:35 +01002366int main(int argc, char **argv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002367{
2368 struct module *mod;
2369 struct buffer buf = { };
Sam Ravnborg040fcc82006-01-28 22:15:55 +01002370 char *kernel_read = NULL, *module_read = NULL;
Rusty Russell712f9b42013-04-04 17:37:38 +10302371 char *dump_write = NULL, *files_source = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002372 int opt;
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002373 int err;
Richard Hacker2d04b5a2008-02-28 09:40:52 +01002374 struct ext_sym_list *extsym_iter;
2375 struct ext_sym_list *extsym_start = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002376
Guenter Roeckeed380f2013-09-23 15:23:54 +09302377 while ((opt = getopt(argc, argv, "i:I:e:mnsST:o:awM:K:")) != -1) {
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002378 switch (opt) {
2379 case 'i':
2380 kernel_read = optarg;
2381 break;
2382 case 'I':
2383 module_read = optarg;
2384 external_module = 1;
2385 break;
Richard Hacker2d04b5a2008-02-28 09:40:52 +01002386 case 'e':
2387 external_module = 1;
2388 extsym_iter =
2389 NOFAIL(malloc(sizeof(*extsym_iter)));
2390 extsym_iter->next = extsym_start;
2391 extsym_iter->file = optarg;
2392 extsym_start = extsym_iter;
2393 break;
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002394 case 'm':
2395 modversions = 1;
2396 break;
Guenter Roeckeed380f2013-09-23 15:23:54 +09302397 case 'n':
2398 ignore_missing_files = 1;
2399 break;
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002400 case 'o':
2401 dump_write = optarg;
2402 break;
2403 case 'a':
2404 all_versions = 1;
2405 break;
2406 case 's':
2407 vmlinux_section_warnings = 0;
2408 break;
Sam Ravnborg588ccd72008-01-24 21:12:37 +01002409 case 'S':
2410 sec_mismatch_verbose = 0;
2411 break;
Rusty Russell712f9b42013-04-04 17:37:38 +10302412 case 'T':
2413 files_source = optarg;
2414 break;
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002415 case 'w':
2416 warn_unresolved = 1;
2417 break;
2418 default:
2419 exit(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002420 }
2421 }
2422
Sam Ravnborg040fcc82006-01-28 22:15:55 +01002423 if (kernel_read)
2424 read_dump(kernel_read, 1);
2425 if (module_read)
2426 read_dump(module_read, 0);
Richard Hacker2d04b5a2008-02-28 09:40:52 +01002427 while (extsym_start) {
2428 read_dump(extsym_start->file, 0);
2429 extsym_iter = extsym_start->next;
2430 free(extsym_start);
2431 extsym_start = extsym_iter;
2432 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433
Sam Ravnborgdf578e72008-01-11 19:17:15 +01002434 while (optind < argc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002435 read_symbols(argv[optind++]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436
Rusty Russell712f9b42013-04-04 17:37:38 +10302437 if (files_source)
2438 read_symbols_from_files(files_source);
2439
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440 for (mod = modules; mod; mod = mod->next) {
2441 if (mod->skip)
2442 continue;
Sam Ravnborgc96fca22006-07-01 11:44:23 +02002443 check_exports(mod);
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02002444 }
2445
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002446 err = 0;
2447
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02002448 for (mod = modules; mod; mod = mod->next) {
Mathias Kraused93e1712014-08-27 20:28:56 +09302449 char fname[PATH_MAX];
Andi Kleen666ab412007-11-22 03:43:10 +01002450
Sam Ravnborgb817f6f2006-06-09 21:53:55 +02002451 if (mod->skip)
2452 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453
2454 buf.pos = 0;
2455
2456 add_header(&buf, mod);
Ben Hutchings2449b8b2011-10-24 15:12:28 +02002457 add_intree_flag(&buf, !external_module);
Greg Kroah-Hartmana9860bf2008-09-24 14:46:44 -07002458 add_staging_flag(&buf, mod->name);
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002459 err |= add_versions(&buf, mod);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002460 add_depends(&buf, mod, modules);
2461 add_moddevtable(&buf, mod);
2462 add_srcversion(&buf, mod);
2463
2464 sprintf(fname, "%s.mod.c", mod->name);
2465 write_if_changed(&buf, fname);
2466 }
2467
2468 if (dump_write)
2469 write_dump(dump_write);
Sam Ravnborg588ccd72008-01-24 21:12:37 +01002470 if (sec_mismatch_count && !sec_mismatch_verbose)
Geert Uytterhoeven7c0ac492008-02-05 11:38:49 +01002471 warn("modpost: Found %d section mismatch(es).\n"
2472 "To see full details build your kernel with:\n"
2473 "'make CONFIG_DEBUG_SECTION_MISMATCH=y'\n",
2474 sec_mismatch_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475
Kirill Korotaevc53ddac2006-09-07 13:08:54 -07002476 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477}