Return to process.rep CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / pascal / pdx / process

Annotation of 43BSDTahoe/ucb/pascal/pdx/process/process.rep, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1982 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  *
        !             6:  *     @(#)process.rep 5.4 (Berkeley) 1/3/88
        !             7:  */
        !             8: 
        !             9: /*
        !            10:  * This file defines the representation of a process.
        !            11:  * It is MACHINE DEPENDENT.
        !            12:  */
        !            13: 
        !            14: #define STOPPED 0177
        !            15: #define FINISHED 0
        !            16: 
        !            17: #ifdef vax
        !            18: #define NREG 12                        /* maximum number of saved registers */
        !            19: #endif
        !            20: #ifdef tahoe
        !            21: #define        NREG 13
        !            22: #endif
        !            23: #ifdef mc68000
        !            24: #define NREG 14                        /* maximum number of saved registers */
        !            25: #endif
        !            26: #define CSIZE 101              /* size of instruction cache */
        !            27: 
        !            28: /*
        !            29:  * Cache-ing of instruction segment is done to reduce the number
        !            30:  * of calls to ptrace.
        !            31:  */
        !            32: 
        !            33: typedef struct {
        !            34:        WORD addr;
        !            35:        WORD val;
        !            36: } CACHEWORD;
        !            37: 
        !            38: /*
        !            39:  * This structure holds the information we need from the user structure.
        !            40:  */
        !            41: 
        !            42: struct process {
        !            43:        int pid;                /* process being traced */
        !            44:        WORD reg[NREG];         /* process's registers */
        !            45: #ifdef tahoe
        !            46:        WORD fp, sp, pc;        /* special registers */
        !            47: #else
        !            48:        WORD ap, fp, sp, pc;    /* special registers */
        !            49: #endif
        !            50:        WORD oreg[NREG];        /* registers when process last stopped */
        !            51:        WORD oap, ofp, osp, opc;/* special registers when process stopped */
        !            52:        int status;             /* either STOPPED or FINISHED */
        !            53:        int signo;              /* signal that stopped process */
        !            54:        int exitval;            /* return value from exit() */
        !            55:        long sigset;            /* bit array of traced signals */
        !            56:        CACHEWORD word[CSIZE];  /* text segment cache */
        !            57: };
        !            58: 
        !            59: /*
        !            60:  * Process manipulation routines local to this module.
        !            61:  */
        !            62: 
        !            63: int pstart();                  /* start up a process */
        !            64: int pcont();                   /* continue execution */
        !            65: int pstep();                   /* single step */
        !            66: int pio();                     /* process memory move */
        !            67: int psigtrace();               /* catch/don't catch a signal */
        !            68: int unsetsigtraces();          /* don't catch any signals */
        !            69: 
        !            70: /*
        !            71:  * These definitions are for the arguments to "pio".
        !            72:  */
        !            73: 
        !            74: typedef enum { PREAD, PWRITE } PIO_OP;
        !            75: typedef enum { TEXTSEG, DATASEG } PIO_SEG;
        !            76: 
        !            77: /* macros for things that used to be functions */
        !            78: 
        !            79: #define        iread(buf, addr, nbytes)        dread(buf, addr+ENDOFF, nbytes)
        !            80: #define        iwrite(buf, addr, nbytes)       dwrite(buf, addr+ENDOFF, nbytes)
        !            81: #define        dread(buf, addr, nbytes)        drdwr(PREAD, buf, addr, nbytes)
        !            82: #define        dwrite(buf, addr, nbytes)       drdwr(PWRITE, buf, addr, nbytes)

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