minix/commands/mdb/core.c
Ben Gras 5e3b213f05 import of mdb (minix debugger), some ptrace and signals unbreaking
seem to have made it work (runtime debugging and core reading).
2005-08-04 08:44:16 +00:00

394 lines
8.4 KiB
C

/*
* core.c for mdb
*
* reads information from 'core' file
* Partly derived from 'adb' by D. Dugger.
*/
#include <pm/const.h>
#include "mdb.h"
#include <signal.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/ptrace.h>
#include <pm/type.h>
#include <pm/mproc.h>
#include <kernel/const.h>
#include <kernel/type.h>
#include <kernel/proc.h>
/* defined in kernel.c */
extern struct proc *prc;
#include "proto.h"
#define BSIZE 512
#define LOGBS 9
PRIVATE struct file {
int fid;
char *name;
long cblock;
long tmap[3];
long dmap[3];
long smap[3];
char buf[BSIZE + BSIZE];
} Core_File, *core_file;
#define b1 tmap[0]
#define e1 tmap[1]
#define f1 tmap[2]
#define b2 dmap[0]
#define e2 dmap[1]
#define f2 dmap[2]
#define b3 smap[0]
#define e3 smap[1]
#define f3 smap[2]
PRIVATE long cnt[3]; /* Sizes of segments */
PRIVATE int h_size; /* Size of core header */
PRIVATE char def_name[] = "core"; /* Default core name */
#define SIZE_MP_SEG (sizeof(struct mem_map) * NR_LOCAL_SEGS)
#define SIZE_KINFO sizeof(struct proc)
#define SIZE_HEADER SIZE_MP_SEG
FORWARD _PROTOTYPE( int kernel_info , (int fd ));
FORWARD _PROTOTYPE( void setmap , (struct file *fp ));
FORWARD _PROTOTYPE( void read_info , (struct file *fp ));
FORWARD _PROTOTYPE( void ill_addr , (long d , int segment ));
FORWARD _PROTOTYPE( long map_addr , (long d , int segment ));
FORWARD _PROTOTYPE( unsigned long c_status, (void));
FORWARD _PROTOTYPE( long getn, (long d, int s) );
/*
* set and display mapping for core file
*/
PRIVATE void setmap(fp)
struct file *fp;
{
long h = (long) h_size;
fp->b1 = st_addr;
fp->e1 = st_addr + cnt[T];
fp->f1 = h;
fp->b2 = sd_addr;
fp->e2 = sd_addr + cnt[D];
fp->f2 = cnt[T] + h;
fp->b3 = sk_addr;
fp->e3 = sk_addr + cnt[S];
fp->f3 = cnt[T] + cnt[D] + h;
#ifdef MINIX_PC
if(is_separate) {
if ( end_addr < et_addr ) end_addr = et_addr;
}
else {
fp->b2 = st_addr;
fp->e2 = st_addr + cnt[T] + cnt[D];
fp->f2 = h;
end_addr = fp->e2;
fp->b1 = 0;
fp->e1 = -1;
fp->f1 = 0;
}
#endif
Printf("From core file:\n");
Printf("T\t%8lx %8lx %8lx\n", core_file->b1, core_file->e1, core_file->f1);
Printf("D\t%8lx %8lx %8lx\n", core_file->b2, core_file->e2, core_file->f2);
Printf("S\t%8lx %8lx %8lx\n", core_file->b3, core_file->e3, core_file->f3);
Printf("\n");
}
/* Print mapping */
PUBLIC void prtmap()
{
Printf("%s I & D space\t", (is_separate) ? "Separate " : "Combined ");
if (corepid > 0) {
Printf("File: %s\n\n", core_file->name);
setmap(core_file);
disp_maps();
}
else {
Printf("Pid: %d\n\n", curpid);
update();
disp_maps();
}
}
/* Illegal address */
PRIVATE void ill_addr(d, segment)
long d;
int segment;
{
Printf("Bad addr=%lx seg=%d",d,segment);
mdb_error("\n");
}
/* Map virtual address -> core file addresses
* depends on current segment if Separate I & D
*/
PRIVATE long map_addr(d, segment)
long d;
int segment;
{
#ifdef MINIX_PC
if (is_separate)
switch (segment) {
case T:
if (d >= core_file->b1 && d < core_file->e1)
d += core_file->f1 - core_file->b1;
else
ill_addr(d,segment);
break;
case D:
case S:
if (d >= core_file->b2 && d < core_file->e2)
d += core_file->f2 - core_file->b2;
else if (d >= core_file->b3 && d < core_file->e3)
d += core_file->f3 - core_file->b3;
else
ill_addr(d,segment);
break;
}
else {
#endif
if (d >= core_file->b1 && d < core_file->e1)
d += core_file->f1 - core_file->b1;
else if (d >= core_file->b2 && d < core_file->e2)
d += core_file->f2 - core_file->b2;
else if (d >= core_file->b3 && d < core_file->e3)
d += core_file->f3 - core_file->b3;
else
ill_addr(d,segment);
#ifdef MINIX_PC
}
#endif
return d;
}
/* Get value with address d and segment s */
PRIVATE long getn(d, s)
long d;
int s;
{
long b;
register int o,i;
union {
unsigned long l;
unsigned char c[4];
} data;
/* Map address */
d = map_addr(d, s);
b = d >> LOGBS;
o = d & (BSIZE - 1);
if (core_file->cblock != b) {
core_file->cblock = b;
lseek(core_file->fid, b << LOGBS, 0);
read(core_file->fid, core_file->buf, sizeof(core_file->buf));
}
for(i = 0; i<4; i++)
data.c[i] = core_file->buf[o+i];
#ifdef DEBUG
if (debug)
Printf("getn at %8lx val %8lx\n", d, data.l);
#endif
return data.l;
}
/* Read kernel info from core file into lbuf[] */
PRIVATE int kernel_info(fd)
int fd;
{
int r;
int ks;
/* Round SIZE_KINFO to multiple of sizeof(long) */
/* See mm/signal.c to see how a 'core' file is written */
ks = ( SIZE_KINFO / sizeof(long) ) * sizeof(long);
r = read(fd, (char *)lbuf, ks);
return(r == ks) ? ks : -1;
}
/*
* Print status info from core - returns PC
*/
PRIVATE unsigned long c_status()
{
fprintf(stderr, "WARNING: don't know pid from core; using proc nr for pid.\n");
Printf("Proc = %6d\n", prc->p_nr);
/* Set current pid to that of core */
curpid = corepid = prc->p_nr;
disp_maps();
Printf("\nPC = 0x%0*lx\t", 2 * ADDRSIZE, PC_MEMBER(prc) & MASK(ADDRSIZE));
symbolic((long) PC_MEMBER(prc), '\n');
dasm((long) PC_MEMBER(prc), 1, 1);
return PC_MEMBER(prc);
}
/* Read memory maps and kernel info from core file */
PRIVATE void read_info(fp)
struct file *fp;
{
struct mproc mm_info;
struct mproc *rmp;
int r;
int i;
rmp = &mm_info;
lseek(fp->fid, 0L, 0L);
/* First read memory map of all segments. */
if (read(fp->fid, (char *) rmp->mp_seg, (int) SIZE_MP_SEG) < 0) {
close(fp->fid);
Printf("mdb: cannot read core header\n");
fp->fid = -1;
return;
}
h_size = SIZE_HEADER;
/* Read kernel dependent info */
r = kernel_info(fp->fid);
if (r < 0) {
close(fp->fid);
Printf("mdb: cannot read kernel info from 'core' file\n");
fp->fid = -1;
return;
} else
h_size += r;
/* copy info */
for (i = T; i <= S; i++)
cnt[i] = (long) rmp->mp_seg[i].mem_len << CLICK_SHIFT;
/* This needs to be set for map_addr() below */
if(coreonly && cnt[T] != 0) is_separate = TRUE;
st_addr = (long) rmp->mp_seg[T].mem_vir << CLICK_SHIFT;
et_addr = st_addr + ((long) rmp->mp_seg[T].mem_len << CLICK_SHIFT);
sd_addr = (long) rmp->mp_seg[D].mem_vir << CLICK_SHIFT;
end_addr = ed_addr =
sd_addr + ((long) rmp->mp_seg[D].mem_len << CLICK_SHIFT);
sk_addr = (long) rmp->mp_seg[S].mem_vir << CLICK_SHIFT;
sk_size = (long) rmp->mp_seg[S].mem_len << CLICK_SHIFT;
setmap(fp);
}
/* initialization for core files
* returns PC address from core file
*/
PUBLIC unsigned long core_init(filename)
char *filename;
{
core_file = &Core_File;
core_file->name = (filename != NULL) ? filename : def_name;
core_file->fid = open(core_file->name, 0);
if (filename != NULL && core_file->fid < 0) {
Printf("mdb - warning cannot open: %s\n", core_file->name);
return -1;
}
core_file->b1 = core_file->b2 = core_file->b3 = 0;
core_file->e1 = core_file->e2 = core_file->e3 = -1;
core_file->f1 = core_file->f2 = core_file->f3 = 0;
core_file->cblock = -1;
if (core_file->fid > 0) {
read_info(core_file);
return c_status();
}
return 0;
}
/* initialization for a file ( -f option )
* always returns 0
* Similar to core files.
*/
PUBLIC unsigned long file_init(filename)
char *filename;
{
core_file = &Core_File;
core_file->name = (filename != NULL) ? filename : def_name;
core_file->fid = open(core_file->name, 0);
if (filename != NULL && core_file->fid < 0) {
Printf("mdb - warning cannot open: %s\n", core_file->name);
return -1;
}
core_file->b1 = core_file->b2 = core_file->b3 = 0;
core_file->e1 = core_file->e2 = core_file->e3 = -1;
core_file->f1 = core_file->f2 = core_file->f3 = 0;
core_file->cblock = -1;
is_separate = FALSE;
core_file->e1 = file_size(core_file->fid);
curpid = corepid = 1;
return 0;
}
/*
* Read from core file
* Called by mdbtrace()
*/
PUBLIC long read_core(req, addr, data)
int req;
long addr, data;
{
int i;
int segment;
long val;
switch (req) {
case T_GETINS:
case T_GETDATA:
/* Check segment and address - call getn to read core file */
segment = (req == T_GETINS) ? T : D;
addr &= MASK(ADDRSIZE);
val = getn(addr, segment);
#ifdef DEBUG
if (debug) Printf("val=>%lx\n", val);
#endif
return val;
break;
case T_GETUSER:
/* Convert addr to index to long array */
i = (int) (addr >> 2);
#ifdef DEBUG
if (debug) Printf("lbuf[%d] %lx\n", i, lbuf[i]);
#endif
return lbuf[i];
break;
case T_OK:
case T_EXIT:
return 0L;
break;
default:
mdb_error("Not supported with 'core' files\n");
}
}