Annotation of src/usr.bin/systat/pool.c, Revision 1.20
1.20 ! jsg 1: /* $OpenBSD: pool.c,v 1.19 2019/06/28 13:35:04 deraadt Exp $ */
1.1 canacar 2: /*
3: * Copyright (c) 2008 Can Erkin Acar <canacar@openbsd.org>
4: *
5: * Permission to use, copy, modify, and distribute this software for any
6: * purpose with or without fee is hereby granted, provided that the above
7: * copyright notice and this permission notice appear in all copies.
8: *
9: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16: */
17:
18: #include <sys/types.h>
1.10 deraadt 19: #include <sys/signal.h>
1.1 canacar 20: #include <sys/sysctl.h>
21: #include <sys/pool.h>
22: #include <errno.h>
23: #include <stdlib.h>
1.3 chl 24: #include <string.h>
1.10 deraadt 25: #include <limits.h>
1.1 canacar 26:
27: #include "systat.h"
28:
1.12 dlg 29: #ifndef nitems
30: #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
31: #endif
32:
33: static int sysctl_rdint(const int *, unsigned int);
34: static int hw_ncpusfound(void);
35:
36: static int pool_get_npools(void);
37: static int pool_get_name(int, char *, size_t);
38: static int pool_get_cache(int, struct kinfo_pool_cache *);
39: static int pool_get_cache_cpus(int, struct kinfo_pool_cache_cpu *,
40: unsigned int);
41:
1.1 canacar 42: void print_pool(void);
43: int read_pool(void);
44: void sort_pool(void);
45: int select_pool(void);
46: void showpool(int k);
1.8 mpi 47: int pool_keyboard_callback(int);
1.1 canacar 48:
49: /* qsort callbacks */
50: int sort_name_callback(const void *s1, const void *s2);
1.2 canacar 51: int sort_req_callback(const void *s1, const void *s2);
1.4 canacar 52: int sort_psize_callback(const void *s1, const void *s2);
53: int sort_npage_callback(const void *s1, const void *s2);
1.1 canacar 54:
55: struct pool_info {
56: char name[32];
1.7 dlg 57: struct kinfo_pool pool;
1.1 canacar 58: };
59:
1.12 dlg 60: /*
61: * the kernel gives an array of ncpusfound * kinfo_pool_cache structs, but
62: * it's idea of how big that struct is may differ from here. we fetch both
63: * ncpusfound and the size it thinks kinfo_pool_cache is from sysctl, and
64: * then allocate the memory for this here.
65: */
66: struct pool_cache_info {
67: char name[32];
68: struct kinfo_pool_cache cache;
69: struct kinfo_pool_cache_cpu *cache_cpus;
70: };
1.1 canacar 71:
1.8 mpi 72: int print_all = 0;
1.1 canacar 73: int num_pools = 0;
74: struct pool_info *pools = NULL;
1.12 dlg 75: int num_pool_caches = 0;
76: struct pool_cache_info *pool_caches = NULL;
1.17 martijn 77: size_t pool_caches_size = 0;
1.1 canacar 78:
1.12 dlg 79: int ncpusfound = 0;
1.1 canacar 80:
81: field_def fields_pool[] = {
1.11 sthen 82: {"NAME", 12, 32, 1, FLD_ALIGN_LEFT, -1, 0, 0, 0},
1.1 canacar 83: {"SIZE", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
84: {"REQUESTS", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
85: {"FAIL", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
86: {"INUSE", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
87: {"PGREQ", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
88: {"PGREL", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
89: {"NPAGE", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
90: {"HIWAT", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
91: {"MINPG", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
92: {"MAXPG", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
93: {"IDLE", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0}
94: };
95:
1.6 jasper 96: #define FLD_POOL_NAME FIELD_ADDR(fields_pool,0)
97: #define FLD_POOL_SIZE FIELD_ADDR(fields_pool,1)
98: #define FLD_POOL_REQS FIELD_ADDR(fields_pool,2)
99: #define FLD_POOL_FAIL FIELD_ADDR(fields_pool,3)
100: #define FLD_POOL_INUSE FIELD_ADDR(fields_pool,4)
101: #define FLD_POOL_PGREQ FIELD_ADDR(fields_pool,5)
102: #define FLD_POOL_PGREL FIELD_ADDR(fields_pool,6)
103: #define FLD_POOL_NPAGE FIELD_ADDR(fields_pool,7)
104: #define FLD_POOL_HIWAT FIELD_ADDR(fields_pool,8)
105: #define FLD_POOL_MINPG FIELD_ADDR(fields_pool,9)
106: #define FLD_POOL_MAXPG FIELD_ADDR(fields_pool,10)
107: #define FLD_POOL_IDLE FIELD_ADDR(fields_pool,11)
1.1 canacar 108:
109: /* Define views */
110: field_def *view_pool_0[] = {
111: FLD_POOL_NAME, FLD_POOL_SIZE, FLD_POOL_REQS, FLD_POOL_FAIL,
112: FLD_POOL_INUSE, FLD_POOL_PGREQ, FLD_POOL_PGREL, FLD_POOL_NPAGE,
113: FLD_POOL_HIWAT, FLD_POOL_MINPG, FLD_POOL_MAXPG, FLD_POOL_IDLE, NULL
114: };
115:
116: order_type pool_order_list[] = {
1.2 canacar 117: {"name", "name", 'N', sort_name_callback},
118: {"requests", "requests", 'Q', sort_req_callback},
1.4 canacar 119: {"size", "size", 'Z', sort_psize_callback},
120: {"npages", "npages", 'P', sort_npage_callback},
1.1 canacar 121: {NULL, NULL, 0, NULL}
122: };
123:
124: /* Define view managers */
125: struct view_manager pool_mgr = {
126: "Pool", select_pool, read_pool, sort_pool, print_header,
1.8 mpi 127: print_pool, pool_keyboard_callback, pool_order_list, pool_order_list
1.1 canacar 128: };
129:
1.12 dlg 130: field_view pool_view = {
131: view_pool_0,
132: "pool",
133: '5',
134: &pool_mgr
135: };
136:
137: void pool_cache_print(void);
138: int pool_cache_read(void);
139: void pool_cache_sort(void);
140: void pool_cache_show(const struct pool_cache_info *);
1.17 martijn 141: int pool_cache_sort_name_callback(const void *, const void *);
142: int pool_cache_sort_len_callback(const void *, const void *);
143: int pool_cache_sort_idle_callback(const void *, const void *);
144: int pool_cache_sort_ngc_callback(const void *, const void *);
145: int pool_cache_sort_req_callback(const void *, const void *);
146: int pool_cache_sort_put_callback(const void *, const void *);
147: int pool_cache_sort_lreq_callback(const void *, const void *);
148: int pool_cache_sort_lput_callback(const void *, const void *);
1.12 dlg 149:
150: field_def pool_cache_fields[] = {
151: {"NAME", 12, 32, 1, FLD_ALIGN_LEFT, -1, 0, 0, 0},
152: {"LEN", 4, 4, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
1.13 dlg 153: {"IDLE", 4, 4, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
1.12 dlg 154: {"NGC", 4, 4, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
155: {"CPU", 4, 4, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
156: {"REQ", 8, 12, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
157: {"REL", 8, 12, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
158: {"LREQ", 8, 12, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
159: {"LREL", 8, 12, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
160: };
161:
162: #define FLD_POOL_CACHE_NAME FIELD_ADDR(pool_cache_fields, 0)
163: #define FLD_POOL_CACHE_LEN FIELD_ADDR(pool_cache_fields, 1)
1.13 dlg 164: #define FLD_POOL_CACHE_IDLE FIELD_ADDR(pool_cache_fields, 2)
1.12 dlg 165: #define FLD_POOL_CACHE_NGC FIELD_ADDR(pool_cache_fields, 3)
166: #define FLD_POOL_CACHE_CPU FIELD_ADDR(pool_cache_fields, 4)
167: #define FLD_POOL_CACHE_GET FIELD_ADDR(pool_cache_fields, 5)
168: #define FLD_POOL_CACHE_PUT FIELD_ADDR(pool_cache_fields, 6)
169: #define FLD_POOL_CACHE_LGET FIELD_ADDR(pool_cache_fields, 7)
170: #define FLD_POOL_CACHE_LPUT FIELD_ADDR(pool_cache_fields, 8)
171:
172: field_def *view_pool_cache_0[] = {
173: FLD_POOL_CACHE_NAME,
174: FLD_POOL_CACHE_LEN,
1.13 dlg 175: FLD_POOL_CACHE_IDLE,
1.12 dlg 176: FLD_POOL_CACHE_NGC,
177: FLD_POOL_CACHE_CPU,
178: FLD_POOL_CACHE_GET,
179: FLD_POOL_CACHE_PUT,
180: FLD_POOL_CACHE_LGET,
181: FLD_POOL_CACHE_LPUT,
182: NULL,
183: };
184:
185: order_type pool_cache_order_list[] = {
1.17 martijn 186: {"name", "name", 'N', pool_cache_sort_name_callback},
187: {"len", "len", 'L', pool_cache_sort_len_callback},
188: {"idle", "idle", 'I', pool_cache_sort_idle_callback},
189: {"ngc", "ngc", 'G', pool_cache_sort_ngc_callback},
190: {"requests", "requests", 'Q', pool_cache_sort_req_callback},
191: {"releases", "releases", 'P', pool_cache_sort_put_callback},
192: {"listrequests", "listrequests", 'E', pool_cache_sort_req_callback},
193: {"listreleases", "listreleases", 'U', pool_cache_sort_put_callback},
1.1 canacar 194: {NULL, NULL, 0, NULL}
195: };
196:
1.12 dlg 197: /* Define view managers */
198: struct view_manager pool_cache_mgr = {
199: "PoolCache",
1.17 martijn 200: NULL,
1.12 dlg 201: pool_cache_read,
202: pool_cache_sort,
203: print_header,
204: pool_cache_print,
205: pool_keyboard_callback,
206: pool_cache_order_list,
207: pool_cache_order_list
208: };
209:
210: field_view pool_cache_view = {
211: view_pool_cache_0,
212: "pcaches",
213: '5',
214: &pool_cache_mgr
215: };
1.1 canacar 216:
217: int
218: sort_name_callback(const void *s1, const void *s2)
219: {
220: struct pool_info *p1, *p2;
221: p1 = (struct pool_info *)s1;
222: p2 = (struct pool_info *)s2;
223:
1.2 canacar 224: return strcmp(p1->name, p2->name) * sortdir;
225: }
226:
227: int
228: sort_req_callback(const void *s1, const void *s2)
229: {
230: struct pool_info *p1, *p2;
231: p1 = (struct pool_info *)s1;
232: p2 = (struct pool_info *)s2;
233:
234: if (p1->pool.pr_nget < p2->pool.pr_nget)
235: return sortdir;
236: if (p1->pool.pr_nget > p2->pool.pr_nget)
237: return -sortdir;
238:
239: return sort_name_callback(s1, s2);
1.4 canacar 240: }
241:
242: int
243: sort_npage_callback(const void *s1, const void *s2)
244: {
245: struct pool_info *p1, *p2;
246: p1 = (struct pool_info *)s1;
247: p2 = (struct pool_info *)s2;
248:
249: if (p1->pool.pr_npages < p2->pool.pr_npages)
250: return sortdir;
251: if (p1->pool.pr_npages > p2->pool.pr_npages)
252: return -sortdir;
253:
254: return sort_name_callback(s1, s2);
255: }
256:
257: int
258: sort_psize_callback(const void *s1, const void *s2)
259: {
260: struct pool_info *p1, *p2;
261:
262: p1 = (struct pool_info *)s1;
263: p2 = (struct pool_info *)s2;
264:
1.16 martijn 265: if (p1->pool.pr_size < p2->pool.pr_size)
1.4 canacar 266: return sortdir;
1.16 martijn 267: if (p1->pool.pr_size > p2->pool.pr_size)
1.4 canacar 268: return -sortdir;
269:
270: return sort_npage_callback(s1, s2);
1.1 canacar 271: }
272:
273: void
274: sort_pool(void)
275: {
276: order_type *ordering;
277:
278: if (curr_mgr == NULL)
279: return;
280:
281: ordering = curr_mgr->order_curr;
282:
283: if (ordering == NULL)
284: return;
285: if (ordering->func == NULL)
286: return;
287: if (pools == NULL)
288: return;
289: if (num_pools <= 0)
290: return;
291:
1.2 canacar 292: mergesort(pools, num_pools, sizeof(struct pool_info), ordering->func);
1.1 canacar 293: }
294:
295: int
296: select_pool(void)
297: {
298: num_disp = num_pools;
299: return (0);
300: }
301:
302: int
303: read_pool(void)
304: {
1.12 dlg 305: int mib[] = { CTL_KERN, KERN_POOL, KERN_POOL_POOL, 0 };
306: struct pool_info *p;
307: int np, i;
1.1 canacar 308: size_t size;
309:
1.12 dlg 310: np = pool_get_npools();
311: if (np == -1) {
1.1 canacar 312: error("sysctl(npools): %s", strerror(errno));
313: return (-1);
314: }
315:
1.12 dlg 316: if (np == 0) {
317: free(pools);
318: pools = NULL;
1.1 canacar 319: num_pools = 0;
320: return (0);
321: }
322:
323: if (np > num_pools || pools == NULL) {
1.12 dlg 324: p = reallocarray(pools, np, sizeof(*pools));
1.1 canacar 325: if (p == NULL) {
326: error("realloc: %s", strerror(errno));
327: return (-1);
328: }
1.12 dlg 329: /* commit */
1.1 canacar 330: pools = p;
331: num_pools = np;
332: }
333:
1.5 canacar 334: num_disp = num_pools;
335:
1.1 canacar 336: for (i = 0; i < num_pools; i++) {
1.12 dlg 337: p = &pools[i];
338: np = i + 1;
339:
340: mib[3] = np;
1.7 dlg 341: size = sizeof(pools[i].pool);
1.19 deraadt 342: if (sysctl(mib, nitems(mib), &p->pool, &size, NULL, 0) == -1) {
1.12 dlg 343: p->name[0] = '\0';
1.5 canacar 344: num_disp--;
345: continue;
1.1 canacar 346: }
347:
1.12 dlg 348: if (pool_get_name(np, p->name, sizeof(p->name)) < 0)
349: snprintf(p->name, sizeof(p->name), "#%d#", i + 1);
1.1 canacar 350: }
351:
352: return 0;
353: }
354:
355:
356: void
357: print_pool(void)
358: {
1.8 mpi 359: struct pool_info *p;
1.5 canacar 360: int i, n, count = 0;
1.1 canacar 361:
362: if (pools == NULL)
363: return;
364:
1.5 canacar 365: for (n = i = 0; i < num_pools; i++) {
1.8 mpi 366: p = &pools[i];
367: if (p->name[0] == 0)
1.5 canacar 368: continue;
1.8 mpi 369:
370: if (!print_all &&
371: (p->pool.pr_nget == 0 && p->pool.pr_npagealloc == 0))
372: continue;
373:
1.5 canacar 374: if (n++ < dispstart)
375: continue;
376: showpool(i);
1.1 canacar 377: count++;
378: if (maxprint > 0 && count >= maxprint)
379: break;
380: }
381: }
382:
383: int
384: initpool(void)
385: {
1.12 dlg 386: add_view(&pool_view);
387: read_pool();
388:
389: ncpusfound = hw_ncpusfound();
390: if (ncpusfound == -1) {
391: error("sysctl(ncpusfound): %s", strerror(errno));
392: exit(1);
393: }
1.1 canacar 394:
1.12 dlg 395: add_view(&pool_cache_view);
396: pool_cache_read();
1.1 canacar 397:
398: return(0);
399: }
400:
401: void
402: showpool(int k)
403: {
404: struct pool_info *p = pools + k;
405:
406: if (k < 0 || k >= num_pools)
407: return;
408:
409: print_fld_str(FLD_POOL_NAME, p->name);
410: print_fld_uint(FLD_POOL_SIZE, p->pool.pr_size);
411:
412: print_fld_size(FLD_POOL_REQS, p->pool.pr_nget);
413: print_fld_size(FLD_POOL_FAIL, p->pool.pr_nfail);
414: print_fld_ssize(FLD_POOL_INUSE, p->pool.pr_nget - p->pool.pr_nput);
415: print_fld_size(FLD_POOL_PGREQ, p->pool.pr_npagealloc);
416: print_fld_size(FLD_POOL_PGREL, p->pool.pr_npagefree);
417:
418: print_fld_size(FLD_POOL_NPAGE, p->pool.pr_npages);
419: print_fld_size(FLD_POOL_HIWAT, p->pool.pr_hiwat);
420: print_fld_size(FLD_POOL_MINPG, p->pool.pr_minpages);
421:
422: if (p->pool.pr_maxpages == UINT_MAX)
423: print_fld_str(FLD_POOL_MAXPG, "inf");
424: else
425: print_fld_size(FLD_POOL_MAXPG, p->pool.pr_maxpages);
426:
427: print_fld_size(FLD_POOL_IDLE, p->pool.pr_nidle);
428:
429: end_line();
1.8 mpi 430: }
431:
432: int
433: pool_keyboard_callback(int ch)
434: {
435: switch (ch) {
436: case 'A':
437: print_all ^= 1;
438: gotsig_alarm = 1;
439: default:
440: return keyboard_callback(ch);
441: };
442:
443: return (1);
1.12 dlg 444: }
445:
446: int
447: pool_cache_read(void)
448: {
449: struct pool_cache_info *pc;
450: int np, i;
451:
452: np = pool_get_npools();
453: if (np == -1) {
454: error("sysctl(npools): %s", strerror(errno));
455: return (-1);
456: }
457:
1.17 martijn 458: if (np > pool_caches_size) {
1.12 dlg 459: pc = reallocarray(pool_caches, np, sizeof(*pc));
460: if (pc == NULL) {
461: error("realloc: %s", strerror(errno));
462: return (-1);
463: }
464: /* commit to using the new memory */
465: pool_caches = pc;
466:
1.17 martijn 467: for (i = pool_caches_size; i < np; i++) {
1.12 dlg 468: pc = &pool_caches[i];
469: pc->name[0] = '\0';
470:
471: pc->cache_cpus = reallocarray(NULL, ncpusfound,
472: sizeof(*pc->cache_cpus));
473: if (pc->cache_cpus == NULL) {
474: error("malloc cache cpus: %s", strerror(errno));
475: goto unalloc;
476: }
477: }
478:
479: /* commit to using the new cache_infos */
1.17 martijn 480: pool_caches_size = np;
1.12 dlg 481: }
482:
1.17 martijn 483: num_pool_caches = 0;
484: for (i = 0; i < pool_caches_size; i++) {
485: pc = &pool_caches[num_pool_caches];
1.12 dlg 486: np = i + 1;
487:
488: if (pool_get_cache(np, &pc->cache) < 0 ||
489: pool_get_cache_cpus(np, pc->cache_cpus, ncpusfound) < 0) {
490: pc->name[0] = '\0';
491: continue;
492: }
493:
494: if (pool_get_name(np, pc->name, sizeof(pc->name)) < 0)
495: snprintf(pc->name, sizeof(pc->name), "#%d#", i + 1);
1.17 martijn 496: num_pool_caches++;
1.12 dlg 497: }
498:
499: return 0;
500:
501: unalloc:
1.17 martijn 502: while (i > pool_caches_size) {
1.12 dlg 503: pc = &pool_caches[--i];
504: free(pc->cache_cpus);
505: }
1.14 florian 506: return (-1);
1.12 dlg 507: }
508:
509: void
510: pool_cache_sort(void)
511: {
512: order_type *ordering;
513:
514: if (curr_mgr == NULL)
515: return;
516:
517: ordering = curr_mgr->order_curr;
518:
519: if (ordering == NULL)
520: return;
521: if (ordering->func == NULL)
522: return;
1.17 martijn 523: if (pool_caches == NULL)
1.12 dlg 524: return;
1.17 martijn 525: if (num_pool_caches <= 0)
1.12 dlg 526: return;
527:
1.17 martijn 528: mergesort(pool_caches, num_pool_caches, sizeof(*pool_caches), ordering->func);
1.12 dlg 529: }
530:
531: void
532: pool_cache_print(void)
533: {
534: struct pool_cache_info *pc;
535: int i, n, count = 0;
536:
537: if (pool_caches == NULL)
538: return;
539:
540: for (n = i = 0; i < num_pool_caches; i++) {
541: pc = &pool_caches[i];
542: if (pc->name[0] == '\0')
543: continue;
544:
545: if (n++ < dispstart)
546: continue;
547:
548: pool_cache_show(pc);
549: count++;
550: if (maxprint > 0 && count >= maxprint)
551: break;
552: }
553: }
554:
555: void
556: pool_cache_show(const struct pool_cache_info *pc)
557: {
558: const struct kinfo_pool_cache *kpc;
559: const struct kinfo_pool_cache_cpu *kpcc;
560: int cpu;
561:
562: kpc = &pc->cache;
563:
564: print_fld_str(FLD_POOL_CACHE_NAME, pc->name);
565: print_fld_uint(FLD_POOL_CACHE_LEN, kpc->pr_len);
1.13 dlg 566: print_fld_uint(FLD_POOL_CACHE_IDLE, kpc->pr_nitems);
1.15 dlg 567: print_fld_size(FLD_POOL_CACHE_NGC, kpc->pr_ngc);
1.12 dlg 568:
569: for (cpu = 0; cpu < ncpusfound; cpu++) {
570: kpcc = &pc->cache_cpus[cpu];
571:
572: print_fld_uint(FLD_POOL_CACHE_CPU, kpcc->pr_cpu);
573:
574: print_fld_size(FLD_POOL_CACHE_GET, kpcc->pr_nget);
575: print_fld_size(FLD_POOL_CACHE_PUT, kpcc->pr_nput);
576: print_fld_size(FLD_POOL_CACHE_LGET, kpcc->pr_nlget);
577: print_fld_size(FLD_POOL_CACHE_LPUT, kpcc->pr_nlput);
578: end_line();
579: }
1.17 martijn 580: }
581:
582: int
583: pool_cache_sort_name_callback(const void *s1, const void *s2)
584: {
585: struct pool_cache_info *pc1, *pc2;
586: pc1 = (struct pool_cache_info *)s1;
587: pc2 = (struct pool_cache_info *)s2;
588:
589: return strcmp(pc1->name, pc2->name) * sortdir;
590: }
591:
592: int
593: pool_cache_sort_len_callback(const void *s1, const void *s2)
594: {
595: struct pool_cache_info *pc1, *pc2;
596: pc1 = (struct pool_cache_info *)s1;
597: pc2 = (struct pool_cache_info *)s2;
598:
599: if (pc1->cache.pr_len < pc2->cache.pr_len)
600: return sortdir;
601: if (pc1->cache.pr_len > pc2->cache.pr_len)
602: return -sortdir;
603:
604: return pool_cache_sort_name_callback(s1, s2);
605: }
606:
607: int
608: pool_cache_sort_idle_callback(const void *s1, const void *s2)
609: {
610: struct pool_cache_info *pc1, *pc2;
611: pc1 = (struct pool_cache_info *)s1;
612: pc2 = (struct pool_cache_info *)s2;
613:
614: if (pc1->cache.pr_nitems < pc2->cache.pr_nitems)
615: return sortdir;
616: if (pc1->cache.pr_nitems > pc2->cache.pr_nitems)
617: return -sortdir;
618:
619: return pool_cache_sort_name_callback(s1, s2);
620: }
621:
622: int
623: pool_cache_sort_ngc_callback(const void *s1, const void *s2)
624: {
625: struct pool_cache_info *pc1, *pc2;
626: pc1 = (struct pool_cache_info *)s1;
627: pc2 = (struct pool_cache_info *)s2;
628:
629: if (pc1->cache.pr_ngc < pc2->cache.pr_ngc)
630: return sortdir;
631: if (pc1->cache.pr_ngc > pc2->cache.pr_ngc)
632: return -sortdir;
633:
634: return pool_cache_sort_name_callback(s1, s2);
635: }
636:
637: int
638: pool_cache_sort_req_callback(const void *s1, const void *s2)
639: {
640: struct pool_cache_info *pc1, *pc2;
641: uint64_t nget1 = 0, nget2 = 0;
642: int oflow1 = 0, oflow2 = 0;
643: int cpu;
644:
645: pc1 = (struct pool_cache_info *)s1;
646: pc2 = (struct pool_cache_info *)s2;
647:
648: for (cpu = 0; cpu < ncpusfound; cpu++) {
649: if (nget1 + pc1->cache_cpus->pr_nget < nget1)
650: oflow1++;
651: nget1 += pc1->cache_cpus->pr_nget;
652: if (nget2 + pc2->cache_cpus->pr_nget < nget2)
653: oflow2++;
654: nget2 += pc2->cache_cpus->pr_nget;
655: }
656:
657: if (oflow1 < oflow2)
658: return sortdir;
659: if (oflow1 > oflow2)
660: return -sortdir;
661: if (nget1 < nget2)
662: return sortdir;
663: if (nget1 > nget2)
664: return -sortdir;
665:
666: return pool_cache_sort_name_callback(s1, s2);
667: }
668:
669: int
670: pool_cache_sort_put_callback(const void *s1, const void *s2)
671: {
672: struct pool_cache_info *pc1, *pc2;
673: uint64_t nput1 = 0, nput2 = 0;
674: int oflow1 = 0, oflow2 = 0;
675: int cpu;
676:
677: pc1 = (struct pool_cache_info *)s1;
678: pc2 = (struct pool_cache_info *)s2;
679:
680: for (cpu = 0; cpu < ncpusfound; cpu++) {
681: if (nput1 + pc1->cache_cpus->pr_nput < nput1)
682: oflow1++;
683: nput1 += pc1->cache_cpus->pr_nput;
684: if (nput2 + pc2->cache_cpus->pr_nput < nput2)
685: oflow2++;
686: nput2 += pc2->cache_cpus->pr_nput;
687: }
688:
689: if (oflow1 < oflow2)
690: return sortdir;
691: if (oflow1 > oflow2)
692: return -sortdir;
693: if (nput1 < nput2)
694: return sortdir;
695: if (nput1 > nput2)
696: return -sortdir;
697:
698: return pool_cache_sort_name_callback(s1, s2);
699: }
700:
701: int
702: pool_cache_sort_lreq_callback(const void *s1, const void *s2)
703: {
704: struct pool_cache_info *pc1, *pc2;
705: uint64_t nlget1 = 0, nlget2 = 0;
706: int oflow1 = 0, oflow2 = 0;
707: int cpu;
708:
709: pc1 = (struct pool_cache_info *)s1;
710: pc2 = (struct pool_cache_info *)s2;
711:
712: for (cpu = 0; cpu < ncpusfound; cpu++) {
713: if (nlget1 + pc1->cache_cpus->pr_nlget < nlget1)
714: oflow1++;
715: nlget1 += pc1->cache_cpus->pr_nlget;
716: if (nlget2 + pc2->cache_cpus->pr_nlget < nlget2)
717: oflow2++;
718: nlget2 += pc2->cache_cpus->pr_nlget;
719: }
720:
721: if (oflow1 < oflow2)
722: return sortdir;
723: if (oflow1 > oflow2)
724: return -sortdir;
725: if (nlget1 < nlget2)
726: return sortdir;
727: if (nlget1 > nlget2)
728: return -sortdir;
729:
730: return pool_cache_sort_name_callback(s1, s2);
731: }
732:
733: int
734: pool_cache_sort_lput_callback(const void *s1, const void *s2)
735: {
736: struct pool_cache_info *pc1, *pc2;
737: uint64_t nlput1 = 0, nlput2 = 0;
738: int oflow1 = 0, oflow2 = 0;
739: int cpu;
740:
741: pc1 = (struct pool_cache_info *)s1;
742: pc2 = (struct pool_cache_info *)s2;
743:
744: for (cpu = 0; cpu < ncpusfound; cpu++) {
745: if (nlput1 + pc1->cache_cpus->pr_nlput < nlput1)
746: oflow1++;
747: nlput1 += pc1->cache_cpus->pr_nlput;
748: if (nlput2 + pc2->cache_cpus->pr_nlput < nlput2)
749: oflow2++;
750: nlput2 += pc2->cache_cpus->pr_nlput;
751: }
1.12 dlg 752:
1.17 martijn 753: if (oflow1 < oflow2)
754: return sortdir;
755: if (oflow1 > oflow2)
756: return -sortdir;
757: if (nlput1 < nlput2)
758: return sortdir;
759: if (nlput1 > nlput2)
760: return -sortdir;
761:
762: return pool_cache_sort_name_callback(s1, s2);
1.12 dlg 763: }
764:
1.17 martijn 765: int
1.12 dlg 766: pool_get_npools(void)
767: {
768: int mib[] = { CTL_KERN, KERN_POOL, KERN_POOL_NPOOLS };
769:
770: return (sysctl_rdint(mib, nitems(mib)));
771: }
772:
773: static int
774: pool_get_cache(int pool, struct kinfo_pool_cache *kpc)
775: {
776: int mib[] = { CTL_KERN, KERN_POOL, KERN_POOL_CACHE, pool };
777: size_t len = sizeof(*kpc);
778:
779: return (sysctl(mib, nitems(mib), kpc, &len, NULL, 0));
780: }
781:
782: static int
783: pool_get_cache_cpus(int pool, struct kinfo_pool_cache_cpu *kpcc,
784: unsigned int ncpus)
785: {
786: int mib[] = { CTL_KERN, KERN_POOL, KERN_POOL_CACHE_CPUS, pool };
787: size_t len = sizeof(*kpcc) * ncpus;
788:
789: return (sysctl(mib, nitems(mib), kpcc, &len, NULL, 0));
790: }
791:
792: static int
793: pool_get_name(int pool, char *name, size_t len)
794: {
795: int mib[] = { CTL_KERN, KERN_POOL, KERN_POOL_NAME, pool };
796:
797: return (sysctl(mib, nitems(mib), name, &len, NULL, 0));
798: }
799:
800: static int
801: hw_ncpusfound(void)
802: {
803: int mib[] = { CTL_HW, HW_NCPUFOUND };
804:
805: return (sysctl_rdint(mib, nitems(mib)));
806: }
807:
808: static int
809: sysctl_rdint(const int *mib, unsigned int nmib)
810: {
811: int i;
812: size_t size = sizeof(i);
813:
814: if (sysctl(mib, nmib, &i, &size, NULL, 0) == -1)
815: return (-1);
816:
817: return (i);
1.1 canacar 818: }
![[BACK]](/icons/back.gif){kind=icon}
Return to pool.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / systat