开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 驱动编程 > 查看源码
ksymoops.c
资源名称：ksymoops-2.4.9.tar.gz　[点击查看]
上传用户：hxtd_72
上传日期：2007-06-06
资源大小：64k
文件大小：20k
源码类别：

驱动编程

开发平台：

C/C++

ksymoops.c：源码内容
  1. /*
  2.     ksymoops.c.
  4.     Read a Linux kernel Oops file and make the best stab at converting
  5.     the code to instructions and mapping stack values to kernel
  6.     symbols.
  8.     Copyright 1999 Keith Owens <kaos@ocs.com.au>.
  9.     Released under the GNU Public Licence, Version 2.
  10. */
  12. #define VERSION "2.4.9"
  14. #include "ksymoops.h"
  15. #include <ctype.h>
  16. #include <errno.h>
  17. #include <getopt.h>
  18. #include <malloc.h>
  19. #include <stdlib.h>
  20. #include <string.h>
  21. #include <unistd.h>
  22. #include <sys/utsname.h>
  23. #include <endian.h>
  25. char *prefix;
  26. char *path_nm = INSTALL_PREFIX"/bin/"CROSS"nm";          /* env KSYMOOPS_NM */
  27. char *path_find = "/usr/bin/find";      /* env KSYMOOPS_FIND */
  28. char *path_objdump = INSTALL_PREFIX"/bin/"CROSS"objdump";    /* env KSYMOOPS_OBJDUMP */
  29. int debug = 0;
  30. int errors = 0;
  31. int warnings = 0;
  32. addr_t truncate_mask = ~(addr_t)0;
  34. SYMBOL_SET   ss_vmlinux;
  35. SYMBOL_SET   ss_ksyms_base;
  36. SYMBOL_SET **ss_ksyms_module;
  37. int          ss_ksyms_modules;
  38. int          ss_ksyms_modules_known_objects;
  39. SYMBOL_SET   ss_lsmod;
  40. SYMBOL_SET **ss_object;
  41. int          ss_objects;
  42. SYMBOL_SET   ss_system_map;
  44. SYMBOL_SET   ss_merged;   /* merged map with info from all sources */
  45. SYMBOL_SET   ss_Version;  /* Version_ numbers where available */
  47. /* Regular expression stuff */
  49. regex_t     re_nm;
  50. regmatch_t *re_nm_pmatch;
  51. regex_t     re_bracketed_address;
  52. regmatch_t *re_bracketed_address_pmatch;
  53. regex_t     re_revbracketed_address;
  54. regmatch_t *re_revbracketed_address_pmatch;
  55. regex_t     re_unbracketed_address;
  56. regmatch_t *re_unbracketed_address_pmatch;
  58. static void usage(void)
  59. {
  60.     static const char usage_text[] =
  61.    "t[-v vmlinux] [--vmlinux=vmlinux]ntttttWhere to read vmlinuxn"
  62.    "t[-V] [--no-vmlinux]ttNo vmlinux is availablen"
  63.    "t[-k ksyms] [--ksyms=ksyms]tWhere to read ksymsn"
  64.    "t[-K] [--no-ksyms]ttNo ksyms is availablen"
  65.    "t[-l lsmod] [--lsmod=lsmod]tWhere to read lsmodn"
  66.    "t[-L] [--no-lsmod]ttNo lsmod is availablen"
  67.    "t[-o object] [--object=object]tDirectory containing modules or anntttttindividual object namen"
  68.    "t[-O] [--no-object]ttNo objects are availablen"
  69.    "t[-m system.map] [--system-map=system.map]ntttttWhere to read System.mapn"
  70.    "t[-M] [--no-system-map]ttNo System.map is availablen"
  71.    "t[-s save.map] [--save-map=save.map]ntttttSave consolidated mapn"
  72.    "t[-S] [--short-lines]ttShort or long lines togglen"
  73.    "t[-e] [--endian-swap]ttToggle endianess of code bytesn"
  74.    "t[-x] [--hex]tttHex or decimal togglen"
  75.    "t[-1] [--one-shot]ttOne shot toggle (exit after first Oops)n"
  76.    "t[-i] [--ignore-insmod-path]tIgnore path from __insmod symbols, togglen"
  77.    "t[-I] [--ignore-insmod-all]tIgnore all __insmod symbols, togglen"
  78.    "t[-d] [--debug]tttIncrease debug level by 1n"
  79.    "t[-h] [--help]tttPrint help textn"
  80.    "t[-t target] [--target=target]tTarget of oops logn"
  81.    "t[-a architecture] [--architecture=architecture]ntttttArchitecture of oops logn"
  82.    "t[-A "address list"] [--addresses="address list"]ntttttAdhoc addresses to decoden"
  83.    "t< Oops.filetttOops report to decoden"
  84.    "n"
  85.    "ttAll flags can occur more than once.  With the exception "
  86. "of -o,n"
  87.    "tt-d and -A which are cumulative, the last occurrence of each "
  88. "flag isn"
  89.    "ttused.  Note that "-v my.vmlinux -V" will be taken as "
  90. ""No vmlinuxn"
  91.    "ttavailable" but "-V -v my.vmlinux" will read "
  92. "my.vmlinux.  Youn"
  93.    "ttwill be warned about such combinations.n"
  94.    "n"
  95.    "ttEach occurrence of -d increases the debug level.n"
  96.    "n"
  97.    "ttEach -o flag can refer to a directory or to a single "
  98. "objectn"
  99.    "ttfile.  If a directory is specified then all *.o files in "
  100. "thatn"
  101.    "ttdirectory and its subdirectories are assumed to be "
  102. "modules.n"
  103.    "n"
  104.    "ttIf any of the vmlinux, object, ksyms or system.map "
  105. "optionsn"
  106.    "ttcontain the string *r (*m, *n, *s) then it is replaced "
  107. "at runn"
  108.    "tttime by the current value of `uname -r` (-m, -n, -s).n"
  109.    "n"
  110.    "ttThe defaults can be changed in the Makefile, current "
  111. "defaultsn"
  112.    "ttarenn"
  113.    "ttt"
  114. #ifdef DEF_VMLINUX
  115.    "-v " DEF_VMLINUX
  116. #else
  117.    "-V"
  118. #endif
  119.    "n"
  120.    "ttt"
  121. #ifdef DEF_KSYMS
  122.    "-k " DEF_KSYMS
  123. #else
  124.    "-K"
  125. #endif
  126.    "n"
  127.    "ttt"
  128. #ifdef DEF_LSMOD
  129.    "-l " DEF_LSMOD
  130. #else
  131.    "-L"
  132. #endif
  133.    "n"
  134.    "ttt"
  135. #ifdef DEF_OBJECTS
  136.    "-o " DEF_OBJECTS
  137. #else
  138.    "-O"
  139. #endif
  140.    "n"
  141.    "ttt"
  142. #ifdef DEF_MAP
  143.    "-m " DEF_MAP
  144. #else
  145.    "-M"
  146. #endif
  147.    "n"
  148. #ifdef DEF_TARGET
  149.    "ttt"
  150.    "-t " DEF_TARGET
  151.    "n"
  152. #endif
  153. #ifdef DEF_ARCH
  154.    "ttt"
  155.    "-a " DEF_ARCH
  156.    "n"
  157. #endif
  158.    "n"
  159.   ;
  160.     printf("Version " VERSION "n");
  161.     printf("usage: %sn", prefix);
  162.     printf("%s", usage_text);
  163. }
  165. /* Check if possibly conflicting options were specified */
  166. static void multi_opt(int specl, int specu, char type, const char *using)
  167. {
  168.     static char procname[] = "multi_opt";
  169.     if (specl && specu) {
  170. WARNING_S("you specified both -%c and -%c.  Using '",
  171.     type, toupper(type));
  172. if (using) {
  173.     WARNING_M("-%c %s", type, using);
  174.     if (type == 'o')
  175. WARNING_M("%s", " ...");
  176.     WARNING_E("%s", "'");
  177. }
  178. else
  179.     WARNING_E("-%c'", toupper(type));
  180.     }
  181.     else if (specl > 1 && type != 'o') {
  182. WARNING("you specified -%c more than once.  Using '-%c %s'",
  183.     type, type, using);
  184.     }
  185.     else if (specu > 1) {
  186. WARNING("you specified -%c more than once.  "
  187.     "Second and subsequent '-%c' ignored",
  188.     toupper(type), toupper(type));
  189.     }
  190. }
  192. /* If a name contains *r (*m, *n, *s), replace with the current value of
  193.  * `uname -r` (-m, -n, -s).  Actually uses uname system call rather than the
  194.  * uname command but the result is the same.
  195.  */
  196. static void convert_uname(char **name)
  197. {
  198.     char *p, *newname, *oldname, *replacement;
  199.     unsigned len;
  200.     int free_oldname = 0;
  201.     static char procname[] = "convert_uname";
  203.     if (!*name)
  204. return;
  206.     while ((p = strchr(*name, '*'))) {
  207. struct utsname buf;
  208. int i = uname(&buf);
  209. DEBUG(1, "%s in", *name);
  210. if (i) {
  211.     ERROR("uname failed, %s will not be processed", *name);
  212.     perror(prefix);
  213.     return;
  214. }
  215. switch (*(p+1)) {
  216. case 'r':
  217.     replacement = buf.release;
  218.     break;
  219. case 'm':
  220.     replacement = buf.machine;
  221.     break;
  222. case 'n':
  223.     replacement = buf.nodename;
  224.     break;
  225. case 's':
  226.     replacement = buf.sysname;
  227.     break;
  228. default:
  229.     ERROR("invalid replacement character '*%c' in %s", *(p+1), *name);
  230.     return;
  231. }
  232. len = strlen(*name)-2+strlen(replacement)+1;
  233. if (!(newname = malloc(len)))
  234.     malloc_error(procname);
  235. strncpy(newname, *name, (p-*name));
  236. strcpy(newname+(p-*name), replacement);
  237. strcpy(newname+(p-*name)+strlen(replacement), p+2);
  238. p = newname+(p-*name)+strlen(replacement);  /* no rescan */
  239. oldname = *name;
  240. *name = newname;
  241. if (free_oldname)
  242.     free(oldname);
  243. free_oldname = 1;
  244. DEBUG(1, "%s out", *name);
  245.     }
  246.     return;
  247. }
  249. /* Report if the option was specified or defaulted */
  250. static void spec_or_default(int spec, int *some_spec) {
  251.     if (spec) {
  252. printf(" (specified)n");
  253. if (some_spec)
  254.     *some_spec = 1;
  255.     }
  256.     else
  257. printf(" (default)n");
  258. }
  260. /* Extract adhoc addresses from a string and save for later.
  261.  * An address is a string of at least 4 hex digits delimited by white space or
  262.  * punctuation marks, possibly prefixed by 0x or 0X.
  263.  */
  264. static void adhoc_addresses(struct options *options, const unsigned char *string)
  265. {
  266.     int count, start;
  267.     const unsigned char *p = string, *p1;
  268.     char *address;
  269.     while (*p) {
  270. while (*p && !isxdigit(*p))
  271.     ++p;
  272. if (!*p)
  273.     continue;
  274. start = p == string || isspace(*(p-1)) || ispunct(*(p-1));
  275. if (!start && p >= string+2 && *(p-2) == '0' && (*(p-1) == 'x' || *(p-1) == 'X')) {
  276.     start = p == string+2 || isspace(*(p-3)) || ispunct(*(p-3));
  277. }
  278. if (!start) {
  279.     ++p;
  280.     continue;
  281. }
  282. p1 = p;
  283. while (isxdigit(*++p)) {};
  284. if (p-p1 < 4)
  285.     continue;
  286. address = malloc(p-p1+1);
  287. if (!address)
  288.     malloc_error("adhoc_addresses");
  289. memcpy(address, p1, p-p1);
  290. address[p-p1] = '';
  291. for (count = 0; options->adhoc_addresses && options->adhoc_addresses[count]; ++count) {};
  292. options->adhoc_addresses = realloc(options->adhoc_addresses, (count+2)*sizeof(options->adhoc_addresses));
  293. if (!options->adhoc_addresses)
  294.     malloc_error("adhoc_addresses");
  295. options->adhoc_addresses[count] = address;
  296. options->adhoc_addresses[count+1] = NULL;
  297.     }
  298. }
  300. /* Parse the options.  Verbose but what's new with getopt? */
  301. static void parse(int argc, char **argv, struct options *options, int *spec_h)
  302. {
  303.     int spec_v = 0, spec_V = 0,
  304. spec_o = 0, spec_O = 0,
  305. spec_k = 0, spec_K = 0,
  306. spec_l = 0, spec_L = 0,
  307. spec_m = 0, spec_M = 0,
  308. spec_s = 0;
  309.     struct utsname buf;
  310.     static char const procname[] = "parse";
  311.     struct option long_opts[] = {
  312. {"vmlinux", 1, 0, 'v'},
  313. {"no-vmlinux", 0, 0, 'V'},
  314. {"ksyms", 1, 0, 'k'},
  315. {"no-ksyms", 0, 0, 'K'},
  316. {"lsmod", 1, 0, 'l'},
  317. {"no-lsmod", 0, 0, 'L'},
  318. {"object", 1, 0, 'o'},
  319. {"no-object", 0, 0, 'O'},
  320. {"system-map", 1, 0, 'm'},
  321. {"no-system-map", 0, 0, 'M'},
  322. {"save-map", 1, 0, 's'},
  323. {"short-lines", 0, 0, 'S'},
  324. {"endian-swap", 0, 0, 'e'},
  325. {"hex", 0, 0, 'x'},
  326. {"one-shot", 0, 0, '1'},
  327. {"ignore-insmod-path", 0, 0, 'i'},
  328. {"ignore-insmod-all", 0, 0, 'I'},
  329. {"truncate", 1, 0, 'T'},
  330. {"debug", 0, 0, 'd'},
  331. {"help", 0, 0, 'h'},
  332. {"target", 1, 0, 't'},
  333. {"architecture", 1, 0, 'a'},
  334. {"addresses", 1, 0, 'A'},
  335. {0, 0, 0, 0}
  336.     };
  338.     int c, i, some_spec = 0;
  339.     char *p, *before;
  341.     while ((c = getopt_long(argc, argv, "v:Vk:Kl:Lo:Om:Ms:e1xSiIT:hdt:a:A:",
  342.     long_opts, NULL)) != EOF) {
  343. if (c != 'd')
  344.     DEBUG(1, "'%c' '%s'", c, optarg);
  345. switch(c) {
  346. case 'v':
  347.     options->vmlinux = optarg;
  348.     ++spec_v;
  349.     break;
  350. case 'V':
  351.     options->vmlinux = NULL;
  352.     ++spec_V;
  353.     break;
  354. case 'k':
  355.     options->ksyms = optarg;
  356.     ++spec_k;
  357.     break;
  358. case 'K':
  359.     options->ksyms = NULL;
  360.     ++spec_K;
  361.     break;
  362. case 'l':
  363.     options->lsmod = optarg;
  364.     ++spec_l;
  365.     break;
  366. case 'L':
  367.     options->lsmod = NULL;
  368.     ++spec_L;
  369.     break;
  370. case 'o':
  371.     if (!spec_o) {
  372. /* First -o, discard default value(s) */
  373. for (i = 0; i < options->objects; ++i)
  374.     free((options->object)[i]);
  375. free(options->object);
  376. options->object = NULL;
  377. options->objects = 0;
  378.     }
  379.     options->object = realloc(options->object,
  380. ((options->objects)+1)*sizeof(*(options->object)));
  381.     if (!options->object)
  382. malloc_error("object");
  383.     if (!(p = strdup(optarg)))
  384. malloc_error("strdup -o");
  385.     else {
  386. (options->object)[(options->objects)++] = p;
  387. ++spec_o;
  388.     }
  389.     break;
  390. case 'O':
  391.     ++spec_O;
  392.     for (i = 0; i < options->objects; ++i)
  393. free((options->object)[i]);
  394.     free(options->object);
  395.     options->object = NULL;
  396.     options->objects = 0;
  397.     break;
  398. case 'm':
  399.     options->system_map = optarg;
  400.     ++spec_m;
  401.     break;
  402. case 'M':
  403.     options->system_map = NULL;
  404.     ++spec_M;
  405.     break;
  406. case 's':
  407.     options->save_system_map = optarg;
  408.     ++spec_s;
  409.     break;
  410. case 'e':
  411.     options->endianess = !options->endianess;
  412.     break;
  413. case '1':
  414.     options->one_shot = !options->one_shot;
  415.     break;
  416. case 'x':
  417.     options->hex = !options->hex;
  418.     break;
  419. case 'S':
  420.     options->short_lines = !options->short_lines;
  421.     break;
  422. case 'i':
  423.     options->ignore_insmod_path = !options->ignore_insmod_path;
  424.     break;
  425. case 'I':
  426.     options->ignore_insmod_all = !options->ignore_insmod_all;
  427.     break;
  428. case 'T':
  429.     options->truncate = atoi(optarg);
  430.     if (options->truncate >= 8*sizeof(addr_t) || options->truncate <= 0) {
  431. options->truncate = 0;
  432. truncate_mask = ~(addr_t)0;
  433.     }
  434.     else {
  435. truncate_mask = (~(addr_t)0) >> (8*sizeof(addr_t)-options->truncate);
  436.     }
  437.     break;
  438. case 'h':
  439.     usage();
  440.     ++*spec_h;
  441.     break;
  442. case 'd':
  443.     ++debug;
  444.     break;
  445. case 't':
  446.     options->target = optarg;
  447.     break;
  448. case 'a':
  449.     options->architecture = optarg;
  450.     break;
  451. case 'A':
  452.     adhoc_addresses(options, optarg);
  453.     break;
  454. case '?':
  455.     if (c == 'c')
  456. printf("Option -c is obsolete, use -e toggle insteadn");
  457.     usage();
  458.     exit(2);
  459. }
  460.     }
  462.     options->filecount = argc - optind;
  463.     options->filename = argv + optind;
  465.     if (options->adhoc_addresses && !options->filecount) {
  466. static char *null = "/dev/null";
  467. static char **null_list = { &null };
  468. options->filecount = 1;
  469. options->filename = null_list;
  470.     }
  472.     /* Expand any requests for the current uname values */
  473.     convert_uname(&options->vmlinux);
  474.     if (options->objects) {
  475. for (i = 0; i < options->objects; ++i)
  476.     convert_uname(options->object+i);
  477.     }
  478.     convert_uname(&options->ksyms);
  479.     convert_uname(&options->lsmod);
  480.     convert_uname(&options->system_map);
  482.     /* Check for multiple options specified */
  483.     multi_opt(spec_v, spec_V, 'v', options->vmlinux);
  484.     multi_opt(spec_o, spec_O, 'o', options->object ? *options->object : NULL);
  485.     multi_opt(spec_k, spec_K, 'k', options->ksyms);
  486.     multi_opt(spec_l, spec_L, 'l', options->lsmod);
  487.     multi_opt(spec_m, spec_M, 'm', options->system_map);
  489.     printf("ksymoops %s", VERSION);
  490.     if (uname(&buf) == 0)
  491. printf(" on %s %s", buf.machine, buf.release);
  492.     printf(".  Options usedn");
  493.     printf("    ");
  494.     if (options->vmlinux)
  495. printf(" -v %s", options->vmlinux);
  496.     else
  497. printf(" -V");
  498.     spec_or_default(spec_v || spec_V, &some_spec);
  500.     printf("    ");
  501.     if (options->ksyms)
  502. printf(" -k %s", options->ksyms);
  503.     else
  504. printf(" -K");
  505.     spec_or_default(spec_k || spec_K, &some_spec);
  507.     printf("    ");
  508.     if (options->lsmod)
  509. printf(" -l %s", options->lsmod);
  510.     else
  511. printf(" -L");
  512.     spec_or_default(spec_l || spec_L, &some_spec);
  514.     printf("    ");
  515.     if (options->objects) {
  516. for (i = 0; i < options->objects; ++i)
  517.     printf(" -o %s", (options->object)[i]);
  518.     }
  519.     else
  520. printf(" -O");
  521.     spec_or_default(spec_o || spec_O, &some_spec);
  523.     printf("    ");
  524.     if (options->system_map)
  525. printf(" -m %s", options->system_map);
  526.     else
  527. printf(" -M");
  528.     spec_or_default(spec_m || spec_M, &some_spec);
  530.     /* Toggles on one line */
  531.     before = "    ";
  532.     if (!options->short_lines) {
  533. printf("%s -S", before);
  534. before = "";
  535.     }
  536.     if (options->endianess) {
  537. printf("%s -e", before);
  538. before = "";
  539.     }
  540.     if (!options->hex) {
  541. printf("%s -x", before);
  542. before = "";
  543.     }
  544.     if (options->one_shot) {
  545. printf("%s -1", before);
  546. before = "";
  547.     }
  548.     if (options->ignore_insmod_path) {
  549. printf("%s -i", before);
  550. before = "";
  551.     }
  552.     if (options->ignore_insmod_all) {
  553. printf("%s -I", before);
  554. before = "";
  555.     }
  556.     if (!*before)
  557. printf("n");
  559.     before = "    ";
  560.     if (options->truncate) {
  561. printf("%s -T %d", before, options->truncate);
  562. before = "";
  563.     }
  564.     if (!*before)
  565. printf("n");
  567.     /* Target and architecture on one line */
  568.     before = "    ";
  569.     if (options->target) {
  570. printf("%s -t %s", before, options->target);
  571. before = "";
  572.     }
  573.     if (options->architecture) {
  574. printf("%s -a %s", before, options->architecture);
  575. before = "";
  576.     }
  577.     if (!*before)
  578. printf("n");
  580.     printf("n");
  582.     if (!some_spec) {
  583. /* special warning, no procname */
  584. ++warnings;
  585. WARNING_E("%s",
  586. "Warning: You did not tell me where to find symbol information.  I willn"
  587. "assume that the log matches the kernel and modules that are runningn"
  588. "right now and I'll use the default options above for symbol resolution.n"
  589. "If the current kernel and/or modules do not match the log, you can getn"
  590. "more accurate output by telling me the kernel version and where to findn"
  591. "map, modules, ksyms etc.  ksymoops -h explains the options.n"
  592.     );
  593.     }
  594. }
  596. /* Read environment variables */
  597. static void read_env(const char *external, char **internal)
  598. {
  599.     char *p;
  600.     static char const procname[] = "read_env";
  601.     if ((p = getenv(external))) {
  602. *internal = p;
  603. DEBUG(1, "override %s=%s", external, *internal);
  604.     }
  605.     else
  606. DEBUG(1, "default %s=%s", external, *internal);
  607. }
  609. /* Print the available target and architectures. */
  610. static void print_available_ta(const struct options *options)
  611. {
  612.     const char **list, **one;
  613.     if (options->target && strcmp(options->target, "?") == 0) {
  614. printf("Targets supported by your libbfdn");
  615. list = one = bfd_target_list();
  616. if (!list || !*list)
  617.     printf("    None, oh dearn");
  618. else while (*one)
  619.     printf("    %sn", *one++);
  620. free(list);
  621.     }
  622.     if (options->architecture && strcmp(options->architecture, "?") == 0) {
  623. printf("Architectures supported by your libbfdn");
  624. list = one = bfd_arch_list();
  625. if (!list || !*list)
  626.     printf("    None, oh dearn");
  627. else while (*one)
  628.     printf("    %sn", *one++);
  629. free(list);
  630.     }
  631.     printf(
  632. "Note that the above list comes from libbfd.  I have to assume that yourn"
  633. "other binutils libraries (libiberty, libopcodes) and binutils programsn"
  634. "(nm and objdump) are in sync with libbfd.n"
  635.     );
  636. }
  638. /* Do all the hard work of reading the symbol sources */
  639. void read_symbol_sources(const OPTIONS *options)
  640. {
  641.     int i;
  643.     read_vmlinux(options);
  644.     read_ksyms(options);
  645.     /* No point in reading modules unless ksyms shows modules loaded */
  646.     if (ss_ksyms_modules) {
  647. expand_objects(options);
  648. for (i = 0; i < ss_objects; ++i)
  649.     read_object(ss_object[i]->source, i);
  650.     }
  651.     else if (options->objects)
  652. printf("No modules in ksyms, skipping objectsn");
  653.     /* No point in reading lsmod without ksyms */
  654.     if (ss_ksyms_modules || ss_ksyms_base.used)
  655. read_lsmod(options);
  656.     else if (options->lsmod)
  657. printf("No ksyms, skipping lsmodn");
  658.     read_system_map(options);
  659.     merge_maps(options);
  660. }
  662. int main(int argc, char **argv)
  663. {
  664.     int spec_h = 0;     /* -h was specified */
  665.     int ret;
  666.     struct options options = {
  667. NULL,   /* vmlinux */
  668. NULL,   /* object */
  669. 0, /* objects */
  670. NULL,   /* ksyms */
  671. NULL,   /* lsmod */
  672. NULL,   /* system_map */
  673. NULL,   /* save_system_map */
  674. NULL,   /* filename */
  675. 0, /* filecount */
  676. 1, /* short_lines */
  677. 0, /* endianess */
  678. 1, /* hex */
  679. 0, /* one_shot */
  680. 0, /* ignore_insmod_path */
  681. 0, /* ignore_insmod_all */
  682. 0, /* truncate */
  683. NULL,   /* target */
  684. NULL,   /* architecture */
  685. NULL,   /* addresses */
  686. 0 /* address_bits */
  687.     };
  688.     static char const procname[] = "main";
  690.     prefix = *argv;
  691.     setvbuf(stdout, NULL, _IONBF, 0);
  693. #ifdef DEF_VMLINUX
  694.     options.vmlinux = DEF_VMLINUX;
  695. #endif
  696. #ifdef DEF_KSYMS
  697.     options.ksyms = DEF_KSYMS;
  698. #endif
  699. #ifdef DEF_LSMOD
  700.     options.lsmod = DEF_LSMOD;
  701. #endif
  702. #ifdef DEF_OBJECTS
  703.     {
  704. char *p;
  705. options.object = realloc(options.object,
  706.     (options.objects+1)*sizeof(*options.object));
  707. if (!options.object)
  708.     malloc_error("DEF_OBJECTS");
  709. if (!(p = strdup(DEF_OBJECTS)))
  710.     malloc_error("DEF_OBJECTS");
  711. else
  712.     options.object[options.objects++] = p;
  713.     }
  714. #endif
  715. #ifdef DEF_MAP
  716.     options.system_map = DEF_MAP;
  717. #endif
  718. #ifdef DEF_TARGET
  719.     options.target = DEF_TARGET;
  720.     {
  721. int target_byteorder;
  723. if (strstr(options.target, "-big"))
  724.     target_byteorder = __BIG_ENDIAN;
  725. else if (strstr(options.target, "-little"))
  726.     target_byteorder = __LITTLE_ENDIAN;
  727. else
  728.     target_byteorder = __BYTE_ORDER;
  730. if (target_byteorder != __BYTE_ORDER)
  731.     options.endianess = 1;
  732.     }
  733. #endif
  734. #ifdef DEF_ARCH
  735.     options.architecture = DEF_ARCH;
  736. #endif
  738.     /* Not all include files define __u16, __u32, __u64 so do it the hard way.
  739.      * Any decent optimizing compiler will discard these tests at compile time
  740.      * unless there is a problem.
  741.      */
  742.     if (sizeof(U16) != 2)
  743. FATAL("%s", "sizeof(U16) != 2");
  744.     if (sizeof(U32) != 4)
  745. FATAL("%s", "sizeof(U32) != 4");
  746.     if (sizeof(U64) != 8)
  747. FATAL("%s", "sizeof(U64) != 8");
  749.     parse(argc, argv, &options, &spec_h);
  751.     if (spec_h && options.filecount == 0)
  752. return(0);  /* just the help text */
  754.     bfd_init();
  756.     if ((options.target && strcmp(options.target, "?") == 0) ||
  757. (options.architecture && strcmp(options.architecture, "?") == 0)) {
  758. print_available_ta(&options);
  759. return(0);  /* just the available target/architecture */
  760.     }
  762.     if (errors)
  763. return(1);
  765.     DEBUG(1, "level %d", debug);
  767.     read_env("KSYMOOPS_NM", &path_nm);
  768.     read_env("KSYMOOPS_FIND", &path_find);
  769.     read_env("KSYMOOPS_OBJDUMP", &path_objdump);
  771.     re_compile_common();
  772.     ss_init_common();
  774.     if (!options.one_shot)
  775. read_symbol_sources(&options);
  777.     /* After all that work, it is finally time to read the Oops report */
  778.     ret = Oops_read(&options);
  780.     if (warnings || errors) {
  781. printf("n");
  782. if (warnings)
  783.     printf("%d warning%s ",
  784.    warnings, warnings == 1 ? "" : "s");
  785. if (warnings && errors)
  786.     printf("and ");
  787. if (errors)
  788.     printf("%d error%s ", errors, errors == 1 ? "" : "s");
  789. printf("issued.  Results may not be reliable.n");
  790. if (!ret)
  791.     return(1);
  792.     }
  794.     return(ret);
  795. }