Return to kmem.c CVS log

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

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

1.1     ! root        1: #include <stdio.h>
        !             2: #include "ps.h"
        !             3: #include <nlist.h>
        !             4: 
        !             5: struct nlist nl[] = {
        !             6:        { "_proc" },
        !             7: #define        X_PROC          0
        !             8:        { "_proccnt" },
        !             9: #define        X_NPROC         1
        !            10:        { "_physspt" },
        !            11: #define        X_PHYSSPT       2
        !            12:        { 0 },
        !            13: };
        !            14: 
        !            15: struct proc *kproc;
        !            16: static int nproc, lastproc;
        !            17: long physspt;
        !            18: 
        !            19: long vtophys();
        !            20: 
        !            21: initk()
        !            22: {
        !            23: 
        !            24:        if (memf == NULL)
        !            25:                memf = "/dev/mem";
        !            26:        else {
        !            27:                if (drumf == NULL)      /* and memf was specified */
        !            28:                        drumf = "/dev/null";
        !            29:        }
        !            30:        if (drumf == NULL)
        !            31:                drumf = "/dev/drum";
        !            32:        if (nlistf == NULL)
        !            33:                nlistf = "/unix";
        !            34:        if ((drum = open(drumf, 0)) < 0) {
        !            35:                perror(drumf);
        !            36:                exit(1);
        !            37:        }
        !            38:        if ((memory = open(memf, 0)) < 0) {
        !            39:                perror(memf);
        !            40:                exit(1);
        !            41:        }
        !            42:        nlist(nlistf, nl);
        !            43:        if(nl[0].n_type == 0) {
        !            44:                fprintf(stderr, "%s: No namelist\n", nlistf);
        !            45:                exit(1);
        !            46:        }
        !            47:        if (memrd(memory, (char *)&physspt, sizeof(physspt),
        !            48:            (long)nl[X_PHYSSPT].n_value-KSTART) != sizeof(physspt)) {
        !            49:                fprintf(stderr, "can't read physspt\n");
        !            50:                exit(1);
        !            51:        }
        !            52: }
        !            53: 
        !            54: setkproc()
        !            55: {
        !            56:        if (memrd(memory, (char *)&nproc, sizeof(nproc),
        !            57:            vtophys(nl[X_NPROC].n_value)) != sizeof(nproc)) {
        !            58:                fprintf(stderr, "can't read nproc\n");
        !            59:                exit(1);
        !            60:        }
        !            61:        if((kproc = (struct proc *)malloc(nproc*sizeof(struct proc))) == 0) {
        !            62:                fprintf(stderr, "no memory for proc table\n");
        !            63:                exit(1);
        !            64:        }
        !            65:        if (memrd(memory, (char *)kproc, nproc*sizeof(struct proc),
        !            66:            vtophys(nl[X_PROC].n_value)) != nproc*sizeof(struct proc)) {
        !            67:                fprintf(stderr, "can't read proc table\n");
        !            68:                exit(1);
        !            69:        }
        !            70:        lastproc = nproc-1;
        !            71: }
        !            72: 
        !            73: getprock(s, pp)
        !            74: char *s;
        !            75: struct proc *pp;
        !            76: {
        !            77:        register int pid, x;
        !            78: 
        !            79:        if (nproc == 0)
        !            80:                setkproc();
        !            81:        pid = atoi(s);
        !            82:        for(x = lastproc+1; x != lastproc; x++) {
        !            83:                if(x >= nproc)
        !            84:                        x = 0;
        !            85:                if (kproc[x].p_stat == 0)
        !            86:                        continue;
        !            87:                if(kproc[x].p_pid == pid) {
        !            88:                        *pp = kproc[x];
        !            89:                        lastproc = x;
        !            90:                        return 0;
        !            91:                }
        !            92:        }
        !            93:        return -1;
        !            94: }
        !            95: 
        !            96: char *
        !            97: getuareak(fd, pp, up)
        !            98: register struct proc *pp;
        !            99: register struct user *up;
        !           100: {
        !           101:        struct pte upte[UPAGES];
        !           102:        register int i;
        !           103: 
        !           104:        if (pp->p_stat == SZOMB) {
        !           105:                memset((char *)up, 0, sizeof(*up));
        !           106:                return (0);
        !           107:        }
        !           108:        if (pp->p_flag & SLOAD) {
        !           109:                if (memrd(memory, (char *)upte, sizeof(upte), vtophys((long)pp->p_addr)) != sizeof(upte))
        !           110:                        return ("can't read user ptes");
        !           111:                for (i = 0; i < UPAGES; i++)
        !           112:                        if (memrd(memory, ((char *)up)+i*NBPG, NBPG,
        !           113:                            ctob(upte[i].pg_pfnum)) != NBPG)
        !           114:                                return ("can't read user");
        !           115:                return (0);
        !           116:        } else {
        !           117:                if (memrd(drum, (char *)up, sizeof(*up), ctob(pp->p_swaddr)) != sizeof(*up))
        !           118:                        return ("can't read user block");
        !           119:                return (0);
        !           120:        }
        !           121: }
        !           122: 
        !           123: getstackk(f, pp, up, stack)
        !           124: register struct proc *pp;
        !           125: register struct user *up;
        !           126: char *stack;
        !           127: {
        !           128:        register int i;
        !           129:        int nstack, nspte;
        !           130:        int szpt;       /* swapped pt size */
        !           131:        struct pte pte[NPTEPG];
        !           132: 
        !           133:        nstack = ctob(up->u_ssize);
        !           134:        if (nstack <= 0)
        !           135:                return (0);
        !           136:        if (nstack > NSTACK)
        !           137:                nstack = NSTACK;
        !           138:        nspte = btoc(nstack);
        !           139:        szpt = clrnd(ctopt(UPAGES+pp->p_tsize+pp->p_dsize+pp->p_ssize));
        !           140:        if (pp->p_flag & SLOAD) {
        !           141:                if (memrd(memory, (char *)pte, sizeof(pte),
        !           142:                    vtophys((long)pp->p_addr+UPAGES*sizeof(struct pte)-NBPG)) != sizeof(pte))
        !           143:                        return (0);
        !           144:        } else {
        !           145:                if (memrd(drum, (char *)pte, sizeof(pte),
        !           146:                    ctob(pp->p_swaddr+UPAGES+szpt-1)) != sizeof(pte))
        !           147:                        return (0);
        !           148:        }
        !           149:        for (i = nspte-1; i >= 0; stack += NBPG, --i)
        !           150:                rdpage(up, i, &pte[NPTEPG-UPAGES-1-i], stack);
        !           151:        return (nstack);
        !           152: }
        !           153: 
        !           154: List *
        !           155: getprlistk()
        !           156: {
        !           157:        register List *lp;
        !           158:        register Entry *ep;
        !           159:        register int x;
        !           160: 
        !           161:        if (nproc == 0)
        !           162:                setkproc();
        !           163:        if((lp = Malloc(List, 1)) == 0)
        !           164:                return 0;
        !           165:        lp->next = 0;
        !           166:        lp->begin = 0;
        !           167:        lp->nentry = 0;
        !           168:        for(x = 0; x < nproc; x++) {
        !           169:                if(kproc[x].p_stat == 0)
        !           170:                        continue;
        !           171:                if((ep = Malloc(Entry, 1)) == 0)
        !           172:                        break;
        !           173:                ep->next = lp->begin;
        !           174:                lp->begin = ep;
        !           175:                lp->nentry++;
        !           176:                ep->e_val = kproc[x].p_pid;
        !           177:                sprintf(ep->e_name, "%d", kproc[x].p_pid);
        !           178:        }
        !           179:        return lp;
        !           180: }
        !           181: 
        !           182: long
        !           183: vtophys(loc)
        !           184: long loc;
        !           185: {
        !           186:        struct pte pte;
        !           187:        register long nloc;
        !           188: 
        !           189:        nloc = loc - KSTART;
        !           190:        if (nloc < 0) {
        !           191:                fprintf(stderr, "bad kernel address %x\n", loc);
        !           192:                return (0);
        !           193:        }
        !           194:        if (memrd(memory, (char *)&pte, sizeof(pte),
        !           195:            physspt + (nloc/NBPG)*sizeof(struct pte)) != sizeof(pte)) {
        !           196:                fprintf(stderr, "can't get spt for %x\n", loc);
        !           197:                return (0);
        !           198:        }
        !           199:        if (pte.pg_v == 0) {
        !           200:                fprintf(stderr, "invalid spt for %x\n", loc);
        !           201:                return (0);
        !           202:        }
        !           203:        return (pte.pg_pfnum * NBPG + (nloc & PGOFSET));
        !           204: }
        !           205: 
        !           206: kreadk(addr, buf, size)
        !           207: long addr;
        !           208: char *buf;
        !           209: int size;
        !           210: {
        !           211: 
        !           212:        return (memrd(memory, buf, size, vtophys(addr)) == size);
        !           213: }

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