URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [tags/] [before_ORP/] [uclinux/] [uClinux-2.0.x/] [scripts/] [ksymoops.cc] - Rev 1765
Compare with Previous | Blame | View Log
// ksymoops.cc v1.7 -- A simple filter to resolve symbols in Linux Oops-logs // Copyright (C) 1995 Greg McGary <gkm@magilla.cichlid.com> // compile like so: g++ -o ksymoops ksymoops.cc -liostream ////////////////////////////////////////////////////////////////////////////// // This program is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2, or (at your option) // any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program; see the file COPYING. If not, write to the // Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. // This is a simple filter to resolve EIP and call-trace symbols from // a Linux kernel "Oops" log. Supply the symbol-map file name as a // command-line argument, and redirect the oops-log into stdin. Out // will come the EIP and call-trace in symbolic form. ////////////////////////////////////////////////////////////////////////////// // BUGS: // * Doesn't deal with line-prefixes prepended by syslog--strip // these off first, before submitting to ksymoops. // * Only resolves operands of jump and call instructions. #include <fstream.h> #include <strstream.h> #include <iomanip.h> #include <stdio.h> #include <string.h> #include <stdlib.h> #include <unistd.h> #include <ctype.h> inline int strequ(char const* x, char const* y) { return (::strcmp(x, y) == 0); } inline int strnequ(char const* x, char const* y, size_t n) { return (::strncmp(x, y, n) == 0); } const int code_size = 20; ////////////////////////////////////////////////////////////////////////////// class KSym { friend class NameList; private: long address_; char* name_; long offset_; long extent_; private: istream& scan(istream&); ostream& print(ostream&) const; void set_extent(KSym const& next_ksym) { extent_ = next_ksym.address_ - address_; } public: friend istream& operator >> (istream& is, KSym& k) { return k.scan(is); } friend ostream& operator << (ostream& os, const KSym& k) { return k.print(os); } }; istream& KSym::scan(istream& is) { is >> ::hex >> address_; char type; is >> type; char name[128]; is >> name; name_ = new char [strlen(name)+1]; strcpy(name_, name); offset_ = 0; return is; } ostream& KSym::print(ostream& os) const { os << ::hex << address_ + offset_ << ' ' << '<' << name_; if (offset_) os << '+' << ::hex << offset_ << '/' << ::hex << extent_; return os << '>'; } ////////////////////////////////////////////////////////////////////////////// class NameList { private: // Caution: Fixed Allocation! // This should suffice for awhile since 1.1.86 has only 2482 symbols. KSym ksyms_0_[8000]; int cardinality_; public: NameList() : cardinality_(0) { } private: istream& scan(istream&); public: int valid() { return (cardinality_ > 0); } KSym* find(long address); void decode(unsigned char* code, long eip_addr); public: friend istream& operator >> (istream& is, NameList& n) { return n.scan(is); } }; KSym* NameList::find(long address) { if (!valid()) return 0; KSym* start = ksyms_0_; KSym* end = &ksyms_0_[cardinality_ - 1]; if (address < start->address_ || address >= end->address_) return 0; KSym* mid; while (start <= end) { mid = &start[(end - start) / 2]; if (mid->address_ < address) start = mid + 1; else if (mid->address_ > address) end = mid - 1; else return mid; } while (mid->address_ > address) --mid; mid->offset_ = address - mid->address_; if (mid->offset_ > mid->extent_) clog << "Oops! " << *mid << endl; return mid; } void NameList::decode(unsigned char* code, long eip_addr) { /* This is a hack to avoid using gcc. We create an object file by concatenating objfile_head, the twenty bytes of code, and objfile_tail. */ unsigned char objfile_head[] = { 0x07, 0x01, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; unsigned char objfile_tail[] = { 0x00, 0x90, 0x90, 0x90, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 'g', 'c', 'c', '2', '_', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'd', '.', '\0', '_', 'E', 'I', 'P', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0' }; char const* objdump_command = "objdump -d oops_decode.o"; char const* objfile_name = &objdump_command[11]; ofstream objfile_stream(objfile_name); objfile_stream.write(objfile_head, sizeof(objfile_head)); objfile_stream.write(code, code_size); objfile_stream.write(objfile_tail, sizeof(objfile_tail)); objfile_stream.close(); FILE* objdump_FILE = popen(objdump_command, "r"); if (objdump_FILE == 0) { clog << "Sorry, without " << objdump_command << ", I can't disassemble the `Code' section." << endl; return; } char buf[1024]; int lines = 0; int eip_seen = 0; long offset; while (fgets(buf, sizeof(buf), objdump_FILE)) { if (eip_seen && buf[4] == ':') { // assume objdump from binutils 2.8..., reformat to old style offset = strtol(buf, 0, 16); char newbuf[sizeof(buf)]; memset(newbuf, '\0', sizeof(newbuf)); ostrstream ost(newbuf, sizeof(newbuf)); ost.width(8); ost << offset; ost << " <_EIP+" << offset << ">: " << &buf[6] << ends; strcpy(buf, newbuf); } if (!strnequ(&buf[9], "<_EIP", 5)) continue; eip_seen = 1; if (strstr(buf, " is out of bounds")) break; lines++; cout << "Code: "; if (!valid()) { cout << buf; continue; } offset = strtol(buf, 0, 16); char* bp_0 = strchr(buf, '>'); KSym* ksym = find(eip_addr + offset); if (bp_0) bp_0 += 2; else bp_0 = strchr(buf, ':'); if (ksym) cout << *ksym << ' '; char *bp_1 = strstr(bp_0, "\t"); // objdump from binutils 2.8... if (bp_1) ++bp_1; else bp_1 = bp_0; char *bp = bp_1; while (!isspace(*bp)) bp++; while (isspace(*bp)) bp++; if (!isxdigit(*bp)) { cout << bp_0; } else if (*bp_1 == 'j' || strnequ(bp_1, "call", 4)) { // a jump or call insn long rel_addr = strtol(bp, 0, 16); ksym = find(eip_addr + rel_addr); if (ksym) { *bp++ = '\0'; cout << bp_0 << *ksym << endl; } else cout << bp_0; } else { cout << bp_0; } } if (!lines) clog << "Sorry, your " << objdump_command << " can't disassemble--you must upgrade your binutils." << endl; pclose(objdump_FILE); unlink(objfile_name); } istream& NameList::scan(istream& is) { KSym* ksyms = ksyms_0_; int cardinality = 0; while (!is.eof()) { is >> *ksyms; if (cardinality++ > 0) ksyms[-1].set_extent(*ksyms); ksyms++; } cardinality_ = --cardinality; return is; } ////////////////////////////////////////////////////////////////////////////// char const* program_name; void usage() { clog << "Usage: " << program_name << " [ System.map ] < oops-log" << endl; exit(1); } int main(int argc, char** argv) { char c; program_name = (argc--, *argv++); NameList names; if (argc > 1) usage(); else if (argc == 1) { char const* map_file_name = (argc--, *argv++); ifstream map(map_file_name); if (map.bad()) clog << program_name << ": Can't open `" << map_file_name << "'" << endl; else { map >> names; cout << "Using `" << map_file_name << "' to map addresses to symbols." << endl; } } if (!names.valid()) cout << "No symbol map. I'll only show you disassembled code." << endl; cout << endl; char buffer[1024]; while (!cin.eof()) { long eip_addr; cin >> buffer; if (strequ(buffer, "EIP:") && names.valid()) { cin >> ::hex >> eip_addr; cin >> c >> c >> c; cin >> ::hex >> eip_addr; cin >> c >> c >> buffer; if (!strequ(buffer, "EFLAGS:")) { clog << "Please strip the line-prefixes and rerun " << program_name << endl; exit(1); } KSym* ksym = names.find(eip_addr); if (ksym) cout << ">>EIP: " << *ksym << endl; } else if (strequ(buffer, "Trace:") && names.valid()) { long address; while ((cin >> buffer) && (sscanf(buffer, " [<%x>]", &address) == 1) && address > 0xc) { cout << "Trace: "; KSym* ksym = names.find(address); if (ksym) cout << *ksym; else cout << ::hex << address; cout << endl; } cout << endl; } if (strequ(buffer, "ode:") || strequ(buffer, "Code:")) { // The 'C' might have been consumed as a hex number unsigned char code[code_size]; unsigned char* cp = code; unsigned char* end = &code[code_size]; while (cp < end) { int c; cin >> ::hex >> c; *cp++ = c; } names.decode(code, eip_addr); } } cout << flush; return 0; }