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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
oops.c
资源名称：LINUX设备驱动程序第二版配套源码.rar　[点击查看]
上传用户：wudi5211
上传日期：2010-01-21
资源大小：607k
文件大小：12k
源码类别：

嵌入式Linux

开发平台：

C/C++

oops.c：源码内容
  1. /*
  2.  * ksymoops v2.0 -- A simple filter to resolve symbols in Linux Oops-logs
  3.  *
  4.  * Copyright (C) 1995 Greg McGary <gkm@magilla.cichlid.com> (version 1.x)
  5.  * Copyright (C) 1996 Alessandro Rubini <rubini@ipvvis.unipc.it> (upgrades)
  6.  */
  8. /*
  9.  * New features:
  10.  *       strips syslog prefixes
  11.  *       decodes registers and stack
  12.  *       uses %esp to show pointers to local vars
  13.  *       uses symbols in modules from /proc/ksyms
  14.  */ 
  16. /* 
  17.  * Missing features:
  18.  *       check /proc/ksyms against the map for mismatches
  19.  */
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24. #include <unistd.h>
  25. #include <ctype.h>
  26. #include <linux/module.h>
  29. #define MAX_NAME MOD_MAX_NAME /* quite big, indeed ... */
  30. struct ksym {
  31.   unsigned long address, extent;
  32.   struct ksym *next;
  33.   char name[MAX_NAME];
  34.   char id[MAX_NAME];
  35. };
  37. struct ksym *gsymlist; /* global symlist */
  39. /*----------------------------------------------------------------------*/
  40. /* read a text line into a symbol */
  41. struct  ksym *linesym(char *line)
  42. {
  43.     struct ksym *newsym=malloc(sizeof(struct ksym));
  44.     char s[MAX_NAME];
  45.     int i;
  46.     
  47.     i=sscanf(line,"%lx %s %s",&newsym->address,newsym->name,s);
  48.     switch(i) {
  49.       case 2:
  50.         newsym->id[0]=''; /* no id available, but allright */
  51.         break;
  52.       case 3:
  53.         if (strlen(newsym->name)==1) {        /* a line in the system map */
  54.             strcpy(newsym->id,newsym->name);  /* use segment as id */
  55.             newsym->id[0]=toupper(newsym->id[0]);
  56.             strcpy(newsym->name,s);           /* this was the name */
  57.             break;
  58.         }
  59.         if (s[0]=='[') { /* a module from "ksyms" */
  60.             s[strlen(s)-1]=''; /* trim the bracket */
  61.             strcpy(newsym->id,s+1);
  62.             break;
  63.         }
  65.       default:         /* unknown format */
  66.         free(newsym);
  67.         return NULL;
  68.     }
  69.     newsym->extent = newsym->extent = 0;
  70.     newsym->next = NULL;
  71.     return newsym;
  72. }
  74. /*----------------------------------------------------------------------*/
  75. /*
  76.  * insert a symbol in the list.
  77.  * "trial" is an hint used to speed things  -- it's tenfold faster 
  78.  */
  79. struct ksym *insert(struct ksym *symlist, struct ksym *newsym,
  80.                    struct ksym *trial)
  81. {
  82.     if (!symlist) return newsym;
  83.     if (!trial || trial->address > newsym->address) {
  84.         if (newsym->address < symlist->address) {
  85.             newsym->next = symlist;
  86.             return newsym;
  87.         }
  88.         trial = symlist;
  89.         /* disregard hint */
  90.     }
  91.     for ( ; trial->next; trial=trial->next)
  92.         if (trial->next->address > newsym->address)
  93.             break;
  95.     newsym->next = trial->next;
  96.     trial->next = newsym;
  98.     return symlist;
  99. }
  102. /*----------------------------------------------------------------------*/
  103. /* read a file into a symlist */
  104. struct ksym *filesym(struct ksym *symlist, FILE *f, const char *fname)
  105. {
  106.     char s[80];
  107.     int lineno = 0;
  108.     struct ksym *last = NULL, *sym;
  110.     if (!f) {
  111.         f=fopen(fname,"r");
  112.         if (!f) {
  113.             perror(fname);
  114.             return symlist;
  115.         }
  116.     }
  117.     while (fgets(s,80,f)) {
  118.         lineno++;
  119.         sym = linesym(s);
  120.         if (!sym) {
  121.             fprintf(stderr,"%s:%i: Unknown format for data linen",
  122.                     fname,lineno);
  123.             continue;
  124.         }
  125.         symlist = insert(symlist,sym,last);
  126.         last = sym;
  127.     }
  128.     return symlist;
  129. }
  131. /*----------------------------------------------------------------------*/
  132. /* write extents and remove duplicate items */
  133. struct ksym *fixlist(struct ksym *symlist)
  134. { 
  135.     struct ksym *ptr, *next;
  136.     
  137.     for (ptr=symlist; ptr && ptr->next; ptr = ptr->next) {
  138.         while (ptr->address == ptr->next->address) { /* remove duplicates */
  139.             next=ptr->next;
  140.             if (ptr->id[0] && next->id[0]) /* both valid... hmmm */
  141.                 break;
  142.             if (next->id[0])
  143.                 strcpy(ptr->id,next->id);
  144.             ptr->next=next->next;
  145.             free(next);
  146.         }
  147.         if (!strcmp(ptr->id,ptr->next->id))
  148.             ptr->extent = ptr->next->address - ptr->address;
  149.         else
  150.             ptr->extent = 0;
  151.     }
  152.     ptr->extent=0;
  153.  
  154.     return symlist;
  155. }
  156. /*----------------------------------------------------------------------*/
  157. #ifdef DEBUG
  158. int dumplist(struct ksym *symlist)
  159. {
  160.     for (; symlist; symlist=symlist->next) {
  161.        printf("%08lx %-30s (e %08lx, id "%s")n",
  162.               symlist->address,
  163.               symlist->name, symlist->extent, symlist->id);
  164.        fflush(stdout);
  165.     }
  166.     return 0;
  167. }    
  168. #endif /* DEBUG */                       
  170. /*----------------------------------------------------------------------*/
  171. /* print an address in symbolic form */
  172. char *decode(unsigned int add, unsigned int esp)
  173. {
  174.     static char res[64];
  175.     static struct ksym *symlist=NULL; /* used to remember last time */
  177.     if (!symlist || symlist->address > add) symlist=gsymlist;
  178.     for (;symlist && symlist->next && symlist->next->address <= add;
  179.          symlist=symlist->next)
  180.         /* nothing */;
  181.     if (add < symlist->address || !symlist->extent) { /* out of regions */
  182.         if (abs(add-esp) < 2000) {
  183.             sprintf(res,"<%%esp+%x>",add-esp);
  184.             return res;
  185.         } else
  186.             return "";
  187.     }
  188.     sprintf(res,"<%s+%lx/%lx>",symlist->name,add-symlist->address,
  189.             symlist->extent);
  190.     return res;
  191. }
  193. /*----------------------------------------------------------------------*/
  194. int disass(char *data, unsigned int eip, unsigned int esp)
  195. {
  196.     /*
  197.      * This is a hack to avoid using gcc.  We create an object file by
  198.      * concatenating objfile_head, the twenty bytes of code, and
  199.      * objfile_tail. 
  200.      */
  201.     static unsigned char objfile_head[] = {
  202. 0x07, 0x01, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
  203. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  204. 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  205. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  206.     };
  207.     static unsigned char objfile_tail[] = {
  208. 0x00, 0x90, 0x90, 0x90,
  209. 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
  210. 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
  211. 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  212. 0x25, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
  213. 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00,
  214. 'g',  'c',  'c',  '2',  '_',  'c',  'o',  'm',  
  215. 'p',  'i',  'l',  'e',  'd',  '.',  '', '_',  
  216. 'E',  'I',  'P',  '', '', '', '', '',
  217. '', '', '', '', '', '', '', '',
  218. '', '', '', '', '', ''
  219.     };
  221.     char * objdump = "objdump -d /tmp/oops_decode.o";
  222.     char * objfile = "/tmp/oops_decode.o";
  223.     char buf[128], *bptr;
  224.     char *s;
  225.     FILE *f;
  226.     long l;
  228.     if (!(f=fopen(objfile,"w"))) {
  229.         perror(objfile); return -1;
  230.     }
  231.     fwrite(objfile_head, 1, sizeof(objfile_head), f);
  232.     fwrite(data, 1, 20, f);
  233.     fwrite(objfile_tail, 1, sizeof(objfile_tail), f);
  234.     fclose(f);
  236.     if (!(f=popen(objdump,"r"))) {
  237.         perror("objdump"); return -1;
  238.     }
  240.     while (fgets(buf,128,f)) {
  241.         if (strncmp(&buf[9], "<_EIP", 5))
  242.             continue;
  243. if (strstr(buf, " is out of bounds"))
  244.     break;
  245.         printf("Code: ");
  247.         /* try to print eip in decoded form */
  248. l = strtol(buf, &bptr, 16);
  249.         s=decode(eip+l,esp);
  250.         if (s[0])
  251.             printf("%s",s); /* the decoded address */
  252.         else
  253.             printf("%08lx",eip+l);
  254.         while (*bptr++ != '>')
  255.             /* skip */ ;
  256.         
  257.         /* print the rest of line, without newline */
  258.         bptr[strlen(bptr)-1]='';
  259.         printf("%s",bptr);
  260.         
  261.         /* and now decode any address it embedded */
  262.         while ( (bptr=strstr(bptr, "0x")) ) {
  263.             l=strtol(bptr, &bptr, 0);
  264.             s=decode(l, esp);
  265.             if (s[0])
  266.                 printf(" %s", s);
  267.         }
  268.         putchar('n');
  269.     }
  270.     pclose(f);
  271.     unlink(objfile);
  272.            
  273.     return 0;
  274. }
  276. /*----------------------------------------------------------------------*/
  277. /*
  278.  * All is there: now use it
  279.  */
  280. int main(int argc, char **argv)
  281. {
  282.     char s[512];
  283.     char *subs=NULL, *savedsubs;
  284.     int status=0, offset;
  285.     unsigned int j, k, esp, eip;
  286.     unsigned int i[16];        /* 8 suffice by now, but who knows... */
  287.     char names[16][8], c[20];  /* [8][8] suffice, but who knows */
  288.     char *ptr;
  289.     char *prgname=argv[0];
  290.     struct ksym *symlist=NULL;
  291.     char defaultmap[]="/usr/src/linux/System.map";
  292.     char *mapname=defaultmap;
  295.     if (argc>2) {
  296.         fprintf(stderr,"%s: Usage: "%s [mapfile_name] < oops-log"n",
  297.                 prgname, prgname);
  298.         exit(1);
  299.     }
  300.     if (argc==2)
  301.         mapname=argv[1];
  302.     fprintf(stderr,"%s: Using %s as mapn", prgname, mapname);
  304.     symlist = filesym(symlist,NULL,mapname);
  305.     symlist = filesym(symlist,NULL,"/proc/ksyms");
  307.     symlist=fixlist(symlist);
  308.     /* dumplist(symlist); */
  309.     gsymlist=symlist;
  310.     /*
  311.      * Ok, the symbol table is there, now get the message
  312.      */
  313.     if (isatty(0)) {
  314.         fprintf(stderr,"%s: please paste the oops on my stdinn",prgname);
  315.     }
  317.     while (fgets(s,512,stdin)) {
  318.         if (!subs) { /* nothing yet */
  319.             savedsubs = subs = strstr(s,"EIP: ");
  320.         }
  321.         switch(status) {
  322.         case 0: /* not found */
  323.             if (!subs) continue;
  324.             status++;
  325.             offset=0;
  326.             esp=0;
  327.             j=sscanf(subs,"%s %x:[<%x>]",s,&i[0],&i[1]);
  328.             if (j!=3) {
  329.                 fprintf(stderr,"Wrong "EIP" linen");
  330.                 continue;
  331.             }
  332.             printf("n%-7s %04x:%08x %sn",s,i[0],i[1],decode(i[1],0));
  333.             eip=i[1]; /* keep to disass */
  334.             break;
  335.             
  336.         case 1: /* before the stack */
  337.             j=sscanf(subs,"%s %x %s %x %s %x %s %x",names[0+offset],i+offset,
  338.                      names[1+offset],i+1+offset,names[2+offset],i+2+offset,
  339.                      names[3+offset],i+3+offset);
  340.             if (j==8 && strlen(names[0])==4) { /* registers */
  341.                 /*
  342.                  * The problem with registers is that I need "esp"
  343.                  * first, on order to refer registers to the stack.
  344.                  * So, I save them, and decode later on
  345.                  */
  346.                 if ( (ptr=strstr(subs,"esp:")) ) {
  347.                     sscanf(ptr,"%*s %x",&esp);
  348.                 }
  349.                 if (esp) { /* decode only when they can be ref'd to stack */
  350.                     for (j=0; j<4+offset; j++)
  351.                         printf("%s %08x %sn",names[j],i[j],decode(i[j],esp));
  352.                     offset=0;
  353.                 } else {
  354.                     offset+=4; /* next time, write after these ones */
  355.                 }
  356.                 continue;
  357.             }
  358.             else if (strncmp(subs,"Stack: ",7)) {
  359.                 printf("%s",subs);
  360.                 continue;
  361.             } else {
  362.                 status++;
  363.                 offset=0;
  364.                 subs+=6; /* skip the string, and fall through */
  365.             }
  367.         case 2: /* stack and trace*/
  368.             if (strncmp(subs,"Call Trace",4) != 0) {
  369.                 k=sscanf(subs,"%x %x %x %x %x %x %x %x",i,i+1,i+2,i+3,
  370.                          i+4,i+5,i+6,i+7);
  371.                 if (k<=0) {
  372.                     fprintf(stderr,"Bad stack line (%i items)n",j);
  373.                 } else {
  374.                     for (j=0; j<k; j++)
  375.                         printf("esp+%02x: %08x %sn",(offset+j)*4,i[j],
  376.                                decode(i[j],esp));
  377.                 }
  378.                 if (!offset) subs = savedsubs; /* restore */
  379.                 offset+=8;
  380.                 continue;
  381.             }
  382.             /* call trace */
  383.             status++;
  384.             offset=0;
  385.             subs+=12; /* skip the string, and fall through */
  387.         case 3: /* the trace */
  388.             if (strncmp(subs,"Code",4)) {
  389.                 k=sscanf(subs," [<%x>] [<%x>] [<%x>] [<%x>] "
  390.                          "[<%x>] [<%x>] [<%x>] [<%x>]",i,i+1,i+2,i+3,
  391.                          i+4,i+5,i+6,i+7);
  392.                 if (k==0) {
  393.                     fprintf(stderr,"Bad trace line %s(no add found)n",subs);
  394.                 } else {
  395.                     for (j=0; j<k; j++)
  396.                         printf("Trace: %08x %sn", i[j], decode(i[j],esp));
  397.                 }
  398.                 subs = savedsubs; /* restore */
  399.                 continue;
  400.             }
  401.             /* the code */
  402.             ptr = subs+5; /* skip "Code:" */
  403.             for (j=0; j<20; j++) {
  404.                 long l=strtol(ptr,&ptr,16);
  405.                 c[j]=(char)l;
  406.             }
  407.    
  408.             disass(c, eip, esp);
  409.             esp=0; status=0; subs=NULL; /* ready for another oops */
  410.         }
  411.         
  412.                 
  413.     }
  414.     return 0;
  415. }