|
|
1.1 root 1: #include <stdio.h>
2: #include "ps.h"
3:
4: struct proc proc;
5:
6: union { struct user user; char userchars[UPAGES*NBPG]; } usp;
7: #define u usp.user
8: #define upages usp.userchars
9:
10: static char tmpstr[4096]; static Xflag;
11:
12: main(argc, argv)
13: int argc; char **argv;
14: {
15: register struct direct *dp;
16: register Psline *ps; Psline *psbegin, *psend;
17: register char *cp; register ncp, fd;
18:
19: progname=argv[0];
20:
21: if ((devlist = getdir("/dev", devlist)) == 0)
22: error("can't getdir /dev");
23: if ((devlist = getdir("/dev/dk", devlist)) == 0)
24: error("can't getdir /dev/dk");
25: if ((devlist = getdir("/dev/pt", devlist)) == 0)
26: error("can't getdir /dev/pt");
27: if ((drum = open("/dev/drum", 0)) < 0)
28: error("can't open /dev/drum");
29:
30: myuid = getuid(); mypid = getpid();
31:
32: if (argc > 1)
33: selbeg = selend = Malloc(Select, argc-1);
34: doarg(*++argv), Xflag = xflag && !tflag;
35: while (--argc > 1)
36: doarg(*++argv);
37:
38: if (hflag) {
39: if (uflag) printf("User %%cpu ");
40: if (lflag) printf("size rss ppid wchan ");
41: printf(" pid tty stat time command\n");
42: }
43:
44: if (Nflag && !tflag && !Fflag) {
45: register Select *sp;
46: Nflag = tflag = 0;
47: ++aflag; ++xflag;
48: for (sp=selbeg; sp<selend; sp++) {
49: if ((fd = doselect(sp->id, &proc, &u)) < 0)
50: continue;
51: if (printp(tmpstr, fd, &proc, &u) > tmpstr)
52: printf("%s", tmpstr);
53: }
54: return 0;
55: }
56:
57: if ((prlist = getdir("/proc", 0)) == 0)
58: error("can't getdir /proc");
59: if ((psbegin = Malloc(Psline, prlist->end - prlist->begin)) == 0)
60: error("can't malloc ps line table");
61:
62: for (ps = psbegin, dp = prlist->begin; dp < prlist->end; dp++) {
63: if (dp->d_ino == 0 || dp->d_name[0] == '.')
64: continue;
65: if ((fd = doselect(dp->d_name, &proc, &u)) < 0)
66: continue;
67: if ((cp = printp(tmpstr, fd, &proc, &u)) <= tmpstr)
68: continue;
69: if (nflag) {
70: printf("%s", tmpstr);
71: continue;
72: }
73: ncp = cp - tmpstr + 1;
74: ps->string = memcpy(malloc(ncp), tmpstr, ncp);
75: ps->weight = proc.p_pid;
76: if (uflag)
77: ps->weight += (1001 - (int)(1000.0*proc.p_pctcpu+0.5))<<16;
78: ps++;
79: }
80: if (!nflag) {
81: ptsort(psbegin, psend = --ps);
82: for (ps=psbegin; ps<=psend; ps++)
83: printf("%s", ps->string);
84: }
85: exit(0);
86: }
87:
88: doarg(cp)
89: register char *cp;
90: {
91: struct stat fds;
92: register Select *sp;
93: xflag = 0;
94: if (cp) do switch (*cp) {
95: case 0:
96: cp = 0; break;
97: case '-':
98: break;
99: case 't':
100: if (*++cp == '.') {
101: if (fstat(0, &fds) == 0) {
102: cp = gettty(fds.st_ino);
103: if (*cp == '?')
104: cp = 0;
105: } else {
106: fprintf(stderr, "0: cannot fstat\n");
107: cp = 0;
108: }
109: }
110: if (cp) {
111: ++tflag;
112: sp = selend++;
113: sp->flag = SELTTY;
114: if (Xflag || xflag)
115: sp->flag |= SELXFL;
116: sp->id = cp;
117: cp = 0;
118: }
119: break;
120: case 'a':
121: aflag++; break;
122: case 'F':
123: if (stat(++cp, &fds) == 0) {
124: Fflag++;
125: sp = selend++;
126: sp->flag = SELFIL;
127: sp->id = cp;
128: sp->dev = fds.st_dev;
129: sp->ino = fds.st_ino;
130: if (kernel <= 0)
131: kernel = open("/dev/kmemr", 0);
132: } else
133: fprintf(stderr, "%s: cannot stat\n", cp);
134: cp = 0;
135: break;
136: case 'f':
137: if (kernel <= 0)
138: kernel = open("/dev/kmemr", 0);
139: if (kernel)
140: fflag++, getfstab();
141: break;
142: case 'h':
143: hflag++; break;
144: case 'l':
145: lflag++; break;
146: case 'n':
147: nflag++; break;
148: case 'r':
149: rflag++; break;
150: case 'u':
151: uflag++; getlogins(); break;
152: case 'x':
153: xflag++; break;
154: case 'T':
155: Tflag++; break;
156: default:
157: if (*cp < '0' || *cp > '9')
158: usage();
159: ++Nflag;
160: sp = selend++;
161: sp->flag = SELXFL;
162: sp->id = cp;
163: cp = 0;
164: } while (cp++);
165: return 0;
166: }
167:
168: error(s)
169: char *s;
170: {
171: fprintf(stderr, "%s: %s\n", progname, s);
172: exit(1);
173: }
174:
175: usage()
176: {
177: fprintf(stderr, "Usage: %s [afhlnruxFt#] ...\n", progname);
178: exit(1);
179: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.