1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 #include <alloca.h>
27 #include <assert.h>
28 #include <errno.h>
29 #include <langinfo.h>
30 #include <libintl.h>
31 #include <libscf.h>
32 #include <signal.h>
33 #include <stdarg.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <strings.h>
37 #include <sys/fxpriocntl.h>
38 #include <sys/priocntl.h>
39 #include <sys/types.h>
40 #include <time.h>
41 #include <unistd.h>
42 #include <zonestat.h>
43
44 extern char *optarg;
45 extern int optind, opterr, optopt;
46
47 #define ZSTAT_OK 0
48 #define ZSTAT_ERROR 1
49 #define ZSTAT_USAGE 2
50
51 #define ZSTAT_UNIX_TIMESTAMP 1
52 #define ZSTAT_ISO_TIMESTAMP 2
53 #define ZSTAT_DATE_TIMESTAMP 3
54
55 #define ZSTAT_RES_PHYSICAL_MEMORY 0x1
56 #define ZSTAT_RES_VIRTUAL_MEMORY 0x2
57 #define ZSTAT_RES_LOCKED_MEMORY 0x4
58 #define ZSTAT_RES_MEMORY 0x7
59
60 #define ZSTAT_RES_DEFAULT_PSET 0x10
61 #define ZSTAT_RES_PSETS 0x20
62 #define ZSTAT_RES_SUMMARY 0x40
63
64 #define ZSTAT_RES_PROCESSES 0x100
65 #define ZSTAT_RES_LWPS 0x200
66 #define ZSTAT_RES_LOFI 0x400
67 #define ZSTAT_RES_LIMITS 0x700
68
69 #define ZSTAT_RES_SHM_MEMORY 0x1000
70 #define ZSTAT_RES_SHM_IDS 0x2000
71 #define ZSTAT_RES_SEM_IDS 0x4000
72 #define ZSTAT_RES_MSG_IDS 0x8000
73 #define ZSTAT_RES_SYSV 0xF000
74
75 #define ZSTAT_RES_ALL 0xF777
76
77 #define ZONESTAT_PHYSICAL_MEMORY "physical-memory"
78 #define ZONESTAT_VIRTUAL_MEMORY "virtual-memory"
79 #define ZONESTAT_LOCKED_MEMORY "locked-memory"
80 #define ZONESTAT_MEMORY "memory"
81
82 #define ZONESTAT_DEFAULT_PSET "default-pset"
83 #define ZONESTAT_POOL_PSET "pool-pset"
84 #define ZONESTAT_PSRSET_PSET "psrset-pset"
85 #define ZONESTAT_DEDICATED_CPU "dedicated-cpu"
86 #define ZONESTAT_PROCESSOR_SET "processor-set"
87 #define ZONESTAT_PSETS "psets"
88 #define ZONESTAT_SUMMARY "summary"
89
90 #define ZONESTAT_PROCESSES "processes"
91 #define ZONESTAT_LWPS "lwps"
92 #define ZONESTAT_LOFI "lofi"
93 #define ZONESTAT_LIMITS "limits"
94
95 #define ZONESTAT_SHM_MEMORY "shm-memory"
96 #define ZONESTAT_SHM_IDS "shm-ids"
97 #define ZONESTAT_SEM_IDS "sem-ids"
98 #define ZONESTAT_MSG_IDS "msg-ids"
99 #define ZONESTAT_SYSV "sysv"
100
101 #define ZONESTAT_ALL "all"
102
103 #define ZONESTAT_NAME_MEM_DEFAULT "mem_default"
104 #define ZONESTAT_NAME_VM_DEFAULT "vm_default"
105
106 #define ZONESTAT_NAME_AVERAGE "average"
107 #define ZONESTAT_NAME_HIGH "high"
108
109 #define ZONESTAT_NAME_RESOURCE "resource"
110 #define ZONESTAT_NAME_TOTAL "total"
111 #define ZONESTAT_NAME_SYSTEM "system"
112 #define ZONESTAT_NAME_ZONES "zones"
113 #define ZONESTAT_NAME_HEADER "header"
114 #define ZONESTAT_NAME_FOOTER "footer"
115
116 #define ZONESTAT_NAME_NAME "name"
117 #define ZONESTAT_NAME_USED "used"
118 #define ZONESTAT_NAME_CAP "cap"
119 #define ZONESTAT_NAME_PCAP "pcap"
120 #define ZONESTAT_NAME_SHR "shr"
121 #define ZONESTAT_NAME_PSHRU "pshru"
122 #define ZONESTAT_NAME_CPU "cpu"
123 #define ZONESTAT_NAME_PHYSICAL_MEMORY ZONESTAT_PHYSICAL_MEMORY
124 #define ZONESTAT_NAME_VIRTUAL_MEMORY ZONESTAT_VIRTUAL_MEMORY
125
126 #define ZONESTAT_NAME_SYSTEM_LIMIT "system-limit"
127
128 #define ZSTAT_REPORT_FMT_INTERVAL 0
129 #define ZSTAT_REPORT_FMT_TOTAL 1
130 #define ZSTAT_REPORT_FMT_AVERAGE 2
131 #define ZSTAT_REPORT_FMT_HIGH 3
132 #define ZSTAT_REPORT_FMT_END 4
133
134 #define ZSTAT_REPORT_TEXT_INTERVAL "interval"
135 #define ZSTAT_REPORT_TEXT_TOTAL "report-total"
136 #define ZSTAT_REPORT_TEXT_AVERAGE "report-average"
137 #define ZSTAT_REPORT_TEXT_HIGH "report-high"
138 #define ZSTAT_REPORT_TEXT_END "footer"
139
140 #define ZSTAT_DURATION_INF ((int)INT_MAX)
141 #define ZSTAT_INTERVAL_DEFAULT ((int)INT_MAX)
142 #define ZSTAT_REPORT_END ((int)INT_MAX)
143
144 #define ZSTAT_SORT_CPU 1
145 #define ZSTAT_SORT_PHYSICAL 2
146 #define ZSTAT_SORT_VIRTUAL 3
147 #define ZSTAT_SORT_USED 4
148 #define ZSTAT_SORT_CAP 5
149 #define ZSTAT_SORT_PCAP 6
150 #define ZSTAT_SORT_SHR 7
151 #define ZSTAT_SORT_PSHRU 8
152 #define ZSTAT_SORT_NAME 9
153 #define ZSTAT_SORT_MAX 10
154
155 #define ZSTAT_SUM_MIN_ZONENAME 19
156 #define ZSTAT_SUM_HDR_FORMAT "%23s %17s %17s\n"
157 #define ZSTAT_SUM_ZONE_FORMAT "%5s %5s %5s %5s %5s %5s %5s %5s %5s %5s\n"
158
159 #define ZSTAT_CPU_MIN_PSETNAME 22
160 #define ZSTAT_CPU_MIN_ZONENAME 36
161 #define ZSTAT_CPU_RES_FORMAT "%13s %11s %11s\n"
162 #define ZSTAT_CPU_ZONE_FORMAT "%5s %5s %5s %5s %6s %5s %5s\n"
163
164 #define ZSTAT_RESOURCE_MIN_RESNAME 28
165 #define ZSTAT_RESOURCE_MIN_ZONENAME 36
166 #define ZSTAT_RESOURCE_FORMAT "%13s\n"
167 #define ZSTAT_RESOURCE_ZONE_FORMAT "%5s %5s %5s %5s\n"
168
169 #define ZS_UINT64_STRLEN 20
170 #define ZS_PCT_STRLEN 10
171 #define ZS_TIME_STRLEN 20
172 #define ZS_NAME_STRLEN 10
173
174 time_t g_now_time;
175 time_t g_boot_time;
176 time_t g_start_time;
177 time_t g_end_time;
178 int g_interval;
179 int g_count;
180 int g_report_count;
181 time_t g_seconds;
182
183 int g_resources;
184 zs_ctl_t *g_zsctl;
185 boolean_t g_quit = B_FALSE;
186 zs_zone_t **g_zone_list;
187 int g_zone_num;
188 zs_pset_zone_t **g_pz_list;
189 int g_pz_num;
190 zs_pset_t **g_pset_list;
191 int g_pset_num;
192 int g_sort_by;
193 int g_sorts[ZSTAT_SORT_MAX];
194 int g_sort_summary;
195 size_t g_max_zonename;
196
197 /* Storage for command line arguments. */
198 char **arg_zonenames;
199 int arg_zonename_count;
200 char **arg_resnames;
201 int arg_resname_count;
202 char **arg_restypes;
203 int arg_restype_count;
204 char ** arg_reports;
205 int arg_report_count;
206 char ** arg_sort_list;
207 int arg_sort_count;
208 char ** arg_line_list;
209 int arg_line_count;
210
211 time_t arg_starttime;
212 time_t arg_endtime;
213 uint_t arg_timestamp = ZSTAT_DATE_TIMESTAMP;
214 int arg_interval = 5;
215 int arg_duration = -1;
216 int arg_report = -1;
217
218 /* Options with or as arguments */
219 boolean_t opt_zonenames = B_FALSE;
220 boolean_t opt_resnames = B_FALSE;
221 boolean_t opt_restypes = B_FALSE;
222 boolean_t opt_start = B_FALSE;
223 boolean_t opt_end = B_FALSE;
224 boolean_t opt_in = B_FALSE;
225 boolean_t opt_out = B_FALSE;
226 boolean_t opt_timestamp = B_FALSE;
227 boolean_t opt_report = B_FALSE;
228 boolean_t opt_sort = B_FALSE;
229
230 boolean_t opt_report_high = B_FALSE;
231 boolean_t opt_report_total = B_FALSE;
232 boolean_t opt_report_average = B_FALSE;
233
234 boolean_t opt_line_resource = B_FALSE;
235 boolean_t opt_line_total = B_FALSE;
236 boolean_t opt_line_system = B_FALSE;
237 boolean_t opt_line_zones = B_FALSE;
238 boolean_t opt_line_header = B_FALSE;
239 boolean_t opt_line_any = B_FALSE;
240
241 /* Options without arguments */
242 boolean_t opt_quiet_intervals = B_FALSE;
243 boolean_t opt_parseable = B_FALSE;
244 boolean_t opt_debug = B_FALSE;
245
246 static int
zonestat_usage(boolean_t explicit)247 zonestat_usage(boolean_t explicit)
248 {
249 FILE *fd = explicit ? stdout : stderr;
250
251 (void) fprintf(fd, gettext("Usage:\n"));
252 (void) fprintf(fd,
253 " zonestat [-z zonelist] [-r reslist] [-n namelist]\n"
254 " [-T u | d | i] [-R reports] [-q] [-p [-P lines]] [-S cols]\n"
255 " interval [duration [report]]\n"
256 "\n");
257 (void) fprintf(fd, gettext(
258 " Options:\n"
259 " %s Report resources of specified types.\n"
260 " Valid resource types are:\n"
261 " \"%s\"\n"
262 " \"%s\"\n"
263 " \"%s\"\n"
264 " \"%s\"\n"
265 " \"%s\", \"%s\", \"%s\"\n"
266 " \"%s\", \"%s\", \"%s\", \"%s\"\n"),
267 "-r",
268 ZONESTAT_VIRTUAL_MEMORY, ZONESTAT_PHYSICAL_MEMORY,
269 ZONESTAT_LOCKED_MEMORY, ZONESTAT_PROCESSOR_SET,
270 ZONESTAT_PROCESSES, ZONESTAT_LWPS, ZONESTAT_LOFI,
271 ZONESTAT_SHM_MEMORY, ZONESTAT_SHM_IDS, ZONESTAT_SEM_IDS,
272 ZONESTAT_MSG_IDS);
273
274 (void) fprintf(fd, gettext(
275 " The following resource nicknames can also be specified:\n"
276 " \"%s\"\n"
277 " \"%s\"\n"
278 " \"%s\"\n"
279 " \"%s\"\n"
280 " \"%s\"\n"
281 " \"%s\"\n"),
282 ZONESTAT_SUMMARY, ZONESTAT_MEMORY, ZONESTAT_PSETS,
283 ZONESTAT_DEFAULT_PSET, ZONESTAT_LIMITS, ZONESTAT_SYSV);
284 (void) fprintf(fd, gettext(
285 " %s Report resources used by zones\n"
286 " %s Report resources with specific names.\n"
287 " Valid resource names are:\n"
288 " \"%s\"\n"
289 " \"%s\"\n"
290 " Name of a pool processor set\n"
291 " Id of a processor set created with psrset(8)\n"
292 " Name of a zone using dedicated-cpu\n"),
293 "-z", "-n",
294 ZONESTAT_NAME_MEM_DEFAULT, ZONESTAT_NAME_VM_DEFAULT);
295 (void) fprintf(fd, gettext(
296 " %s Print timestamp. Valid timestamps are:\n"
297 " \"%s\"\tDate as specifed by date(1) command\n"
298 " \"%s\"\tUnix time as returned by time(2)\n"
299 " \"%s\"\tISO 8601 timestamp \"%s\"\n"
300 " %s Print reports at end or after each report interval.\n"
301 " Valid reports are:\n"
302 " \"%s\"\tUsage of each zone\n"
303 " \"%s\"\tUsage of each zone while running\n"
304 " \"%s\"\tMaximum usage of each zone\n"
305 " %s Quiet. Do not print intervals. Only print reports.\n"
306 " %s Machine parseable output.\n"),
307 "-T", "d", "u", "i", "YYYYMMDDThhmmssZ",
308 "-R", ZONESTAT_NAME_TOTAL, ZONESTAT_NAME_AVERAGE,
309 ZONESTAT_NAME_HIGH,
310 "-q", "-p");
311
312 (void) fprintf(fd, gettext(
313 " %s Select desired lines in parseable output.\n"
314 " \"%s\"\tLines describing each resource\n"
315 " \"%s\"\tTotal usage of each resource\n"
316 " \"%s\"\tSystem usage of each resource\n"
317 " \"%s\"\tPer-zone usage of each resource\n"
318 " \"%s\"\tHeader lines between intervals and reports\n"),
319 "-P", ZONESTAT_NAME_RESOURCE, ZONESTAT_NAME_TOTAL,
320 ZONESTAT_NAME_SYSTEM, ZONESTAT_NAME_ZONES, ZONESTAT_NAME_HEADER);
321
322 (void) fprintf(fd, gettext(
323 " %s Sort output by the specified columns:\n"
324 " \"%s\"\tby name alphanumerically\n"
325 " \"%s\"\tby percent of resource used\n"
326 " \"%s\"\tby configured cap\n"
327 " \"%s\"\tby percent of cap used\n"
328 " \"%s\"\tby shares configured\n"
329 " \"%s\"\tby percent of share used\n"
330 " \"%s\"\tSort summary by cpu\n"
331 " \"%s\"\tSort summary by physical memory\n"
332 " \"%s\"\tSort summary by virtual memory\n"),
333 "-S", ZONESTAT_NAME_NAME, ZONESTAT_NAME_USED, ZONESTAT_NAME_CAP,
334 ZONESTAT_NAME_PCAP, ZONESTAT_NAME_SHR, ZONESTAT_NAME_PSHRU,
335 ZONESTAT_NAME_CPU, ZONESTAT_NAME_PHYSICAL_MEMORY,
336 ZONESTAT_NAME_VIRTUAL_MEMORY);
337
338 if (!explicit)
339 (void) fputs("\n", fd);
340 return (ZSTAT_USAGE);
341 }
342
343 /* PRINTFLIKE1 */
344 static int
zonestat_error(const char * fmt,...)345 zonestat_error(const char *fmt, ...)
346 {
347 va_list alist;
348
349 va_start(alist, fmt);
350
351 (void) fprintf(stderr, "zonestat: Error: ");
352 (void) vfprintf(stderr, fmt, alist);
353 (void) fprintf(stderr, "\n");
354 va_end(alist);
355 return (ZSTAT_ERROR);
356 }
357
358 static void
zonestat_determine_lines()359 zonestat_determine_lines()
360 {
361 int i;
362 boolean_t fail = B_FALSE;
363
364 if (arg_line_count == 0) {
365 opt_line_resource = B_TRUE;
366 opt_line_total = B_TRUE;
367 opt_line_system = B_TRUE;
368 opt_line_zones = B_TRUE;
369 opt_line_header = B_TRUE;
370 }
371 for (i = 0; i < arg_line_count; i++) {
372 if (strcmp(arg_line_list[i], ZONESTAT_NAME_RESOURCE) == 0)
373 opt_line_resource = B_TRUE;
374 else if (strcmp(arg_line_list[i], ZONESTAT_NAME_TOTAL) == 0)
375 opt_line_total = B_TRUE;
376 else if (strcmp(arg_line_list[i], ZONESTAT_NAME_SYSTEM) == 0)
377 opt_line_system = B_TRUE;
378 else if (strcmp(arg_line_list[i], ZONESTAT_NAME_ZONES) == 0)
379 opt_line_zones = B_TRUE;
380 else if (strcmp(arg_line_list[i], ZONESTAT_NAME_HEADER) == 0)
381 opt_line_header = B_TRUE;
382 else {
383 (void) zonestat_error(gettext("Unknown -O arg: %s"),
384 arg_line_list[i]);
385 fail = B_TRUE;
386 }
387 }
388 if (fail == B_TRUE)
389 exit(zonestat_usage(B_FALSE));
390 }
391
392 static void
zonestat_determine_reports()393 zonestat_determine_reports()
394 {
395 int i;
396 boolean_t fail = B_FALSE;
397
398 for (i = 0; i < arg_report_count; i++) {
399 if (strcmp(arg_reports[i], ZONESTAT_NAME_TOTAL) == 0)
400 opt_report_total = B_TRUE;
401 else if (strcmp(arg_reports[i], ZONESTAT_NAME_AVERAGE) == 0)
402 opt_report_average = B_TRUE;
403 else if (strcmp(arg_reports[i], ZONESTAT_NAME_HIGH) == 0)
404 opt_report_high = B_TRUE;
405 else {
406 (void) zonestat_error(gettext("Unknown -R arg: %s"),
407 arg_reports[i]);
408 fail = B_TRUE;
409 }
410 }
411 if (fail == B_TRUE)
412 exit(zonestat_usage(B_FALSE));
413 }
414
415 /*
416 * Compares list of -S sort arguments to the list of known sorts. Only
417 * one of cpu, physical memory, and virtual memory can be specified.
418 */
419 static void
zonestat_determine_sort()420 zonestat_determine_sort()
421 {
422 int i, count = 0;
423 boolean_t fail = B_FALSE;
424
425 if (arg_sort_count == 0) {
426 g_sort_summary = ZS_RESOURCE_CPU;
427 g_sorts[0] = ZSTAT_SORT_USED;
428 g_sorts[1] = ZSTAT_SORT_NAME;
429 arg_sort_count = 2;
430 return;
431 }
432
433 if (arg_sort_count > ZSTAT_SORT_MAX)
434 exit(zonestat_error(gettext(
435 "Too many -S sort columns specified")));
436
437 for (i = 0; i < arg_sort_count; i++) {
438 if (strcmp(arg_sort_list[i], ZONESTAT_NAME_NAME) == 0)
439 g_sorts[count++] = ZSTAT_SORT_NAME;
440 else if (strcmp(arg_sort_list[i], ZONESTAT_NAME_USED) == 0)
441 g_sorts[count++] = ZSTAT_SORT_USED;
442 else if (strcmp(arg_sort_list[i], ZONESTAT_NAME_CAP) == 0)
443 g_sorts[count++] = ZSTAT_SORT_CAP;
444 else if (strcmp(arg_sort_list[i], ZONESTAT_NAME_PCAP) == 0)
445 g_sorts[count++] = ZSTAT_SORT_PCAP;
446 else if (strcmp(arg_sort_list[i], ZONESTAT_NAME_SHR) == 0)
447 g_sorts[count++] = ZSTAT_SORT_SHR;
448 else if (strcmp(arg_sort_list[i], ZONESTAT_NAME_PSHRU) == 0)
449 g_sorts[count++] = ZSTAT_SORT_PSHRU;
450 else if (strcmp(arg_sort_list[i], ZONESTAT_NAME_CPU) == 0) {
451 if (g_sort_summary != 0)
452 fail = B_TRUE;
453 g_sort_summary = ZS_RESOURCE_CPU;
454 } else if (strcmp(arg_sort_list[i],
455 ZONESTAT_NAME_PHYSICAL_MEMORY) == 0) {
456 if (g_sort_summary != 0)
457 fail = B_TRUE;
458 g_sort_summary = ZS_RESOURCE_RAM_RSS;
459 } else if (strcmp(arg_sort_list[i],
460 ZONESTAT_NAME_VIRTUAL_MEMORY) == 0) {
461 if (g_sort_summary != 0)
462 fail = B_TRUE;
463 g_sort_summary = ZS_RESOURCE_VM;
464 } else {
465 (void) zonestat_error(gettext("Unknown -S arg: %s"),
466 arg_sort_list[i]);
467 fail = B_TRUE;
468 }
469 }
470 if (g_sort_summary == 0)
471 g_sort_summary = ZS_RESOURCE_CPU;
472
473 if (fail == B_TRUE) {
474 (void) zonestat_error(gettext(
475 "-S: only one of \"%s\", \"%s\", or "
476 "\"%s\" permitted"), "-S", ZONESTAT_NAME_CPU,
477 ZONESTAT_NAME_PHYSICAL_MEMORY,
478 ZONESTAT_NAME_VIRTUAL_MEMORY);
479 exit(zonestat_usage(B_FALSE));
480 }
481 }
482
483 typedef struct zonestat_resource_struct {
484 char *zr_name;
485 uint_t zr_flag;
486 } zonestat_resource_t;
487
488
489 /* Used to map resource name strings to resource flags */
490 zonestat_resource_t g_resource_list[] = {
491 ZONESTAT_PHYSICAL_MEMORY, ZSTAT_RES_PHYSICAL_MEMORY,
492 ZONESTAT_VIRTUAL_MEMORY, ZSTAT_RES_VIRTUAL_MEMORY,
493 ZONESTAT_LOCKED_MEMORY, ZSTAT_RES_LOCKED_MEMORY,
494 ZONESTAT_MEMORY, ZSTAT_RES_MEMORY,
495 ZONESTAT_PROCESSOR_SET, ZSTAT_RES_PSETS,
496 ZONESTAT_PSETS, ZSTAT_RES_PSETS,
497 ZONESTAT_DEFAULT_PSET, ZSTAT_RES_DEFAULT_PSET,
498 ZONESTAT_PROCESSES, ZSTAT_RES_PROCESSES,
499 ZONESTAT_LWPS, ZSTAT_RES_LWPS,
500 ZONESTAT_LOFI, ZSTAT_RES_LOFI,
501 ZONESTAT_LIMITS, ZSTAT_RES_LIMITS,
502 ZONESTAT_SHM_MEMORY, ZSTAT_RES_SHM_MEMORY,
503 ZONESTAT_SHM_IDS, ZSTAT_RES_SHM_IDS,
504 ZONESTAT_SEM_IDS, ZSTAT_RES_SEM_IDS,
505 ZONESTAT_MSG_IDS, ZSTAT_RES_MSG_IDS,
506 ZONESTAT_SYSV, ZSTAT_RES_SYSV,
507 ZONESTAT_SUMMARY, ZSTAT_RES_SUMMARY,
508 ZONESTAT_ALL, ZSTAT_RES_ALL
509 };
510
511 /*
512 * Compares list of resources passed to -r to the known list of
513 * resources.
514 */
515 static void
zonestat_determine_resources()516 zonestat_determine_resources()
517 {
518 int i, j, count;
519 boolean_t found, fail = B_FALSE;
520
521 if (arg_restype_count == 0) {
522 g_resources = ZSTAT_RES_SUMMARY;
523 return;
524 }
525
526 count = sizeof (g_resource_list) / sizeof (zonestat_resource_t);
527
528 for (i = 0; i < arg_restype_count; i++) {
529 found = B_FALSE;
530 for (j = 0; j < count; j++) {
531 if (strcmp(arg_restypes[i], g_resource_list[j].zr_name)
532 == 0) {
533 g_resources |= g_resource_list[j].zr_flag;
534 found = B_TRUE;
535 break;
536 }
537 }
538 if (found == B_FALSE) {
539 (void) zonestat_error(gettext("Unknown resource: %s"),
540 arg_restypes[i]);
541 fail = B_TRUE;
542 }
543 }
544 if (fail == B_TRUE)
545 exit(zonestat_usage(B_FALSE));
546 }
547
548 /*
549 * Returns 1 if the name matches one of the specified zone names. 0
550 * otherwise. Always matches if no zone names were specified.
551 */
552 static int
zonestat_match_zonename(char * name)553 zonestat_match_zonename(char *name)
554 {
555 int i;
556
557 if (arg_zonename_count == 0)
558 return (1);
559 for (i = 0; i < arg_zonename_count; i++) {
560 if (strcmp(name, arg_zonenames[i]) == 0)
561 return (1);
562 }
563 return (0);
564 }
565
566 /*
567 * compare name to base, ignoring prefix on name.
568 */
569 static int
zonestat_match_with_prefix(char * prefix,char * name,char * base)570 zonestat_match_with_prefix(char *prefix, char *name, char *base)
571 {
572 size_t prefix_len;
573
574 prefix_len = strlen(prefix);
575 if (strncmp(name, prefix, prefix_len) == 0) {
576 name += prefix_len;
577 if (strcmp(name, base) == 0)
578 return (1);
579 }
580 return (0);
581 }
582 /*
583 * Returns 1 if the resource matches one of the specified resource names. 0
584 * otherwise. Always matches if no resource names were specified.
585 */
586 static int
zonestat_match_resname(char * name)587 zonestat_match_resname(char *name)
588 {
589 int i;
590
591 if (arg_resname_count == 0)
592 return (1);
593 for (i = 0; i < arg_resname_count; i++) {
594
595 if (strcmp(name, arg_resnames[i]) == 0)
596 return (1);
597
598 if (zonestat_match_with_prefix("SUNWtmp_", name,
599 arg_resnames[i]))
600 return (1);
601
602 if (zonestat_match_with_prefix("SUNWlegacy_pset_", name,
603 arg_resnames[i]))
604 return (1);
605 }
606 return (0);
607 }
608
609 /*
610 * Format unsigned uint64_t
611 *
612 * 9999 9999
613 * 99.9K 99999
614 * 9999K 9999999
615 * 99.9M 99999999
616 * 9999M 9999999999
617 * 99.9G 99999999999
618 * 9999G 9999999999999
619 * 99.9T 99999999999999
620 * 9999T 9999999999999999
621 * 99.9P 99999999999999999
622 * 9999P 9999999999999999999
623 * 99.9E UINT64_MAX
624 */
625 static void
format_uint64(uint64_t val,char * str,size_t len)626 format_uint64(uint64_t val, char *str, size_t len)
627 {
628 uint64_t high;
629 uint64_t low;
630
631 if (val == UINT64_MAX) {
632 (void) snprintf(str, len, "-");
633 return;
634 }
635 if (val <= 9999) {
636 (void) snprintf(str, len, "%llu", val);
637 return;
638 }
639 if (val <= 99999) {
640 high = val / 1024;
641 low = val * 10 / 1024 - (high * 10);
642 (void) snprintf(str, len, "%llu%1.1lluK", high, low);
643 return;
644 }
645 val = val / 1024;
646 if (val <= 9999 || opt_parseable) {
647 high = val;
648 (void) snprintf(str, len, "%lluK", high);
649 return;
650 }
651 if (val <= 99999) {
652 high = val / 1024;
653 low = val * 10 / 1024 - (high * 10);
654 (void) snprintf(str, len, "%llu.%1.1lluM", high, low);
655 return;
656 }
657 val = val / 1024;
658 if (val <= 9999) {
659 high = val;
660 (void) snprintf(str, len, "%lluM", high);
661 return;
662 }
663 if (val <= 99999) {
664 high = val / 1024;
665 low = val * 10 / 1024 - (high * 10);
666 (void) snprintf(str, len, "%llu.%1.1lluG", high, low);
667 return;
668 }
669 val = val / 1024;
670 if (val <= 9999) {
671 high = val;
672 (void) snprintf(str, len, "%lluG", high);
673 return;
674 }
675 if (val <= 99999) {
676 high = val / 1024;
677 low = val * 10 / 1024 - (high * 10);
678 (void) snprintf(str, len, "%llu.%1.1lluT", high, low);
679 return;
680 }
681 val = val / 1024;
682 if (val <= 9999) {
683 high = val;
684 (void) snprintf(str, len, "%lluT", high);
685 return;
686 }
687 if (val <= 99999) {
688 high = val / 1024;
689 low = val * 10 / 1024 - (high * 10);
690 (void) snprintf(str, len, "%llu.%1.1lluP", high, low);
691 return;
692 }
693 val = val / 1024;
694 if (val <= 9999) {
695 high = val;
696 (void) snprintf(str, len, "%lluP", high);
697 return;
698 }
699 high = val / 1024;
700 low = val * 10 / 1024 - (high * 10);
701 (void) snprintf(str, len, "%llu.%1.1lluE", high, low);
702 }
703
704
705 static void
format_pct(uint_t pct,char * str,size_t len)706 format_pct(uint_t pct, char *str, size_t len)
707 {
708 uint_t high;
709 uint_t low;
710
711 if (pct == ZS_PCT_NONE) {
712 (void) snprintf(str, len, "-");
713 return;
714 }
715 /*
716 * pct's are printed as one of:
717 * #.##%
718 * ##.#%
719 * ###%
720 * ####%
721 *
722 * The value is fixed decimal. 10000 equals 100.00 percent.
723 * Percents can exceed 100.00 percent. Percents greater than
724 * 9999% will exceed the 5 column width.
725 */
726 if (pct <= 999 || opt_parseable) {
727 high = pct / 100;
728 low = pct - (high * 100);
729 (void) snprintf(str, len, "%u.%2.2u%%", high, low);
730 } else if (pct <= 9999) {
731 pct = pct / 10;
732 high = pct / 10;
733 low = pct - (high * 10);
734 (void) snprintf(str, len, "%u.%1.1u%%", high, low);
735 } else {
736 pct = pct / 100;
737 (void) snprintf(str, len, "%u%%", pct);
738 }
739 }
740 /*
741 * Cpu cap is 100 times the number of cpus allocated. It is formatted as a
742 * decimal. Example, a cpu-cap of 50 is 0.50 cpus.
743 *
744 * The cpu cap value can go up to UINT_MAX, so handle all cases even though
745 * the higher ones are nonsense.
746 *
747 * Format Max cpu-cap value for format.
748 * 42.9M 4294967296
749 * 9999K 999999999
750 * 99.9K 9999999
751 * 9999 999999
752 * 999.9 99999
753 * 9.99 999
754 */
755 void
format_cpu(uint64_t cpu,char * str,size_t len)756 format_cpu(uint64_t cpu, char *str, size_t len)
757 {
758
759 uint64_t high;
760 uint64_t low;
761
762 /* #.## cpus */
763 if (cpu <= 999 || opt_parseable) {
764 high = cpu / 100;
765 low = cpu - (high * 100);
766 (void) snprintf(str, len, "%llu.%2.2llu", high, low);
767 return;
768 }
769 /* ##.# cpus */
770 if (cpu <= 99999) {
771 high = cpu / 100;
772 low = cpu - (high * 100);
773 (void) snprintf(str, len, "%llu.%1.1llu", high, low);
774 return;
775 }
776 /* #### cpus */
777 if (cpu <= 999999) {
778 cpu = cpu / 100;
779 (void) snprintf(str, len, "%llu", cpu);
780 return;
781 }
782 /* ##.#K cpus */
783 cpu = cpu / 1000;
784 if (cpu <= 99999) {
785 high = cpu / 100;
786 low = cpu - (high * 100);
787 (void) snprintf(str, len, "%llu.%1.1lluK", high, low);
788 return;
789 }
790 /* ####K cpus */
791 if (cpu <= 999999) {
792 cpu = cpu / 100;
793 (void) snprintf(str, len, "%lluK", cpu);
794 return;
795 }
796 /* ##.#M cpus */
797 cpu = cpu / 1000;
798 if (cpu <= UINT_MAX) {
799 high = cpu / 100;
800 low = cpu - (high * 100);
801 (void) snprintf(str, len, "%llu.%1.1lluM", high, low);
802 return;
803 }
804 (void) snprintf(str, len, "error", high, low);
805 }
806
807 /*
808 * Format a timetruct as:
809 * HH:MM:SS.SS
810 *
811 * Human readable format omits the fractional seconds.
812 */
813 static void
format_ts(timestruc_t * ts,char * str,size_t len,boolean_t human_readable)814 format_ts(timestruc_t *ts, char *str, size_t len, boolean_t human_readable)
815 {
816 uint64_t secs, mins, hours, pct;
817
818 hours = 0;
819 mins = 0;
820
821 secs = ts->tv_sec;
822 pct = ts->tv_nsec / 1000 / 1000 / 10;
823 while (pct >= 100) {
824 pct -= 100;
825 secs++;
826 }
827 if (secs >= 60) {
828 mins = secs / 60;
829 secs = secs % 60;
830 }
831 if (mins >= 60) {
832 hours = mins / 60;
833 mins = mins % 60;
834 }
835 if (human_readable)
836 (void) snprintf(str, len, "%llu:%2.2llu:%2.2llu", hours,
837 mins, secs);
838 else
839 (void) snprintf(str, len, "%llu-%2.2llu-%2.2llu.%2.2llu", hours,
840 mins, secs, pct);
841 }
842
843 char *g_report_formats[] = {
844 ZSTAT_REPORT_TEXT_INTERVAL,
845 ZSTAT_REPORT_TEXT_TOTAL,
846 ZSTAT_REPORT_TEXT_AVERAGE,
847 ZSTAT_REPORT_TEXT_HIGH,
848 ZSTAT_REPORT_TEXT_END
849 };
850
851 /* Get the label for the current report type */
852 static char *
zonestat_get_plabel(int format)853 zonestat_get_plabel(int format)
854 {
855 if (format >= sizeof (g_report_formats) / sizeof (char *))
856 exit(zonestat_error(gettext(
857 "Internal error, invalid report format")));
858
859 return (g_report_formats[format]);
860 }
861
862 #define ZSTAT_CPULINE "----------CPU----------"
863 #define ZSTAT_MEMLINE "----PHYSICAL-----"
864 #define ZSTAT_VMLINE "-----VIRTUAL-----"
865
866 static void
zonestat_print_summary_header(size_t namewidth,int report_fmt,uint64_t cpu,uint64_t online,uint64_t mem,uint64_t vm)867 zonestat_print_summary_header(size_t namewidth, int report_fmt, uint64_t cpu,
868 uint64_t online, uint64_t mem, uint64_t vm)
869 {
870 char str_cpu[ZS_UINT64_STRLEN];
871 char str_online[ZS_UINT64_STRLEN];
872 char str_mem[ZS_UINT64_STRLEN];
873 char str_vm[ZS_UINT64_STRLEN];
874 char name_format[ZS_NAME_STRLEN];
875 char tot_cpu[sizeof (ZSTAT_CPULINE)];
876 char tot_mem[sizeof (ZSTAT_MEMLINE)];
877 char tot_vm[sizeof (ZSTAT_VMLINE)];
878
879 char *label;
880
881 format_uint64(cpu, str_cpu, sizeof (str_cpu));
882 format_uint64(online, str_online, sizeof (str_online));
883 format_uint64(mem, str_mem, sizeof (str_mem));
884 format_uint64(vm, str_vm, sizeof (str_vm));
885
886 if (opt_parseable) {
887 label = zonestat_get_plabel(report_fmt);
888 (void) printf("%s:%s:[%s]:%s:%s:%s:%s\n", label,
889 ZONESTAT_SUMMARY, ZONESTAT_NAME_RESOURCE, str_cpu,
890 str_online, str_mem, str_vm);
891 return;
892 }
893
894 (void) snprintf(tot_cpu, sizeof (tot_cpu), "Cpus/Online: %s/%s",
895 str_cpu, str_online);
896
897 (void) snprintf(tot_mem, sizeof (tot_mem), "Physical: %s", str_mem);
898
899 (void) snprintf(tot_vm, sizeof (tot_vm), "Virtual: %s", str_vm);
900
901 /* Make first column as wide as longest zonename */
902 (void) snprintf(name_format, sizeof (name_format), "%%-%ds ",
903 namewidth);
904 /* LINTED */
905 (void) printf(name_format, "SUMMARY");
906 (void) printf(ZSTAT_SUM_HDR_FORMAT, tot_cpu, tot_mem,
907 tot_vm);
908
909 /* LINTED */
910 (void) printf(name_format, "");
911 (void) printf(ZSTAT_SUM_HDR_FORMAT, ZSTAT_CPULINE,
912 ZSTAT_MEMLINE, ZSTAT_VMLINE);
913
914 (void) snprintf(name_format, sizeof (name_format), "%%%ds ",
915 namewidth);
916 /* LINTED */
917 (void) printf(name_format, "ZONE");
918
919 (void) printf(ZSTAT_SUM_ZONE_FORMAT, "USED", "%PART", "%CAP",
920 "%SHRU", "USED", "PCT", "%CAP", "USED", "PCT", "%CAP");
921 }
922
923 static void
zonestat_print_resource__header(size_t namelen,char * restype,char * size)924 zonestat_print_resource__header(size_t namelen, char *restype, char *size)
925 {
926 char name_format[ZS_NAME_STRLEN];
927
928 if (opt_parseable)
929 return;
930
931 (void) snprintf(name_format, sizeof (name_format), "%%-%ds ", namelen);
932 /* LINTED */
933 (void) printf(name_format, restype);
934 (void) printf(ZSTAT_RESOURCE_FORMAT, size);
935 }
936
937 static void
zonestat_print_resource_zone_header(size_t namelen)938 zonestat_print_resource_zone_header(size_t namelen)
939 {
940 char name_format[ZS_NAME_STRLEN];
941
942 if (opt_parseable)
943 return;
944
945 (void) snprintf(name_format, sizeof (name_format), "%%%ds ", namelen);
946 /* LINTED */
947 (void) printf(name_format, "ZONE");
948
949 (void) printf(ZSTAT_RESOURCE_ZONE_FORMAT, "USED", "PCT", "CAP", "%CAP");
950 }
951
952 static void
zonestat_print_timestamp(time_t t)953 zonestat_print_timestamp(time_t t)
954 {
955 static char *fmt = NULL;
956 int len;
957 char dstr[64];
958
959 /* We only need to retrieve this once per invocation */
960
961 if (arg_timestamp == ZSTAT_UNIX_TIMESTAMP) {
962 (void) printf("%ld", t);
963 } else if (arg_timestamp == ZSTAT_ISO_TIMESTAMP) {
964
965 len = strftime(dstr, sizeof (dstr), "%Y%m%dT%H%M%SZ",
966 gmtime(&t));
967 if (len > 0)
968 (void) printf("%s", dstr);
969
970 } else {
971
972 if (fmt == NULL)
973 fmt = nl_langinfo(_DATE_FMT);
974
975 len = strftime(dstr, sizeof (dstr), fmt, localtime(&t));
976 if (len > 0)
977 (void) printf("%s", dstr);
978 }
979 }
980
981 static void
zonestat_print_summary_zone(size_t namewidth,int report_fmt,char * name,uint64_t cused,uint_t ppart,uint_t pccap,uint_t pshru,uint64_t mused,uint_t mpct,uint_t pmcap,uint64_t vused,uint_t vpct,uint_t pvcap)982 zonestat_print_summary_zone(size_t namewidth, int report_fmt, char *name,
983 uint64_t cused, uint_t ppart, uint_t pccap, uint_t pshru, uint64_t mused,
984 uint_t mpct, uint_t pmcap, uint64_t vused, uint_t vpct, uint_t pvcap)
985 {
986 char *label;
987
988 char str_cused[ZS_UINT64_STRLEN];
989 char str_ppart[ZS_PCT_STRLEN];
990 char str_pccap[ZS_PCT_STRLEN];
991 char str_pshru[ZS_PCT_STRLEN];
992 char str_mused[ZS_UINT64_STRLEN];
993 char str_mpct[ZS_PCT_STRLEN];
994 char str_pmcap[ZS_PCT_STRLEN];
995 char str_vused[ZS_UINT64_STRLEN];
996 char str_vpct[ZS_PCT_STRLEN];
997 char str_pvcap[ZS_PCT_STRLEN];
998 char name_format[ZS_NAME_STRLEN];
999
1000 format_cpu(cused, str_cused, sizeof (str_cused));
1001 format_pct(ppart, str_ppart, sizeof (str_ppart));
1002 format_pct(pccap, str_pccap, sizeof (str_pccap));
1003 format_pct(pshru, str_pshru, sizeof (str_pshru));
1004 format_uint64(mused, str_mused, sizeof (str_mused));
1005 format_pct(mpct, str_mpct, sizeof (str_mpct));
1006 format_pct(pmcap, str_pmcap, sizeof (str_pmcap));
1007 format_uint64(vused, str_vused, sizeof (str_vused));
1008 format_pct(vpct, str_vpct, sizeof (str_vpct));
1009 format_pct(pvcap, str_pvcap, sizeof (str_pvcap));
1010
1011 if (opt_parseable) {
1012 if (opt_timestamp) {
1013 zonestat_print_timestamp(g_now_time);
1014 (void) printf(":");
1015 }
1016 label = zonestat_get_plabel(report_fmt);
1017 (void) printf("%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s\n",
1018 label, ZONESTAT_SUMMARY, name, str_cused, str_ppart,
1019 str_pccap, str_pshru, str_mused, str_mpct, str_pmcap,
1020 str_vused, str_vpct, str_pvcap);
1021 return;
1022 }
1023 (void) snprintf(name_format, sizeof (name_format), "%%%ds ",
1024 namewidth);
1025 /* LINTED */
1026 (void) printf(name_format, name);
1027 (void) printf(ZSTAT_SUM_ZONE_FORMAT, str_cused, str_ppart,
1028 str_pccap, str_pshru, str_mused, str_mpct, str_pmcap, str_vused,
1029 str_vpct, str_pvcap);
1030 }
1031
1032 static void
zonestat_print_resource_(size_t namelen,int report_fmt,char * res,char * name,uint64_t size)1033 zonestat_print_resource_(size_t namelen, int report_fmt, char *res,
1034 char *name, uint64_t size)
1035 {
1036 char strsize[ZS_UINT64_STRLEN];
1037 char *label;
1038 char name_format[ZS_NAME_STRLEN];
1039
1040 format_uint64(size, strsize, sizeof (strsize));
1041 if (opt_parseable) {
1042 if (opt_timestamp) {
1043 zonestat_print_timestamp(g_now_time);
1044 (void) printf(":");
1045 }
1046 label = zonestat_get_plabel(report_fmt);
1047 (void) printf("%s:%s:%s:[%s]:%s\n", label, res, name,
1048 ZONESTAT_NAME_RESOURCE, strsize);
1049 return;
1050 }
1051
1052 (void) snprintf(name_format, sizeof (name_format), "%%-%ds ", namelen);
1053 /* LINTED */
1054 (void) printf(name_format, name);
1055 (void) printf(ZSTAT_RESOURCE_FORMAT, strsize);
1056 }
1057
1058 static void
zonestat_print_resource_zone(size_t namelen,int report_fmt,char * restype,char * resname,char * name,uint64_t used,uint_t pct,uint64_t cap,uint_t pctcap)1059 zonestat_print_resource_zone(size_t namelen, int report_fmt, char *restype,
1060 char *resname, char *name, uint64_t used, uint_t pct, uint64_t cap,
1061 uint_t pctcap)
1062 {
1063 char strused[ZS_UINT64_STRLEN];
1064 char strpct[ZS_PCT_STRLEN];
1065 char strcap[ZS_UINT64_STRLEN];
1066 char strpctcap[ZS_PCT_STRLEN];
1067 char name_format[ZS_NAME_STRLEN];
1068
1069 char *label;
1070
1071 format_uint64(used, strused, sizeof (strused));
1072 format_pct(pct, strpct, sizeof (strpct));
1073 if (cap == ZS_LIMIT_NONE)
1074 (void) strlcpy(strcap, "-", sizeof (strcap));
1075 else
1076 format_uint64(cap, strcap, sizeof (strcap));
1077
1078 if (pctcap == ZS_PCT_NONE)
1079 (void) strlcpy(strpctcap, "-", sizeof (strpctcap));
1080 else
1081 format_pct(pctcap, strpctcap, sizeof (strpctcap));
1082
1083 if (opt_parseable) {
1084 if (opt_timestamp) {
1085 zonestat_print_timestamp(g_now_time);
1086 (void) printf(":");
1087 }
1088 label = zonestat_get_plabel(report_fmt);
1089 (void) printf("%s:%s:%s:%s:%s:%s:%s:%s\n", label, restype,
1090 resname, name, strused, strpct, strcap, strpctcap);
1091 return;
1092 }
1093
1094 (void) snprintf(name_format, sizeof (name_format), "%%%ds ", namelen);
1095 /* LINTED */
1096 (void) printf(name_format, name);
1097 (void) printf(ZSTAT_RESOURCE_ZONE_FORMAT, strused, strpct, strcap,
1098 strpctcap);
1099 }
1100
1101 /*
1102 * Not thread safe.
1103 */
1104 static void
zonestat_qsort(void * base,size_t nel,size_t width,int (* compar)(const void *,const void *),int by)1105 zonestat_qsort(void *base, size_t nel, size_t width,
1106 int (*compar)(const void *, const void *), int by)
1107 {
1108 g_sort_by = by;
1109 g_max_zonename = 0;
1110 qsort(base, nel, width, compar);
1111 }
1112
1113 static int
zonestat_zone_compare_resource(const void * a,const void * b)1114 zonestat_zone_compare_resource(const void *a, const void *b)
1115 {
1116 zs_zone_t *zonea = *(zs_zone_t **)a;
1117 zs_zone_t *zoneb = *(zs_zone_t **)b;
1118 zs_property_t *prop, *propb;
1119 uint64_t resa, resb;
1120 uint_t uinta, uintb;
1121 int i, res;
1122
1123 prop = alloca(zs_property_size());
1124 propb = alloca(zs_property_size());
1125
1126 for (i = 0; i < arg_sort_count; i++) {
1127
1128 /* Sort by order of selection */
1129 switch (g_sorts[i]) {
1130 case ZSTAT_SORT_USED:
1131 resa = zs_resource_used_zone_uint64(zonea, g_sort_by);
1132 resb = zs_resource_used_zone_uint64(zoneb, g_sort_by);
1133 break;
1134 case ZSTAT_SORT_CAP:
1135 resa = zs_zone_limit_uint64(zonea, g_sort_by);
1136 if (resa == ZS_LIMIT_NONE)
1137 resa = 0;
1138 resb = zs_zone_limit_uint64(zoneb, g_sort_by);
1139 if (resb == ZS_LIMIT_NONE)
1140 resb = 0;
1141 break;
1142 case ZSTAT_SORT_PCAP:
1143 uinta = zs_zone_limit_used_pct(zonea, g_sort_by);
1144 uintb = zs_zone_limit_used_pct(zoneb, g_sort_by);
1145 if (uinta == ZS_PCT_NONE)
1146 resa = 0;
1147 else
1148 resa = uinta;
1149 if (uintb == ZS_PCT_NONE)
1150 resb = 0;
1151 else
1152 resb = uintb;
1153 break;
1154 case ZSTAT_SORT_SHR:
1155 zs_zone_property(zonea, ZS_PZ_PROP_CPU_SHARES, prop);
1156 resa = zs_property_uint64(prop);
1157 if (resa == ZS_LIMIT_NONE)
1158 resa = 0;
1159 zs_zone_property(zoneb, ZS_PZ_PROP_CPU_SHARES, prop);
1160 resb = zs_property_uint64(prop);
1161 if (resb == ZS_LIMIT_NONE)
1162 resb = 0;
1163 break;
1164 case ZSTAT_SORT_PSHRU:
1165 uinta = zs_zone_limit_used_pct(zonea,
1166 ZS_LIMIT_CPU_SHARES);
1167 uintb = zs_zone_limit_used_pct(zoneb,
1168 ZS_LIMIT_CPU_SHARES);
1169 if (uinta == ZS_PCT_NONE)
1170 resa = 0;
1171 else
1172 resa = uinta;
1173 if (uintb == ZS_PCT_NONE)
1174 resb = 0;
1175 else
1176 resb = uintb;
1177 break;
1178 case ZSTAT_SORT_NAME:
1179 zs_zone_property(zonea, ZS_ZONE_PROP_NAME, prop);
1180 zs_zone_property(zoneb, ZS_ZONE_PROP_NAME, propb);
1181
1182 res = strcmp(zs_property_string(prop),
1183 zs_property_string(propb));
1184 if (res != 0)
1185 return (res);
1186 break;
1187 default:
1188 exit(zonestat_error(gettext("Internal sort error")));
1189 }
1190 if (resa < resb)
1191 return (1);
1192 if (resb < resa)
1193 return (-1);
1194 }
1195 /* No difference, return 0 */
1196 return (0);
1197 }
1198 /*
1199 * Sort psets. Default pset first, then shared psets, then dedicated
1200 * psets.
1201 */
1202 static int
zonestat_pset_compare(const void * a,const void * b)1203 zonestat_pset_compare(const void *a, const void *b)
1204 {
1205 zs_pset_t *pseta = *(zs_pset_t **)a;
1206 zs_pset_t *psetb = *(zs_pset_t **)b;
1207 zs_property_t *p;
1208 uint_t typea, typeb;
1209
1210
1211 p = (zs_property_t *)alloca(zs_property_size());
1212 zs_pset_property(pseta, ZS_PSET_PROP_CPUTYPE, p);
1213 typea = zs_property_uint(p);
1214 zs_pset_property(psetb, ZS_PSET_PROP_CPUTYPE, p);
1215 typeb = zs_property_uint(p);
1216
1217 if (typea == ZS_CPUTYPE_DEFAULT_PSET)
1218 return (-1);
1219 if (typeb == ZS_CPUTYPE_DEFAULT_PSET)
1220 return (1);
1221 if (typea == ZS_CPUTYPE_POOL_PSET)
1222 return (-1);
1223 if (typeb == ZS_CPUTYPE_POOL_PSET)
1224 return (1);
1225 if (typea == ZS_CPUTYPE_PSRSET_PSET)
1226 return (-1);
1227 if (typeb == ZS_CPUTYPE_PSRSET_PSET)
1228 return (1);
1229
1230 return (0);
1231 }
1232
1233 static int
zonestat_pz_compare_usage(const void * a,const void * b)1234 zonestat_pz_compare_usage(const void *a, const void *b)
1235 {
1236 zs_pset_zone_t *zonea = *(zs_pset_zone_t **)a;
1237 zs_pset_zone_t *zoneb = *(zs_pset_zone_t **)b;
1238 zs_property_t *prop, *propb;
1239 uint64_t resa, resb;
1240 uint_t uinta, uintb;
1241 int i, res;
1242
1243 prop = alloca(zs_property_size());
1244 propb = alloca(zs_property_size());
1245
1246 for (i = 0; i < arg_sort_count; i++) {
1247
1248 /* Sort by order of selection */
1249 switch (g_sorts[i]) {
1250 case ZSTAT_SORT_USED:
1251 resa = zs_pset_zone_used_cpus(zonea);
1252 resb = zs_pset_zone_used_cpus(zoneb);
1253 break;
1254 case ZSTAT_SORT_CAP:
1255 zs_pset_zone_property(zonea, ZS_PZ_PROP_CPU_CAP,
1256 prop);
1257 resa = zs_property_uint64(prop);
1258 if (resa == ZS_LIMIT_NONE)
1259 resa = 0;
1260 zs_pset_zone_property(zoneb, ZS_PZ_PROP_CPU_CAP,
1261 prop);
1262 resb = zs_property_uint64(prop);
1263 if (resb == ZS_LIMIT_NONE)
1264 resb = 0;
1265 break;
1266 case ZSTAT_SORT_PCAP:
1267 uinta = zs_pset_zone_used_pct(zonea, ZS_PZ_PCT_CPU_CAP);
1268 uintb = zs_pset_zone_used_pct(zoneb, ZS_PZ_PCT_CPU_CAP);
1269 if (uinta == ZS_PCT_NONE)
1270 resa = 0;
1271 else
1272 resa = uinta;
1273 if (uintb == ZS_PCT_NONE)
1274 resb = 0;
1275 else
1276 resb = uintb;
1277 break;
1278 case ZSTAT_SORT_SHR:
1279 zs_pset_zone_property(zonea, ZS_PZ_PROP_CPU_SHARES,
1280 prop);
1281 resa = zs_property_uint64(prop);
1282 if (resa == ZS_LIMIT_NONE)
1283 resa = 0;
1284 zs_pset_zone_property(zoneb, ZS_PZ_PROP_CPU_SHARES,
1285 prop);
1286 resb = zs_property_uint64(prop);
1287 if (resb == ZS_LIMIT_NONE)
1288 resb = 0;
1289 break;
1290 case ZSTAT_SORT_PSHRU:
1291 uinta = zs_pset_zone_used_pct(zonea,
1292 ZS_PZ_PCT_CPU_SHARES);
1293 uintb = zs_pset_zone_used_pct(zoneb,
1294 ZS_PZ_PCT_CPU_SHARES);
1295 if (uinta == ZS_PCT_NONE)
1296 resa = 0;
1297 else
1298 resa = uinta;
1299 if (uintb == ZS_PCT_NONE)
1300 resb = 0;
1301 else
1302 resb = uintb;
1303 break;
1304 case ZSTAT_SORT_NAME:
1305 zs_zone_property(zs_pset_zone_get_zone(zonea),
1306 ZS_ZONE_PROP_NAME, prop);
1307 zs_zone_property(zs_pset_zone_get_zone(zoneb),
1308 ZS_ZONE_PROP_NAME, propb);
1309
1310 res = strcmp(zs_property_string(prop),
1311 zs_property_string(propb));
1312 if (res != 0)
1313 return (res);
1314 break;
1315 default:
1316 exit(zonestat_error(gettext("Internal sort error")));
1317 }
1318 if (resa < resb)
1319 return (1);
1320 if (resb < resa)
1321 return (-1);
1322 }
1323 /* No difference, return 0 */
1324 return (0);
1325 }
1326
1327
1328 static void
zonestat_print_summary(int report_fmt,zs_usage_t * u)1329 zonestat_print_summary(int report_fmt, zs_usage_t *u)
1330 {
1331 int num, i;
1332 zs_zone_t *z;
1333 uint64_t cpus, online, tot_mem, tot_vm;
1334 uint64_t cused, mused, vused;
1335 uint_t ppart, pshru, pccap, mpct, pmcap, vpct, pvcap;
1336 char zonename[ZS_ZONENAME_MAX];
1337 zs_property_t *prop;
1338 size_t namewidth = 0, len;
1339
1340 prop = (zs_property_t *)alloca(zs_property_size());
1341
1342 zs_resource_property(u, ZS_RESOURCE_CPU, ZS_RESOURCE_PROP_CPU_TOTAL,
1343 prop);
1344 cpus = zs_property_uint64(prop);
1345
1346 zs_resource_property(u, ZS_RESOURCE_CPU,
1347 ZS_RESOURCE_PROP_CPU_ONLINE, prop);
1348 online = zs_property_uint64(prop);
1349
1350 tot_mem = zs_resource_total_uint64(u, ZS_RESOURCE_RAM_RSS);
1351 tot_vm = zs_resource_total_uint64(u, ZS_RESOURCE_VM);
1352
1353 again:
1354 num = zs_zone_list(u, g_zone_list, g_zone_num);
1355 if (num > g_zone_num) {
1356 if (g_zone_list != NULL)
1357 free(g_zone_list);
1358 g_zone_list = (zs_zone_t **) malloc(sizeof (zs_zone_t *) * num);
1359 g_zone_num = num;
1360 goto again;
1361 }
1362
1363 /* Find the longest zone name to set output width. */
1364 namewidth = ZSTAT_SUM_MIN_ZONENAME;
1365 for (i = 0; i < num; i++) {
1366 z = g_zone_list[i];
1367 (void) zs_zone_property(z, ZS_ZONE_PROP_NAME, prop);
1368 len = strlen(zs_property_string(prop));
1369 if (len > namewidth)
1370 namewidth = len;
1371 }
1372 zonestat_print_summary_header(namewidth, report_fmt, cpus, online,
1373 tot_mem, tot_vm);
1374
1375 zonestat_qsort(g_zone_list, num, sizeof (zs_zone_t *),
1376 zonestat_zone_compare_resource, g_sort_summary);
1377
1378 cused = zs_resource_used_uint64(u, ZS_RESOURCE_CPU, ZS_USER_ALL);
1379 mused = zs_resource_used_uint64(u, ZS_RESOURCE_RAM_RSS, ZS_USER_ALL);
1380 vused = zs_resource_used_uint64(u, ZS_RESOURCE_VM, ZS_USER_ALL);
1381
1382 ppart = zs_resource_used_pct(u, ZS_RESOURCE_CPU, ZS_USER_ALL);
1383 mpct = zs_resource_used_pct(u, ZS_RESOURCE_RAM_RSS, ZS_USER_ALL);
1384 vpct = zs_resource_used_pct(u, ZS_RESOURCE_VM, ZS_USER_ALL);
1385
1386 if (opt_line_total) {
1387 (void) snprintf(zonename, sizeof (zonename), "[%s]",
1388 ZONESTAT_NAME_TOTAL);
1389 zonestat_print_summary_zone(namewidth, report_fmt, zonename,
1390 cused, ppart, ZS_PCT_NONE, ZS_PCT_NONE, mused, mpct,
1391 ZS_PCT_NONE, vused, vpct, ZS_PCT_NONE);
1392 }
1393 cused = zs_resource_used_uint64(u, ZS_RESOURCE_CPU, ZS_USER_KERNEL);
1394 mused = zs_resource_used_uint64(u, ZS_RESOURCE_RAM_RSS, ZS_USER_KERNEL);
1395 vused = zs_resource_used_uint64(u, ZS_RESOURCE_VM, ZS_USER_KERNEL);
1396
1397 ppart = zs_resource_used_pct(u, ZS_RESOURCE_CPU, ZS_USER_KERNEL);
1398 mpct = zs_resource_used_pct(u, ZS_RESOURCE_RAM_RSS, ZS_USER_KERNEL);
1399 vpct = zs_resource_used_pct(u, ZS_RESOURCE_VM, ZS_USER_KERNEL);
1400
1401 if (opt_line_system) {
1402 (void) snprintf(zonename, sizeof (zonename), "[%s]",
1403 ZONESTAT_NAME_SYSTEM);
1404 zonestat_print_summary_zone(namewidth, report_fmt, zonename,
1405 cused, ppart, ZS_PCT_NONE, ZS_PCT_NONE, mused, mpct,
1406 ZS_PCT_NONE, vused, vpct, ZS_PCT_NONE);
1407 }
1408 for (i = 0; i < num; i++) {
1409
1410 z = g_zone_list[i];
1411
1412 zs_zone_property(z, ZS_ZONE_PROP_NAME, prop);
1413 (void) strlcpy(zonename, zs_property_string(prop),
1414 sizeof (zonename));
1415
1416 cused = zs_resource_used_zone_uint64(z, ZS_RESOURCE_CPU);
1417 mused = zs_resource_used_zone_uint64(z, ZS_RESOURCE_RAM_RSS);
1418 vused = zs_resource_used_zone_uint64(z, ZS_RESOURCE_VM);
1419
1420 ppart = zs_resource_used_zone_pct(z, ZS_RESOURCE_CPU);
1421 mpct = zs_resource_used_zone_pct(z, ZS_RESOURCE_RAM_RSS);
1422 vpct = zs_resource_used_zone_pct(z, ZS_RESOURCE_VM);
1423
1424 pshru = zs_zone_limit_used_pct(z, ZS_LIMIT_CPU_SHARES);
1425 pccap = zs_zone_limit_used_pct(z, ZS_LIMIT_CPU);
1426 pmcap = zs_zone_limit_used_pct(z, ZS_LIMIT_RAM_RSS);
1427 pvcap = zs_zone_limit_used_pct(z, ZS_LIMIT_VM);
1428
1429 zonestat_print_summary_zone(namewidth, report_fmt, zonename,
1430 cused, ppart, pccap, pshru, mused, mpct, pmcap, vused, vpct,
1431 pvcap);
1432 }
1433
1434 if (!opt_parseable)
1435 (void) printf("\n");
1436 (void) fflush(stdout);
1437 }
1438
1439 static void
zonestat_print_res(int report_fmt,char * header,char * sizename,char * resname,char * name,zs_usage_t * u,int res,int limit)1440 zonestat_print_res(int report_fmt, char *header, char *sizename, char *resname,
1441 char *name, zs_usage_t *u, int res, int limit)
1442 {
1443 zs_zone_t *zone;
1444 char zonename[ZS_ZONENAME_MAX];
1445 uint64_t size;
1446 uint64_t used;
1447 uint64_t cap;
1448 uint_t pct;
1449 uint_t pctcap;
1450 zs_property_t *prop;
1451 int num, i;
1452 size_t namelen, len;
1453
1454 prop = (zs_property_t *)alloca(zs_property_size());
1455
1456 /* See if resource matches specified resource names */
1457 if (zonestat_match_resname(name) == 0)
1458 return;
1459
1460 namelen = strlen(resname);
1461 if (ZSTAT_RESOURCE_MIN_RESNAME > namelen)
1462 namelen = ZSTAT_RESOURCE_MIN_RESNAME;
1463
1464 zonestat_print_resource__header(namelen, header, sizename);
1465
1466 size = zs_resource_total_uint64(u, res);
1467
1468 if (opt_line_resource)
1469 zonestat_print_resource_(namelen, report_fmt, resname, name,
1470 size);
1471
1472 again:
1473 num = zs_zone_list(u, g_zone_list, g_zone_num);
1474 if (num > g_zone_num) {
1475 if (g_zone_list != NULL)
1476 free(g_zone_list);
1477 g_zone_list = (zs_zone_t **) malloc(sizeof (zs_zone_t *) * num);
1478 g_zone_num = num;
1479 goto again;
1480 }
1481 namelen = ZSTAT_RESOURCE_MIN_ZONENAME;
1482 for (i = 0; i < num; i++) {
1483 zone = g_zone_list[i];
1484 (void) zs_zone_property(zone, ZS_ZONE_PROP_NAME, prop);
1485 len = strlen(zs_property_string(prop));
1486 if (len > namelen)
1487 namelen = len;
1488 }
1489
1490 zonestat_print_resource_zone_header(namelen);
1491
1492 used = zs_resource_used_uint64(u, res, ZS_USER_ALL);
1493 pct = zs_resource_used_pct(u, res, ZS_USER_ALL);
1494
1495 if (opt_line_total) {
1496 (void) snprintf(zonename, sizeof (zonename), "[%s]",
1497 ZONESTAT_NAME_TOTAL);
1498 zonestat_print_resource_zone(namelen, report_fmt, resname,
1499 name, zonename, used, pct, ZS_LIMIT_NONE, ZS_PCT_NONE);
1500 }
1501 used = zs_resource_used_uint64(u, res, ZS_USER_KERNEL);
1502 pct = zs_resource_used_pct(u, res, ZS_USER_KERNEL);
1503
1504 if (opt_line_system) {
1505 (void) snprintf(zonename, sizeof (zonename), "[%s]",
1506 ZONESTAT_NAME_SYSTEM);
1507 zonestat_print_resource_zone(namelen, report_fmt, resname, name,
1508 zonename, used, pct, ZS_LIMIT_NONE, ZS_PCT_NONE);
1509 }
1510 zonestat_qsort(g_zone_list, num, sizeof (zs_zone_t *),
1511 zonestat_zone_compare_resource, res);
1512
1513 for (i = 0; i < num; i++) {
1514
1515 zone = g_zone_list[i];
1516 zs_zone_property(zone, ZS_ZONE_PROP_NAME, prop);
1517 (void) strlcpy(zonename, zs_property_string(prop),
1518 sizeof (zonename));
1519
1520 if (zonestat_match_zonename(zonename) == 0)
1521 continue;
1522
1523 used = zs_resource_used_zone_uint64(zone, res);
1524 pct = zs_resource_used_zone_pct(zone, res);
1525
1526 cap = zs_zone_limit_uint64(zone, limit);
1527 pctcap = zs_zone_limit_used_pct(zone, limit);
1528
1529 if (opt_line_zones)
1530 zonestat_print_resource_zone(namelen, report_fmt,
1531 resname, name, zonename, used, pct, cap, pctcap);
1532 }
1533 if (!opt_parseable)
1534 (void) printf("\n");
1535 }
1536
1537 static void
zonestat_print_cpu_res_header(size_t namelen)1538 zonestat_print_cpu_res_header(size_t namelen)
1539 {
1540 char name_format[ZS_NAME_STRLEN];
1541
1542 if (opt_parseable)
1543 return;
1544
1545 (void) snprintf(name_format, sizeof (name_format), "%%-%ds ", namelen);
1546 /* LINTED */
1547 (void) printf(name_format, "PROCESSOR_SET");
1548 (void) printf(ZSTAT_CPU_RES_FORMAT, "TYPE", "ONLINE/CPUS", "MIN/MAX");
1549 }
1550 static void
zonestat_print_cpu_zone_header(size_t namelen)1551 zonestat_print_cpu_zone_header(size_t namelen)
1552 {
1553 char name_format[ZS_NAME_STRLEN];
1554
1555 if (opt_parseable)
1556 return;
1557
1558 (void) snprintf(name_format, sizeof (name_format), "%%%ds ", namelen);
1559 /* LINTED */
1560 (void) printf(name_format, "ZONE");
1561
1562 (void) printf(ZSTAT_CPU_ZONE_FORMAT, "USED", "PCT", "CAP",
1563 "%CAP", "SHRS", "%SHR", "%SHRU");
1564 }
1565
1566 static void
zonestat_print_cpu_res(size_t namelen,int report_fmt,char * cputype,char * name,uint64_t online,uint64_t size,uint64_t min,uint64_t max,timestruc_t * ts)1567 zonestat_print_cpu_res(size_t namelen, int report_fmt, char *cputype,
1568 char *name, uint64_t online, uint64_t size, uint64_t min, uint64_t max,
1569 timestruc_t *ts)
1570 {
1571 char online_str[ZS_UINT64_STRLEN];
1572 char size_str[ZS_UINT64_STRLEN];
1573 char min_str[ZS_UINT64_STRLEN];
1574 char max_str[ZS_UINT64_STRLEN];
1575 char cpus_str[ZS_UINT64_STRLEN + ZS_UINT64_STRLEN + 1];
1576 char minmax_str[ZS_UINT64_STRLEN + ZS_UINT64_STRLEN + 1];
1577 char ts_str[ZS_TIME_STRLEN];
1578 char name_format[ZS_NAME_STRLEN];
1579
1580 char *label;
1581
1582 format_uint64(online, online_str, sizeof (online_str));
1583 format_uint64(size, size_str, sizeof (size_str));
1584 format_uint64(min, min_str, sizeof (min_str));
1585 format_uint64(max, max_str, sizeof (max_str));
1586 format_ts(ts, ts_str, sizeof (ts_str), B_FALSE);
1587
1588 if (opt_parseable) {
1589 if (opt_timestamp) {
1590 zonestat_print_timestamp(g_now_time);
1591 (void) printf(":");
1592 }
1593 label = zonestat_get_plabel(report_fmt);
1594
1595 (void) printf("%s:%s:%s:%s:[%s]:%s:%s:%s:%s:%s\n", label,
1596 ZONESTAT_PROCESSOR_SET, cputype, name,
1597 ZONESTAT_NAME_RESOURCE, online_str, size_str, min_str,
1598 max_str, ts_str);
1599 return;
1600 }
1601
1602 (void) snprintf(cpus_str, sizeof (cpus_str), "%s/%s", online_str,
1603 size_str);
1604 (void) snprintf(minmax_str, sizeof (minmax_str), "%s/%s", min_str,
1605 max_str);
1606
1607 (void) snprintf(name_format, sizeof (name_format), "%%-%ds ", namelen);
1608 /* LINTED */
1609 (void) printf(name_format, name);
1610 (void) printf(ZSTAT_CPU_RES_FORMAT, cputype, cpus_str, minmax_str);
1611 }
1612
1613 static void
zonestat_print_cpu_zone(size_t namelen,int report_fmt,char * cputype,char * name,char * zonename,uint64_t used,uint_t pct,uint64_t cap,uint_t pct_cap,uint64_t shares,uint_t scheds,uint_t pct_shares,uint_t pct_shares_used,timestruc_t * ts,boolean_t report_conflict)1614 zonestat_print_cpu_zone(size_t namelen, int report_fmt, char *cputype,
1615 char *name, char *zonename, uint64_t used, uint_t pct, uint64_t cap,
1616 uint_t pct_cap, uint64_t shares, uint_t scheds, uint_t pct_shares,
1617 uint_t pct_shares_used, timestruc_t *ts, boolean_t report_conflict)
1618 {
1619 char used_str[ZS_UINT64_STRLEN];
1620 char pct_str[ZS_PCT_STRLEN];
1621 char cap_str[ZS_UINT64_STRLEN];
1622 char pct_cap_str[ZS_PCT_STRLEN];
1623 char shares_str[ZS_UINT64_STRLEN];
1624 char pct_shares_str[ZS_PCT_STRLEN];
1625 char pct_shares_used_str[ZS_PCT_STRLEN];
1626 char ts_str[ZS_TIME_STRLEN];
1627 char name_format[ZS_NAME_STRLEN];
1628 char *label;
1629
1630 format_cpu(used, used_str, sizeof (used_str));
1631 format_pct(pct, pct_str, sizeof (pct_str));
1632 format_ts(ts, ts_str, sizeof (ts_str), B_FALSE);
1633
1634 if (cap == ZS_LIMIT_NONE)
1635 (void) strlcpy(cap_str, "-", sizeof (cap_str));
1636 else
1637 format_cpu(cap, cap_str, sizeof (cap_str));
1638
1639 if (pct_cap == ZS_PCT_NONE)
1640 (void) strlcpy(pct_cap_str, "-", sizeof (pct_cap_str));
1641 else
1642 format_pct(pct_cap, pct_cap_str, sizeof (pct_cap_str));
1643
1644 if ((scheds & ZS_SCHED_CONFLICT) &&
1645 (!(scheds & ZS_SCHED_FSS)))
1646 (void) strlcpy(shares_str, "no-fss", sizeof (shares_str));
1647 else if (shares == ZS_LIMIT_NONE)
1648 (void) strlcpy(shares_str, "-", sizeof (shares_str));
1649 else if (shares == ZS_SHARES_UNLIMITED)
1650 (void) strlcpy(shares_str, "inf", sizeof (shares_str));
1651 else
1652 format_uint64(shares, shares_str, sizeof (shares_str));
1653
1654 if (pct_shares == ZS_PCT_NONE)
1655 (void) strlcpy(pct_shares_str, "-", sizeof (pct_shares_str));
1656 else
1657 format_pct(pct_shares, pct_shares_str,
1658 sizeof (pct_shares_str));
1659
1660 if (pct_shares_used == ZS_PCT_NONE) {
1661 (void) strlcpy(pct_shares_used_str, "-",
1662 sizeof (pct_shares_used_str));
1663 } else {
1664 format_pct(pct_shares_used, pct_shares_used_str,
1665 sizeof (pct_shares_used_str));
1666 }
1667 if (opt_parseable) {
1668 if (opt_timestamp) {
1669 zonestat_print_timestamp(g_now_time);
1670 (void) printf(":");
1671 }
1672 label = zonestat_get_plabel(report_fmt);
1673
1674 (void) printf("%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s\n", label,
1675 ZONESTAT_PROCESSOR_SET, cputype, name, zonename, used_str,
1676 pct_str, cap_str, pct_cap_str, shares_str, pct_shares_str,
1677 pct_shares_used_str, ts_str);
1678 return;
1679 } else {
1680 (void) snprintf(name_format, sizeof (name_format), "%%%ds ",
1681 namelen);
1682 /* LINTED */
1683 (void) printf(name_format, zonename);
1684
1685 (void) printf(ZSTAT_CPU_ZONE_FORMAT, used_str,
1686 pct_str, cap_str, pct_cap_str, shares_str, pct_shares_str,
1687 pct_shares_used_str);
1688 }
1689 /* Report if zone has mix of schedulers conflicting with FSS */
1690 if (report_conflict && (scheds & ZS_SCHED_CONFLICT) &&
1691 (scheds & ZS_SCHED_FSS)) {
1692 /* LINTED */
1693 (void) printf(name_format, "");
1694 (void) printf(" mixed schedulers found:");
1695 (void) printf(" FSS");
1696 if (scheds & ZS_SCHED_TS)
1697 (void) printf(", TS");
1698 if (scheds & ZS_SCHED_IA)
1699 (void) printf(", IA");
1700 if (scheds & ZS_SCHED_FX)
1701 (void) printf(", FX");
1702 (void) printf("\n");
1703 }
1704 }
1705
1706 static void
zonestat_print_pset(int report_fmt,zs_pset_t * pset,char * cputype)1707 zonestat_print_pset(int report_fmt, zs_pset_t *pset, char *cputype)
1708 {
1709 zs_pset_zone_t *pz;
1710 zs_zone_t *zone;
1711 uint64_t cpus;
1712 uint64_t size;
1713 uint64_t min;
1714 uint64_t max;
1715 uint_t scheds;
1716 uint64_t used;
1717 uint_t pct;
1718 uint64_t cap;
1719 uint_t pct_cap;
1720 uint64_t shares;
1721 uint_t pct_shares;
1722 uint_t pct_shares_used;
1723 char psetname[ZS_PSETNAME_MAX];
1724 char zonename[ZS_PSETNAME_MAX];
1725 char *name;
1726 zs_property_t *prop;
1727 boolean_t zone_match;
1728 int num, i;
1729 timestruc_t ts;
1730 size_t namelen, len;
1731
1732 prop = (zs_property_t *)alloca(zs_property_size());
1733
1734 zs_pset_property(pset, ZS_PSET_PROP_NAME, prop);
1735 (void) strlcpy(psetname, zs_property_string(prop), sizeof (psetname));
1736
1737 /* Check if pset contains specified zone */
1738 if (arg_zonename_count > 0) {
1739 zone_match = B_FALSE;
1740 for (pz = zs_pset_zone_first(pset); pz != NULL;
1741 pz = zs_pset_zone_next(pset, pz)) {
1742 zone = zs_pset_zone_get_zone(pz);
1743 (void) zs_zone_property(zone, ZS_ZONE_PROP_NAME, prop);
1744 (void) strlcpy(zonename, zs_property_string(prop),
1745 sizeof (zonename));
1746
1747 if (zonestat_match_zonename(zonename) == 1) {
1748 zone_match = B_TRUE;
1749 break;
1750 }
1751 }
1752 if (zone_match == B_FALSE)
1753 return;
1754 }
1755
1756 if (zonestat_match_resname(psetname) == 0)
1757 return;
1758
1759 zs_pset_property(pset, ZS_PSET_PROP_ONLINE, prop);
1760 cpus = zs_property_uint64(prop);
1761 zs_pset_property(pset, ZS_PSET_PROP_SIZE, prop);
1762 size = zs_property_uint64(prop);
1763 zs_pset_property(pset, ZS_PSET_PROP_MIN, prop);
1764 min = zs_property_uint64(prop);
1765 zs_pset_property(pset, ZS_PSET_PROP_MAX, prop);
1766 max = zs_property_uint64(prop);
1767 zs_pset_total_time(pset, &ts);
1768
1769 /* Strip off SUNWtmp_ from pset name */
1770 name = psetname;
1771 if (strncmp(psetname, "SUNWtmp_", strlen("SUNWtmp_")) == 0) {
1772 name = strchr(psetname, '_');
1773 name++;
1774 }
1775
1776 /* Strip off SUNWlegacy_pst for psrset psets */
1777 if (strncmp(psetname, "SUNWlegacy_pset_",
1778 strlen("SUNWlegacy_pset_")) == 0) {
1779 name = strrchr(psetname, '_');
1780 name++;
1781 }
1782
1783 namelen = strlen(name);
1784 if (ZSTAT_CPU_MIN_PSETNAME > namelen)
1785 namelen = ZSTAT_CPU_MIN_PSETNAME;
1786
1787 zonestat_print_cpu_res_header(namelen);
1788
1789 if (opt_line_resource)
1790 zonestat_print_cpu_res(namelen, report_fmt, cputype, name, cpus,
1791 size, min, max, &ts);
1792
1793 again:
1794 num = zs_pset_zone_list(pset, g_pz_list, g_pz_num);
1795 if (num > g_pz_num) {
1796 if (g_pz_list != NULL)
1797 free(g_pz_list);
1798 g_pz_list = (zs_pset_zone_t **)malloc(
1799 sizeof (zs_pset_zone_t *) * num);
1800 g_pz_num = num;
1801 goto again;
1802 }
1803
1804 /* Find longest zone name in pset */
1805 namelen = ZSTAT_CPU_MIN_ZONENAME;
1806 for (i = 0; i < num; i++) {
1807 pz = g_pz_list[i];
1808 zone = zs_pset_zone_get_zone(pz);
1809 zs_zone_property(zone, ZS_ZONE_PROP_NAME, prop);
1810 len = strlen(zs_property_string(prop));
1811 if (len > namelen)
1812 namelen = len;
1813 }
1814
1815 qsort(g_pz_list, num, sizeof (zs_pset_zone_t *),
1816 zonestat_pz_compare_usage);
1817
1818 zonestat_print_cpu_zone_header(namelen);
1819
1820 zs_pset_property(pset, ZS_PSET_PROP_CPU_SHARES, prop);
1821 shares = zs_property_uint64(prop);
1822 zs_pset_property(pset, ZS_PSET_PROP_SCHEDULERS, prop);
1823 scheds = zs_property_uint(prop);
1824
1825 zs_pset_used_time(pset, ZS_USER_ALL, &ts);
1826 used = zs_pset_used_cpus(pset, ZS_USER_ALL);
1827 pct = zs_pset_used_pct(pset, ZS_USER_ALL);
1828
1829 if (opt_line_total) {
1830 (void) snprintf(zonename, sizeof (zonename), "[%s]",
1831 ZONESTAT_NAME_TOTAL);
1832 zonestat_print_cpu_zone(namelen, report_fmt, cputype, name,
1833 zonename, used, pct, ZS_LIMIT_NONE, ZS_PCT_NONE, shares,
1834 scheds, ZS_PCT_NONE, ZS_PCT_NONE, &ts, B_FALSE);
1835 }
1836 zs_pset_used_time(pset, ZS_USER_KERNEL, &ts);
1837 used = zs_pset_used_cpus(pset, ZS_USER_KERNEL);
1838 pct = zs_pset_used_pct(pset, ZS_USER_KERNEL);
1839
1840 if (opt_line_system) {
1841 (void) snprintf(zonename, sizeof (zonename), "[%s]",
1842 ZONESTAT_NAME_SYSTEM);
1843 zonestat_print_cpu_zone(namelen, report_fmt, cputype, name,
1844 zonename, used, pct, ZS_LIMIT_NONE, ZS_PCT_NONE,
1845 ZS_LIMIT_NONE, 0, ZS_PCT_NONE, ZS_PCT_NONE, &ts, B_FALSE);
1846 }
1847 for (i = 0; i < num; i++) {
1848
1849 pz = g_pz_list[i];
1850 zone = zs_pset_zone_get_zone(pz);
1851 zs_zone_property(zone, ZS_ZONE_PROP_NAME, prop);
1852 (void) strlcpy(zonename, zs_property_string(prop),
1853 sizeof (zonename));
1854
1855 if (zonestat_match_zonename(zonename) == 0)
1856 continue;
1857
1858 zs_pset_zone_property(pz, ZS_PZ_PROP_CPU_CAP, prop);
1859 cap = zs_property_uint64(prop);
1860
1861 zs_pset_zone_property(pz, ZS_PZ_PROP_CPU_SHARES, prop);
1862 shares = zs_property_uint64(prop);
1863 zs_pset_zone_property(pz, ZS_PZ_PROP_SCHEDULERS, prop);
1864 scheds = zs_property_uint(prop);
1865
1866 used = zs_pset_zone_used_cpus(pz);
1867 zs_pset_zone_used_time(pz, &ts);
1868 pct = zs_pset_zone_used_pct(pz, ZS_PZ_PCT_PSET);
1869 pct_cap = zs_pset_zone_used_pct(pz, ZS_PZ_PCT_CPU_CAP);
1870 pct_shares = zs_pset_zone_used_pct(pz, ZS_PZ_PCT_PSET_SHARES);
1871 pct_shares_used = zs_pset_zone_used_pct(pz,
1872 ZS_PZ_PCT_CPU_SHARES);
1873
1874 if (opt_line_zones)
1875 zonestat_print_cpu_zone(namelen, report_fmt, cputype,
1876 name, zonename, used, pct, cap, pct_cap, shares,
1877 scheds, pct_shares, pct_shares_used, &ts, B_TRUE);
1878 }
1879 if (!opt_parseable)
1880 (void) printf("\n");
1881 }
1882
1883 /* ARGSUSED */
1884 static void
zonestat_quithandler(int sig)1885 zonestat_quithandler(int sig)
1886 {
1887 g_quit = B_TRUE;
1888 }
1889
1890 static void
zonestat_print_footer(int report_fmt)1891 zonestat_print_footer(int report_fmt)
1892 {
1893 char *label;
1894
1895 if (!opt_parseable)
1896 return;
1897
1898 if (opt_timestamp) {
1899 zonestat_print_timestamp(g_now_time);
1900 (void) printf(":");
1901 }
1902 label = zonestat_get_plabel(report_fmt);
1903 (void) printf("%s:%s:", label, ZONESTAT_NAME_FOOTER);
1904 zonestat_print_timestamp(g_now_time);
1905 (void) printf("%d:%ld\n", g_interval, g_seconds);
1906 (void) fflush(stdout);
1907 }
1908
1909 static void
zonestat_print_header(int report_fmt)1910 zonestat_print_header(int report_fmt)
1911 {
1912 char *label;
1913 timestruc_t ts;
1914 char string[ZS_TIME_STRLEN];
1915
1916 if (!opt_parseable) {
1917
1918 /* Human readable header */
1919 if (opt_timestamp) {
1920 zonestat_print_timestamp(g_now_time);
1921 (void) printf(", ");
1922 }
1923 if (report_fmt == ZSTAT_REPORT_FMT_INTERVAL) {
1924 ts.tv_sec = g_seconds;
1925 ts.tv_nsec = 0;
1926 format_ts(&ts, string, sizeof (string), B_TRUE);
1927 (void) printf("Interval: %d, Duration: %s\n", g_count,
1928 string);
1929 (void) fflush(stdout);
1930 return;
1931 } else {
1932 switch (report_fmt) {
1933 case ZSTAT_REPORT_FMT_TOTAL:
1934 label = "Report: Total Usage";
1935 break;
1936 case ZSTAT_REPORT_FMT_AVERAGE:
1937 label = "Report: Average Usage";
1938 break;
1939 case ZSTAT_REPORT_FMT_HIGH:
1940 label = "Report: High Usage";
1941 break;
1942 default:
1943 exit(zonestat_error(gettext(
1944 "Internal error, invalid header")));
1945 }
1946 /* Left are the report header formats */
1947 (void) printf("%s\n", label);
1948 (void) printf(" Start: ");
1949 zonestat_print_timestamp(g_start_time);
1950 (void) printf("\n End: ");
1951 zonestat_print_timestamp(g_end_time);
1952 (void) printf("\n");
1953 ts.tv_sec = g_seconds;
1954 ts.tv_nsec = 0;
1955 format_ts(&ts, string, sizeof (string), B_TRUE);
1956 (void) printf(" Intervals: %d, Duration: %s\n",
1957 g_count, string);
1958
1959 (void) fflush(stdout);
1960 return;
1961 }
1962 }
1963
1964 if (!opt_line_header)
1965 return;
1966
1967 /* Parseable header */
1968 if (opt_timestamp) {
1969 zonestat_print_timestamp(g_now_time);
1970 (void) printf(":");
1971 }
1972 label = zonestat_get_plabel(report_fmt);
1973
1974 (void) printf("%s:%s:", label, ZONESTAT_NAME_HEADER);
1975 if (report_fmt == ZSTAT_REPORT_FMT_INTERVAL) {
1976 (void) printf("since-last-interval:");
1977 zonestat_print_timestamp(g_now_time);
1978 (void) printf(":%d:%ld\n", g_count, g_seconds);
1979 (void) fflush(stdout);
1980 return;
1981 }
1982
1983 /* Left are the report header formats */
1984 zonestat_print_timestamp(g_start_time);
1985 (void) printf(":");
1986 zonestat_print_timestamp(g_end_time);
1987 (void) printf(":");
1988 (void) printf("%d:%ld\n", g_interval, g_seconds);
1989 (void) fflush(stdout);
1990 }
1991
1992 static void
zonestat_print_psets(int report_fmt,zs_usage_t * u)1993 zonestat_print_psets(int report_fmt, zs_usage_t *u)
1994 {
1995 zs_pset_t *pset;
1996 char *psettype;
1997 uint_t cputype, num, i;
1998 zs_property_t *p;
1999
2000 again:
2001 num = zs_pset_list(u, g_pset_list, g_pset_num);
2002 if (num > g_pset_num) {
2003 if (g_pset_list != NULL)
2004 free(g_pset_list);
2005 g_pset_list = (zs_pset_t **)malloc(
2006 sizeof (zs_pset_t *) * num);
2007 g_pset_num = num;
2008 goto again;
2009 }
2010
2011 /* Sort, default pset first, then pool, psrset, and dedicated psets */
2012 qsort(g_pset_list, num, sizeof (zs_pset_t *), zonestat_pset_compare);
2013
2014 p = (zs_property_t *)alloca(zs_property_size());
2015 for (i = 0; i < num; i++) {
2016 pset = g_pset_list[i];
2017 (void) zs_pset_property(pset, ZS_PSET_PROP_CPUTYPE, p);
2018 cputype = zs_property_uint(p);
2019 if (cputype == ZS_CPUTYPE_DEFAULT_PSET &&
2020 (g_resources & (ZSTAT_RES_PSETS |
2021 ZSTAT_RES_DEFAULT_PSET))) {
2022 psettype = ZONESTAT_DEFAULT_PSET;
2023 } else if (cputype == ZS_CPUTYPE_POOL_PSET &&
2024 (g_resources & ZSTAT_RES_PSETS)) {
2025 psettype = ZONESTAT_POOL_PSET;
2026 } else if (cputype == ZS_CPUTYPE_PSRSET_PSET &&
2027 (g_resources & ZSTAT_RES_PSETS)) {
2028 psettype = ZONESTAT_PSRSET_PSET;
2029 } else if (cputype == ZS_CPUTYPE_DEDICATED &&
2030 (g_resources & ZSTAT_RES_PSETS)) {
2031 psettype = ZONESTAT_DEDICATED_CPU;
2032 } else {
2033 continue;
2034 }
2035 zonestat_print_pset(report_fmt, pset, psettype);
2036 }
2037 }
2038
2039 static void
zonestat_print_resources(int report_fmt,zs_usage_t * usage)2040 zonestat_print_resources(int report_fmt, zs_usage_t *usage)
2041 {
2042 if (g_resources & ZSTAT_RES_SUMMARY)
2043 zonestat_print_summary(report_fmt, usage);
2044
2045 if (g_resources & ZSTAT_RES_PHYSICAL_MEMORY)
2046 zonestat_print_res(report_fmt, "PHYSICAL-MEMORY",
2047 "SYSTEM MEMORY", ZONESTAT_PHYSICAL_MEMORY,
2048 ZONESTAT_NAME_MEM_DEFAULT, usage,
2049 ZS_RESOURCE_RAM_RSS, ZS_LIMIT_RAM_RSS);
2050 if (g_resources & ZSTAT_RES_VIRTUAL_MEMORY)
2051 zonestat_print_res(report_fmt, "VIRTUAL-MEMORY",
2052 "SYSTEM MEMORY", ZONESTAT_VIRTUAL_MEMORY,
2053 ZONESTAT_NAME_VM_DEFAULT, usage,
2054 ZS_RESOURCE_VM, ZS_LIMIT_VM);
2055 if (g_resources & ZSTAT_RES_LOCKED_MEMORY)
2056 zonestat_print_res(report_fmt, "LOCKED-MEMORY", "SYSTEM MEMORY",
2057 ZONESTAT_LOCKED_MEMORY, ZONESTAT_NAME_MEM_DEFAULT, usage,
2058 ZS_RESOURCE_RAM_LOCKED, ZS_LIMIT_RAM_LOCKED);
2059
2060 if (g_resources & (ZSTAT_RES_PSETS | ZSTAT_RES_DEFAULT_PSET))
2061 zonestat_print_psets(report_fmt, usage);
2062
2063 if (g_resources & ZSTAT_RES_PROCESSES)
2064 zonestat_print_res(report_fmt, "PROCESSES", "SYSTEM LIMIT",
2065 ZONESTAT_PROCESSES, ZONESTAT_NAME_SYSTEM_LIMIT,
2066 usage, ZS_RESOURCE_PROCESSES, ZS_LIMIT_PROCESSES);
2067
2068 if (g_resources & ZSTAT_RES_LWPS)
2069 zonestat_print_res(report_fmt, "LWPS", "SYSTEM LIMIT",
2070 ZONESTAT_LWPS, ZONESTAT_NAME_SYSTEM_LIMIT, usage,
2071 ZS_RESOURCE_LWPS, ZS_LIMIT_LWPS);
2072 if (g_resources & ZSTAT_RES_LOFI)
2073 zonestat_print_res(report_fmt, "LOFI", "SYSTEM LIMIT",
2074 ZONESTAT_LOFI, ZONESTAT_NAME_SYSTEM_LIMIT,
2075 usage, ZS_RESOURCE_LOFI, ZS_LIMIT_LOFI);
2076
2077 if (g_resources & ZSTAT_RES_SHM_MEMORY)
2078 zonestat_print_res(report_fmt, "SHM_MEMORY", "SYSTEM LIMIT",
2079 ZONESTAT_SHM_MEMORY, ZONESTAT_NAME_SYSTEM_LIMIT,
2080 usage, ZS_RESOURCE_SHM_MEMORY, ZS_LIMIT_SHM_MEMORY);
2081
2082 if (g_resources & ZSTAT_RES_SHM_IDS)
2083 zonestat_print_res(report_fmt, "SHM_IDS", "SYSTEM LIMIT",
2084 ZONESTAT_SHM_IDS, ZONESTAT_NAME_SYSTEM_LIMIT,
2085 usage, ZS_RESOURCE_SHM_IDS, ZS_LIMIT_SHM_IDS);
2086
2087 if (g_resources & ZSTAT_RES_SEM_IDS)
2088 zonestat_print_res(report_fmt, "SEM_IDS", "SYSTEM LIMIT",
2089 ZONESTAT_SEM_IDS, ZONESTAT_NAME_SYSTEM_LIMIT,
2090 usage, ZS_RESOURCE_SEM_IDS, ZS_LIMIT_SEM_IDS);
2091
2092 if (g_resources & ZSTAT_RES_MSG_IDS)
2093 zonestat_print_res(report_fmt, "MSG_IDS", "SYSTEM LIMIT",
2094 ZONESTAT_MSG_IDS, ZONESTAT_NAME_SYSTEM_LIMIT,
2095 usage, ZS_RESOURCE_MSG_IDS, ZS_LIMIT_MSG_IDS);
2096 }
2097
2098 /*
2099 * Adds comma seperated list of names to array of names
2100 * Returns new total number of names.
2101 */
2102 static size_t
zonestat_parse_names(char * names,char *** namelist,size_t count)2103 zonestat_parse_names(char *names, char ***namelist, size_t count)
2104 {
2105 size_t num, i;
2106 char *next, *string;
2107
2108 string = strdup(names);
2109 if (string == NULL)
2110 exit(zonestat_error(gettext("Out of Memory")));
2111
2112 /* count names, delimiting with '\0'. */
2113 next = string;
2114 num = 1;
2115 while ((next = strchr(next, ',')) != NULL) {
2116 *next++ = '\0';
2117 num++;
2118 }
2119
2120 /* Resise names array */
2121 *namelist = realloc(*namelist, sizeof (char *) * (num + count));
2122 if (*namelist == NULL)
2123 exit(zonestat_error(gettext("Out of Memory")));
2124
2125 /* add names to names array */
2126 next = string;
2127 for (i = 0; i < num; i++) {
2128 (*namelist)[count + i] = next;
2129 next += strlen(next) + 1;
2130 }
2131 return (count + num);
2132 }
2133
2134 static int
zonestat_extract_int(char * start,char * end,char ** tail)2135 zonestat_extract_int(char *start, char *end, char **tail)
2136 {
2137 int val;
2138 int save;
2139
2140 save = *end;
2141 *end = '\0';
2142 errno = 0;
2143 val = strtol(start, tail, 0);
2144 *end = save;
2145 if (errno != 0 || *tail == start)
2146 return (-1);
2147
2148 return (val);
2149 }
2150
2151 /*
2152 * parses and [nh][nm][hs] notation into seconds
2153 */
2154 static int
zonestat_parse_time(char * string,boolean_t * formatted)2155 zonestat_parse_time(char *string, boolean_t *formatted)
2156 {
2157 int seconds = 0;
2158 int minutes = 0;
2159 int hours = 0;
2160 char *this, *next, *end;
2161
2162 *formatted = B_FALSE;
2163
2164 /* Look for special tokens */
2165 if (strcmp("default", string) == 0)
2166 return (ZSTAT_INTERVAL_DEFAULT);
2167
2168 if (strcmp("inf", string) == 0)
2169 return (ZSTAT_DURATION_INF);
2170
2171 /* Look for hours */
2172 this = string;
2173 next = strchr(this, 'h');
2174 if (next != NULL) {
2175 if ((hours = zonestat_extract_int(this, next, &end)) == -1)
2176 return (-1);
2177
2178 *formatted = B_TRUE;
2179 this = next + 1;
2180 end++;
2181 }
2182
2183 /* Look for minutes delimiter */
2184 next = strrchr(this, 'm');
2185 if (next != NULL) {
2186 if ((minutes = zonestat_extract_int(this, next, &end)) == -1)
2187 return (-1);
2188
2189 *formatted = B_TRUE;
2190 this = next + 1;
2191 end++;
2192 }
2193
2194 /* Look for seconds delimiter */
2195 next = strrchr(this, 's');
2196 if (next != NULL) {
2197 if ((seconds = zonestat_extract_int(this, next, &end)) == -1)
2198 return (-1);
2199
2200 *formatted = B_TRUE;
2201 this = next + 1;
2202 end++;
2203 }
2204
2205 /* No delimiter found. Treat as seconds */
2206 if (*formatted == B_FALSE) {
2207 errno = 0;
2208 seconds = strtol(this, &end, 0);
2209 if (errno != 0 || end == this)
2210 return (-1);
2211 }
2212
2213 if (*end != '\0')
2214 return (-1);
2215
2216 seconds += (minutes * 60);
2217 seconds += (hours * 60 * 60);
2218
2219 return (seconds);
2220 }
2221
2222 static void
zonestat_print_reports(zs_usage_set_t * set)2223 zonestat_print_reports(zs_usage_set_t *set)
2224 {
2225 zs_usage_t *usage_print;
2226
2227 if (opt_report_total == B_TRUE) {
2228 usage_print = zs_usage_set_compute(set,
2229 ZS_COMPUTE_SET_TOTAL);
2230 zonestat_print_header(ZSTAT_REPORT_FMT_TOTAL);
2231 zonestat_print_resources(ZSTAT_REPORT_FMT_TOTAL, usage_print);
2232 zonestat_print_footer(ZSTAT_REPORT_FMT_TOTAL);
2233 (void) fflush(stdout);
2234 }
2235 if (opt_report_average == B_TRUE) {
2236 usage_print = zs_usage_set_compute(set,
2237 ZS_COMPUTE_SET_AVERAGE);
2238 zonestat_print_header(ZSTAT_REPORT_FMT_AVERAGE);
2239 zonestat_print_resources(ZSTAT_REPORT_FMT_AVERAGE, usage_print);
2240 zonestat_print_footer(ZSTAT_REPORT_FMT_AVERAGE);
2241 (void) fflush(stdout);
2242 }
2243 if (opt_report_high == B_TRUE) {
2244 usage_print = zs_usage_set_compute(set,
2245 ZS_COMPUTE_SET_HIGH);
2246 zonestat_print_header(ZSTAT_REPORT_FMT_HIGH);
2247 zonestat_print_resources(ZSTAT_REPORT_FMT_HIGH, usage_print);
2248 zonestat_print_footer(ZSTAT_REPORT_FMT_HIGH);
2249 (void) fflush(stdout);
2250 }
2251 }
2252
2253 static void
zonestat_set_fx()2254 zonestat_set_fx()
2255 {
2256 pcinfo_t pcinfo;
2257 pcparms_t pcparms;
2258
2259 (void) strlcpy(pcinfo.pc_clname, "FX", sizeof (pcinfo.pc_clname));
2260 if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) {
2261 return;
2262 }
2263 pcparms.pc_cid = pcinfo.pc_cid;
2264 ((fxparms_t *)pcparms.pc_clparms)->fx_upri = 60;
2265 ((fxparms_t *)pcparms.pc_clparms)->fx_uprilim = 60;
2266 ((fxparms_t *)pcparms.pc_clparms)->fx_tqsecs = 0;
2267 ((fxparms_t *)pcparms.pc_clparms)->fx_tqnsecs = FX_NOCHANGE;
2268 (void) priocntl(P_PID, getpid(), PC_SETPARMS, (caddr_t)&pcparms);
2269 }
2270
2271 static time_t
zonestat_time()2272 zonestat_time()
2273 {
2274 time_t t;
2275
2276 t = time(NULL);
2277 if (t < 0 && g_quit == B_FALSE)
2278 exit(zonestat_error(gettext(
2279 "Unable to fetch current time")));
2280
2281 return (t);
2282 }
2283
2284 int
main(int argc,char * argv[])2285 main(int argc, char *argv[])
2286 {
2287 int arg;
2288 time_t now, next, start, next_report;
2289 zs_usage_t *usage, *usage_last = NULL, *usage_print;
2290 zs_usage_set_t *set;
2291 boolean_t formatted;
2292 scf_simple_prop_t *prop;
2293 uint64_t *intervalp;
2294 char *not_responding;
2295
2296 /* Process command line options and args */
2297 while ((arg = getopt(argc, argv, "z:r:n:T:R:qpP:S:D?"))
2298 != EOF) {
2299 switch (arg) {
2300 case 'z':
2301 opt_zonenames = B_TRUE;
2302 arg_zonename_count = zonestat_parse_names(optarg,
2303 &arg_zonenames, arg_zonename_count);
2304 break;
2305 case 'r':
2306 arg_restype_count = zonestat_parse_names(optarg,
2307 &arg_restypes, arg_restype_count);
2308 opt_restypes = B_TRUE;
2309 break;
2310 case 'n':
2311 opt_resnames = B_TRUE;
2312 arg_resname_count = zonestat_parse_names(optarg,
2313 &arg_resnames, arg_resname_count);
2314 break;
2315 case 'R':
2316 opt_report = B_TRUE;
2317 arg_report_count = zonestat_parse_names(optarg,
2318 &arg_reports, arg_report_count);
2319 break;
2320 case 'S':
2321 opt_sort = B_TRUE;
2322 arg_sort_count = zonestat_parse_names(optarg,
2323 &arg_sort_list, arg_sort_count);
2324 break;
2325 case 'T':
2326 opt_timestamp = B_TRUE;
2327 if (strcmp(optarg, "u") == 0) {
2328 arg_timestamp = ZSTAT_UNIX_TIMESTAMP;
2329 } else if (strcmp(optarg, "d") == 0) {
2330 arg_timestamp = ZSTAT_DATE_TIMESTAMP;
2331 } else if (strcmp(optarg, "i") == 0) {
2332 arg_timestamp = ZSTAT_ISO_TIMESTAMP;
2333 } else {
2334 (void) zonestat_error(gettext(
2335 "Invalid -T arg \"%s\". "
2336 "Must be 'u', 'i', or 'd'."), optarg);
2337 return (zonestat_usage(B_FALSE));
2338 }
2339 break;
2340 case 'q':
2341 opt_quiet_intervals = B_TRUE;
2342 break;
2343 case 'p':
2344 opt_parseable = B_TRUE;
2345 break;
2346 case 'P':
2347 opt_line_any = B_TRUE;
2348 arg_line_count = zonestat_parse_names(optarg,
2349 &arg_line_list, arg_line_count);
2350 break;
2351 case 'D':
2352 opt_debug = B_TRUE;
2353 break;
2354 case '?':
2355 return (zonestat_usage(B_TRUE));
2356 default:
2357 return (zonestat_usage(B_FALSE));
2358 }
2359 }
2360
2361 if (opt_line_any && (!opt_parseable)) {
2362 (void) zonestat_error(gettext("-P requires -p"));
2363 return (zonestat_usage(B_FALSE));
2364 }
2365
2366 if (opt_timestamp && arg_timestamp == ZSTAT_DATE_TIMESTAMP &&
2367 opt_parseable) {
2368 (void) zonestat_error(gettext(
2369 "-T d invalid with -p. Use -T [u | i]"));
2370 return (zonestat_usage(B_FALSE));
2371
2372 }
2373 /* Default to ISO timetamp in parseable output */
2374 if (!opt_timestamp && opt_parseable)
2375 arg_timestamp = ZSTAT_ISO_TIMESTAMP;
2376
2377 /* Get the interval and count */
2378 optind++;
2379 if (argc >= optind) {
2380 if ((arg_interval = zonestat_parse_time(argv[optind - 1],
2381 &formatted)) < 0 || arg_interval == 0) {
2382 (void) zonestat_error(gettext(
2383 "Invalid interval: \"%s\""), argv[optind - 1]);
2384 return (zonestat_usage(B_FALSE));
2385 }
2386 } else {
2387 (void) zonestat_error(gettext("Interval required."));
2388 return (zonestat_usage(B_FALSE));
2389 }
2390
2391 if (arg_interval == ZSTAT_INTERVAL_DEFAULT) {
2392 /* Get the configured sample interval */
2393 prop = scf_simple_prop_get(NULL,
2394 "svc:/system/zones-monitoring:default", "config",
2395 "sample_interval");
2396
2397 if (prop == NULL) {
2398 return (zonestat_error(gettext(
2399 "Unable to fetch SMF property "
2400 "\"config/sample_interval\"")));
2401 }
2402 if (scf_simple_prop_type(prop) != SCF_TYPE_COUNT) {
2403 return (zonestat_error(gettext("Malformed SMF property "
2404 "\"config/sample_interval\". Must be of type "
2405 "\"count\"")));
2406 }
2407 intervalp = scf_simple_prop_next_count(prop);
2408 arg_interval = *intervalp;
2409 if (arg_interval == 0)
2410 return (zonestat_error(gettext("Malformed SMF property "
2411 "\"config/sample_interval\". Must be greater than"
2412 "zero")));
2413
2414 scf_simple_prop_free(prop);
2415 }
2416 optind++;
2417 if (argc >= optind) {
2418 if ((arg_duration = zonestat_parse_time(argv[optind - 1],
2419 &formatted)) < 0 || arg_duration == 0) {
2420 (void) zonestat_error(gettext(
2421 "Invalid duration: \"%s\""), argv[optind - 1]);
2422 return (zonestat_usage(B_FALSE));
2423 }
2424 /* If not formatted [nh][nm][ns], treat as count */
2425 if (arg_duration != ZSTAT_DURATION_INF &&
2426 formatted == B_FALSE)
2427 arg_duration *= arg_interval;
2428 } else {
2429 arg_duration = ZSTAT_DURATION_INF;
2430 }
2431 optind++;
2432 if (argc >= optind) {
2433 if ((arg_report = zonestat_parse_time(argv[optind - 1],
2434 &formatted)) < 0 || arg_report == 0) {
2435 (void) zonestat_error(gettext(
2436 "Invalid report period: \"%s\""), argv[optind - 1]);
2437 return (zonestat_usage(B_FALSE));
2438 }
2439 /* If not formatted as [nh][nm][ns] treat as count */
2440 if (formatted == B_FALSE)
2441 arg_report *= arg_interval;
2442 } else {
2443 arg_report = ZSTAT_REPORT_END;
2444 }
2445
2446 if (opt_quiet_intervals && (!opt_report)) {
2447 (void) zonestat_error(gettext("-q requires -R"));
2448 return (zonestat_usage(B_FALSE));
2449 }
2450
2451 /* Figure out what resources to report on */
2452 zonestat_determine_resources();
2453 zonestat_determine_reports();
2454 zonestat_determine_lines();
2455 zonestat_determine_sort();
2456
2457 /* Done parsing args beyond this point */
2458
2459 (void) signal(SIGINT, zonestat_quithandler);
2460 (void) signal(SIGTERM, zonestat_quithandler);
2461 (void) signal(SIGHUP, zonestat_quithandler);
2462
2463 /* Run at high priority to keep up with busy system */
2464 zonestat_set_fx();
2465
2466 not_responding = gettext(
2467 "Zones monitoring service \"svc:/system/zones-monitoring:default\" "
2468 "not enabled or responding.");
2469
2470 /* Open zone statistics */
2471 g_zsctl = zs_open();
2472 if (g_zsctl == NULL) {
2473 if (errno == EPERM)
2474 return (zonestat_error(gettext("Permission denied")));
2475 if (errno == EINTR || errno == ESRCH) {
2476 (void) zonestat_error(not_responding);
2477 return (3);
2478 }
2479 if (errno == ENOTSUP)
2480 return (zonestat_error(gettext(
2481 "Mismatched zonestat version. "
2482 "Re-install system/zones package.")));
2483
2484 return (zonestat_error(gettext(
2485 "Unexpected error. Unable to open zone statistics.")));
2486 }
2487 usage_last = zs_usage_read(g_zsctl);
2488 if (usage_last == NULL) {
2489 if (errno == EINTR && g_quit == B_TRUE)
2490 return (0);
2491 (void) zonestat_error(not_responding);
2492 return (3);
2493 }
2494 set = zs_usage_set_alloc(g_zsctl);
2495
2496 g_start_time = g_now_time = start = now = zonestat_time();
2497 g_interval = arg_interval;
2498 g_report_count = g_count = g_seconds = 0;
2499
2500 if (opt_quiet_intervals == B_FALSE && opt_parseable == B_FALSE)
2501 (void) printf(gettext(
2502 "Collecting data for first interval...\n"));
2503
2504 for (;;) {
2505 time_t tosleep;
2506
2507 g_now_time = now = zonestat_time();
2508
2509 if (arg_report != ZSTAT_REPORT_END)
2510 next_report = start + ((g_report_count + 1) *
2511 arg_report);
2512
2513 /*
2514 * Sleep till next interval.
2515 */
2516 g_count++;
2517 next = g_start_time + (g_count) * g_interval;
2518 /*
2519 * Skip to next interval if due to busy system, zonestat did
2520 * not complete in time.
2521 */
2522 while (now >= g_start_time + ((g_count + 1) * g_interval))
2523 g_count++;
2524
2525 while (now < next) {
2526 /* Sleep until at next interval */
2527 tosleep = next - now;
2528 (void) sleep(tosleep);
2529 now = zonestat_time();
2530 if (g_quit == B_TRUE)
2531 goto interval_loop_done;
2532 }
2533
2534 g_seconds = now - start;
2535 g_now_time = now;
2536 if ((usage = zs_usage_read(g_zsctl)) == NULL) {
2537 if (errno == EINTR && g_quit == B_TRUE)
2538 break;
2539 (void) zonestat_error(not_responding);
2540 return (3);
2541 }
2542
2543 /* Compute cpu used since last interval */
2544 usage_print = zs_usage_compute(NULL, usage_last,
2545 usage, ZS_COMPUTE_USAGE_INTERVAL);
2546 if (usage_print == NULL)
2547 (void) zonestat_error(gettext("Out of Memory"));
2548
2549
2550 if (opt_quiet_intervals == B_TRUE)
2551 goto interval_print_end;
2552
2553 zonestat_print_header(ZSTAT_REPORT_FMT_INTERVAL);
2554 zonestat_print_resources(ZSTAT_REPORT_FMT_INTERVAL,
2555 usage_print);
2556 zonestat_print_footer(ZSTAT_REPORT_FMT_INTERVAL);
2557 (void) fflush(stdout);
2558
2559 interval_print_end:
2560 (void) zs_usage_set_add(set, usage_print);
2561
2562
2563 /* Print reports if they are due */
2564 if (opt_report && arg_report != ZSTAT_REPORT_END &&
2565 now >= next_report) {
2566 g_end_time = now;
2567 zonestat_print_reports(set);
2568 zs_usage_set_free(set);
2569 set = zs_usage_set_alloc();
2570 g_start_time = now;
2571 g_report_count++;
2572 }
2573 zs_usage_free(usage_last);
2574 usage_last = usage;
2575 if (arg_duration != ZSTAT_DURATION_INF &&
2576 g_seconds >= arg_duration)
2577 break;
2578 }
2579 interval_loop_done:
2580
2581 /* Print last reports if due */
2582 g_end_time = g_now_time;
2583 if (opt_report && zs_usage_set_count(set) > 0 &&
2584 (arg_report == ZSTAT_REPORT_END || now < next_report))
2585 zonestat_print_reports(set);
2586
2587 zs_usage_set_free(set);
2588 if (usage_last != NULL)
2589 zs_usage_free(usage_last);
2590
2591 if (g_zsctl != NULL)
2592 zs_close(g_zsctl);
2593
2594 return (0);
2595 }
2596