Return to x_snap.c CVS log

Up to [XINU] / xinu / sys / shell

Annotation of xinu/sys/shell/x_snap.c, revision 1.1

1.1     ! root        1: /* x_snap.c - x_snap */
        !             2: 
        !             3: #include <conf.h>
        !             4: #include <kernel.h>
        !             5: #include <shell.h>
        !             6: #include <coreX.h>
        !             7: 
        !             8: extern int     maxaddr;
        !             9: LOCAL  int     snapreg;
        !            10: #define        SNAPSIZ 512
        !            11: 
        !            12: /*------------------------------------------------------------------------
        !            13:  *  x_snap  -  (command snap) write snapshot of memory to a core file
        !            14:  *------------------------------------------------------------------------
        !            15:  */
        !            16: COMMAND        x_snap(stdin, stdout, stderr, nargs, args)
        !            17: int    stdin, stdout, stderr, nargs;
        !            18: char   *args[];
        !            19: {
        !            20:        int     dev, iPkt, len;
        !            21:        struct  coreX   hdr;
        !            22:        char    *p;
        !            23: 
        !            24:        if (nargs > 2) {
        !            25:                fprintf(stderr,"usage: snap [core-file]\n");
        !            26:                return(SYSERR);
        !            27:        }
        !            28:        p = nargs==1 ? "coreX" : args[1];
        !            29:        if ((dev=open(NAMESPACE, p, "w")) == SYSERR) {
        !            30:                fprintf(stderr,"snap: cannot open %s for writing\n", p);
        !            31:                return(SYSERR);
        !            32:        }
        !            33: 
        !            34:        /* make up a core image using coreX structure heading format */
        !            35: 
        !            36:        hdr.c_magic = COREMAGIC;
        !            37:        hdr.c_size = hdr.c_zero1 = hdr.c_zero2 = hdr.c_zero3 =
        !            38:                hdr.c_zero4 = hdr.c_zero5 = 0;
        !            39:        /* Capture machine registers */
        !            40: 
        !            41:        asm("mfpr $0x0, _snapreg"); hdr.c_regs[KSP] = snapreg;
        !            42:        asm("mfpr $0x1, _snapreg"); hdr.c_regs[ESP] = snapreg;
        !            43:        asm("mfpr $0x2, _snapreg"); hdr.c_regs[SSP] = snapreg;
        !            44:        asm("mfpr $0x3, _snapreg"); hdr.c_regs[SSP] = snapreg;
        !            45:        asm("movl r0,_snapreg");  hdr.c_regs[R0]  = snapreg;
        !            46:        asm("movl r1,_snapreg");  hdr.c_regs[R1]  = snapreg;
        !            47:        asm("movl r2,_snapreg");  hdr.c_regs[R2]  = snapreg;
        !            48:        asm("movl r3,_snapreg");  hdr.c_regs[R3]  = snapreg;
        !            49:        asm("movl r4,_snapreg");  hdr.c_regs[R4]  = snapreg;
        !            50:        asm("movl r5,_snapreg");  hdr.c_regs[R5]  = snapreg;
        !            51:        asm("movl r6,_snapreg");  hdr.c_regs[R6]  = snapreg;
        !            52:        asm("movl r7,_snapreg");  hdr.c_regs[R7]  = snapreg;
        !            53:        asm("movl r8,_snapreg");  hdr.c_regs[R8]  = snapreg;
        !            54:        asm("movl r9,_snapreg");  hdr.c_regs[R9]  = snapreg;
        !            55:        asm("movl r10,_snapreg"); hdr.c_regs[R10] = snapreg;
        !            56:        asm("movl r11,_snapreg"); hdr.c_regs[R11] = snapreg;
        !            57:        asm("movl ap,_snapreg");  hdr.c_regs[AP] = snapreg;
        !            58:        asm("movl fp,_snapreg");  hdr.c_regs[FP] = snapreg;
        !            59:        asm("sneakpc: moval sneakpc, _snapreg");  hdr.c_regs[PC] = snapreg;
        !            60:        asm("movpsl _snapreg");   hdr.c_psw = hdr.c_regs[PSL] = snapreg;
        !            61:        asm("mfpr $0x8, _snapreg"); hdr.c_regs[P0BR] = snapreg;
        !            62:        asm("mfpr $0x9, _snapreg"); hdr.c_regs[P0LR] = snapreg;
        !            63:        asm("mfpr $0xa, _snapreg"); hdr.c_regs[P1BR] = snapreg;
        !            64:        asm("mfpr $0xb, _snapreg"); hdr.c_regs[P1LR] = snapreg;
        !            65:        fprintf(stderr, "Writing core image");
        !            66:        if ( write(dev, &hdr, sizeof(struct coreX)) == SYSERR ) {
        !            67:                fprintf(stderr,"snap: can't write core header, quitting\n");
        !            68:                close(dev);
        !            69:                return(SYSERR);
        !            70:        }
        !            71: 
        !            72:        /* Add contents of real memory to core image */
        !            73: 
        !            74:        iPkt = 0;
        !            75:        for (p= (char *)0 ; p < (char *)(maxaddr+sizeof(int)) ; p += len) {
        !            76:                if (++iPkt == 25) {
        !            77:                        iPkt = 0;
        !            78:                        putc(stderr, '.');
        !            79:                }
        !            80:                len = (int) maxaddr - (int) p + sizeof(int);
        !            81:                if (len > (unsigned) SNAPSIZ)
        !            82:                        len = SNAPSIZ;
        !            83:                if (write(dev, p, SNAPSIZ) == SYSERR) {
        !            84:                        fprintf(stderr,
        !            85:                                "\nsnap: write error, quitting\n");
        !            86:                        close(dev);
        !            87:                        return(SYSERR);
        !            88:                }
        !            89:        }
        !            90:        putc(stderr, '\n');
        !            91:        close(dev);
        !            92:        return(OK);
        !            93: }

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