xref: /freebsd/contrib/jemalloc/src/stats.c (revision e17f5b1d)
1 #define JEMALLOC_STATS_C_
2 #include "jemalloc/internal/jemalloc_preamble.h"
3 #include "jemalloc/internal/jemalloc_internal_includes.h"
4 
5 #include "jemalloc/internal/assert.h"
6 #include "jemalloc/internal/ctl.h"
7 #include "jemalloc/internal/emitter.h"
8 #include "jemalloc/internal/mutex.h"
9 #include "jemalloc/internal/mutex_prof.h"
10 
11 const char *global_mutex_names[mutex_prof_num_global_mutexes] = {
12 #define OP(mtx) #mtx,
13 	MUTEX_PROF_GLOBAL_MUTEXES
14 #undef OP
15 };
16 
17 const char *arena_mutex_names[mutex_prof_num_arena_mutexes] = {
18 #define OP(mtx) #mtx,
19 	MUTEX_PROF_ARENA_MUTEXES
20 #undef OP
21 };
22 
23 #define CTL_GET(n, v, t) do {						\
24 	size_t sz = sizeof(t);						\
25 	xmallctl(n, (void *)v, &sz, NULL, 0);				\
26 } while (0)
27 
28 #define CTL_M2_GET(n, i, v, t) do {					\
29 	size_t mib[CTL_MAX_DEPTH];					\
30 	size_t miblen = sizeof(mib) / sizeof(size_t);			\
31 	size_t sz = sizeof(t);						\
32 	xmallctlnametomib(n, mib, &miblen);				\
33 	mib[2] = (i);							\
34 	xmallctlbymib(mib, miblen, (void *)v, &sz, NULL, 0);		\
35 } while (0)
36 
37 #define CTL_M2_M4_GET(n, i, j, v, t) do {				\
38 	size_t mib[CTL_MAX_DEPTH];					\
39 	size_t miblen = sizeof(mib) / sizeof(size_t);			\
40 	size_t sz = sizeof(t);						\
41 	xmallctlnametomib(n, mib, &miblen);				\
42 	mib[2] = (i);							\
43 	mib[4] = (j);							\
44 	xmallctlbymib(mib, miblen, (void *)v, &sz, NULL, 0);		\
45 } while (0)
46 
47 /******************************************************************************/
48 /* Data. */
49 
50 bool opt_stats_print = false;
51 char opt_stats_print_opts[stats_print_tot_num_options+1] = "";
52 
53 /******************************************************************************/
54 
55 static uint64_t
56 rate_per_second(uint64_t value, uint64_t uptime_ns) {
57 	uint64_t billion = 1000000000;
58 	if (uptime_ns == 0 || value == 0) {
59 		return 0;
60 	}
61 	if (uptime_ns < billion) {
62 		return value;
63 	} else {
64 		uint64_t uptime_s = uptime_ns / billion;
65 		return value / uptime_s;
66 	}
67 }
68 
69 /* Calculate x.yyy and output a string (takes a fixed sized char array). */
70 static bool
71 get_rate_str(uint64_t dividend, uint64_t divisor, char str[6]) {
72 	if (divisor == 0 || dividend > divisor) {
73 		/* The rate is not supposed to be greater than 1. */
74 		return true;
75 	}
76 	if (dividend > 0) {
77 		assert(UINT64_MAX / dividend >= 1000);
78 	}
79 
80 	unsigned n = (unsigned)((dividend * 1000) / divisor);
81 	if (n < 10) {
82 		malloc_snprintf(str, 6, "0.00%u", n);
83 	} else if (n < 100) {
84 		malloc_snprintf(str, 6, "0.0%u", n);
85 	} else if (n < 1000) {
86 		malloc_snprintf(str, 6, "0.%u", n);
87 	} else {
88 		malloc_snprintf(str, 6, "1");
89 	}
90 
91 	return false;
92 }
93 
94 #define MUTEX_CTL_STR_MAX_LENGTH 128
95 static void
96 gen_mutex_ctl_str(char *str, size_t buf_len, const char *prefix,
97     const char *mutex, const char *counter) {
98 	malloc_snprintf(str, buf_len, "stats.%s.%s.%s", prefix, mutex, counter);
99 }
100 
101 static void
102 mutex_stats_init_cols(emitter_row_t *row, const char *table_name,
103     emitter_col_t *name,
104     emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters],
105     emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters]) {
106 	mutex_prof_uint64_t_counter_ind_t k_uint64_t = 0;
107 	mutex_prof_uint32_t_counter_ind_t k_uint32_t = 0;
108 
109 	emitter_col_t *col;
110 
111 	if (name != NULL) {
112 		emitter_col_init(name, row);
113 		name->justify = emitter_justify_left;
114 		name->width = 21;
115 		name->type = emitter_type_title;
116 		name->str_val = table_name;
117 	}
118 
119 #define WIDTH_uint32_t 12
120 #define WIDTH_uint64_t 16
121 #define OP(counter, counter_type, human, derived, base_counter)	\
122 	col = &col_##counter_type[k_##counter_type];			\
123 	++k_##counter_type;						\
124 	emitter_col_init(col, row);					\
125 	col->justify = emitter_justify_right;				\
126 	col->width = derived ? 8 : WIDTH_##counter_type;		\
127 	col->type = emitter_type_title;					\
128 	col->str_val = human;
129 	MUTEX_PROF_COUNTERS
130 #undef OP
131 #undef WIDTH_uint32_t
132 #undef WIDTH_uint64_t
133 	col_uint64_t[mutex_counter_total_wait_time_ps].width = 10;
134 }
135 
136 static void
137 mutex_stats_read_global(const char *name, emitter_col_t *col_name,
138     emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters],
139     emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters],
140     uint64_t uptime) {
141 	char cmd[MUTEX_CTL_STR_MAX_LENGTH];
142 
143 	col_name->str_val = name;
144 
145 	emitter_col_t *dst;
146 #define EMITTER_TYPE_uint32_t emitter_type_uint32
147 #define EMITTER_TYPE_uint64_t emitter_type_uint64
148 #define OP(counter, counter_type, human, derived, base_counter)	\
149 	dst = &col_##counter_type[mutex_counter_##counter];		\
150 	dst->type = EMITTER_TYPE_##counter_type;			\
151 	if (!derived) {							\
152 		gen_mutex_ctl_str(cmd, MUTEX_CTL_STR_MAX_LENGTH,	\
153 		    "mutexes", name, #counter);				\
154 		CTL_GET(cmd, (counter_type *)&dst->bool_val, counter_type);	\
155 	} else { \
156 	    emitter_col_t *base = &col_##counter_type[mutex_counter_##base_counter];	\
157 	    dst->counter_type##_val = rate_per_second(base->counter_type##_val, uptime); \
158 	}
159 	MUTEX_PROF_COUNTERS
160 #undef OP
161 #undef EMITTER_TYPE_uint32_t
162 #undef EMITTER_TYPE_uint64_t
163 }
164 
165 static void
166 mutex_stats_read_arena(unsigned arena_ind, mutex_prof_arena_ind_t mutex_ind,
167     const char *name, emitter_col_t *col_name,
168     emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters],
169     emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters],
170     uint64_t uptime) {
171 	char cmd[MUTEX_CTL_STR_MAX_LENGTH];
172 
173 	col_name->str_val = name;
174 
175 	emitter_col_t *dst;
176 #define EMITTER_TYPE_uint32_t emitter_type_uint32
177 #define EMITTER_TYPE_uint64_t emitter_type_uint64
178 #define OP(counter, counter_type, human, derived, base_counter)	\
179 	dst = &col_##counter_type[mutex_counter_##counter];		\
180 	dst->type = EMITTER_TYPE_##counter_type;			\
181 	if (!derived) {                                   \
182 		gen_mutex_ctl_str(cmd, MUTEX_CTL_STR_MAX_LENGTH,        \
183 		    "arenas.0.mutexes", arena_mutex_names[mutex_ind], #counter);\
184 		CTL_M2_GET(cmd, arena_ind, (counter_type *)&dst->bool_val, counter_type); \
185 	} else {                      \
186 		emitter_col_t *base = &col_##counter_type[mutex_counter_##base_counter];	\
187 		dst->counter_type##_val = rate_per_second(base->counter_type##_val, uptime); \
188 	}
189 	MUTEX_PROF_COUNTERS
190 #undef OP
191 #undef EMITTER_TYPE_uint32_t
192 #undef EMITTER_TYPE_uint64_t
193 }
194 
195 static void
196 mutex_stats_read_arena_bin(unsigned arena_ind, unsigned bin_ind,
197     emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters],
198     emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters],
199     uint64_t uptime) {
200 	char cmd[MUTEX_CTL_STR_MAX_LENGTH];
201 	emitter_col_t *dst;
202 
203 #define EMITTER_TYPE_uint32_t emitter_type_uint32
204 #define EMITTER_TYPE_uint64_t emitter_type_uint64
205 #define OP(counter, counter_type, human, derived, base_counter)	\
206 	dst = &col_##counter_type[mutex_counter_##counter];		\
207 	dst->type = EMITTER_TYPE_##counter_type;			\
208 	if (!derived) {                                   \
209 		gen_mutex_ctl_str(cmd, MUTEX_CTL_STR_MAX_LENGTH,        \
210 		    "arenas.0.bins.0","mutex", #counter);            \
211 		CTL_M2_M4_GET(cmd, arena_ind, bin_ind,                \
212 		    (counter_type *)&dst->bool_val, counter_type);  \
213 	} else {                      \
214 		emitter_col_t *base = &col_##counter_type[mutex_counter_##base_counter]; \
215 		dst->counter_type##_val = rate_per_second(base->counter_type##_val, uptime); \
216 	}
217 	MUTEX_PROF_COUNTERS
218 #undef OP
219 #undef EMITTER_TYPE_uint32_t
220 #undef EMITTER_TYPE_uint64_t
221 }
222 
223 /* "row" can be NULL to avoid emitting in table mode. */
224 static void
225 mutex_stats_emit(emitter_t *emitter, emitter_row_t *row,
226     emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters],
227     emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters]) {
228 	if (row != NULL) {
229 		emitter_table_row(emitter, row);
230 	}
231 
232 	mutex_prof_uint64_t_counter_ind_t k_uint64_t = 0;
233 	mutex_prof_uint32_t_counter_ind_t k_uint32_t = 0;
234 
235 	emitter_col_t *col;
236 
237 #define EMITTER_TYPE_uint32_t emitter_type_uint32
238 #define EMITTER_TYPE_uint64_t emitter_type_uint64
239 #define OP(counter, type, human, derived, base_counter)		\
240 	if (!derived) {                    \
241 		col = &col_##type[k_##type];                        \
242 		++k_##type;                            \
243 		emitter_json_kv(emitter, #counter, EMITTER_TYPE_##type,        \
244 		    (const void *)&col->bool_val); \
245 	}
246 	MUTEX_PROF_COUNTERS;
247 #undef OP
248 #undef EMITTER_TYPE_uint32_t
249 #undef EMITTER_TYPE_uint64_t
250 }
251 
252 #define COL(row_name, column_name, left_or_right, col_width, etype)      \
253 	emitter_col_t col_##column_name;                                     \
254 	emitter_col_init(&col_##column_name, &row_name);                     \
255 	col_##column_name.justify = emitter_justify_##left_or_right;         \
256 	col_##column_name.width = col_width;                                 \
257 	col_##column_name.type = emitter_type_##etype;
258 
259 #define COL_HDR(row_name, column_name, human, left_or_right, col_width, etype)  \
260 	COL(row_name, column_name, left_or_right, col_width, etype)	         \
261 	emitter_col_t header_##column_name;                                  \
262 	emitter_col_init(&header_##column_name, &header_##row_name);         \
263 	header_##column_name.justify = emitter_justify_##left_or_right;      \
264 	header_##column_name.width = col_width;                              \
265 	header_##column_name.type = emitter_type_title;                      \
266 	header_##column_name.str_val = human ? human : #column_name;
267 
268 
269 static void
270 stats_arena_bins_print(emitter_t *emitter, bool mutex, unsigned i, uint64_t uptime) {
271 	size_t page;
272 	bool in_gap, in_gap_prev;
273 	unsigned nbins, j;
274 
275 	CTL_GET("arenas.page", &page, size_t);
276 
277 	CTL_GET("arenas.nbins", &nbins, unsigned);
278 
279 	emitter_row_t header_row;
280 	emitter_row_init(&header_row);
281 
282 	emitter_row_t row;
283 	emitter_row_init(&row);
284 
285 	COL_HDR(row, size, NULL, right, 20, size)
286 	COL_HDR(row, ind, NULL, right, 4, unsigned)
287 	COL_HDR(row, allocated, NULL, right, 13, uint64)
288 	COL_HDR(row, nmalloc, NULL, right, 13, uint64)
289 	COL_HDR(row, nmalloc_ps, "(#/sec)", right, 8, uint64)
290 	COL_HDR(row, ndalloc, NULL, right, 13, uint64)
291 	COL_HDR(row, ndalloc_ps, "(#/sec)", right, 8, uint64)
292 	COL_HDR(row, nrequests, NULL, right, 13, uint64)
293 	COL_HDR(row, nrequests_ps, "(#/sec)", right, 10, uint64)
294 	COL_HDR(row, nshards, NULL, right, 9, unsigned)
295 	COL_HDR(row, curregs, NULL, right, 13, size)
296 	COL_HDR(row, curslabs, NULL, right, 13, size)
297 	COL_HDR(row, nonfull_slabs, NULL, right, 15, size)
298 	COL_HDR(row, regs, NULL, right, 5, unsigned)
299 	COL_HDR(row, pgs, NULL, right, 4, size)
300 	/* To buffer a right- and left-justified column. */
301 	COL_HDR(row, justify_spacer, NULL, right, 1, title)
302 	COL_HDR(row, util, NULL, right, 6, title)
303 	COL_HDR(row, nfills, NULL, right, 13, uint64)
304 	COL_HDR(row, nfills_ps, "(#/sec)", right, 8, uint64)
305 	COL_HDR(row, nflushes, NULL, right, 13, uint64)
306 	COL_HDR(row, nflushes_ps, "(#/sec)", right, 8, uint64)
307 	COL_HDR(row, nslabs, NULL, right, 13, uint64)
308 	COL_HDR(row, nreslabs, NULL, right, 13, uint64)
309 	COL_HDR(row, nreslabs_ps, "(#/sec)", right, 8, uint64)
310 
311 	/* Don't want to actually print the name. */
312 	header_justify_spacer.str_val = " ";
313 	col_justify_spacer.str_val = " ";
314 
315 	emitter_col_t col_mutex64[mutex_prof_num_uint64_t_counters];
316 	emitter_col_t col_mutex32[mutex_prof_num_uint32_t_counters];
317 
318 	emitter_col_t header_mutex64[mutex_prof_num_uint64_t_counters];
319 	emitter_col_t header_mutex32[mutex_prof_num_uint32_t_counters];
320 
321 	if (mutex) {
322 		mutex_stats_init_cols(&row, NULL, NULL, col_mutex64,
323 		    col_mutex32);
324 		mutex_stats_init_cols(&header_row, NULL, NULL, header_mutex64,
325 		    header_mutex32);
326 	}
327 
328 	/*
329 	 * We print a "bins:" header as part of the table row; we need to adjust
330 	 * the header size column to compensate.
331 	 */
332 	header_size.width -=5;
333 	emitter_table_printf(emitter, "bins:");
334 	emitter_table_row(emitter, &header_row);
335 	emitter_json_array_kv_begin(emitter, "bins");
336 
337 	for (j = 0, in_gap = false; j < nbins; j++) {
338 		uint64_t nslabs;
339 		size_t reg_size, slab_size, curregs;
340 		size_t curslabs;
341 		size_t nonfull_slabs;
342 		uint32_t nregs, nshards;
343 		uint64_t nmalloc, ndalloc, nrequests, nfills, nflushes;
344 		uint64_t nreslabs;
345 
346 		CTL_M2_M4_GET("stats.arenas.0.bins.0.nslabs", i, j, &nslabs,
347 		    uint64_t);
348 		in_gap_prev = in_gap;
349 		in_gap = (nslabs == 0);
350 
351 		if (in_gap_prev && !in_gap) {
352 			emitter_table_printf(emitter,
353 			    "                     ---\n");
354 		}
355 
356 		CTL_M2_GET("arenas.bin.0.size", j, &reg_size, size_t);
357 		CTL_M2_GET("arenas.bin.0.nregs", j, &nregs, uint32_t);
358 		CTL_M2_GET("arenas.bin.0.slab_size", j, &slab_size, size_t);
359 		CTL_M2_GET("arenas.bin.0.nshards", j, &nshards, uint32_t);
360 
361 		CTL_M2_M4_GET("stats.arenas.0.bins.0.nmalloc", i, j, &nmalloc,
362 		    uint64_t);
363 		CTL_M2_M4_GET("stats.arenas.0.bins.0.ndalloc", i, j, &ndalloc,
364 		    uint64_t);
365 		CTL_M2_M4_GET("stats.arenas.0.bins.0.curregs", i, j, &curregs,
366 		    size_t);
367 		CTL_M2_M4_GET("stats.arenas.0.bins.0.nrequests", i, j,
368 		    &nrequests, uint64_t);
369 		CTL_M2_M4_GET("stats.arenas.0.bins.0.nfills", i, j, &nfills,
370 		    uint64_t);
371 		CTL_M2_M4_GET("stats.arenas.0.bins.0.nflushes", i, j, &nflushes,
372 		    uint64_t);
373 		CTL_M2_M4_GET("stats.arenas.0.bins.0.nreslabs", i, j, &nreslabs,
374 		    uint64_t);
375 		CTL_M2_M4_GET("stats.arenas.0.bins.0.curslabs", i, j, &curslabs,
376 		    size_t);
377 		CTL_M2_M4_GET("stats.arenas.0.bins.0.nonfull_slabs", i, j, &nonfull_slabs,
378 		    size_t);
379 
380 		if (mutex) {
381 			mutex_stats_read_arena_bin(i, j, col_mutex64,
382 			    col_mutex32, uptime);
383 		}
384 
385 		emitter_json_object_begin(emitter);
386 		emitter_json_kv(emitter, "nmalloc", emitter_type_uint64,
387 		    &nmalloc);
388 		emitter_json_kv(emitter, "ndalloc", emitter_type_uint64,
389 		    &ndalloc);
390 		emitter_json_kv(emitter, "curregs", emitter_type_size,
391 		    &curregs);
392 		emitter_json_kv(emitter, "nrequests", emitter_type_uint64,
393 		    &nrequests);
394 		emitter_json_kv(emitter, "nfills", emitter_type_uint64,
395 		    &nfills);
396 		emitter_json_kv(emitter, "nflushes", emitter_type_uint64,
397 		    &nflushes);
398 		emitter_json_kv(emitter, "nreslabs", emitter_type_uint64,
399 		    &nreslabs);
400 		emitter_json_kv(emitter, "curslabs", emitter_type_size,
401 		    &curslabs);
402 		emitter_json_kv(emitter, "nonfull_slabs", emitter_type_size,
403 		    &nonfull_slabs);
404 		if (mutex) {
405 			emitter_json_object_kv_begin(emitter, "mutex");
406 			mutex_stats_emit(emitter, NULL, col_mutex64,
407 			    col_mutex32);
408 			emitter_json_object_end(emitter);
409 		}
410 		emitter_json_object_end(emitter);
411 
412 		size_t availregs = nregs * curslabs;
413 		char util[6];
414 		if (get_rate_str((uint64_t)curregs, (uint64_t)availregs, util))
415 		{
416 			if (availregs == 0) {
417 				malloc_snprintf(util, sizeof(util), "1");
418 			} else if (curregs > availregs) {
419 				/*
420 				 * Race detected: the counters were read in
421 				 * separate mallctl calls and concurrent
422 				 * operations happened in between.  In this case
423 				 * no meaningful utilization can be computed.
424 				 */
425 				malloc_snprintf(util, sizeof(util), " race");
426 			} else {
427 				not_reached();
428 			}
429 		}
430 
431 		col_size.size_val = reg_size;
432 		col_ind.unsigned_val = j;
433 		col_allocated.size_val = curregs * reg_size;
434 		col_nmalloc.uint64_val = nmalloc;
435 		col_nmalloc_ps.uint64_val = rate_per_second(nmalloc, uptime);
436 		col_ndalloc.uint64_val = ndalloc;
437 		col_ndalloc_ps.uint64_val = rate_per_second(ndalloc, uptime);
438 		col_nrequests.uint64_val = nrequests;
439 		col_nrequests_ps.uint64_val = rate_per_second(nrequests, uptime);
440 		col_nshards.unsigned_val = nshards;
441 		col_curregs.size_val = curregs;
442 		col_curslabs.size_val = curslabs;
443 		col_nonfull_slabs.size_val = nonfull_slabs;
444 		col_regs.unsigned_val = nregs;
445 		col_pgs.size_val = slab_size / page;
446 		col_util.str_val = util;
447 		col_nfills.uint64_val = nfills;
448 		col_nfills_ps.uint64_val = rate_per_second(nfills, uptime);
449 		col_nflushes.uint64_val = nflushes;
450 		col_nflushes_ps.uint64_val = rate_per_second(nflushes, uptime);
451 		col_nslabs.uint64_val = nslabs;
452 		col_nreslabs.uint64_val = nreslabs;
453 		col_nreslabs_ps.uint64_val = rate_per_second(nreslabs, uptime);
454 
455 		/*
456 		 * Note that mutex columns were initialized above, if mutex ==
457 		 * true.
458 		 */
459 
460 		emitter_table_row(emitter, &row);
461 	}
462 	emitter_json_array_end(emitter); /* Close "bins". */
463 
464 	if (in_gap) {
465 		emitter_table_printf(emitter, "                     ---\n");
466 	}
467 }
468 
469 static void
470 stats_arena_lextents_print(emitter_t *emitter, unsigned i, uint64_t uptime) {
471 	unsigned nbins, nlextents, j;
472 	bool in_gap, in_gap_prev;
473 
474 	CTL_GET("arenas.nbins", &nbins, unsigned);
475 	CTL_GET("arenas.nlextents", &nlextents, unsigned);
476 
477 	emitter_row_t header_row;
478 	emitter_row_init(&header_row);
479 	emitter_row_t row;
480 	emitter_row_init(&row);
481 
482 	COL_HDR(row, size, NULL, right, 20, size)
483 	COL_HDR(row, ind, NULL, right, 4, unsigned)
484 	COL_HDR(row, allocated, NULL, right, 13, size)
485 	COL_HDR(row, nmalloc, NULL, right, 13, uint64)
486 	COL_HDR(row, nmalloc_ps, "(#/sec)", right, 8, uint64)
487 	COL_HDR(row, ndalloc, NULL, right, 13, uint64)
488 	COL_HDR(row, ndalloc_ps, "(#/sec)", right, 8, uint64)
489 	COL_HDR(row, nrequests, NULL, right, 13, uint64)
490 	COL_HDR(row, nrequests_ps, "(#/sec)", right, 8, uint64)
491 	COL_HDR(row, curlextents, NULL, right, 13, size)
492 
493 	/* As with bins, we label the large extents table. */
494 	header_size.width -= 6;
495 	emitter_table_printf(emitter, "large:");
496 	emitter_table_row(emitter, &header_row);
497 	emitter_json_array_kv_begin(emitter, "lextents");
498 
499 	for (j = 0, in_gap = false; j < nlextents; j++) {
500 		uint64_t nmalloc, ndalloc, nrequests;
501 		size_t lextent_size, curlextents;
502 
503 		CTL_M2_M4_GET("stats.arenas.0.lextents.0.nmalloc", i, j,
504 		    &nmalloc, uint64_t);
505 		CTL_M2_M4_GET("stats.arenas.0.lextents.0.ndalloc", i, j,
506 		    &ndalloc, uint64_t);
507 		CTL_M2_M4_GET("stats.arenas.0.lextents.0.nrequests", i, j,
508 		    &nrequests, uint64_t);
509 		in_gap_prev = in_gap;
510 		in_gap = (nrequests == 0);
511 
512 		if (in_gap_prev && !in_gap) {
513 			emitter_table_printf(emitter,
514 			    "                     ---\n");
515 		}
516 
517 		CTL_M2_GET("arenas.lextent.0.size", j, &lextent_size, size_t);
518 		CTL_M2_M4_GET("stats.arenas.0.lextents.0.curlextents", i, j,
519 		    &curlextents, size_t);
520 
521 		emitter_json_object_begin(emitter);
522 		emitter_json_kv(emitter, "curlextents", emitter_type_size,
523 		    &curlextents);
524 		emitter_json_object_end(emitter);
525 
526 		col_size.size_val = lextent_size;
527 		col_ind.unsigned_val = nbins + j;
528 		col_allocated.size_val = curlextents * lextent_size;
529 		col_nmalloc.uint64_val = nmalloc;
530 		col_nmalloc_ps.uint64_val = rate_per_second(nmalloc, uptime);
531 		col_ndalloc.uint64_val = ndalloc;
532 		col_ndalloc_ps.uint64_val = rate_per_second(ndalloc, uptime);
533 		col_nrequests.uint64_val = nrequests;
534 		col_nrequests_ps.uint64_val = rate_per_second(nrequests, uptime);
535 		col_curlextents.size_val = curlextents;
536 
537 		if (!in_gap) {
538 			emitter_table_row(emitter, &row);
539 		}
540 	}
541 	emitter_json_array_end(emitter); /* Close "lextents". */
542 	if (in_gap) {
543 		emitter_table_printf(emitter, "                     ---\n");
544 	}
545 }
546 
547 static void
548 stats_arena_extents_print(emitter_t *emitter, unsigned i) {
549 	unsigned j;
550 	bool in_gap, in_gap_prev;
551 	emitter_row_t header_row;
552 	emitter_row_init(&header_row);
553 	emitter_row_t row;
554 	emitter_row_init(&row);
555 
556 	COL_HDR(row, size, NULL, right, 20, size)
557 	COL_HDR(row, ind, NULL, right, 4, unsigned)
558 	COL_HDR(row, ndirty, NULL, right, 13, size)
559 	COL_HDR(row, dirty, NULL, right, 13, size)
560 	COL_HDR(row, nmuzzy, NULL, right, 13, size)
561 	COL_HDR(row, muzzy, NULL, right, 13, size)
562 	COL_HDR(row, nretained, NULL, right, 13, size)
563 	COL_HDR(row, retained, NULL, right, 13, size)
564 	COL_HDR(row, ntotal, NULL, right, 13, size)
565 	COL_HDR(row, total, NULL, right, 13, size)
566 
567 	/* Label this section. */
568 	header_size.width -= 8;
569 	emitter_table_printf(emitter, "extents:");
570 	emitter_table_row(emitter, &header_row);
571 	emitter_json_array_kv_begin(emitter, "extents");
572 
573 	in_gap = false;
574 	for (j = 0; j < SC_NPSIZES; j++) {
575 		size_t ndirty, nmuzzy, nretained, total, dirty_bytes,
576 		    muzzy_bytes, retained_bytes, total_bytes;
577 		CTL_M2_M4_GET("stats.arenas.0.extents.0.ndirty", i, j,
578 		    &ndirty, size_t);
579 		CTL_M2_M4_GET("stats.arenas.0.extents.0.nmuzzy", i, j,
580 		    &nmuzzy, size_t);
581 		CTL_M2_M4_GET("stats.arenas.0.extents.0.nretained", i, j,
582 		    &nretained, size_t);
583 		CTL_M2_M4_GET("stats.arenas.0.extents.0.dirty_bytes", i, j,
584 		    &dirty_bytes, size_t);
585 		CTL_M2_M4_GET("stats.arenas.0.extents.0.muzzy_bytes", i, j,
586 		    &muzzy_bytes, size_t);
587 		CTL_M2_M4_GET("stats.arenas.0.extents.0.retained_bytes", i, j,
588 		    &retained_bytes, size_t);
589 		total = ndirty + nmuzzy + nretained;
590 		total_bytes = dirty_bytes + muzzy_bytes + retained_bytes;
591 
592 		in_gap_prev = in_gap;
593 		in_gap = (total == 0);
594 
595 		if (in_gap_prev && !in_gap) {
596 			emitter_table_printf(emitter,
597 			    "                     ---\n");
598 		}
599 
600 		emitter_json_object_begin(emitter);
601 		emitter_json_kv(emitter, "ndirty", emitter_type_size, &ndirty);
602 		emitter_json_kv(emitter, "nmuzzy", emitter_type_size, &nmuzzy);
603 		emitter_json_kv(emitter, "nretained", emitter_type_size,
604 		    &nretained);
605 
606 		emitter_json_kv(emitter, "dirty_bytes", emitter_type_size,
607 		    &dirty_bytes);
608 		emitter_json_kv(emitter, "muzzy_bytes", emitter_type_size,
609 		    &muzzy_bytes);
610 		emitter_json_kv(emitter, "retained_bytes", emitter_type_size,
611 		    &retained_bytes);
612 		emitter_json_object_end(emitter);
613 
614 		col_size.size_val = sz_pind2sz(j);
615 		col_ind.size_val = j;
616 		col_ndirty.size_val = ndirty;
617 		col_dirty.size_val = dirty_bytes;
618 		col_nmuzzy.size_val = nmuzzy;
619 		col_muzzy.size_val = muzzy_bytes;
620 		col_nretained.size_val = nretained;
621 		col_retained.size_val = retained_bytes;
622 		col_ntotal.size_val = total;
623 		col_total.size_val = total_bytes;
624 
625 		if (!in_gap) {
626 			emitter_table_row(emitter, &row);
627 		}
628 	}
629 	emitter_json_array_end(emitter); /* Close "extents". */
630 	if (in_gap) {
631 		emitter_table_printf(emitter, "                     ---\n");
632 	}
633 }
634 
635 static void
636 stats_arena_mutexes_print(emitter_t *emitter, unsigned arena_ind, uint64_t uptime) {
637 	emitter_row_t row;
638 	emitter_col_t col_name;
639 	emitter_col_t col64[mutex_prof_num_uint64_t_counters];
640 	emitter_col_t col32[mutex_prof_num_uint32_t_counters];
641 
642 	emitter_row_init(&row);
643 	mutex_stats_init_cols(&row, "", &col_name, col64, col32);
644 
645 	emitter_json_object_kv_begin(emitter, "mutexes");
646 	emitter_table_row(emitter, &row);
647 
648 	for (mutex_prof_arena_ind_t i = 0; i < mutex_prof_num_arena_mutexes;
649 	    i++) {
650 		const char *name = arena_mutex_names[i];
651 		emitter_json_object_kv_begin(emitter, name);
652 		mutex_stats_read_arena(arena_ind, i, name, &col_name, col64,
653 		    col32, uptime);
654 		mutex_stats_emit(emitter, &row, col64, col32);
655 		emitter_json_object_end(emitter); /* Close the mutex dict. */
656 	}
657 	emitter_json_object_end(emitter); /* End "mutexes". */
658 }
659 
660 static void
661 stats_arena_print(emitter_t *emitter, unsigned i, bool bins, bool large,
662     bool mutex, bool extents) {
663 	unsigned nthreads;
664 	const char *dss;
665 	ssize_t dirty_decay_ms, muzzy_decay_ms;
666 	size_t page, pactive, pdirty, pmuzzy, mapped, retained;
667 	size_t base, internal, resident, metadata_thp, extent_avail;
668 	uint64_t dirty_npurge, dirty_nmadvise, dirty_purged;
669 	uint64_t muzzy_npurge, muzzy_nmadvise, muzzy_purged;
670 	size_t small_allocated;
671 	uint64_t small_nmalloc, small_ndalloc, small_nrequests, small_nfills,
672 	    small_nflushes;
673 	size_t large_allocated;
674 	uint64_t large_nmalloc, large_ndalloc, large_nrequests, large_nfills,
675 	    large_nflushes;
676 	size_t tcache_bytes, abandoned_vm;
677 	uint64_t uptime;
678 
679 	CTL_GET("arenas.page", &page, size_t);
680 
681 	CTL_M2_GET("stats.arenas.0.nthreads", i, &nthreads, unsigned);
682 	emitter_kv(emitter, "nthreads", "assigned threads",
683 	    emitter_type_unsigned, &nthreads);
684 
685 	CTL_M2_GET("stats.arenas.0.uptime", i, &uptime, uint64_t);
686 	emitter_kv(emitter, "uptime_ns", "uptime", emitter_type_uint64,
687 	    &uptime);
688 
689 	CTL_M2_GET("stats.arenas.0.dss", i, &dss, const char *);
690 	emitter_kv(emitter, "dss", "dss allocation precedence",
691 	    emitter_type_string, &dss);
692 
693 	CTL_M2_GET("stats.arenas.0.dirty_decay_ms", i, &dirty_decay_ms,
694 	    ssize_t);
695 	CTL_M2_GET("stats.arenas.0.muzzy_decay_ms", i, &muzzy_decay_ms,
696 	    ssize_t);
697 	CTL_M2_GET("stats.arenas.0.pactive", i, &pactive, size_t);
698 	CTL_M2_GET("stats.arenas.0.pdirty", i, &pdirty, size_t);
699 	CTL_M2_GET("stats.arenas.0.pmuzzy", i, &pmuzzy, size_t);
700 	CTL_M2_GET("stats.arenas.0.dirty_npurge", i, &dirty_npurge, uint64_t);
701 	CTL_M2_GET("stats.arenas.0.dirty_nmadvise", i, &dirty_nmadvise,
702 	    uint64_t);
703 	CTL_M2_GET("stats.arenas.0.dirty_purged", i, &dirty_purged, uint64_t);
704 	CTL_M2_GET("stats.arenas.0.muzzy_npurge", i, &muzzy_npurge, uint64_t);
705 	CTL_M2_GET("stats.arenas.0.muzzy_nmadvise", i, &muzzy_nmadvise,
706 	    uint64_t);
707 	CTL_M2_GET("stats.arenas.0.muzzy_purged", i, &muzzy_purged, uint64_t);
708 
709 	emitter_row_t decay_row;
710 	emitter_row_init(&decay_row);
711 
712 	/* JSON-style emission. */
713 	emitter_json_kv(emitter, "dirty_decay_ms", emitter_type_ssize,
714 	    &dirty_decay_ms);
715 	emitter_json_kv(emitter, "muzzy_decay_ms", emitter_type_ssize,
716 	    &muzzy_decay_ms);
717 
718 	emitter_json_kv(emitter, "pactive", emitter_type_size, &pactive);
719 	emitter_json_kv(emitter, "pdirty", emitter_type_size, &pdirty);
720 	emitter_json_kv(emitter, "pmuzzy", emitter_type_size, &pmuzzy);
721 
722 	emitter_json_kv(emitter, "dirty_npurge", emitter_type_uint64,
723 	    &dirty_npurge);
724 	emitter_json_kv(emitter, "dirty_nmadvise", emitter_type_uint64,
725 	    &dirty_nmadvise);
726 	emitter_json_kv(emitter, "dirty_purged", emitter_type_uint64,
727 	    &dirty_purged);
728 
729 	emitter_json_kv(emitter, "muzzy_npurge", emitter_type_uint64,
730 	    &muzzy_npurge);
731 	emitter_json_kv(emitter, "muzzy_nmadvise", emitter_type_uint64,
732 	    &muzzy_nmadvise);
733 	emitter_json_kv(emitter, "muzzy_purged", emitter_type_uint64,
734 	    &muzzy_purged);
735 
736 	/* Table-style emission. */
737 	COL(decay_row, decay_type, right, 9, title);
738 	col_decay_type.str_val = "decaying:";
739 
740 	COL(decay_row, decay_time, right, 6, title);
741 	col_decay_time.str_val = "time";
742 
743 	COL(decay_row, decay_npages, right, 13, title);
744 	col_decay_npages.str_val = "npages";
745 
746 	COL(decay_row, decay_sweeps, right, 13, title);
747 	col_decay_sweeps.str_val = "sweeps";
748 
749 	COL(decay_row, decay_madvises, right, 13, title);
750 	col_decay_madvises.str_val = "madvises";
751 
752 	COL(decay_row, decay_purged, right, 13, title);
753 	col_decay_purged.str_val = "purged";
754 
755 	/* Title row. */
756 	emitter_table_row(emitter, &decay_row);
757 
758 	/* Dirty row. */
759 	col_decay_type.str_val = "dirty:";
760 
761 	if (dirty_decay_ms >= 0) {
762 		col_decay_time.type = emitter_type_ssize;
763 		col_decay_time.ssize_val = dirty_decay_ms;
764 	} else {
765 		col_decay_time.type = emitter_type_title;
766 		col_decay_time.str_val = "N/A";
767 	}
768 
769 	col_decay_npages.type = emitter_type_size;
770 	col_decay_npages.size_val = pdirty;
771 
772 	col_decay_sweeps.type = emitter_type_uint64;
773 	col_decay_sweeps.uint64_val = dirty_npurge;
774 
775 	col_decay_madvises.type = emitter_type_uint64;
776 	col_decay_madvises.uint64_val = dirty_nmadvise;
777 
778 	col_decay_purged.type = emitter_type_uint64;
779 	col_decay_purged.uint64_val = dirty_purged;
780 
781 	emitter_table_row(emitter, &decay_row);
782 
783 	/* Muzzy row. */
784 	col_decay_type.str_val = "muzzy:";
785 
786 	if (muzzy_decay_ms >= 0) {
787 		col_decay_time.type = emitter_type_ssize;
788 		col_decay_time.ssize_val = muzzy_decay_ms;
789 	} else {
790 		col_decay_time.type = emitter_type_title;
791 		col_decay_time.str_val = "N/A";
792 	}
793 
794 	col_decay_npages.type = emitter_type_size;
795 	col_decay_npages.size_val = pmuzzy;
796 
797 	col_decay_sweeps.type = emitter_type_uint64;
798 	col_decay_sweeps.uint64_val = muzzy_npurge;
799 
800 	col_decay_madvises.type = emitter_type_uint64;
801 	col_decay_madvises.uint64_val = muzzy_nmadvise;
802 
803 	col_decay_purged.type = emitter_type_uint64;
804 	col_decay_purged.uint64_val = muzzy_purged;
805 
806 	emitter_table_row(emitter, &decay_row);
807 
808 	/* Small / large / total allocation counts. */
809 	emitter_row_t alloc_count_row;
810 	emitter_row_init(&alloc_count_row);
811 
812 	COL(alloc_count_row, count_title, left, 21, title);
813 	col_count_title.str_val = "";
814 
815 	COL(alloc_count_row, count_allocated, right, 16, title);
816 	col_count_allocated.str_val = "allocated";
817 
818 	COL(alloc_count_row, count_nmalloc, right, 16, title);
819 	col_count_nmalloc.str_val = "nmalloc";
820 	COL(alloc_count_row, count_nmalloc_ps, right, 8, title);
821 	col_count_nmalloc_ps.str_val = "(#/sec)";
822 
823 	COL(alloc_count_row, count_ndalloc, right, 16, title);
824 	col_count_ndalloc.str_val = "ndalloc";
825 	COL(alloc_count_row, count_ndalloc_ps, right, 8, title);
826 	col_count_ndalloc_ps.str_val = "(#/sec)";
827 
828 	COL(alloc_count_row, count_nrequests, right, 16, title);
829 	col_count_nrequests.str_val = "nrequests";
830 	COL(alloc_count_row, count_nrequests_ps, right, 10, title);
831 	col_count_nrequests_ps.str_val = "(#/sec)";
832 
833 	COL(alloc_count_row, count_nfills, right, 16, title);
834 	col_count_nfills.str_val = "nfill";
835 	COL(alloc_count_row, count_nfills_ps, right, 10, title);
836 	col_count_nfills_ps.str_val = "(#/sec)";
837 
838 	COL(alloc_count_row, count_nflushes, right, 16, title);
839 	col_count_nflushes.str_val = "nflush";
840 	COL(alloc_count_row, count_nflushes_ps, right, 10, title);
841 	col_count_nflushes_ps.str_val = "(#/sec)";
842 
843 	emitter_table_row(emitter, &alloc_count_row);
844 
845 	col_count_nmalloc_ps.type = emitter_type_uint64;
846 	col_count_ndalloc_ps.type = emitter_type_uint64;
847 	col_count_nrequests_ps.type = emitter_type_uint64;
848 	col_count_nfills_ps.type = emitter_type_uint64;
849 	col_count_nflushes_ps.type = emitter_type_uint64;
850 
851 #define GET_AND_EMIT_ALLOC_STAT(small_or_large, name, valtype)		\
852 	CTL_M2_GET("stats.arenas.0." #small_or_large "." #name, i,	\
853 	    &small_or_large##_##name, valtype##_t);			\
854 	emitter_json_kv(emitter, #name, emitter_type_##valtype,		\
855 	    &small_or_large##_##name);					\
856 	col_count_##name.type = emitter_type_##valtype;		\
857 	col_count_##name.valtype##_val = small_or_large##_##name;
858 
859 	emitter_json_object_kv_begin(emitter, "small");
860 	col_count_title.str_val = "small:";
861 
862 	GET_AND_EMIT_ALLOC_STAT(small, allocated, size)
863 	GET_AND_EMIT_ALLOC_STAT(small, nmalloc, uint64)
864 	col_count_nmalloc_ps.uint64_val =
865 	    rate_per_second(col_count_nmalloc.uint64_val, uptime);
866 	GET_AND_EMIT_ALLOC_STAT(small, ndalloc, uint64)
867 	col_count_ndalloc_ps.uint64_val =
868 	    rate_per_second(col_count_ndalloc.uint64_val, uptime);
869 	GET_AND_EMIT_ALLOC_STAT(small, nrequests, uint64)
870 	col_count_nrequests_ps.uint64_val =
871 	    rate_per_second(col_count_nrequests.uint64_val, uptime);
872 	GET_AND_EMIT_ALLOC_STAT(small, nfills, uint64)
873 	col_count_nfills_ps.uint64_val =
874 	    rate_per_second(col_count_nfills.uint64_val, uptime);
875 	GET_AND_EMIT_ALLOC_STAT(small, nflushes, uint64)
876 	col_count_nflushes_ps.uint64_val =
877 	    rate_per_second(col_count_nflushes.uint64_val, uptime);
878 
879 	emitter_table_row(emitter, &alloc_count_row);
880 	emitter_json_object_end(emitter); /* Close "small". */
881 
882 	emitter_json_object_kv_begin(emitter, "large");
883 	col_count_title.str_val = "large:";
884 
885 	GET_AND_EMIT_ALLOC_STAT(large, allocated, size)
886 	GET_AND_EMIT_ALLOC_STAT(large, nmalloc, uint64)
887 	col_count_nmalloc_ps.uint64_val =
888 	    rate_per_second(col_count_nmalloc.uint64_val, uptime);
889 	GET_AND_EMIT_ALLOC_STAT(large, ndalloc, uint64)
890 	col_count_ndalloc_ps.uint64_val =
891 	    rate_per_second(col_count_ndalloc.uint64_val, uptime);
892 	GET_AND_EMIT_ALLOC_STAT(large, nrequests, uint64)
893 	col_count_nrequests_ps.uint64_val =
894 	    rate_per_second(col_count_nrequests.uint64_val, uptime);
895 	GET_AND_EMIT_ALLOC_STAT(large, nfills, uint64)
896 	col_count_nfills_ps.uint64_val =
897 	    rate_per_second(col_count_nfills.uint64_val, uptime);
898 	GET_AND_EMIT_ALLOC_STAT(large, nflushes, uint64)
899 	col_count_nflushes_ps.uint64_val =
900 	    rate_per_second(col_count_nflushes.uint64_val, uptime);
901 
902 	emitter_table_row(emitter, &alloc_count_row);
903 	emitter_json_object_end(emitter); /* Close "large". */
904 
905 #undef GET_AND_EMIT_ALLOC_STAT
906 
907 	/* Aggregated small + large stats are emitter only in table mode. */
908 	col_count_title.str_val = "total:";
909 	col_count_allocated.size_val = small_allocated + large_allocated;
910 	col_count_nmalloc.uint64_val = small_nmalloc + large_nmalloc;
911 	col_count_ndalloc.uint64_val = small_ndalloc + large_ndalloc;
912 	col_count_nrequests.uint64_val = small_nrequests + large_nrequests;
913 	col_count_nfills.uint64_val = small_nfills + large_nfills;
914 	col_count_nflushes.uint64_val = small_nflushes + large_nflushes;
915 	col_count_nmalloc_ps.uint64_val =
916 	    rate_per_second(col_count_nmalloc.uint64_val, uptime);
917 	col_count_ndalloc_ps.uint64_val =
918 	    rate_per_second(col_count_ndalloc.uint64_val, uptime);
919 	col_count_nrequests_ps.uint64_val =
920 	    rate_per_second(col_count_nrequests.uint64_val, uptime);
921 	col_count_nfills_ps.uint64_val =
922 	    rate_per_second(col_count_nfills.uint64_val, uptime);
923 	col_count_nflushes_ps.uint64_val =
924 	    rate_per_second(col_count_nflushes.uint64_val, uptime);
925 	emitter_table_row(emitter, &alloc_count_row);
926 
927 	emitter_row_t mem_count_row;
928 	emitter_row_init(&mem_count_row);
929 
930 	emitter_col_t mem_count_title;
931 	emitter_col_init(&mem_count_title, &mem_count_row);
932 	mem_count_title.justify = emitter_justify_left;
933 	mem_count_title.width = 21;
934 	mem_count_title.type = emitter_type_title;
935 	mem_count_title.str_val = "";
936 
937 	emitter_col_t mem_count_val;
938 	emitter_col_init(&mem_count_val, &mem_count_row);
939 	mem_count_val.justify = emitter_justify_right;
940 	mem_count_val.width = 16;
941 	mem_count_val.type = emitter_type_title;
942 	mem_count_val.str_val = "";
943 
944 	emitter_table_row(emitter, &mem_count_row);
945 	mem_count_val.type = emitter_type_size;
946 
947 	/* Active count in bytes is emitted only in table mode. */
948 	mem_count_title.str_val = "active:";
949 	mem_count_val.size_val = pactive * page;
950 	emitter_table_row(emitter, &mem_count_row);
951 
952 #define GET_AND_EMIT_MEM_STAT(stat)					\
953 	CTL_M2_GET("stats.arenas.0."#stat, i, &stat, size_t);		\
954 	emitter_json_kv(emitter, #stat, emitter_type_size, &stat);	\
955 	mem_count_title.str_val = #stat":";				\
956 	mem_count_val.size_val = stat;					\
957 	emitter_table_row(emitter, &mem_count_row);
958 
959 	GET_AND_EMIT_MEM_STAT(mapped)
960 	GET_AND_EMIT_MEM_STAT(retained)
961 	GET_AND_EMIT_MEM_STAT(base)
962 	GET_AND_EMIT_MEM_STAT(internal)
963 	GET_AND_EMIT_MEM_STAT(metadata_thp)
964 	GET_AND_EMIT_MEM_STAT(tcache_bytes)
965 	GET_AND_EMIT_MEM_STAT(resident)
966 	GET_AND_EMIT_MEM_STAT(abandoned_vm)
967 	GET_AND_EMIT_MEM_STAT(extent_avail)
968 #undef GET_AND_EMIT_MEM_STAT
969 
970 	if (mutex) {
971 		stats_arena_mutexes_print(emitter, i, uptime);
972 	}
973 	if (bins) {
974 		stats_arena_bins_print(emitter, mutex, i, uptime);
975 	}
976 	if (large) {
977 		stats_arena_lextents_print(emitter, i, uptime);
978 	}
979 	if (extents) {
980 		stats_arena_extents_print(emitter, i);
981 	}
982 }
983 
984 static void
985 stats_general_print(emitter_t *emitter) {
986 	const char *cpv;
987 	bool bv, bv2;
988 	unsigned uv;
989 	uint32_t u32v;
990 	uint64_t u64v;
991 	ssize_t ssv, ssv2;
992 	size_t sv, bsz, usz, ssz, sssz, cpsz;
993 
994 	bsz = sizeof(bool);
995 	usz = sizeof(unsigned);
996 	ssz = sizeof(size_t);
997 	sssz = sizeof(ssize_t);
998 	cpsz = sizeof(const char *);
999 
1000 	CTL_GET("version", &cpv, const char *);
1001 	emitter_kv(emitter, "version", "Version", emitter_type_string, &cpv);
1002 
1003 	/* config. */
1004 	emitter_dict_begin(emitter, "config", "Build-time option settings");
1005 #define CONFIG_WRITE_BOOL(name)						\
1006 	do {								\
1007 		CTL_GET("config."#name, &bv, bool);			\
1008 		emitter_kv(emitter, #name, "config."#name,		\
1009 		    emitter_type_bool, &bv);				\
1010 	} while (0)
1011 
1012 	CONFIG_WRITE_BOOL(cache_oblivious);
1013 	CONFIG_WRITE_BOOL(debug);
1014 	CONFIG_WRITE_BOOL(fill);
1015 	CONFIG_WRITE_BOOL(lazy_lock);
1016 	emitter_kv(emitter, "malloc_conf", "config.malloc_conf",
1017 	    emitter_type_string, &config_malloc_conf);
1018 
1019 	CONFIG_WRITE_BOOL(opt_safety_checks);
1020 	CONFIG_WRITE_BOOL(prof);
1021 	CONFIG_WRITE_BOOL(prof_libgcc);
1022 	CONFIG_WRITE_BOOL(prof_libunwind);
1023 	CONFIG_WRITE_BOOL(stats);
1024 	CONFIG_WRITE_BOOL(utrace);
1025 	CONFIG_WRITE_BOOL(xmalloc);
1026 #undef CONFIG_WRITE_BOOL
1027 	emitter_dict_end(emitter); /* Close "config" dict. */
1028 
1029 	/* opt. */
1030 #define OPT_WRITE(name, var, size, emitter_type)			\
1031 	if (je_mallctl("opt."name, (void *)&var, &size, NULL, 0) ==	\
1032 	    0) {							\
1033 		emitter_kv(emitter, name, "opt."name, emitter_type,	\
1034 		    &var);						\
1035 	}
1036 
1037 #define OPT_WRITE_MUTABLE(name, var1, var2, size, emitter_type,		\
1038     altname)								\
1039 	if (je_mallctl("opt."name, (void *)&var1, &size, NULL, 0) ==	\
1040 	    0 && je_mallctl(altname, (void *)&var2, &size, NULL, 0)	\
1041 	    == 0) {							\
1042 		emitter_kv_note(emitter, name, "opt."name,		\
1043 		    emitter_type, &var1, altname, emitter_type,		\
1044 		    &var2);						\
1045 	}
1046 
1047 #define OPT_WRITE_BOOL(name) OPT_WRITE(name, bv, bsz, emitter_type_bool)
1048 #define OPT_WRITE_BOOL_MUTABLE(name, altname)				\
1049 	OPT_WRITE_MUTABLE(name, bv, bv2, bsz, emitter_type_bool, altname)
1050 
1051 #define OPT_WRITE_UNSIGNED(name)					\
1052 	OPT_WRITE(name, uv, usz, emitter_type_unsigned)
1053 
1054 #define OPT_WRITE_SIZE_T(name)						\
1055 	OPT_WRITE(name, sv, ssz, emitter_type_size)
1056 #define OPT_WRITE_SSIZE_T(name)						\
1057 	OPT_WRITE(name, ssv, sssz, emitter_type_ssize)
1058 #define OPT_WRITE_SSIZE_T_MUTABLE(name, altname)			\
1059 	OPT_WRITE_MUTABLE(name, ssv, ssv2, sssz, emitter_type_ssize,	\
1060 	    altname)
1061 
1062 #define OPT_WRITE_CHAR_P(name)						\
1063 	OPT_WRITE(name, cpv, cpsz, emitter_type_string)
1064 
1065 	emitter_dict_begin(emitter, "opt", "Run-time option settings");
1066 
1067 	OPT_WRITE_BOOL("abort")
1068 	OPT_WRITE_BOOL("abort_conf")
1069 	OPT_WRITE_BOOL("confirm_conf")
1070 	OPT_WRITE_BOOL("retain")
1071 	OPT_WRITE_CHAR_P("dss")
1072 	OPT_WRITE_UNSIGNED("narenas")
1073 	OPT_WRITE_CHAR_P("percpu_arena")
1074 	OPT_WRITE_SIZE_T("oversize_threshold")
1075 	OPT_WRITE_CHAR_P("metadata_thp")
1076 	OPT_WRITE_BOOL_MUTABLE("background_thread", "background_thread")
1077 	OPT_WRITE_SSIZE_T_MUTABLE("dirty_decay_ms", "arenas.dirty_decay_ms")
1078 	OPT_WRITE_SSIZE_T_MUTABLE("muzzy_decay_ms", "arenas.muzzy_decay_ms")
1079 	OPT_WRITE_SIZE_T("lg_extent_max_active_fit")
1080 	OPT_WRITE_CHAR_P("junk")
1081 	OPT_WRITE_BOOL("zero")
1082 	OPT_WRITE_BOOL("utrace")
1083 	OPT_WRITE_BOOL("xmalloc")
1084 	OPT_WRITE_BOOL("tcache")
1085 	OPT_WRITE_SSIZE_T("lg_tcache_max")
1086 	OPT_WRITE_CHAR_P("thp")
1087 	OPT_WRITE_BOOL("prof")
1088 	OPT_WRITE_CHAR_P("prof_prefix")
1089 	OPT_WRITE_BOOL_MUTABLE("prof_active", "prof.active")
1090 	OPT_WRITE_BOOL_MUTABLE("prof_thread_active_init",
1091 	    "prof.thread_active_init")
1092 	OPT_WRITE_SSIZE_T_MUTABLE("lg_prof_sample", "prof.lg_sample")
1093 	OPT_WRITE_BOOL("prof_accum")
1094 	OPT_WRITE_SSIZE_T("lg_prof_interval")
1095 	OPT_WRITE_BOOL("prof_gdump")
1096 	OPT_WRITE_BOOL("prof_final")
1097 	OPT_WRITE_BOOL("prof_leak")
1098 	OPT_WRITE_BOOL("stats_print")
1099 	OPT_WRITE_CHAR_P("stats_print_opts")
1100 
1101 	emitter_dict_end(emitter);
1102 
1103 #undef OPT_WRITE
1104 #undef OPT_WRITE_MUTABLE
1105 #undef OPT_WRITE_BOOL
1106 #undef OPT_WRITE_BOOL_MUTABLE
1107 #undef OPT_WRITE_UNSIGNED
1108 #undef OPT_WRITE_SSIZE_T
1109 #undef OPT_WRITE_SSIZE_T_MUTABLE
1110 #undef OPT_WRITE_CHAR_P
1111 
1112 	/* prof. */
1113 	if (config_prof) {
1114 		emitter_dict_begin(emitter, "prof", "Profiling settings");
1115 
1116 		CTL_GET("prof.thread_active_init", &bv, bool);
1117 		emitter_kv(emitter, "thread_active_init",
1118 		    "prof.thread_active_init", emitter_type_bool, &bv);
1119 
1120 		CTL_GET("prof.active", &bv, bool);
1121 		emitter_kv(emitter, "active", "prof.active", emitter_type_bool,
1122 		    &bv);
1123 
1124 		CTL_GET("prof.gdump", &bv, bool);
1125 		emitter_kv(emitter, "gdump", "prof.gdump", emitter_type_bool,
1126 		    &bv);
1127 
1128 		CTL_GET("prof.interval", &u64v, uint64_t);
1129 		emitter_kv(emitter, "interval", "prof.interval",
1130 		    emitter_type_uint64, &u64v);
1131 
1132 		CTL_GET("prof.lg_sample", &ssv, ssize_t);
1133 		emitter_kv(emitter, "lg_sample", "prof.lg_sample",
1134 		    emitter_type_ssize, &ssv);
1135 
1136 		emitter_dict_end(emitter); /* Close "prof". */
1137 	}
1138 
1139 	/* arenas. */
1140 	/*
1141 	 * The json output sticks arena info into an "arenas" dict; the table
1142 	 * output puts them at the top-level.
1143 	 */
1144 	emitter_json_object_kv_begin(emitter, "arenas");
1145 
1146 	CTL_GET("arenas.narenas", &uv, unsigned);
1147 	emitter_kv(emitter, "narenas", "Arenas", emitter_type_unsigned, &uv);
1148 
1149 	/*
1150 	 * Decay settings are emitted only in json mode; in table mode, they're
1151 	 * emitted as notes with the opt output, above.
1152 	 */
1153 	CTL_GET("arenas.dirty_decay_ms", &ssv, ssize_t);
1154 	emitter_json_kv(emitter, "dirty_decay_ms", emitter_type_ssize, &ssv);
1155 
1156 	CTL_GET("arenas.muzzy_decay_ms", &ssv, ssize_t);
1157 	emitter_json_kv(emitter, "muzzy_decay_ms", emitter_type_ssize, &ssv);
1158 
1159 	CTL_GET("arenas.quantum", &sv, size_t);
1160 	emitter_kv(emitter, "quantum", "Quantum size", emitter_type_size, &sv);
1161 
1162 	CTL_GET("arenas.page", &sv, size_t);
1163 	emitter_kv(emitter, "page", "Page size", emitter_type_size, &sv);
1164 
1165 	if (je_mallctl("arenas.tcache_max", (void *)&sv, &ssz, NULL, 0) == 0) {
1166 		emitter_kv(emitter, "tcache_max",
1167 		    "Maximum thread-cached size class", emitter_type_size, &sv);
1168 	}
1169 
1170 	unsigned nbins;
1171 	CTL_GET("arenas.nbins", &nbins, unsigned);
1172 	emitter_kv(emitter, "nbins", "Number of bin size classes",
1173 	    emitter_type_unsigned, &nbins);
1174 
1175 	unsigned nhbins;
1176 	CTL_GET("arenas.nhbins", &nhbins, unsigned);
1177 	emitter_kv(emitter, "nhbins", "Number of thread-cache bin size classes",
1178 	    emitter_type_unsigned, &nhbins);
1179 
1180 	/*
1181 	 * We do enough mallctls in a loop that we actually want to omit them
1182 	 * (not just omit the printing).
1183 	 */
1184 	if (emitter->output == emitter_output_json) {
1185 		emitter_json_array_kv_begin(emitter, "bin");
1186 		for (unsigned i = 0; i < nbins; i++) {
1187 			emitter_json_object_begin(emitter);
1188 
1189 			CTL_M2_GET("arenas.bin.0.size", i, &sv, size_t);
1190 			emitter_json_kv(emitter, "size", emitter_type_size,
1191 			    &sv);
1192 
1193 			CTL_M2_GET("arenas.bin.0.nregs", i, &u32v, uint32_t);
1194 			emitter_json_kv(emitter, "nregs", emitter_type_uint32,
1195 			    &u32v);
1196 
1197 			CTL_M2_GET("arenas.bin.0.slab_size", i, &sv, size_t);
1198 			emitter_json_kv(emitter, "slab_size", emitter_type_size,
1199 			    &sv);
1200 
1201 			CTL_M2_GET("arenas.bin.0.nshards", i, &u32v, uint32_t);
1202 			emitter_json_kv(emitter, "nshards", emitter_type_uint32,
1203 			    &u32v);
1204 
1205 			emitter_json_object_end(emitter);
1206 		}
1207 		emitter_json_array_end(emitter); /* Close "bin". */
1208 	}
1209 
1210 	unsigned nlextents;
1211 	CTL_GET("arenas.nlextents", &nlextents, unsigned);
1212 	emitter_kv(emitter, "nlextents", "Number of large size classes",
1213 	    emitter_type_unsigned, &nlextents);
1214 
1215 	if (emitter->output == emitter_output_json) {
1216 		emitter_json_array_kv_begin(emitter, "lextent");
1217 		for (unsigned i = 0; i < nlextents; i++) {
1218 			emitter_json_object_begin(emitter);
1219 
1220 			CTL_M2_GET("arenas.lextent.0.size", i, &sv, size_t);
1221 			emitter_json_kv(emitter, "size", emitter_type_size,
1222 			    &sv);
1223 
1224 			emitter_json_object_end(emitter);
1225 		}
1226 		emitter_json_array_end(emitter); /* Close "lextent". */
1227 	}
1228 
1229 	emitter_json_object_end(emitter); /* Close "arenas" */
1230 }
1231 
1232 static void
1233 stats_print_helper(emitter_t *emitter, bool merged, bool destroyed,
1234     bool unmerged, bool bins, bool large, bool mutex, bool extents) {
1235 	/*
1236 	 * These should be deleted.  We keep them around for a while, to aid in
1237 	 * the transition to the emitter code.
1238 	 */
1239 	size_t allocated, active, metadata, metadata_thp, resident, mapped,
1240 	    retained;
1241 	size_t num_background_threads;
1242 	uint64_t background_thread_num_runs, background_thread_run_interval;
1243 
1244 	CTL_GET("stats.allocated", &allocated, size_t);
1245 	CTL_GET("stats.active", &active, size_t);
1246 	CTL_GET("stats.metadata", &metadata, size_t);
1247 	CTL_GET("stats.metadata_thp", &metadata_thp, size_t);
1248 	CTL_GET("stats.resident", &resident, size_t);
1249 	CTL_GET("stats.mapped", &mapped, size_t);
1250 	CTL_GET("stats.retained", &retained, size_t);
1251 
1252 	if (have_background_thread) {
1253 		CTL_GET("stats.background_thread.num_threads",
1254 		    &num_background_threads, size_t);
1255 		CTL_GET("stats.background_thread.num_runs",
1256 		    &background_thread_num_runs, uint64_t);
1257 		CTL_GET("stats.background_thread.run_interval",
1258 		    &background_thread_run_interval, uint64_t);
1259 	} else {
1260 		num_background_threads = 0;
1261 		background_thread_num_runs = 0;
1262 		background_thread_run_interval = 0;
1263 	}
1264 
1265 	/* Generic global stats. */
1266 	emitter_json_object_kv_begin(emitter, "stats");
1267 	emitter_json_kv(emitter, "allocated", emitter_type_size, &allocated);
1268 	emitter_json_kv(emitter, "active", emitter_type_size, &active);
1269 	emitter_json_kv(emitter, "metadata", emitter_type_size, &metadata);
1270 	emitter_json_kv(emitter, "metadata_thp", emitter_type_size,
1271 	    &metadata_thp);
1272 	emitter_json_kv(emitter, "resident", emitter_type_size, &resident);
1273 	emitter_json_kv(emitter, "mapped", emitter_type_size, &mapped);
1274 	emitter_json_kv(emitter, "retained", emitter_type_size, &retained);
1275 
1276 	emitter_table_printf(emitter, "Allocated: %zu, active: %zu, "
1277 	    "metadata: %zu (n_thp %zu), resident: %zu, mapped: %zu, "
1278 	    "retained: %zu\n", allocated, active, metadata, metadata_thp,
1279 	    resident, mapped, retained);
1280 
1281 	/* Background thread stats. */
1282 	emitter_json_object_kv_begin(emitter, "background_thread");
1283 	emitter_json_kv(emitter, "num_threads", emitter_type_size,
1284 	    &num_background_threads);
1285 	emitter_json_kv(emitter, "num_runs", emitter_type_uint64,
1286 	    &background_thread_num_runs);
1287 	emitter_json_kv(emitter, "run_interval", emitter_type_uint64,
1288 	    &background_thread_run_interval);
1289 	emitter_json_object_end(emitter); /* Close "background_thread". */
1290 
1291 	emitter_table_printf(emitter, "Background threads: %zu, "
1292 	    "num_runs: %"FMTu64", run_interval: %"FMTu64" ns\n",
1293 	    num_background_threads, background_thread_num_runs,
1294 	    background_thread_run_interval);
1295 
1296 	if (mutex) {
1297 		emitter_row_t row;
1298 		emitter_col_t name;
1299 		emitter_col_t col64[mutex_prof_num_uint64_t_counters];
1300 		emitter_col_t col32[mutex_prof_num_uint32_t_counters];
1301 		uint64_t uptime;
1302 
1303 		emitter_row_init(&row);
1304 		mutex_stats_init_cols(&row, "", &name, col64, col32);
1305 
1306 		emitter_table_row(emitter, &row);
1307 		emitter_json_object_kv_begin(emitter, "mutexes");
1308 
1309 		CTL_M2_GET("stats.arenas.0.uptime", 0, &uptime, uint64_t);
1310 
1311 		for (int i = 0; i < mutex_prof_num_global_mutexes; i++) {
1312 			mutex_stats_read_global(global_mutex_names[i], &name,
1313 			    col64, col32, uptime);
1314 			emitter_json_object_kv_begin(emitter, global_mutex_names[i]);
1315 			mutex_stats_emit(emitter, &row, col64, col32);
1316 			emitter_json_object_end(emitter);
1317 		}
1318 
1319 		emitter_json_object_end(emitter); /* Close "mutexes". */
1320 	}
1321 
1322 	emitter_json_object_end(emitter); /* Close "stats". */
1323 
1324 	if (merged || destroyed || unmerged) {
1325 		unsigned narenas;
1326 
1327 		emitter_json_object_kv_begin(emitter, "stats.arenas");
1328 
1329 		CTL_GET("arenas.narenas", &narenas, unsigned);
1330 		size_t mib[3];
1331 		size_t miblen = sizeof(mib) / sizeof(size_t);
1332 		size_t sz;
1333 		VARIABLE_ARRAY(bool, initialized, narenas);
1334 		bool destroyed_initialized;
1335 		unsigned i, j, ninitialized;
1336 
1337 		xmallctlnametomib("arena.0.initialized", mib, &miblen);
1338 		for (i = ninitialized = 0; i < narenas; i++) {
1339 			mib[1] = i;
1340 			sz = sizeof(bool);
1341 			xmallctlbymib(mib, miblen, &initialized[i], &sz,
1342 			    NULL, 0);
1343 			if (initialized[i]) {
1344 				ninitialized++;
1345 			}
1346 		}
1347 		mib[1] = MALLCTL_ARENAS_DESTROYED;
1348 		sz = sizeof(bool);
1349 		xmallctlbymib(mib, miblen, &destroyed_initialized, &sz,
1350 		    NULL, 0);
1351 
1352 		/* Merged stats. */
1353 		if (merged && (ninitialized > 1 || !unmerged)) {
1354 			/* Print merged arena stats. */
1355 			emitter_table_printf(emitter, "Merged arenas stats:\n");
1356 			emitter_json_object_kv_begin(emitter, "merged");
1357 			stats_arena_print(emitter, MALLCTL_ARENAS_ALL, bins,
1358 			    large, mutex, extents);
1359 			emitter_json_object_end(emitter); /* Close "merged". */
1360 		}
1361 
1362 		/* Destroyed stats. */
1363 		if (destroyed_initialized && destroyed) {
1364 			/* Print destroyed arena stats. */
1365 			emitter_table_printf(emitter,
1366 			    "Destroyed arenas stats:\n");
1367 			emitter_json_object_kv_begin(emitter, "destroyed");
1368 			stats_arena_print(emitter, MALLCTL_ARENAS_DESTROYED,
1369 			    bins, large, mutex, extents);
1370 			emitter_json_object_end(emitter); /* Close "destroyed". */
1371 		}
1372 
1373 		/* Unmerged stats. */
1374 		if (unmerged) {
1375 			for (i = j = 0; i < narenas; i++) {
1376 				if (initialized[i]) {
1377 					char arena_ind_str[20];
1378 					malloc_snprintf(arena_ind_str,
1379 					    sizeof(arena_ind_str), "%u", i);
1380 					emitter_json_object_kv_begin(emitter,
1381 					    arena_ind_str);
1382 					emitter_table_printf(emitter,
1383 					    "arenas[%s]:\n", arena_ind_str);
1384 					stats_arena_print(emitter, i, bins,
1385 					    large, mutex, extents);
1386 					/* Close "<arena-ind>". */
1387 					emitter_json_object_end(emitter);
1388 				}
1389 			}
1390 		}
1391 		emitter_json_object_end(emitter); /* Close "stats.arenas". */
1392 	}
1393 }
1394 
1395 void
1396 stats_print(void (*write_cb)(void *, const char *), void *cbopaque,
1397     const char *opts) {
1398 	int err;
1399 	uint64_t epoch;
1400 	size_t u64sz;
1401 #define OPTION(o, v, d, s) bool v = d;
1402 	STATS_PRINT_OPTIONS
1403 #undef OPTION
1404 
1405 	/*
1406 	 * Refresh stats, in case mallctl() was called by the application.
1407 	 *
1408 	 * Check for OOM here, since refreshing the ctl cache can trigger
1409 	 * allocation.  In practice, none of the subsequent mallctl()-related
1410 	 * calls in this function will cause OOM if this one succeeds.
1411 	 * */
1412 	epoch = 1;
1413 	u64sz = sizeof(uint64_t);
1414 	err = je_mallctl("epoch", (void *)&epoch, &u64sz, (void *)&epoch,
1415 	    sizeof(uint64_t));
1416 	if (err != 0) {
1417 		if (err == EAGAIN) {
1418 			malloc_write("<jemalloc>: Memory allocation failure in "
1419 			    "mallctl(\"epoch\", ...)\n");
1420 			return;
1421 		}
1422 		malloc_write("<jemalloc>: Failure in mallctl(\"epoch\", "
1423 		    "...)\n");
1424 		abort();
1425 	}
1426 
1427 	if (opts != NULL) {
1428 		for (unsigned i = 0; opts[i] != '\0'; i++) {
1429 			switch (opts[i]) {
1430 #define OPTION(o, v, d, s) case o: v = s; break;
1431 				STATS_PRINT_OPTIONS
1432 #undef OPTION
1433 			default:;
1434 			}
1435 		}
1436 	}
1437 
1438 	emitter_t emitter;
1439 	emitter_init(&emitter,
1440 	    json ? emitter_output_json : emitter_output_table, write_cb,
1441 	    cbopaque);
1442 	emitter_begin(&emitter);
1443 	emitter_table_printf(&emitter, "___ Begin jemalloc statistics ___\n");
1444 	emitter_json_object_kv_begin(&emitter, "jemalloc");
1445 
1446 	if (general) {
1447 		stats_general_print(&emitter);
1448 	}
1449 	if (config_stats) {
1450 		stats_print_helper(&emitter, merged, destroyed, unmerged,
1451 		    bins, large, mutex, extents);
1452 	}
1453 
1454 	emitter_json_object_end(&emitter); /* Closes the "jemalloc" dict. */
1455 	emitter_table_printf(&emitter, "--- End jemalloc statistics ---\n");
1456 	emitter_end(&emitter);
1457 }
1458