![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fstat.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd|
Return to fstat.c CVS log | Up to [Research Unix] / researchv8dc / cmd |
1.1 root 1: /*
2: * ps; VAX 4BSD version
3: */
4:
5: #include <stdio.h>
6: #include <ctype.h>
7: #include <nlist.h>
8: #include <pwd.h>
9: #include <sys/param.h>
10: #include <sys/tty.h>
11: #include <sys/dir.h>
12: #include <sys/user.h>
13: #include <sys/proc.h>
14: #include <sys/pte.h>
15: #include <sys/vm.h>
16: #include <sys/text.h>
17: #include <sys/stat.h>
18: #include <math.h>
19: #include <sys/vlimit.h>
20: #include <sys/inode.h>
21: #include <sys/file.h>
22:
23: #define vprintf if (vflg) printf
24: #define WD -1
25: #define TEXT -2
26:
27: int pcbpf, nswap, kmem, mem, swap, uid, pid;
28: int uflg, fflg, inum, Mdev, mdev, special, vflg, nproc, pflg;
29: char *uname;
30:
31: struct nlist nl[] = {
32: { "_proc" },
33: #define X_PROC 0
34: { "_Usrptmap" },
35: #define X_USRPTMA 1
36: { "_usrpt" },
37: #define X_USRPT 2
38: { "_nswap" },
39: #define X_NSWAP 3
40: { "_nproc" },
41: #define X_NPROC 4
42: { 0 },
43: };
44:
45: struct proc proc[8], *mproc; /* 8 = a few, for less syscalls */
46: struct pte *Usrptma, *usrpt;
47:
48: int paduser1; /* avoid hardware mem clobbering botch */
49: union {
50: struct user user;
51: char upages[UPAGES][NBPG];
52: } user;
53: int paduser2; /* avoid hardware mem clobbering botch */
54: #define u user.user
55:
56: char *kmemf, *memf, *swapf, *nlistf;
57:
58: extern int errno;
59:
60: main(argc, argv)
61: char **argv;
62: {
63: register int i, j;
64: off_t procp;
65: dev_t dev;
66:
67: argv++;
68: while (--argc > 0) {
69: if (strcmp(*argv, "-v") == 0) {
70: vflg++;
71: argv++;
72: continue;
73: }
74: if (strcmp(*argv, "-u") == 0) {
75: if (uflg++)
76: usage();
77: if ((uid = getuname(*(++argv))) < 0) {
78: fprintf(stderr, "%s: unknown user\n", *argv);
79: exit(1);
80: }
81: --argc;
82: argv++;
83: continue;
84: }
85: if (strcmp(*argv, "-f") == 0) {
86: if (fflg++)
87: usage();
88: if ((dev = getfname(*(++argv))) < 0) {
89: perror(*argv);
90: exit(1);
91: }
92: --argc;
93: argv++;
94: continue;
95: }
96:
97: if (strcmp(*argv, "-p") == 0) {
98: if (pflg++ || ((pid = Atoi(*(++argv))) <= 0)) {
99: usage();
100: perror(*argv);
101: exit(1);
102: }
103: --argc;
104: argv++;
105: continue;
106: }
107:
108: /* admit missing -u, -f, -p */
109: /* it's an expert system! */
110: if ((pid = Atoi(*argv)) > 0) {
111: if (pflg++)
112: usage();
113: continue;
114: }
115: if (fflg && uflg)
116: usage();
117: if (uflg) {
118: /* it must be a file */
119: fflg++;
120: if ((dev = getfname(*argv)) < 0) {
121: perror(*argv);
122: exit(1);
123: }
124: argv++;
125: continue;
126: }
127: if (fflg) {
128: /* it must be a user */
129: uflg++;
130: if ((uid = getuname(*argv)) < 0) {
131: fprintf(stderr,
132: "%s: unknown user\n", *argv);
133: exit(1);
134: }
135: argv++;
136: continue;
137: }
138: /* !uflg && !fflg -- which is it? */
139: if ((dev = getfname(*argv)) >= 0)
140: fflg++; /* could be a file */
141: if ((uid = getuname(*argv)) >= 0)
142: uflg++; /* could be a user */
143: if ((!uflg ^ !fflg) == 0)
144: usage(); /* could be either/neither */
145: argv++;
146: continue;
147: }
148:
149: if (fflg) {
150: Mdev = major(dev);
151: mdev = minor(dev);
152: }
153:
154: if (chdir("/dev") < 0) {
155: perror("/dev");
156: exit(1);
157: }
158:
159: printf("user\t\t pid\t fd major minor\tinode\n");
160: openfiles();
161: getkvars();
162: procp = getw((off_t) nl[X_PROC].n_value);
163: nproc = getw((off_t) nl[X_NPROC].n_value);
164: for (i=0; i<nproc; i += 8) {
165: lseek(kmem, (long) procp, 0);
166: j = nproc - i;
167: if (j > 8)
168: j = 8;
169: j *= sizeof (struct proc);
170: if (read(kmem, (char *) proc, j) != j)
171: cantread("proc table", kmemf);
172: procp += j;
173: for (j = j / sizeof (struct proc) - 1; j >= 0; j--) {
174: mproc = &proc[j];
175: if (mproc->p_stat == 0)
176: continue;
177: doproc();
178: }
179: }
180: exit(0);
181: }
182:
183: long
184: getw(loc)
185: off_t loc;
186: {
187: long word;
188:
189: lseek(kmem, (long) loc, 0);
190: if (read(kmem, (char *) &word, sizeof (word)) != sizeof (word))
191: vprintf("error reading kmem at %x\n", loc);
192: return (word);
193: }
194:
195: openfiles()
196: {
197:
198: kmemf = "kmem";
199: kmem = open(kmemf, 0);
200: if (kmem < 0) {
201: perror(kmemf);
202: exit(1);
203: }
204: memf = "mem";
205: mem = open(memf, 0);
206: if (mem < 0) {
207: perror(memf);
208: exit(1);
209: }
210: swapf = "drum";
211: swap = open(swapf, 0);
212: if (swap < 0) {
213: perror(swapf);
214: exit(1);
215: }
216: }
217:
218: getkvars()
219: {
220: nlistf = "/unix";
221: nlist(nlistf, nl);
222: if (nl[0].n_type == 0) {
223: fprintf(stderr, "%s: No namelist\n", nlistf);
224: exit(1);
225: }
226: Usrptma = (struct pte *) nl[X_USRPTMA].n_value;
227: usrpt = (struct pte *) nl[X_USRPT].n_value;
228: lseek(kmem, (long) nl[X_NSWAP].n_value, 0);
229: if (read(kmem, (char *) &nswap, sizeof (nswap)) != sizeof (nswap)) {
230: cantread("nswap", kmemf);
231: exit(1);
232: }
233: }
234:
235: cantread(what, fromwhat)
236: char *what, *fromwhat;
237: {
238:
239: vprintf("fstat: error reading %s from %s", what, fromwhat);
240: }
241:
242: doproc()
243: {
244: struct passwd *getpwuid();
245:
246: if (uflg && mproc->p_uid != uid)
247: return;
248: if (pflg && mproc->p_pid != pid)
249: return;
250: if (mproc->p_stat != SZOMB && getu() == 0)
251: return;
252: uname = getpwuid(u.u_uid)->pw_name;
253: dotext();
254: getf();
255: }
256:
257: getu()
258: {
259: struct pte *pteaddr, apte;
260: int pad1; /* avoid hardware botch */
261: struct pte arguutl[UPAGES+CLSIZE];
262: int pad2; /* avoid hardware botch */
263: register int i;
264: int ncl, size, argaddr;
265:
266: size = sizeof (struct user);
267: if ((mproc->p_flag & SLOAD) == 0) {
268: lseek(swap, (long) ctob(mproc->p_swaddr), 0);
269: if (read(swap, (char *) &user.user, size) != size) {
270: vprintf("fstat: cant read u for pid %d from %s\n",
271: mproc->p_pid, swapf);
272: return (0);
273: }
274: pcbpf = 0;
275: argaddr = 0;
276: return (1);
277: }
278: pteaddr = &Usrptma[btokmx(mproc->p_p0br) + mproc->p_szpt - 1];
279: lseek(kmem, (long) pteaddr, 0);
280: if (read(kmem, (char *) &apte, sizeof(apte)) != sizeof(apte)) {
281: vprintf("fstat: can't read indir pte to get u for pid %d from %s\n",
282: mproc->p_pid, swapf);
283: return (0);
284: }
285: lseek(mem,
286: (long) ctob(apte.pg_pfnum+1) - (UPAGES+CLSIZE) * sizeof (struct pte), 0);
287: if (read(mem, (char *) arguutl, sizeof(arguutl)) != sizeof(arguutl)) {
288: vprintf("fstat: can't read page table for u of pid %d from %s\n",
289: mproc->p_pid, swapf);
290: return (0);
291: }
292: if (arguutl[0].pg_fod == 0 && arguutl[0].pg_pfnum)
293: argaddr = ctob(arguutl[0].pg_pfnum);
294: else
295: argaddr = 0;
296: pcbpf = arguutl[CLSIZE].pg_pfnum;
297: ncl = (size + NBPG*CLSIZE - 1) / (NBPG*CLSIZE);
298: while (--ncl >= 0) {
299: i = ncl * CLSIZE;
300: lseek(mem, (long) ctob(arguutl[CLSIZE+i].pg_pfnum), 0);
301: if (read(mem, user.upages[i], CLSIZE*NBPG) != CLSIZE*NBPG) {
302: vprintf("fstat: can't read page %d of u of pid %d from %s\n",
303: arguutl[CLSIZE+i].pg_pfnum, mproc->p_pid, memf);
304: return(0);
305: }
306: }
307: return (1);
308: }
309:
310: #define NMAX 8
311: #define NUID 2048
312:
313: dotext()
314: {
315: struct text text;
316:
317: lseek(kmem, (long) mproc->p_textp, 0);
318: if (read(kmem, (char *) &text, sizeof(text)) != sizeof(text)) {
319: cantread("text table", kmemf);
320: return;
321: }
322: if (text.x_flag == 0)
323: return;
324: itrans(text.x_iptr, TEXT);
325: }
326:
327: itrans(i, fno)
328: struct inode *i;
329: {
330: struct inode inode;
331: dev_t idev;
332:
333: lseek(kmem, (long) i, 0);
334: if (read(kmem, (char *) &inode, sizeof(inode))
335: != sizeof(inode)) {
336: vprintf("error %d reading inode at %x from kmem\n", errno, i);
337: return;
338: }
339: if (special)
340: idev = inode.i_dev;
341: else
342: idev = inode.i_dev;
343: if (fflg && major(idev) != Mdev)
344: return;
345: if (fflg && minor(idev) != mdev)
346: return;
347: if (inum && inode.i_number != inum)
348: return;
349: printf("%-16s%5d\t", uname, mproc->p_pid);
350: if (fno == WD)
351: printf(" wd");
352: else if (fno == TEXT)
353: printf("text");
354: else
355: printf("%4d", fno);
356: printf("\t%2d\t%2d\t%5d\n", major(inode.i_dev), minor(inode.i_dev),
357: inode.i_number);
358: }
359:
360: getf()
361: {
362: int i;
363: struct file file;
364:
365: itrans(u.u_cdir, WD);
366: for (i = 0; i < NOFILE; i++) {
367: if (u.u_ofile[i] == 0)
368: continue;
369: lseek(kmem, (long) u.u_ofile[i], 0);
370: if (read(kmem, (char *) &file, sizeof(file)) != sizeof(file)) {
371: cantread("file", kmemf);
372: continue;
373: }
374: itrans(file.f_inode, i);
375: }
376: }
377:
378: usage()
379: {
380: fputs("usage: fstat [-u user] [-f filename] [-p pid]\n", stderr);
381: exit(1);
382: }
383:
384: getuname(uname)
385: char *uname;
386: {
387: struct passwd *passwd, *getpwnam();
388:
389: if ((passwd = getpwnam(uname)) == NULL)
390: return(-1);
391: return(passwd->pw_uid);
392: }
393:
394: getfname(filename)
395: char *filename;
396: {
397: struct stat statbuf;
398:
399: if (stat(filename, &statbuf) != 0)
400: return(-1);
401:
402: /*
403: * if file is block special, look for open files on it
404: */
405: if ((statbuf.st_mode & S_IFMT) != S_IFBLK) {
406: inum = statbuf.st_ino;
407: return(statbuf.st_dev);
408: } else {
409: special++;
410: inum = 0;
411: return(statbuf.st_rdev);
412: }
413: }
414:
415: Atoi(p)
416: register char *p;
417: {
418: register int n = 0;
419:
420: while(*p >= '0' && *p <= '9')
421: n = n*10 + *p++ - '0';
422: return(*p ? -n : n);
423: }
424: /* @(#)getpwent.c 4.1 (Berkeley) 12/21/80 */
425:
426: static char PASSWD[] = "/etc/passwd";
427: static char EMPTY[] = "";
428: static FILE *pwf = NULL;
429: static char line[BUFSIZ+1];
430: static struct passwd passwd;
431:
432: setpwent()
433: {
434: if( pwf == NULL )
435: pwf = fopen( PASSWD, "r" );
436: else
437: rewind( pwf );
438: }
439:
440: endpwent()
441: {
442: if( pwf != NULL ){
443: fclose( pwf );
444: pwf = NULL;
445: }
446: }
447:
448: static char *
449: pwskip(p)
450: register char *p;
451: {
452: while( *p && *p != ':' )
453: ++p;
454: if( *p ) *p++ = 0;
455: return(p);
456: }
457:
458: struct passwd *
459: getpwent()
460: {
461: register char *p;
462:
463: if (pwf == NULL) {
464: if( (pwf = fopen( PASSWD, "r" )) == NULL )
465: return(0);
466: }
467: p = fgets(line, BUFSIZ, pwf);
468: if (p==NULL)
469: return(0);
470: passwd.pw_name = p;
471: p = pwskip(p);
472: passwd.pw_passwd = p;
473: p = pwskip(p);
474: passwd.pw_uid = atoi(p);
475: p = pwskip(p);
476: passwd.pw_gid = atoi(p);
477: passwd.pw_quota = 0;
478: passwd.pw_comment = EMPTY;
479: p = pwskip(p);
480: passwd.pw_gecos = p;
481: p = pwskip(p);
482: passwd.pw_dir = p;
483: p = pwskip(p);
484: passwd.pw_shell = p;
485: while(*p && *p != '\n') p++;
486: *p = '\0';
487: return(&passwd);
488: }
489: /* @(#)getpwuid.c 4.1 (Berkeley) 12/21/80 */
490:
491: struct passwd *
492: getpwuid(uid)
493: register uid;
494: {
495: register struct passwd *p;
496: struct passwd *getpwent();
497:
498: setpwent();
499: while( (p = getpwent()) && p->pw_uid != uid );
500: endpwent();
501: return(p);
502: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.