1 /* $OpenBSD: pool.c,v 1.20 2024/05/18 09:02:34 jsg Exp $ */
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>
19 #include <sys/signal.h>
20 #include <sys/sysctl.h>
21 #include <sys/pool.h>
22 #include <errno.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <limits.h>
26
27 #include "systat.h"
28
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
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);
47 int pool_keyboard_callback(int);
48
49 /* qsort callbacks */
50 int sort_name_callback(const void *s1, const void *s2);
51 int sort_req_callback(const void *s1, const void *s2);
52 int sort_psize_callback(const void *s1, const void *s2);
53 int sort_npage_callback(const void *s1, const void *s2);
54
55 struct pool_info {
56 char name[32];
57 struct kinfo_pool pool;
58 };
59
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 };
71
72 int print_all = 0;
73 int num_pools = 0;
74 struct pool_info *pools = NULL;
75 int num_pool_caches = 0;
76 struct pool_cache_info *pool_caches = NULL;
77 size_t pool_caches_size = 0;
78
79 int ncpusfound = 0;
80
81 field_def fields_pool[] = {
82 {"NAME", 12, 32, 1, FLD_ALIGN_LEFT, -1, 0, 0, 0},
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
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)
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[] = {
117 {"name", "name", 'N', sort_name_callback},
118 {"requests", "requests", 'Q', sort_req_callback},
119 {"size", "size", 'Z', sort_psize_callback},
120 {"npages", "npages", 'P', sort_npage_callback},
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,
127 print_pool, pool_keyboard_callback, pool_order_list, pool_order_list
128 };
129
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 *);
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 *);
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},
153 {"IDLE", 4, 4, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
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)
164 #define FLD_POOL_CACHE_IDLE FIELD_ADDR(pool_cache_fields, 2)
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,
175 FLD_POOL_CACHE_IDLE,
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[] = {
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},
194 {NULL, NULL, 0, NULL}
195 };
196
197 /* Define view managers */
198 struct view_manager pool_cache_mgr = {
199 "PoolCache",
200 NULL,
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 };
216
217 int
sort_name_callback(const void * s1,const void * s2)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
224 return strcmp(p1->name, p2->name) * sortdir;
225 }
226
227 int
sort_req_callback(const void * s1,const void * s2)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);
240 }
241
242 int
sort_npage_callback(const void * s1,const void * s2)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
sort_psize_callback(const void * s1,const void * s2)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
265 if (p1->pool.pr_size < p2->pool.pr_size)
266 return sortdir;
267 if (p1->pool.pr_size > p2->pool.pr_size)
268 return -sortdir;
269
270 return sort_npage_callback(s1, s2);
271 }
272
273 void
sort_pool(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
292 mergesort(pools, num_pools, sizeof(struct pool_info), ordering->func);
293 }
294
295 int
select_pool(void)296 select_pool(void)
297 {
298 num_disp = num_pools;
299 return (0);
300 }
301
302 int
read_pool(void)303 read_pool(void)
304 {
305 int mib[] = { CTL_KERN, KERN_POOL, KERN_POOL_POOL, 0 };
306 struct pool_info *p;
307 int np, i;
308 size_t size;
309
310 np = pool_get_npools();
311 if (np == -1) {
312 error("sysctl(npools): %s", strerror(errno));
313 return (-1);
314 }
315
316 if (np == 0) {
317 free(pools);
318 pools = NULL;
319 num_pools = 0;
320 return (0);
321 }
322
323 if (np > num_pools || pools == NULL) {
324 p = reallocarray(pools, np, sizeof(*pools));
325 if (p == NULL) {
326 error("realloc: %s", strerror(errno));
327 return (-1);
328 }
329 /* commit */
330 pools = p;
331 num_pools = np;
332 }
333
334 num_disp = num_pools;
335
336 for (i = 0; i < num_pools; i++) {
337 p = &pools[i];
338 np = i + 1;
339
340 mib[3] = np;
341 size = sizeof(pools[i].pool);
342 if (sysctl(mib, nitems(mib), &p->pool, &size, NULL, 0) == -1) {
343 p->name[0] = '\0';
344 num_disp--;
345 continue;
346 }
347
348 if (pool_get_name(np, p->name, sizeof(p->name)) < 0)
349 snprintf(p->name, sizeof(p->name), "#%d#", i + 1);
350 }
351
352 return 0;
353 }
354
355
356 void
print_pool(void)357 print_pool(void)
358 {
359 struct pool_info *p;
360 int i, n, count = 0;
361
362 if (pools == NULL)
363 return;
364
365 for (n = i = 0; i < num_pools; i++) {
366 p = &pools[i];
367 if (p->name[0] == 0)
368 continue;
369
370 if (!print_all &&
371 (p->pool.pr_nget == 0 && p->pool.pr_npagealloc == 0))
372 continue;
373
374 if (n++ < dispstart)
375 continue;
376 showpool(i);
377 count++;
378 if (maxprint > 0 && count >= maxprint)
379 break;
380 }
381 }
382
383 int
initpool(void)384 initpool(void)
385 {
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 }
394
395 add_view(&pool_cache_view);
396 pool_cache_read();
397
398 return(0);
399 }
400
401 void
showpool(int k)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();
430 }
431
432 int
pool_keyboard_callback(int ch)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);
444 }
445
446 int
pool_cache_read(void)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
458 if (np > pool_caches_size) {
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
467 for (i = pool_caches_size; i < np; i++) {
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 */
480 pool_caches_size = np;
481 }
482
483 num_pool_caches = 0;
484 for (i = 0; i < pool_caches_size; i++) {
485 pc = &pool_caches[num_pool_caches];
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);
496 num_pool_caches++;
497 }
498
499 return 0;
500
501 unalloc:
502 while (i > pool_caches_size) {
503 pc = &pool_caches[--i];
504 free(pc->cache_cpus);
505 }
506 return (-1);
507 }
508
509 void
pool_cache_sort(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;
523 if (pool_caches == NULL)
524 return;
525 if (num_pool_caches <= 0)
526 return;
527
528 mergesort(pool_caches, num_pool_caches, sizeof(*pool_caches), ordering->func);
529 }
530
531 void
pool_cache_print(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
pool_cache_show(const struct pool_cache_info * pc)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);
566 print_fld_uint(FLD_POOL_CACHE_IDLE, kpc->pr_nitems);
567 print_fld_size(FLD_POOL_CACHE_NGC, kpc->pr_ngc);
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 }
580 }
581
582 int
pool_cache_sort_name_callback(const void * s1,const void * s2)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
pool_cache_sort_len_callback(const void * s1,const void * s2)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
pool_cache_sort_idle_callback(const void * s1,const void * s2)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
pool_cache_sort_ngc_callback(const void * s1,const void * s2)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
pool_cache_sort_req_callback(const void * s1,const void * s2)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
pool_cache_sort_put_callback(const void * s1,const void * s2)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
pool_cache_sort_lreq_callback(const void * s1,const void * s2)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
pool_cache_sort_lput_callback(const void * s1,const void * s2)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 }
752
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);
763 }
764
765 int
pool_get_npools(void)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
pool_get_cache(int pool,struct kinfo_pool_cache * kpc)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
pool_get_cache_cpus(int pool,struct kinfo_pool_cache_cpu * kpcc,unsigned int ncpus)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
pool_get_name(int pool,char * name,size_t len)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
hw_ncpusfound(void)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
sysctl_rdint(const int * mib,unsigned int nmib)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);
818 }
819