Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit af42e970b6097a34cb2b93ec4c12c2a226b1d008

Authored by Max Filippov
Committed by Chris Zankel
1 parent 717460ee3e
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

modpost: fix modpost warnings for xtensa 

Suppress warnings for two informational sections (.xt.lit and .xt.prop)
used by the Xtensa architecture.

Signed-off-by: Max Filippov <jcmvbkbc@gmail.com>
Signed-off-by: Chris Zankel <chris@zankel.net>

Showing 1 changed file with 2 additions and 0 deletions Inline Diff

scripts/mod/modpost.c
Diff comments   View file @ af42e97
1 /* Postprocess module symbol versions 1 /* Postprocess module symbol versions
2 * 2 *
3 * Copyright 2003 Kai Germaschewski 3 * Copyright 2003 Kai Germaschewski
4 * Copyright 2002-2004 Rusty Russell, IBM Corporation 4 * Copyright 2002-2004 Rusty Russell, IBM Corporation
5 * Copyright 2006-2008 Sam Ravnborg 5 * Copyright 2006-2008 Sam Ravnborg
6 * Based in part on module-init-tools/depmod.c,file2alias 6 * Based in part on module-init-tools/depmod.c,file2alias
7 * 7 *
8 * This software may be used and distributed according to the terms 8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference. 9 * of the GNU General Public License, incorporated herein by reference.
10 * 10 *
11 * Usage: modpost vmlinux module1.o module2.o ... 11 * Usage: modpost vmlinux module1.o module2.o ...
12 */ 12 */
13 13
14 #define _GNU_SOURCE 14 #define _GNU_SOURCE
15 #include <stdio.h> 15 #include <stdio.h>
16 #include <ctype.h> 16 #include <ctype.h>
17 #include <string.h> 17 #include <string.h>
18 #include "modpost.h" 18 #include "modpost.h"
19 #include "../../include/generated/autoconf.h" 19 #include "../../include/generated/autoconf.h"
20 #include "../../include/linux/license.h" 20 #include "../../include/linux/license.h"
21 21
22 /* Some toolchains use a `_' prefix for all user symbols. */ 22 /* Some toolchains use a `_' prefix for all user symbols. */
23 #ifdef CONFIG_SYMBOL_PREFIX 23 #ifdef CONFIG_SYMBOL_PREFIX
24 #define MODULE_SYMBOL_PREFIX CONFIG_SYMBOL_PREFIX 24 #define MODULE_SYMBOL_PREFIX CONFIG_SYMBOL_PREFIX
25 #else 25 #else
26 #define MODULE_SYMBOL_PREFIX "" 26 #define MODULE_SYMBOL_PREFIX ""
27 #endif 27 #endif
28 28
29 29
30 /* Are we using CONFIG_MODVERSIONS? */ 30 /* Are we using CONFIG_MODVERSIONS? */
31 int modversions = 0; 31 int modversions = 0;
32 /* Warn about undefined symbols? (do so if we have vmlinux) */ 32 /* Warn about undefined symbols? (do so if we have vmlinux) */
33 int have_vmlinux = 0; 33 int have_vmlinux = 0;
34 /* Is CONFIG_MODULE_SRCVERSION_ALL set? */ 34 /* Is CONFIG_MODULE_SRCVERSION_ALL set? */
35 static int all_versions = 0; 35 static int all_versions = 0;
36 /* If we are modposting external module set to 1 */ 36 /* If we are modposting external module set to 1 */
37 static int external_module = 0; 37 static int external_module = 0;
38 /* Warn about section mismatch in vmlinux if set to 1 */ 38 /* Warn about section mismatch in vmlinux if set to 1 */
39 static int vmlinux_section_warnings = 1; 39 static int vmlinux_section_warnings = 1;
40 /* Only warn about unresolved symbols */ 40 /* Only warn about unresolved symbols */
41 static int warn_unresolved = 0; 41 static int warn_unresolved = 0;
42 /* How a symbol is exported */ 42 /* How a symbol is exported */
43 static int sec_mismatch_count = 0; 43 static int sec_mismatch_count = 0;
44 static int sec_mismatch_verbose = 1; 44 static int sec_mismatch_verbose = 1;
45 45
46 enum export { 46 enum export {
47 export_plain, export_unused, export_gpl, 47 export_plain, export_unused, export_gpl,
48 export_unused_gpl, export_gpl_future, export_unknown 48 export_unused_gpl, export_gpl_future, export_unknown
49 }; 49 };
50 50
51 #define PRINTF __attribute__ ((format (printf, 1, 2))) 51 #define PRINTF __attribute__ ((format (printf, 1, 2)))
52 52
53 PRINTF void fatal(const char *fmt, ...) 53 PRINTF void fatal(const char *fmt, ...)
54 { 54 {
55 va_list arglist; 55 va_list arglist;
56 56
57 fprintf(stderr, "FATAL: "); 57 fprintf(stderr, "FATAL: ");
58 58
59 va_start(arglist, fmt); 59 va_start(arglist, fmt);
60 vfprintf(stderr, fmt, arglist); 60 vfprintf(stderr, fmt, arglist);
61 va_end(arglist); 61 va_end(arglist);
62 62
63 exit(1); 63 exit(1);
64 } 64 }
65 65
66 PRINTF void warn(const char *fmt, ...) 66 PRINTF void warn(const char *fmt, ...)
67 { 67 {
68 va_list arglist; 68 va_list arglist;
69 69
70 fprintf(stderr, "WARNING: "); 70 fprintf(stderr, "WARNING: ");
71 71
72 va_start(arglist, fmt); 72 va_start(arglist, fmt);
73 vfprintf(stderr, fmt, arglist); 73 vfprintf(stderr, fmt, arglist);
74 va_end(arglist); 74 va_end(arglist);
75 } 75 }
76 76
77 PRINTF void merror(const char *fmt, ...) 77 PRINTF void merror(const char *fmt, ...)
78 { 78 {
79 va_list arglist; 79 va_list arglist;
80 80
81 fprintf(stderr, "ERROR: "); 81 fprintf(stderr, "ERROR: ");
82 82
83 va_start(arglist, fmt); 83 va_start(arglist, fmt);
84 vfprintf(stderr, fmt, arglist); 84 vfprintf(stderr, fmt, arglist);
85 va_end(arglist); 85 va_end(arglist);
86 } 86 }
87 87
88 static int is_vmlinux(const char *modname) 88 static int is_vmlinux(const char *modname)
89 { 89 {
90 const char *myname; 90 const char *myname;
91 91
92 myname = strrchr(modname, '/'); 92 myname = strrchr(modname, '/');
93 if (myname) 93 if (myname)
94 myname++; 94 myname++;
95 else 95 else
96 myname = modname; 96 myname = modname;
97 97
98 return (strcmp(myname, "vmlinux") == 0) || 98 return (strcmp(myname, "vmlinux") == 0) ||
99 (strcmp(myname, "vmlinux.o") == 0); 99 (strcmp(myname, "vmlinux.o") == 0);
100 } 100 }
101 101
102 void *do_nofail(void *ptr, const char *expr) 102 void *do_nofail(void *ptr, const char *expr)
103 { 103 {
104 if (!ptr) 104 if (!ptr)
105 fatal("modpost: Memory allocation failure: %s.\n", expr); 105 fatal("modpost: Memory allocation failure: %s.\n", expr);
106 106
107 return ptr; 107 return ptr;
108 } 108 }
109 109
110 /* A list of all modules we processed */ 110 /* A list of all modules we processed */
111 static struct module *modules; 111 static struct module *modules;
112 112
113 static struct module *find_module(char *modname) 113 static struct module *find_module(char *modname)
114 { 114 {
115 struct module *mod; 115 struct module *mod;
116 116
117 for (mod = modules; mod; mod = mod->next) 117 for (mod = modules; mod; mod = mod->next)
118 if (strcmp(mod->name, modname) == 0) 118 if (strcmp(mod->name, modname) == 0)
119 break; 119 break;
120 return mod; 120 return mod;
121 } 121 }
122 122
123 static struct module *new_module(char *modname) 123 static struct module *new_module(char *modname)
124 { 124 {
125 struct module *mod; 125 struct module *mod;
126 char *p, *s; 126 char *p, *s;
127 127
128 mod = NOFAIL(malloc(sizeof(*mod))); 128 mod = NOFAIL(malloc(sizeof(*mod)));
129 memset(mod, 0, sizeof(*mod)); 129 memset(mod, 0, sizeof(*mod));
130 p = NOFAIL(strdup(modname)); 130 p = NOFAIL(strdup(modname));
131 131
132 /* strip trailing .o */ 132 /* strip trailing .o */
133 s = strrchr(p, '.'); 133 s = strrchr(p, '.');
134 if (s != NULL) 134 if (s != NULL)
135 if (strcmp(s, ".o") == 0) { 135 if (strcmp(s, ".o") == 0) {
136 *s = '\0'; 136 *s = '\0';
137 mod->is_dot_o = 1; 137 mod->is_dot_o = 1;
138 } 138 }
139 139
140 /* add to list */ 140 /* add to list */
141 mod->name = p; 141 mod->name = p;
142 mod->gpl_compatible = -1; 142 mod->gpl_compatible = -1;
143 mod->next = modules; 143 mod->next = modules;
144 modules = mod; 144 modules = mod;
145 145
146 return mod; 146 return mod;
147 } 147 }
148 148
149 /* A hash of all exported symbols, 149 /* A hash of all exported symbols,
150 * struct symbol is also used for lists of unresolved symbols */ 150 * struct symbol is also used for lists of unresolved symbols */
151 151
152 #define SYMBOL_HASH_SIZE 1024 152 #define SYMBOL_HASH_SIZE 1024
153 153
154 struct symbol { 154 struct symbol {
155 struct symbol *next; 155 struct symbol *next;
156 struct module *module; 156 struct module *module;
157 unsigned int crc; 157 unsigned int crc;
158 int crc_valid; 158 int crc_valid;
159 unsigned int weak:1; 159 unsigned int weak:1;
160 unsigned int vmlinux:1; /* 1 if symbol is defined in vmlinux */ 160 unsigned int vmlinux:1; /* 1 if symbol is defined in vmlinux */
161 unsigned int kernel:1; /* 1 if symbol is from kernel 161 unsigned int kernel:1; /* 1 if symbol is from kernel
162 * (only for external modules) **/ 162 * (only for external modules) **/
163 unsigned int preloaded:1; /* 1 if symbol from Module.symvers */ 163 unsigned int preloaded:1; /* 1 if symbol from Module.symvers */
164 enum export export; /* Type of export */ 164 enum export export; /* Type of export */
165 char name[0]; 165 char name[0];
166 }; 166 };
167 167
168 static struct symbol *symbolhash[SYMBOL_HASH_SIZE]; 168 static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
169 169
170 /* This is based on the hash agorithm from gdbm, via tdb */ 170 /* This is based on the hash agorithm from gdbm, via tdb */
171 static inline unsigned int tdb_hash(const char *name) 171 static inline unsigned int tdb_hash(const char *name)
172 { 172 {
173 unsigned value; /* Used to compute the hash value. */ 173 unsigned value; /* Used to compute the hash value. */
174 unsigned i; /* Used to cycle through random values. */ 174 unsigned i; /* Used to cycle through random values. */
175 175
176 /* Set the initial value from the key size. */ 176 /* Set the initial value from the key size. */
177 for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++) 177 for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)
178 value = (value + (((unsigned char *)name)[i] << (i*5 % 24))); 178 value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
179 179
180 return (1103515243 * value + 12345); 180 return (1103515243 * value + 12345);
181 } 181 }
182 182
183 /** 183 /**
184 * Allocate a new symbols for use in the hash of exported symbols or 184 * Allocate a new symbols for use in the hash of exported symbols or
185 * the list of unresolved symbols per module 185 * the list of unresolved symbols per module
186 **/ 186 **/
187 static struct symbol *alloc_symbol(const char *name, unsigned int weak, 187 static struct symbol *alloc_symbol(const char *name, unsigned int weak,
188 struct symbol *next) 188 struct symbol *next)
189 { 189 {
190 struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1)); 190 struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
191 191
192 memset(s, 0, sizeof(*s)); 192 memset(s, 0, sizeof(*s));
193 strcpy(s->name, name); 193 strcpy(s->name, name);
194 s->weak = weak; 194 s->weak = weak;
195 s->next = next; 195 s->next = next;
196 return s; 196 return s;
197 } 197 }
198 198
199 /* For the hash of exported symbols */ 199 /* For the hash of exported symbols */
200 static struct symbol *new_symbol(const char *name, struct module *module, 200 static struct symbol *new_symbol(const char *name, struct module *module,
201 enum export export) 201 enum export export)
202 { 202 {
203 unsigned int hash; 203 unsigned int hash;
204 struct symbol *new; 204 struct symbol *new;
205 205
206 hash = tdb_hash(name) % SYMBOL_HASH_SIZE; 206 hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
207 new = symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]); 207 new = symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
208 new->module = module; 208 new->module = module;
209 new->export = export; 209 new->export = export;
210 return new; 210 return new;
211 } 211 }
212 212
213 static struct symbol *find_symbol(const char *name) 213 static struct symbol *find_symbol(const char *name)
214 { 214 {
215 struct symbol *s; 215 struct symbol *s;
216 216
217 /* For our purposes, .foo matches foo. PPC64 needs this. */ 217 /* For our purposes, .foo matches foo. PPC64 needs this. */
218 if (name[0] == '.') 218 if (name[0] == '.')
219 name++; 219 name++;
220 220
221 for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) { 221 for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {
222 if (strcmp(s->name, name) == 0) 222 if (strcmp(s->name, name) == 0)
223 return s; 223 return s;
224 } 224 }
225 return NULL; 225 return NULL;
226 } 226 }
227 227
228 static struct { 228 static struct {
229 const char *str; 229 const char *str;
230 enum export export; 230 enum export export;
231 } export_list[] = { 231 } export_list[] = {
232 { .str = "EXPORT_SYMBOL", .export = export_plain }, 232 { .str = "EXPORT_SYMBOL", .export = export_plain },
233 { .str = "EXPORT_UNUSED_SYMBOL", .export = export_unused }, 233 { .str = "EXPORT_UNUSED_SYMBOL", .export = export_unused },
234 { .str = "EXPORT_SYMBOL_GPL", .export = export_gpl }, 234 { .str = "EXPORT_SYMBOL_GPL", .export = export_gpl },
235 { .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl }, 235 { .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },
236 { .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future }, 236 { .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },
237 { .str = "(unknown)", .export = export_unknown }, 237 { .str = "(unknown)", .export = export_unknown },
238 }; 238 };
239 239
240 240
241 static const char *export_str(enum export ex) 241 static const char *export_str(enum export ex)
242 { 242 {
243 return export_list[ex].str; 243 return export_list[ex].str;
244 } 244 }
245 245
246 static enum export export_no(const char *s) 246 static enum export export_no(const char *s)
247 { 247 {
248 int i; 248 int i;
249 249
250 if (!s) 250 if (!s)
251 return export_unknown; 251 return export_unknown;
252 for (i = 0; export_list[i].export != export_unknown; i++) { 252 for (i = 0; export_list[i].export != export_unknown; i++) {
253 if (strcmp(export_list[i].str, s) == 0) 253 if (strcmp(export_list[i].str, s) == 0)
254 return export_list[i].export; 254 return export_list[i].export;
255 } 255 }
256 return export_unknown; 256 return export_unknown;
257 } 257 }
258 258
259 static const char *sec_name(struct elf_info *elf, int secindex); 259 static const char *sec_name(struct elf_info *elf, int secindex);
260 260
261 #define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0) 261 #define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0)
262 262
263 static enum export export_from_secname(struct elf_info *elf, unsigned int sec) 263 static enum export export_from_secname(struct elf_info *elf, unsigned int sec)
264 { 264 {
265 const char *secname = sec_name(elf, sec); 265 const char *secname = sec_name(elf, sec);
266 266
267 if (strstarts(secname, "___ksymtab+")) 267 if (strstarts(secname, "___ksymtab+"))
268 return export_plain; 268 return export_plain;
269 else if (strstarts(secname, "___ksymtab_unused+")) 269 else if (strstarts(secname, "___ksymtab_unused+"))
270 return export_unused; 270 return export_unused;
271 else if (strstarts(secname, "___ksymtab_gpl+")) 271 else if (strstarts(secname, "___ksymtab_gpl+"))
272 return export_gpl; 272 return export_gpl;
273 else if (strstarts(secname, "___ksymtab_unused_gpl+")) 273 else if (strstarts(secname, "___ksymtab_unused_gpl+"))
274 return export_unused_gpl; 274 return export_unused_gpl;
275 else if (strstarts(secname, "___ksymtab_gpl_future+")) 275 else if (strstarts(secname, "___ksymtab_gpl_future+"))
276 return export_gpl_future; 276 return export_gpl_future;
277 else 277 else
278 return export_unknown; 278 return export_unknown;
279 } 279 }
280 280
281 static enum export export_from_sec(struct elf_info *elf, unsigned int sec) 281 static enum export export_from_sec(struct elf_info *elf, unsigned int sec)
282 { 282 {
283 if (sec == elf->export_sec) 283 if (sec == elf->export_sec)
284 return export_plain; 284 return export_plain;
285 else if (sec == elf->export_unused_sec) 285 else if (sec == elf->export_unused_sec)
286 return export_unused; 286 return export_unused;
287 else if (sec == elf->export_gpl_sec) 287 else if (sec == elf->export_gpl_sec)
288 return export_gpl; 288 return export_gpl;
289 else if (sec == elf->export_unused_gpl_sec) 289 else if (sec == elf->export_unused_gpl_sec)
290 return export_unused_gpl; 290 return export_unused_gpl;
291 else if (sec == elf->export_gpl_future_sec) 291 else if (sec == elf->export_gpl_future_sec)
292 return export_gpl_future; 292 return export_gpl_future;
293 else 293 else
294 return export_unknown; 294 return export_unknown;
295 } 295 }
296 296
297 /** 297 /**
298 * Add an exported symbol - it may have already been added without a 298 * Add an exported symbol - it may have already been added without a
299 * CRC, in this case just update the CRC 299 * CRC, in this case just update the CRC
300 **/ 300 **/
301 static struct symbol *sym_add_exported(const char *name, struct module *mod, 301 static struct symbol *sym_add_exported(const char *name, struct module *mod,
302 enum export export) 302 enum export export)
303 { 303 {
304 struct symbol *s = find_symbol(name); 304 struct symbol *s = find_symbol(name);
305 305
306 if (!s) { 306 if (!s) {
307 s = new_symbol(name, mod, export); 307 s = new_symbol(name, mod, export);
308 } else { 308 } else {
309 if (!s->preloaded) { 309 if (!s->preloaded) {
310 warn("%s: '%s' exported twice. Previous export " 310 warn("%s: '%s' exported twice. Previous export "
311 "was in %s%s\n", mod->name, name, 311 "was in %s%s\n", mod->name, name,
312 s->module->name, 312 s->module->name,
313 is_vmlinux(s->module->name) ?"":".ko"); 313 is_vmlinux(s->module->name) ?"":".ko");
314 } else { 314 } else {
315 /* In case Modules.symvers was out of date */ 315 /* In case Modules.symvers was out of date */
316 s->module = mod; 316 s->module = mod;
317 } 317 }
318 } 318 }
319 s->preloaded = 0; 319 s->preloaded = 0;
320 s->vmlinux = is_vmlinux(mod->name); 320 s->vmlinux = is_vmlinux(mod->name);
321 s->kernel = 0; 321 s->kernel = 0;
322 s->export = export; 322 s->export = export;
323 return s; 323 return s;
324 } 324 }
325 325
326 static void sym_update_crc(const char *name, struct module *mod, 326 static void sym_update_crc(const char *name, struct module *mod,
327 unsigned int crc, enum export export) 327 unsigned int crc, enum export export)
328 { 328 {
329 struct symbol *s = find_symbol(name); 329 struct symbol *s = find_symbol(name);
330 330
331 if (!s) 331 if (!s)
332 s = new_symbol(name, mod, export); 332 s = new_symbol(name, mod, export);
333 s->crc = crc; 333 s->crc = crc;
334 s->crc_valid = 1; 334 s->crc_valid = 1;
335 } 335 }
336 336
337 void *grab_file(const char *filename, unsigned long *size) 337 void *grab_file(const char *filename, unsigned long *size)
338 { 338 {
339 struct stat st; 339 struct stat st;
340 void *map = MAP_FAILED; 340 void *map = MAP_FAILED;
341 int fd; 341 int fd;
342 342
343 fd = open(filename, O_RDONLY); 343 fd = open(filename, O_RDONLY);
344 if (fd < 0) 344 if (fd < 0)
345 return NULL; 345 return NULL;
346 if (fstat(fd, &st)) 346 if (fstat(fd, &st))
347 goto failed; 347 goto failed;
348 348
349 *size = st.st_size; 349 *size = st.st_size;
350 map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0); 350 map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
351 351
352 failed: 352 failed:
353 close(fd); 353 close(fd);
354 if (map == MAP_FAILED) 354 if (map == MAP_FAILED)
355 return NULL; 355 return NULL;
356 return map; 356 return map;
357 } 357 }
358 358
359 /** 359 /**
360 * Return a copy of the next line in a mmap'ed file. 360 * Return a copy of the next line in a mmap'ed file.
361 * spaces in the beginning of the line is trimmed away. 361 * spaces in the beginning of the line is trimmed away.
362 * Return a pointer to a static buffer. 362 * Return a pointer to a static buffer.
363 **/ 363 **/
364 char *get_next_line(unsigned long *pos, void *file, unsigned long size) 364 char *get_next_line(unsigned long *pos, void *file, unsigned long size)
365 { 365 {
366 static char line[4096]; 366 static char line[4096];
367 int skip = 1; 367 int skip = 1;
368 size_t len = 0; 368 size_t len = 0;
369 signed char *p = (signed char *)file + *pos; 369 signed char *p = (signed char *)file + *pos;
370 char *s = line; 370 char *s = line;
371 371
372 for (; *pos < size ; (*pos)++) { 372 for (; *pos < size ; (*pos)++) {
373 if (skip && isspace(*p)) { 373 if (skip && isspace(*p)) {
374 p++; 374 p++;
375 continue; 375 continue;
376 } 376 }
377 skip = 0; 377 skip = 0;
378 if (*p != '\n' && (*pos < size)) { 378 if (*p != '\n' && (*pos < size)) {
379 len++; 379 len++;
380 *s++ = *p++; 380 *s++ = *p++;
381 if (len > 4095) 381 if (len > 4095)
382 break; /* Too long, stop */ 382 break; /* Too long, stop */
383 } else { 383 } else {
384 /* End of string */ 384 /* End of string */
385 *s = '\0'; 385 *s = '\0';
386 return line; 386 return line;
387 } 387 }
388 } 388 }
389 /* End of buffer */ 389 /* End of buffer */
390 return NULL; 390 return NULL;
391 } 391 }
392 392
393 void release_file(void *file, unsigned long size) 393 void release_file(void *file, unsigned long size)
394 { 394 {
395 munmap(file, size); 395 munmap(file, size);
396 } 396 }
397 397
398 static int parse_elf(struct elf_info *info, const char *filename) 398 static int parse_elf(struct elf_info *info, const char *filename)
399 { 399 {
400 unsigned int i; 400 unsigned int i;
401 Elf_Ehdr *hdr; 401 Elf_Ehdr *hdr;
402 Elf_Shdr *sechdrs; 402 Elf_Shdr *sechdrs;
403 Elf_Sym *sym; 403 Elf_Sym *sym;
404 const char *secstrings; 404 const char *secstrings;
405 unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U; 405 unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
406 406
407 hdr = grab_file(filename, &info->size); 407 hdr = grab_file(filename, &info->size);
408 if (!hdr) { 408 if (!hdr) {
409 perror(filename); 409 perror(filename);
410 exit(1); 410 exit(1);
411 } 411 }
412 info->hdr = hdr; 412 info->hdr = hdr;
413 if (info->size < sizeof(*hdr)) { 413 if (info->size < sizeof(*hdr)) {
414 /* file too small, assume this is an empty .o file */ 414 /* file too small, assume this is an empty .o file */
415 return 0; 415 return 0;
416 } 416 }
417 /* Is this a valid ELF file? */ 417 /* Is this a valid ELF file? */
418 if ((hdr->e_ident[EI_MAG0] != ELFMAG0) || 418 if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
419 (hdr->e_ident[EI_MAG1] != ELFMAG1) || 419 (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
420 (hdr->e_ident[EI_MAG2] != ELFMAG2) || 420 (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
421 (hdr->e_ident[EI_MAG3] != ELFMAG3)) { 421 (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
422 /* Not an ELF file - silently ignore it */ 422 /* Not an ELF file - silently ignore it */
423 return 0; 423 return 0;
424 } 424 }
425 /* Fix endianness in ELF header */ 425 /* Fix endianness in ELF header */
426 hdr->e_type = TO_NATIVE(hdr->e_type); 426 hdr->e_type = TO_NATIVE(hdr->e_type);
427 hdr->e_machine = TO_NATIVE(hdr->e_machine); 427 hdr->e_machine = TO_NATIVE(hdr->e_machine);
428 hdr->e_version = TO_NATIVE(hdr->e_version); 428 hdr->e_version = TO_NATIVE(hdr->e_version);
429 hdr->e_entry = TO_NATIVE(hdr->e_entry); 429 hdr->e_entry = TO_NATIVE(hdr->e_entry);
430 hdr->e_phoff = TO_NATIVE(hdr->e_phoff); 430 hdr->e_phoff = TO_NATIVE(hdr->e_phoff);
431 hdr->e_shoff = TO_NATIVE(hdr->e_shoff); 431 hdr->e_shoff = TO_NATIVE(hdr->e_shoff);
432 hdr->e_flags = TO_NATIVE(hdr->e_flags); 432 hdr->e_flags = TO_NATIVE(hdr->e_flags);
433 hdr->e_ehsize = TO_NATIVE(hdr->e_ehsize); 433 hdr->e_ehsize = TO_NATIVE(hdr->e_ehsize);
434 hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize); 434 hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
435 hdr->e_phnum = TO_NATIVE(hdr->e_phnum); 435 hdr->e_phnum = TO_NATIVE(hdr->e_phnum);
436 hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize); 436 hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
437 hdr->e_shnum = TO_NATIVE(hdr->e_shnum); 437 hdr->e_shnum = TO_NATIVE(hdr->e_shnum);
438 hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx); 438 hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);
439 sechdrs = (void *)hdr + hdr->e_shoff; 439 sechdrs = (void *)hdr + hdr->e_shoff;
440 info->sechdrs = sechdrs; 440 info->sechdrs = sechdrs;
441 441
442 /* Check if file offset is correct */ 442 /* Check if file offset is correct */
443 if (hdr->e_shoff > info->size) { 443 if (hdr->e_shoff > info->size) {
444 fatal("section header offset=%lu in file '%s' is bigger than " 444 fatal("section header offset=%lu in file '%s' is bigger than "
445 "filesize=%lu\n", (unsigned long)hdr->e_shoff, 445 "filesize=%lu\n", (unsigned long)hdr->e_shoff,
446 filename, info->size); 446 filename, info->size);
447 return 0; 447 return 0;
448 } 448 }
449 449
450 if (hdr->e_shnum == SHN_UNDEF) { 450 if (hdr->e_shnum == SHN_UNDEF) {
451 /* 451 /*
452 * There are more than 64k sections, 452 * There are more than 64k sections,
453 * read count from .sh_size. 453 * read count from .sh_size.
454 */ 454 */
455 info->num_sections = TO_NATIVE(sechdrs[0].sh_size); 455 info->num_sections = TO_NATIVE(sechdrs[0].sh_size);
456 } 456 }
457 else { 457 else {
458 info->num_sections = hdr->e_shnum; 458 info->num_sections = hdr->e_shnum;
459 } 459 }
460 if (hdr->e_shstrndx == SHN_XINDEX) { 460 if (hdr->e_shstrndx == SHN_XINDEX) {
461 info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link); 461 info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link);
462 } 462 }
463 else { 463 else {
464 info->secindex_strings = hdr->e_shstrndx; 464 info->secindex_strings = hdr->e_shstrndx;
465 } 465 }
466 466
467 /* Fix endianness in section headers */ 467 /* Fix endianness in section headers */
468 for (i = 0; i < info->num_sections; i++) { 468 for (i = 0; i < info->num_sections; i++) {
469 sechdrs[i].sh_name = TO_NATIVE(sechdrs[i].sh_name); 469 sechdrs[i].sh_name = TO_NATIVE(sechdrs[i].sh_name);
470 sechdrs[i].sh_type = TO_NATIVE(sechdrs[i].sh_type); 470 sechdrs[i].sh_type = TO_NATIVE(sechdrs[i].sh_type);
471 sechdrs[i].sh_flags = TO_NATIVE(sechdrs[i].sh_flags); 471 sechdrs[i].sh_flags = TO_NATIVE(sechdrs[i].sh_flags);
472 sechdrs[i].sh_addr = TO_NATIVE(sechdrs[i].sh_addr); 472 sechdrs[i].sh_addr = TO_NATIVE(sechdrs[i].sh_addr);
473 sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset); 473 sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);
474 sechdrs[i].sh_size = TO_NATIVE(sechdrs[i].sh_size); 474 sechdrs[i].sh_size = TO_NATIVE(sechdrs[i].sh_size);
475 sechdrs[i].sh_link = TO_NATIVE(sechdrs[i].sh_link); 475 sechdrs[i].sh_link = TO_NATIVE(sechdrs[i].sh_link);
476 sechdrs[i].sh_info = TO_NATIVE(sechdrs[i].sh_info); 476 sechdrs[i].sh_info = TO_NATIVE(sechdrs[i].sh_info);
477 sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign); 477 sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
478 sechdrs[i].sh_entsize = TO_NATIVE(sechdrs[i].sh_entsize); 478 sechdrs[i].sh_entsize = TO_NATIVE(sechdrs[i].sh_entsize);
479 } 479 }
480 /* Find symbol table. */ 480 /* Find symbol table. */
481 secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset; 481 secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
482 for (i = 1; i < info->num_sections; i++) { 482 for (i = 1; i < info->num_sections; i++) {
483 const char *secname; 483 const char *secname;
484 int nobits = sechdrs[i].sh_type == SHT_NOBITS; 484 int nobits = sechdrs[i].sh_type == SHT_NOBITS;
485 485
486 if (!nobits && sechdrs[i].sh_offset > info->size) { 486 if (!nobits && sechdrs[i].sh_offset > info->size) {
487 fatal("%s is truncated. sechdrs[i].sh_offset=%lu > " 487 fatal("%s is truncated. sechdrs[i].sh_offset=%lu > "
488 "sizeof(*hrd)=%zu\n", filename, 488 "sizeof(*hrd)=%zu\n", filename,
489 (unsigned long)sechdrs[i].sh_offset, 489 (unsigned long)sechdrs[i].sh_offset,
490 sizeof(*hdr)); 490 sizeof(*hdr));
491 return 0; 491 return 0;
492 } 492 }
493 secname = secstrings + sechdrs[i].sh_name; 493 secname = secstrings + sechdrs[i].sh_name;
494 if (strcmp(secname, ".modinfo") == 0) { 494 if (strcmp(secname, ".modinfo") == 0) {
495 if (nobits) 495 if (nobits)
496 fatal("%s has NOBITS .modinfo\n", filename); 496 fatal("%s has NOBITS .modinfo\n", filename);
497 info->modinfo = (void *)hdr + sechdrs[i].sh_offset; 497 info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
498 info->modinfo_len = sechdrs[i].sh_size; 498 info->modinfo_len = sechdrs[i].sh_size;
499 } else if (strcmp(secname, "__ksymtab") == 0) 499 } else if (strcmp(secname, "__ksymtab") == 0)
500 info->export_sec = i; 500 info->export_sec = i;
501 else if (strcmp(secname, "__ksymtab_unused") == 0) 501 else if (strcmp(secname, "__ksymtab_unused") == 0)
502 info->export_unused_sec = i; 502 info->export_unused_sec = i;
503 else if (strcmp(secname, "__ksymtab_gpl") == 0) 503 else if (strcmp(secname, "__ksymtab_gpl") == 0)
504 info->export_gpl_sec = i; 504 info->export_gpl_sec = i;
505 else if (strcmp(secname, "__ksymtab_unused_gpl") == 0) 505 else if (strcmp(secname, "__ksymtab_unused_gpl") == 0)
506 info->export_unused_gpl_sec = i; 506 info->export_unused_gpl_sec = i;
507 else if (strcmp(secname, "__ksymtab_gpl_future") == 0) 507 else if (strcmp(secname, "__ksymtab_gpl_future") == 0)
508 info->export_gpl_future_sec = i; 508 info->export_gpl_future_sec = i;
509 509
510 if (sechdrs[i].sh_type == SHT_SYMTAB) { 510 if (sechdrs[i].sh_type == SHT_SYMTAB) {
511 unsigned int sh_link_idx; 511 unsigned int sh_link_idx;
512 symtab_idx = i; 512 symtab_idx = i;
513 info->symtab_start = (void *)hdr + 513 info->symtab_start = (void *)hdr +
514 sechdrs[i].sh_offset; 514 sechdrs[i].sh_offset;
515 info->symtab_stop = (void *)hdr + 515 info->symtab_stop = (void *)hdr +
516 sechdrs[i].sh_offset + sechdrs[i].sh_size; 516 sechdrs[i].sh_offset + sechdrs[i].sh_size;
517 sh_link_idx = sechdrs[i].sh_link; 517 sh_link_idx = sechdrs[i].sh_link;
518 info->strtab = (void *)hdr + 518 info->strtab = (void *)hdr +
519 sechdrs[sh_link_idx].sh_offset; 519 sechdrs[sh_link_idx].sh_offset;
520 } 520 }
521 521
522 /* 32bit section no. table? ("more than 64k sections") */ 522 /* 32bit section no. table? ("more than 64k sections") */
523 if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) { 523 if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
524 symtab_shndx_idx = i; 524 symtab_shndx_idx = i;
525 info->symtab_shndx_start = (void *)hdr + 525 info->symtab_shndx_start = (void *)hdr +
526 sechdrs[i].sh_offset; 526 sechdrs[i].sh_offset;
527 info->symtab_shndx_stop = (void *)hdr + 527 info->symtab_shndx_stop = (void *)hdr +
528 sechdrs[i].sh_offset + sechdrs[i].sh_size; 528 sechdrs[i].sh_offset + sechdrs[i].sh_size;
529 } 529 }
530 } 530 }
531 if (!info->symtab_start) 531 if (!info->symtab_start)
532 fatal("%s has no symtab?\n", filename); 532 fatal("%s has no symtab?\n", filename);
533 533
534 /* Fix endianness in symbols */ 534 /* Fix endianness in symbols */
535 for (sym = info->symtab_start; sym < info->symtab_stop; sym++) { 535 for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
536 sym->st_shndx = TO_NATIVE(sym->st_shndx); 536 sym->st_shndx = TO_NATIVE(sym->st_shndx);
537 sym->st_name = TO_NATIVE(sym->st_name); 537 sym->st_name = TO_NATIVE(sym->st_name);
538 sym->st_value = TO_NATIVE(sym->st_value); 538 sym->st_value = TO_NATIVE(sym->st_value);
539 sym->st_size = TO_NATIVE(sym->st_size); 539 sym->st_size = TO_NATIVE(sym->st_size);
540 } 540 }
541 541
542 if (symtab_shndx_idx != ~0U) { 542 if (symtab_shndx_idx != ~0U) {
543 Elf32_Word *p; 543 Elf32_Word *p;
544 if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link) 544 if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)
545 fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n", 545 fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
546 filename, sechdrs[symtab_shndx_idx].sh_link, 546 filename, sechdrs[symtab_shndx_idx].sh_link,
547 symtab_idx); 547 symtab_idx);
548 /* Fix endianness */ 548 /* Fix endianness */
549 for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop; 549 for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
550 p++) 550 p++)
551 *p = TO_NATIVE(*p); 551 *p = TO_NATIVE(*p);
552 } 552 }
553 553
554 return 1; 554 return 1;
555 } 555 }
556 556
557 static void parse_elf_finish(struct elf_info *info) 557 static void parse_elf_finish(struct elf_info *info)
558 { 558 {
559 release_file(info->hdr, info->size); 559 release_file(info->hdr, info->size);
560 } 560 }
561 561
562 static int ignore_undef_symbol(struct elf_info *info, const char *symname) 562 static int ignore_undef_symbol(struct elf_info *info, const char *symname)
563 { 563 {
564 /* ignore __this_module, it will be resolved shortly */ 564 /* ignore __this_module, it will be resolved shortly */
565 if (strcmp(symname, MODULE_SYMBOL_PREFIX "__this_module") == 0) 565 if (strcmp(symname, MODULE_SYMBOL_PREFIX "__this_module") == 0)
566 return 1; 566 return 1;
567 /* ignore global offset table */ 567 /* ignore global offset table */
568 if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0) 568 if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
569 return 1; 569 return 1;
570 if (info->hdr->e_machine == EM_PPC) 570 if (info->hdr->e_machine == EM_PPC)
571 /* Special register function linked on all modules during final link of .ko */ 571 /* Special register function linked on all modules during final link of .ko */
572 if (strncmp(symname, "_restgpr_", sizeof("_restgpr_") - 1) == 0 || 572 if (strncmp(symname, "_restgpr_", sizeof("_restgpr_") - 1) == 0 ||
573 strncmp(symname, "_savegpr_", sizeof("_savegpr_") - 1) == 0 || 573 strncmp(symname, "_savegpr_", sizeof("_savegpr_") - 1) == 0 ||
574 strncmp(symname, "_rest32gpr_", sizeof("_rest32gpr_") - 1) == 0 || 574 strncmp(symname, "_rest32gpr_", sizeof("_rest32gpr_") - 1) == 0 ||
575 strncmp(symname, "_save32gpr_", sizeof("_save32gpr_") - 1) == 0) 575 strncmp(symname, "_save32gpr_", sizeof("_save32gpr_") - 1) == 0)
576 return 1; 576 return 1;
577 if (info->hdr->e_machine == EM_PPC64) 577 if (info->hdr->e_machine == EM_PPC64)
578 /* Special register function linked on all modules during final link of .ko */ 578 /* Special register function linked on all modules during final link of .ko */
579 if (strncmp(symname, "_restgpr0_", sizeof("_restgpr0_") - 1) == 0 || 579 if (strncmp(symname, "_restgpr0_", sizeof("_restgpr0_") - 1) == 0 ||
580 strncmp(symname, "_savegpr0_", sizeof("_savegpr0_") - 1) == 0) 580 strncmp(symname, "_savegpr0_", sizeof("_savegpr0_") - 1) == 0)
581 return 1; 581 return 1;
582 /* Do not ignore this symbol */ 582 /* Do not ignore this symbol */
583 return 0; 583 return 0;
584 } 584 }
585 585
586 #define CRC_PFX MODULE_SYMBOL_PREFIX "__crc_" 586 #define CRC_PFX MODULE_SYMBOL_PREFIX "__crc_"
587 #define KSYMTAB_PFX MODULE_SYMBOL_PREFIX "__ksymtab_" 587 #define KSYMTAB_PFX MODULE_SYMBOL_PREFIX "__ksymtab_"
588 588
589 static void handle_modversions(struct module *mod, struct elf_info *info, 589 static void handle_modversions(struct module *mod, struct elf_info *info,
590 Elf_Sym *sym, const char *symname) 590 Elf_Sym *sym, const char *symname)
591 { 591 {
592 unsigned int crc; 592 unsigned int crc;
593 enum export export; 593 enum export export;
594 594
595 if ((!is_vmlinux(mod->name) || mod->is_dot_o) && 595 if ((!is_vmlinux(mod->name) || mod->is_dot_o) &&
596 strncmp(symname, "__ksymtab", 9) == 0) 596 strncmp(symname, "__ksymtab", 9) == 0)
597 export = export_from_secname(info, get_secindex(info, sym)); 597 export = export_from_secname(info, get_secindex(info, sym));
598 else 598 else
599 export = export_from_sec(info, get_secindex(info, sym)); 599 export = export_from_sec(info, get_secindex(info, sym));
600 600
601 switch (sym->st_shndx) { 601 switch (sym->st_shndx) {
602 case SHN_COMMON: 602 case SHN_COMMON:
603 warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name); 603 warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
604 break; 604 break;
605 case SHN_ABS: 605 case SHN_ABS:
606 /* CRC'd symbol */ 606 /* CRC'd symbol */
607 if (strncmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) { 607 if (strncmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) {
608 crc = (unsigned int) sym->st_value; 608 crc = (unsigned int) sym->st_value;
609 sym_update_crc(symname + strlen(CRC_PFX), mod, crc, 609 sym_update_crc(symname + strlen(CRC_PFX), mod, crc,
610 export); 610 export);
611 } 611 }
612 break; 612 break;
613 case SHN_UNDEF: 613 case SHN_UNDEF:
614 /* undefined symbol */ 614 /* undefined symbol */
615 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL && 615 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
616 ELF_ST_BIND(sym->st_info) != STB_WEAK) 616 ELF_ST_BIND(sym->st_info) != STB_WEAK)
617 break; 617 break;
618 if (ignore_undef_symbol(info, symname)) 618 if (ignore_undef_symbol(info, symname))
619 break; 619 break;
620 /* cope with newer glibc (2.3.4 or higher) STT_ definition in elf.h */ 620 /* cope with newer glibc (2.3.4 or higher) STT_ definition in elf.h */
621 #if defined(STT_REGISTER) || defined(STT_SPARC_REGISTER) 621 #if defined(STT_REGISTER) || defined(STT_SPARC_REGISTER)
622 /* add compatibility with older glibc */ 622 /* add compatibility with older glibc */
623 #ifndef STT_SPARC_REGISTER 623 #ifndef STT_SPARC_REGISTER
624 #define STT_SPARC_REGISTER STT_REGISTER 624 #define STT_SPARC_REGISTER STT_REGISTER
625 #endif 625 #endif
626 if (info->hdr->e_machine == EM_SPARC || 626 if (info->hdr->e_machine == EM_SPARC ||
627 info->hdr->e_machine == EM_SPARCV9) { 627 info->hdr->e_machine == EM_SPARCV9) {
628 /* Ignore register directives. */ 628 /* Ignore register directives. */
629 if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER) 629 if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
630 break; 630 break;
631 if (symname[0] == '.') { 631 if (symname[0] == '.') {
632 char *munged = strdup(symname); 632 char *munged = strdup(symname);
633 munged[0] = '_'; 633 munged[0] = '_';
634 munged[1] = toupper(munged[1]); 634 munged[1] = toupper(munged[1]);
635 symname = munged; 635 symname = munged;
636 } 636 }
637 } 637 }
638 #endif 638 #endif
639 639
640 if (memcmp(symname, MODULE_SYMBOL_PREFIX, 640 if (memcmp(symname, MODULE_SYMBOL_PREFIX,
641 strlen(MODULE_SYMBOL_PREFIX)) == 0) { 641 strlen(MODULE_SYMBOL_PREFIX)) == 0) {
642 mod->unres = 642 mod->unres =
643 alloc_symbol(symname + 643 alloc_symbol(symname +
644 strlen(MODULE_SYMBOL_PREFIX), 644 strlen(MODULE_SYMBOL_PREFIX),
645 ELF_ST_BIND(sym->st_info) == STB_WEAK, 645 ELF_ST_BIND(sym->st_info) == STB_WEAK,
646 mod->unres); 646 mod->unres);
647 } 647 }
648 break; 648 break;
649 default: 649 default:
650 /* All exported symbols */ 650 /* All exported symbols */
651 if (strncmp(symname, KSYMTAB_PFX, strlen(KSYMTAB_PFX)) == 0) { 651 if (strncmp(symname, KSYMTAB_PFX, strlen(KSYMTAB_PFX)) == 0) {
652 sym_add_exported(symname + strlen(KSYMTAB_PFX), mod, 652 sym_add_exported(symname + strlen(KSYMTAB_PFX), mod,
653 export); 653 export);
654 } 654 }
655 if (strcmp(symname, MODULE_SYMBOL_PREFIX "init_module") == 0) 655 if (strcmp(symname, MODULE_SYMBOL_PREFIX "init_module") == 0)
656 mod->has_init = 1; 656 mod->has_init = 1;
657 if (strcmp(symname, MODULE_SYMBOL_PREFIX "cleanup_module") == 0) 657 if (strcmp(symname, MODULE_SYMBOL_PREFIX "cleanup_module") == 0)
658 mod->has_cleanup = 1; 658 mod->has_cleanup = 1;
659 break; 659 break;
660 } 660 }
661 } 661 }
662 662
663 /** 663 /**
664 * Parse tag=value strings from .modinfo section 664 * Parse tag=value strings from .modinfo section
665 **/ 665 **/
666 static char *next_string(char *string, unsigned long *secsize) 666 static char *next_string(char *string, unsigned long *secsize)
667 { 667 {
668 /* Skip non-zero chars */ 668 /* Skip non-zero chars */
669 while (string[0]) { 669 while (string[0]) {
670 string++; 670 string++;
671 if ((*secsize)-- <= 1) 671 if ((*secsize)-- <= 1)
672 return NULL; 672 return NULL;
673 } 673 }
674 674
675 /* Skip any zero padding. */ 675 /* Skip any zero padding. */
676 while (!string[0]) { 676 while (!string[0]) {
677 string++; 677 string++;
678 if ((*secsize)-- <= 1) 678 if ((*secsize)-- <= 1)
679 return NULL; 679 return NULL;
680 } 680 }
681 return string; 681 return string;
682 } 682 }
683 683
684 static char *get_next_modinfo(void *modinfo, unsigned long modinfo_len, 684 static char *get_next_modinfo(void *modinfo, unsigned long modinfo_len,
685 const char *tag, char *info) 685 const char *tag, char *info)
686 { 686 {
687 char *p; 687 char *p;
688 unsigned int taglen = strlen(tag); 688 unsigned int taglen = strlen(tag);
689 unsigned long size = modinfo_len; 689 unsigned long size = modinfo_len;
690 690
691 if (info) { 691 if (info) {
692 size -= info - (char *)modinfo; 692 size -= info - (char *)modinfo;
693 modinfo = next_string(info, &size); 693 modinfo = next_string(info, &size);
694 } 694 }
695 695
696 for (p = modinfo; p; p = next_string(p, &size)) { 696 for (p = modinfo; p; p = next_string(p, &size)) {
697 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=') 697 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
698 return p + taglen + 1; 698 return p + taglen + 1;
699 } 699 }
700 return NULL; 700 return NULL;
701 } 701 }
702 702
703 static char *get_modinfo(void *modinfo, unsigned long modinfo_len, 703 static char *get_modinfo(void *modinfo, unsigned long modinfo_len,
704 const char *tag) 704 const char *tag)
705 705
706 { 706 {
707 return get_next_modinfo(modinfo, modinfo_len, tag, NULL); 707 return get_next_modinfo(modinfo, modinfo_len, tag, NULL);
708 } 708 }
709 709
710 /** 710 /**
711 * Test if string s ends in string sub 711 * Test if string s ends in string sub
712 * return 0 if match 712 * return 0 if match
713 **/ 713 **/
714 static int strrcmp(const char *s, const char *sub) 714 static int strrcmp(const char *s, const char *sub)
715 { 715 {
716 int slen, sublen; 716 int slen, sublen;
717 717
718 if (!s || !sub) 718 if (!s || !sub)
719 return 1; 719 return 1;
720 720
721 slen = strlen(s); 721 slen = strlen(s);
722 sublen = strlen(sub); 722 sublen = strlen(sub);
723 723
724 if ((slen == 0) || (sublen == 0)) 724 if ((slen == 0) || (sublen == 0))
725 return 1; 725 return 1;
726 726
727 if (sublen > slen) 727 if (sublen > slen)
728 return 1; 728 return 1;
729 729
730 return memcmp(s + slen - sublen, sub, sublen); 730 return memcmp(s + slen - sublen, sub, sublen);
731 } 731 }
732 732
733 static const char *sym_name(struct elf_info *elf, Elf_Sym *sym) 733 static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
734 { 734 {
735 if (sym) 735 if (sym)
736 return elf->strtab + sym->st_name; 736 return elf->strtab + sym->st_name;
737 else 737 else
738 return "(unknown)"; 738 return "(unknown)";
739 } 739 }
740 740
741 static const char *sec_name(struct elf_info *elf, int secindex) 741 static const char *sec_name(struct elf_info *elf, int secindex)
742 { 742 {
743 Elf_Shdr *sechdrs = elf->sechdrs; 743 Elf_Shdr *sechdrs = elf->sechdrs;
744 return (void *)elf->hdr + 744 return (void *)elf->hdr +
745 elf->sechdrs[elf->secindex_strings].sh_offset + 745 elf->sechdrs[elf->secindex_strings].sh_offset +
746 sechdrs[secindex].sh_name; 746 sechdrs[secindex].sh_name;
747 } 747 }
748 748
749 static const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr) 749 static const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr)
750 { 750 {
751 return (void *)elf->hdr + 751 return (void *)elf->hdr +
752 elf->sechdrs[elf->secindex_strings].sh_offset + 752 elf->sechdrs[elf->secindex_strings].sh_offset +
753 sechdr->sh_name; 753 sechdr->sh_name;
754 } 754 }
755 755
756 /* if sym is empty or point to a string 756 /* if sym is empty or point to a string
757 * like ".[0-9]+" then return 1. 757 * like ".[0-9]+" then return 1.
758 * This is the optional prefix added by ld to some sections 758 * This is the optional prefix added by ld to some sections
759 */ 759 */
760 static int number_prefix(const char *sym) 760 static int number_prefix(const char *sym)
761 { 761 {
762 if (*sym++ == '\0') 762 if (*sym++ == '\0')
763 return 1; 763 return 1;
764 if (*sym != '.') 764 if (*sym != '.')
765 return 0; 765 return 0;
766 do { 766 do {
767 char c = *sym++; 767 char c = *sym++;
768 if (c < '0' || c > '9') 768 if (c < '0' || c > '9')
769 return 0; 769 return 0;
770 } while (*sym); 770 } while (*sym);
771 return 1; 771 return 1;
772 } 772 }
773 773
774 /* The pattern is an array of simple patterns. 774 /* The pattern is an array of simple patterns.
775 * "foo" will match an exact string equal to "foo" 775 * "foo" will match an exact string equal to "foo"
776 * "*foo" will match a string that ends with "foo" 776 * "*foo" will match a string that ends with "foo"
777 * "foo*" will match a string that begins with "foo" 777 * "foo*" will match a string that begins with "foo"
778 * "foo$" will match a string equal to "foo" or "foo.1" 778 * "foo$" will match a string equal to "foo" or "foo.1"
779 * where the '1' can be any number including several digits. 779 * where the '1' can be any number including several digits.
780 * The $ syntax is for sections where ld append a dot number 780 * The $ syntax is for sections where ld append a dot number
781 * to make section name unique. 781 * to make section name unique.
782 */ 782 */
783 static int match(const char *sym, const char * const pat[]) 783 static int match(const char *sym, const char * const pat[])
784 { 784 {
785 const char *p; 785 const char *p;
786 while (*pat) { 786 while (*pat) {
787 p = *pat++; 787 p = *pat++;
788 const char *endp = p + strlen(p) - 1; 788 const char *endp = p + strlen(p) - 1;
789 789
790 /* "*foo" */ 790 /* "*foo" */
791 if (*p == '*') { 791 if (*p == '*') {
792 if (strrcmp(sym, p + 1) == 0) 792 if (strrcmp(sym, p + 1) == 0)
793 return 1; 793 return 1;
794 } 794 }
795 /* "foo*" */ 795 /* "foo*" */
796 else if (*endp == '*') { 796 else if (*endp == '*') {
797 if (strncmp(sym, p, strlen(p) - 1) == 0) 797 if (strncmp(sym, p, strlen(p) - 1) == 0)
798 return 1; 798 return 1;
799 } 799 }
800 /* "foo$" */ 800 /* "foo$" */
801 else if (*endp == '$') { 801 else if (*endp == '$') {
802 if (strncmp(sym, p, strlen(p) - 1) == 0) { 802 if (strncmp(sym, p, strlen(p) - 1) == 0) {
803 if (number_prefix(sym + strlen(p) - 1)) 803 if (number_prefix(sym + strlen(p) - 1))
804 return 1; 804 return 1;
805 } 805 }
806 } 806 }
807 /* no wildcards */ 807 /* no wildcards */
808 else { 808 else {
809 if (strcmp(p, sym) == 0) 809 if (strcmp(p, sym) == 0)
810 return 1; 810 return 1;
811 } 811 }
812 } 812 }
813 /* no match */ 813 /* no match */
814 return 0; 814 return 0;
815 } 815 }
816 816
817 /* sections that we do not want to do full section mismatch check on */ 817 /* sections that we do not want to do full section mismatch check on */
818 static const char *section_white_list[] = 818 static const char *section_white_list[] =
819 { 819 {
820 ".comment*", 820 ".comment*",
821 ".debug*", 821 ".debug*",
822 ".zdebug*", /* Compressed debug sections. */ 822 ".zdebug*", /* Compressed debug sections. */
823 ".GCC-command-line", /* mn10300 */ 823 ".GCC-command-line", /* mn10300 */
824 ".mdebug*", /* alpha, score, mips etc. */ 824 ".mdebug*", /* alpha, score, mips etc. */
825 ".pdr", /* alpha, score, mips etc. */ 825 ".pdr", /* alpha, score, mips etc. */
826 ".stab*", 826 ".stab*",
827 ".note*", 827 ".note*",
828 ".got*", 828 ".got*",
829 ".toc*", 829 ".toc*",
830 ".xt.prop", /* xtensa */
831 ".xt.lit", /* xtensa */
830 NULL 832 NULL
831 }; 833 };
832 834
833 /* 835 /*
834 * This is used to find sections missing the SHF_ALLOC flag. 836 * This is used to find sections missing the SHF_ALLOC flag.
835 * The cause of this is often a section specified in assembler 837 * The cause of this is often a section specified in assembler
836 * without "ax" / "aw". 838 * without "ax" / "aw".
837 */ 839 */
838 static void check_section(const char *modname, struct elf_info *elf, 840 static void check_section(const char *modname, struct elf_info *elf,
839 Elf_Shdr *sechdr) 841 Elf_Shdr *sechdr)
840 { 842 {
841 const char *sec = sech_name(elf, sechdr); 843 const char *sec = sech_name(elf, sechdr);
842 844
843 if (sechdr->sh_type == SHT_PROGBITS && 845 if (sechdr->sh_type == SHT_PROGBITS &&
844 !(sechdr->sh_flags & SHF_ALLOC) && 846 !(sechdr->sh_flags & SHF_ALLOC) &&
845 !match(sec, section_white_list)) { 847 !match(sec, section_white_list)) {
846 warn("%s (%s): unexpected non-allocatable section.\n" 848 warn("%s (%s): unexpected non-allocatable section.\n"
847 "Did you forget to use \"ax\"/\"aw\" in a .S file?\n" 849 "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
848 "Note that for example <linux/init.h> contains\n" 850 "Note that for example <linux/init.h> contains\n"
849 "section definitions for use in .S files.\n\n", 851 "section definitions for use in .S files.\n\n",
850 modname, sec); 852 modname, sec);
851 } 853 }
852 } 854 }
853 855
854 856
855 857
856 #define ALL_INIT_DATA_SECTIONS \ 858 #define ALL_INIT_DATA_SECTIONS \
857 ".init.setup$", ".init.rodata$", \ 859 ".init.setup$", ".init.rodata$", \
858 ".devinit.rodata$", ".cpuinit.rodata$", ".meminit.rodata$", \ 860 ".devinit.rodata$", ".cpuinit.rodata$", ".meminit.rodata$", \
859 ".init.data$", ".devinit.data$", ".cpuinit.data$", ".meminit.data$" 861 ".init.data$", ".devinit.data$", ".cpuinit.data$", ".meminit.data$"
860 #define ALL_EXIT_DATA_SECTIONS \ 862 #define ALL_EXIT_DATA_SECTIONS \
861 ".exit.data$", ".devexit.data$", ".cpuexit.data$", ".memexit.data$" 863 ".exit.data$", ".devexit.data$", ".cpuexit.data$", ".memexit.data$"
862 864
863 #define ALL_INIT_TEXT_SECTIONS \ 865 #define ALL_INIT_TEXT_SECTIONS \
864 ".init.text$", ".devinit.text$", ".cpuinit.text$", ".meminit.text$" 866 ".init.text$", ".devinit.text$", ".cpuinit.text$", ".meminit.text$"
865 #define ALL_EXIT_TEXT_SECTIONS \ 867 #define ALL_EXIT_TEXT_SECTIONS \
866 ".exit.text$", ".devexit.text$", ".cpuexit.text$", ".memexit.text$" 868 ".exit.text$", ".devexit.text$", ".cpuexit.text$", ".memexit.text$"
867 869
868 #define ALL_PCI_INIT_SECTIONS \ 870 #define ALL_PCI_INIT_SECTIONS \
869 ".pci_fixup_early$", ".pci_fixup_header$", ".pci_fixup_final$", \ 871 ".pci_fixup_early$", ".pci_fixup_header$", ".pci_fixup_final$", \
870 ".pci_fixup_enable$", ".pci_fixup_resume$", \ 872 ".pci_fixup_enable$", ".pci_fixup_resume$", \
871 ".pci_fixup_resume_early$", ".pci_fixup_suspend$" 873 ".pci_fixup_resume_early$", ".pci_fixup_suspend$"
872 874
873 #define ALL_XXXINIT_SECTIONS DEV_INIT_SECTIONS, CPU_INIT_SECTIONS, \ 875 #define ALL_XXXINIT_SECTIONS DEV_INIT_SECTIONS, CPU_INIT_SECTIONS, \
874 MEM_INIT_SECTIONS 876 MEM_INIT_SECTIONS
875 #define ALL_XXXEXIT_SECTIONS DEV_EXIT_SECTIONS, CPU_EXIT_SECTIONS, \ 877 #define ALL_XXXEXIT_SECTIONS DEV_EXIT_SECTIONS, CPU_EXIT_SECTIONS, \
876 MEM_EXIT_SECTIONS 878 MEM_EXIT_SECTIONS
877 879
878 #define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS 880 #define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
879 #define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS 881 #define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
880 882
881 #define DATA_SECTIONS ".data$", ".data.rel$" 883 #define DATA_SECTIONS ".data$", ".data.rel$"
882 #define TEXT_SECTIONS ".text$" 884 #define TEXT_SECTIONS ".text$"
883 885
884 #define INIT_SECTIONS ".init.*" 886 #define INIT_SECTIONS ".init.*"
885 #define DEV_INIT_SECTIONS ".devinit.*" 887 #define DEV_INIT_SECTIONS ".devinit.*"
886 #define CPU_INIT_SECTIONS ".cpuinit.*" 888 #define CPU_INIT_SECTIONS ".cpuinit.*"
887 #define MEM_INIT_SECTIONS ".meminit.*" 889 #define MEM_INIT_SECTIONS ".meminit.*"
888 890
889 #define EXIT_SECTIONS ".exit.*" 891 #define EXIT_SECTIONS ".exit.*"
890 #define DEV_EXIT_SECTIONS ".devexit.*" 892 #define DEV_EXIT_SECTIONS ".devexit.*"
891 #define CPU_EXIT_SECTIONS ".cpuexit.*" 893 #define CPU_EXIT_SECTIONS ".cpuexit.*"
892 #define MEM_EXIT_SECTIONS ".memexit.*" 894 #define MEM_EXIT_SECTIONS ".memexit.*"
893 895
894 /* init data sections */ 896 /* init data sections */
895 static const char *init_data_sections[] = { ALL_INIT_DATA_SECTIONS, NULL }; 897 static const char *init_data_sections[] = { ALL_INIT_DATA_SECTIONS, NULL };
896 898
897 /* all init sections */ 899 /* all init sections */
898 static const char *init_sections[] = { ALL_INIT_SECTIONS, NULL }; 900 static const char *init_sections[] = { ALL_INIT_SECTIONS, NULL };
899 901
900 /* All init and exit sections (code + data) */ 902 /* All init and exit sections (code + data) */
901 static const char *init_exit_sections[] = 903 static const char *init_exit_sections[] =
902 {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL }; 904 {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
903 905
904 /* data section */ 906 /* data section */
905 static const char *data_sections[] = { DATA_SECTIONS, NULL }; 907 static const char *data_sections[] = { DATA_SECTIONS, NULL };
906 908
907 909
908 /* symbols in .data that may refer to init/exit sections */ 910 /* symbols in .data that may refer to init/exit sections */
909 #define DEFAULT_SYMBOL_WHITE_LIST \ 911 #define DEFAULT_SYMBOL_WHITE_LIST \
910 "*driver", \ 912 "*driver", \
911 "*_template", /* scsi uses *_template a lot */ \ 913 "*_template", /* scsi uses *_template a lot */ \
912 "*_timer", /* arm uses ops structures named _timer a lot */ \ 914 "*_timer", /* arm uses ops structures named _timer a lot */ \
913 "*_sht", /* scsi also used *_sht to some extent */ \ 915 "*_sht", /* scsi also used *_sht to some extent */ \
914 "*_ops", \ 916 "*_ops", \
915 "*_probe", \ 917 "*_probe", \
916 "*_probe_one", \ 918 "*_probe_one", \
917 "*_console" 919 "*_console"
918 920
919 static const char *head_sections[] = { ".head.text*", NULL }; 921 static const char *head_sections[] = { ".head.text*", NULL };
920 static const char *linker_symbols[] = 922 static const char *linker_symbols[] =
921 { "__init_begin", "_sinittext", "_einittext", NULL }; 923 { "__init_begin", "_sinittext", "_einittext", NULL };
922 924
923 enum mismatch { 925 enum mismatch {
924 TEXT_TO_ANY_INIT, 926 TEXT_TO_ANY_INIT,
925 DATA_TO_ANY_INIT, 927 DATA_TO_ANY_INIT,
926 TEXT_TO_ANY_EXIT, 928 TEXT_TO_ANY_EXIT,
927 DATA_TO_ANY_EXIT, 929 DATA_TO_ANY_EXIT,
928 XXXINIT_TO_SOME_INIT, 930 XXXINIT_TO_SOME_INIT,
929 XXXEXIT_TO_SOME_EXIT, 931 XXXEXIT_TO_SOME_EXIT,
930 ANY_INIT_TO_ANY_EXIT, 932 ANY_INIT_TO_ANY_EXIT,
931 ANY_EXIT_TO_ANY_INIT, 933 ANY_EXIT_TO_ANY_INIT,
932 EXPORT_TO_INIT_EXIT, 934 EXPORT_TO_INIT_EXIT,
933 }; 935 };
934 936
935 struct sectioncheck { 937 struct sectioncheck {
936 const char *fromsec[20]; 938 const char *fromsec[20];
937 const char *tosec[20]; 939 const char *tosec[20];
938 enum mismatch mismatch; 940 enum mismatch mismatch;
939 const char *symbol_white_list[20]; 941 const char *symbol_white_list[20];
940 }; 942 };
941 943
942 const struct sectioncheck sectioncheck[] = { 944 const struct sectioncheck sectioncheck[] = {
943 /* Do not reference init/exit code/data from 945 /* Do not reference init/exit code/data from
944 * normal code and data 946 * normal code and data
945 */ 947 */
946 { 948 {
947 .fromsec = { TEXT_SECTIONS, NULL }, 949 .fromsec = { TEXT_SECTIONS, NULL },
948 .tosec = { ALL_INIT_SECTIONS, NULL }, 950 .tosec = { ALL_INIT_SECTIONS, NULL },
949 .mismatch = TEXT_TO_ANY_INIT, 951 .mismatch = TEXT_TO_ANY_INIT,
950 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 952 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
951 }, 953 },
952 { 954 {
953 .fromsec = { DATA_SECTIONS, NULL }, 955 .fromsec = { DATA_SECTIONS, NULL },
954 .tosec = { ALL_XXXINIT_SECTIONS, NULL }, 956 .tosec = { ALL_XXXINIT_SECTIONS, NULL },
955 .mismatch = DATA_TO_ANY_INIT, 957 .mismatch = DATA_TO_ANY_INIT,
956 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 958 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
957 }, 959 },
958 { 960 {
959 .fromsec = { DATA_SECTIONS, NULL }, 961 .fromsec = { DATA_SECTIONS, NULL },
960 .tosec = { INIT_SECTIONS, NULL }, 962 .tosec = { INIT_SECTIONS, NULL },
961 .mismatch = DATA_TO_ANY_INIT, 963 .mismatch = DATA_TO_ANY_INIT,
962 .symbol_white_list = { 964 .symbol_white_list = {
963 "*_template", "*_timer", "*_sht", "*_ops", 965 "*_template", "*_timer", "*_sht", "*_ops",
964 "*_probe", "*_probe_one", "*_console", NULL 966 "*_probe", "*_probe_one", "*_console", NULL
965 }, 967 },
966 }, 968 },
967 { 969 {
968 .fromsec = { TEXT_SECTIONS, NULL }, 970 .fromsec = { TEXT_SECTIONS, NULL },
969 .tosec = { ALL_EXIT_SECTIONS, NULL }, 971 .tosec = { ALL_EXIT_SECTIONS, NULL },
970 .mismatch = TEXT_TO_ANY_EXIT, 972 .mismatch = TEXT_TO_ANY_EXIT,
971 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 973 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
972 }, 974 },
973 { 975 {
974 .fromsec = { DATA_SECTIONS, NULL }, 976 .fromsec = { DATA_SECTIONS, NULL },
975 .tosec = { ALL_EXIT_SECTIONS, NULL }, 977 .tosec = { ALL_EXIT_SECTIONS, NULL },
976 .mismatch = DATA_TO_ANY_EXIT, 978 .mismatch = DATA_TO_ANY_EXIT,
977 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 979 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
978 }, 980 },
979 /* Do not reference init code/data from devinit/cpuinit/meminit code/data */ 981 /* Do not reference init code/data from devinit/cpuinit/meminit code/data */
980 { 982 {
981 .fromsec = { ALL_XXXINIT_SECTIONS, NULL }, 983 .fromsec = { ALL_XXXINIT_SECTIONS, NULL },
982 .tosec = { INIT_SECTIONS, NULL }, 984 .tosec = { INIT_SECTIONS, NULL },
983 .mismatch = XXXINIT_TO_SOME_INIT, 985 .mismatch = XXXINIT_TO_SOME_INIT,
984 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 986 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
985 }, 987 },
986 /* Do not reference cpuinit code/data from meminit code/data */ 988 /* Do not reference cpuinit code/data from meminit code/data */
987 { 989 {
988 .fromsec = { MEM_INIT_SECTIONS, NULL }, 990 .fromsec = { MEM_INIT_SECTIONS, NULL },
989 .tosec = { CPU_INIT_SECTIONS, NULL }, 991 .tosec = { CPU_INIT_SECTIONS, NULL },
990 .mismatch = XXXINIT_TO_SOME_INIT, 992 .mismatch = XXXINIT_TO_SOME_INIT,
991 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 993 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
992 }, 994 },
993 /* Do not reference meminit code/data from cpuinit code/data */ 995 /* Do not reference meminit code/data from cpuinit code/data */
994 { 996 {
995 .fromsec = { CPU_INIT_SECTIONS, NULL }, 997 .fromsec = { CPU_INIT_SECTIONS, NULL },
996 .tosec = { MEM_INIT_SECTIONS, NULL }, 998 .tosec = { MEM_INIT_SECTIONS, NULL },
997 .mismatch = XXXINIT_TO_SOME_INIT, 999 .mismatch = XXXINIT_TO_SOME_INIT,
998 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 1000 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
999 }, 1001 },
1000 /* Do not reference exit code/data from devexit/cpuexit/memexit code/data */ 1002 /* Do not reference exit code/data from devexit/cpuexit/memexit code/data */
1001 { 1003 {
1002 .fromsec = { ALL_XXXEXIT_SECTIONS, NULL }, 1004 .fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
1003 .tosec = { EXIT_SECTIONS, NULL }, 1005 .tosec = { EXIT_SECTIONS, NULL },
1004 .mismatch = XXXEXIT_TO_SOME_EXIT, 1006 .mismatch = XXXEXIT_TO_SOME_EXIT,
1005 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 1007 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1006 }, 1008 },
1007 /* Do not reference cpuexit code/data from memexit code/data */ 1009 /* Do not reference cpuexit code/data from memexit code/data */
1008 { 1010 {
1009 .fromsec = { MEM_EXIT_SECTIONS, NULL }, 1011 .fromsec = { MEM_EXIT_SECTIONS, NULL },
1010 .tosec = { CPU_EXIT_SECTIONS, NULL }, 1012 .tosec = { CPU_EXIT_SECTIONS, NULL },
1011 .mismatch = XXXEXIT_TO_SOME_EXIT, 1013 .mismatch = XXXEXIT_TO_SOME_EXIT,
1012 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 1014 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1013 }, 1015 },
1014 /* Do not reference memexit code/data from cpuexit code/data */ 1016 /* Do not reference memexit code/data from cpuexit code/data */
1015 { 1017 {
1016 .fromsec = { CPU_EXIT_SECTIONS, NULL }, 1018 .fromsec = { CPU_EXIT_SECTIONS, NULL },
1017 .tosec = { MEM_EXIT_SECTIONS, NULL }, 1019 .tosec = { MEM_EXIT_SECTIONS, NULL },
1018 .mismatch = XXXEXIT_TO_SOME_EXIT, 1020 .mismatch = XXXEXIT_TO_SOME_EXIT,
1019 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 1021 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1020 }, 1022 },
1021 /* Do not use exit code/data from init code */ 1023 /* Do not use exit code/data from init code */
1022 { 1024 {
1023 .fromsec = { ALL_INIT_SECTIONS, NULL }, 1025 .fromsec = { ALL_INIT_SECTIONS, NULL },
1024 .tosec = { ALL_EXIT_SECTIONS, NULL }, 1026 .tosec = { ALL_EXIT_SECTIONS, NULL },
1025 .mismatch = ANY_INIT_TO_ANY_EXIT, 1027 .mismatch = ANY_INIT_TO_ANY_EXIT,
1026 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 1028 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1027 }, 1029 },
1028 /* Do not use init code/data from exit code */ 1030 /* Do not use init code/data from exit code */
1029 { 1031 {
1030 .fromsec = { ALL_EXIT_SECTIONS, NULL }, 1032 .fromsec = { ALL_EXIT_SECTIONS, NULL },
1031 .tosec = { ALL_INIT_SECTIONS, NULL }, 1033 .tosec = { ALL_INIT_SECTIONS, NULL },
1032 .mismatch = ANY_EXIT_TO_ANY_INIT, 1034 .mismatch = ANY_EXIT_TO_ANY_INIT,
1033 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 1035 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1034 }, 1036 },
1035 { 1037 {
1036 .fromsec = { ALL_PCI_INIT_SECTIONS, NULL }, 1038 .fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
1037 .tosec = { INIT_SECTIONS, NULL }, 1039 .tosec = { INIT_SECTIONS, NULL },
1038 .mismatch = ANY_INIT_TO_ANY_EXIT, 1040 .mismatch = ANY_INIT_TO_ANY_EXIT,
1039 .symbol_white_list = { NULL }, 1041 .symbol_white_list = { NULL },
1040 }, 1042 },
1041 /* Do not export init/exit functions or data */ 1043 /* Do not export init/exit functions or data */
1042 { 1044 {
1043 .fromsec = { "__ksymtab*", NULL }, 1045 .fromsec = { "__ksymtab*", NULL },
1044 .tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL }, 1046 .tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
1045 .mismatch = EXPORT_TO_INIT_EXIT, 1047 .mismatch = EXPORT_TO_INIT_EXIT,
1046 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 1048 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1047 } 1049 }
1048 }; 1050 };
1049 1051
1050 static const struct sectioncheck *section_mismatch( 1052 static const struct sectioncheck *section_mismatch(
1051 const char *fromsec, const char *tosec) 1053 const char *fromsec, const char *tosec)
1052 { 1054 {
1053 int i; 1055 int i;
1054 int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck); 1056 int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
1055 const struct sectioncheck *check = &sectioncheck[0]; 1057 const struct sectioncheck *check = &sectioncheck[0];
1056 1058
1057 for (i = 0; i < elems; i++) { 1059 for (i = 0; i < elems; i++) {
1058 if (match(fromsec, check->fromsec) && 1060 if (match(fromsec, check->fromsec) &&
1059 match(tosec, check->tosec)) 1061 match(tosec, check->tosec))
1060 return check; 1062 return check;
1061 check++; 1063 check++;
1062 } 1064 }
1063 return NULL; 1065 return NULL;
1064 } 1066 }
1065 1067
1066 /** 1068 /**
1067 * Whitelist to allow certain references to pass with no warning. 1069 * Whitelist to allow certain references to pass with no warning.
1068 * 1070 *
1069 * Pattern 1: 1071 * Pattern 1:
1070 * If a module parameter is declared __initdata and permissions=0 1072 * If a module parameter is declared __initdata and permissions=0
1071 * then this is legal despite the warning generated. 1073 * then this is legal despite the warning generated.
1072 * We cannot see value of permissions here, so just ignore 1074 * We cannot see value of permissions here, so just ignore
1073 * this pattern. 1075 * this pattern.
1074 * The pattern is identified by: 1076 * The pattern is identified by:
1075 * tosec = .init.data 1077 * tosec = .init.data
1076 * fromsec = .data* 1078 * fromsec = .data*
1077 * atsym =__param* 1079 * atsym =__param*
1078 * 1080 *
1079 * Pattern 1a: 1081 * Pattern 1a:
1080 * module_param_call() ops can refer to __init set function if permissions=0 1082 * module_param_call() ops can refer to __init set function if permissions=0
1081 * The pattern is identified by: 1083 * The pattern is identified by:
1082 * tosec = .init.text 1084 * tosec = .init.text
1083 * fromsec = .data* 1085 * fromsec = .data*
1084 * atsym = __param_ops_* 1086 * atsym = __param_ops_*
1085 * 1087 *
1086 * Pattern 2: 1088 * Pattern 2:
1087 * Many drivers utilise a *driver container with references to 1089 * Many drivers utilise a *driver container with references to
1088 * add, remove, probe functions etc. 1090 * add, remove, probe functions etc.
1089 * These functions may often be marked __devinit and we do not want to 1091 * These functions may often be marked __devinit and we do not want to
1090 * warn here. 1092 * warn here.
1091 * the pattern is identified by: 1093 * the pattern is identified by:
1092 * tosec = init or exit section 1094 * tosec = init or exit section
1093 * fromsec = data section 1095 * fromsec = data section
1094 * atsym = *driver, *_template, *_sht, *_ops, *_probe, 1096 * atsym = *driver, *_template, *_sht, *_ops, *_probe,
1095 * *probe_one, *_console, *_timer 1097 * *probe_one, *_console, *_timer
1096 * 1098 *
1097 * Pattern 3: 1099 * Pattern 3:
1098 * Whitelist all references from .head.text to any init section 1100 * Whitelist all references from .head.text to any init section
1099 * 1101 *
1100 * Pattern 4: 1102 * Pattern 4:
1101 * Some symbols belong to init section but still it is ok to reference 1103 * Some symbols belong to init section but still it is ok to reference
1102 * these from non-init sections as these symbols don't have any memory 1104 * these from non-init sections as these symbols don't have any memory
1103 * allocated for them and symbol address and value are same. So even 1105 * allocated for them and symbol address and value are same. So even
1104 * if init section is freed, its ok to reference those symbols. 1106 * if init section is freed, its ok to reference those symbols.
1105 * For ex. symbols marking the init section boundaries. 1107 * For ex. symbols marking the init section boundaries.
1106 * This pattern is identified by 1108 * This pattern is identified by
1107 * refsymname = __init_begin, _sinittext, _einittext 1109 * refsymname = __init_begin, _sinittext, _einittext
1108 * 1110 *
1109 **/ 1111 **/
1110 static int secref_whitelist(const struct sectioncheck *mismatch, 1112 static int secref_whitelist(const struct sectioncheck *mismatch,
1111 const char *fromsec, const char *fromsym, 1113 const char *fromsec, const char *fromsym,
1112 const char *tosec, const char *tosym) 1114 const char *tosec, const char *tosym)
1113 { 1115 {
1114 /* Check for pattern 1 */ 1116 /* Check for pattern 1 */
1115 if (match(tosec, init_data_sections) && 1117 if (match(tosec, init_data_sections) &&
1116 match(fromsec, data_sections) && 1118 match(fromsec, data_sections) &&
1117 (strncmp(fromsym, "__param", strlen("__param")) == 0)) 1119 (strncmp(fromsym, "__param", strlen("__param")) == 0))
1118 return 0; 1120 return 0;
1119 1121
1120 /* Check for pattern 1a */ 1122 /* Check for pattern 1a */
1121 if (strcmp(tosec, ".init.text") == 0 && 1123 if (strcmp(tosec, ".init.text") == 0 &&
1122 match(fromsec, data_sections) && 1124 match(fromsec, data_sections) &&
1123 (strncmp(fromsym, "__param_ops_", strlen("__param_ops_")) == 0)) 1125 (strncmp(fromsym, "__param_ops_", strlen("__param_ops_")) == 0))
1124 return 0; 1126 return 0;
1125 1127
1126 /* Check for pattern 2 */ 1128 /* Check for pattern 2 */
1127 if (match(tosec, init_exit_sections) && 1129 if (match(tosec, init_exit_sections) &&
1128 match(fromsec, data_sections) && 1130 match(fromsec, data_sections) &&
1129 match(fromsym, mismatch->symbol_white_list)) 1131 match(fromsym, mismatch->symbol_white_list))
1130 return 0; 1132 return 0;
1131 1133
1132 /* Check for pattern 3 */ 1134 /* Check for pattern 3 */
1133 if (match(fromsec, head_sections) && 1135 if (match(fromsec, head_sections) &&
1134 match(tosec, init_sections)) 1136 match(tosec, init_sections))
1135 return 0; 1137 return 0;
1136 1138
1137 /* Check for pattern 4 */ 1139 /* Check for pattern 4 */
1138 if (match(tosym, linker_symbols)) 1140 if (match(tosym, linker_symbols))
1139 return 0; 1141 return 0;
1140 1142
1141 return 1; 1143 return 1;
1142 } 1144 }
1143 1145
1144 /** 1146 /**
1145 * Find symbol based on relocation record info. 1147 * Find symbol based on relocation record info.
1146 * In some cases the symbol supplied is a valid symbol so 1148 * In some cases the symbol supplied is a valid symbol so
1147 * return refsym. If st_name != 0 we assume this is a valid symbol. 1149 * return refsym. If st_name != 0 we assume this is a valid symbol.
1148 * In other cases the symbol needs to be looked up in the symbol table 1150 * In other cases the symbol needs to be looked up in the symbol table
1149 * based on section and address. 1151 * based on section and address.
1150 * **/ 1152 * **/
1151 static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr, 1153 static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
1152 Elf_Sym *relsym) 1154 Elf_Sym *relsym)
1153 { 1155 {
1154 Elf_Sym *sym; 1156 Elf_Sym *sym;
1155 Elf_Sym *near = NULL; 1157 Elf_Sym *near = NULL;
1156 Elf64_Sword distance = 20; 1158 Elf64_Sword distance = 20;
1157 Elf64_Sword d; 1159 Elf64_Sword d;
1158 unsigned int relsym_secindex; 1160 unsigned int relsym_secindex;
1159 1161
1160 if (relsym->st_name != 0) 1162 if (relsym->st_name != 0)
1161 return relsym; 1163 return relsym;
1162 1164
1163 relsym_secindex = get_secindex(elf, relsym); 1165 relsym_secindex = get_secindex(elf, relsym);
1164 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) { 1166 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1165 if (get_secindex(elf, sym) != relsym_secindex) 1167 if (get_secindex(elf, sym) != relsym_secindex)
1166 continue; 1168 continue;
1167 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION) 1169 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1168 continue; 1170 continue;
1169 if (sym->st_value == addr) 1171 if (sym->st_value == addr)
1170 return sym; 1172 return sym;
1171 /* Find a symbol nearby - addr are maybe negative */ 1173 /* Find a symbol nearby - addr are maybe negative */
1172 d = sym->st_value - addr; 1174 d = sym->st_value - addr;
1173 if (d < 0) 1175 if (d < 0)
1174 d = addr - sym->st_value; 1176 d = addr - sym->st_value;
1175 if (d < distance) { 1177 if (d < distance) {
1176 distance = d; 1178 distance = d;
1177 near = sym; 1179 near = sym;
1178 } 1180 }
1179 } 1181 }
1180 /* We need a close match */ 1182 /* We need a close match */
1181 if (distance < 20) 1183 if (distance < 20)
1182 return near; 1184 return near;
1183 else 1185 else
1184 return NULL; 1186 return NULL;
1185 } 1187 }
1186 1188
1187 static inline int is_arm_mapping_symbol(const char *str) 1189 static inline int is_arm_mapping_symbol(const char *str)
1188 { 1190 {
1189 return str[0] == '$' && strchr("atd", str[1]) 1191 return str[0] == '$' && strchr("atd", str[1])
1190 && (str[2] == '\0' || str[2] == '.'); 1192 && (str[2] == '\0' || str[2] == '.');
1191 } 1193 }
1192 1194
1193 /* 1195 /*
1194 * If there's no name there, ignore it; likewise, ignore it if it's 1196 * If there's no name there, ignore it; likewise, ignore it if it's
1195 * one of the magic symbols emitted used by current ARM tools. 1197 * one of the magic symbols emitted used by current ARM tools.
1196 * 1198 *
1197 * Otherwise if find_symbols_between() returns those symbols, they'll 1199 * Otherwise if find_symbols_between() returns those symbols, they'll
1198 * fail the whitelist tests and cause lots of false alarms ... fixable 1200 * fail the whitelist tests and cause lots of false alarms ... fixable
1199 * only by merging __exit and __init sections into __text, bloating 1201 * only by merging __exit and __init sections into __text, bloating
1200 * the kernel (which is especially evil on embedded platforms). 1202 * the kernel (which is especially evil on embedded platforms).
1201 */ 1203 */
1202 static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym) 1204 static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1203 { 1205 {
1204 const char *name = elf->strtab + sym->st_name; 1206 const char *name = elf->strtab + sym->st_name;
1205 1207
1206 if (!name || !strlen(name)) 1208 if (!name || !strlen(name))
1207 return 0; 1209 return 0;
1208 return !is_arm_mapping_symbol(name); 1210 return !is_arm_mapping_symbol(name);
1209 } 1211 }
1210 1212
1211 /* 1213 /*
1212 * Find symbols before or equal addr and after addr - in the section sec. 1214 * Find symbols before or equal addr and after addr - in the section sec.
1213 * If we find two symbols with equal offset prefer one with a valid name. 1215 * If we find two symbols with equal offset prefer one with a valid name.
1214 * The ELF format may have a better way to detect what type of symbol 1216 * The ELF format may have a better way to detect what type of symbol
1215 * it is, but this works for now. 1217 * it is, but this works for now.
1216 **/ 1218 **/
1217 static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr, 1219 static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1218 const char *sec) 1220 const char *sec)
1219 { 1221 {
1220 Elf_Sym *sym; 1222 Elf_Sym *sym;
1221 Elf_Sym *near = NULL; 1223 Elf_Sym *near = NULL;
1222 Elf_Addr distance = ~0; 1224 Elf_Addr distance = ~0;
1223 1225
1224 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) { 1226 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1225 const char *symsec; 1227 const char *symsec;
1226 1228
1227 if (is_shndx_special(sym->st_shndx)) 1229 if (is_shndx_special(sym->st_shndx))
1228 continue; 1230 continue;
1229 symsec = sec_name(elf, get_secindex(elf, sym)); 1231 symsec = sec_name(elf, get_secindex(elf, sym));
1230 if (strcmp(symsec, sec) != 0) 1232 if (strcmp(symsec, sec) != 0)
1231 continue; 1233 continue;
1232 if (!is_valid_name(elf, sym)) 1234 if (!is_valid_name(elf, sym))
1233 continue; 1235 continue;
1234 if (sym->st_value <= addr) { 1236 if (sym->st_value <= addr) {
1235 if ((addr - sym->st_value) < distance) { 1237 if ((addr - sym->st_value) < distance) {
1236 distance = addr - sym->st_value; 1238 distance = addr - sym->st_value;
1237 near = sym; 1239 near = sym;
1238 } else if ((addr - sym->st_value) == distance) { 1240 } else if ((addr - sym->st_value) == distance) {
1239 near = sym; 1241 near = sym;
1240 } 1242 }
1241 } 1243 }
1242 } 1244 }
1243 return near; 1245 return near;
1244 } 1246 }
1245 1247
1246 /* 1248 /*
1247 * Convert a section name to the function/data attribute 1249 * Convert a section name to the function/data attribute
1248 * .init.text => __init 1250 * .init.text => __init
1249 * .cpuinit.data => __cpudata 1251 * .cpuinit.data => __cpudata
1250 * .memexitconst => __memconst 1252 * .memexitconst => __memconst
1251 * etc. 1253 * etc.
1252 * 1254 *
1253 * The memory of returned value has been allocated on a heap. The user of this 1255 * The memory of returned value has been allocated on a heap. The user of this
1254 * method should free it after usage. 1256 * method should free it after usage.
1255 */ 1257 */
1256 static char *sec2annotation(const char *s) 1258 static char *sec2annotation(const char *s)
1257 { 1259 {
1258 if (match(s, init_exit_sections)) { 1260 if (match(s, init_exit_sections)) {
1259 char *p = malloc(20); 1261 char *p = malloc(20);
1260 char *r = p; 1262 char *r = p;
1261 1263
1262 *p++ = '_'; 1264 *p++ = '_';
1263 *p++ = '_'; 1265 *p++ = '_';
1264 if (*s == '.') 1266 if (*s == '.')
1265 s++; 1267 s++;
1266 while (*s && *s != '.') 1268 while (*s && *s != '.')
1267 *p++ = *s++; 1269 *p++ = *s++;
1268 *p = '\0'; 1270 *p = '\0';
1269 if (*s == '.') 1271 if (*s == '.')
1270 s++; 1272 s++;
1271 if (strstr(s, "rodata") != NULL) 1273 if (strstr(s, "rodata") != NULL)
1272 strcat(p, "const "); 1274 strcat(p, "const ");
1273 else if (strstr(s, "data") != NULL) 1275 else if (strstr(s, "data") != NULL)
1274 strcat(p, "data "); 1276 strcat(p, "data ");
1275 else 1277 else
1276 strcat(p, " "); 1278 strcat(p, " ");
1277 return r; 1279 return r;
1278 } else { 1280 } else {
1279 return strdup(""); 1281 return strdup("");
1280 } 1282 }
1281 } 1283 }
1282 1284
1283 static int is_function(Elf_Sym *sym) 1285 static int is_function(Elf_Sym *sym)
1284 { 1286 {
1285 if (sym) 1287 if (sym)
1286 return ELF_ST_TYPE(sym->st_info) == STT_FUNC; 1288 return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1287 else 1289 else
1288 return -1; 1290 return -1;
1289 } 1291 }
1290 1292
1291 static void print_section_list(const char * const list[20]) 1293 static void print_section_list(const char * const list[20])
1292 { 1294 {
1293 const char *const *s = list; 1295 const char *const *s = list;
1294 1296
1295 while (*s) { 1297 while (*s) {
1296 fprintf(stderr, "%s", *s); 1298 fprintf(stderr, "%s", *s);
1297 s++; 1299 s++;
1298 if (*s) 1300 if (*s)
1299 fprintf(stderr, ", "); 1301 fprintf(stderr, ", ");
1300 } 1302 }
1301 fprintf(stderr, "\n"); 1303 fprintf(stderr, "\n");
1302 } 1304 }
1303 1305
1304 /* 1306 /*
1305 * Print a warning about a section mismatch. 1307 * Print a warning about a section mismatch.
1306 * Try to find symbols near it so user can find it. 1308 * Try to find symbols near it so user can find it.
1307 * Check whitelist before warning - it may be a false positive. 1309 * Check whitelist before warning - it may be a false positive.
1308 */ 1310 */
1309 static void report_sec_mismatch(const char *modname, 1311 static void report_sec_mismatch(const char *modname,
1310 const struct sectioncheck *mismatch, 1312 const struct sectioncheck *mismatch,
1311 const char *fromsec, 1313 const char *fromsec,
1312 unsigned long long fromaddr, 1314 unsigned long long fromaddr,
1313 const char *fromsym, 1315 const char *fromsym,
1314 int from_is_func, 1316 int from_is_func,
1315 const char *tosec, const char *tosym, 1317 const char *tosec, const char *tosym,
1316 int to_is_func) 1318 int to_is_func)
1317 { 1319 {
1318 const char *from, *from_p; 1320 const char *from, *from_p;
1319 const char *to, *to_p; 1321 const char *to, *to_p;
1320 char *prl_from; 1322 char *prl_from;
1321 char *prl_to; 1323 char *prl_to;
1322 1324
1323 switch (from_is_func) { 1325 switch (from_is_func) {
1324 case 0: from = "variable"; from_p = ""; break; 1326 case 0: from = "variable"; from_p = ""; break;
1325 case 1: from = "function"; from_p = "()"; break; 1327 case 1: from = "function"; from_p = "()"; break;
1326 default: from = "(unknown reference)"; from_p = ""; break; 1328 default: from = "(unknown reference)"; from_p = ""; break;
1327 } 1329 }
1328 switch (to_is_func) { 1330 switch (to_is_func) {
1329 case 0: to = "variable"; to_p = ""; break; 1331 case 0: to = "variable"; to_p = ""; break;
1330 case 1: to = "function"; to_p = "()"; break; 1332 case 1: to = "function"; to_p = "()"; break;
1331 default: to = "(unknown reference)"; to_p = ""; break; 1333 default: to = "(unknown reference)"; to_p = ""; break;
1332 } 1334 }
1333 1335
1334 sec_mismatch_count++; 1336 sec_mismatch_count++;
1335 if (!sec_mismatch_verbose) 1337 if (!sec_mismatch_verbose)
1336 return; 1338 return;
1337 1339
1338 warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s " 1340 warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1339 "to the %s %s:%s%s\n", 1341 "to the %s %s:%s%s\n",
1340 modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec, 1342 modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
1341 tosym, to_p); 1343 tosym, to_p);
1342 1344
1343 switch (mismatch->mismatch) { 1345 switch (mismatch->mismatch) {
1344 case TEXT_TO_ANY_INIT: 1346 case TEXT_TO_ANY_INIT:
1345 prl_from = sec2annotation(fromsec); 1347 prl_from = sec2annotation(fromsec);
1346 prl_to = sec2annotation(tosec); 1348 prl_to = sec2annotation(tosec);
1347 fprintf(stderr, 1349 fprintf(stderr,
1348 "The function %s%s() references\n" 1350 "The function %s%s() references\n"
1349 "the %s %s%s%s.\n" 1351 "the %s %s%s%s.\n"
1350 "This is often because %s lacks a %s\n" 1352 "This is often because %s lacks a %s\n"
1351 "annotation or the annotation of %s is wrong.\n", 1353 "annotation or the annotation of %s is wrong.\n",
1352 prl_from, fromsym, 1354 prl_from, fromsym,
1353 to, prl_to, tosym, to_p, 1355 to, prl_to, tosym, to_p,
1354 fromsym, prl_to, tosym); 1356 fromsym, prl_to, tosym);
1355 free(prl_from); 1357 free(prl_from);
1356 free(prl_to); 1358 free(prl_to);
1357 break; 1359 break;
1358 case DATA_TO_ANY_INIT: { 1360 case DATA_TO_ANY_INIT: {
1359 prl_to = sec2annotation(tosec); 1361 prl_to = sec2annotation(tosec);
1360 fprintf(stderr, 1362 fprintf(stderr,
1361 "The variable %s references\n" 1363 "The variable %s references\n"
1362 "the %s %s%s%s\n" 1364 "the %s %s%s%s\n"
1363 "If the reference is valid then annotate the\n" 1365 "If the reference is valid then annotate the\n"
1364 "variable with __init* or __refdata (see linux/init.h) " 1366 "variable with __init* or __refdata (see linux/init.h) "
1365 "or name the variable:\n", 1367 "or name the variable:\n",
1366 fromsym, to, prl_to, tosym, to_p); 1368 fromsym, to, prl_to, tosym, to_p);
1367 print_section_list(mismatch->symbol_white_list); 1369 print_section_list(mismatch->symbol_white_list);
1368 free(prl_to); 1370 free(prl_to);
1369 break; 1371 break;
1370 } 1372 }
1371 case TEXT_TO_ANY_EXIT: 1373 case TEXT_TO_ANY_EXIT:
1372 prl_to = sec2annotation(tosec); 1374 prl_to = sec2annotation(tosec);
1373 fprintf(stderr, 1375 fprintf(stderr,
1374 "The function %s() references a %s in an exit section.\n" 1376 "The function %s() references a %s in an exit section.\n"
1375 "Often the %s %s%s has valid usage outside the exit section\n" 1377 "Often the %s %s%s has valid usage outside the exit section\n"
1376 "and the fix is to remove the %sannotation of %s.\n", 1378 "and the fix is to remove the %sannotation of %s.\n",
1377 fromsym, to, to, tosym, to_p, prl_to, tosym); 1379 fromsym, to, to, tosym, to_p, prl_to, tosym);
1378 free(prl_to); 1380 free(prl_to);
1379 break; 1381 break;
1380 case DATA_TO_ANY_EXIT: { 1382 case DATA_TO_ANY_EXIT: {
1381 prl_to = sec2annotation(tosec); 1383 prl_to = sec2annotation(tosec);
1382 fprintf(stderr, 1384 fprintf(stderr,
1383 "The variable %s references\n" 1385 "The variable %s references\n"
1384 "the %s %s%s%s\n" 1386 "the %s %s%s%s\n"
1385 "If the reference is valid then annotate the\n" 1387 "If the reference is valid then annotate the\n"
1386 "variable with __exit* (see linux/init.h) or " 1388 "variable with __exit* (see linux/init.h) or "
1387 "name the variable:\n", 1389 "name the variable:\n",
1388 fromsym, to, prl_to, tosym, to_p); 1390 fromsym, to, prl_to, tosym, to_p);
1389 print_section_list(mismatch->symbol_white_list); 1391 print_section_list(mismatch->symbol_white_list);
1390 free(prl_to); 1392 free(prl_to);
1391 break; 1393 break;
1392 } 1394 }
1393 case XXXINIT_TO_SOME_INIT: 1395 case XXXINIT_TO_SOME_INIT:
1394 case XXXEXIT_TO_SOME_EXIT: 1396 case XXXEXIT_TO_SOME_EXIT:
1395 prl_from = sec2annotation(fromsec); 1397 prl_from = sec2annotation(fromsec);
1396 prl_to = sec2annotation(tosec); 1398 prl_to = sec2annotation(tosec);
1397 fprintf(stderr, 1399 fprintf(stderr,
1398 "The %s %s%s%s references\n" 1400 "The %s %s%s%s references\n"
1399 "a %s %s%s%s.\n" 1401 "a %s %s%s%s.\n"
1400 "If %s is only used by %s then\n" 1402 "If %s is only used by %s then\n"
1401 "annotate %s with a matching annotation.\n", 1403 "annotate %s with a matching annotation.\n",
1402 from, prl_from, fromsym, from_p, 1404 from, prl_from, fromsym, from_p,
1403 to, prl_to, tosym, to_p, 1405 to, prl_to, tosym, to_p,
1404 tosym, fromsym, tosym); 1406 tosym, fromsym, tosym);
1405 free(prl_from); 1407 free(prl_from);
1406 free(prl_to); 1408 free(prl_to);
1407 break; 1409 break;
1408 case ANY_INIT_TO_ANY_EXIT: 1410 case ANY_INIT_TO_ANY_EXIT:
1409 prl_from = sec2annotation(fromsec); 1411 prl_from = sec2annotation(fromsec);
1410 prl_to = sec2annotation(tosec); 1412 prl_to = sec2annotation(tosec);
1411 fprintf(stderr, 1413 fprintf(stderr,
1412 "The %s %s%s%s references\n" 1414 "The %s %s%s%s references\n"
1413 "a %s %s%s%s.\n" 1415 "a %s %s%s%s.\n"
1414 "This is often seen when error handling " 1416 "This is often seen when error handling "
1415 "in the init function\n" 1417 "in the init function\n"
1416 "uses functionality in the exit path.\n" 1418 "uses functionality in the exit path.\n"
1417 "The fix is often to remove the %sannotation of\n" 1419 "The fix is often to remove the %sannotation of\n"
1418 "%s%s so it may be used outside an exit section.\n", 1420 "%s%s so it may be used outside an exit section.\n",
1419 from, prl_from, fromsym, from_p, 1421 from, prl_from, fromsym, from_p,
1420 to, prl_to, tosym, to_p, 1422 to, prl_to, tosym, to_p,
1421 prl_to, tosym, to_p); 1423 prl_to, tosym, to_p);
1422 free(prl_from); 1424 free(prl_from);
1423 free(prl_to); 1425 free(prl_to);
1424 break; 1426 break;
1425 case ANY_EXIT_TO_ANY_INIT: 1427 case ANY_EXIT_TO_ANY_INIT:
1426 prl_from = sec2annotation(fromsec); 1428 prl_from = sec2annotation(fromsec);
1427 prl_to = sec2annotation(tosec); 1429 prl_to = sec2annotation(tosec);
1428 fprintf(stderr, 1430 fprintf(stderr,
1429 "The %s %s%s%s references\n" 1431 "The %s %s%s%s references\n"
1430 "a %s %s%s%s.\n" 1432 "a %s %s%s%s.\n"
1431 "This is often seen when error handling " 1433 "This is often seen when error handling "
1432 "in the exit function\n" 1434 "in the exit function\n"
1433 "uses functionality in the init path.\n" 1435 "uses functionality in the init path.\n"
1434 "The fix is often to remove the %sannotation of\n" 1436 "The fix is often to remove the %sannotation of\n"
1435 "%s%s so it may be used outside an init section.\n", 1437 "%s%s so it may be used outside an init section.\n",
1436 from, prl_from, fromsym, from_p, 1438 from, prl_from, fromsym, from_p,
1437 to, prl_to, tosym, to_p, 1439 to, prl_to, tosym, to_p,
1438 prl_to, tosym, to_p); 1440 prl_to, tosym, to_p);
1439 free(prl_from); 1441 free(prl_from);
1440 free(prl_to); 1442 free(prl_to);
1441 break; 1443 break;
1442 case EXPORT_TO_INIT_EXIT: 1444 case EXPORT_TO_INIT_EXIT:
1443 prl_to = sec2annotation(tosec); 1445 prl_to = sec2annotation(tosec);
1444 fprintf(stderr, 1446 fprintf(stderr,
1445 "The symbol %s is exported and annotated %s\n" 1447 "The symbol %s is exported and annotated %s\n"
1446 "Fix this by removing the %sannotation of %s " 1448 "Fix this by removing the %sannotation of %s "
1447 "or drop the export.\n", 1449 "or drop the export.\n",
1448 tosym, prl_to, prl_to, tosym); 1450 tosym, prl_to, prl_to, tosym);
1449 free(prl_to); 1451 free(prl_to);
1450 break; 1452 break;
1451 } 1453 }
1452 fprintf(stderr, "\n"); 1454 fprintf(stderr, "\n");
1453 } 1455 }
1454 1456
1455 static void check_section_mismatch(const char *modname, struct elf_info *elf, 1457 static void check_section_mismatch(const char *modname, struct elf_info *elf,
1456 Elf_Rela *r, Elf_Sym *sym, const char *fromsec) 1458 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1457 { 1459 {
1458 const char *tosec; 1460 const char *tosec;
1459 const struct sectioncheck *mismatch; 1461 const struct sectioncheck *mismatch;
1460 1462
1461 tosec = sec_name(elf, get_secindex(elf, sym)); 1463 tosec = sec_name(elf, get_secindex(elf, sym));
1462 mismatch = section_mismatch(fromsec, tosec); 1464 mismatch = section_mismatch(fromsec, tosec);
1463 if (mismatch) { 1465 if (mismatch) {
1464 Elf_Sym *to; 1466 Elf_Sym *to;
1465 Elf_Sym *from; 1467 Elf_Sym *from;
1466 const char *tosym; 1468 const char *tosym;
1467 const char *fromsym; 1469 const char *fromsym;
1468 1470
1469 from = find_elf_symbol2(elf, r->r_offset, fromsec); 1471 from = find_elf_symbol2(elf, r->r_offset, fromsec);
1470 fromsym = sym_name(elf, from); 1472 fromsym = sym_name(elf, from);
1471 to = find_elf_symbol(elf, r->r_addend, sym); 1473 to = find_elf_symbol(elf, r->r_addend, sym);
1472 tosym = sym_name(elf, to); 1474 tosym = sym_name(elf, to);
1473 1475
1474 /* check whitelist - we may ignore it */ 1476 /* check whitelist - we may ignore it */
1475 if (secref_whitelist(mismatch, 1477 if (secref_whitelist(mismatch,
1476 fromsec, fromsym, tosec, tosym)) { 1478 fromsec, fromsym, tosec, tosym)) {
1477 report_sec_mismatch(modname, mismatch, 1479 report_sec_mismatch(modname, mismatch,
1478 fromsec, r->r_offset, fromsym, 1480 fromsec, r->r_offset, fromsym,
1479 is_function(from), tosec, tosym, 1481 is_function(from), tosec, tosym,
1480 is_function(to)); 1482 is_function(to));
1481 } 1483 }
1482 } 1484 }
1483 } 1485 }
1484 1486
1485 static unsigned int *reloc_location(struct elf_info *elf, 1487 static unsigned int *reloc_location(struct elf_info *elf,
1486 Elf_Shdr *sechdr, Elf_Rela *r) 1488 Elf_Shdr *sechdr, Elf_Rela *r)
1487 { 1489 {
1488 Elf_Shdr *sechdrs = elf->sechdrs; 1490 Elf_Shdr *sechdrs = elf->sechdrs;
1489 int section = sechdr->sh_info; 1491 int section = sechdr->sh_info;
1490 1492
1491 return (void *)elf->hdr + sechdrs[section].sh_offset + 1493 return (void *)elf->hdr + sechdrs[section].sh_offset +
1492 r->r_offset; 1494 r->r_offset;
1493 } 1495 }
1494 1496
1495 static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r) 1497 static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1496 { 1498 {
1497 unsigned int r_typ = ELF_R_TYPE(r->r_info); 1499 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1498 unsigned int *location = reloc_location(elf, sechdr, r); 1500 unsigned int *location = reloc_location(elf, sechdr, r);
1499 1501
1500 switch (r_typ) { 1502 switch (r_typ) {
1501 case R_386_32: 1503 case R_386_32:
1502 r->r_addend = TO_NATIVE(*location); 1504 r->r_addend = TO_NATIVE(*location);
1503 break; 1505 break;
1504 case R_386_PC32: 1506 case R_386_PC32:
1505 r->r_addend = TO_NATIVE(*location) + 4; 1507 r->r_addend = TO_NATIVE(*location) + 4;
1506 /* For CONFIG_RELOCATABLE=y */ 1508 /* For CONFIG_RELOCATABLE=y */
1507 if (elf->hdr->e_type == ET_EXEC) 1509 if (elf->hdr->e_type == ET_EXEC)
1508 r->r_addend += r->r_offset; 1510 r->r_addend += r->r_offset;
1509 break; 1511 break;
1510 } 1512 }
1511 return 0; 1513 return 0;
1512 } 1514 }
1513 1515
1514 #ifndef R_ARM_CALL 1516 #ifndef R_ARM_CALL
1515 #define R_ARM_CALL 28 1517 #define R_ARM_CALL 28
1516 #endif 1518 #endif
1517 #ifndef R_ARM_JUMP24 1519 #ifndef R_ARM_JUMP24
1518 #define R_ARM_JUMP24 29 1520 #define R_ARM_JUMP24 29
1519 #endif 1521 #endif
1520 1522
1521 static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r) 1523 static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1522 { 1524 {
1523 unsigned int r_typ = ELF_R_TYPE(r->r_info); 1525 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1524 1526
1525 switch (r_typ) { 1527 switch (r_typ) {
1526 case R_ARM_ABS32: 1528 case R_ARM_ABS32:
1527 /* From ARM ABI: (S + A) | T */ 1529 /* From ARM ABI: (S + A) | T */
1528 r->r_addend = (int)(long) 1530 r->r_addend = (int)(long)
1529 (elf->symtab_start + ELF_R_SYM(r->r_info)); 1531 (elf->symtab_start + ELF_R_SYM(r->r_info));
1530 break; 1532 break;
1531 case R_ARM_PC24: 1533 case R_ARM_PC24:
1532 case R_ARM_CALL: 1534 case R_ARM_CALL:
1533 case R_ARM_JUMP24: 1535 case R_ARM_JUMP24:
1534 /* From ARM ABI: ((S + A) | T) - P */ 1536 /* From ARM ABI: ((S + A) | T) - P */
1535 r->r_addend = (int)(long)(elf->hdr + 1537 r->r_addend = (int)(long)(elf->hdr +
1536 sechdr->sh_offset + 1538 sechdr->sh_offset +
1537 (r->r_offset - sechdr->sh_addr)); 1539 (r->r_offset - sechdr->sh_addr));
1538 break; 1540 break;
1539 default: 1541 default:
1540 return 1; 1542 return 1;
1541 } 1543 }
1542 return 0; 1544 return 0;
1543 } 1545 }
1544 1546
1545 static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r) 1547 static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1546 { 1548 {
1547 unsigned int r_typ = ELF_R_TYPE(r->r_info); 1549 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1548 unsigned int *location = reloc_location(elf, sechdr, r); 1550 unsigned int *location = reloc_location(elf, sechdr, r);
1549 unsigned int inst; 1551 unsigned int inst;
1550 1552
1551 if (r_typ == R_MIPS_HI16) 1553 if (r_typ == R_MIPS_HI16)
1552 return 1; /* skip this */ 1554 return 1; /* skip this */
1553 inst = TO_NATIVE(*location); 1555 inst = TO_NATIVE(*location);
1554 switch (r_typ) { 1556 switch (r_typ) {
1555 case R_MIPS_LO16: 1557 case R_MIPS_LO16:
1556 r->r_addend = inst & 0xffff; 1558 r->r_addend = inst & 0xffff;
1557 break; 1559 break;
1558 case R_MIPS_26: 1560 case R_MIPS_26:
1559 r->r_addend = (inst & 0x03ffffff) << 2; 1561 r->r_addend = (inst & 0x03ffffff) << 2;
1560 break; 1562 break;
1561 case R_MIPS_32: 1563 case R_MIPS_32:
1562 r->r_addend = inst; 1564 r->r_addend = inst;
1563 break; 1565 break;
1564 } 1566 }
1565 return 0; 1567 return 0;
1566 } 1568 }
1567 1569
1568 static void section_rela(const char *modname, struct elf_info *elf, 1570 static void section_rela(const char *modname, struct elf_info *elf,
1569 Elf_Shdr *sechdr) 1571 Elf_Shdr *sechdr)
1570 { 1572 {
1571 Elf_Sym *sym; 1573 Elf_Sym *sym;
1572 Elf_Rela *rela; 1574 Elf_Rela *rela;
1573 Elf_Rela r; 1575 Elf_Rela r;
1574 unsigned int r_sym; 1576 unsigned int r_sym;
1575 const char *fromsec; 1577 const char *fromsec;
1576 1578
1577 Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset; 1579 Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
1578 Elf_Rela *stop = (void *)start + sechdr->sh_size; 1580 Elf_Rela *stop = (void *)start + sechdr->sh_size;
1579 1581
1580 fromsec = sech_name(elf, sechdr); 1582 fromsec = sech_name(elf, sechdr);
1581 fromsec += strlen(".rela"); 1583 fromsec += strlen(".rela");
1582 /* if from section (name) is know good then skip it */ 1584 /* if from section (name) is know good then skip it */
1583 if (match(fromsec, section_white_list)) 1585 if (match(fromsec, section_white_list))
1584 return; 1586 return;
1585 1587
1586 for (rela = start; rela < stop; rela++) { 1588 for (rela = start; rela < stop; rela++) {
1587 r.r_offset = TO_NATIVE(rela->r_offset); 1589 r.r_offset = TO_NATIVE(rela->r_offset);
1588 #if KERNEL_ELFCLASS == ELFCLASS64 1590 #if KERNEL_ELFCLASS == ELFCLASS64
1589 if (elf->hdr->e_machine == EM_MIPS) { 1591 if (elf->hdr->e_machine == EM_MIPS) {
1590 unsigned int r_typ; 1592 unsigned int r_typ;
1591 r_sym = ELF64_MIPS_R_SYM(rela->r_info); 1593 r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1592 r_sym = TO_NATIVE(r_sym); 1594 r_sym = TO_NATIVE(r_sym);
1593 r_typ = ELF64_MIPS_R_TYPE(rela->r_info); 1595 r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1594 r.r_info = ELF64_R_INFO(r_sym, r_typ); 1596 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1595 } else { 1597 } else {
1596 r.r_info = TO_NATIVE(rela->r_info); 1598 r.r_info = TO_NATIVE(rela->r_info);
1597 r_sym = ELF_R_SYM(r.r_info); 1599 r_sym = ELF_R_SYM(r.r_info);
1598 } 1600 }
1599 #else 1601 #else
1600 r.r_info = TO_NATIVE(rela->r_info); 1602 r.r_info = TO_NATIVE(rela->r_info);
1601 r_sym = ELF_R_SYM(r.r_info); 1603 r_sym = ELF_R_SYM(r.r_info);
1602 #endif 1604 #endif
1603 r.r_addend = TO_NATIVE(rela->r_addend); 1605 r.r_addend = TO_NATIVE(rela->r_addend);
1604 sym = elf->symtab_start + r_sym; 1606 sym = elf->symtab_start + r_sym;
1605 /* Skip special sections */ 1607 /* Skip special sections */
1606 if (is_shndx_special(sym->st_shndx)) 1608 if (is_shndx_special(sym->st_shndx))
1607 continue; 1609 continue;
1608 check_section_mismatch(modname, elf, &r, sym, fromsec); 1610 check_section_mismatch(modname, elf, &r, sym, fromsec);
1609 } 1611 }
1610 } 1612 }
1611 1613
1612 static void section_rel(const char *modname, struct elf_info *elf, 1614 static void section_rel(const char *modname, struct elf_info *elf,
1613 Elf_Shdr *sechdr) 1615 Elf_Shdr *sechdr)
1614 { 1616 {
1615 Elf_Sym *sym; 1617 Elf_Sym *sym;
1616 Elf_Rel *rel; 1618 Elf_Rel *rel;
1617 Elf_Rela r; 1619 Elf_Rela r;
1618 unsigned int r_sym; 1620 unsigned int r_sym;
1619 const char *fromsec; 1621 const char *fromsec;
1620 1622
1621 Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset; 1623 Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
1622 Elf_Rel *stop = (void *)start + sechdr->sh_size; 1624 Elf_Rel *stop = (void *)start + sechdr->sh_size;
1623 1625
1624 fromsec = sech_name(elf, sechdr); 1626 fromsec = sech_name(elf, sechdr);
1625 fromsec += strlen(".rel"); 1627 fromsec += strlen(".rel");
1626 /* if from section (name) is know good then skip it */ 1628 /* if from section (name) is know good then skip it */
1627 if (match(fromsec, section_white_list)) 1629 if (match(fromsec, section_white_list))
1628 return; 1630 return;
1629 1631
1630 for (rel = start; rel < stop; rel++) { 1632 for (rel = start; rel < stop; rel++) {
1631 r.r_offset = TO_NATIVE(rel->r_offset); 1633 r.r_offset = TO_NATIVE(rel->r_offset);
1632 #if KERNEL_ELFCLASS == ELFCLASS64 1634 #if KERNEL_ELFCLASS == ELFCLASS64
1633 if (elf->hdr->e_machine == EM_MIPS) { 1635 if (elf->hdr->e_machine == EM_MIPS) {
1634 unsigned int r_typ; 1636 unsigned int r_typ;
1635 r_sym = ELF64_MIPS_R_SYM(rel->r_info); 1637 r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1636 r_sym = TO_NATIVE(r_sym); 1638 r_sym = TO_NATIVE(r_sym);
1637 r_typ = ELF64_MIPS_R_TYPE(rel->r_info); 1639 r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1638 r.r_info = ELF64_R_INFO(r_sym, r_typ); 1640 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1639 } else { 1641 } else {
1640 r.r_info = TO_NATIVE(rel->r_info); 1642 r.r_info = TO_NATIVE(rel->r_info);
1641 r_sym = ELF_R_SYM(r.r_info); 1643 r_sym = ELF_R_SYM(r.r_info);
1642 } 1644 }
1643 #else 1645 #else
1644 r.r_info = TO_NATIVE(rel->r_info); 1646 r.r_info = TO_NATIVE(rel->r_info);
1645 r_sym = ELF_R_SYM(r.r_info); 1647 r_sym = ELF_R_SYM(r.r_info);
1646 #endif 1648 #endif
1647 r.r_addend = 0; 1649 r.r_addend = 0;
1648 switch (elf->hdr->e_machine) { 1650 switch (elf->hdr->e_machine) {
1649 case EM_386: 1651 case EM_386:
1650 if (addend_386_rel(elf, sechdr, &r)) 1652 if (addend_386_rel(elf, sechdr, &r))
1651 continue; 1653 continue;
1652 break; 1654 break;
1653 case EM_ARM: 1655 case EM_ARM:
1654 if (addend_arm_rel(elf, sechdr, &r)) 1656 if (addend_arm_rel(elf, sechdr, &r))
1655 continue; 1657 continue;
1656 break; 1658 break;
1657 case EM_MIPS: 1659 case EM_MIPS:
1658 if (addend_mips_rel(elf, sechdr, &r)) 1660 if (addend_mips_rel(elf, sechdr, &r))
1659 continue; 1661 continue;
1660 break; 1662 break;
1661 } 1663 }
1662 sym = elf->symtab_start + r_sym; 1664 sym = elf->symtab_start + r_sym;
1663 /* Skip special sections */ 1665 /* Skip special sections */
1664 if (is_shndx_special(sym->st_shndx)) 1666 if (is_shndx_special(sym->st_shndx))
1665 continue; 1667 continue;
1666 check_section_mismatch(modname, elf, &r, sym, fromsec); 1668 check_section_mismatch(modname, elf, &r, sym, fromsec);
1667 } 1669 }
1668 } 1670 }
1669 1671
1670 /** 1672 /**
1671 * A module includes a number of sections that are discarded 1673 * A module includes a number of sections that are discarded
1672 * either when loaded or when used as built-in. 1674 * either when loaded or when used as built-in.
1673 * For loaded modules all functions marked __init and all data 1675 * For loaded modules all functions marked __init and all data
1674 * marked __initdata will be discarded when the module has been initialized. 1676 * marked __initdata will be discarded when the module has been initialized.
1675 * Likewise for modules used built-in the sections marked __exit 1677 * Likewise for modules used built-in the sections marked __exit
1676 * are discarded because __exit marked function are supposed to be called 1678 * are discarded because __exit marked function are supposed to be called
1677 * only when a module is unloaded which never happens for built-in modules. 1679 * only when a module is unloaded which never happens for built-in modules.
1678 * The check_sec_ref() function traverses all relocation records 1680 * The check_sec_ref() function traverses all relocation records
1679 * to find all references to a section that reference a section that will 1681 * to find all references to a section that reference a section that will
1680 * be discarded and warns about it. 1682 * be discarded and warns about it.
1681 **/ 1683 **/
1682 static void check_sec_ref(struct module *mod, const char *modname, 1684 static void check_sec_ref(struct module *mod, const char *modname,
1683 struct elf_info *elf) 1685 struct elf_info *elf)
1684 { 1686 {
1685 int i; 1687 int i;
1686 Elf_Shdr *sechdrs = elf->sechdrs; 1688 Elf_Shdr *sechdrs = elf->sechdrs;
1687 1689
1688 /* Walk through all sections */ 1690 /* Walk through all sections */
1689 for (i = 0; i < elf->num_sections; i++) { 1691 for (i = 0; i < elf->num_sections; i++) {
1690 check_section(modname, elf, &elf->sechdrs[i]); 1692 check_section(modname, elf, &elf->sechdrs[i]);
1691 /* We want to process only relocation sections and not .init */ 1693 /* We want to process only relocation sections and not .init */
1692 if (sechdrs[i].sh_type == SHT_RELA) 1694 if (sechdrs[i].sh_type == SHT_RELA)
1693 section_rela(modname, elf, &elf->sechdrs[i]); 1695 section_rela(modname, elf, &elf->sechdrs[i]);
1694 else if (sechdrs[i].sh_type == SHT_REL) 1696 else if (sechdrs[i].sh_type == SHT_REL)
1695 section_rel(modname, elf, &elf->sechdrs[i]); 1697 section_rel(modname, elf, &elf->sechdrs[i]);
1696 } 1698 }
1697 } 1699 }
1698 1700
1699 static void read_symbols(char *modname) 1701 static void read_symbols(char *modname)
1700 { 1702 {
1701 const char *symname; 1703 const char *symname;
1702 char *version; 1704 char *version;
1703 char *license; 1705 char *license;
1704 struct module *mod; 1706 struct module *mod;
1705 struct elf_info info = { }; 1707 struct elf_info info = { };
1706 Elf_Sym *sym; 1708 Elf_Sym *sym;
1707 1709
1708 if (!parse_elf(&info, modname)) 1710 if (!parse_elf(&info, modname))
1709 return; 1711 return;
1710 1712
1711 mod = new_module(modname); 1713 mod = new_module(modname);
1712 1714
1713 /* When there's no vmlinux, don't print warnings about 1715 /* When there's no vmlinux, don't print warnings about
1714 * unresolved symbols (since there'll be too many ;) */ 1716 * unresolved symbols (since there'll be too many ;) */
1715 if (is_vmlinux(modname)) { 1717 if (is_vmlinux(modname)) {
1716 have_vmlinux = 1; 1718 have_vmlinux = 1;
1717 mod->skip = 1; 1719 mod->skip = 1;
1718 } 1720 }
1719 1721
1720 license = get_modinfo(info.modinfo, info.modinfo_len, "license"); 1722 license = get_modinfo(info.modinfo, info.modinfo_len, "license");
1721 if (info.modinfo && !license && !is_vmlinux(modname)) 1723 if (info.modinfo && !license && !is_vmlinux(modname))
1722 warn("modpost: missing MODULE_LICENSE() in %s\n" 1724 warn("modpost: missing MODULE_LICENSE() in %s\n"
1723 "see include/linux/module.h for " 1725 "see include/linux/module.h for "
1724 "more information\n", modname); 1726 "more information\n", modname);
1725 while (license) { 1727 while (license) {
1726 if (license_is_gpl_compatible(license)) 1728 if (license_is_gpl_compatible(license))
1727 mod->gpl_compatible = 1; 1729 mod->gpl_compatible = 1;
1728 else { 1730 else {
1729 mod->gpl_compatible = 0; 1731 mod->gpl_compatible = 0;
1730 break; 1732 break;
1731 } 1733 }
1732 license = get_next_modinfo(info.modinfo, info.modinfo_len, 1734 license = get_next_modinfo(info.modinfo, info.modinfo_len,
1733 "license", license); 1735 "license", license);
1734 } 1736 }
1735 1737
1736 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) { 1738 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
1737 symname = info.strtab + sym->st_name; 1739 symname = info.strtab + sym->st_name;
1738 1740
1739 handle_modversions(mod, &info, sym, symname); 1741 handle_modversions(mod, &info, sym, symname);
1740 handle_moddevtable(mod, &info, sym, symname); 1742 handle_moddevtable(mod, &info, sym, symname);
1741 } 1743 }
1742 if (!is_vmlinux(modname) || 1744 if (!is_vmlinux(modname) ||
1743 (is_vmlinux(modname) && vmlinux_section_warnings)) 1745 (is_vmlinux(modname) && vmlinux_section_warnings))
1744 check_sec_ref(mod, modname, &info); 1746 check_sec_ref(mod, modname, &info);
1745 1747
1746 version = get_modinfo(info.modinfo, info.modinfo_len, "version"); 1748 version = get_modinfo(info.modinfo, info.modinfo_len, "version");
1747 if (version) 1749 if (version)
1748 maybe_frob_rcs_version(modname, version, info.modinfo, 1750 maybe_frob_rcs_version(modname, version, info.modinfo,
1749 version - (char *)info.hdr); 1751 version - (char *)info.hdr);
1750 if (version || (all_versions && !is_vmlinux(modname))) 1752 if (version || (all_versions && !is_vmlinux(modname)))
1751 get_src_version(modname, mod->srcversion, 1753 get_src_version(modname, mod->srcversion,
1752 sizeof(mod->srcversion)-1); 1754 sizeof(mod->srcversion)-1);
1753 1755
1754 parse_elf_finish(&info); 1756 parse_elf_finish(&info);
1755 1757
1756 /* Our trick to get versioning for module struct etc. - it's 1758 /* Our trick to get versioning for module struct etc. - it's
1757 * never passed as an argument to an exported function, so 1759 * never passed as an argument to an exported function, so
1758 * the automatic versioning doesn't pick it up, but it's really 1760 * the automatic versioning doesn't pick it up, but it's really
1759 * important anyhow */ 1761 * important anyhow */
1760 if (modversions) 1762 if (modversions)
1761 mod->unres = alloc_symbol("module_layout", 0, mod->unres); 1763 mod->unres = alloc_symbol("module_layout", 0, mod->unres);
1762 } 1764 }
1763 1765
1764 #define SZ 500 1766 #define SZ 500
1765 1767
1766 /* We first write the generated file into memory using the 1768 /* We first write the generated file into memory using the
1767 * following helper, then compare to the file on disk and 1769 * following helper, then compare to the file on disk and
1768 * only update the later if anything changed */ 1770 * only update the later if anything changed */
1769 1771
1770 void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf, 1772 void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
1771 const char *fmt, ...) 1773 const char *fmt, ...)
1772 { 1774 {
1773 char tmp[SZ]; 1775 char tmp[SZ];
1774 int len; 1776 int len;
1775 va_list ap; 1777 va_list ap;
1776 1778
1777 va_start(ap, fmt); 1779 va_start(ap, fmt);
1778 len = vsnprintf(tmp, SZ, fmt, ap); 1780 len = vsnprintf(tmp, SZ, fmt, ap);
1779 buf_write(buf, tmp, len); 1781 buf_write(buf, tmp, len);
1780 va_end(ap); 1782 va_end(ap);
1781 } 1783 }
1782 1784
1783 void buf_write(struct buffer *buf, const char *s, int len) 1785 void buf_write(struct buffer *buf, const char *s, int len)
1784 { 1786 {
1785 if (buf->size - buf->pos < len) { 1787 if (buf->size - buf->pos < len) {
1786 buf->size += len + SZ; 1788 buf->size += len + SZ;
1787 buf->p = realloc(buf->p, buf->size); 1789 buf->p = realloc(buf->p, buf->size);
1788 } 1790 }
1789 strncpy(buf->p + buf->pos, s, len); 1791 strncpy(buf->p + buf->pos, s, len);
1790 buf->pos += len; 1792 buf->pos += len;
1791 } 1793 }
1792 1794
1793 static void check_for_gpl_usage(enum export exp, const char *m, const char *s) 1795 static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
1794 { 1796 {
1795 const char *e = is_vmlinux(m) ?"":".ko"; 1797 const char *e = is_vmlinux(m) ?"":".ko";
1796 1798
1797 switch (exp) { 1799 switch (exp) {
1798 case export_gpl: 1800 case export_gpl:
1799 fatal("modpost: GPL-incompatible module %s%s " 1801 fatal("modpost: GPL-incompatible module %s%s "
1800 "uses GPL-only symbol '%s'\n", m, e, s); 1802 "uses GPL-only symbol '%s'\n", m, e, s);
1801 break; 1803 break;
1802 case export_unused_gpl: 1804 case export_unused_gpl:
1803 fatal("modpost: GPL-incompatible module %s%s " 1805 fatal("modpost: GPL-incompatible module %s%s "
1804 "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s); 1806 "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s);
1805 break; 1807 break;
1806 case export_gpl_future: 1808 case export_gpl_future:
1807 warn("modpost: GPL-incompatible module %s%s " 1809 warn("modpost: GPL-incompatible module %s%s "
1808 "uses future GPL-only symbol '%s'\n", m, e, s); 1810 "uses future GPL-only symbol '%s'\n", m, e, s);
1809 break; 1811 break;
1810 case export_plain: 1812 case export_plain:
1811 case export_unused: 1813 case export_unused:
1812 case export_unknown: 1814 case export_unknown:
1813 /* ignore */ 1815 /* ignore */
1814 break; 1816 break;
1815 } 1817 }
1816 } 1818 }
1817 1819
1818 static void check_for_unused(enum export exp, const char *m, const char *s) 1820 static void check_for_unused(enum export exp, const char *m, const char *s)
1819 { 1821 {
1820 const char *e = is_vmlinux(m) ?"":".ko"; 1822 const char *e = is_vmlinux(m) ?"":".ko";
1821 1823
1822 switch (exp) { 1824 switch (exp) {
1823 case export_unused: 1825 case export_unused:
1824 case export_unused_gpl: 1826 case export_unused_gpl:
1825 warn("modpost: module %s%s " 1827 warn("modpost: module %s%s "
1826 "uses symbol '%s' marked UNUSED\n", m, e, s); 1828 "uses symbol '%s' marked UNUSED\n", m, e, s);
1827 break; 1829 break;
1828 default: 1830 default:
1829 /* ignore */ 1831 /* ignore */
1830 break; 1832 break;
1831 } 1833 }
1832 } 1834 }
1833 1835
1834 static void check_exports(struct module *mod) 1836 static void check_exports(struct module *mod)
1835 { 1837 {
1836 struct symbol *s, *exp; 1838 struct symbol *s, *exp;
1837 1839
1838 for (s = mod->unres; s; s = s->next) { 1840 for (s = mod->unres; s; s = s->next) {
1839 const char *basename; 1841 const char *basename;
1840 exp = find_symbol(s->name); 1842 exp = find_symbol(s->name);
1841 if (!exp || exp->module == mod) 1843 if (!exp || exp->module == mod)
1842 continue; 1844 continue;
1843 basename = strrchr(mod->name, '/'); 1845 basename = strrchr(mod->name, '/');
1844 if (basename) 1846 if (basename)
1845 basename++; 1847 basename++;
1846 else 1848 else
1847 basename = mod->name; 1849 basename = mod->name;
1848 if (!mod->gpl_compatible) 1850 if (!mod->gpl_compatible)
1849 check_for_gpl_usage(exp->export, basename, exp->name); 1851 check_for_gpl_usage(exp->export, basename, exp->name);
1850 check_for_unused(exp->export, basename, exp->name); 1852 check_for_unused(exp->export, basename, exp->name);
1851 } 1853 }
1852 } 1854 }
1853 1855
1854 /** 1856 /**
1855 * Header for the generated file 1857 * Header for the generated file
1856 **/ 1858 **/
1857 static void add_header(struct buffer *b, struct module *mod) 1859 static void add_header(struct buffer *b, struct module *mod)
1858 { 1860 {
1859 buf_printf(b, "#include <linux/module.h>\n"); 1861 buf_printf(b, "#include <linux/module.h>\n");
1860 buf_printf(b, "#include <linux/vermagic.h>\n"); 1862 buf_printf(b, "#include <linux/vermagic.h>\n");
1861 buf_printf(b, "#include <linux/compiler.h>\n"); 1863 buf_printf(b, "#include <linux/compiler.h>\n");
1862 buf_printf(b, "\n"); 1864 buf_printf(b, "\n");
1863 buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n"); 1865 buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
1864 buf_printf(b, "\n"); 1866 buf_printf(b, "\n");
1865 buf_printf(b, "struct module __this_module\n"); 1867 buf_printf(b, "struct module __this_module\n");
1866 buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n"); 1868 buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n");
1867 buf_printf(b, "\t.name = KBUILD_MODNAME,\n"); 1869 buf_printf(b, "\t.name = KBUILD_MODNAME,\n");
1868 if (mod->has_init) 1870 if (mod->has_init)
1869 buf_printf(b, "\t.init = init_module,\n"); 1871 buf_printf(b, "\t.init = init_module,\n");
1870 if (mod->has_cleanup) 1872 if (mod->has_cleanup)
1871 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n" 1873 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
1872 "\t.exit = cleanup_module,\n" 1874 "\t.exit = cleanup_module,\n"
1873 "#endif\n"); 1875 "#endif\n");
1874 buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n"); 1876 buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n");
1875 buf_printf(b, "};\n"); 1877 buf_printf(b, "};\n");
1876 } 1878 }
1877 1879
1878 static void add_intree_flag(struct buffer *b, int is_intree) 1880 static void add_intree_flag(struct buffer *b, int is_intree)
1879 { 1881 {
1880 if (is_intree) 1882 if (is_intree)
1881 buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n"); 1883 buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
1882 } 1884 }
1883 1885
1884 static void add_staging_flag(struct buffer *b, const char *name) 1886 static void add_staging_flag(struct buffer *b, const char *name)
1885 { 1887 {
1886 static const char *staging_dir = "drivers/staging"; 1888 static const char *staging_dir = "drivers/staging";
1887 1889
1888 if (strncmp(staging_dir, name, strlen(staging_dir)) == 0) 1890 if (strncmp(staging_dir, name, strlen(staging_dir)) == 0)
1889 buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n"); 1891 buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
1890 } 1892 }
1891 1893
1892 /** 1894 /**
1893 * Record CRCs for unresolved symbols 1895 * Record CRCs for unresolved symbols
1894 **/ 1896 **/
1895 static int add_versions(struct buffer *b, struct module *mod) 1897 static int add_versions(struct buffer *b, struct module *mod)
1896 { 1898 {
1897 struct symbol *s, *exp; 1899 struct symbol *s, *exp;
1898 int err = 0; 1900 int err = 0;
1899 1901
1900 for (s = mod->unres; s; s = s->next) { 1902 for (s = mod->unres; s; s = s->next) {
1901 exp = find_symbol(s->name); 1903 exp = find_symbol(s->name);
1902 if (!exp || exp->module == mod) { 1904 if (!exp || exp->module == mod) {
1903 if (have_vmlinux && !s->weak) { 1905 if (have_vmlinux && !s->weak) {
1904 if (warn_unresolved) { 1906 if (warn_unresolved) {
1905 warn("\"%s\" [%s.ko] undefined!\n", 1907 warn("\"%s\" [%s.ko] undefined!\n",
1906 s->name, mod->name); 1908 s->name, mod->name);
1907 } else { 1909 } else {
1908 merror("\"%s\" [%s.ko] undefined!\n", 1910 merror("\"%s\" [%s.ko] undefined!\n",
1909 s->name, mod->name); 1911 s->name, mod->name);
1910 err = 1; 1912 err = 1;
1911 } 1913 }
1912 } 1914 }
1913 continue; 1915 continue;
1914 } 1916 }
1915 s->module = exp->module; 1917 s->module = exp->module;
1916 s->crc_valid = exp->crc_valid; 1918 s->crc_valid = exp->crc_valid;
1917 s->crc = exp->crc; 1919 s->crc = exp->crc;
1918 } 1920 }
1919 1921
1920 if (!modversions) 1922 if (!modversions)
1921 return err; 1923 return err;
1922 1924
1923 buf_printf(b, "\n"); 1925 buf_printf(b, "\n");
1924 buf_printf(b, "static const struct modversion_info ____versions[]\n"); 1926 buf_printf(b, "static const struct modversion_info ____versions[]\n");
1925 buf_printf(b, "__used\n"); 1927 buf_printf(b, "__used\n");
1926 buf_printf(b, "__attribute__((section(\"__versions\"))) = {\n"); 1928 buf_printf(b, "__attribute__((section(\"__versions\"))) = {\n");
1927 1929
1928 for (s = mod->unres; s; s = s->next) { 1930 for (s = mod->unres; s; s = s->next) {
1929 if (!s->module) 1931 if (!s->module)
1930 continue; 1932 continue;
1931 if (!s->crc_valid) { 1933 if (!s->crc_valid) {
1932 warn("\"%s\" [%s.ko] has no CRC!\n", 1934 warn("\"%s\" [%s.ko] has no CRC!\n",
1933 s->name, mod->name); 1935 s->name, mod->name);
1934 continue; 1936 continue;
1935 } 1937 }
1936 buf_printf(b, "\t{ %#8x, \"%s\" },\n", s->crc, s->name); 1938 buf_printf(b, "\t{ %#8x, \"%s\" },\n", s->crc, s->name);
1937 } 1939 }
1938 1940
1939 buf_printf(b, "};\n"); 1941 buf_printf(b, "};\n");
1940 1942
1941 return err; 1943 return err;
1942 } 1944 }
1943 1945
1944 static void add_depends(struct buffer *b, struct module *mod, 1946 static void add_depends(struct buffer *b, struct module *mod,
1945 struct module *modules) 1947 struct module *modules)
1946 { 1948 {
1947 struct symbol *s; 1949 struct symbol *s;
1948 struct module *m; 1950 struct module *m;
1949 int first = 1; 1951 int first = 1;
1950 1952
1951 for (m = modules; m; m = m->next) 1953 for (m = modules; m; m = m->next)
1952 m->seen = is_vmlinux(m->name); 1954 m->seen = is_vmlinux(m->name);
1953 1955
1954 buf_printf(b, "\n"); 1956 buf_printf(b, "\n");
1955 buf_printf(b, "static const char __module_depends[]\n"); 1957 buf_printf(b, "static const char __module_depends[]\n");
1956 buf_printf(b, "__used\n"); 1958 buf_printf(b, "__used\n");
1957 buf_printf(b, "__attribute__((section(\".modinfo\"))) =\n"); 1959 buf_printf(b, "__attribute__((section(\".modinfo\"))) =\n");
1958 buf_printf(b, "\"depends="); 1960 buf_printf(b, "\"depends=");
1959 for (s = mod->unres; s; s = s->next) { 1961 for (s = mod->unres; s; s = s->next) {
1960 const char *p; 1962 const char *p;
1961 if (!s->module) 1963 if (!s->module)
1962 continue; 1964 continue;
1963 1965
1964 if (s->module->seen) 1966 if (s->module->seen)
1965 continue; 1967 continue;
1966 1968
1967 s->module->seen = 1; 1969 s->module->seen = 1;
1968 p = strrchr(s->module->name, '/'); 1970 p = strrchr(s->module->name, '/');
1969 if (p) 1971 if (p)
1970 p++; 1972 p++;
1971 else 1973 else
1972 p = s->module->name; 1974 p = s->module->name;
1973 buf_printf(b, "%s%s", first ? "" : ",", p); 1975 buf_printf(b, "%s%s", first ? "" : ",", p);
1974 first = 0; 1976 first = 0;
1975 } 1977 }
1976 buf_printf(b, "\";\n"); 1978 buf_printf(b, "\";\n");
1977 } 1979 }
1978 1980
1979 static void add_srcversion(struct buffer *b, struct module *mod) 1981 static void add_srcversion(struct buffer *b, struct module *mod)
1980 { 1982 {
1981 if (mod->srcversion[0]) { 1983 if (mod->srcversion[0]) {
1982 buf_printf(b, "\n"); 1984 buf_printf(b, "\n");
1983 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n", 1985 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
1984 mod->srcversion); 1986 mod->srcversion);
1985 } 1987 }
1986 } 1988 }
1987 1989
1988 static void write_if_changed(struct buffer *b, const char *fname) 1990 static void write_if_changed(struct buffer *b, const char *fname)
1989 { 1991 {
1990 char *tmp; 1992 char *tmp;
1991 FILE *file; 1993 FILE *file;
1992 struct stat st; 1994 struct stat st;
1993 1995
1994 file = fopen(fname, "r"); 1996 file = fopen(fname, "r");
1995 if (!file) 1997 if (!file)
1996 goto write; 1998 goto write;
1997 1999
1998 if (fstat(fileno(file), &st) < 0) 2000 if (fstat(fileno(file), &st) < 0)
1999 goto close_write; 2001 goto close_write;
2000 2002
2001 if (st.st_size != b->pos) 2003 if (st.st_size != b->pos)
2002 goto close_write; 2004 goto close_write;
2003 2005
2004 tmp = NOFAIL(malloc(b->pos)); 2006 tmp = NOFAIL(malloc(b->pos));
2005 if (fread(tmp, 1, b->pos, file) != b->pos) 2007 if (fread(tmp, 1, b->pos, file) != b->pos)
2006 goto free_write; 2008 goto free_write;
2007 2009
2008 if (memcmp(tmp, b->p, b->pos) != 0) 2010 if (memcmp(tmp, b->p, b->pos) != 0)
2009 goto free_write; 2011 goto free_write;
2010 2012
2011 free(tmp); 2013 free(tmp);
2012 fclose(file); 2014 fclose(file);
2013 return; 2015 return;
2014 2016
2015 free_write: 2017 free_write:
2016 free(tmp); 2018 free(tmp);
2017 close_write: 2019 close_write:
2018 fclose(file); 2020 fclose(file);
2019 write: 2021 write:
2020 file = fopen(fname, "w"); 2022 file = fopen(fname, "w");
2021 if (!file) { 2023 if (!file) {
2022 perror(fname); 2024 perror(fname);
2023 exit(1); 2025 exit(1);
2024 } 2026 }
2025 if (fwrite(b->p, 1, b->pos, file) != b->pos) { 2027 if (fwrite(b->p, 1, b->pos, file) != b->pos) {
2026 perror(fname); 2028 perror(fname);
2027 exit(1); 2029 exit(1);
2028 } 2030 }
2029 fclose(file); 2031 fclose(file);
2030 } 2032 }
2031 2033
2032 /* parse Module.symvers file. line format: 2034 /* parse Module.symvers file. line format:
2033 * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something] 2035 * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something]
2034 **/ 2036 **/
2035 static void read_dump(const char *fname, unsigned int kernel) 2037 static void read_dump(const char *fname, unsigned int kernel)
2036 { 2038 {
2037 unsigned long size, pos = 0; 2039 unsigned long size, pos = 0;
2038 void *file = grab_file(fname, &size); 2040 void *file = grab_file(fname, &size);
2039 char *line; 2041 char *line;
2040 2042
2041 if (!file) 2043 if (!file)
2042 /* No symbol versions, silently ignore */ 2044 /* No symbol versions, silently ignore */
2043 return; 2045 return;
2044 2046
2045 while ((line = get_next_line(&pos, file, size))) { 2047 while ((line = get_next_line(&pos, file, size))) {
2046 char *symname, *modname, *d, *export, *end; 2048 char *symname, *modname, *d, *export, *end;
2047 unsigned int crc; 2049 unsigned int crc;
2048 struct module *mod; 2050 struct module *mod;
2049 struct symbol *s; 2051 struct symbol *s;
2050 2052
2051 if (!(symname = strchr(line, '\t'))) 2053 if (!(symname = strchr(line, '\t')))
2052 goto fail; 2054 goto fail;
2053 *symname++ = '\0'; 2055 *symname++ = '\0';
2054 if (!(modname = strchr(symname, '\t'))) 2056 if (!(modname = strchr(symname, '\t')))
2055 goto fail; 2057 goto fail;
2056 *modname++ = '\0'; 2058 *modname++ = '\0';
2057 if ((export = strchr(modname, '\t')) != NULL) 2059 if ((export = strchr(modname, '\t')) != NULL)
2058 *export++ = '\0'; 2060 *export++ = '\0';
2059 if (export && ((end = strchr(export, '\t')) != NULL)) 2061 if (export && ((end = strchr(export, '\t')) != NULL))
2060 *end = '\0'; 2062 *end = '\0';
2061 crc = strtoul(line, &d, 16); 2063 crc = strtoul(line, &d, 16);
2062 if (*symname == '\0' || *modname == '\0' || *d != '\0') 2064 if (*symname == '\0' || *modname == '\0' || *d != '\0')
2063 goto fail; 2065 goto fail;
2064 mod = find_module(modname); 2066 mod = find_module(modname);
2065 if (!mod) { 2067 if (!mod) {
2066 if (is_vmlinux(modname)) 2068 if (is_vmlinux(modname))
2067 have_vmlinux = 1; 2069 have_vmlinux = 1;
2068 mod = new_module(modname); 2070 mod = new_module(modname);
2069 mod->skip = 1; 2071 mod->skip = 1;
2070 } 2072 }
2071 s = sym_add_exported(symname, mod, export_no(export)); 2073 s = sym_add_exported(symname, mod, export_no(export));
2072 s->kernel = kernel; 2074 s->kernel = kernel;
2073 s->preloaded = 1; 2075 s->preloaded = 1;
2074 sym_update_crc(symname, mod, crc, export_no(export)); 2076 sym_update_crc(symname, mod, crc, export_no(export));
2075 } 2077 }
2076 return; 2078 return;
2077 fail: 2079 fail:
2078 fatal("parse error in symbol dump file\n"); 2080 fatal("parse error in symbol dump file\n");
2079 } 2081 }
2080 2082
2081 /* For normal builds always dump all symbols. 2083 /* For normal builds always dump all symbols.
2082 * For external modules only dump symbols 2084 * For external modules only dump symbols
2083 * that are not read from kernel Module.symvers. 2085 * that are not read from kernel Module.symvers.
2084 **/ 2086 **/
2085 static int dump_sym(struct symbol *sym) 2087 static int dump_sym(struct symbol *sym)
2086 { 2088 {
2087 if (!external_module) 2089 if (!external_module)
2088 return 1; 2090 return 1;
2089 if (sym->vmlinux || sym->kernel) 2091 if (sym->vmlinux || sym->kernel)
2090 return 0; 2092 return 0;
2091 return 1; 2093 return 1;
2092 } 2094 }
2093 2095
2094 static void write_dump(const char *fname) 2096 static void write_dump(const char *fname)
2095 { 2097 {
2096 struct buffer buf = { }; 2098 struct buffer buf = { };
2097 struct symbol *symbol; 2099 struct symbol *symbol;
2098 int n; 2100 int n;
2099 2101
2100 for (n = 0; n < SYMBOL_HASH_SIZE ; n++) { 2102 for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
2101 symbol = symbolhash[n]; 2103 symbol = symbolhash[n];
2102 while (symbol) { 2104 while (symbol) {
2103 if (dump_sym(symbol)) 2105 if (dump_sym(symbol))
2104 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\n", 2106 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\n",
2105 symbol->crc, symbol->name, 2107 symbol->crc, symbol->name,
2106 symbol->module->name, 2108 symbol->module->name,
2107 export_str(symbol->export)); 2109 export_str(symbol->export));
2108 symbol = symbol->next; 2110 symbol = symbol->next;
2109 } 2111 }
2110 } 2112 }
2111 write_if_changed(&buf, fname); 2113 write_if_changed(&buf, fname);
2112 } 2114 }
2113 2115
2114 struct ext_sym_list { 2116 struct ext_sym_list {
2115 struct ext_sym_list *next; 2117 struct ext_sym_list *next;
2116 const char *file; 2118 const char *file;
2117 }; 2119 };
2118 2120
2119 int main(int argc, char **argv) 2121 int main(int argc, char **argv)
2120 { 2122 {
2121 struct module *mod; 2123 struct module *mod;
2122 struct buffer buf = { }; 2124 struct buffer buf = { };
2123 char *kernel_read = NULL, *module_read = NULL; 2125 char *kernel_read = NULL, *module_read = NULL;
2124 char *dump_write = NULL; 2126 char *dump_write = NULL;
2125 int opt; 2127 int opt;
2126 int err; 2128 int err;
2127 struct ext_sym_list *extsym_iter; 2129 struct ext_sym_list *extsym_iter;
2128 struct ext_sym_list *extsym_start = NULL; 2130 struct ext_sym_list *extsym_start = NULL;
2129 2131
2130 while ((opt = getopt(argc, argv, "i:I:e:cmsSo:awM:K:")) != -1) { 2132 while ((opt = getopt(argc, argv, "i:I:e:cmsSo:awM:K:")) != -1) {
2131 switch (opt) { 2133 switch (opt) {
2132 case 'i': 2134 case 'i':
2133 kernel_read = optarg; 2135 kernel_read = optarg;
2134 break; 2136 break;
2135 case 'I': 2137 case 'I':
2136 module_read = optarg; 2138 module_read = optarg;
2137 external_module = 1; 2139 external_module = 1;
2138 break; 2140 break;
2139 case 'c': 2141 case 'c':
2140 cross_build = 1; 2142 cross_build = 1;
2141 break; 2143 break;
2142 case 'e': 2144 case 'e':
2143 external_module = 1; 2145 external_module = 1;
2144 extsym_iter = 2146 extsym_iter =
2145 NOFAIL(malloc(sizeof(*extsym_iter))); 2147 NOFAIL(malloc(sizeof(*extsym_iter)));
2146 extsym_iter->next = extsym_start; 2148 extsym_iter->next = extsym_start;
2147 extsym_iter->file = optarg; 2149 extsym_iter->file = optarg;
2148 extsym_start = extsym_iter; 2150 extsym_start = extsym_iter;
2149 break; 2151 break;
2150 case 'm': 2152 case 'm':
2151 modversions = 1; 2153 modversions = 1;
2152 break; 2154 break;
2153 case 'o': 2155 case 'o':
2154 dump_write = optarg; 2156 dump_write = optarg;
2155 break; 2157 break;
2156 case 'a': 2158 case 'a':
2157 all_versions = 1; 2159 all_versions = 1;
2158 break; 2160 break;
2159 case 's': 2161 case 's':
2160 vmlinux_section_warnings = 0; 2162 vmlinux_section_warnings = 0;
2161 break; 2163 break;
2162 case 'S': 2164 case 'S':
2163 sec_mismatch_verbose = 0; 2165 sec_mismatch_verbose = 0;
2164 break; 2166 break;
2165 case 'w': 2167 case 'w':
2166 warn_unresolved = 1; 2168 warn_unresolved = 1;
2167 break; 2169 break;
2168 default: 2170 default:
2169 exit(1); 2171 exit(1);
2170 } 2172 }
2171 } 2173 }
2172 2174
2173 if (kernel_read) 2175 if (kernel_read)
2174 read_dump(kernel_read, 1); 2176 read_dump(kernel_read, 1);
2175 if (module_read) 2177 if (module_read)
2176 read_dump(module_read, 0); 2178 read_dump(module_read, 0);
2177 while (extsym_start) { 2179 while (extsym_start) {
2178 read_dump(extsym_start->file, 0); 2180 read_dump(extsym_start->file, 0);
2179 extsym_iter = extsym_start->next; 2181 extsym_iter = extsym_start->next;
2180 free(extsym_start); 2182 free(extsym_start);
2181 extsym_start = extsym_iter; 2183 extsym_start = extsym_iter;
2182 } 2184 }
2183 2185
2184 while (optind < argc) 2186 while (optind < argc)
2185 read_symbols(argv[optind++]); 2187 read_symbols(argv[optind++]);
2186 2188
2187 for (mod = modules; mod; mod = mod->next) { 2189 for (mod = modules; mod; mod = mod->next) {
2188 if (mod->skip) 2190 if (mod->skip)
2189 continue; 2191 continue;
2190 check_exports(mod); 2192 check_exports(mod);
2191 } 2193 }
2192 2194
2193 err = 0; 2195 err = 0;
2194 2196
2195 for (mod = modules; mod; mod = mod->next) { 2197 for (mod = modules; mod; mod = mod->next) {
2196 char fname[strlen(mod->name) + 10]; 2198 char fname[strlen(mod->name) + 10];
2197 2199
2198 if (mod->skip) 2200 if (mod->skip)
2199 continue; 2201 continue;
2200 2202
2201 buf.pos = 0; 2203 buf.pos = 0;
2202 2204
2203 add_header(&buf, mod); 2205 add_header(&buf, mod);
2204 add_intree_flag(&buf, !external_module); 2206 add_intree_flag(&buf, !external_module);
2205 add_staging_flag(&buf, mod->name); 2207 add_staging_flag(&buf, mod->name);
2206 err |= add_versions(&buf, mod); 2208 err |= add_versions(&buf, mod);
2207 add_depends(&buf, mod, modules); 2209 add_depends(&buf, mod, modules);
2208 add_moddevtable(&buf, mod); 2210 add_moddevtable(&buf, mod);
2209 add_srcversion(&buf, mod); 2211 add_srcversion(&buf, mod);
2210 2212
2211 sprintf(fname, "%s.mod.c", mod->name); 2213 sprintf(fname, "%s.mod.c", mod->name);
2212 write_if_changed(&buf, fname); 2214 write_if_changed(&buf, fname);
2213 } 2215 }
2214 2216
2215 if (dump_write) 2217 if (dump_write)
2216 write_dump(dump_write); 2218 write_dump(dump_write);
2217 if (sec_mismatch_count && !sec_mismatch_verbose) 2219 if (sec_mismatch_count && !sec_mismatch_verbose)
2218 warn("modpost: Found %d section mismatch(es).\n" 2220 warn("modpost: Found %d section mismatch(es).\n"
2219 "To see full details build your kernel with:\n" 2221 "To see full details build your kernel with:\n"
2220 "'make CONFIG_DEBUG_SECTION_MISMATCH=y'\n", 2222 "'make CONFIG_DEBUG_SECTION_MISMATCH=y'\n",
2221 sec_mismatch_count); 2223 sec_mismatch_count);
2222 2224
2223 return err; 2225 return err;
2224 } 2226 }
2225 2227