Return to fetch.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / systat

Annotation of 43BSDReno/usr.bin/systat/fetch.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Copyright (c) 1980 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: 
                      7: #ifndef lint
                      8: static char sccsid[] = "@(#)fetch.c    5.2 (Berkeley) 2/25/90";
                      9: #endif not lint
                     10: 
                     11: #include "systat.h"
                     12: #include <sys/user.h>
                     13: #include <sys/proc.h>
                     14: #include <sys/vmmac.h>
                     15: #include <machine/pte.h>
                     16: #include <pwd.h>
                     17: 
                     18: long
                     19: getw(loc)
                     20:         int loc;
                     21: {
                     22:         long word;
                     23: 
                     24:         lseek(kmem, loc, L_SET);
                     25:         if (read(kmem, &word, sizeof (word)) != sizeof (word))
                     26:                 printf("Error reading kmem at %x\n", loc);
                     27:         return (word);
                     28: }
                     29: 
                     30: char *
                     31: getpname(pid, mproc)
                     32:         int pid;
                     33:         register struct proc *mproc;
                     34: {
                     35:         register struct procs *pp;
                     36:         register char *namp;
                     37:         register int j;
                     38:         char *getcmd();
                     39: 
                     40:         pp = procs;
                     41:         for (j = numprocs - 1; j >= 0; j--) {
                     42:                 if (pp->pid == pid)
                     43:                         return (pp->cmd);
                     44:                 pp++;
                     45:         }
                     46:         if (j < 0) {
                     47:                 if (numprocs < 200) {
                     48:                         pp = &procs[numprocs];
                     49:                         namp = strncpy(pp->cmd, getcmd(pid, mproc), 15);
                     50:                         pp->cmd[15] = 0;
                     51:                         pp->pid = pid;
                     52:                         numprocs++;
                     53:                 } else
                     54:                         namp = getcmd(pid, mproc);
                     55:         }
                     56:         return (namp);
                     57: }
                     58: 
                     59: union {
                     60:         struct  user user;
                     61:         char    upages[UPAGES][NBPG];
                     62: } user;
                     63: #define u       user.user
                     64: 
                     65: char *
                     66: getcmd(pid, mproc)
                     67:         int pid;
                     68:         register struct proc *mproc;
                     69: {
                     70:         static char cmd[30];
                     71: 
                     72:         if (mproc == NULL || mproc->p_stat == SZOMB)
                     73:                return ("");
                     74:        if (pid == 1)
                     75:                return ("swapper");
                     76:        if (pid == 2)
                     77:                return ("pagedaemon");
                     78:         if (mproc->p_flag&(SSYS|SWEXIT))
                     79:                 return ("");
                     80:         (void) strncpy(cmd, mproc->p_comm, sizeof (cmd));
                     81:         return (cmd);
                     82: }
                     83: 
                     84: static int argaddr;
                     85: static int pcbpf;
                     86: 
                     87: getu(mproc)
                     88:         register struct proc *mproc;
                     89: {
                     90:         struct pte *pteaddr, apte;
                     91:         struct pte arguutl[UPAGES+CLSIZE];
                     92:         register int i;
                     93:         int ncl, size;
                     94: 
                     95:         size = sizeof (struct user);
                     96:         if ((mproc->p_flag & SLOAD) == 0) {
                     97:                 if (swap < 0)
                     98:                         return (0);
                     99:                 (void) lseek(swap, (long)dtob(mproc->p_swaddr), L_SET);
                    100:                 if (read(swap, (char *)&user.user, size) != size) {
                    101:                        error("cant read u for pid %d", mproc->p_pid);
                    102:                         return (0);
                    103:                 }
                    104:                 pcbpf = 0;
                    105:                 argaddr = 0;
                    106:                 return (1);
                    107:         }
                    108:         pteaddr = &Usrptma[btokmx(mproc->p_p0br) + mproc->p_szpt - 1];
                    109:         klseek(kmem, (long)pteaddr, L_SET);
                    110:         if (read(kmem, (char *)&apte, sizeof (apte)) != sizeof (apte)) {
                    111:                 error("cant read indir pte to get u for pid %d", mproc->p_pid);
                    112:                 return (0);
                    113:         }
                    114:         klseek(mem,
                    115:             (long)ctob(apte.pg_pfnum+1) - (UPAGES+CLSIZE) * sizeof (struct pte),
                    116:                 L_SET);
                    117:         if (read(mem, (char *)arguutl, sizeof (arguutl)) != sizeof (arguutl)) {
                    118:                 error("cant read page table for u of pid %d", mproc->p_pid);
                    119:                 return (0);
                    120:         }
                    121:         if (arguutl[0].pg_fod == 0 && arguutl[0].pg_pfnum)
                    122:                 argaddr = ctob(arguutl[0].pg_pfnum);
                    123:         else
                    124:                 argaddr = 0;
                    125:         pcbpf = arguutl[CLSIZE].pg_pfnum;
                    126:         ncl = (size + NBPG*CLSIZE - 1) / (NBPG*CLSIZE);
                    127:         while (--ncl >= 0) {
                    128:                 i = ncl * CLSIZE;
                    129:                 klseek(mem, (long)ctob(arguutl[CLSIZE+i].pg_pfnum), L_SET);
                    130:                 if (read(mem, user.upages[i], CLSIZE*NBPG) != CLSIZE*NBPG) {
                    131:                         error("cant read page %d of u of pid %d\n",
                    132:                             arguutl[CLSIZE+i].pg_pfnum, mproc->p_pid);
                    133:                         return (0);
                    134:                 }
                    135:         }
                    136:         return (1);
                    137: }
                    138: 
                    139: klseek(fd, loc, off)
                    140:         int fd;
                    141:         long loc;
                    142:         int off;
                    143: {
                    144: 
                    145:         (void) lseek(fd, (long)loc, off);
                    146: }

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