Annotation of src/usr.bin/systat/pool.c, Revision 1.17
1.17 ! martijn 1: /* $OpenBSD: pool.c,v 1.16 2018/02/08 13:22:25 martijn 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: int pool_cache_kbd_cb(int);
150:
151: field_def pool_cache_fields[] = {
152: {"NAME", 12, 32, 1, FLD_ALIGN_LEFT, -1, 0, 0, 0},
153: {"LEN", 4, 4, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
1.13 dlg 154: {"IDLE", 4, 4, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
1.12 dlg 155: {"NGC", 4, 4, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
156: {"CPU", 4, 4, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
157: {"REQ", 8, 12, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
158: {"REL", 8, 12, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
159: {"LREQ", 8, 12, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
160: {"LREL", 8, 12, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
161: };
162:
163: #define FLD_POOL_CACHE_NAME FIELD_ADDR(pool_cache_fields, 0)
164: #define FLD_POOL_CACHE_LEN FIELD_ADDR(pool_cache_fields, 1)
1.13 dlg 165: #define FLD_POOL_CACHE_IDLE FIELD_ADDR(pool_cache_fields, 2)
1.12 dlg 166: #define FLD_POOL_CACHE_NGC FIELD_ADDR(pool_cache_fields, 3)
167: #define FLD_POOL_CACHE_CPU FIELD_ADDR(pool_cache_fields, 4)
168: #define FLD_POOL_CACHE_GET FIELD_ADDR(pool_cache_fields, 5)
169: #define FLD_POOL_CACHE_PUT FIELD_ADDR(pool_cache_fields, 6)
170: #define FLD_POOL_CACHE_LGET FIELD_ADDR(pool_cache_fields, 7)
171: #define FLD_POOL_CACHE_LPUT FIELD_ADDR(pool_cache_fields, 8)
172:
173: field_def *view_pool_cache_0[] = {
174: FLD_POOL_CACHE_NAME,
175: FLD_POOL_CACHE_LEN,
1.13 dlg 176: FLD_POOL_CACHE_IDLE,
1.12 dlg 177: FLD_POOL_CACHE_NGC,
178: FLD_POOL_CACHE_CPU,
179: FLD_POOL_CACHE_GET,
180: FLD_POOL_CACHE_PUT,
181: FLD_POOL_CACHE_LGET,
182: FLD_POOL_CACHE_LPUT,
183: NULL,
184: };
185:
186: order_type pool_cache_order_list[] = {
1.17 ! martijn 187: {"name", "name", 'N', pool_cache_sort_name_callback},
! 188: {"len", "len", 'L', pool_cache_sort_len_callback},
! 189: {"idle", "idle", 'I', pool_cache_sort_idle_callback},
! 190: {"ngc", "ngc", 'G', pool_cache_sort_ngc_callback},
! 191: {"requests", "requests", 'Q', pool_cache_sort_req_callback},
! 192: {"releases", "releases", 'P', pool_cache_sort_put_callback},
! 193: {"listrequests", "listrequests", 'E', pool_cache_sort_req_callback},
! 194: {"listreleases", "listreleases", 'U', pool_cache_sort_put_callback},
1.1 canacar 195: {NULL, NULL, 0, NULL}
196: };
197:
1.12 dlg 198: /* Define view managers */
199: struct view_manager pool_cache_mgr = {
200: "PoolCache",
1.17 ! martijn 201: NULL,
1.12 dlg 202: pool_cache_read,
203: pool_cache_sort,
204: print_header,
205: pool_cache_print,
206: pool_keyboard_callback,
207: pool_cache_order_list,
208: pool_cache_order_list
209: };
210:
211: field_view pool_cache_view = {
212: view_pool_cache_0,
213: "pcaches",
214: '5',
215: &pool_cache_mgr
216: };
1.1 canacar 217:
218: int
219: sort_name_callback(const void *s1, const void *s2)
220: {
221: struct pool_info *p1, *p2;
222: p1 = (struct pool_info *)s1;
223: p2 = (struct pool_info *)s2;
224:
1.2 canacar 225: return strcmp(p1->name, p2->name) * sortdir;
226: }
227:
228: int
229: sort_req_callback(const void *s1, const void *s2)
230: {
231: struct pool_info *p1, *p2;
232: p1 = (struct pool_info *)s1;
233: p2 = (struct pool_info *)s2;
234:
235: if (p1->pool.pr_nget < p2->pool.pr_nget)
236: return sortdir;
237: if (p1->pool.pr_nget > p2->pool.pr_nget)
238: return -sortdir;
239:
240: return sort_name_callback(s1, s2);
1.4 canacar 241: }
242:
243: int
244: sort_npage_callback(const void *s1, const void *s2)
245: {
246: struct pool_info *p1, *p2;
247: p1 = (struct pool_info *)s1;
248: p2 = (struct pool_info *)s2;
249:
250: if (p1->pool.pr_npages < p2->pool.pr_npages)
251: return sortdir;
252: if (p1->pool.pr_npages > p2->pool.pr_npages)
253: return -sortdir;
254:
255: return sort_name_callback(s1, s2);
256: }
257:
258: int
259: sort_psize_callback(const void *s1, const void *s2)
260: {
261: struct pool_info *p1, *p2;
262:
263: p1 = (struct pool_info *)s1;
264: p2 = (struct pool_info *)s2;
265:
1.16 martijn 266: if (p1->pool.pr_size < p2->pool.pr_size)
1.4 canacar 267: return sortdir;
1.16 martijn 268: if (p1->pool.pr_size > p2->pool.pr_size)
1.4 canacar 269: return -sortdir;
270:
271: return sort_npage_callback(s1, s2);
1.1 canacar 272: }
273:
274: void
275: sort_pool(void)
276: {
277: order_type *ordering;
278:
279: if (curr_mgr == NULL)
280: return;
281:
282: ordering = curr_mgr->order_curr;
283:
284: if (ordering == NULL)
285: return;
286: if (ordering->func == NULL)
287: return;
288: if (pools == NULL)
289: return;
290: if (num_pools <= 0)
291: return;
292:
1.2 canacar 293: mergesort(pools, num_pools, sizeof(struct pool_info), ordering->func);
1.1 canacar 294: }
295:
296: int
297: select_pool(void)
298: {
299: num_disp = num_pools;
300: return (0);
301: }
302:
303: int
304: read_pool(void)
305: {
1.12 dlg 306: int mib[] = { CTL_KERN, KERN_POOL, KERN_POOL_POOL, 0 };
307: struct pool_info *p;
308: int np, i;
1.1 canacar 309: size_t size;
310:
1.12 dlg 311: np = pool_get_npools();
312: if (np == -1) {
1.1 canacar 313: error("sysctl(npools): %s", strerror(errno));
314: return (-1);
315: }
316:
1.12 dlg 317: if (np == 0) {
318: free(pools);
319: pools = NULL;
1.1 canacar 320: num_pools = 0;
321: return (0);
322: }
323:
324: if (np > num_pools || pools == NULL) {
1.12 dlg 325: p = reallocarray(pools, np, sizeof(*pools));
1.1 canacar 326: if (p == NULL) {
327: error("realloc: %s", strerror(errno));
328: return (-1);
329: }
1.12 dlg 330: /* commit */
1.1 canacar 331: pools = p;
332: num_pools = np;
333: }
334:
1.5 canacar 335: num_disp = num_pools;
336:
1.1 canacar 337: for (i = 0; i < num_pools; i++) {
1.12 dlg 338: p = &pools[i];
339: np = i + 1;
340:
341: mib[3] = np;
1.7 dlg 342: size = sizeof(pools[i].pool);
1.12 dlg 343: if (sysctl(mib, nitems(mib), &p->pool, &size, NULL, 0) < 0) {
344: p->name[0] = '\0';
1.5 canacar 345: num_disp--;
346: continue;
1.1 canacar 347: }
348:
1.12 dlg 349: if (pool_get_name(np, p->name, sizeof(p->name)) < 0)
350: snprintf(p->name, sizeof(p->name), "#%d#", i + 1);
1.1 canacar 351: }
352:
353: return 0;
354: }
355:
356:
357: void
358: print_pool(void)
359: {
1.8 mpi 360: struct pool_info *p;
1.5 canacar 361: int i, n, count = 0;
1.1 canacar 362:
363: if (pools == NULL)
364: return;
365:
1.5 canacar 366: for (n = i = 0; i < num_pools; i++) {
1.8 mpi 367: p = &pools[i];
368: if (p->name[0] == 0)
1.5 canacar 369: continue;
1.8 mpi 370:
371: if (!print_all &&
372: (p->pool.pr_nget == 0 && p->pool.pr_npagealloc == 0))
373: continue;
374:
1.5 canacar 375: if (n++ < dispstart)
376: continue;
377: showpool(i);
1.1 canacar 378: count++;
379: if (maxprint > 0 && count >= maxprint)
380: break;
381: }
382: }
383:
384: int
385: initpool(void)
386: {
387: field_view *v;
388:
1.12 dlg 389: add_view(&pool_view);
390: read_pool();
391:
392: ncpusfound = hw_ncpusfound();
393: if (ncpusfound == -1) {
394: error("sysctl(ncpusfound): %s", strerror(errno));
395: exit(1);
396: }
1.1 canacar 397:
1.12 dlg 398: add_view(&pool_cache_view);
399: pool_cache_read();
1.1 canacar 400:
401: return(0);
402: }
403:
404: void
405: showpool(int k)
406: {
407: struct pool_info *p = pools + k;
408:
409: if (k < 0 || k >= num_pools)
410: return;
411:
412: print_fld_str(FLD_POOL_NAME, p->name);
413: print_fld_uint(FLD_POOL_SIZE, p->pool.pr_size);
414:
415: print_fld_size(FLD_POOL_REQS, p->pool.pr_nget);
416: print_fld_size(FLD_POOL_FAIL, p->pool.pr_nfail);
417: print_fld_ssize(FLD_POOL_INUSE, p->pool.pr_nget - p->pool.pr_nput);
418: print_fld_size(FLD_POOL_PGREQ, p->pool.pr_npagealloc);
419: print_fld_size(FLD_POOL_PGREL, p->pool.pr_npagefree);
420:
421: print_fld_size(FLD_POOL_NPAGE, p->pool.pr_npages);
422: print_fld_size(FLD_POOL_HIWAT, p->pool.pr_hiwat);
423: print_fld_size(FLD_POOL_MINPG, p->pool.pr_minpages);
424:
425: if (p->pool.pr_maxpages == UINT_MAX)
426: print_fld_str(FLD_POOL_MAXPG, "inf");
427: else
428: print_fld_size(FLD_POOL_MAXPG, p->pool.pr_maxpages);
429:
430: print_fld_size(FLD_POOL_IDLE, p->pool.pr_nidle);
431:
432: end_line();
1.8 mpi 433: }
434:
435: int
436: pool_keyboard_callback(int ch)
437: {
438: switch (ch) {
439: case 'A':
440: print_all ^= 1;
441: gotsig_alarm = 1;
442: default:
443: return keyboard_callback(ch);
444: };
445:
446: return (1);
1.12 dlg 447: }
448:
449: int
450: pool_cache_read(void)
451: {
452: struct pool_cache_info *pc;
453: int np, i;
454:
455: np = pool_get_npools();
456: if (np == -1) {
457: error("sysctl(npools): %s", strerror(errno));
458: return (-1);
459: }
460:
1.17 ! martijn 461: if (np > pool_caches_size) {
1.12 dlg 462: pc = reallocarray(pool_caches, np, sizeof(*pc));
463: if (pc == NULL) {
464: error("realloc: %s", strerror(errno));
465: return (-1);
466: }
467: /* commit to using the new memory */
468: pool_caches = pc;
469:
1.17 ! martijn 470: for (i = pool_caches_size; i < np; i++) {
1.12 dlg 471: pc = &pool_caches[i];
472: pc->name[0] = '\0';
473:
474: pc->cache_cpus = reallocarray(NULL, ncpusfound,
475: sizeof(*pc->cache_cpus));
476: if (pc->cache_cpus == NULL) {
477: error("malloc cache cpus: %s", strerror(errno));
478: goto unalloc;
479: }
480: }
481:
482: /* commit to using the new cache_infos */
1.17 ! martijn 483: pool_caches_size = np;
1.12 dlg 484: }
485:
1.17 ! martijn 486: num_pool_caches = 0;
! 487: for (i = 0; i < pool_caches_size; i++) {
! 488: pc = &pool_caches[num_pool_caches];
1.12 dlg 489: np = i + 1;
490:
491: if (pool_get_cache(np, &pc->cache) < 0 ||
492: pool_get_cache_cpus(np, pc->cache_cpus, ncpusfound) < 0) {
493: pc->name[0] = '\0';
494: continue;
495: }
496:
497: if (pool_get_name(np, pc->name, sizeof(pc->name)) < 0)
498: snprintf(pc->name, sizeof(pc->name), "#%d#", i + 1);
1.17 ! martijn 499: num_pool_caches++;
1.12 dlg 500: }
501:
502: return 0;
503:
504: unalloc:
1.17 ! martijn 505: while (i > pool_caches_size) {
1.12 dlg 506: pc = &pool_caches[--i];
507: free(pc->cache_cpus);
508: }
1.14 florian 509: return (-1);
1.12 dlg 510: }
511:
512: void
513: pool_cache_sort(void)
514: {
515: order_type *ordering;
516:
517: if (curr_mgr == NULL)
518: return;
519:
520: ordering = curr_mgr->order_curr;
521:
522: if (ordering == NULL)
523: return;
524: if (ordering->func == NULL)
525: return;
1.17 ! martijn 526: if (pool_caches == NULL)
1.12 dlg 527: return;
1.17 ! martijn 528: if (num_pool_caches <= 0)
1.12 dlg 529: return;
530:
1.17 ! martijn 531: mergesort(pool_caches, num_pool_caches, sizeof(*pool_caches), ordering->func);
1.12 dlg 532: }
533:
534: void
535: pool_cache_print(void)
536: {
537: struct pool_cache_info *pc;
538: int i, n, count = 0;
539:
540: if (pool_caches == NULL)
541: return;
542:
543: for (n = i = 0; i < num_pool_caches; i++) {
544: pc = &pool_caches[i];
545: if (pc->name[0] == '\0')
546: continue;
547:
548: if (n++ < dispstart)
549: continue;
550:
551: pool_cache_show(pc);
552: count++;
553: if (maxprint > 0 && count >= maxprint)
554: break;
555: }
556: }
557:
558: void
559: pool_cache_show(const struct pool_cache_info *pc)
560: {
561: const struct kinfo_pool_cache *kpc;
562: const struct kinfo_pool_cache_cpu *kpcc;
563: int cpu;
564:
565: kpc = &pc->cache;
566:
567: print_fld_str(FLD_POOL_CACHE_NAME, pc->name);
568: print_fld_uint(FLD_POOL_CACHE_LEN, kpc->pr_len);
1.13 dlg 569: print_fld_uint(FLD_POOL_CACHE_IDLE, kpc->pr_nitems);
1.15 dlg 570: print_fld_size(FLD_POOL_CACHE_NGC, kpc->pr_ngc);
1.12 dlg 571:
572: for (cpu = 0; cpu < ncpusfound; cpu++) {
573: kpcc = &pc->cache_cpus[cpu];
574:
575: print_fld_uint(FLD_POOL_CACHE_CPU, kpcc->pr_cpu);
576:
577: print_fld_size(FLD_POOL_CACHE_GET, kpcc->pr_nget);
578: print_fld_size(FLD_POOL_CACHE_PUT, kpcc->pr_nput);
579: print_fld_size(FLD_POOL_CACHE_LGET, kpcc->pr_nlget);
580: print_fld_size(FLD_POOL_CACHE_LPUT, kpcc->pr_nlput);
581: end_line();
582: }
1.17 ! martijn 583: }
! 584:
! 585: int
! 586: pool_cache_sort_name_callback(const void *s1, const void *s2)
! 587: {
! 588: struct pool_cache_info *pc1, *pc2;
! 589: pc1 = (struct pool_cache_info *)s1;
! 590: pc2 = (struct pool_cache_info *)s2;
! 591:
! 592: return strcmp(pc1->name, pc2->name) * sortdir;
! 593: }
! 594:
! 595: int
! 596: pool_cache_sort_len_callback(const void *s1, const void *s2)
! 597: {
! 598: struct pool_cache_info *pc1, *pc2;
! 599: pc1 = (struct pool_cache_info *)s1;
! 600: pc2 = (struct pool_cache_info *)s2;
! 601:
! 602: if (pc1->cache.pr_len < pc2->cache.pr_len)
! 603: return sortdir;
! 604: if (pc1->cache.pr_len > pc2->cache.pr_len)
! 605: return -sortdir;
! 606:
! 607: return pool_cache_sort_name_callback(s1, s2);
! 608: }
! 609:
! 610: int
! 611: pool_cache_sort_idle_callback(const void *s1, const void *s2)
! 612: {
! 613: struct pool_cache_info *pc1, *pc2;
! 614: pc1 = (struct pool_cache_info *)s1;
! 615: pc2 = (struct pool_cache_info *)s2;
! 616:
! 617: if (pc1->cache.pr_nitems < pc2->cache.pr_nitems)
! 618: return sortdir;
! 619: if (pc1->cache.pr_nitems > pc2->cache.pr_nitems)
! 620: return -sortdir;
! 621:
! 622: return pool_cache_sort_name_callback(s1, s2);
! 623: }
! 624:
! 625: int
! 626: pool_cache_sort_ngc_callback(const void *s1, const void *s2)
! 627: {
! 628: struct pool_cache_info *pc1, *pc2;
! 629: pc1 = (struct pool_cache_info *)s1;
! 630: pc2 = (struct pool_cache_info *)s2;
! 631:
! 632: if (pc1->cache.pr_ngc < pc2->cache.pr_ngc)
! 633: return sortdir;
! 634: if (pc1->cache.pr_ngc > pc2->cache.pr_ngc)
! 635: return -sortdir;
! 636:
! 637: return pool_cache_sort_name_callback(s1, s2);
! 638: }
! 639:
! 640: int
! 641: pool_cache_sort_req_callback(const void *s1, const void *s2)
! 642: {
! 643: struct pool_cache_info *pc1, *pc2;
! 644: uint64_t nget1 = 0, nget2 = 0;
! 645: int oflow1 = 0, oflow2 = 0;
! 646: int cpu;
! 647:
! 648: pc1 = (struct pool_cache_info *)s1;
! 649: pc2 = (struct pool_cache_info *)s2;
! 650:
! 651: for (cpu = 0; cpu < ncpusfound; cpu++) {
! 652: if (nget1 + pc1->cache_cpus->pr_nget < nget1)
! 653: oflow1++;
! 654: nget1 += pc1->cache_cpus->pr_nget;
! 655: if (nget2 + pc2->cache_cpus->pr_nget < nget2)
! 656: oflow2++;
! 657: nget2 += pc2->cache_cpus->pr_nget;
! 658: }
! 659:
! 660: if (oflow1 < oflow2)
! 661: return sortdir;
! 662: if (oflow1 > oflow2)
! 663: return -sortdir;
! 664: if (nget1 < nget2)
! 665: return sortdir;
! 666: if (nget1 > nget2)
! 667: return -sortdir;
! 668:
! 669: return pool_cache_sort_name_callback(s1, s2);
! 670: }
! 671:
! 672: int
! 673: pool_cache_sort_put_callback(const void *s1, const void *s2)
! 674: {
! 675: struct pool_cache_info *pc1, *pc2;
! 676: uint64_t nput1 = 0, nput2 = 0;
! 677: int oflow1 = 0, oflow2 = 0;
! 678: int cpu;
! 679:
! 680: pc1 = (struct pool_cache_info *)s1;
! 681: pc2 = (struct pool_cache_info *)s2;
! 682:
! 683: for (cpu = 0; cpu < ncpusfound; cpu++) {
! 684: if (nput1 + pc1->cache_cpus->pr_nput < nput1)
! 685: oflow1++;
! 686: nput1 += pc1->cache_cpus->pr_nput;
! 687: if (nput2 + pc2->cache_cpus->pr_nput < nput2)
! 688: oflow2++;
! 689: nput2 += pc2->cache_cpus->pr_nput;
! 690: }
! 691:
! 692: if (oflow1 < oflow2)
! 693: return sortdir;
! 694: if (oflow1 > oflow2)
! 695: return -sortdir;
! 696: if (nput1 < nput2)
! 697: return sortdir;
! 698: if (nput1 > nput2)
! 699: return -sortdir;
! 700:
! 701: return pool_cache_sort_name_callback(s1, s2);
! 702: }
! 703:
! 704: int
! 705: pool_cache_sort_lreq_callback(const void *s1, const void *s2)
! 706: {
! 707: struct pool_cache_info *pc1, *pc2;
! 708: uint64_t nlget1 = 0, nlget2 = 0;
! 709: int oflow1 = 0, oflow2 = 0;
! 710: int cpu;
! 711:
! 712: pc1 = (struct pool_cache_info *)s1;
! 713: pc2 = (struct pool_cache_info *)s2;
! 714:
! 715: for (cpu = 0; cpu < ncpusfound; cpu++) {
! 716: if (nlget1 + pc1->cache_cpus->pr_nlget < nlget1)
! 717: oflow1++;
! 718: nlget1 += pc1->cache_cpus->pr_nlget;
! 719: if (nlget2 + pc2->cache_cpus->pr_nlget < nlget2)
! 720: oflow2++;
! 721: nlget2 += pc2->cache_cpus->pr_nlget;
! 722: }
! 723:
! 724: if (oflow1 < oflow2)
! 725: return sortdir;
! 726: if (oflow1 > oflow2)
! 727: return -sortdir;
! 728: if (nlget1 < nlget2)
! 729: return sortdir;
! 730: if (nlget1 > nlget2)
! 731: return -sortdir;
! 732:
! 733: return pool_cache_sort_name_callback(s1, s2);
! 734: }
! 735:
! 736: int
! 737: pool_cache_sort_lput_callback(const void *s1, const void *s2)
! 738: {
! 739: struct pool_cache_info *pc1, *pc2;
! 740: uint64_t nlput1 = 0, nlput2 = 0;
! 741: int oflow1 = 0, oflow2 = 0;
! 742: int cpu;
! 743:
! 744: pc1 = (struct pool_cache_info *)s1;
! 745: pc2 = (struct pool_cache_info *)s2;
! 746:
! 747: for (cpu = 0; cpu < ncpusfound; cpu++) {
! 748: if (nlput1 + pc1->cache_cpus->pr_nlput < nlput1)
! 749: oflow1++;
! 750: nlput1 += pc1->cache_cpus->pr_nlput;
! 751: if (nlput2 + pc2->cache_cpus->pr_nlput < nlput2)
! 752: oflow2++;
! 753: nlput2 += pc2->cache_cpus->pr_nlput;
! 754: }
1.12 dlg 755:
1.17 ! martijn 756: if (oflow1 < oflow2)
! 757: return sortdir;
! 758: if (oflow1 > oflow2)
! 759: return -sortdir;
! 760: if (nlput1 < nlput2)
! 761: return sortdir;
! 762: if (nlput1 > nlput2)
! 763: return -sortdir;
! 764:
! 765: return pool_cache_sort_name_callback(s1, s2);
1.12 dlg 766: }
767:
1.17 ! martijn 768: int
1.12 dlg 769: pool_get_npools(void)
770: {
771: int mib[] = { CTL_KERN, KERN_POOL, KERN_POOL_NPOOLS };
772:
773: return (sysctl_rdint(mib, nitems(mib)));
774: }
775:
776: static int
777: pool_get_cache(int pool, struct kinfo_pool_cache *kpc)
778: {
779: int mib[] = { CTL_KERN, KERN_POOL, KERN_POOL_CACHE, pool };
780: size_t len = sizeof(*kpc);
781:
782: return (sysctl(mib, nitems(mib), kpc, &len, NULL, 0));
783: }
784:
785: static int
786: pool_get_cache_cpus(int pool, struct kinfo_pool_cache_cpu *kpcc,
787: unsigned int ncpus)
788: {
789: int mib[] = { CTL_KERN, KERN_POOL, KERN_POOL_CACHE_CPUS, pool };
790: size_t len = sizeof(*kpcc) * ncpus;
791:
792: return (sysctl(mib, nitems(mib), kpcc, &len, NULL, 0));
793: }
794:
795: static int
796: pool_get_name(int pool, char *name, size_t len)
797: {
798: int mib[] = { CTL_KERN, KERN_POOL, KERN_POOL_NAME, pool };
799:
800: return (sysctl(mib, nitems(mib), name, &len, NULL, 0));
801: }
802:
803: static int
804: hw_ncpusfound(void)
805: {
806: int mib[] = { CTL_HW, HW_NCPUFOUND };
807:
808: return (sysctl_rdint(mib, nitems(mib)));
809: }
810:
811: static int
812: sysctl_rdint(const int *mib, unsigned int nmib)
813: {
814: int i;
815: size_t size = sizeof(i);
816:
817: if (sysctl(mib, nmib, &i, &size, NULL, 0) == -1)
818: return (-1);
819:
820: return (i);
1.1 canacar 821: }
![[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