modpost.c 52 KB

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