Return to coredump.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ucb / dbx

Annotation of 42BSD/ucb/dbx/coredump.c, revision 1.1.1.1

1.1       root        1: /* Copyright (c) 1982 Regents of the University of California */
                      2: 
                      3: static char sccsid[] = "@(#)coredump.c 1.4 1/25/83";
                      4: 
                      5: /*
                      6:  * Deal with the core dump anachronism.
                      7:  *
                      8:  * If I understood this code, I'd try to make it readable.
                      9:  */
                     10: 
                     11: #include "defs.h"
                     12: #include "coredump.h"
                     13: #include "machine.h"
                     14: #include "object.h"
                     15: #include "main.h"
                     16: #include <sys/param.h>
                     17: #include <sys/dir.h>
                     18: #include <machine/psl.h>
                     19: #include <machine/pte.h>
                     20: #include <sys/user.h>
                     21: #include <sys/vm.h>
                     22: #include <machine/reg.h>
                     23: #include <a.out.h>
                     24: 
                     25: #ifndef public
                     26: #define coredump_readin(m, r, s) coredump_xreadin(&(m), r, &(s))
                     27: 
                     28: #include "machine.h"
                     29: #endif
                     30: 
                     31: #define MAXSTKADDR (0x80000000 - ctob(UPAGES)) /* highest stack address */
                     32: 
                     33: typedef struct {
                     34:     Address begin;
                     35:     Address end;
                     36:     Address seekaddr;
                     37: } Map;
                     38: 
                     39: private Map datamap, stkmap;
                     40: private File objfile;
                     41: private struct exec hdr;
                     42: 
                     43: /*
                     44:  * Read the user area information from the core dump.
                     45:  */
                     46: 
                     47: public coredump_xreadin(mask, reg, signo)
                     48: int *mask;
                     49: Word reg[];
                     50: int *signo;
                     51: {
                     52:     register struct user *up;
                     53:     register Word *savreg;
                     54:     union {
                     55:        struct user u;
                     56:        char dummy[ctob(UPAGES)];
                     57:     } ustruct;
                     58: 
                     59:     objfile = fopen(objname, "r");
                     60:     if (objfile == nil) {
                     61:        fatal("can't read \"%s\"", objname);
                     62:     }
                     63:     get(objfile, hdr);
                     64:     up = &(ustruct.u);
                     65:     fread(up, ctob(UPAGES), 1, corefile);
                     66:     savreg = (Word *) &(ustruct.dummy[ctob(UPAGES)]);
                     67:     *mask = savreg[PS];
                     68:     reg[0] = savreg[R0];
                     69:     reg[1] = savreg[R1];
                     70:     reg[2] = savreg[R2];
                     71:     reg[3] = savreg[R3];
                     72:     reg[4] = savreg[R4];
                     73:     reg[5] = savreg[R5];
                     74:     reg[6] = savreg[R6];
                     75:     reg[7] = savreg[R7];
                     76:     reg[8] = savreg[R8];
                     77:     reg[9] = savreg[R9];
                     78:     reg[10] = savreg[R10];
                     79:     reg[11] = savreg[R11];
                     80:     reg[ARGP] = savreg[AP];
                     81:     reg[FRP] = savreg[FP];
                     82:     reg[STKP] = savreg[SP];
                     83:     reg[PROGCTR] = savreg[PC];
                     84:     *signo = up->u_arg[0];
                     85:     datamap.seekaddr = ctob(UPAGES);
                     86:     stkmap.begin = MAXSTKADDR - ctob(up->u_ssize);
                     87:     stkmap.end = MAXSTKADDR;
                     88:     stkmap.seekaddr = datamap.seekaddr + ctob(up->u_dsize);
                     89:     switch (hdr.a_magic) {
                     90:        case OMAGIC:
                     91:            datamap.begin = 0;
                     92:            datamap.end = ctob(up->u_tsize) + ctob(up->u_dsize);
                     93:            break;
                     94: 
                     95:        case NMAGIC:
                     96:        case ZMAGIC:
                     97:            datamap.begin = (Address) ptob(btop(ctob(up->u_tsize) - 1) + 1);
                     98:            datamap.end = datamap.begin + ctob(up->u_dsize);
                     99:            break;
                    100: 
                    101:        default:
                    102:            fatal("bad magic number 0x%x", hdr.a_magic);
                    103:     }
                    104:     /*
                    105:      * Core dump not from this object file?
                    106:      */
                    107:     if (hdr.a_magic != 0 and up->u_exdata.ux_mag  != 0 and
                    108:       hdr.a_magic != up->u_exdata.ux_mag) {
                    109:        warning("core dump ignored");
                    110:        coredump = false;
                    111:        fclose(corefile);
                    112:        fclose(objfile);
                    113:        start(nil, nil, nil);
                    114:     }
                    115: }
                    116: 
                    117: public coredump_close()
                    118: {
                    119:     fclose(objfile);
                    120: }
                    121: 
                    122: public coredump_readtext(buff, addr, nbytes)
                    123: char *buff;
                    124: Address addr;
                    125: int nbytes;
                    126: {
                    127:     if (hdr.a_magic == OMAGIC) {
                    128:        coredump_readdata(buff, addr, nbytes);
                    129:     } else {
                    130:        fseek(objfile, N_TXTOFF(hdr) + addr, 0);
                    131:        fread(buff, nbytes, sizeof(Byte), objfile);
                    132:     }
                    133: }
                    134: 
                    135: public coredump_readdata(buff, addr, nbytes)
                    136: char *buff;
                    137: Address addr;
                    138: int nbytes;
                    139: {
                    140:     if (addr < datamap.begin) {
                    141:        error("data address 0x%x too low (lb = 0x%x)", addr, datamap.begin);
                    142:     } else if (addr > stkmap.end) {
                    143:        error("data address 0x%x too high (ub = 0x%x)", addr, stkmap.end);
                    144:     } else if (addr < stkmap.begin) {
                    145:        fseek(corefile, datamap.seekaddr + addr - datamap.begin, 0);
                    146:        fread(buff, nbytes, sizeof(Byte), corefile);
                    147:     } else {
                    148:        fseek(corefile, stkmap.seekaddr + addr - stkmap.begin, 0);
                    149:        fread(buff, nbytes, sizeof(Byte), corefile);
                    150:     }
                    151: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.