Eric Lee / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 8d99513c1b76cfd0b2dcf061c5136cb1061e6b37

Authored by Michal Marek
Committed by Rusty Russell
1 parent d4703aefdb
Exists in master and in 39 other branches 8mp-imx_5.4.70_2.3.0, 8qm-imx_5.4.70_2.3.0, emb_imx_lf-5.15.y, emb_lf-6.1.y, imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, imx_4.1.15_1.0.0_ga, pitx_8mp_lf-5.10.y, rt-smarc-imx_4.1.15_1.0.0_ga, rt_linux_5.15.71, smarc-8m-android-11.0.0_2.0.0, smarc-imx6_4.14.98_2.0.0_ga, smarc-imx6_4.9.88_2.0.0_ga, smarc-imx7_4.14.98_2.0.0_ga, smarc-imx7_4.9.11_1.0.0_ga, smarc-imx7_4.9.88_2.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-imx_4.1.15_1.0.0_ga, smarc-imx_4.9.11_1.0.0_ga, smarc-imx_4.9.51_imx8m_ga, smarc-imx_4.9.88_2.0.0_ga, smarc-m6.0.1_2.1.0-ga, smarc-n7.1.2_2.0.0-ga, smarc-rel_imx_4.1.15_1.2.0_ga, smarc_8m_00d0_imx_4.14.98_2.0.0_ga, smarc_8m_imx_4.14.78_1.0.0_ga, smarc_8m_imx_4.14.98_2.0.0_ga, smarc_8m_imx_4.19.35_1.1.0, smarc_8mm_imx_4.14.78_1.0.0_ga, smarc_8mm_imx_4.14.98_2.0.0_ga, smarc_8mm_imx_4.19.35_1.1.0, smarc_8mm_imx_5.4.24_2.1.0, smarc_8mp_lf-5.10.y, smarc_8mq_imx_5.4.24_2.1.0, smarc_8mq_lf-5.10.y, smarc_imx_lf-5.15.y

modpost: fix segfault with short symbol names 

memcmp() is wrong here, the symbol name can be shorter than KSYMTAB_PFX
or CRC_PFX.

Signed-off-by: Michal Marek <mmarek@suse.cz>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>

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

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