/*

* 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/arch/i386/include/archtypes.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");

}

}