source: trunk/minix/commands/mdb/core.c@ 12

/* 
 * 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");
        }
}