Commit | Line | Data |
---|---|---|
07ed1e09 KM |
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 | ||
ce3b185b | 7 | #ifndef lint |
c0b7e584 | 8 | static char sccsid[] = "@(#)swap.c 5.2 (Berkeley) %G%"; |
07ed1e09 | 9 | #endif not lint |
ce3b185b SL |
10 | |
11 | #include "systat.h" | |
855ff304 KM |
12 | #include <sys/dir.h> |
13 | #include <sys/user.h> | |
14 | #include <sys/proc.h> | |
15 | #include <sys/text.h> | |
16 | #include <sys/conf.h> | |
855ff304 KM |
17 | #include <sys/vmmac.h> |
18 | #include <machine/pte.h> | |
ce3b185b | 19 | |
d830bff6 SL |
20 | WINDOW * |
21 | openswap() | |
ce3b185b SL |
22 | { |
23 | ||
b5eefd1e | 24 | return (subwin(stdscr, LINES-5-1, 0, 5, 0)); |
852c7064 SL |
25 | } |
26 | ||
d830bff6 SL |
27 | closeswap(w) |
28 | WINDOW *w; | |
852c7064 SL |
29 | { |
30 | ||
d830bff6 | 31 | if (w == NULL) |
c6265927 | 32 | return; |
d830bff6 SL |
33 | wclear(w); |
34 | wrefresh(w); | |
b5eefd1e | 35 | delwin(w); |
ce3b185b SL |
36 | } |
37 | ||
d830bff6 SL |
38 | int dmmin; |
39 | int dmmax; | |
40 | int dmtext; | |
41 | int nswdev; | |
42 | #define MAXSWAPDEV 4 | |
43 | short buckets[MAXSWAPDEV][NDMAP]; | |
44 | struct swdevt *swdevt; | |
e7a897ca SL |
45 | int colwidth; |
46 | ||
852c7064 SL |
47 | extern union { |
48 | struct user user; | |
49 | char upages[UPAGES][NBPG]; | |
50 | } user; | |
51 | #define u user.user | |
52 | ||
ce3b185b SL |
53 | showswap() |
54 | { | |
e7a897ca | 55 | register int i, j; |
852c7064 SL |
56 | register struct proc *pp; |
57 | register struct text *xp; | |
ce3b185b | 58 | register int row; |
852c7064 SL |
59 | register int ts; |
60 | register swblk_t *dp; | |
ce3b185b | 61 | |
c6265927 | 62 | if (xtext == 0) |
e7a897ca | 63 | return; |
852c7064 SL |
64 | for (xp = xtext; xp < &xtext[ntext]; xp++) { |
65 | if (xp->x_iptr == NULL) | |
66 | continue; | |
67 | ts = ctod(xp->x_size); | |
68 | dp = xp->x_daddr; | |
69 | for (i = 0; i < ts; i += dmtext) { | |
70 | j = ts - i; | |
71 | if (j > dmtext) | |
72 | j = dmtext; | |
73 | #define swatodev(addr) (((addr) / dmmax) % nswdev) | |
74 | buckets[swatodev(*dp)][dmtoindex(j)]++; | |
75 | dp++; | |
e7a897ca | 76 | } |
852c7064 SL |
77 | if ((xp->x_flag & XPAGI) && xp->x_ptdaddr) |
78 | buckets[swatodev(xp->x_ptdaddr)] | |
79 | [dmtoindex(ctod(ctopt(xp->x_size)))]++; | |
e7a897ca | 80 | } |
b5eefd1e | 81 | row = swapdisplay(2, dmtext, 'X'); |
c6265927 SL |
82 | if (kprocp == NULL) |
83 | return; | |
852c7064 SL |
84 | for (i = 0, pp = kprocp; i < nproc; i++, pp++) { |
85 | if (pp->p_stat == 0 || pp->p_stat == SZOMB) | |
86 | continue; | |
87 | if (pp->p_flag & SSYS) | |
88 | continue; | |
c6265927 | 89 | if (getu(pp) == 0) |
852c7064 | 90 | continue; |
852c7064 SL |
91 | vsacct(&u.u_dmap); |
92 | vsacct(&u.u_smap); | |
ce3b185b | 93 | #ifdef notdef |
852c7064 SL |
94 | if ((pp->p_flag & SLOAD) == 0) |
95 | vusize(pp); | |
ce3b185b | 96 | #endif |
852c7064 | 97 | } |
b5eefd1e | 98 | (void) swapdisplay(1+row, dmmax, 'X'); |
e7a897ca | 99 | } |
ce3b185b | 100 | |
b5eefd1e SL |
101 | #define OFFSET 5 /* left hand column */ |
102 | ||
852c7064 SL |
103 | swapdisplay(baserow, dmbound, c) |
104 | int baserow, dmbound; | |
105 | char c; | |
ce3b185b | 106 | { |
852c7064 SL |
107 | register int i, j, k, row; |
108 | register short *pb; | |
109 | char buf[10]; | |
ce3b185b | 110 | |
852c7064 SL |
111 | for (row = baserow, i = dmmin; i <= dmbound; i *= 2, row++) { |
112 | for (j = 0; j < nswdev; j++) { | |
113 | pb = &buckets[j][row - baserow]; | |
b5eefd1e | 114 | wmove(wnd, row, OFFSET + j * (1 + colwidth)); |
852c7064 SL |
115 | k = MIN(*pb, colwidth); |
116 | if (*pb > colwidth) { | |
117 | sprintf(buf, " %d", *pb); | |
118 | k -= strlen(buf); | |
119 | while (k--) | |
120 | waddch(wnd, c); | |
121 | waddstr(wnd, buf); | |
122 | } else { | |
123 | while (k--) | |
124 | waddch(wnd, c); | |
125 | k = MAX(colwidth - *pb, 0); | |
126 | while (k--) | |
127 | waddch(wnd, ' '); | |
e7a897ca | 128 | } |
852c7064 | 129 | *pb = 0; |
e7a897ca SL |
130 | } |
131 | } | |
852c7064 | 132 | return (row); |
ce3b185b SL |
133 | } |
134 | ||
852c7064 SL |
135 | vsacct(dmp) |
136 | register struct dmap *dmp; | |
ce3b185b | 137 | { |
852c7064 SL |
138 | register swblk_t *ip; |
139 | register int blk = dmmin, index = 0; | |
ce3b185b | 140 | |
852c7064 SL |
141 | for (ip = dmp->dm_map; dmp->dm_alloc > 0; ip++) { |
142 | if (ip - dmp->dm_map >= NDMAP) { | |
143 | error("vsacct NDMAP"); | |
144 | break; | |
145 | } | |
146 | if (*ip == 0) | |
147 | error("vsacct *ip == 0"); | |
148 | buckets[swatodev(*ip)][index]++; | |
149 | dmp->dm_alloc -= blk; | |
150 | if (blk < dmmax) { | |
151 | blk *= 2; | |
152 | index++; | |
e7a897ca | 153 | } |
e7a897ca | 154 | } |
852c7064 SL |
155 | } |
156 | ||
157 | dmtoindex(dm) | |
158 | int dm; | |
159 | { | |
160 | register int i, j; | |
161 | ||
162 | for (j = 0, i = dmmin; i <= dmmax; i *= 2, j++) | |
163 | if (dm <= i) | |
164 | return (j); | |
165 | error("dmtoindex(%d)", dm); | |
166 | return (NDMAP - 1); | |
ce3b185b | 167 | } |
d830bff6 SL |
168 | |
169 | static struct nlist nlst[] = { | |
170 | #define X_PROC 0 | |
171 | { "_proc" }, | |
172 | #define X_NPROC 1 | |
173 | { "_nproc" }, | |
174 | #define X_USRPTMAP 2 | |
175 | { "_Usrptmap" }, | |
176 | #define X_USRPT 3 | |
177 | { "_usrpt" }, | |
178 | #define X_NSWAP 4 | |
179 | { "_nswap" }, | |
180 | #define X_DMMIN 5 | |
181 | { "_dmmin" }, | |
182 | #define X_DMMAX 6 | |
183 | { "_dmmax" }, | |
184 | #define X_DMTEXT 7 | |
185 | { "_dmtext" }, | |
186 | #define X_NSWDEV 8 | |
187 | { "_nswdev" }, | |
188 | #define X_SWDEVT 9 | |
189 | { "_swdevt" }, | |
190 | #define X_NTEXT 10 | |
191 | { "_ntext" }, | |
192 | #define X_TEXT 11 | |
193 | { "_text" }, | |
194 | { "" } | |
195 | }; | |
196 | ||
197 | initswap() | |
198 | { | |
199 | ||
200 | if (nlst[X_PROC].n_type == 0) { | |
201 | nlist("/vmunix", nlst); | |
202 | if (nlst[X_PROC].n_type == 0) { | |
203 | error("namelist on /vmunix failed"); | |
c0b7e584 | 204 | return(0); |
d830bff6 SL |
205 | } |
206 | } | |
207 | if (nswdev == 0) { | |
208 | dmmin = getw(nlst[X_DMMIN].n_value); | |
209 | dmmax = getw(nlst[X_DMMAX].n_value); | |
210 | dmtext = getw(nlst[X_DMTEXT].n_value); | |
211 | nswdev = getw(nlst[X_NSWDEV].n_value); | |
212 | swdevt = (struct swdevt *)calloc(nswdev, sizeof (*swdevt)); | |
213 | klseek(kmem, nlst[X_SWDEVT].n_value, L_SET); | |
214 | read(kmem, swdevt, nswdev * sizeof (struct swdevt)); | |
215 | ntext = getw(nlst[X_NTEXT].n_value); | |
216 | textp = getw(nlst[X_TEXT].n_value); | |
217 | } | |
218 | if (procp == NULL) { | |
219 | procp = getw(nlst[X_PROC].n_value); | |
220 | nproc = getw(nlst[X_NPROC].n_value); | |
221 | } | |
222 | if (xtext == NULL) | |
223 | xtext = (struct text *)calloc(ntext, sizeof (struct text)); | |
224 | if (kprocp == NULL) | |
225 | kprocp = (struct proc *)calloc(nproc, sizeof (struct proc)); | |
226 | if (usrpt != NULL) | |
c0b7e584 | 227 | return(1); |
d830bff6 SL |
228 | usrpt = (struct pte *)nlst[X_USRPT].n_value; |
229 | Usrptma = (struct pte *)nlst[X_USRPTMAP].n_value; | |
230 | if (pt == NULL) | |
231 | pt = (struct p_times *)malloc(nproc * sizeof (struct p_times)); | |
c0b7e584 | 232 | return(1); |
d830bff6 SL |
233 | } |
234 | ||
235 | fetchswap() | |
236 | { | |
237 | ||
238 | if (nlst[X_PROC].n_type == 0) | |
239 | return; | |
240 | if (kprocp == NULL) { | |
241 | kprocp = (struct proc *)malloc(sizeof (*kprocp) * nproc); | |
242 | if (kprocp == NULL) | |
243 | return; | |
244 | } | |
245 | lseek(kmem, procp, L_SET); | |
246 | if (read(kmem, kprocp, sizeof (struct proc) * nproc) != | |
247 | sizeof (struct proc) * nproc) { | |
248 | error("couldn't read proc table"); | |
249 | return; | |
250 | } | |
251 | if (xtext == NULL) { | |
252 | xtext = (struct text *)calloc(ntext, sizeof (struct text)); | |
253 | if (xtext == NULL) | |
254 | return; | |
255 | } | |
256 | lseek(kmem, textp, L_SET); | |
257 | if (read(kmem, xtext, ntext * sizeof (struct text)) != | |
258 | sizeof (struct text) * ntext) | |
259 | error("couldn't read text table"); | |
260 | } | |
261 | ||
262 | #ifdef vax | |
263 | char *devnames[] = | |
264 | { "hp", "ht", "up", "rk", "sw", "tm", "ts", "mt", "tu", "ra", "ut", | |
265 | "rb", "rx", "rl" }; | |
266 | #endif | |
267 | ||
268 | labelswap() | |
269 | { | |
d830bff6 SL |
270 | register int row; |
271 | ||
272 | if (nswdev == 0) { | |
273 | error("Don't know how many swap devices.\n"); | |
274 | return; | |
275 | } | |
b5eefd1e SL |
276 | colwidth = (COLS - OFFSET - (nswdev - 1)) / nswdev; |
277 | row = swaplabel(0, dmtext, 1); | |
d830bff6 SL |
278 | (void) swaplabel(row, dmmax, 0); |
279 | } | |
280 | ||
281 | swaplabel(row, dmbound, donames) | |
282 | register int row; | |
283 | int dmbound, donames; | |
284 | { | |
285 | register int i, j; | |
286 | ||
287 | for (i = 0; i < nswdev; i++) { | |
b5eefd1e SL |
288 | if (donames) |
289 | mvwprintw(wnd, | |
290 | row, OFFSET + i*(1 + colwidth) + (colwidth - 3)/2, | |
291 | "%s%d", devnames[major(swdevt[i].sw_dev)], | |
292 | minor(swdevt[i].sw_dev) >> 3); | |
293 | for (j = 0; j + 5 < colwidth; j += 5) | |
294 | mvwprintw(wnd, row + donames, | |
295 | OFFSET + i*(1 + colwidth) + j, "/%-2d ", j); | |
d830bff6 SL |
296 | } |
297 | row += 1 + donames; | |
298 | for (j = 0, i = dmmin; i <= dmbound; i *= 2, j++, row++) { | |
299 | int k; | |
300 | ||
b5eefd1e | 301 | mvwprintw(wnd, row, 0, "%4d|", i); |
d830bff6 | 302 | for (k = 1; k < nswdev; k++) |
b5eefd1e | 303 | mvwaddch(wnd, row, OFFSET + k*(1 + colwidth) - 1, '|'); |
d830bff6 SL |
304 | } |
305 | return (row); | |
306 | } |