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

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

驱动编程

开发平台：

C/C++

oops.c：源码内容
  1. /*
  2.     oops.c.
  4.     Oops processing for ksymoops.
  6.     Copyright 1999 Keith Owens <kaos@ocs.com.au>.
  7.     Released under the GNU Public Licence, Version 2.
  9.  */
  11. #include "ksymoops.h"
  12. #include <ctype.h>
  13. #include <errno.h>
  14. #include <malloc.h>
  15. #include <memory.h>
  16. #include <stdlib.h>
  17. #include <string.h>
  18. #include <unistd.h>
  20. /* Error detected by bfd */
  21. static void Oops_bfd_perror(const char *msg)
  22. {
  23.     static char const procname[] = "Oops_bfd_perror";
  24.     bfd_error_type err = bfd_get_error();
  25.     ERROR("%s %s", msg, bfd_errmsg(err));
  26. }
  28. /* Open the ksymoops binary so we have an input bfd to copy data from. */
  29. static void Oops_open_input_bfd(char **me, bfd **ibfd, const OPTIONS *options)
  30. {
  31.     char **matches, **match;
  32.     static char const procname[] = "Oops_open_input_bfd";
  34.     *me = find_fullpath(prefix);
  36.     if (!*ibfd && !(*ibfd = bfd_openr(*me, NULL))) {
  37. Oops_bfd_perror(*me);
  38. FATAL("%s", "giving up");
  39.     }
  41.     if (!bfd_check_format_matches(*ibfd, bfd_object, &matches)) {
  42. Oops_bfd_perror(*me);
  43. if (bfd_get_error() == bfd_error_file_ambiguously_recognized) {
  44.     printf("%s Matching formats:", procname);
  45.     match = matches;
  46.     while (*match)
  47. printf(" %s", *match++);
  48.     printf("n");
  49.     free(matches);
  50. }
  51. FATAL("%s", "giving up");
  52.     }
  53. }
  55. /* If target or architecture is not already set, default to the same as
  56.  * ksymoops.
  57.  */
  58. static void Oops_set_default_ta(const char *me, const bfd *ibfd,
  59. OPTIONS *options)
  60. {
  61.     static char const procname[] = "Oops_set_default_ta";
  62.     const char *bt;
  63.     const bfd_arch_info_type *bai;
  64.     int t = 0, a = 0;
  66.     if (!options->target) {
  67. bt = bfd_get_target(ibfd); /* Bah, undocumented bfd function */
  68. if (!bt) {
  69.     Oops_bfd_perror(me);
  70.     FATAL("cannot get bfd_target for %s:", me);
  71. }
  72. options->target = bt;
  73. t = 1;
  74.     }
  76.     if (!options->architecture) {
  77. /* bfd_get_arch_info should really take (const bfd *) */
  78. bai = bfd_get_arch_info((bfd *)ibfd);
  79. if (!bai) {
  80.     Oops_bfd_perror(me);
  81.     FATAL("cannot get bfd_arch_info for %s:", me);
  82. }
  83. options->architecture = bai->printable_name;
  84. a = 1;
  85.     }
  86.     if (t || a) {
  87. printf("Using defaults from ksymoops");
  88. if (t)
  89.     printf(" -t %s", options->target);
  90. if (a)
  91.     printf(" -a %s", options->architecture);
  92. printf("n");
  93.     }
  94. }
  96. /* Write the code values to a file using bfd. */
  97. static int Oops_write_bfd_data(const bfd *ibfd, bfd *obfd,
  98.        const char *code, int size)
  99. {
  100.     asection *isec, *osec;
  101.     asymbol *osym;
  103.     /* bfd_get_section_by_name should really take (const bfd *,) */
  104.     if (!(isec = bfd_get_section_by_name((bfd *)ibfd, ".text"))) {
  105. Oops_bfd_perror("get_section");
  106. return(0);
  107.     }
  108.     if (!bfd_set_start_address(obfd, 0)) {
  109. Oops_bfd_perror("set_start_address");
  110. return(0);
  111.     }
  112.     if (!(osec = bfd_make_section(obfd, ".text"))) {
  113. Oops_bfd_perror("make_section");
  114. return(0);
  115.     }
  116.     if (!bfd_set_section_flags(obfd, osec,
  117. bfd_get_section_flags(ibfd, isec))) {
  118. Oops_bfd_perror("set_section_flags");
  119. return(0);
  120.     }
  121.     if (!bfd_set_section_alignment(obfd, osec,
  122. bfd_get_section_alignment(ibfd, isec))) {
  123. Oops_bfd_perror("set_section_alignment");
  124. return(0);
  125.     }
  126.     osec->output_section = osec;
  127.     if (!(osym = bfd_make_empty_symbol(obfd))) {
  128. Oops_bfd_perror("make_empty_symbol");
  129. return(0);
  130.     }
  131.     osym->name = "_XXX";
  132.     osym->section = osec;
  133.     osym->flags = BSF_GLOBAL;
  134.     osym->value = 0;
  135.     if (!bfd_set_symtab(obfd, &osym, 1)) {
  136. Oops_bfd_perror("set_symtab");
  137. return(0);
  138.     }
  139.     if (!bfd_set_section_size(obfd, osec, size)) {
  140. Oops_bfd_perror("set_section_size");
  141. return(0);
  142.     }
  143.     if (!bfd_set_section_vma(obfd, osec, 0)) {
  144. Oops_bfd_perror("set_section_vma");
  145. return(0);
  146.     }
  147.     if (!bfd_set_section_contents(obfd, osec, (PTR) code, 0, size)) {
  148. Oops_bfd_perror("set_section_contents");
  149. return(0);
  150.     }
  151.     if (!bfd_close(obfd)) {
  152. Oops_bfd_perror("close(obfd)");
  153. return(0);
  154.     }
  155.     return 1;
  156. }
  158. /* Write the Oops code to a temporary file with suitable header and trailer. */
  159. static char *Oops_code_to_file(const char *code, int size, const bfd *ibfd,
  160.        OPTIONS *options)
  161. {
  162.     char *file, *tmpdir;
  163.     int fd;
  164.     bfd *obfd;
  165.     const bfd_arch_info_type *bai;
  166.     static const char temp_suffix[] = "/ksymoops.XXXXXX";
  167.     static char const procname[] = "Oops_code_to_file";
  169.     /* Security fix, use mkstemp and honour TMPDIR */
  170.     if (!(tmpdir = getenv("TMPDIR")) || !*tmpdir) {
  171. #ifdef P_tmpdir
  172. tmpdir = P_tmpdir;
  173. #else
  174. tmpdir = "/tmp";
  175. #endif
  176.     }
  177.     file = malloc(strlen(tmpdir) + sizeof(temp_suffix));
  178.     if (!file)
  179. malloc_error(procname);
  180.     strcpy(file, tmpdir);
  181.     strcat(file, temp_suffix);
  182.     if ((fd = mkstemp(file)) < 0) {
  183. ERROR("Unable to open mkstemp file '%s'n", file);
  184. perror(prefix);
  185. return(NULL);
  186.     }
  187.     close(fd);
  189.     /* Set the target on the output file */
  190.     if (!(obfd = bfd_openw(file, options->target))) {
  191. Oops_bfd_perror(file);
  192. if (bfd_get_error() == bfd_error_wrong_format)
  193.     printf("Sorry, looks like your binutils cannot "
  194.    "handle target %sn", options->target);
  195. return(NULL);
  196.     }
  197.     bfd_set_format(obfd, bfd_object);
  199.     /* Set the architecture on the output file */
  200.     if (!(bai = bfd_scan_arch(options->architecture))) {
  201. Oops_bfd_perror("scan_arch for specified architecture");
  202. if (bfd_get_error() == bfd_error_wrong_format)
  203.     printf("Sorry, looks like your binutils cannot "
  204. "handle the specified architecturen");
  205. return(NULL);
  206.     }
  207.     bfd_set_arch_info(obfd, bai);
  208.     options->address_bits = bfd_arch_bits_per_address(obfd);
  210.     if (!Oops_write_bfd_data(ibfd, obfd, code, size))
  211. return(NULL);
  212.     return(file);
  213. }
  215. /* Run objdump against the binary Oops code */
  216. static FILE *Oops_objdump(const char *file, const OPTIONS *options)
  217. {
  218.     char *cmd;
  219.     FILE *f;
  220.     static char const objdump_options[] = "-dhf ";
  221.     static char const procname[] = "Oops_objdump";
  223.     cmd = malloc(strlen(path_objdump)+1+strlen(objdump_options)+strlen(file)+1);
  224.     if (!cmd)
  225. malloc_error(procname);
  226.     strcpy(cmd, path_objdump);
  227.     strcat(cmd, " ");
  228.     strcat(cmd, objdump_options);
  229.     strcat(cmd, file);
  230.     DEBUG(2, "command '%s'", cmd);
  231.     f = popen_local(cmd, procname);
  232.     free(cmd);
  233.     return(f);
  234. }
  237. /* Forward references. */
  238. static const char *Oops_arch_to_eip(const OPTIONS *options);
  239. static void Oops_decode_one_add(SYMBOL_SET *ss, const addr_t address,
  240. const char *line1, const char type, const OPTIONS *options);
  241. static addr_t Oops_truncate_address(addr_t address, const OPTIONS *options);
  243. /* Process one code line from objdump, ignore everything else */
  244. static void Oops_decode_one(SYMBOL_SET *ss, const char *line, addr_t eip,
  245.     int adjust, const char type, const OPTIONS *options)
  246. {
  247.     int i;
  248.     addr_t address, eip_relative;
  249.     char *line2, *map, **string = NULL;
  250.     static regex_t     re_Oops_objdump;
  251.     static regmatch_t *re_Oops_objdump_pmatch;
  252.     static char const procname[] = "Oops_decode_one";
  254.     /* objdump output.  Optional whitespace, hex digits, optional
  255.      * ' <_XXX+offset>', ':'.  The '+offset' after _XXX is also optional.
  256.      * Older binutils output 'xxxxxxxx <_XXX+offset>:', newer versions do
  257.      * '00000000 <_XXX>:' first followed by '      xx:' lines.
  258.      *
  259.      * Just to complicate things even more, objdump recognises jmp, call,
  260.      * etc., converts the code to something like this :-
  261.      * "   f: e8 32 34 00 00  call   3446 <_XXX+0x3446>"
  262.      * Recognise this and append the eip adjusted address, followed by the
  263.      * map_address text for that address.
  264.      *
  265.      * With any luck, objdump will take care of all such references which
  266.      * makes this routine architecture insensitive.  No need to test for
  267.      * i386 jmp, call or m68k swl etc.
  268.      */
  269.     RE_COMPILE(&re_Oops_objdump,
  270.     "^ *"
  271.     "([0-9a-fA-F]+)" /* 1 */
  272.     "( <_XXX[^>]*>)?" /* 2 */
  273.     ":"
  274.     "(" /* 3 */
  275.     ".* +<_XXX\+0?x?([0-9a-fA-F]+)> *$" /* 4 */
  276.     ")?"
  277.     ".*"
  278.     ,
  279. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  280. &re_Oops_objdump_pmatch);
  282.     i = regexec(&re_Oops_objdump, line, re_Oops_objdump.re_nsub+1,
  283. re_Oops_objdump_pmatch, 0);
  284.     DEBUG(4, "regexec %d", i);
  285.     if (i != 0)
  286. return;
  288.     re_strings(&re_Oops_objdump, line, re_Oops_objdump_pmatch, &string);
  289.     address = hexstring(string[1]);
  290.     if (errno) {
  291. ERROR("Invalid hex value in objdump line, treated as zero - '%s'n"
  292.     "  objdump line '%s'",
  293.     string[1], line);
  294. perror(prefix);
  295. address = 0;
  296.     }
  297.     address = Oops_truncate_address(address + eip + adjust, options);
  298.     if (string[4]) {
  299. /* EIP relative data to be adjusted. */
  300. eip_relative = hexstring(string[4]);
  301. if (errno) {
  302.     ERROR("Invalid hex value in objdump line, treated as zero - '%s'n"
  303.   "objdump line '%s'", string[4], line);
  304.     perror(prefix);
  305.     eip_relative = 0;
  306. }
  307. eip_relative = Oops_truncate_address(eip_relative + eip + adjust,
  308. options);
  309. map = map_address(&ss_merged, eip_relative, options);
  310. /* new text is original line, eip_relative in hex, map text */
  311. i = strlen(line)+1+2*sizeof(eip_relative)+1+strlen(map)+1;
  312. line2 = malloc(i);
  313. if (!line2)
  314.     malloc_error(procname);
  315. snprintf(line2, i, "%s %s %s",
  316.     line, format_address(eip_relative, options), map);
  317. Oops_decode_one_add(ss, address, line2, type, options);
  318. free(line2);
  319.     }
  320.     else
  321. Oops_decode_one_add(ss, address, line, type, options);  /* as is */
  322.     re_strings_free(&re_Oops_objdump, &string);
  323. }
  325. /* Maximum number of code bytes to process.  It needs to be a multiple of 2 for
  326.  * endianess swapping (-e).  Sparc and alpha dump 36 bytes so use 64.
  327.  */
  328. #define CODE_SIZE 64
  330. /* Extract the hex values from the Code: line and convert to binary.
  331.  * Strange as it seems, this is actually architecture independent, nothing in
  332.  * this proc cares who created the Code: line.
  333.  */
  334. static int Oops_code_values(const unsigned char* code_text, unsigned char *code,
  335.     int *adjust, const OPTIONS *options)
  336. {
  337.     int byte = 0, byte_prev, len, ret = 1;
  338.     U16 u16;
  339.     U32 u32;
  340.     U64 u64, value;
  341.     char **string = NULL;
  342.     const char *p;
  343.     static regex_t     re_Oops_code_value;
  344.     static regmatch_t *re_Oops_code_value_pmatch;
  345.     static const char procname[] = "Oops_code_values";
  347.     /* Given by re_Oops_code: code_text is a message (e.g. "general protection")
  348.      * or one or more hex fields separated by spaces.  Some architectures
  349.      * bracket the current instruction with '<' and '>', others use '(' and ')'.
  350.      * The first character is nonblank.
  351.      */
  352.     if (!isxdigit(*code_text)) {
  353. WARNING("%s", "Code looks like message, not hex digits.  "
  354.     "No disassembly attempted.");
  355. return(0);
  356.     }
  357.     memset(code, '', CODE_SIZE);
  358.     p = code_text;
  359.     *adjust = 0;    /* EIP points to code byte 0 */
  361.     /* Code values.  Hex values separated by white space.  On some systems, the
  362.      * current instruction is bracketed in '<' and '>' or '(' and ')'.
  363.      */
  364.     RE_COMPILE(&re_Oops_code_value,
  365.     "^"
  366.     "(" /* 1 */
  367.       "([<(]?)" /* 2 */
  368.       "([0-9a-fA-F]+)" /* 3 */
  369.       "[)>]?"
  370.       " *"
  371.     ")"
  372.     "|(Bad .*)" /* 4 */
  373.     ,
  374. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  375. &re_Oops_code_value_pmatch);
  377.     while (regexec(&re_Oops_code_value, p, re_Oops_code_value.re_nsub+1,
  378.     re_Oops_code_value_pmatch, 0) == 0) {
  379. re_strings(&re_Oops_code_value, p,
  380.     re_Oops_code_value_pmatch, &string);
  381. if (string[4] && *(string[4])) {
  382.     ret = 0;
  383.     break; /* Bad EIP value, no code bytes */
  384. }
  385. if (byte >= CODE_SIZE)
  386.     break;
  387. value = hexstring(string[3]);
  388. if (errno) {
  389.     ERROR("Invalid hex value in code_value line, treated as zero - "
  390.   "'%s'ncode_value line '%s'", string[3], code_text);
  391.     perror(prefix);
  392.     value = 0;
  393. }
  394. if (string[2] && *(string[2]))
  395.     *adjust = -byte;    /* this byte is EIP */
  396. /* On some architectures Code: is a stream of bytes, on some it is a
  397.  * stream of shorts, on some it is a stream of ints.  Consistent we're
  398.  * not!
  399.  */
  400. len = strlen(string[3]);
  401. byte_prev = byte;
  402. if (byte+len/2 > CODE_SIZE) {
  403.     WARNING("extra values in Code line, ignored - '%s'", string[3]);
  404.     break;
  405. }
  406. switch (len) {
  407.     case 2:
  408. code[byte++] = value;
  409. break;
  410.     case 4:
  411. u16 = value;
  412. memcpy(code+byte, &u16, sizeof(u16));
  413. byte += sizeof(u16);
  414. break;
  415.     case 8:
  416. u32 = value;
  417. memcpy(code+byte, &u32, sizeof(u32));
  418. byte += sizeof(u32);
  419. break;
  420.     case 16:
  421. u64 = value;
  422. memcpy(code+byte, &u64, sizeof(u64));
  423. byte += sizeof(u64);
  424. break;
  425.     default:
  426. ERROR("invalid value 0x%s in Code line, must be 2, 4, 8 or 16 "
  427.       "digits, value ignored", string[3]);
  428. break;
  429. }
  430. if (options->endianess && len != 2) {
  431.     /* Reverse the endianess of the bytes just stored */
  432.     char c;
  433.     len /= 2;
  434.     while (len) {
  435. c = code[byte_prev];
  436. code[byte_prev] = code[byte_prev+len-1];
  437. code[byte_prev+len-1] = c;
  438. ++byte_prev;
  439. len -= 2;
  440.     }
  441. }
  442. p += re_Oops_code_value_pmatch[0].rm_eo;
  443.     }
  445.     if (ret && *p)
  446. WARNING("garbage '%s' at end of code line ignored", p);
  448.     re_strings_free(&re_Oops_code_value, &string);
  449.     return(ret);
  450. }
  452. /* Add an objdump line to the symbol table.  Just to keep the non-ix86 users
  453.  * happy, replace XXX with an target specific string.
  454.  */
  455. static void Oops_decode_one_add(SYMBOL_SET *ss, const addr_t address,
  456. const char *line1, const char type, const OPTIONS *options)
  457. {
  458.     int i;
  459.     const char *p1;
  460.     char *line2, *p2, *p3;
  461.     static char const procname[] = "Oops_decode_one_add";
  463.     i = strlen(line1)+1;
  464.     line2 = malloc(i);
  465.     if (!line2)
  466. malloc_error(procname);
  467.     memset(line2, '', i);
  468.     p1 = line1;
  469.     p2 = line2;
  470.     while (1) {
  471. if ((p3 = strstr(p1, "_XXX"))) {
  472.     memcpy(p2, p1, p3-p1+1);
  473.     p2 += p3 - p1 + 1;
  474.     p1 = p3 + 4;
  475.     strcpy(p2, Oops_arch_to_eip(options));
  476.     while (*p2)
  477. ++p2;
  478. }
  479. else {
  480.     strcpy(p2, p1);
  481.     break;
  482. }
  483.     }
  484.     if (strlen(line2) > strlen(line1))
  485. ERROR("line2 overrun, should never happen line1='%s'nline2='%s'",
  486.     line1, line2);
  487.     add_symbol_n(ss, address, type, 1, line2);
  488.     free(line2);
  489. }
  491. /* Set the eip from the EIP line */
  492. static void Oops_set_eip(const char *value, addr_t *eip, SYMBOL_SET *ss,
  493.  const char *me, const bfd *ibfd,
  494.  OPTIONS *options)
  495. {
  496.     static const char procname[] = "Oops_set_eip";
  497.     char eip_name[10], *p;
  499.     /* Ensure target is set so EIP text is correct */
  500.     Oops_set_default_ta(me, ibfd, options);
  502.     *eip = hexstring(value);
  503.     if (errno) {
  504. ERROR("Invalid hex value in %s line, ignored - '%s'",
  505.     Oops_arch_to_eip(options), value);
  506. perror(prefix);
  507. *eip = 0;
  508.     }
  509.     snprintf(eip_name, sizeof(eip_name), ">>%-3s;",
  510.  Oops_arch_to_eip(options));
  511.     while ((p = strstr(eip_name, " ;")))
  512. strncpy(p, "; ", 2);
  513.     *eip = Oops_truncate_address(*eip, options);
  514.     add_symbol_n(ss, *eip, 'E', 1, eip_name);
  515. }
  517. /* Look for the sysrq-t (show_task) process line and extract the command name */
  518. static int Oops_set_task_name(const char *line, char ***string, int string_max, SYMBOL_SET *ss)
  519. {
  520.     int i;
  521.     char id[64];
  522.     static regex_t     re_Oops_set_task_name;
  523.     static regmatch_t *re_Oops_set_task_name_pmatch;
  524.     static const char procname[] = "Oops_set_task_name";
  526.     /* Task header from show_task contains (L-TLB) or (NOTLB), the first field
  527.      * is the command name.
  528.      */
  529.     RE_COMPILE(&re_Oops_set_task_name,
  530.     "^([^ ]+) +[^ ] *([^ ]+).*\((L-TLB|NOTLB)\)",
  531. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  532. &re_Oops_set_task_name_pmatch);
  534.     i = regexec(&re_Oops_set_task_name, line, re_Oops_set_task_name.re_nsub+1,
  535. re_Oops_set_task_name_pmatch, 0);
  536.     DEBUG(4, "regexec %d", i);
  537.     if (i)
  538. return(0);
  539.     re_string_check(re_Oops_set_task_name.re_nsub+1, string_max, procname);
  540.     re_strings(&re_Oops_set_task_name, line, re_Oops_set_task_name_pmatch, string);
  541.     snprintf(id, sizeof(id), "Proc;  %s", (*string)[1]);
  542.     add_symbol_n(ss, 0, 'I', 1, id);
  543.     return(1);
  544. }
  546. static regex_t     re_Oops_regs;
  547. static regmatch_t *re_Oops_regs_pmatch;
  549. /* Decide if the line contains registers.  Returns first register name. */
  550. static const char *Oops_regs(const char *line)
  551. {
  552.     int i;
  553.     const char *p;
  554.     static const char procname[] = "Oops_regs";
  556.     RE_COMPILE(&re_Oops_regs,
  557.     "^(" /* 1 */
  558.     "(GP|o)?r[0-9]{1,2}" /* 2 */
  559.     "|[goli][0-9]{1,2}"
  560.     "|[eR][ABCD]X"
  561.     "|[eR][DS]I"
  562.     "|RBP"
  563.     "|e[bs]p"
  564.     "|[fsi]p"
  565.     "|IRP"
  566.     "|SRP"
  567.     "|D?CCR"
  568.     "|USP"
  569.     "|MOF"
  570.     "|ret_pc"
  571.     ")"
  572.     " *[:=] *"
  573.     UNBRACKETED_ADDRESS /* 3 */
  574.     " *"
  575.     ,
  576. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  577. &re_Oops_regs_pmatch);
  579.     i = regexec(&re_Oops_regs, line, re_Oops_regs.re_nsub+1,
  580. re_Oops_regs_pmatch, 0);
  581.     DEBUG(4, "regexec %d", i);
  582.     if (i)
  583. return(NULL);
  584.     /* Some lines just have one register at the start followed by a set of
  585.      * values, those lines are handled as special cases because I have to
  586.      * generate the register numbers.  This code only routines lines that
  587.      * contain exactly one value or each value is preceded by ':' or '='.
  588.      * Lazy check, any ':' or '=' in the rest of the line will do.
  589.      */
  590.     p = line + re_Oops_regs_pmatch[0].rm_eo;
  591.     if (*p && !index(p, ':') && !index(p, '='))
  592. return(NULL);
  593.     return(line + re_Oops_regs_pmatch[0].rm_so);
  594. }
  596. /* Process a register line, extract addresses */
  597. static void Oops_set_regs(const char *line, const char *p,
  598.        SYMBOL_SET *ss, const OPTIONS *options)
  599. {
  600.     addr_t reg;
  601.     char regname[20];
  602.     char **string = NULL;
  603.     static const char procname[] = "Oops_set_regs";
  605.     /* Loop over register names and unbracketed addresses */
  606.     while (1) {
  607. if (regexec(&re_Oops_regs, p, re_Oops_regs.re_nsub+1,
  608.     re_Oops_regs_pmatch, 0) == 0) {
  609.     re_strings(&re_Oops_regs, p, re_Oops_regs_pmatch, &string);
  610.     reg = hexstring(string[3]); /* contents */
  611.     if (errno) {
  612. ERROR(" Invalid hex value in register line, ignored - '%s'",
  613.       string[3]);
  614. perror(prefix);
  615. reg = 0;
  616.     }
  617.     reg = Oops_truncate_address(reg, options);
  618.     strcpy(regname, ">>");
  619.     strncpy(regname+2, string[1], sizeof(regname)-2);
  620.     if (strlen(regname) < sizeof(regname)-1)
  621. strcat(regname, ";");
  622.     add_symbol_n(ss, reg, 'R', 1, regname);
  623.     p += re_Oops_regs_pmatch[0].rm_eo;
  624. }
  625. else
  626.     break;
  627.     }
  629.     if (*p)
  630. WARNING("garbage '%s' at end of register line ignored", p);
  631.     re_strings_free(&re_Oops_regs, &string);
  632. }
  634. /******************************************************************************/
  635. /*                     Start architecture sensitive code                      */
  636. /******************************************************************************/
  638. static regex_t     re_Oops_cris_regs;
  639. static regmatch_t *re_Oops_cris_regs_pmatch;
  640. static int         s390_reg_num = -1;
  642. /* All address arithmetic is done in 64 bit mode, truncate to the result to
  643.  * a valid range for the target.
  644.  */
  645. static addr_t Oops_truncate_address(addr_t address, const OPTIONS *options)
  646. {
  647.     if (options->address_bits == 32 ||
  648. (options->target && (
  649.  strstr(options->target, "i370") ||
  650.  strstr(options->target, "s390")))) {
  651. U32 u32 = address;
  652. if (strstr(options->target, "i370") ||
  653.     strstr(options->target, "s390"))
  654.     u32 &= 0x7fffffff;  /* Really 31 bit addressing on i370/s390 */
  655. address = u32;
  656.     }
  657.     address &= truncate_mask;
  658.     return(address);
  659. }
  661. /* Return a string to represent the eip, depending on the target. */
  662. static const char *Oops_arch_to_eip(const OPTIONS *options)
  663. {
  664.     if (!options->target)
  665. return("???");
  666.     if (strstr(options->target, "i386"))
  667. return("EIP");
  668.     if (strstr(options->target, "alpha") ||
  669. strstr(options->target, "arm")   ||
  670. strstr(options->target, "cris")  ||
  671. strstr(options->target, "m68k")  ||
  672. strstr(options->target, "mips"))
  673.     return("PC");
  674.     if (strstr(options->target, "sparc")) {
  675. if (strstr(options->target, "64"))
  676.     return("TPC");
  677. else
  678.     return("PC");
  679.     }
  680.     if (strstr(options->target, "powerpc"))
  681. return("NIP");
  682.     if (strstr(options->target, "i370") ||
  683. strstr(options->target, "s390"))
  684. return("PSW");
  685.     if (strstr(options->target, "ia64"))
  686. return("IP");
  687.     if (strstr(options->target, "x86_64") ||
  688. strstr(options->target, "x86-64") ||
  689. strstr(options->target, "x8664"))
  690.     return("RIP");
  691.     return("???");
  692. }
  694. /* Look for the EIP: line, returns start of the relevant hex value */
  695. static char *Oops_eip(const char *line, char ***string, int string_max,
  696.       const bfd *ibfd, OPTIONS *options)
  697. {
  698.     int i;
  699.     static regex_t     re_Oops_eip_sparc;
  700.     static regmatch_t *re_Oops_eip_sparc_pmatch;
  701.     static regex_t     re_Oops_eip_sparc64;
  702.     static regmatch_t *re_Oops_eip_sparc64_pmatch;
  703.     static regex_t     re_Oops_eip_ppc;
  704.     static regmatch_t *re_Oops_eip_ppc_pmatch;
  705.     static regex_t     re_Oops_eip_mips;
  706.     static regmatch_t *re_Oops_eip_mips_pmatch;
  707.     static regex_t     re_Oops_eip_kdb;
  708.     static regmatch_t *re_Oops_eip_kdb_pmatch;
  709.     static regex_t     re_Oops_eip_ia64;
  710.     static regmatch_t *re_Oops_eip_ia64_pmatch;
  711.     static regex_t     re_Oops_mca_ip_ia64;
  712.     static regmatch_t *re_Oops_mca_ip_ia64_pmatch;
  713.     static regex_t     re_Oops_eip_cris;
  714.     static regmatch_t *re_Oops_eip_cris_pmatch;
  715.     static regex_t     re_Oops_eip_other;
  716.     static regmatch_t *re_Oops_eip_other_pmatch;
  717.     static const char procname[] = "Oops_eip";
  719.     /* Oops 'EIP:' line for sparc, actually PSR followed by PC */
  720.     RE_COMPILE(&re_Oops_eip_sparc,
  721.     "^PSR: [0-9a-fA-F]+ PC: " UNBRACKETED_ADDRESS,
  722. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  723. &re_Oops_eip_sparc_pmatch);
  725.     i = regexec(&re_Oops_eip_sparc, line, re_Oops_eip_sparc.re_nsub+1,
  726. re_Oops_eip_sparc_pmatch, 0);
  727.     DEBUG(4, "regexec sparc %d", i);
  728.     if (i == 0) {
  729. re_string_check(re_Oops_eip_sparc.re_nsub+1, string_max,
  730.     procname);
  731. re_strings(&re_Oops_eip_sparc, line, re_Oops_eip_sparc_pmatch,
  732.     string);
  733. return((*string)[re_Oops_eip_sparc.re_nsub]);
  734.     }
  736.     /* Oops 'EIP:' line for sparc64, actually TSTATE followed by TPC */
  737.     RE_COMPILE(&re_Oops_eip_sparc64,
  738.     "^TSTATE: [0-9a-fA-F]{16} TPC: " UNBRACKETED_ADDRESS,
  739. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  740. &re_Oops_eip_sparc64_pmatch);
  742.     re_string_check(re_Oops_eip_sparc64.re_nsub+1, string_max, procname);
  743.     i = regexec(&re_Oops_eip_sparc64, line, re_Oops_eip_sparc64.re_nsub+1,
  744. re_Oops_eip_sparc64_pmatch, 0);
  745.     DEBUG(4, "regexec sparc64 %d", i);
  746.     if (i == 0) {
  747. /* Special case for sparc64.  If the output target is defaulting to the
  748.  * same format as ksymoops then the default is wrong, kernel is 64 bit,
  749.  * ksymoops is 32 bit.  When we see an EIP from sparc64, set the correct
  750.  * default.
  751.  */
  752. if (!options->target && !options->architecture &&
  753.     strcmp(bfd_get_target(ibfd), "elf32-sparc")) {
  754.     options->target = "elf64-sparc";
  755.     options->architecture = "sparc:v9a";
  756. }
  757. re_strings(&re_Oops_eip_sparc64, line, re_Oops_eip_sparc64_pmatch,
  758.     string);
  759. return((*string)[re_Oops_eip_sparc64.re_nsub]);
  760.     }
  762.     /* Oops 'EIP:' line for PPC, all over the place */
  763.     RE_COMPILE(&re_Oops_eip_ppc,
  764.     "("
  765.       "kernel pc "
  766.       "|trap at PC: "
  767.       "|bad area pc "
  768.       "|NIP: "
  769.     ")"
  770.     UNBRACKETED_ADDRESS,
  771. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  772. &re_Oops_eip_ppc_pmatch);
  774.     i = regexec(&re_Oops_eip_ppc, line, re_Oops_eip_ppc.re_nsub+1,
  775. re_Oops_eip_ppc_pmatch, 0);
  776.     DEBUG(4, "regexec ppc %d", i);
  777.     if (i == 0) {
  778. re_string_check(re_Oops_eip_ppc.re_nsub+1, string_max,
  779.     procname);
  780. re_strings(&re_Oops_eip_ppc, line, re_Oops_eip_ppc_pmatch,
  781.     string);
  782. return((*string)[re_Oops_eip_ppc.re_nsub]);
  783.     }
  785.     /* Oops 'EIP:' line for mips, epc, optional white space, ':',
  786.      * optional white space, unbracketed address.
  787.      */
  788.     RE_COMPILE(&re_Oops_eip_mips,
  789.     "^epc *:+ *"
  790.     UNBRACKETED_ADDRESS,
  791. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  792. &re_Oops_eip_mips_pmatch);
  794.     i = regexec(&re_Oops_eip_mips, line, re_Oops_eip_mips.re_nsub+1,
  795. re_Oops_eip_mips_pmatch, 0);
  796.     DEBUG(4, "regexec mips %d", i);
  797.     if (i == 0) {
  798. re_string_check(re_Oops_eip_mips.re_nsub+1, string_max,
  799.     procname);
  800. re_strings(&re_Oops_eip_mips, line, re_Oops_eip_mips_pmatch,
  801.     string);
  802. return((*string)[re_Oops_eip_mips.re_nsub]);
  803.     }
  805.     /* Oops 'IP' line for ia64, space, ip, optional white space, ':',
  806.      * optional white space, bracketed address.
  807.      */
  808.     RE_COMPILE(&re_Oops_eip_ia64,
  809.     " ip *:+ *"
  810.     BRACKETED_ADDRESS,
  811. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  812. &re_Oops_eip_ia64_pmatch);
  814.     i = regexec(&re_Oops_eip_ia64, line, re_Oops_eip_ia64.re_nsub+1,
  815. re_Oops_eip_ia64_pmatch, 0);
  816.     DEBUG(4, "regexec eip_ia64 %d", i);
  817.     if (i == 0) {
  818. re_string_check(re_Oops_eip_ia64.re_nsub+1, string_max,
  819.     procname);
  820. re_strings(&re_Oops_eip_ia64, line, re_Oops_eip_ia64_pmatch,
  821.     string);
  822. return((*string)[re_Oops_eip_ia64.re_nsub]);
  823.     }
  825.     /* MCA 'IP' line for ia64.  [x]ip at start of line, space, '('regname'),
  826.      * spaces, :, space, 0x, UNBRACKETED_ADDRESS.
  827.      */
  828.     RE_COMPILE(&re_Oops_mca_ip_ia64,
  829.     "[xi]ip *\([^)]*\) *: *"
  830.     "0x" UNBRACKETED_ADDRESS,
  831. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  832. &re_Oops_mca_ip_ia64_pmatch);
  834.     i = regexec(&re_Oops_mca_ip_ia64, line, re_Oops_mca_ip_ia64.re_nsub+1,
  835. re_Oops_mca_ip_ia64_pmatch, 0);
  836.     DEBUG(4, "regexec mca_ip_ia64 %d", i);
  837.     if (i == 0) {
  838. re_string_check(re_Oops_mca_ip_ia64.re_nsub+1, string_max,
  839.     procname);
  840. re_strings(&re_Oops_mca_ip_ia64, line, re_Oops_mca_ip_ia64_pmatch,
  841.     string);
  842. return((*string)[re_Oops_mca_ip_ia64.re_nsub]);
  843.     }
  845.     /* SGI kdb backtrace EIP.  At start of line, 0x unbracketed
  846.      * address, 0x unbracketed address, anything, '+0x'.  The second
  847.      * unbracketed address is the EIP.
  848.      * The initial kdb reports has lines like
  849.      * Entering kdb on processor 2 due to panic @ 0x5005f426
  850.      */
  851.     RE_COMPILE(&re_Oops_eip_kdb,
  852.     "(" /* 1 */
  853.       "^0x" UNBRACKETED_ADDRESS /* 2 */
  854.       "0x" UNBRACKETED_ADDRESS /* 3 */
  855.       ".*+0x"
  856.     ")"
  857.     "|(" /* 4 */
  858.       "^Entering kdb on processor.*0x"
  859.       UNBRACKETED_ADDRESS /* 5 */
  860.     ")",
  861. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  862. &re_Oops_eip_kdb_pmatch);
  864.     i = regexec(&re_Oops_eip_kdb, line, re_Oops_eip_kdb.re_nsub+1,
  865. re_Oops_eip_kdb_pmatch, 0);
  866.     DEBUG(4, "regexec kdb %d", i);
  867.     if (i == 0) {
  868. re_string_check(re_Oops_eip_kdb.re_nsub+1, string_max,
  869.     procname);
  870. re_strings(&re_Oops_eip_kdb, line, re_Oops_eip_kdb_pmatch,
  871.     string);
  872. if ((*string)[3] && *((*string)[3]))
  873.     return((*string)[3]);
  874. if ((*string)[5] && *((*string)[5]))
  875.     return((*string)[5]);
  876.     }
  878.     /* Oops 'IRP' line for CRIS: "^IRP: " unbracketed address.
  879.      * Keep spacing optional.
  880.      */
  881.     RE_COMPILE(&re_Oops_eip_cris,
  882.     "^ *IRP *: *"
  883.     UNBRACKETED_ADDRESS,
  884. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  885. &re_Oops_eip_cris_pmatch);
  887.     i = regexec(&re_Oops_eip_cris, line, re_Oops_eip_cris.re_nsub+1,
  888. re_Oops_eip_cris_pmatch, 0);
  889.     DEBUG(4, "regexec cris %d", i);
  890.     if (i == 0) {
  891. re_string_check(re_Oops_eip_cris.re_nsub+1, string_max,
  892.     procname);
  893. re_strings(&re_Oops_eip_cris, line, re_Oops_eip_cris_pmatch,
  894.     string);
  895. return((*string)[re_Oops_eip_cris.re_nsub]);
  896.     }
  898.     /* Oops 'EIP:' line for other architectures */
  899.     RE_COMPILE(&re_Oops_eip_other,
  900. "^("
  901.   "EIP: +.*" /* i386 */
  902.   "|RIP: +.*" /* x86_64 */
  903.   "|PC *= *" /* m68k, alpha */
  904.   "|pc *: *" /* arm */
  905. ")"
  906. BRACKETED_ADDRESS
  907. ,
  908. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  909. &re_Oops_eip_other_pmatch);
  911.     i = regexec(&re_Oops_eip_other, line, re_Oops_eip_other.re_nsub+1,
  912. re_Oops_eip_other_pmatch, 0);
  913.     DEBUG(4, "regexec other %d", i);
  914.     if (i == 0) {
  915. re_string_check(re_Oops_eip_other.re_nsub+1, string_max,
  916.     procname);
  917. re_strings(&re_Oops_eip_other, line, re_Oops_eip_other_pmatch,
  918.     string);
  919. return((*string)[re_Oops_eip_other.re_nsub]);
  920.     }
  921.     return(NULL);
  922. }
  924. /* Look for the arm lr line, returns start of the relevant hex value */
  925. static char *Oops_arm_lr(const char *line, char ***string, int string_max)
  926. {
  927.     int i;
  928.     static regex_t     re_Oops_arm_lr;
  929.     static regmatch_t *re_Oops_arm_lr_pmatch;
  930.     static const char procname[] = "Oops_arm_lr";
  932.     RE_COMPILE(&re_Oops_arm_lr,
  933.     "pc *: *" BRACKETED_ADDRESS /* 1 */
  934.     " *lr *: *" BRACKETED_ADDRESS, /* 2 */
  935. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  936. &re_Oops_arm_lr_pmatch);
  938.     i = regexec(&re_Oops_arm_lr, line, re_Oops_arm_lr.re_nsub+1,
  939. re_Oops_arm_lr_pmatch, 0);
  940.     DEBUG(4, "regexec %d", i);
  941.     if (i == 0) {
  942. re_string_check(re_Oops_arm_lr.re_nsub+1, string_max, procname);
  943. re_strings(&re_Oops_arm_lr, line, re_Oops_arm_lr_pmatch,
  944.     string);
  945. return((*string)[re_Oops_arm_lr.re_nsub]);
  946.     }
  947.     return(NULL);
  948. }
  950. /* Set the arm lr from the lr line */
  951. static void Oops_set_arm_lr(const char *value, SYMBOL_SET *ss)
  952. {
  953.     static const char procname[] = "Oops_set_arm_lr";
  954.     addr_t ra;
  955.     ra = hexstring(value);
  956.     if (errno) {
  957. ERROR(" Invalid hex value in ra line, ignored - '%s'", value);
  958. perror(prefix);
  959. ra = 0;
  960.     }
  961.     add_symbol_n(ss, ra, 'R', 1, ">>LR; ");
  962. }
  964. /* Look for the alpha ra line, returns start of the relevant hex value */
  965. static char *Oops_alpha_ra(const char *line, char ***string, int string_max)
  966. {
  967.     int i;
  968.     static regex_t     re_Oops_alpha_ra;
  969.     static regmatch_t *re_Oops_alpha_ra_pmatch;
  970.     static const char procname[] = "Oops_alpha_ra";
  972.     RE_COMPILE(&re_Oops_alpha_ra,
  973.     "pc *= *" BRACKETED_ADDRESS /* 1 */
  974.     " *ra *= *" BRACKETED_ADDRESS, /* 2 */
  975. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  976. &re_Oops_alpha_ra_pmatch);
  978.     i = regexec(&re_Oops_alpha_ra, line, re_Oops_alpha_ra.re_nsub+1,
  979. re_Oops_alpha_ra_pmatch, 0);
  980.     DEBUG(4, "regexec %d", i);
  981.     if (i == 0) {
  982. re_string_check(re_Oops_alpha_ra.re_nsub+1, string_max, procname);
  983. re_strings(&re_Oops_alpha_ra, line, re_Oops_alpha_ra_pmatch,
  984.     string);
  985. return((*string)[re_Oops_alpha_ra.re_nsub]);
  986.     }
  987.     return(NULL);
  988. }
  990. /* Set the alpha ra from the ra line */
  991. static void Oops_set_alpha_ra(const char *value, SYMBOL_SET *ss)
  992. {
  993.     static const char procname[] = "Oops_set_alpha_ra";
  994.     addr_t ra;
  995.     ra = hexstring(value);
  996.     if (errno) {
  997. ERROR(" Invalid hex value in ra line, ignored - '%s'", value);
  998. perror(prefix);
  999. ra = 0;
  1000.     }
  1001.     add_symbol_n(ss, ra, 'R', 1, ">>RA; ");
  1002. }
  1004. /* Look for the alpha spinlock stuck line, returns TRUE with string[1]
  1005.  * containing the PC, string[2] containing the previous PC.
  1006.  */
  1007. static int Oops_eip_alpha_spinlock(const char *line, char ***string,
  1008.    int string_max, OPTIONS *options)
  1009. {
  1010.     int i;
  1011.     static regex_t     re_Oops_eip_alpha_spinlock;
  1012.     static regmatch_t *re_Oops_eip_alpha_spinlock_pmatch;
  1013.     static const char procname[] = "Oops_eip_alpha_spinlock";
  1015.     RE_COMPILE(&re_Oops_eip_alpha_spinlock,
  1016.     "^spinlock stuck at " UNBRACKETED_ADDRESS
  1017.     ".*owner.*at " UNBRACKETED_ADDRESS,
  1018. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  1019. &re_Oops_eip_alpha_spinlock_pmatch);
  1021.     i = regexec(&re_Oops_eip_alpha_spinlock, line,
  1022. re_Oops_eip_alpha_spinlock.re_nsub+1,
  1023. re_Oops_eip_alpha_spinlock_pmatch, 0);
  1024.     DEBUG(4, "regexec %d", i);
  1025.     if (i == 0) {
  1026. re_string_check(re_Oops_eip_alpha_spinlock.re_nsub+1, string_max,
  1027.     procname);
  1028. re_strings(&re_Oops_eip_alpha_spinlock, line,
  1029.     re_Oops_eip_alpha_spinlock_pmatch, string);
  1030. return(1);
  1031.     }
  1032.     return(0);
  1033. }
  1035. /* Look for the sparc spinlock stuck line, returns TRUE with string[1]
  1036.  * containing the lock address, string[2] containing the caller PC,
  1037.  * string[3] containing the owning PC.
  1038.  */
  1039. static int Oops_eip_sparc_spinlock(const char *line, char ***string,
  1040.    int string_max, OPTIONS *options)
  1041. {
  1042.     int i;
  1043.     static regex_t     re_Oops_eip_sparc_spinlock;
  1044.     static regmatch_t *re_Oops_eip_sparc_spinlock_pmatch;
  1045.     static const char procname[] = "Oops_eip_sparc_spinlock";
  1047.     RE_COMPILE(&re_Oops_eip_sparc_spinlock,
  1048.     "^spin_lock[^ ]*\(" UNBRACKETED_ADDRESS
  1049.     ".*stuck at *" UNBRACKETED_ADDRESS
  1050.     ".*PC\(" UNBRACKETED_ADDRESS,
  1051. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  1052. &re_Oops_eip_sparc_spinlock_pmatch);
  1054.     i = regexec(&re_Oops_eip_sparc_spinlock, line,
  1055. re_Oops_eip_sparc_spinlock.re_nsub+1,
  1056. re_Oops_eip_sparc_spinlock_pmatch, 0);
  1057.     DEBUG(4, "regexec %d", i);
  1058.     if (i == 0) {
  1059. re_string_check(re_Oops_eip_sparc_spinlock.re_nsub+1, string_max,
  1060.     procname);
  1061. re_strings(&re_Oops_eip_sparc_spinlock, line,
  1062.     re_Oops_eip_sparc_spinlock_pmatch, string);
  1063. return(1);
  1064.     }
  1065.     return(0);
  1066. }
  1068. /* Look for the mips ra line, returns start of the relevant hex value */
  1069. static char *Oops_mips_ra(const char *line, char ***string, int string_max)
  1070. {
  1071.     int i;
  1072.     static regex_t     re_Oops_mips_ra;
  1073.     static regmatch_t *re_Oops_mips_ra_pmatch;
  1074.     static const char procname[] = "Oops_mips_ra";
  1076.     /* Oops 'ra:' line for mips, ra, optional white space, one or
  1077.      * more '=', optional white space, unbracketed address.
  1078.      */
  1079.     RE_COMPILE(&re_Oops_mips_ra,
  1080.     "ra *=+ *"
  1081.     UNBRACKETED_ADDRESS,
  1082. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  1083. &re_Oops_mips_ra_pmatch);
  1085.     i = regexec(&re_Oops_mips_ra, line, re_Oops_mips_ra.re_nsub+1,
  1086. re_Oops_mips_ra_pmatch, 0);
  1087.     DEBUG(4, "regexec %d", i);
  1088.     if (i == 0) {
  1089. re_string_check(re_Oops_mips_ra.re_nsub+1, string_max, procname);
  1090. re_strings(&re_Oops_mips_ra, line, re_Oops_mips_ra_pmatch,
  1091.     string);
  1092. return((*string)[re_Oops_mips_ra.re_nsub]);
  1093.     }
  1094.     return(NULL);
  1095. }
  1097. /* Set the mips ra from the ra line */
  1098. static void Oops_set_mips_ra(const char *value, SYMBOL_SET *ss)
  1099. {
  1100.     static const char procname[] = "Oops_set_mips_ra";
  1101.     addr_t ra;
  1102.     ra = hexstring(value);
  1103.     if (errno) {
  1104. ERROR(" Invalid hex value in ra line, ignored - '%s'", value);
  1105. perror(prefix);
  1106. ra = 0;
  1107.     }
  1108.     add_symbol_n(ss, ra, 'R', 1, ">>RA; ");
  1109. }
  1111. /* Extract mips registers. */
  1112. static void Oops_mips_regs(const char *line, SYMBOL_SET *ss, const OPTIONS *options)
  1113. {
  1114.     int i, reg_num;
  1115.     addr_t reg;
  1116.     char regname[7];
  1117.     char **string = NULL;
  1118.     const char *p;
  1119.     static regex_t     re_Oops_mips_regs;
  1120.     static regmatch_t *re_Oops_mips_regs_pmatch;
  1121.     static const char procname[] = "Oops_mips_regs";
  1123.     RE_COMPILE(&re_Oops_mips_regs,
  1124.     "^(\$[0-9]{1,2}) *: *" /* 1 */
  1125.     UNBRACKETED_ADDRESS /* 2 */
  1126.     ,
  1127. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  1128. &re_Oops_mips_regs_pmatch);
  1130.     i = regexec(&re_Oops_mips_regs, line, re_Oops_mips_regs.re_nsub+1,
  1131. re_Oops_mips_regs_pmatch, 0);
  1132.     DEBUG(4, "regexec %d", i);
  1133.     if (i)
  1134. return;
  1135.     p = line + re_Oops_mips_regs_pmatch[0].rm_so + 1;
  1136.     reg_num = strtoul(p, NULL, 10);
  1137.     p = line + re_Oops_mips_regs_pmatch[2].rm_so;
  1138.     /* Loop over unbracketed addresses */
  1139.     while (1) {
  1140. if (regexec(&re_unbracketed_address, p, re_unbracketed_address.re_nsub+1,
  1141.     re_unbracketed_address_pmatch, 0) == 0) {
  1142.     re_strings(&re_unbracketed_address, p, re_unbracketed_address_pmatch, &string);
  1143.     reg = hexstring(string[1]); /* contents */
  1144.     if (errno) {
  1145. ERROR(" Invalid hex value in register line, ignored - '%s'",
  1146.       string[1]);
  1147. perror(prefix);
  1148. break;
  1149.     }
  1150.     reg = Oops_truncate_address(reg, options);
  1151.     snprintf(regname, sizeof(regname), ">>$%d;", reg_num);
  1152.     add_symbol_n(ss, reg, 'R', 1, regname);
  1153.     p += re_unbracketed_address_pmatch[0].rm_eo;
  1154.     ++reg_num;
  1155.     if (reg_num == 26)
  1156. reg_num += 2; /* skip k0, k1 */
  1157. }
  1158. else
  1159.     break;
  1160.     }
  1162.     if (*p)
  1163. WARNING("garbage '%s' at end of mips register line ignored", p);
  1164.     re_strings_free(&re_unbracketed_address, &string);
  1165. }
  1167. /* Look for the ia64 b0 line and set all the values */
  1168. static void Oops_set_ia64_b0(const char *line, char ***string, int string_max, SYMBOL_SET *ss)
  1169. {
  1170.     int i;
  1171.     addr_t b;
  1172.     char label[6];
  1173.     static regex_t     re_Oops_ia64_b0;
  1174.     static regmatch_t *re_Oops_ia64_b0_pmatch;
  1175.     static const char procname[] = "Oops_ia64_b0";
  1177.     /* Oops 'b0' line for ia64, b0 : unbracketed address, may be
  1178.      * repeated for b6, b7.  MCA has b0 '('regname')' : 0x unbracketed address.
  1179.      */
  1180.     RE_COMPILE(&re_Oops_ia64_b0,
  1181.     "^b[0-7] *(\([^)]*\) *)?: *(0x)?"
  1182.     UNBRACKETED_ADDRESS,
  1183. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  1184. &re_Oops_ia64_b0_pmatch);
  1186.     /* Scan entire line for b0, b6, b7 */
  1187.     while(1) {
  1188. i = regexec(&re_Oops_ia64_b0, line, re_Oops_ia64_b0.re_nsub+1,
  1189.     re_Oops_ia64_b0_pmatch, 0);
  1190. DEBUG(4, "regexec %d", i);
  1191. if (i)
  1192.     break;
  1193. re_string_check(re_Oops_ia64_b0.re_nsub+1, string_max, procname);
  1194. re_strings(&re_Oops_ia64_b0, line, re_Oops_ia64_b0_pmatch, string);
  1195. strcpy(label, ">>bx; ");
  1196. label[3] = line[1]; /* register number */
  1197. b = hexstring((*string)[re_Oops_ia64_b0.re_nsub]);
  1198. if (errno) {
  1199.     ERROR(" Invalid hex value in b%c line, ignored - '%s'",
  1200. line[1], (*string)[re_Oops_ia64_b0.re_nsub]);
  1201.     perror(prefix);
  1202.     b = 0;
  1203. }
  1204. add_symbol_n(ss, b, 'R', 1, label);
  1205. line += re_Oops_ia64_b0_pmatch[0].rm_eo;
  1206.     }
  1207. }
  1209. /* Look for the sparc register dump lines end */
  1210. static int Oops_sparc_regdump(const char *line, char ***string)
  1211. {
  1212.     int i;
  1213.     static regex_t     re_Oops_sparc_regdump;
  1214.     static regmatch_t *re_Oops_sparc_regdump_pmatch;
  1215.     static const char procname[] = "Oops_sparc_regdump";
  1217.     RE_COMPILE(&re_Oops_sparc_regdump,
  1218.     "^("
  1219. "i[04]: "
  1220. "|Instruction DUMP: "
  1221. "|Caller\["
  1222.     ")",
  1223. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  1224. &re_Oops_sparc_regdump_pmatch);
  1226.     i = regexec(&re_Oops_sparc_regdump, line, re_Oops_sparc_regdump.re_nsub+1,
  1227. re_Oops_sparc_regdump_pmatch, 0);
  1228.     DEBUG(4, "regexec %d", i);
  1229.     if (i == 0)
  1230. return 1;
  1231.     return 0;
  1232. }
  1234. /* Look for the i370 PSW line, returns start of the relevant hex value */
  1235. static char *Oops_i370_psw(const char *line, char ***string, int string_max)
  1236. {
  1237.     int i;
  1238.     static regex_t     re_Oops_i370_psw;
  1239.     static regmatch_t *re_Oops_i370_psw_pmatch;
  1240.     static const char procname[] = "Oops_i370_psw";
  1242.     /* Oops 'PSW:' line for i370, PSW at start of line, value is second
  1243.      * address.
  1244.      */
  1245.     RE_COMPILE(&re_Oops_i370_psw,
  1246.     "^PSW *flags: *"
  1247.     UNBRACKETED_ADDRESS /* flags */
  1248.     " *PSW addr: *"
  1249.     UNBRACKETED_ADDRESS,
  1250. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  1251. &re_Oops_i370_psw_pmatch);
  1253.     i = regexec(&re_Oops_i370_psw, line, re_Oops_i370_psw.re_nsub+1,
  1254. re_Oops_i370_psw_pmatch, 0);
  1255.     DEBUG(4, "regexec %d", i);
  1256.     if (i == 0) {
  1257. re_string_check(re_Oops_i370_psw.re_nsub+1, string_max, procname);
  1258. re_strings(&re_Oops_i370_psw, line, re_Oops_i370_psw_pmatch,
  1259.     string);
  1260. return((*string)[re_Oops_i370_psw.re_nsub]);
  1261.     }
  1262.     return(NULL);
  1263. }
  1265. /* Set the i370 PSW from the PSW line */
  1266. static void Oops_set_i370_psw(const char *value, SYMBOL_SET *ss,
  1267.       const char *me, const bfd *ibfd,
  1268.       OPTIONS *options)
  1269. {
  1270.     static const char procname[] = "Oops_set_i370_psw";
  1271.     addr_t PSW;
  1272.     /* Ensure target is set so EIP text is correct */
  1273.     Oops_set_default_ta(me, ibfd, options);
  1274.     PSW = hexstring(value);
  1275.     if (errno) {
  1276. ERROR(" Invalid hex value in PSW line, ignored - '%s'", value);
  1277. perror(prefix);
  1278. PSW = 0;
  1279.     }
  1280.     PSW = Oops_truncate_address(PSW, options);
  1281.     add_symbol_n(ss, PSW, 'E', 1, ">>PSW;");
  1282. }
  1284. /* Look for the s390 PSW line, returns start of the relevant hex value */
  1285. static char *Oops_s390_psw(const char *line, char ***string, int string_max)
  1286. {
  1287.     int i;
  1288.     static regex_t     re_Oops_s390_psw;
  1289.     static regmatch_t *re_Oops_s390_psw_pmatch;
  1290.     static const char procname[] = "Oops_s390_psw";
  1292.     /* Oops 'Kernel PSW:' line for s390, PSW at start of line, value is
  1293.      * second address.
  1294.      */
  1295.     RE_COMPILE(&re_Oops_s390_psw,
  1296.     "^Kernel PSW: *"
  1297.     UNBRACKETED_ADDRESS /* flags */
  1298.     UNBRACKETED_ADDRESS,
  1299. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  1300. &re_Oops_s390_psw_pmatch);
  1302.     i = regexec(&re_Oops_s390_psw, line, re_Oops_s390_psw.re_nsub+1,
  1303. re_Oops_s390_psw_pmatch, 0);
  1304.     DEBUG(4, "regexec %d", i);
  1305.     if (i == 0) {
  1306. re_string_check(re_Oops_s390_psw.re_nsub+1, string_max, procname);
  1307. re_strings(&re_Oops_s390_psw, line, re_Oops_s390_psw_pmatch,
  1308.     string);
  1309. return((*string)[re_Oops_s390_psw.re_nsub]);
  1310.     }
  1311.     return(NULL);
  1312. }
  1314. /* No need for Oops_set_s390_psw, can use Oops_set_i370_psw for both */
  1315. #define Oops_set_s390_psw(line, string, me, ibfd, options) 
  1316. Oops_set_i370_psw(line, string, me, ibfd, options)
  1318. /* Extract ppc registers. */
  1319. static void Oops_ppc_regs(const char *line, SYMBOL_SET *ss, const OPTIONS *options)
  1320. {
  1321.     int i, reg_num;
  1322.     addr_t reg;
  1323.     char regname[9];
  1324.     char **string = NULL;
  1325.     const char *p;
  1326.     static regex_t     re_Oops_ppc_regs;
  1327.     static regmatch_t *re_Oops_ppc_regs_pmatch;
  1328.     static const char procname[] = "Oops_ppc_regs";
  1330.     RE_COMPILE(&re_Oops_ppc_regs,
  1331.     "^(GPR[0-9]{1,2}) *: *" /* 1 */
  1332.     UNBRACKETED_ADDRESS /* 2 */
  1333.     ,
  1334. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  1335. &re_Oops_ppc_regs_pmatch);
  1337.     i = regexec(&re_Oops_ppc_regs, line, re_Oops_ppc_regs.re_nsub+1,
  1338. re_Oops_ppc_regs_pmatch, 0);
  1339.     DEBUG(4, "regexec %d", i);
  1340.     if (i)
  1341. return;
  1342.     p = line + re_Oops_ppc_regs_pmatch[0].rm_so + 3;
  1343.     reg_num = strtoul(p, NULL, 10);
  1344.     p = line + re_Oops_ppc_regs_pmatch[2].rm_so;
  1345.     /* Loop over unbracketed addresses */
  1346.     while (1) {
  1347. if (regexec(&re_unbracketed_address, p, re_unbracketed_address.re_nsub+1,
  1348.     re_unbracketed_address_pmatch, 0) == 0) {
  1349.     re_strings(&re_unbracketed_address, p, re_unbracketed_address_pmatch, &string);
  1350.     reg = hexstring(string[1]); /* contents */
  1351.     if (errno) {
  1352. ERROR(" Invalid hex value in register line, ignored - '%s'",
  1353.       string[1]);
  1354. perror(prefix);
  1355. break;
  1356.     }
  1357.     reg = Oops_truncate_address(reg, options);
  1358.     snprintf(regname, sizeof(regname), ">>GPR%d;", reg_num);
  1359.     add_symbol_n(ss, reg, 'R', 1, regname);
  1360.     p += re_unbracketed_address_pmatch[0].rm_eo;
  1361.     ++reg_num;
  1362. }
  1363. else
  1364.     break;
  1365.     }
  1367.     if (*p)
  1368. WARNING("garbage '%s' at end of ppc register line ignored", p);
  1369.     re_strings_free(&re_unbracketed_address, &string);
  1370. }
  1372. /* Look for the Trace multilines :(.  Returns start of addresses. */
  1373. static const char *Oops_trace(const char *line)
  1374. {
  1375.     int i;
  1376.     const char *start = NULL;
  1377.     static int trace_line = 0;
  1378.     static regex_t     re_Oops_trace;
  1379.     static regmatch_t *re_Oops_trace_pmatch;
  1380.     static const char procname[] = "Oops_trace";
  1382.     /* Oops 'Trace' lines.  The ikd patch adds "(nn)" for the stack frame size
  1383.      * after each trace entry, it should appear on the same line as the
  1384.      * bracketed address.  Alas users have been known to split lines so "(nn)"
  1385.      * appears at the start of the continuation line, look for that as well.
  1386.      * Life would be so much easier without users.
  1387.      * The person who did the s390 trace obviously did not like any of the ways
  1388.      * that other Linux kernels report problems so they invented a system all on
  1389.      * their own.  It is different from the i370 trace and even more ambiguous
  1390.      * than the other trace formats.  That is what happens when code is written
  1391.      * in secret!
  1392.      */
  1393.     RE_COMPILE(&re_Oops_trace,
  1394.     "^("      /* 1 */
  1395.     "(Call Trace: *)"      /* 2 */
  1396.     /* alpha */     "|(Trace:)"      /* 3 */
  1397.     /* various */   "|(" BRACKETED_ADDRESS ")"      /* 4,5 */
  1398.     /* ppc */     "|(Call backtrace:)"      /* 6 */
  1399.     /* ppc, s390 */ "|" UNBRACKETED_ADDRESS      /* 7 */
  1400.     /* arm */     "|Function entered at (" BRACKETED_ADDRESS ")"   /* 8,9 */
  1401.     /* sparc64 */   "|Caller\[" UNBRACKETED_ADDRESS "\]"      /* 10 */
  1402.     /* i386 */     "|(" REVBRACKETED_ADDRESS ")"      /* 11,12 */
  1403.     /* ikd patch */ "|(\([0-9]+\) *(" BRACKETED_ADDRESS "))"      /* 13,14,15 */
  1404.     /* i370 */     "|([0-9]+ +base=0x" UNBRACKETED_ADDRESS ")"      /* 16,17 */
  1405.     /* s390 */     "|(Kernel BackChain.*)"                          /* 18    */
  1406.     ")",
  1407. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  1408. &re_Oops_trace_pmatch);
  1410.     i = regexec(&re_Oops_trace, line, re_Oops_trace.re_nsub+1,
  1411. re_Oops_trace_pmatch, 0);
  1412.     DEBUG(4, "regexec %d", i);
  1413.     if (i == 0) {
  1414. #undef MATCHED
  1415. #define MATCHED(n) (re_Oops_trace_pmatch[n].rm_so != -1)
  1416. if (MATCHED(2) || MATCHED(3)) {
  1417.     /* Most start lines */
  1418.     trace_line = 1;
  1419.     start = line + re_Oops_trace_pmatch[0].rm_eo;
  1420. }
  1421. else if (MATCHED(6)) {
  1422.     /* ppc start line, not a bracketed address, just an address */
  1423.     trace_line = 2;     /* ppc */
  1424.     start = line + re_Oops_trace_pmatch[0].rm_eo;
  1425. }
  1426. else if (MATCHED(8)) {
  1427.     /* arm only line, two bracketed addresses on each line */
  1428.     trace_line = 3;
  1429.     start = line + re_Oops_trace_pmatch[8].rm_so;
  1430. }
  1431. else if (MATCHED(10)) {
  1432.     /* sparc64 only line, one unbracketed address */
  1433.     trace_line = 3;
  1434.     start = line + re_Oops_trace_pmatch[10].rm_so;
  1435. }
  1436. else if (MATCHED(17)) {
  1437.     /* i370 only line, one unbracketed address */
  1438.     trace_line = 3;
  1439.     start = line + re_Oops_trace_pmatch[17].rm_so;
  1440. }
  1441. else if (MATCHED(18)) {
  1442.     /* s390 only line, no addresses on this line */
  1443.     trace_line = 4;
  1444.     start = line + re_Oops_trace_pmatch[18].rm_eo;
  1445. }
  1446. else if (MATCHED(11)) {
  1447.     /* Reversed addresses for spinloops :( */
  1448.     trace_line = 1;
  1449.     start = line + re_Oops_trace_pmatch[11].rm_so;
  1450. }
  1451. else if (trace_line == 1 && MATCHED(4))
  1452.     /* Most continuation lines */
  1453.     start = line + re_Oops_trace_pmatch[4].rm_so;
  1454. else if (trace_line == 1 && MATCHED(14))
  1455.     /* incorrectly split trace lines from ikd patch */
  1456.     start = line + re_Oops_trace_pmatch[14].rm_so;
  1457. else if ((trace_line == 2 || trace_line == 4) && MATCHED(7))
  1458.     /* ppc/s390 continuation line */
  1459.     start = line + re_Oops_trace_pmatch[7].rm_so;
  1460. else
  1461.     trace_line = 0;
  1462.     }
  1463.     else
  1464. trace_line = 0;
  1465.     if (trace_line) {
  1466. if (trace_line == 3)
  1467.     trace_line = 0; /* no continuation lines */
  1468. return(start);
  1469.     }
  1470.     return(NULL);
  1471. }
  1473. /* Process a trace call line, extract addresses */
  1474. static void Oops_trace_line(const char *line, const char *p, SYMBOL_SET *ss,
  1475.     const OPTIONS *options)
  1476. {
  1477.     char **string = NULL;
  1478.     regex_t *pregex;
  1479.     regmatch_t *pregmatch;
  1480.     static regex_t     re_ikd;
  1481.     static regmatch_t *re_ikd_pmatch;
  1482.     static const char procname[] = "Oops_trace_line";
  1484.     /* ikd adds "(nn)" for stack frame size after each 'Trace' field. */
  1485.     RE_COMPILE(&re_ikd,
  1486.     "^(\([0-9]+\) *)",
  1487. REG_NEWLINE|REG_EXTENDED,
  1488. &re_ikd_pmatch);
  1490.     /* ppc/s390 does not bracket its addresses */
  1491.     if (isxdigit(*p)) {
  1492. pregex = &re_unbracketed_address;
  1493. pregmatch = re_unbracketed_address_pmatch;
  1494.     }
  1495.     else if (strncmp(p, "<[", 2) == 0) {
  1496. /* I hate special cases! */
  1497. pregex = &re_revbracketed_address;
  1498. pregmatch = re_revbracketed_address_pmatch;
  1499.     }
  1500.     else {
  1501. pregex = &re_bracketed_address;
  1502. pregmatch = re_bracketed_address_pmatch;
  1503.     }
  1505.     /* Loop over (un|rev)?bracketed addresses */
  1506.     while (1) {
  1507. if (regexec(pregex, p, pregex->re_nsub+1, pregmatch, 0) == 0) {
  1508.     addr_t addr;
  1509.     re_strings(pregex, p, pregmatch, &string);
  1510.     addr = hexstring(string[1]);
  1511.     addr = Oops_truncate_address(addr, options);
  1512.     add_symbol_n(ss, addr, 'T', 1, "Trace;");
  1513.     p += pregmatch[0].rm_eo;
  1514. }
  1515. else if (strncmp(p, "from ", 5) == 0)
  1516.     p += 5;     /* arm does "address from address" */
  1517. else if (regexec(&re_ikd, p, re_ikd.re_nsub+1, re_ikd_pmatch, 0) == 0)
  1518.     p += re_ikd_pmatch[0].rm_eo;  /* step over ikd stack frame size */
  1519. else
  1520.     break;
  1521.     }
  1523.     if (*p && !strcmp(p, "..."))
  1524. WARNING("garbage '%s' at end of trace line ignored", p);
  1525.     re_strings_free(pregex, &string);
  1526. }
  1528. /* Decide if the line contains CRIS registers.  Returns first register name. */
  1529. static const char *Oops_cris_regs(const char *line)
  1530. {
  1531.     int i;
  1532.     static const char procname[] = "Oops_cris_regs";
  1534.     /* Note that most of the register dump, the r0: to oR10: lines, are
  1535.        handled by Oops_regs.  */
  1536.     RE_COMPILE(&re_Oops_cris_regs,
  1537.     "^(IRP|SRP|D?CCR|USP|MOF): *" UNBRACKETED_ADDRESS,
  1538. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  1539. &re_Oops_cris_regs_pmatch);
  1541.     i = regexec(&re_Oops_cris_regs, line, re_Oops_cris_regs.re_nsub+1,
  1542. re_Oops_cris_regs_pmatch, 0);
  1543.     DEBUG(4, "regexec %d", i);
  1544.     if (i == 0)
  1545. return(line + re_Oops_cris_regs_pmatch[0].rm_so);
  1546.     return(NULL);
  1547. }
  1549. /* Process a CRIS register line, extract addresses */
  1550. static void Oops_set_cris_regs(const char *line, const char *p,
  1551.        SYMBOL_SET *ss, const OPTIONS *options)
  1552. {
  1553.     addr_t reg;
  1554.     char regname[7];
  1555.     char **string = NULL;
  1556.     static const char procname[] = "Oops_set_cris_regs";
  1558.     /* Loop over CRIS register names and unbracketed addresses.  */
  1559.     while (1) {
  1560. if (regexec(&re_Oops_cris_regs, p, re_Oops_cris_regs.re_nsub+1,
  1561.     re_Oops_cris_regs_pmatch, 0) == 0) {
  1562.     re_strings(&re_Oops_cris_regs, p, re_Oops_cris_regs_pmatch, &string);
  1563.     reg = hexstring(string[2]); /* contents */
  1564.     if (errno) {
  1565. ERROR(" Invalid hex value in CRIS register line, ignored - '%s'",
  1566.       string[2]);
  1567. perror(prefix);
  1568. reg = 0;
  1569.     }
  1570.     else {
  1571.       reg = Oops_truncate_address(reg, options);
  1572.       strcpy(regname, ">>");
  1573.       strncpy(regname+2, string[1], sizeof(regname)-3);
  1574.       strcat(regname, ";");
  1575.       add_symbol_n(ss, reg, 'R', 1, regname);
  1576.     }
  1577.     p += re_Oops_cris_regs_pmatch[0].rm_eo;
  1578. }
  1579. else
  1580.     break;
  1581.     }
  1583.     if (*p)
  1584. WARNING("garbage '%s' at end of CRIS register line ignored", p);
  1585.     re_strings_free(&re_Oops_cris_regs, &string);
  1586. }
  1588. /* Decide if the line contains s390 registers.  Returns first register value.
  1589.  * This is messier than the trace lines.  The heading is on one line followed by
  1590.  * the registers with *NO* keywords.  Fine for a dedicated JESMSG file, very
  1591.  * poor design for a multi-user log system.
  1592.  */
  1593. static const char *Oops_s390_regs(const char *line)
  1594. {
  1595.     int i;
  1596.     static regex_t     re_Oops_s390_regs;
  1597.     static regmatch_t *re_Oops_s390_regs_pmatch;
  1598.     static const char procname[] = "Oops_s390_regs";
  1600.     RE_COMPILE(&re_Oops_s390_regs,
  1601.     "^(Kernel GPRS.*)",
  1602. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  1603. &re_Oops_s390_regs_pmatch);
  1605.     i = regexec(&re_Oops_s390_regs, line, re_Oops_s390_regs.re_nsub+1,
  1606. re_Oops_s390_regs_pmatch, 0);
  1607.     DEBUG(4, "regexec %d", i);
  1608.     if (i == 0) {
  1609. s390_reg_num = 0;  /* Start with R0 */
  1610. return(line + re_Oops_s390_regs_pmatch[0].rm_eo);
  1611.     }
  1612.     else if (s390_reg_num >= 0) /* Header already seen */ {
  1613. i = regexec(&re_unbracketed_address, line,
  1614.     re_unbracketed_address.re_nsub+1,
  1615.     re_unbracketed_address_pmatch, 0);
  1616. DEBUG(4, "regexec %d", i);
  1617. if (i == 0)
  1618.     return(line + re_unbracketed_address_pmatch[0].rm_so);
  1619.     }
  1620.     s390_reg_num = -1;  /* Not processing s390 registers */
  1621.     return(NULL);
  1622. }
  1624. /* Process a s390 register line, extract addresses */
  1625. static void Oops_set_s390_regs(const char *line, const char *p,
  1626.        SYMBOL_SET *ss, const OPTIONS *options)
  1627. {
  1628.     addr_t reg;
  1629.     char regname[7];
  1630.     char **string = NULL;
  1631.     static const char procname[] = "Oops_set_s390_regs";
  1633.     /* Loop over s390 unbracketed register values.  No keywords so we have to
  1634.      * synthesize the register numbers ourselves, yuck!
  1635.      */
  1636.     while (1) {
  1637. if (regexec(&re_unbracketed_address, p,
  1638.     re_unbracketed_address.re_nsub+1,
  1639.     re_unbracketed_address_pmatch, 0) == 0) {
  1640.     re_strings(&re_unbracketed_address, p,
  1641. re_unbracketed_address_pmatch, &string);
  1642.     reg = hexstring(string[1]); /* contents */
  1643.     if (errno) {
  1644. ERROR(" Invalid hex value in s390 register line, ignored - '%s'",
  1645.       string[1]);
  1646. perror(prefix);
  1647. reg = 0;
  1648.     }
  1649.     reg = Oops_truncate_address(reg, options);
  1650.     strcpy(regname, ">>");
  1651.     snprintf(regname, sizeof(regname), "r%-2d;  ", s390_reg_num);
  1652.     add_symbol_n(ss, reg, 'R', 1, regname);
  1653.     p += re_unbracketed_address_pmatch[0].rm_eo;
  1654.     ++s390_reg_num;
  1655. }
  1656. else
  1657.     break;
  1658.     }
  1660.     if (*p)
  1661. WARNING("garbage '%s' at end of s390 register line ignored", p);
  1662.     re_strings_free(&re_unbracketed_address, &string);
  1663. }
  1665. /* Do pattern matching to decide if the line should be printed.  When reading a
  1666.  * syslog containing multiple Oops, you need the intermediate data (registers,
  1667.  * tss etc.) to go with the decoded text.  Sets text to the start of the useful
  1668.  * text, after any prefix.  Note that any leading white space is treated as part
  1669.  * of the prefix, later routines do not see any indentation.
  1670.  *
  1671.  * Note: If a line is not printed, it will not be scanned for any other text.
  1672.  */
  1674. #ifdef TIME_RE
  1675. /* time the re code */
  1676. #include <sys/time.h>
  1677. struct timeval before, after;
  1678. long long diff[30];
  1679. int count[30];
  1680. #define START gettimeofday(&before, NULL);
  1681. #define DIFF(n) gettimeofday(&after, NULL); 
  1682. ++count[n]; 
  1683. diff[n] += (after.tv_sec - before.tv_sec)*1000001 + (after.tv_usec - before.tv_usec); 
  1684. before = after;
  1685. #else
  1686. #define START
  1687. #define DIFF(n)
  1688. #endif
  1690. static int Oops_print(const char *line, const char **text, char ***string,
  1691.       int string_max)
  1692. {
  1693.     int i, print = 0;
  1694.     static int stack_line = 0, trace_line = 0;
  1695.     static regex_t     re_Oops_prefix;
  1696.     static regmatch_t *re_Oops_prefix_pmatch;
  1697.     static regex_t     re_Oops_print_s;
  1698.     static regmatch_t *re_Oops_print_s_pmatch;
  1699.     static regex_t     re_Oops_print_a;
  1700.     static regmatch_t *re_Oops_print_a_pmatch;
  1701.     static const char procname[] = "Oops_print";
  1703.     START
  1705.     *text = line;
  1707.     /* Lines to be ignored.  For some reason the "amuse the user" print in
  1708.      * some die_if_kernel routines causes regexec to run very slowly.
  1709.      */
  1711.     if (strstr(*text, "\|/ ____ \|/")  ||
  1712. strstr(*text, ""@'/ ,. \`@"") ||
  1713. strstr(*text, ""@'/ .. \`@"") ||
  1714. strstr(*text, "/_| \__/ |_\")  ||
  1715. strstr(*text, "   \__U_/"))
  1716. return(1);  /* print but avoid regexec */
  1718.     DIFF(1);
  1720.     /* Trial and error with regex leads me to the following conclusions.
  1721.      *
  1722.      * regex does not like a lot of sub patterns that start with "^".  So split
  1723.      * the patterns into two groups, one set must appear at the start of the
  1724.      * line, the other set can appear anywhere.
  1725.      *
  1726.      * Lots of bracketed subexpressions really slows regex down.  Only use
  1727.      * brackets where absolutely necessary.  Examples are where you want to
  1728.      * extract matching substrings such as stack, call trace etc.  Or where
  1729.      * you have suboptions within a string, like the sparc die_if_kernel text.
  1730.      * Otherwise omit brackets, except that every re should have at least one
  1731.      * bracketed expression, that is how RE_COMPILE tells if the expression
  1732.      * has already been compiled.
  1733.      */
  1735.     /* Prefixes to be ignored.  These prefixes were originally done as
  1736.      * ^((pattern1)|(pattern2)|(pattern3))+  but that caused pathological
  1737.      * behaviour in regexec when faced with lines like
  1738.      *                     : "=r" (__cu_len), "=r" (__cu_from), "=r" (__cu_to)
  1739.      * Would you believe 11 seconds just to resolve that one line :(.  So just
  1740.      * look for one prefix at a time and loop until all prefixes are stripped.
  1741.      */
  1742.     RE_COMPILE(&re_Oops_prefix,
  1743.     "^(" /* start of line */
  1744.     " +" /* leading spaces */
  1745.     "|[^ ]{3} [ 0-9][0-9] [0-9]{2}:[0-9]{2}:[0-9]{2} "
  1746.       "[^ ]+ kernel: +" /* syslogd */
  1747.     "|<[0-9]+>" /* kmsg */
  1748.     "|[0-9]+\|[^|]+\|[^|]+\|[^|]+\|" /* syslog-ng */
  1749.     "|[0-9][AC] [0-9]{3} [0-9]{3}[cir][0-9]{2}:" /* SNIA */
  1750.     "\+" /* leading '+' */
  1751.     ")",
  1752. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  1753. &re_Oops_prefix_pmatch);
  1755.     do {
  1756. i = regexec(&re_Oops_prefix, *text, re_Oops_prefix.re_nsub+1,
  1757.     re_Oops_prefix_pmatch, 0);
  1758. DEBUG(4, "regexec prefix %d", i);
  1759. if (i == 0)
  1760.     *text += re_Oops_prefix_pmatch[0].rm_eo;  /* step over prefix */
  1761.     } while (i == 0);
  1763.     DIFF(2);
  1765.     /* Lots of possibilities.  Expand as required for all architectures. */
  1767.     /* These patterns must appear at the start of the line, after stripping
  1768.      * the prefix above.
  1769.      *
  1770.      * The order below is required to handle multiline outupt.
  1771.      * string 2 is defined if the text is 'Stack from '.
  1772.      * string 3 is defined if the text is 'Stack: '.
  1773.      * string 4 is defined if the text might be a stack continuation.
  1774.      * string 5 is defined if the text is 'Call Trace: *'.
  1775.      * string 6 is defined if the text might be a trace continuation.
  1776.      * string 7 is the address part of the BRACKETED_ADDRESS.
  1777.      *
  1778.      * string 8 is defined if the text contains a version number.  No Oops
  1779.      * report contains this as of 2.1.125 but IMHO it should be added.  If
  1780.      * anybody wants to print a VERSION_nnnn line in their Oops, this code
  1781.      * is ready.
  1782.      *
  1783.      * string 9 is defined if the text is 'Trace:' (alpha).
  1784.      * string 10 is defined if the text is 'Call backtrace:' (ppc, i370).
  1785.      * string 11 is defined if the text is 'bh:' (i386).  Stack addresses are
  1786.      * on the next line.  In our typical inconsistent manner, the bh: stack
  1787.      * addresses are different from every other address, they are <[...]>
  1788.      * instead of [<...>] so define yet another re, string 12.  Sigh.
  1789.      *
  1790.      * The ikd patch adds "(nn)" for the stack frame size after each trace
  1791.      * entry, it should appear on the same line as the bracketed address.  Alas
  1792.      * users have been known to split lines so "(nn)" appears at the start of
  1793.      * the continuation line, look for that as well.  Life would be so much
  1794.      * easier without users.  Andi Kleen's multi cpu traceback patch adds the
  1795.      * module name as "(name)" after addresses.  Strings 13 and 14 are
  1796.      * a special case of strings 6 and 7 to handle "(nn)" and "(name)",
  1797.      * in fact anything in "()" between addresses is ignored.
  1798.      *
  1799.      * Both ppc and i370 use 'Call backtrace:' but the i370 data is completely
  1800.      * different from anything else.  It starts on a separate line and consists
  1801.      * of multiple lines, each containing a number (trace depth), base=, link=,
  1802.      * stack=.
  1803.      *
  1804.      * s390 decided to do their own thing instead of using the same format as
  1805.      * i370.  A bad case of "not invented here".  s390 data starts on a separate
  1806.      * line and consists of multiple addresses.
  1807.      *
  1808.      * The SGI kdb backtrace for ix86 prints EBP and EIP, one per line after the
  1809.      * header.
  1810.      *
  1811.      * Some strings indicate stack data (S), some indicate trace data (T).
  1812.      */
  1813.     RE_COMPILE(&re_Oops_print_s,
  1814.     /* arch type */ /* Required order */
  1815. "^(" /*  1 */
  1816.     /* i386 */     "(Stack: )" /*  2  S */
  1817.     /* m68k */     "|(Stack from )" /*  3  S */
  1818.     /* various */   "|([0-9a-fA-F]{4,})" /*  4  S,T */
  1819.     /* various */   "|(Call Trace: *)" /*  5  T */
  1820.     /* various */   "|(" BRACKETED_ADDRESS ")" /* 6,7 T */
  1821.     /* various */   "|(Version_[0-9]+)" /*  8 */
  1822.     /* alpha */     "|(Trace:)" /*  9  T */
  1823.     /* ppc, i370 */ "|(Call backtrace:)" /* 10  T */
  1824.     /* i386 */     "|(bh:)" /* 11  T */
  1825.     /* i386 */     "|" REVBRACKETED_ADDRESS /* 12  T */
  1826.     /* ikd/AK */    "|(\([^ ]+\) *" /* 13  T */
  1827.       BRACKETED_ADDRESS ")" /* 14    */
  1828.     /* i370 */     "|([0-9]+ +base=)" /* 15  T */
  1829.     /* s390 */     "|(Kernel BackChain)" /* 16  T */
  1830.     /* kdb ix86 */  "|EBP *EIP" /* 17  T */
  1831.     /* kdb ix86 */  "|0x" UNBRACKETED_ADDRESS "0x" UNBRACKETED_ADDRESS /* 18, 19 T */
  1834.     /* order does not matter from here on */
  1836.     /* various */   "|Process .*stackpage="
  1837.     /* various */   "|Code *: "
  1838.     /* various */   "|Kernel panic"
  1839.     /* various */   "|In swapper task"
  1840.     /* various */   "|kmem_free"
  1841.     /* various */   "|swapper"
  1842.     /* various */   "|Pid:"
  1843.     /* various */   "|r[0-9]{1,2} *[:=]" /* generic register dump */
  1845.     /* i386 2.0 */  "|Corrupted stack page"
  1846.     /* i386 */     "|invalid operand: "
  1847.     /* i386 */     "|Oops: "
  1848.     /* i386 */     "|Cpu:* +[0-9]"
  1849.     /* i386 */     "|current->tss"
  1850.     /* i386 */     "|\*pde +="
  1851.     /* i386 */     "|EIP: "
  1852.     /* i386 */     "|EFLAGS: "
  1853.     /* i386 */     "|eax: "
  1854.     /* i386 */     "|esi: "
  1855.     /* i386 */     "|ds: "
  1856.     /* i386 */     "|CR0: "
  1857.     /* i386 */     "|wait_on_"
  1858.     /* i386 */     "|irq: "
  1859.     /* i386 */     "|Stack dumps:"
  1861.     /* x86_64 */    "|RAX: "
  1862.     /* x86_64 */    "|RSP: "
  1863.     /* x86_64 */    "|RIP: "
  1864.     /* x86_64 */    "|RDX: "
  1865.     /* x86_64 */    "|RBP: "
  1866.     /* x86_64 */    "|FS: "
  1867.     /* x86_64 */    "|CS: "
  1868.     /* x86_64 */    "|CR2: "
  1869.     /* x86_64 */    "|PML4"
  1871.     /* m68k */     "|pc[:=]"
  1872.     /* m68k */     "|68060 access"
  1873.     /* m68k */     "|Exception at "
  1874.     /* m68k */     "|d[04]: "
  1875.     /* m68k */     "|Frame format="
  1876.     /* m68k */     "|wb [0-9] stat"
  1877.     /* m68k */     "|push data: "
  1878.     /* m68k */     "|baddr="
  1879.     /* any other m68K lines to print? */
  1881.     /* alpha */     "|Arithmetic fault"
  1882.     /* alpha */     "|Instruction fault"
  1883.     /* alpha */     "|Bad unaligned kernel"
  1884.     /* alpha */     "|Forwarding unaligned exception"
  1885.     /* alpha */     "|: unhandled unaligned exception"
  1886.     /* alpha */     "|pc *="
  1887.     /* alpha */     "|[rvtsa][0-9]+ *=" /* Changed from r to [vtsa] in 2.2.14 */
  1888.     /* alpha */     "|gp *="
  1889.     /* alpha */     "|spinlock stuck"
  1890.     /* any other alpha lines to print? */
  1892.     /* sparc */     "|tsk->"
  1893.     /* sparc */     "|PSR: "
  1894.     /* sparc */     "|[goli]0: "
  1895.     /* sparc */     "|Instruction DUMP: "
  1896.     /* sparc */     "|spin_lock"
  1897.     /* any other sparc lines to print? */
  1899.     /* sparc64 */   "|TSTATE: "
  1900.     /* sparc64 */   "|[goli]4: "
  1901.     /* sparc64 */   "|Caller\["
  1902.     /* sparc64 */   "|CPU\["
  1903.     /* any other sparc64 lines to print? */
  1905.     /* ppc */     "|MSR: "
  1906.     /* ppc */     "|TASK = "
  1907.     /* ppc */     "|last math "
  1908.     /* ppc */     "|GPR[0-9]+: "
  1909.     /* any other ppc lines to print? */
  1911.     /* mips */     "|.* in .*\.[ch]:.*, line [0-9]+:"
  1912.     /* mips */     "|\$[0-9 ]+:"
  1913.     /* mips */     "|Hi *:"
  1914.     /* mips */     "|Lo *:"
  1915.     /* mips */     "|epc *:"
  1916.     /* mips */     "|badvaddr *:"
  1917.     /* mips */     "|Status *:"
  1918.     /* mips */     "|Cause *:"
  1919.     /* any other mips lines to print? */
  1921.     /* arm */     "|Backtrace:"
  1922.     /* arm */     "|Function entered at"
  1923.     /* arm */     "|\*pgd ="
  1924.     /* arm */     "|Internal error"
  1925.     /* arm */     "|pc :"
  1926.     /* arm */     "|sp :"
  1927.     /* arm */     "|Flags:"
  1928.     /* arm */     "|Control:"
  1929.     /* any other arm lines to print? */
  1931.     /* ikd patch */ "|WARNING:"
  1932.     /* ikd patch */ "|this_stack:"
  1933.     /* ikd patch */ "|i:"
  1934.     /* any other ikd lines to print? */
  1936.     /* i370 */     "|PSW"
  1937.     /* i370 */     "|cr[0-9]+:"
  1938.     /* i370 */     "|machine check"
  1939.     /* i370 */     "|Exception in "
  1940.     /* i370 */     "|Program Check "
  1941.     /* i370 */     "|System restart "
  1942.     /* i370 */     "|IUCV "
  1943.     /* i370 */     "|unexpected external "
  1944.     /* i370 */     "|Kernel stack "
  1945.     /* any other i370 lines to print? */
  1947.     /* s390 */     "|User process fault:"
  1948.     /* s390 */     "|failing address"
  1949.     /* s390 */     "|User PSW"
  1950.     /* s390 */     "|User GPRS"
  1951.     /* s390 */     "|User ACRS"
  1952.     /* s390 */     "|Kernel PSW"
  1953.     /* s390 */     "|Kernel GPRS"
  1954.     /* s390 */     "|Kernel ACRS"
  1955.     /* s390 */     "|illegal operation"
  1956.     /* s390 */     "|task:"
  1957.     /* any other s390 lines to print? */
  1959.     /* SGI kdb */ "|Entering kdb"
  1960.     /* SGI kdb */ "|eax *="
  1961.     /* SGI kdb */ "|esi *="
  1962.     /* SGI kdb */ "|ebp *="
  1963.     /* SGI kdb */ "|ds *="
  1964.     /* any other SGI kdb lines to print? */
  1966.     /* ia64 */     "|psr "
  1967.     /* ia64 */     "|unat  "
  1968.     /* ia64 */     "|rnat "
  1969.     /* ia64 */     "|ldrs "
  1970.     /* ia64 */     "|xip "
  1971.     /* ia64 */     "|iip "
  1972.     /* ia64 */     "|ipsr "
  1973.     /* ia64 */     "|ifa "
  1974.     /* ia64 */     "|pr "
  1975.     /* ia64 */     "|itc "
  1976.     /* ia64 */     "|ifs "
  1977.     /* ia64 */     "|bsp "
  1978.     /* ia64 */     "|[bfr][0-9]+ "
  1979.     /* ia64 */     "|irr[0-9] "
  1980.     /* ia64 */     "|General Exception"
  1981.     /* ia64 */     "|MCA"
  1982.     /* ia64 */     "|SAL"
  1983.     /* ia64 */     "|Processor State"
  1984.     /* ia64 */     "|Bank [0-9]+"
  1985.     /* ia64 */     "|Register Stack"
  1986.     /* ia64 */     "|Processor Error Info"
  1987.     /* ia64 */     "|proc err map"
  1988.     /* ia64 */     "|proc state param"
  1989.     /* ia64 */     "|proc lid"
  1990.     /* ia64 */     "|processor structure"
  1991.     /* ia64 */     "|check info"
  1992.     /* ia64 */     "|target identifier"
  1993.     /* any other ia64 lines to print? */
  1995.     /* CRIS */     "|IRP *: "
  1996.     /* any other cris lines to print? */
  1998. ")",
  1999. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  2000. &re_Oops_print_s_pmatch);
  2002.     i = regexec(&re_Oops_print_s, *text, re_Oops_print_s.re_nsub+1,
  2003. re_Oops_print_s_pmatch, 0);
  2004.     DEBUG(4, "regexec start %d", i);
  2005.     DIFF(3);
  2006.     print = 0;
  2007. #undef MATCHED
  2008. #define MATCHED(n) (re_Oops_print_s_pmatch[n].rm_so != -1)
  2009.     DIFF(4);
  2010.     /* Handle multiline messages, messy.  Only treat strings that look like
  2011.      * addresses as useful when they immediately follow a definite stack or
  2012.      * trace header or a previously valid stack or trace line.
  2013.      * Because of the horribly ambiguous s390 register dump, unbracketed
  2014.      * addresses (string 4) can now be either stack or trace.  How not to design
  2015.      * dump output.
  2016.      */
  2017.     /* Stack lines */
  2018.     if (!MATCHED(2) && !MATCHED(3) && !MATCHED(4))
  2019. stack_line = 0;
  2020.     else if (MATCHED(2) || MATCHED(3))
  2021. stack_line = 1;
  2022.     else if (stack_line && !MATCHED(4))
  2023. stack_line = 0;
  2024.     /* Trace lines */
  2025.     if (!MATCHED(4) && !MATCHED(5) && !MATCHED(6) && !MATCHED(9) &&
  2026. !MATCHED(10) && !MATCHED(11) && !MATCHED(12) && !MATCHED(13) &&
  2027. !MATCHED(15) && !MATCHED(16) && !MATCHED(17) && !MATCHED(19))
  2028. trace_line = 0;
  2029.     else if (MATCHED(4) || MATCHED(5) || MATCHED(9) || MATCHED(10) ||
  2030. MATCHED(11) || MATCHED(15) || MATCHED(16) || MATCHED(17))
  2031. trace_line = 1;
  2032.     else if (trace_line && !MATCHED(4) && !MATCHED(6) && !MATCHED(12) &&
  2033. !MATCHED(13) && !MATCHED(19))
  2034. trace_line = 0;
  2035.     if (i == 0) {
  2036. print = 1;
  2037. if (MATCHED(4) && !stack_line && !trace_line) {
  2038.     print = 0;
  2039.     DEBUG(4, "%s", "ambiguous stack/trace line ignored");
  2040. }
  2041. if ((MATCHED(6) || MATCHED(12) || MATCHED(13)) && !trace_line) {
  2042.     print = 0;
  2043.     DEBUG(4, "%s", "ambiguous trace line ignored");
  2044. }
  2045.     }
  2046.     if (print && MATCHED(4)) {
  2047. /* Ambiguity with 3Com messages, a line like 3c503.c:v1.10 9/23/93
  2048.  * starts with 4 or more hex digits but is not an error message, instead
  2049.  * it is a filename.  Look for '.c:' before the first space and ignore
  2050.  * if found.  Also ad1848, look for '/' before first space.  Do not look
  2051.  * for ':' on its own, arm does "address: stack values" :(.
  2052.  *
  2053.  * Ambiguity of ambiguities, saith the preacher; all is ambiguity.
  2054.  */
  2055. const char *p1, *p2;
  2056. p2 = strstr(*text, " ");
  2057. if (p2) {
  2058.     if ((p1 = strstr(*text, ".c:")) && p1 < p2)
  2059. print = 0;  /* ignore ambiguous match */
  2060.     else if ((p1 = strstr(*text, "/")) && p1 < p2)
  2061. print = 0;  /* ignore ambiguous match */
  2062. }
  2063. if (!print)
  2064.     DEBUG(4, "%s", "ambiguous start ignored");
  2065.     }
  2066.     /* delay splitting into strings until we really them */
  2067.     if (print && MATCHED(8)) {
  2068. re_string_check(re_Oops_print_s.re_nsub+1, string_max,
  2069.     procname);
  2070. re_strings(&re_Oops_print_s, *text,
  2071.     re_Oops_print_s_pmatch,
  2072.     string);
  2073. add_Version((*string)[8]+8, "Oops");
  2074.     }
  2075.     DIFF(5);
  2077.     /* These patterns can appear anywhere in the line, after stripping
  2078.      * the prefix above.
  2079.      */
  2080.     RE_COMPILE(&re_Oops_print_a,
  2081.    /* arch type */
  2083.     /* various */   "Unable to handle kernel"
  2084.     /* various */   "|Aiee"      /* anywhere in text is a bad sign (TM) */
  2085.     /* various */   "|die_if_kernel"  /* ditto */
  2086.     /* various */   "|NMI "
  2087.     /* various */   "|BUG "
  2088.     /* various */   "|\(L-TLB\)"
  2089.     /* various */   "|\(NOTLB\)"
  2091.     /* alpha */     "|\([0-9]\): Oops "
  2092.     /* alpha */     "|: memory violation"
  2093.     /* alpha */     "|: Exception at"
  2094.     /* alpha */     "|: Arithmetic fault"
  2095.     /* alpha */     "|: Instruction fault"
  2096.     /* alpha */     "|: arithmetic trap"
  2097.     /* alpha */     "|: unaligned trap"
  2099.     /* sparc      die_if_kernel has no fixed text, identify by (pid): text.
  2100.      *            Somebody has been playful with the texts.
  2101.      *
  2102.      *            Alas adding this next pattern increases run time by 15% on
  2103.      *            its own!  It would be considerably faster if sparc had
  2104.      *            consistent error texts.
  2105.      */
  2106.     /* sparc */     "|\([0-9]+\): "
  2107. "("
  2108.     "Whee"
  2109.     "|Oops"
  2110.     "|Kernel"
  2111.     "|.*Penguin"
  2112.     "|BOGUS"
  2113. ")"
  2115.     /* ppc */       "|kernel pc "
  2116.     /* ppc */       "|trap at PC: "
  2117.     /* ppc */       "|bad area pc "
  2118.     /* ppc */       "|NIP: "
  2120.     /* mips */      "| ra *=="
  2122. ,
  2123. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  2124. &re_Oops_print_a_pmatch);
  2126.     if (!print) {
  2127. i = regexec(&re_Oops_print_a, *text, re_Oops_print_a.re_nsub+1,
  2128.     re_Oops_print_a_pmatch, 0);
  2129. DEBUG(4, "regexec anywhere %d", i);
  2130. if (i == 0)
  2131.     print = 1;
  2132.     }
  2133.     DIFF(6);
  2135.     return(print);
  2136. }
  2138. /* Look for the Code: line.  Returns start of the code bytes. */
  2139. static const char *Oops_code(const char *line, char ***string, int string_max)
  2140. {
  2141.     int i;
  2142.     char *p;
  2143.     static regex_t     re_Oops_code;
  2144.     static regmatch_t *re_Oops_code_pmatch;
  2145.     static const char procname[] = "Oops_code";
  2147.     /* Oops 'Code: ' hopefully followed by at least one hex code.  sparc
  2148.      * brackets the PC in '<' and '>'.  arm brackets the PC in '(' and ')'.
  2149.      */
  2150.     RE_COMPILE(&re_Oops_code,
  2151. "^(" /*  1 */
  2152.     /* various */ "(Instruction DUMP)" /*  2 */
  2153.     /* various */ "|(Code:? *)" /*  3 */
  2154. ")"
  2155. ": +"
  2156. "(" /*  4 */
  2157.   "(general protection.*)"
  2158.   "|(Bad E?IP value.*)"
  2159.   "|(<[0-9]+>)"
  2160.   "|(([<(]?[0-9a-fA-F]+[>)]? +)+[<(]?[0-9a-fA-F]+[>)]?)"
  2161. ")"
  2162. "(.*)$" /* trailing garbage */
  2163. ,
  2164. REG_NEWLINE|REG_EXTENDED|REG_ICASE,
  2165. &re_Oops_code_pmatch);
  2167.     i = regexec(&re_Oops_code, line, re_Oops_code.re_nsub+1,
  2168. re_Oops_code_pmatch, 0);
  2169.     DEBUG(4, "regexec %d", i);
  2170.     if (i == 0) {
  2171. re_string_check(re_Oops_code.re_nsub+1, string_max, procname);
  2172. re_strings(&re_Oops_code, line, re_Oops_code_pmatch,
  2173.     string);
  2174. if ((*string)[re_Oops_code.re_nsub] &&
  2175.     *((*string)[re_Oops_code.re_nsub])) {
  2176.     /* Performance fix to Code: re means that trailing space is no
  2177.      * longer part of the Code: text.  No point in complaining about
  2178.      * trailing space.
  2179.      */
  2180.     for (p = (*string)[re_Oops_code.re_nsub]; isspace(*p); ++p)
  2181. /* skip white space */ ;
  2182.     if (*p) {
  2183. WARNING("trailing garbage ignored on Code: linen"
  2184.     "  Text: '%s'n"
  2185.     "  Garbage: '%s'",
  2186.     line, (*string)[re_Oops_code.re_nsub]);
  2187.     }
  2188. }
  2189. return((*string)[4]);
  2190.     }
  2191.     return(NULL);
  2192. }
  2194. /******************************************************************************/
  2195. /*                      End architecture sensitive code                       */
  2196. /******************************************************************************/
  2198. /* Decode part or all of the Oops Code: via objdump. */
  2199. static void Oops_decode_part(const char* code, int code_size,
  2200.      addr_t eip, int adjust,
  2201.      const char type, SYMBOL_SET *ss,
  2202.      char ***string, int string_max,
  2203.      const bfd *ibfd, OPTIONS *options)
  2204. {
  2205.     FILE *f;
  2206.     char *file, *line = NULL;
  2207.     int size = 0, lines = 0;
  2208.     static char const procname[] = "Oops_decode_part";
  2210.     DEBUG(1, "%s", "");
  2211.     /* binary to same format as ksymoops */
  2212.     if (!(file = Oops_code_to_file(code, code_size, ibfd, options)))
  2213. return;
  2214.     /* objdump the pseudo object */
  2215.     if (!(f = Oops_objdump(file, options)))
  2216. return;
  2217.     while (fgets_local(&line, &size, f, procname)) {
  2218. DEBUG(2, "%s", line);
  2219. ++lines;
  2220. Oops_decode_one(ss, line, eip, adjust, type, options);
  2221.     }
  2222.     pclose_local(f, procname);  /* opened in Oops_objdump */
  2223.     free(line);
  2224.     if (!lines)
  2225. ERROR("no objdump lines read for %s", file);
  2226.     else if (unlink(file)) {
  2227. ERROR("could not unlink %s", file);
  2228. perror(prefix);
  2229.     }
  2230. }
  2232. /* Decode the Oops Code: via objdump. */
  2233. static void Oops_decode(const unsigned char* code_text, addr_t eip,
  2234. SYMBOL_SET *ss, char ***string, int string_max,
  2235. const bfd *ibfd, OPTIONS *options)
  2236. {
  2237.     char code[CODE_SIZE];
  2238.     int adjust;
  2239.     static char const procname[] = "Oops_decode";
  2241.     DEBUG(1, "%s", "");
  2242.     /* text to binary */
  2243.     if (!Oops_code_values(code_text, code, &adjust, options))
  2244. return;
  2245.     /* adjust is -ve number of bytes before eip */
  2246.     if (adjust && options->vli) {
  2247.     Oops_decode_part(code, -adjust, eip, adjust, 'U', ss, string, string_max, ibfd, options);
  2248.     Oops_decode_part(code-adjust, CODE_SIZE+adjust, eip, 0, 'C', ss, string, string_max, ibfd, options);
  2249.     } else {
  2250.     Oops_decode_part(code, CODE_SIZE, eip, adjust, 'C', ss, string, string_max, ibfd, options);
  2251.     }
  2252. }
  2254. /* Reached the end of an Oops report, format the extracted data. */
  2255. static void Oops_format(const SYMBOL_SET *ss_format, OPTIONS *options)
  2256. {
  2257.     int i;
  2258.     SYMBOL *s;
  2259.     addr_t eip = 0;
  2260.     char *eye_catcher, prev_type = '';
  2261.     static const char procname[] = "Oops_format";
  2263.     DEBUG(1, "%s", "");
  2265.     compare_Version();  /* Oops might have a version one day */
  2266.     printf("n");
  2267.     for (s = ss_format->symbol, i = 0; i < ss_format->used; ++i, ++s) {
  2268. /* For type C and U data, print Code:, address, map, "name" (actually
  2269.  * the text of an objdump line).  For type I (id) print the string.
  2270.  * For other types print name, address, map.
  2271.  */
  2272. if (s->type == 'C' || s->type == 'U') {
  2273.     if (prev_type != s->type) {
  2274. printf("n");
  2275. if (s->type == 'U')
  2276.     printf("This architecture has variable length instructions, decoding before eipn"
  2277.    "is unreliable, take these instructions with a pinch of salt.nn");
  2278. else if (prev_type == 'U')
  2279.     printf("This decode from eip onwards should be reliablenn");
  2280.     }
  2281.     eye_catcher = "";
  2282.     if (eip && i < ss_format->used-1 && (s+1)->type == s->type &&
  2283. eip >= s->address && eip < (s+1)->address)
  2284. eye_catcher = "   <=====";
  2285.     if (options->short_lines)
  2286. printf("Code;  %s %s%sn%s%sn",
  2287.     format_address(s->address, options),
  2288.     map_address(&ss_merged, s->address, options), eye_catcher,
  2289.     s->name, eye_catcher);
  2290.     else
  2291. printf("Code;  %s %-30s %s%sn",
  2292.     format_address(s->address, options),
  2293.     map_address(&ss_merged, s->address, options),
  2294.     s->name, eye_catcher);
  2295. }
  2296. else if (s->type == 'I') {
  2297.     printf("%sn", s->name);
  2298. }
  2299. else {
  2300.     /* Suppress registers that do not resolve to symbols */
  2301.     char *map = map_address(&ss_merged, s->address, options);
  2302.     if (s->type == 'R') {
  2303. if (index(map, '+') == NULL || strncmp(map, "<END_OF_CODE+", 13) == 0) {
  2304.     continue;
  2305. }
  2306.     }
  2307.     if (prev_type != s->type)
  2308. printf("n");
  2309.     printf("%s %s %s",
  2310. s->name, format_address(s->address, options), map);
  2311.     if (s->type == 'E') {
  2312. eip = s->address;
  2313. if (eip)
  2314.     printf("   <=====");
  2315.     }
  2316.     printf("n");
  2317. }
  2318. prev_type = s->type;
  2319.     }
  2320.     printf("n");
  2321. }
  2323. /* Select next Oops input file */
  2324. static FILE *Oops_next_file(OPTIONS *options)
  2325. {
  2326.     static FILE *f = NULL;
  2327.     static int first_file = 1;
  2328.     static const char procname[] = "Oops_next_file";
  2330.     if (first_file) {
  2331. f = stdin;
  2332. first_file = 0;
  2333.     }
  2334.     while (options->filecount) {
  2335. if (f)
  2336.     fclose_local(f, procname);
  2337. f = NULL;
  2338. if (strcmp(*(options->filename), "/dev/null") == 0 ||
  2339.     regular_file(*(options->filename), procname))
  2340.     f = fopen_local(*(options->filename), "r", procname);
  2341. if (f)
  2342.     DEBUG(1, "reading Oops report from %s", *(options->filename));
  2343. ++options->filename;
  2344. --options->filecount;
  2345. if (f)
  2346.     return(f);
  2347.     }
  2348.     return(f);
  2349. }
  2351. /* Read the Oops report */
  2352. #define MAX_STRINGS 300 /* Maximum strings in any Oops re */
  2353. int Oops_read(OPTIONS *options)
  2354. {
  2355.     char *line = NULL, **string = NULL, *me;
  2356.     const char *start, *text;
  2357.     int i, size = 0, lineno = 0, lastprint = 0, print;
  2358.     addr_t eip = 0;
  2359.     int sparc_regdump = 0;
  2360.     FILE *f;
  2361.     SYMBOL_SET ss_format;
  2362.     bfd *ibfd = NULL;
  2363.     static const char procname[] = "Oops_read";
  2365.     ss_init(&ss_format, "Oops log data");
  2366.     Oops_open_input_bfd(&me, &ibfd, options);
  2368.     if (options->adhoc_addresses) {
  2369. char **adhoc;
  2370. for (adhoc = options->adhoc_addresses; *adhoc; ++adhoc) {
  2371.     add_symbol(&ss_format, *adhoc, 'A', 1, "Adhoc");
  2372. }
  2373.     }
  2375.     if (!options->filecount && isatty(0))
  2376. printf("Reading Oops report from the terminaln");
  2378.     string = malloc(MAX_STRINGS*sizeof(*string));
  2379.     if (!string)
  2380. malloc_error(procname);
  2381.     memset(string, '', MAX_STRINGS*sizeof(*string));
  2383.     do {
  2384. if (!(f = Oops_next_file(options)))
  2385.     continue;
  2386. while (fgets_local(&line, &size, f, procname)) {
  2387.     DEBUG(3, "%s", line);
  2388.     ++lineno;
  2389.     print = Oops_print(line, &text, &string, MAX_STRINGS);
  2390.     if (print && Oops_sparc_regdump(text, &string)) {
  2391. sparc_regdump = 1;
  2392.     } else {
  2393. if (options->target &&
  2394.     strstr(options->target, "sparc") &&
  2395.     sparc_regdump &&
  2396.     ss_format.used) {
  2397.     Oops_format(&ss_format, options);
  2398.     ss_free(&ss_format);
  2399. }
  2400. sparc_regdump = 0;
  2401.     }
  2402.     if (print) {
  2403. if (options->one_shot && lastprint == 0)
  2404.     read_symbol_sources(options);
  2405. puts(line);
  2406. lastprint = lineno;
  2407. if ((start = Oops_eip(text, &string, MAX_STRINGS, ibfd,
  2408.       options))) {
  2409.     const char *ret_addr;
  2410.     if ((ret_addr = Oops_arm_lr(text, &string, MAX_STRINGS)))
  2411. Oops_set_arm_lr(ret_addr, &ss_format);
  2412.     if ((ret_addr = Oops_alpha_ra(text, &string, MAX_STRINGS)))
  2413. Oops_set_alpha_ra(ret_addr, &ss_format);
  2414.     Oops_set_eip(start, &eip, &ss_format, me, ibfd, options);
  2415.     options->vli = strstr(line, " VLI") != NULL;
  2416. }
  2417. if (Oops_eip_alpha_spinlock(text, &string, MAX_STRINGS,
  2418.     options)) {
  2419.     /* Set the eip and previous user from the alpha spinlock
  2420.      * stuck line.  YASC, this line contains both the eip and
  2421.      * the equivalent of a trace entry.
  2422.      */
  2423.     Oops_set_eip(string[1], &eip, &ss_format, me, ibfd, options);
  2424.     Oops_trace_line(line, string[2], &ss_format, options);
  2425. }
  2426. if (Oops_eip_sparc_spinlock(text, &string, MAX_STRINGS,
  2427.     options)) {
  2428.     /* Set the eip and previous user from the sparc spinlock
  2429.      * stuck line.  YASC, this line contains the lock and two
  2430.      * PC entries.
  2431.      */
  2432.     Oops_set_eip(string[2], &eip, &ss_format, me, ibfd, options);
  2433.     Oops_set_eip(string[3], &eip, &ss_format, me, ibfd, options);
  2434.     Oops_trace_line(line, string[1], &ss_format, options);
  2435. }
  2436. if ((start = Oops_mips_ra(text, &string, MAX_STRINGS)))
  2437.     Oops_set_mips_ra(start, &ss_format);
  2438. Oops_mips_regs(text, &ss_format, options);
  2439. Oops_ppc_regs(text, &ss_format, options);
  2440. if ((start = Oops_i370_psw(text, &string, MAX_STRINGS)))
  2441.     Oops_set_i370_psw(start, &ss_format, me, ibfd, options);
  2442. if ((start = Oops_s390_psw(text, &string, MAX_STRINGS)))
  2443.     Oops_set_s390_psw(start, &ss_format, me, ibfd, options);
  2444. if ((start = Oops_trace(text)))
  2445.     Oops_trace_line(text, start, &ss_format, options);
  2446. if ((start = Oops_regs(text)))
  2447.     Oops_set_regs(text, start, &ss_format, options);
  2448. if ((start = Oops_s390_regs(text)))
  2449.     Oops_set_s390_regs(text, start, &ss_format, options);
  2450. if ((start = Oops_cris_regs(text)))
  2451.     Oops_set_cris_regs(text, start, &ss_format, options);
  2452. Oops_set_ia64_b0(text, &string, MAX_STRINGS, &ss_format);
  2453. if (Oops_set_task_name(text, &string, MAX_STRINGS, &ss_format))
  2454.     Oops_set_eip(string[2], &eip, &ss_format, me, ibfd, options);
  2455. if ((start = Oops_code(text, &string, MAX_STRINGS))) {
  2456.     /* In case no EIP line was seen */
  2457.     Oops_set_default_ta(me, ibfd, options);
  2458.     Oops_decode(start, eip, &ss_format, &string, MAX_STRINGS,
  2459. ibfd, options);
  2460.     Oops_format(&ss_format, options);
  2461.     ss_free(&ss_format);
  2462.     if (options->one_shot)
  2463. return(0);
  2464. }
  2465.     }
  2466.     /* More than 5 (arbitrary) lines which were not printed
  2467.      * and there is some saved data, assume we missed the
  2468.      * Code: line.
  2469.      */
  2470.     if (ss_format.used && lineno > lastprint+5) {
  2471. WARNING("%s", "Code line not seen, dumping what data is available");
  2472. Oops_format(&ss_format, options);
  2473. ss_free(&ss_format);
  2474. if (options->one_shot)
  2475.     return(0);
  2476.     }
  2477. }
  2478. if (ss_format.used) {
  2479.     if (options->target &&
  2480. strstr(options->target, "sparc") == 0 &&
  2481. sparc_regdump)
  2482. ; /* sparc regdump comes *after* code, ignore :( */
  2483.     else if (!options->adhoc_addresses)
  2484. WARNING("%s", "Code line not seen, dumping what data is available");
  2485.     Oops_format(&ss_format, options);
  2486.     ss_free(&ss_format);
  2487.     if (options->one_shot)
  2488. return(0);
  2489. }
  2490.     } while (options->filecount != 0);
  2492. #ifdef TIME_RE
  2493.     for (i = 0; i < sizeof(diff)/sizeof(diff[0]); ++i)
  2494. printf("diff %d %d %lld %lldn", i, count[i], diff[i], count[i] ? diff[i]/count[i] : 0);
  2495. #endif
  2497.     if (ibfd && !bfd_close(ibfd)) {
  2498. Oops_bfd_perror("close(ibfd)");
  2499. return(0);
  2500.     }
  2502.     for (i = 0; i < sizeof(string); ++i) {
  2503. free(string[i]);
  2504. string[i] = NULL;
  2505.     }
  2506.     free(line);
  2507.     if (options->one_shot)
  2508. return(3);  /* one shot mode, end of input, no data */
  2509.     return(0);
  2510. }