i have a few things left to do in the pools per cpu caches, one of
which is make their activity visibile. to that end, here's a diff
provides a way for userland to request stats from the per cpu caches,
and uses that in systat so you can watch them.
there are two added pool sysctls. one copies an array of stats from
each cpus cache. the interesting bits in those stats are how many
items each cpu handled, and how many list operations the cpu did
against the global pool cache.
the second sysctl reports stats about the global pool cache. currently
this is the target for the list length the cpus build is, how many
lists its holding, and how many times the gc has moved a list of
items back into the pool for recovery.
these are used by sysctl for a new view which ive called pcaches,
short for pool caches.
ksh: Fmt: not found
2 users Load 1.42 0.78 0.35 (1-88 of 158) v880.embarrassm.net 13:48:40
NAME LEN NL NGC CPU REQ REL LREQ LREL
mbufpl 8 72 0 0 955967 2622839 794 209151
1 907108 362300 88367 20266
2 915933 356927 90031 20155
3 878324 339160 86646 19250
4 30620 7851 3301 454
5 1401 885 117 52
6 56 57 0 0
7 37 45 0 0
mtagpl 8 0 0 0 0 0 0 0
1 0 0 0 0
2 0 0 0 0
3 0 0 0 0
4 0 0 0 0
5 0 0 0 0
6 0 0 0 0
7 0 0 0 0
mcl2k 8 32 0 0 944634 7776 117605 497
1 122 318421 0 39786
2 114 313498 0 39171
3 105 298051 0 37242
4 22 6834 0 850
5 0 744 0 91
6 0 1 0 0
7 1 3 0 0
mcl2k2 8 0 0 0 0 0 0 0
1 0 0 0 0
2 0 0 0 0
3 0 0 0 0
4 0 0 0 0
5 0 0 0 0
6 0 0 0 0
7 0 0 0 0
mcl4k 8 2 0 0 20 44 1 2
1 1978 2072 85 96
2 2100 1988 97 83
3 1910 1986 83 91
4 87 61 6 2
5 1 9 0 0
6 0 0 0 0
7 0 0 0 0
mcl8k 8 17 0 0 97 956 11 117
1 19517 20418 2254 2366
2 20934 20704 2441 2412
3 20294 19734 2347 2275
4 1234 399 150 45
5 0 54 0 5
6 0 0 0 0
7 0 0 0 0
mcl9k 8 0 0 0 1 5 0 0
1 145 176 2 4
2 156 162 2 2
3 159 154 1 0
4 3 2 1 0
5 0 1 0 0
6 0 0 0 0
7 0 0 0 0
mcl12k 8 2 0 0 2 8 0 0
1 271 294 6 8
2 302 256 8 2
3 223 294 1 9
4 20 4 2 0
5 0 2 0 0
6 0 0 0 0
7 0 0 0 0
mcl16k 8 2 0 0 7 34 0 2
1 1108 1137 39 42
2 1095 1141 40 45
3 1021 998 39 35
4 51 27 4 0
5 1 3 0 0
6 0 0 0 0
7 0 0 0 0
mcl64k 8 3 0 0 68 327 3 34
1 17492 18495 1694 1819
2 18369 18135 1842 1812
3 18017 17252 1808 1711
4 618 409 69 41
5 22 41 1 3
6 0 0 0 0
7 0 0 0 0
the systat view could be improved, but id prefer to do that in tree.
ok?
Index: sys/kern/subr_pool.c
===================================================================
RCS file: /cvs/src/sys/kern/subr_pool.c,v
retrieving revision 1.209
diff -u -p -r1.209 subr_pool.c
--- sys/kern/subr_pool.c 13 Jun 2017 11:41:11 -0000 1.209
+++ sys/kern/subr_pool.c 14 Jun 2017 03:13:47 -0000
@@ -122,9 +122,12 @@ struct pool_cache {
struct pool_cache_item *pc_prev; /* previous list of items */
uint64_t pc_gen; /* generation number */
- uint64_t pc_gets;
- uint64_t pc_puts;
- uint64_t pc_fails;
+ uint64_t pc_nget; /* # of successful requests */
+ uint64_t pc_nfail; /* # of unsuccessful reqs */
+ uint64_t pc_nput; /* # of releases */
+ uint64_t pc_nlget; /* # of list requests */
+ uint64_t pc_nlfail; /* # of fails getting a list */
+ uint64_t pc_nlput; /* # of list releases */
int pc_nout;
};
@@ -133,7 +136,9 @@ void *pool_cache_get(struct pool *);
void pool_cache_put(struct pool *, void *);
void pool_cache_destroy(struct pool *);
#endif
-void pool_cache_info(struct pool *, struct kinfo_pool *);
+void pool_cache_pool_info(struct pool *, struct kinfo_pool *);
+int pool_cache_info(struct pool *, void *, size_t *);
+int pool_cache_cpus_info(struct pool *, void *, size_t *);
#ifdef POOL_DEBUG
int pool_debug = 1;
@@ -1379,6 +1384,8 @@ sysctl_dopool(int *name, u_int namelen,
case KERN_POOL_NAME:
case KERN_POOL_POOL:
+ case KERN_POOL_CACHE:
+ case KERN_POOL_CACHE_CPUS:
break;
default:
return (EOPNOTSUPP);
@@ -1423,10 +1430,18 @@ sysctl_dopool(int *name, u_int namelen,
pi.pr_nidle = pp->pr_nidle;
mtx_leave(&pp->pr_mtx);
- pool_cache_info(pp, &pi);
+ pool_cache_pool_info(pp, &pi);
rv = sysctl_rdstruct(oldp, oldlenp, NULL, &pi, sizeof(pi));
break;
+
+ case KERN_POOL_CACHE:
+ rv = pool_cache_info(pp, oldp, oldlenp);
+ break;
+
+ case KERN_POOL_CACHE_CPUS:
+ rv = pool_cache_cpus_info(pp, oldp, oldlenp);
+ break;
}
done:
@@ -1608,7 +1623,7 @@ pool_cache_init(struct pool *pp)
IPL_NONE, PR_WAITOK, "plcache", NULL);
}
- /* must be able to use the pool items as cache list items */
+ /* must be able to use the pool items as cache list entries */
KASSERT(pp->pr_size >= sizeof(struct pool_cache_item));
cm = cpumem_get(&pool_caches);
@@ -1625,9 +1640,12 @@ pool_cache_init(struct pool *pp)
pc->pc_nactv = 0;
pc->pc_prev = NULL;
- pc->pc_gets = 0;
- pc->pc_puts = 0;
- pc->pc_fails = 0;
+ pc->pc_nget = 0;
+ pc->pc_nfail = 0;
+ pc->pc_nput = 0;
+ pc->pc_nlget = 0;
+ pc->pc_nlfail = 0;
+ pc->pc_nlput = 0;
pc->pc_nout = 0;
}
@@ -1694,7 +1712,10 @@ pool_cache_list_alloc(struct pool *pp, s
pp->pr_cache_nlist--;
pool_cache_item_magic(pp, pl);
- }
+
+ pc->pc_nlget++;
+ } else
+ pc->pc_nlfail++;
/* fold this cpus nout into the global while we have the lock */
pp->pr_cache_nout += pc->pc_nout;
@@ -1712,6 +1733,8 @@ pool_cache_list_free(struct pool *pp, st
TAILQ_INSERT_TAIL(&pp->pr_cache_lists, ci, ci_nextl);
pp->pr_cache_nlist++;
+ pc->pc_nlput++;
+
/* fold this cpus nout into the global while we have the lock */
pp->pr_cache_nout += pc->pc_nout;
pc->pc_nout = 0;
@@ -1753,7 +1776,7 @@ pool_cache_get(struct pool *pp)
ci = pc->pc_prev;
pc->pc_prev = NULL;
} else if ((ci = pool_cache_list_alloc(pp, pc)) == NULL) {
- pc->pc_fails++;
+ pc->pc_nfail++;
goto done;
}
@@ -1778,7 +1801,7 @@ pool_cache_get(struct pool *pp)
pc->pc_actv = ci->ci_next;
pc->pc_nactv = POOL_CACHE_ITEM_NITEMS(ci) - 1;
- pc->pc_gets++;
+ pc->pc_nget++;
pc->pc_nout++;
done:
@@ -1825,7 +1848,7 @@ pool_cache_put(struct pool *pp, void *v)
pc->pc_actv = ci;
pc->pc_nactv = nitems;
- pc->pc_puts++;
+ pc->pc_nput++;
pc->pc_nout--;
pool_cache_leave(pp, pc, s);
@@ -1874,7 +1897,7 @@ pool_cache_destroy(struct pool *pp)
}
void
-pool_cache_info(struct pool *pp, struct kinfo_pool *pi)
+pool_cache_pool_info(struct pool *pp, struct kinfo_pool *pi)
{
struct pool_cache *pc;
struct cpumem_iter i;
@@ -1892,8 +1915,8 @@ pool_cache_info(struct pool *pp, struct
while ((gen = pc->pc_gen) & 1)
yield();
- nget = pc->pc_gets;
- nput = pc->pc_puts;
+ nget = pc->pc_nget;
+ nput = pc->pc_nput;
} while (gen != pc->pc_gen);
pi->pr_nget += nget;
@@ -1908,6 +1931,80 @@ pool_cache_info(struct pool *pp, struct
pi->pr_nout += pp->pr_cache_nout;
mtx_leave(&pp->pr_cache_mtx);
}
+
+int
+pool_cache_info(struct pool *pp, void *oldp, size_t *oldlenp)
+{
+ struct kinfo_pool_cache kpc;
+
+ if (pp->pr_cache == NULL)
+ return (EOPNOTSUPP);
+
+ memset(&kpc, 0, sizeof(kpc)); /* don't leak padding */
+
+ mtx_enter(&pp->pr_cache_mtx);
+ kpc.pr_ngc = 0; /* notyet */
+ kpc.pr_len = pp->pr_cache_items;
+ kpc.pr_nlist = pp->pr_cache_nlist;
+ mtx_leave(&pp->pr_cache_mtx);
+
+ return (sysctl_rdstruct(oldp, oldlenp, NULL, &kpc, sizeof(kpc)));
+}
+
+int
+pool_cache_cpus_info(struct pool *pp, void *oldp, size_t *oldlenp)
+{
+ struct pool_cache *pc;
+ struct kinfo_pool_cache_cpu *kpcc, *info;
+ unsigned int cpu = 0;
+ struct cpumem_iter i;
+ int error = 0;
+ size_t len;
+
+ if (pp->pr_cache == NULL)
+ return (EOPNOTSUPP);
+ if (*oldlenp % sizeof(*kpcc))
+ return (EINVAL);
+
+ kpcc = mallocarray(ncpusfound, sizeof(*kpcc), M_TEMP,
+ M_WAITOK|M_CANFAIL|M_ZERO);
+ if (kpcc == NULL)
+ return (EIO);
+
+ len = ncpusfound * sizeof(*kpcc);
+
+ CPUMEM_FOREACH(pc, &i, pp->pr_cache) {
+ uint64_t gen;
+
+ if (cpu >= ncpusfound) {
+ error = EIO;
+ goto err;
+ }
+
+ info = &kpcc[cpu];
+ info->pr_cpu = cpu;
+
+ do {
+ while ((gen = pc->pc_gen) & 1)
+ yield();
+
+ info->pr_nget = pc->pc_nget;
+ info->pr_nfail = pc->pc_nfail;
+ info->pr_nput = pc->pc_nput;
+ info->pr_nlget = pc->pc_nlget;
+ info->pr_nlfail = pc->pc_nlfail;
+ info->pr_nlput = pc->pc_nlput;
+ } while (gen != pc->pc_gen);
+
+ cpu++;
+ }
+
+ error = sysctl_rdstruct(oldp, oldlenp, NULL, kpcc, len);
+err:
+ free(kpcc, M_TEMP, len);
+
+ return (error);
+}
#else /* MULTIPROCESSOR */
void
pool_cache_init(struct pool *pp)
@@ -1916,8 +2013,20 @@ pool_cache_init(struct pool *pp)
}
void
-pool_cache_info(struct pool *pp, struct kinfo_pool *pi)
+pool_cache_pool_info(struct pool *pp, struct kinfo_pool *pi)
{
/* nop */
+}
+
+int
+pool_cache_info(struct pool *pp, void *oldp, size_t *oldlenp)
+{
+ return (EOPNOTSUPP);
+}
+
+int
+pool_cache_cpus_info(struct pool *pp, void *oldp, size_t *oldlenp)
+{
+ return (EOPNOTSUPP);
}
#endif /* MULTIPROCESSOR */
Index: sys/sys/pool.h
===================================================================
RCS file: /cvs/src/sys/sys/pool.h,v
retrieving revision 1.69
diff -u -p -r1.69 pool.h
--- sys/sys/pool.h 7 Feb 2017 05:39:17 -0000 1.69
+++ sys/sys/pool.h 14 Jun 2017 03:13:47 -0000
@@ -43,6 +43,8 @@
#define KERN_POOL_NPOOLS 1
#define KERN_POOL_NAME 2
#define KERN_POOL_POOL 3
+#define KERN_POOL_CACHE 4 /* global pool cache info */
+#define KERN_POOL_CACHE_CPUS 5 /* all cpus cache info */
struct kinfo_pool {
unsigned int pr_size; /* size of a pool item */
@@ -66,6 +68,30 @@ struct kinfo_pool {
unsigned long pr_nidle; /* # of idle pages */
};
+struct kinfo_pool_cache {
+ uint64_t pr_ngc; /* # of times a list has been gc'ed */
+ unsigned int pr_len; /* current target for list len */
+ unsigned int pr_nlist; /* # of lists in the pool */
+};
+
+/*
+ * KERN_POOL_CACHE_CPUS access to an array, not a single struct. ie, it
+ * provides struct kinfo_pool_cache_cpu kppc[ncpusfound].
+ */
+struct kinfo_pool_cache_cpu {
+ unsigned int pr_cpu; /* which cpu is this a cache on */
+
+ /* counters for times items were hanled by the cache */
+ uint64_t pr_nget; /* # of requests */
+ uint64_t pr_nfail; /* # of unsuccessful requests */
+ uint64_t pr_nput; /* # of releases */
+
+ /* counters for times the cache interacted with the pool */
+ uint64_t pr_nlget; /* # of list requests */
+ uint64_t pr_nlfail; /* # of unsuccessful list requests */
+ uint64_t pr_nlput; /* # of list releases */
+};
+
#if defined(_KERNEL) || defined(_LIBKVM)
#include <sys/queue.h>
@@ -159,8 +185,8 @@ struct pool {
struct mutex pr_cache_mtx;
struct pool_cache_lists
pr_cache_lists;
- u_int pr_cache_nlist;
- u_int pr_cache_items;
+ u_int pr_cache_nlist; /* # of lists */
+ u_int pr_cache_items; /* target list length */
u_int pr_cache_contention;
int pr_cache_nout;
Index: usr.bin/systat/pool.c
===================================================================
RCS file: /cvs/src/usr.bin/systat/pool.c,v
retrieving revision 1.11
diff -u -p -r1.11 pool.c
--- usr.bin/systat/pool.c 12 Mar 2016 12:45:27 -0000 1.11
+++ usr.bin/systat/pool.c 14 Jun 2017 03:13:48 -0000
@@ -26,6 +26,19 @@
#include "systat.h"
+#ifndef nitems
+#define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
+#endif
+
+static int sysctl_rdint(const int *, unsigned int);
+static int hw_ncpusfound(void);
+
+static int pool_get_npools(void);
+static int pool_get_name(int, char *, size_t);
+static int pool_get_cache(int, struct kinfo_pool_cache *);
+static int pool_get_cache_cpus(int, struct kinfo_pool_cache_cpu *,
+ unsigned int);
+
void print_pool(void);
int read_pool(void);
void sort_pool(void);
@@ -44,11 +57,25 @@ struct pool_info {
struct kinfo_pool pool;
};
+/*
+ * the kernel gives an array of ncpusfound * kinfo_pool_cache structs, but
+ * it's idea of how big that struct is may differ from here. we fetch both
+ * ncpusfound and the size it thinks kinfo_pool_cache is from sysctl, and
+ * then allocate the memory for this here.
+ */
+struct pool_cache_info {
+ char name[32];
+ struct kinfo_pool_cache cache;
+ struct kinfo_pool_cache_cpu *cache_cpus;
+};
int print_all = 0;
int num_pools = 0;
struct pool_info *pools = NULL;
+int num_pool_caches = 0;
+struct pool_cache_info *pool_caches = NULL;
+int ncpusfound = 0;
field_def fields_pool[] = {
{"NAME", 12, 32, 1, FLD_ALIGN_LEFT, -1, 0, 0, 0},
@@ -65,7 +92,6 @@ field_def fields_pool[] = {
{"IDLE", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0}
};
-
#define FLD_POOL_NAME FIELD_ADDR(fields_pool,0)
#define FLD_POOL_SIZE FIELD_ADDR(fields_pool,1)
#define FLD_POOL_REQS FIELD_ADDR(fields_pool,2)
@@ -100,11 +126,80 @@ struct view_manager pool_mgr = {
print_pool, pool_keyboard_callback, pool_order_list, pool_order_list
};
-field_view views_pool[] = {
- {view_pool_0, "pool", '5', &pool_mgr},
+field_view pool_view = {
+ view_pool_0,
+ "pool",
+ '5',
+ &pool_mgr
+};
+
+void pool_cache_print(void);
+int pool_cache_read(void);
+void pool_cache_sort(void);
+void pool_cache_show(const struct pool_cache_info *);
+int pool_cache_kbd_cb(int);
+
+field_def pool_cache_fields[] = {
+ {"NAME", 12, 32, 1, FLD_ALIGN_LEFT, -1, 0, 0, 0},
+ {"LEN", 4, 4, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
+ {"NL", 4, 4, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
+ {"NGC", 4, 4, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
+ {"CPU", 4, 4, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
+ {"REQ", 8, 12, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
+ {"REL", 8, 12, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
+ {"LREQ", 8, 12, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
+ {"LREL", 8, 12, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
+};
+
+#define FLD_POOL_CACHE_NAME FIELD_ADDR(pool_cache_fields, 0)
+#define FLD_POOL_CACHE_LEN FIELD_ADDR(pool_cache_fields, 1)
+#define FLD_POOL_CACHE_NL FIELD_ADDR(pool_cache_fields, 2)
+#define FLD_POOL_CACHE_NGC FIELD_ADDR(pool_cache_fields, 3)
+#define FLD_POOL_CACHE_CPU FIELD_ADDR(pool_cache_fields, 4)
+#define FLD_POOL_CACHE_GET FIELD_ADDR(pool_cache_fields, 5)
+#define FLD_POOL_CACHE_PUT FIELD_ADDR(pool_cache_fields, 6)
+#define FLD_POOL_CACHE_LGET FIELD_ADDR(pool_cache_fields, 7)
+#define FLD_POOL_CACHE_LPUT FIELD_ADDR(pool_cache_fields, 8)
+
+field_def *view_pool_cache_0[] = {
+ FLD_POOL_CACHE_NAME,
+ FLD_POOL_CACHE_LEN,
+ FLD_POOL_CACHE_NL,
+ FLD_POOL_CACHE_NGC,
+ FLD_POOL_CACHE_CPU,
+ FLD_POOL_CACHE_GET,
+ FLD_POOL_CACHE_PUT,
+ FLD_POOL_CACHE_LGET,
+ FLD_POOL_CACHE_LPUT,
+ NULL,
+};
+
+order_type pool_cache_order_list[] = {
+ {"name", "name", 'N', sort_name_callback},
+ {"requests", "requests", 'G', sort_req_callback},
+ {"releases", "releases", 'P', sort_req_callback},
{NULL, NULL, 0, NULL}
};
+/* Define view managers */
+struct view_manager pool_cache_mgr = {
+ "PoolCache",
+ select_pool,
+ pool_cache_read,
+ pool_cache_sort,
+ print_header,
+ pool_cache_print,
+ pool_keyboard_callback,
+ pool_cache_order_list,
+ pool_cache_order_list
+};
+
+field_view pool_cache_view = {
+ view_pool_cache_0,
+ "pcaches",
+ '5',
+ &pool_cache_mgr
+};
int
sort_name_callback(const void *s1, const void *s2)
@@ -200,30 +295,31 @@ select_pool(void)
int
read_pool(void)
{
- int mib[4], np, i;
+ int mib[] = { CTL_KERN, KERN_POOL, KERN_POOL_POOL, 0 };
+ struct pool_info *p;
+ int np, i;
size_t size;
- mib[0] = CTL_KERN;
- mib[1] = KERN_POOL;
- mib[2] = KERN_POOL_NPOOLS;
- size = sizeof(np);
-
- if (sysctl(mib, 3, &np, &size, NULL, 0) < 0) {
+ np = pool_get_npools();
+ if (np == -1) {
error("sysctl(npools): %s", strerror(errno));
return (-1);
}
- if (np <= 0) {
+ if (np == 0) {
+ free(pools);
+ pools = NULL;
num_pools = 0;
return (0);
}
if (np > num_pools || pools == NULL) {
- struct pool_info *p = reallocarray(pools, np, sizeof(*pools));
+ p = reallocarray(pools, np, sizeof(*pools));
if (p == NULL) {
error("realloc: %s", strerror(errno));
return (-1);
}
+ /* commit */
pools = p;
num_pools = np;
}
@@ -231,26 +327,19 @@ read_pool(void)
num_disp = num_pools;
for (i = 0; i < num_pools; i++) {
- mib[0] = CTL_KERN;
- mib[1] = KERN_POOL;
- mib[2] = KERN_POOL_POOL;
- mib[3] = i + 1;
+ p = &pools[i];
+ np = i + 1;
+
+ mib[3] = np;
size = sizeof(pools[i].pool);
- if (sysctl(mib, 4, &pools[i].pool, &size, NULL, 0) < 0) {
- memset(&pools[i], 0, sizeof(pools[i]));
+ if (sysctl(mib, nitems(mib), &p->pool, &size, NULL, 0) < 0) {
+ p->name[0] = '\0';
num_disp--;
continue;
}
- mib[2] = KERN_POOL_NAME;
- size = sizeof(pools[i].name);
- if (sysctl(mib, 4, &pools[i].name, &size, NULL, 0) < 0) {
- snprintf(pools[i].name, size, "#%d#", mib[3]);
- }
- }
- if (i != num_pools) {
- memset(pools, 0, sizeof(*pools) * num_pools);
- return (-1);
+ if (pool_get_name(np, p->name, sizeof(p->name)) < 0)
+ snprintf(p->name, sizeof(p->name), "#%d#", i + 1);
}
return 0;
@@ -289,11 +378,18 @@ initpool(void)
{
field_view *v;
- for (v = views_pool; v->name != NULL; v++)
- add_view(v);
-
+ add_view(&pool_view);
read_pool();
+ ncpusfound = hw_ncpusfound();
+ if (ncpusfound == -1) {
+ error("sysctl(ncpusfound): %s", strerror(errno));
+ exit(1);
+ }
+
+ add_view(&pool_cache_view);
+ pool_cache_read();
+
return(0);
}
@@ -340,4 +436,194 @@ pool_keyboard_callback(int ch)
};
return (1);
+}
+
+int
+pool_cache_read(void)
+{
+ struct pool_cache_info *pc;
+ int np, i;
+
+ np = pool_get_npools();
+ if (np == -1) {
+ error("sysctl(npools): %s", strerror(errno));
+ return (-1);
+ }
+
+ if (np > num_pool_caches) {
+ pc = reallocarray(pool_caches, np, sizeof(*pc));
+ if (pc == NULL) {
+ error("realloc: %s", strerror(errno));
+ return (-1);
+ }
+ /* commit to using the new memory */
+ pool_caches = pc;
+
+ for (i = num_pool_caches; i < np; i++) {
+ pc = &pool_caches[i];
+ pc->name[0] = '\0';
+
+ pc->cache_cpus = reallocarray(NULL, ncpusfound,
+ sizeof(*pc->cache_cpus));
+ if (pc->cache_cpus == NULL) {
+ error("malloc cache cpus: %s", strerror(errno));
+ goto unalloc;
+ }
+ }
+
+ /* commit to using the new cache_infos */
+ num_pool_caches = np;
+ }
+
+ for (i = 0; i < num_pool_caches; i++) {
+ pc = &pool_caches[i];
+ np = i + 1;
+
+ if (pool_get_cache(np, &pc->cache) < 0 ||
+ pool_get_cache_cpus(np, pc->cache_cpus, ncpusfound) < 0) {
+ pc->name[0] = '\0';
+ continue;
+ }
+
+ if (pool_get_name(np, pc->name, sizeof(pc->name)) < 0)
+ snprintf(pc->name, sizeof(pc->name), "#%d#", i + 1);
+ }
+
+ return 0;
+
+unalloc:
+ while (i > num_pool_caches) {
+ pc = &pool_caches[--i];
+ free(pc->cache_cpus);
+ }
+}
+
+void
+pool_cache_sort(void)
+{
+ /* XXX */
+ order_type *ordering;
+
+ if (curr_mgr == NULL)
+ return;
+
+ ordering = curr_mgr->order_curr;
+
+ if (ordering == NULL)
+ return;
+ if (ordering->func == NULL)
+ return;
+ if (pools == NULL)
+ return;
+ if (num_pools <= 0)
+ return;
+
+ mergesort(pools, num_pools, sizeof(struct pool_info), ordering->func);
+}
+
+void
+pool_cache_print(void)
+{
+ struct pool_cache_info *pc;
+ int i, n, count = 0;
+
+ if (pool_caches == NULL)
+ return;
+
+ for (n = i = 0; i < num_pool_caches; i++) {
+ pc = &pool_caches[i];
+ if (pc->name[0] == '\0')
+ continue;
+
+ if (n++ < dispstart)
+ continue;
+
+ pool_cache_show(pc);
+ count++;
+ if (maxprint > 0 && count >= maxprint)
+ break;
+ }
+}
+
+void
+pool_cache_show(const struct pool_cache_info *pc)
+{
+ const struct kinfo_pool_cache *kpc;
+ const struct kinfo_pool_cache_cpu *kpcc;
+ int cpu;
+
+ kpc = &pc->cache;
+
+ print_fld_str(FLD_POOL_CACHE_NAME, pc->name);
+ print_fld_uint(FLD_POOL_CACHE_LEN, kpc->pr_len);
+ print_fld_uint(FLD_POOL_CACHE_NL, kpc->pr_nlist);
+ print_fld_uint(FLD_POOL_CACHE_NGC, kpc->pr_ngc);
+
+ for (cpu = 0; cpu < ncpusfound; cpu++) {
+ kpcc = &pc->cache_cpus[cpu];
+
+ print_fld_uint(FLD_POOL_CACHE_CPU, kpcc->pr_cpu);
+
+ print_fld_size(FLD_POOL_CACHE_GET, kpcc->pr_nget);
+ print_fld_size(FLD_POOL_CACHE_PUT, kpcc->pr_nput);
+ print_fld_size(FLD_POOL_CACHE_LGET, kpcc->pr_nlget);
+ print_fld_size(FLD_POOL_CACHE_LPUT, kpcc->pr_nlput);
+ end_line();
+ }
+
+}
+
+static int
+pool_get_npools(void)
+{
+ int mib[] = { CTL_KERN, KERN_POOL, KERN_POOL_NPOOLS };
+
+ return (sysctl_rdint(mib, nitems(mib)));
+}
+
+static int
+pool_get_cache(int pool, struct kinfo_pool_cache *kpc)
+{
+ int mib[] = { CTL_KERN, KERN_POOL, KERN_POOL_CACHE, pool };
+ size_t len = sizeof(*kpc);
+
+ return (sysctl(mib, nitems(mib), kpc, &len, NULL, 0));
+}
+
+static int
+pool_get_cache_cpus(int pool, struct kinfo_pool_cache_cpu *kpcc,
+ unsigned int ncpus)
+{
+ int mib[] = { CTL_KERN, KERN_POOL, KERN_POOL_CACHE_CPUS, pool };
+ size_t len = sizeof(*kpcc) * ncpus;
+
+ return (sysctl(mib, nitems(mib), kpcc, &len, NULL, 0));
+}
+
+static int
+pool_get_name(int pool, char *name, size_t len)
+{
+ int mib[] = { CTL_KERN, KERN_POOL, KERN_POOL_NAME, pool };
+
+ return (sysctl(mib, nitems(mib), name, &len, NULL, 0));
+}
+
+static int
+hw_ncpusfound(void)
+{
+ int mib[] = { CTL_HW, HW_NCPUFOUND };
+
+ return (sysctl_rdint(mib, nitems(mib)));
+}
+
+static int
+sysctl_rdint(const int *mib, unsigned int nmib)
+{
+ int i;
+ size_t size = sizeof(i);
+
+ if (sysctl(mib, nmib, &i, &size, NULL, 0) == -1)
+ return (-1);
+
+ return (i);
}
Index: usr.bin/systat/systat.1
===================================================================
RCS file: /cvs/src/usr.bin/systat/systat.1,v
retrieving revision 1.101
diff -u -p -r1.101 systat.1
--- usr.bin/systat/systat.1 12 Mar 2015 01:03:00 -0000 1.101
+++ usr.bin/systat/systat.1 14 Jun 2017 03:13:48 -0000
@@ -136,6 +136,7 @@ argument expects to be one of:
.Ic queues ,
.Ic pf ,
.Ic pool ,
+.Ic pcache ,
.Ic malloc ,
.Ic buckets ,
.Ic nfsclient ,
@@ -379,6 +380,10 @@ and
By default only the statistics of active pools are displayed but pressing
.Ic A
changes the view to show all of them.
+.It Ic pcache
+Display kernel
+.Xr pool 9
+per CPU cache statistics.
.It Ic queues
Display statistics about the active queues,
similar to the output of
