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

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.