// 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;
}
