Return to proca.c CVS log

Up to [Research Unix] / researchv10no / cmd / ps

Annotation of researchv10no/cmd/ps/proca.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include "ps.h"
        !             3: 
        !             4: inita()
        !             5: {
        !             6:        if (drumf == NULL)
        !             7:                drumf = "/dev/drum";
        !             8:        if (memf == NULL)
        !             9:                memf = "/dev/kmem";
        !            10:        if ((drum = open(drumf, 0)) < 0) {
        !            11:                perror(drumf);
        !            12:                exit(1);
        !            13:        }
        !            14:        if ((memory = open(memf, 0)) < 0) {
        !            15:                perror(memf);
        !            16:                exit(1);
        !            17:        }
        !            18: }
        !            19: 
        !            20: getproca(s, pp)
        !            21: char *s; register struct proc *pp;
        !            22: {
        !            23:        register int fd;
        !            24:        char sstr[32];
        !            25:        extern char stack[];
        !            26: 
        !            27:        if((fd = open(strcat(strcpy(sstr, "/proc/"), s), 0)) == -1)
        !            28:                return -1;
        !            29:        if(ioctl(fd, PIOCGETPR, pp) < 0) {
        !            30:                close(fd);
        !            31:                fprintf(stderr, "%s %s: /proc ioctl error\n", progname, s);
        !            32:                return -1;
        !            33:        }
        !            34:        return fd;
        !            35: }
        !            36: 
        !            37: char *
        !            38: getuareaa(fd, pp, up)
        !            39: register struct proc *pp; register struct user *up;
        !            40: {
        !            41:        if (up->u_procp)
        !            42:                return 0;
        !            43:        if (pp->p_stat == SZOMB) {
        !            44:                memset((char *)up, 0, sizeof(*up));
        !            45:                return (0);
        !            46:        }
        !            47:        if (pp->p_flag & SLOAD) {
        !            48:                register ntry = 4;
        !            49:                do
        !            50:                        if (memrd(fd, (char *)up, sizeof(*up), UBASE) == sizeof(*up))
        !            51:                                return 0;
        !            52:                while (errno == EBUSY && --ntry > 0);
        !            53:                close(fd);
        !            54:                return "/proc read error";
        !            55:        }
        !            56:        if (memrd(drum, (char *)up, sizeof(*up), ctob(pp->p_swaddr)) == sizeof(*up))
        !            57:                return 0;
        !            58:        close(fd);
        !            59:        return "drum read error";
        !            60: }
        !            61: 
        !            62: getstacka(f, pp, up, stack)
        !            63: struct proc *pp;
        !            64: struct user *up;
        !            65: char *stack;
        !            66: {
        !            67:        int nstack;
        !            68:        int nspte;
        !            69:        int szpt;
        !            70:        register int i;
        !            71:        struct pte pte[NPTEPG];
        !            72: 
        !            73:        nstack = ctob(up->u_ssize);
        !            74:        if (nstack <= 0)
        !            75:                return (0);
        !            76:        if (nstack > NSTACK)
        !            77:                nstack = NSTACK;
        !            78:        if (pp->p_flag & SLOAD) {
        !            79:                lseek(f, UBASE-nstack, 0);
        !            80:                return (read(f, stack, nstack));
        !            81:        } else {
        !            82:                nspte = btoc(nstack);
        !            83:                szpt = clrnd(ctopt(UPAGES+pp->p_tsize+pp->p_dsize+pp->p_ssize));
        !            84:                lseek(drum, ctob(pp->p_swaddr+UPAGES+szpt-1), 0);
        !            85:                if (read(drum, (char *)pte, sizeof(pte)) != sizeof(pte))
        !            86:                        return (0);
        !            87:                for (i = nspte-1; i >= 0; stack += NBPG, --i)
        !            88:                        rdpage(up, i, &pte[NPTEPG-UPAGES-1-i], stack);
        !            89:                return (nstack);
        !            90:        }
        !            91: }
        !            92: 
        !            93: List *
        !            94: getprlista()
        !            95: {
        !            96:        register List *prlist;
        !            97: 
        !            98:        if ((prlist = getdir("/proc", (List *)0)) == 0)
        !            99:                error("can't getdir /proc");
        !           100:        return prlist;
        !           101: }
        !           102: 
        !           103: kreada(addr, buf, size)
        !           104: long addr;
        !           105: char *buf;
        !           106: int size;
        !           107: {
        !           108: 
        !           109:        return (memrd(memory, buf, size, addr) == size);
        !           110: }

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