xref: /titanic_41/usr/src/cmd/busstat/busstat.c (revision 7c478bd95313f5f23a4c958a745db2134aa03244)
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, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <strings.h>
32 #include <time.h>
33 #include <signal.h>
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <sys/time.h>
37 #include <sys/modctl.h>
38 #include <sys/systeminfo.h>
39 #include <limits.h>
40 #include <signal.h>
41 #include <fcntl.h>
42 #include <unistd.h>
43 #include <stropts.h>
44 #include <locale.h>
45 #include <libintl.h>
46 #include <libgen.h>
47 #include <nl_types.h>
48 #include <kstat.h>
49 #include <ctype.h>
50 #include <signal.h>
51 #include <errno.h>
52 #include <time.h>
53 
54 #include "busstat.h"
55 
56 
57 /* Global defines */
58 static int		delta = TRUE;
59 static int		banner = TRUE;
60 static int		max_pic_num = 1;
61 static int		initial_read = TRUE;
62 static char		*pgmname;
63 static kstat_ctl_t	*kc;			/* libkstat cookie */
64 static dev_node_t	*dev_list_head	= NULL;
65 static dev_node_t	*dev_list_tail	= NULL;
66 
67 /*
68  * Global flags.
69  */
70 static char	curr_dev_name[KSTAT_STRLEN];
71 static int	curr_inst_num;
72 
73 static void print_evt(void);
74 static void print_dev(int, char *);
75 static void parse_cmd(int);
76 static void parse_dev_inst(char *);
77 static void parse_pic_evt(char *);
78 static void add_dev_node(char *, int);
79 static void add_all_dev_node(char *);
80 static void add_evt_node(dev_node_t *);
81 static void modify_evt_node(dev_node_t *, char *);
82 static void prune_evt_nodes(dev_node_t *);
83 static void setup_evts(void);
84 static void set_evt(dev_node_t *);
85 static void read_evts(void);
86 static void read_r_evt_node(dev_node_t *, int, kstat_named_t *);
87 static void read_w_evt_node(dev_node_t *, int, kstat_named_t *);
88 static void check_dr_ops(void);
89 static void remove_dev_node(dev_node_t *);
90 static dev_node_t *find_dev_node(char *, int, int);
91 static kstat_t *find_pic_kstat(char *, int, char *);
92 static int64_t is_num(char *);
93 static void print_banner(void);
94 static void print_timestamp(void);
95 static void usage(void);
96 static void *safe_malloc(size_t);
97 static void set_timer(int);
98 static void handle_sig(int);
99 static int strisnum(const char *);
100 
101 int
main(int argc,char ** argv)102 main(int argc, char **argv)
103 {
104 	int		c, i;
105 	int		interval = 1;	/* Interval between displays */
106 	int		count = 0;	/* Number of times to sample */
107 	int		write_evts = FALSE;
108 	int		pos = 0;
109 
110 #if !defined(TEXT_DOMAIN)
111 #define	TEXT_DOMAIN	"SYS_TEST"
112 #endif
113 
114 	/* For I18N */
115 	(void) setlocale(LC_ALL, "");
116 	(void) textdomain(TEXT_DOMAIN);
117 
118 	pgmname = basename(argv[0]);
119 
120 	if ((kc = kstat_open()) == NULL) {
121 		(void) fprintf(stderr, gettext("%s: could not "
122 			"open /dev/kstat\n"), pgmname);
123 		exit(1);
124 	}
125 
126 	while ((c = getopt(argc, argv, "e:w:r:ahln")) != EOF) {
127 		switch (c) {
128 		case 'a':
129 			delta = FALSE;
130 			break;
131 		case 'e':
132 			(void) print_evt();
133 			break;
134 		case 'h':
135 			usage();
136 			break;
137 		case 'l':
138 			(void) print_dev(argc, argv[argc-1]);
139 			break;
140 		case 'n':
141 			banner = FALSE;
142 			break;
143 		case 'r':
144 			(void) parse_cmd(READ_EVT);
145 			break;
146 		case 'w':
147 			(void) parse_cmd(WRITE_EVT);
148 			write_evts = TRUE;
149 			break;
150 		default:
151 			(void) fprintf(stderr, gettext("%s: invalid "
152 				"option\n"), pgmname);
153 			usage();
154 			break;
155 		}
156 	}
157 
158 	if ((argc == 1) || (dev_list_head == NULL))
159 		usage();
160 
161 	/*
162 	 * validate remaining operands are numeric.
163 	 */
164 	pos = optind;
165 	while (pos < argc) {
166 		if (strisnum(argv[pos]) == 0) {
167 			(void) fprintf(stderr,
168 				gettext("%s: syntax error\n"),
169 				pgmname);
170 			usage();
171 		}
172 		pos++;
173 	}
174 
175 	if (optind < argc) {
176 		if ((interval = atoi(argv[optind])) == 0) {
177 			(void) fprintf(stderr, gettext("%s: invalid "
178 				"interval value\n"), pgmname);
179 			exit(1);
180 		}
181 
182 		optind++;
183 		if (optind < argc)
184 			if ((count = atoi(argv[optind])) <= 0) {
185 				(void) fprintf(stderr, gettext("%s: "
186 					"invalid iteration value.\n"),
187 					    pgmname);
188 				exit(1);
189 			}
190 	}
191 
192 	set_timer(interval);
193 
194 	/*
195 	 * Set events for the first time.
196 	 */
197 	if (write_evts == TRUE)
198 		setup_evts();
199 
200 
201 	if (count > 0) {
202 		for (i = 0; i < count; i++) {
203 			if (banner)
204 				print_banner();
205 
206 			check_dr_ops();
207 			read_evts();
208 			(void) fflush(stdout);
209 			(void) pause();
210 		}
211 	} else {
212 		for (;;) {
213 			if (banner)
214 				print_banner();
215 
216 			check_dr_ops();
217 			read_evts();
218 			(void) fflush(stdout);
219 			(void) pause();
220 		}
221 	}
222 
223 	read_evts();
224 	return (0);
225 }
226 
227 
228 /*
229  * Display all the events that can be set on a device.
230  */
231 void
print_evt()232 print_evt()
233 {
234 	kstat_t		*cnt_ksp;
235 	kstat_t		*pic_ksp;
236 	kstat_named_t	*cnt_data;
237 	kstat_named_t	*pic_data;
238 	char		*device = NULL;
239 	char		*value;
240 	int		inst_num = -1;
241 	int		i = 0;
242 	int		j;
243 
244 	value = optarg;
245 
246 	/*
247 	 * Search through the value string for a numeric char which will
248 	 * be the device instance number, if the user specified one. If
249 	 * the user did not specify an instance then the return value from
250 	 * strscpn will be equal to the string length. In this case we
251 	 * use a default value of -1 for the kstat_lookup which causes
252 	 * the device number to be ignored during the search.
253 	 */
254 	if (((i = strcspn(value, "0123456789")) > 0) && (i != strlen(value))) {
255 
256 		device = safe_malloc(sizeof (char) * i+1);
257 		device[i] = '\0';
258 		(void) strncpy(device, value, i);
259 
260 		value = value + i;
261 		inst_num = atoi(value);
262 	}
263 
264 	/*
265 	 * No instance specified.
266 	 */
267 	if (device == NULL)
268 		device = value;
269 
270 	/*
271 	 * Get the "counters" kstat, so that we can get
272 	 * the names of the "picN" kstats, which hold the
273 	 * event names.
274 	 */
275 	if ((cnt_ksp = kstat_lookup(kc, device, inst_num, "counters"))
276 								== NULL) {
277 		(void) fprintf(stderr, gettext("%s: invalid device "
278 			"name or instance (%s)\n"), pgmname, device);
279 		exit(1);
280 	}
281 
282 	if (kstat_read(kc, cnt_ksp, NULL) == FAIL) {
283 		(void) fprintf(stderr, gettext("%s: could not read "
284 			"kstat.\n"), pgmname);
285 		exit(1);
286 	}
287 
288 	cnt_data = (kstat_named_t *)cnt_ksp->ks_data;
289 
290 	/*
291 	 * Start at 1 as the first entry in the "counters"
292 	 * kstat is the pcr value/name. We are looking for the
293 	 * name of the "picN" kstats. For each one found store
294 	 * a pointer to it in pic_data[].
295 	 */
296 	if (cnt_ksp->ks_ndata <= 1) {
297 		(void) fprintf(stderr, gettext("%s: invalid kstat "
298 			"structure.\n"), pgmname);
299 		exit(1);
300 	}
301 
302 	for (i = 1; i < cnt_ksp->ks_ndata; i++) {
303 		if ((pic_ksp = find_pic_kstat(device, inst_num,
304 			cnt_data[i].name)) == NULL) {
305 
306 			(void) fprintf(stderr, gettext("%s: could not read "
307 				"pic kstat data structure for %s\n"),
308 				    pgmname, cnt_ksp->ks_module);
309 
310 			exit(1);
311 		}
312 
313 		if (kstat_read(kc, pic_ksp, NULL) == FAIL) {
314 			(void) fprintf(stderr, gettext("%s: could not read "
315 				"pic kstat.\n"), pgmname);
316 
317 			exit(1);
318 		}
319 
320 		pic_data = (kstat_named_t *)pic_ksp->ks_data;
321 
322 		(void) printf(gettext("pic%-8d\n"), i-1);
323 
324 		for (j = 0; j < pic_ksp->ks_ndata-1; j++) {
325 			(void) printf("%-30s\n", pic_data[j].name);
326 		}
327 
328 		(void) printf("\n");
329 	}
330 
331 	exit(0);
332 }
333 
334 
335 /*
336  * Display the names and instances of the devices on the system
337  * which can support performance monitoring.
338  */
339 void
print_dev(int argc,char * str)340 print_dev(int argc, char *str)
341 {
342 	kstat_t	*ksp;
343 	static int first_time = 1;
344 
345 	if ((argc > 2) || (strcmp(str, "-l") != 0)) {
346 		(void) fprintf(stderr, gettext("%s: no arguments "
347 			"permitted with -l option.\n"),
348 			    pgmname);
349 		usage();
350 		exit(1);
351 	}
352 
353 	/*
354 	 * For each device node, print the node name (device
355 	 * name) and the instance numbers.
356 	 */
357 	for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
358 		if ((strcmp(ksp->ks_class, "bus") == 0) &&
359 			(strcmp(ksp->ks_name, "counters") == 0)) {
360 					if (first_time) {
361 						(void) printf(gettext("Busstat "
362 							"Device(s):\n"));
363 						first_time = 0;
364 					}
365 					(void) printf("%s%d ", ksp->ks_module,
366 						ksp->ks_instance);
367 		}
368 	}
369 
370 	if (first_time)
371 		(void) fprintf(stderr, gettext("%s: No devices available "
372 			"in system."), pgmname);
373 
374 	(void) printf("\n");
375 
376 	exit(0);
377 }
378 
379 /*
380  * Parses the cmd line, checks all the values and
381  * creates the appropiate data structures.
382  */
383 void
parse_cmd(int mode)384 parse_cmd(int mode)
385 {
386 	char		*options = optarg, *value;
387 	int		arg_num	= 0;
388 
389 	while ((value = (char *)strtok(options, ",=")) != NULL) {
390 		/*
391 		 * First arg must be device name.
392 		 */
393 		if (!arg_num) {
394 			parse_dev_inst(value);
395 		} else {
396 			if (mode == READ_EVT) {
397 				(void) fprintf(stderr, gettext("%s: "
398 					"event names or pic values not "
399 					"permitted with -r option.\n"),
400 					    pgmname);
401 					usage();
402 				exit(1);
403 			}
404 			/*
405 			 * Now dealing with pic values.
406 			 */
407 			parse_pic_evt(value);
408 		}
409 		/*
410 		 * After first strtok call, must set first arg
411 		 * to null if wish to parse rest of string.
412 		 * See strtok man page.
413 		 */
414 		if (options != NULL)
415 			options = NULL;
416 		arg_num++;
417 	}
418 }
419 
420 
421 /*
422  * Parse the device name/instance section of the
423  * command line.
424  */
425 void
parse_dev_inst(char * value)426 parse_dev_inst(char *value)
427 {
428 	int		i;
429 	char		*device	= NULL;
430 	int		malloc_flag = FALSE;
431 
432 	if (strlen(value) == 0) {
433 		(void) fprintf(stderr, gettext("%s: No device name given.\n"),
434 			pgmname);
435 		exit(1);
436 	}
437 
438 	/*
439 	 * Break string into device name and
440 	 * instance number (if given).
441 	 */
442 	if ((i = strcspn(value, "0123456789")) > 0) {
443 		if (i != strlen(value)) {
444 			device = safe_malloc(sizeof (char) * i+1);
445 			device[i] = '\0';
446 
447 			(void) strncpy(device, value, i);
448 			malloc_flag = TRUE;
449 
450 			value = value + i;
451 		}
452 	}
453 
454 	/*
455 	 * No instance was specified so we assume
456 	 * the user wants to use ALL instances.
457 	 */
458 	if (device == NULL) {
459 		if ((device = value) == NULL) {
460 			(void) fprintf(stderr, gettext("%s: no device "
461 				"specified\n"), pgmname);
462 			exit(1);
463 		}
464 
465 		/*
466 		 * Set global flags.
467 		 */
468 		(void) strcpy(curr_dev_name, device);
469 		curr_inst_num = -1;
470 
471 		add_all_dev_node(device);
472 		goto clean_up;
473 	}
474 
475 	/*
476 	 * Set global flags.
477 	 */
478 	(void) strcpy(curr_dev_name, device);
479 	curr_inst_num = atoi(value);
480 
481 	add_dev_node(device, curr_inst_num);
482 
483 clean_up:
484 	if (malloc_flag) {
485 		free(device);
486 	}
487 }
488 
489 
490 /*
491  * Adds new event nodes to existing ones, modifies existing ones, or
492  * prunes existing ones.
493  *
494  * A specific instance call will overwrite an earlier all
495  * instances call, but *not* vice-versa.
496  *
497  * All the state transitions are given below.
498  *
499  *
500  *                       Call Type
501  * STATE |  Specific Instance          All Instances.
502  * ======================================================
503  * INIT  | Change state to       | Change state to ALL,
504  *       | INST, add events      | add events.
505  *       |                       |
506  * INST  | State unchanged,      | No change.
507  *       | Add events.           |
508  *       |                       |
509  * ALL   | Change state to       | State unchanged,
510  *       | INST, replace events. | add events.
511  */
512 void
parse_pic_evt(char * value)513 parse_pic_evt(char *value)
514 {
515 	dev_node_t	*dev_node;
516 	char		*evt_name;
517 	int		pic_num;
518 
519 	if (strlen(value) <= PIC_STR_LEN) {
520 		(void) fprintf(stderr, gettext("%s: no pic number "
521 			"specified.\n"), pgmname);
522 		exit(1);
523 	}
524 
525 	if (strncmp(value, "pic", PIC_STR_LEN) != 0) {
526 		(void) fprintf(stderr, gettext("%s: missing pic "
527 			"specifier\n"), pgmname);
528 		usage();
529 	}
530 
531 	/*
532 	 * Step over the 'pic' part of the string to
533 	 * get the pic number.
534 	 */
535 	value = value + PIC_STR_LEN;
536 	pic_num = atoi(value);
537 
538 	if ((pic_num == -1) || (pic_num > max_pic_num -1)) {
539 		(void) fprintf(stderr, gettext("%s: invalid pic "
540 			"number.\n"), pgmname);
541 		exit(1);
542 	}
543 
544 	if ((evt_name = (char *)strtok(NULL, "=,")) == NULL) {
545 		(void) fprintf(stderr, gettext("%s: no event "
546 			"specified.\n"), pgmname);
547 		exit(1);
548 	}
549 
550 	/*
551 	 * Dealing with a specific instance.
552 	 */
553 	if (curr_inst_num >= 0) {
554 		if ((dev_node = find_dev_node(curr_dev_name,
555 			curr_inst_num, pic_num)) == NULL) {
556 			(void) fprintf(stderr, gettext("%s: could not find "
557 				"data structures for %s\n"),
558 				    pgmname, curr_dev_name);
559 			exit(1);
560 		}
561 
562 		if (dev_node->r_w == EVT_READ) {
563 			modify_evt_node(dev_node, evt_name);
564 			dev_node->r_w = EVT_WRITE;
565 			dev_node->state = STATE_INST;
566 
567 		} else if ((dev_node->r_w == EVT_WRITE) &&
568 			(dev_node->state == STATE_ALL)) {
569 
570 			prune_evt_nodes(dev_node);
571 			modify_evt_node(dev_node, evt_name);
572 			dev_node->state = STATE_INST;
573 
574 		} else if ((dev_node->r_w == EVT_WRITE) &&
575 			(dev_node->state == STATE_INST)) {
576 
577 			add_evt_node(dev_node);
578 			modify_evt_node(dev_node, evt_name);
579 		}
580 
581 		return;
582 	}
583 
584 	/*
585 	 * Dealing with all instances of a specific device.
586 	 */
587 	dev_node = dev_list_head;
588 	while (dev_node != NULL) {
589 		if ((strcmp(dev_node->name, curr_dev_name) == 0) &&
590 			(dev_node->pic_num == pic_num)) {
591 
592 			if (dev_node->r_w == EVT_READ) {
593 				modify_evt_node(dev_node,
594 					evt_name);
595 
596 				dev_node->r_w = EVT_WRITE;
597 				dev_node->state = STATE_ALL;
598 
599 			} else if ((dev_node->r_w == EVT_WRITE) &&
600 				(dev_node->state == STATE_ALL)) {
601 
602 				add_evt_node(dev_node);
603 				modify_evt_node(dev_node, evt_name);
604 
605 			}
606 		}
607 		dev_node = dev_node->next;
608 	}
609 }
610 
611 
612 /*
613  * Create a dev_node structure for this device if one does not
614  * already exist.
615  */
616 void
add_dev_node(char * dev_name,int inst_num)617 add_dev_node(char *dev_name, int inst_num)
618 {
619 	dev_node_t	*new_dev_node;
620 	kstat_named_t	*cnt_data;
621 	kstat_t		*cnt_ksp;
622 	kstat_t		*pic_ksp;
623 	int		pic_num;
624 
625 
626 	if ((cnt_ksp = kstat_lookup(kc, dev_name,
627 		inst_num, "counters")) == NULL) {
628 		(void) fprintf(stderr, gettext("%s: invalid device "
629 			"name or instance (%s%d)\n"), pgmname,
630 				dev_name, inst_num);
631 		exit(1);
632 	}
633 
634 	if (kstat_read(kc, cnt_ksp, NULL) == FAIL) {
635 		(void) fprintf(stderr, gettext("%s : could not read counters "
636 			"kstat for device %s.\n"), pgmname, dev_name);
637 		exit(1);
638 	}
639 
640 	cnt_data = (kstat_named_t *)cnt_ksp->ks_data;
641 
642 	if (cnt_ksp->ks_ndata <= 1) {
643 		(void) fprintf(stderr, gettext("%s : invalid "
644 			"kstat structure.\n"), pgmname);
645 		exit(1);
646 	}
647 
648 	/*
649 	 * max_pic_num used to format headers correctly
650 	 * for printing.
651 	 */
652 	if (cnt_ksp->ks_ndata-1 > max_pic_num)
653 		max_pic_num = cnt_ksp->ks_ndata-1;
654 
655 	/* for each pic... */
656 	for (pic_num = 0; pic_num < cnt_ksp->ks_ndata-1; pic_num++) {
657 		if (find_dev_node(dev_name, inst_num, pic_num) != NULL) {
658 			/* Node already exists */
659 			continue;
660 		}
661 
662 		new_dev_node = safe_malloc(sizeof (dev_node_t));
663 		bzero(new_dev_node, sizeof (dev_node_t));
664 
665 		(void) strcpy(new_dev_node->name, dev_name);
666 		new_dev_node->dev_inst = inst_num;
667 		new_dev_node->pic_num = pic_num;
668 
669 		new_dev_node->cnt_ksp = cnt_ksp;
670 
671 		if ((pic_ksp = find_pic_kstat(dev_name, inst_num,
672 			cnt_data[pic_num+1].name)) == NULL) {
673 
674 			(void) fprintf(stderr, gettext("%s: could not find "
675 				"pic kstat structure for %s.\n"),
676 				    pgmname, cnt_ksp->ks_module);
677 			exit(1);
678 		}
679 
680 		new_dev_node->pic_ksp = pic_ksp;
681 
682 		add_evt_node(new_dev_node);
683 
684 		new_dev_node->state = STATE_INIT;
685 		new_dev_node->r_w = EVT_READ;
686 
687 		if (dev_list_head == NULL) {
688 			dev_list_head = new_dev_node;
689 			dev_list_tail = new_dev_node;
690 
691 		} else if (find_dev_node(dev_name, inst_num, pic_num) == NULL) {
692 			dev_list_tail->next = new_dev_node;
693 			dev_list_tail = new_dev_node;
694 		}
695 	}
696 }
697 
698 
699 /*
700  * Add all possible instances of a device.
701  */
702 void
add_all_dev_node(char * dev_name)703 add_all_dev_node(char *dev_name)
704 {
705 	kstat_t	*ksp;
706 	int	match = 0;
707 
708 	for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
709 		if ((strcmp(ksp->ks_class, "bus") == 0) &&
710 			(strcmp(ksp->ks_name, "counters") == 0) &&
711 			(strcmp(ksp->ks_module, dev_name) == 0)) {
712 				match = 1;
713 				add_dev_node(dev_name, ksp->ks_instance);
714 		}
715 	}
716 
717 	if (match == 0) {
718 		(void) fprintf(stderr,
719 			gettext("%s: invalid device name (%s)\n"),
720 			pgmname, dev_name);
721 		exit(1);
722 	}
723 }
724 
725 
726 /*
727  * Add an event node to a specified device node.
728  */
729 void
add_evt_node(dev_node_t * dev_node)730 add_evt_node(dev_node_t *dev_node)
731 {
732 	evt_node_t	*new_evt_node;
733 	evt_node_t	*curr_evt_node;
734 
735 	new_evt_node = safe_malloc(sizeof (evt_node_t));
736 	bzero(new_evt_node, sizeof (evt_node_t));
737 
738 	(void) strcpy(new_evt_node->evt_name, "");
739 
740 	if (dev_node->evt_node == NULL) {
741 		dev_node->evt_node = new_evt_node;
742 		new_evt_node->next = new_evt_node;
743 		return;
744 	} else {
745 		curr_evt_node = dev_node->evt_node;
746 		while (curr_evt_node->next != dev_node->evt_node)
747 			curr_evt_node = curr_evt_node->next;
748 
749 		curr_evt_node->next = new_evt_node;
750 		new_evt_node->next = dev_node->evt_node;
751 	}
752 }
753 
754 
755 /*
756  * Fill in or change the fields of an evt node.
757  */
758 void
modify_evt_node(dev_node_t * dev_node,char * evt_name)759 modify_evt_node(dev_node_t *dev_node, char *evt_name)
760 {
761 	evt_node_t	*evt_node;
762 	kstat_t		*pic_ksp;
763 	kstat_named_t	*pic_data;
764 	int64_t		evt_num = 0;
765 	int		evt_match = 0;
766 	int		i;
767 
768 	evt_node = dev_node->evt_node;
769 
770 	/*
771 	 * Find the last event node.
772 	 */
773 	if (evt_node->next != evt_node) {
774 		while (evt_node->next != dev_node->evt_node) {
775 			evt_node = evt_node->next;
776 		}
777 	}
778 
779 	evt_node->prev_count = 0;
780 	evt_node->total = 0;
781 
782 	pic_ksp = dev_node->pic_ksp;
783 
784 	if (kstat_read(kc, pic_ksp, NULL) == FAIL) {
785 		(void) fprintf(stderr, gettext("%s: could not read "
786 			"pic kstat.\n"), pgmname);
787 		exit(1);
788 	}
789 
790 	pic_data = (kstat_named_t *)dev_node->pic_ksp->ks_data;
791 
792 	/*
793 	 * The event can either be given as a event name (string) or
794 	 * as a pcr mask. If given as pcr mask, we try to match it
795 	 * to an event name, and use that name. Otherwise we just use
796 	 * the pcr mask value.
797 	 */
798 	if ((evt_num = is_num(evt_name)) == EVT_STR) {
799 		(void) strcpy(evt_node->evt_name, evt_name);
800 
801 		for (i = 0; i < dev_node->pic_ksp->ks_ndata; i++) {
802 			if (strcmp(evt_name, pic_data[i].name) == 0) {
803 				evt_node->evt_pcr_mask = pic_data[i].value.ui64;
804 				return;
805 			}
806 		}
807 
808 		(void) fprintf(stderr,
809 			gettext("%s: %s is not a valid event name.\n"),
810 			pgmname, evt_name);
811 		exit(1);
812 
813 	} else {
814 		/*
815 		 * See if the pcr mask given by the user matches that for any
816 		 * existing event.
817 		 */
818 		for (i = 0; i < dev_node->pic_ksp->ks_ndata; i++) {
819 			if (evt_num == pic_data[i].value.ui64) {
820 				(void) strcpy(evt_node->evt_name,
821 					pic_data[i].name);
822 				evt_match = 1;
823 				break;
824 			}
825 		}
826 
827 		if (evt_match == 0)
828 			(void) sprintf(evt_node->evt_name, "%llx", evt_num);
829 
830 		evt_node->evt_pcr_mask = evt_num;
831 	}
832 }
833 
834 
835 /*
836  * Removes all bar one of the evt_nodes that are hanging off the
837  * specified dev_node.
838  */
839 void
prune_evt_nodes(dev_node_t * dev_node)840 prune_evt_nodes(dev_node_t *dev_node)
841 {
842 	evt_node_t	*next_evt_node;
843 	evt_node_t	*curr_evt_node;
844 
845 	/*
846 	 * Only one evt node, nothing for us to do.
847 	 */
848 	if (dev_node->evt_node->next == dev_node->evt_node) {
849 		return;
850 	}
851 
852 	curr_evt_node = dev_node->evt_node->next;
853 	dev_node->evt_node->next = dev_node->evt_node;
854 
855 	while (curr_evt_node != dev_node->evt_node) {
856 		next_evt_node = curr_evt_node->next;
857 		free(curr_evt_node);
858 		curr_evt_node = next_evt_node;
859 	}
860 }
861 
862 
863 /*
864  * Set the events for each pic on each device instance.
865  */
866 void
setup_evts()867 setup_evts()
868 {
869 	dev_node_t	*dev_node;
870 
871 	dev_node = dev_list_head;
872 
873 	while (dev_node != NULL) {
874 		if (dev_node->r_w == EVT_WRITE)
875 			set_evt(dev_node);
876 
877 		dev_node = dev_node->next;
878 	}
879 }
880 
881 
882 /*
883  * Set the appropiate events. Only called for event nodes
884  * that are marked EVT_WRITE.
885  */
886 void
set_evt(dev_node_t * dev_node)887 set_evt(dev_node_t *dev_node)
888 {
889 	kstat_named_t	*cnt_data;
890 	kstat_named_t	*pic_data;
891 	kstat_t		*cnt_ksp;
892 	kstat_t		*pic_ksp;
893 	evt_node_t	*evt_node;
894 	uint64_t	clear_pcr_mask;
895 	uint64_t	pcr;
896 	int		pic_num;
897 
898 	cnt_ksp = dev_node->cnt_ksp;
899 	pic_ksp = dev_node->pic_ksp;
900 	pic_num = dev_node->pic_num;
901 	evt_node = dev_node->evt_node;
902 
903 	/* Read the "counters" kstat */
904 	if (kstat_read(kc, cnt_ksp, NULL) == FAIL) {
905 		(void) fprintf(stderr, gettext("%s: could "
906 			"not set event's.\n"), pgmname);
907 		exit(1);
908 	}
909 
910 	cnt_data = (kstat_named_t *)cnt_ksp->ks_data;
911 
912 	if (kstat_read(kc, pic_ksp, NULL) == FAIL) {
913 		(void) fprintf(stderr, gettext("%s: could "
914 			"not set event's.\n"), pgmname);
915 		exit(1);
916 	}
917 
918 	pic_data = (kstat_named_t *)pic_ksp->ks_data;
919 	clear_pcr_mask = pic_data[pic_ksp->ks_ndata-1].value.ui64;
920 
921 	if ((pic_num < 0) || (pic_num > cnt_ksp->ks_ndata-1)) {
922 		(void) fprintf(stderr,
923 			gettext("%s: invalid pic #%d.\n"),
924 			pgmname, pic_num);
925 		exit(1);
926 	}
927 
928 	/*
929 	 * Store the previous value that is on the pic
930 	 * so that we can calculate the delta value
931 	 * later.
932 	 */
933 	evt_node->prev_count = cnt_data[pic_num+1].value.ui64;
934 
935 
936 	/*
937 	 * Read the current pcr value from device.
938 	 */
939 	pcr = cnt_data[0].value.ui64;
940 
941 	/*
942 	 * Clear the section of the pcr which corresponds to the
943 	 * pic we are setting events on. Also clear the pcr value
944 	 * which is stored in the instance node.
945 	 *
946 	 */
947 	pcr = pcr & clear_pcr_mask;
948 
949 	/*
950 	 * Set the event.
951 	 */
952 	pcr = pcr | evt_node->evt_pcr_mask;
953 	cnt_data[0].value.ui64 = pcr;
954 
955 	/*
956 	 * Write the value back to the kstat, to make it
957 	 * visible to the underlying driver.
958 	 */
959 	if (kstat_write(kc, cnt_ksp, NULL) == FAIL) {
960 		(void) fprintf(stderr, gettext("%s: could not set events "
961 					"(setting events requires root "
962 					    "permission).\n"), pgmname);
963 		exit(1);
964 	}
965 }
966 
967 
968 /*
969  * Works through the list of device nodes, reading events
970  * and where appropiate setting new events (multiplexing).
971  */
972 void
read_evts()973 read_evts()
974 {
975 	dev_node_t	*dev_node;
976 	kstat_t		*cnt_ksp;
977 	kstat_named_t	*cnt_data;
978 	char		tmp_str[30];
979 	int		iter = 0;
980 
981 	dev_node = dev_list_head;
982 
983 	while (dev_node != NULL) {
984 		if (iter == 0)
985 			print_timestamp();
986 		/*
987 		 * First read of all the counters is done
988 		 * to establish a baseline for the counts.
989 		 * This data is not printed.
990 		 */
991 		if ((!initial_read) && (iter == 0)) {
992 			(void) snprintf(tmp_str, sizeof (tmp_str), "%s%d",
993 				dev_node->name, dev_node->dev_inst);
994 			(void) printf("%-7s", tmp_str);
995 		}
996 
997 		cnt_ksp = (kstat_t *)dev_node->cnt_ksp;
998 
999 		if (kstat_read(kc, cnt_ksp, NULL) == FAIL) {
1000 			(void) fprintf(stderr, gettext("%s: device %s%d "
1001 				"(pic %d) no longer valid.\n"),
1002 				    pgmname, dev_node->name,
1003 				    dev_node->dev_inst,
1004 				    dev_node->pic_num);
1005 			remove_dev_node(dev_node);
1006 			dev_node = dev_list_head;
1007 			continue;
1008 		}
1009 
1010 		cnt_data = (kstat_named_t *)cnt_ksp->ks_data;
1011 
1012 		if (dev_node->r_w == EVT_READ) {
1013 			read_r_evt_node(dev_node, dev_node->pic_num, cnt_data);
1014 			iter++;
1015 		} else {
1016 			read_w_evt_node(dev_node, dev_node->pic_num, cnt_data);
1017 			iter++;
1018 		}
1019 
1020 		if ((!initial_read) && (iter == max_pic_num)) {
1021 			iter = 0;
1022 			(void) printf("\n");
1023 		}
1024 
1025 		/*
1026 		 * If there is more than one event node
1027 		 * per-pic then we are multiplexing.
1028 		 */
1029 		if ((dev_node->evt_node->next != dev_node->evt_node) &&
1030 			(!initial_read)) {
1031 				dev_node->evt_node = dev_node->evt_node->next;
1032 				set_evt(dev_node);
1033 		}
1034 		dev_node = dev_node->next;
1035 	}
1036 	initial_read = FALSE;
1037 }
1038 
1039 
1040 /*
1041  * Read a node that is marked as EVT_READ
1042  */
1043 void
read_r_evt_node(dev_node_t * dev_node,int pic_num,kstat_named_t * cnt_data)1044 read_r_evt_node(dev_node_t *dev_node, int pic_num, kstat_named_t *cnt_data)
1045 {
1046 	evt_node_t	*evt_node;
1047 	kstat_t		*pic_ksp;
1048 	kstat_named_t	*pic_data;
1049 	uint64_t	pcr_read;
1050 	uint64_t	clear_pcr_mask;
1051 	uint64_t	delta_count;
1052 	int		i;
1053 	int		match = 0;
1054 	int		evt_blank = 1;
1055 
1056 	evt_node = dev_node->evt_node;
1057 
1058 	pic_ksp = (kstat_t *)dev_node->pic_ksp;
1059 
1060 	if (kstat_read(kc, pic_ksp, NULL) == FAIL) {
1061 		(void) fprintf(stderr, gettext("%s: device %s%d "
1062 			"(pic %d) no longer valid.\n"), pgmname,
1063 			    dev_node->name, dev_node->dev_inst,
1064 			    dev_node->pic_num);
1065 		remove_dev_node(dev_node);
1066 		return;
1067 	}
1068 
1069 	pic_data = (kstat_named_t *)pic_ksp->ks_data;
1070 	clear_pcr_mask = pic_data[pic_ksp->ks_ndata-1].value.ui64;
1071 
1072 	/*
1073 	 * Get PCR value from device. We extract the portion
1074 	 * of the PCR relating to the pic we are interested by
1075 	 * AND'ing the inverse of the clear mask for this pic.
1076 	 *
1077 	 * The clear mask is usually used to clear the appropiate
1078 	 * section of the PCR before we write events into it. So
1079 	 * by using the inverse of the mask, we zero everything
1080 	 * *but* the section we are interested in.
1081 	 */
1082 	pcr_read = cnt_data[0].value.ui64;
1083 	pcr_read = pcr_read & ~(clear_pcr_mask);
1084 
1085 	/*
1086 	 * If the event name is blank this is the first time that
1087 	 * this node has been accessed, so we read the pcr and
1088 	 * from that we get the event name if it exists.
1089 	 *
1090 	 * If the pcr read from the device does not match that
1091 	 * stored in the node, then it means that the event has
1092 	 * changed from its previous value, so we need to re-read
1093 	 * all the values.
1094 	 */
1095 	if ((strcmp(evt_node->evt_name, "") == 0) ||
1096 		(pcr_read != evt_node->evt_pcr_mask)) {
1097 
1098 		for (i = 0; i < pic_ksp->ks_ndata-1; i++) {
1099 			if (pcr_read == pic_data[i].value.ui64) {
1100 				match = TRUE;
1101 				break;
1102 			}
1103 		}
1104 
1105 		/*
1106 		 * Able to resolve pcr value to a event name.
1107 		 */
1108 		if (match) {
1109 			(void) strcpy(evt_node->evt_name, pic_data[i].name);
1110 			evt_node->evt_pcr_mask = pcr_read;
1111 			evt_node->total = 0;
1112 			evt_node->prev_count =
1113 				cnt_data[pic_num+1].value.ui64;
1114 
1115 			if ((evt_blank) && (!initial_read)) {
1116 				(void) printf("%s\t%-8d\t",
1117 					evt_node->evt_name, 0);
1118 				evt_blank = 0;
1119 			}
1120 
1121 		} else {
1122 			(void) sprintf(evt_node->evt_name, "0x%llx", pcr_read);
1123 			evt_node->evt_pcr_mask = pcr_read;
1124 			evt_node->total = 0;
1125 			evt_node->prev_count =
1126 				cnt_data[pic_num+1].value.ui64;
1127 
1128 			if ((evt_blank) && (!initial_read)) {
1129 				(void) printf("%s\t%-8d\t",
1130 					evt_node->evt_name, 0);
1131 				evt_blank = 0;
1132 			}
1133 
1134 		}
1135 	} else {
1136 		/* Deal with wraparound of the counters */
1137 		if (cnt_data[pic_num+1].value.ui64 < evt_node->prev_count) {
1138 
1139 			delta_count = (UINT32_MAX-evt_node->prev_count) +
1140 				cnt_data[pic_num+1].value.ui64;
1141 		} else {
1142 			/* Calcalate delta value */
1143 			delta_count = cnt_data[pic_num+1].value.ui64
1144 						- evt_node->prev_count;
1145 		}
1146 
1147 
1148 		/*
1149 		 * Store value so that we can calculate delta next
1150 		 * time through.
1151 		 */
1152 		evt_node->prev_count = cnt_data[pic_num+1].value.ui64;
1153 
1154 		/* Update count total */
1155 		evt_node->total += delta_count;
1156 
1157 		if (delta) {
1158 			(void) printf("%-20s %-9lld   ",
1159 				evt_node->evt_name, delta_count);
1160 		} else {
1161 
1162 			(void) printf("%-20s %-9lld   ",
1163 				evt_node->evt_name, evt_node->total);
1164 		}
1165 	}
1166 }
1167 
1168 
1169 /*
1170  * Read event nodes marked as EVT_WRITE
1171  */
1172 void
read_w_evt_node(dev_node_t * dev_node,int pic_num,kstat_named_t * cnt_data)1173 read_w_evt_node(dev_node_t *dev_node, int pic_num, kstat_named_t *cnt_data)
1174 {
1175 	kstat_t		*pic_ksp;
1176 	kstat_named_t	*pic_data;
1177 	evt_node_t	*evt_node;
1178 	uint64_t	delta_count;
1179 	uint64_t	pcr_read;
1180 	uint64_t	clear_pcr_mask;
1181 
1182 	evt_node = dev_node->evt_node;
1183 
1184 	pic_ksp = (kstat_t *)dev_node->pic_ksp;
1185 
1186 	if (kstat_read(kc, pic_ksp, NULL) == FAIL) {
1187 		(void) fprintf(stderr, gettext("%s: could not read "
1188 			"%s%d\n"), pgmname, dev_node->name,
1189 			    dev_node->dev_inst);
1190 		remove_dev_node(dev_node);
1191 		return;
1192 	}
1193 
1194 	pic_data = (kstat_named_t *)pic_ksp->ks_data;
1195 	clear_pcr_mask = pic_data[pic_ksp->ks_ndata-1].value.ui64;
1196 
1197 	/*
1198 	 * Get PCR value from device. We extract the portion
1199 	 * of the PCR relating to the pic we are interested by
1200 	 * AND'ing the inverse of the clear mask for this pic.
1201 	 *
1202 	 * The clear mask is usually used to clear the appropiate
1203 	 * section of the PCR before we write events into it. So
1204 	 * by using the inverse of the mask, we zero everything
1205 	 * *but* the section we are interested in.
1206 	 */
1207 	pcr_read = cnt_data[0].value.ui64;
1208 	pcr_read = pcr_read & ~(clear_pcr_mask);
1209 
1210 	/*
1211 	 * If the pcr value from the device does not match the
1212 	 * stored value, then the events on at least one of the
1213 	 * pics must have been change by another busstat instance.
1214 	 *
1215 	 * Regard this as a fatal error.
1216 	 */
1217 	if (pcr_read != evt_node->evt_pcr_mask) {
1218 		(void) fprintf(stderr, gettext("%s: events changed (possibly "
1219 			"by another busstat).\n"), pgmname);
1220 		exit(2);
1221 	}
1222 
1223 	/*
1224 	 * Calculate delta, and then store value just read to allow us to
1225 	 * calculate delta next time around.
1226 	 */
1227 	/* Deal with wraparound of the counters */
1228 	if (cnt_data[pic_num+1].value.ui64 < evt_node->prev_count) {
1229 
1230 		delta_count = (UINT32_MAX-evt_node->prev_count) +
1231 			cnt_data[pic_num+1].value.ui64;
1232 	} else {
1233 		/* Calcalate delta value */
1234 		delta_count = cnt_data[pic_num+1].value.ui64
1235 			- evt_node->prev_count;
1236 	}
1237 
1238 	evt_node->prev_count = cnt_data[pic_num+1].value.ui64;
1239 
1240 	if (initial_read) {
1241 		evt_node->total = 0;
1242 
1243 	} else {
1244 		/* Update count total */
1245 		evt_node->total += delta_count;
1246 
1247 		if (delta) {
1248 			(void) printf("%-20s %-9lld   ",
1249 				evt_node->evt_name, delta_count);
1250 		} else {
1251 			(void) printf("%-20s %-9lld   ",
1252 				evt_node->evt_name, evt_node->total);
1253 		}
1254 	}
1255 }
1256 
1257 
1258 /*
1259  * Check to see if any DR operations have occured, and deal with the
1260  * consequences.
1261  *
1262  * Use the Kstat chain ID to check for DR operations. If the ID has
1263  * changed then some kstats on system have been modified, we check
1264  * all the data structures to see are they still valid. If they are
1265  * not we remove them.
1266  */
1267 void
check_dr_ops()1268 check_dr_ops()
1269 {
1270 	dev_node_t	*dev_node;
1271 	kid_t		new_id;
1272 	kstat_t		*ksp;
1273 	int		match = 0;
1274 
1275 	if ((new_id = kstat_chain_update(kc)) < 0) {
1276 		(void) fprintf(stderr, gettext("%s: could not get "
1277 			"kstat chain id\n"), pgmname);
1278 		exit(1);
1279 	}
1280 
1281 	if (new_id == 0) {
1282 		/* Kstat chain has not changed. */
1283 		return;
1284 	}
1285 
1286 	/*
1287 	 * Scan the chain of device nodes, making sure that their associated
1288 	 * kstats are still present. If not we remove the appropiate node.
1289 	 */
1290 	dev_node = dev_list_head;
1291 
1292 	while (dev_node != NULL) {
1293 		for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
1294 			if ((strcmp("bus", ksp->ks_class) == 0) &&
1295 				(strcmp("counters", ksp->ks_name) == 0) &&
1296 				(strcmp(dev_node->name, ksp->ks_module) == 0) &&
1297 				(ksp->ks_instance == dev_node->dev_inst)) {
1298 					match = 1;
1299 					break;
1300 			}
1301 		}
1302 		if (match == 0) {
1303 			(void) fprintf(stderr, gettext("%s: device %s%d"
1304 				" (pic %d) no longer valid.\n"), pgmname,
1305 				    dev_node->name, dev_node->dev_inst,
1306 				    dev_node->pic_num);
1307 
1308 			remove_dev_node(dev_node);
1309 		}
1310 		dev_node = dev_node->next;
1311 	}
1312 }
1313 
1314 
1315 
1316 /*
1317  * Remove a device node and its associated event nodes.
1318  */
1319 void
remove_dev_node(dev_node_t * dev_node)1320 remove_dev_node(dev_node_t *dev_node)
1321 {
1322 	dev_node_t	*curr_node;
1323 	dev_node_t	*prev_node;
1324 	evt_node_t	*curr_evt_node;
1325 	evt_node_t	*next_evt_node;
1326 	evt_node_t	*start_pos;
1327 
1328 	curr_node = dev_list_head;
1329 
1330 	if (curr_node == dev_node) {
1331 		dev_list_head = dev_node->next;
1332 
1333 		if (dev_list_head == NULL) {
1334 			(void) fprintf(stderr, gettext("%s: no "
1335 				"devices left to monitor.\n"),
1336 				    pgmname);
1337 			exit(1);
1338 		}
1339 
1340 		/* Remove each event node first */
1341 		start_pos = dev_node->evt_node;
1342 		curr_evt_node = start_pos->next;
1343 
1344 		while (curr_evt_node != start_pos) {
1345 			next_evt_node = curr_evt_node->next;
1346 
1347 			free(curr_evt_node);
1348 			curr_evt_node = next_evt_node;
1349 		}
1350 
1351 		free(start_pos);
1352 		free(dev_node);
1353 		return;
1354 	}
1355 
1356 	/* Find the device node */
1357 	prev_node = dev_list_head;
1358 	curr_node = prev_node->next;
1359 
1360 	while (curr_node != NULL) {
1361 		if (curr_node == dev_node) {
1362 			prev_node->next = curr_node->next;
1363 
1364 			/* Remove each event node first */
1365 			start_pos = dev_node->evt_node;
1366 			curr_evt_node = start_pos->next;
1367 
1368 			while (curr_evt_node != start_pos) {
1369 				next_evt_node = curr_evt_node->next;
1370 
1371 				free(curr_evt_node);
1372 				curr_evt_node = next_evt_node;
1373 			}
1374 			free(start_pos);
1375 
1376 			free(dev_node);
1377 			return;
1378 		}
1379 		prev_node = curr_node;
1380 		curr_node = curr_node->next;
1381 	}
1382 }
1383 
1384 
1385 /*
1386  * Find a device node in the linked list of dev_nodes. Match
1387  * is done on device name, and instance number.
1388  */
1389 dev_node_t *
find_dev_node(char * name,int inst_num,int pic_num)1390 find_dev_node(char *name, int inst_num, int pic_num)
1391 {
1392 	dev_node_t	*curr_node;
1393 
1394 	curr_node = dev_list_head;
1395 
1396 	while (curr_node != NULL) {
1397 		if ((strcmp(curr_node->name, name) == 0) &&
1398 			(curr_node->dev_inst == inst_num) &&
1399 			(curr_node->pic_num == pic_num)) {
1400 				return (curr_node);
1401 		}
1402 
1403 		curr_node = curr_node->next;
1404 	}
1405 
1406 	return (NULL);
1407 }
1408 
1409 
1410 /*
1411  * Determines whether the string represents a event name
1412  * or a numeric value. Numeric value can be dec, hex
1413  * or octal. All are converted to long int.
1414  */
1415 int64_t
is_num(char * name)1416 is_num(char *name)
1417 {
1418 	char	*remainder = NULL;
1419 	int64_t	num;
1420 
1421 	num = (int64_t)strtol(name, &remainder, 0);
1422 
1423 	if (name == remainder) {
1424 		return (EVT_STR);
1425 	} else {
1426 		return (num);
1427 	}
1428 }
1429 
1430 
1431 /*
1432  * Find a pointer to the specified picN kstat. First
1433  * search for the specific kstat, and if that can't
1434  * be found search for any picN kstat belonging to this device.
1435  */
1436 kstat_t *
find_pic_kstat(char * dev_name,int inst_num,char * pic)1437 find_pic_kstat(char *dev_name, int inst_num, char *pic)
1438 {
1439 	kstat_t	*ksp;
1440 	kstat_t	*p_ksp;
1441 
1442 	/* Look for specific picN kstat */
1443 	if ((p_ksp = kstat_lookup(kc, dev_name, inst_num, pic)) == NULL) {
1444 
1445 		for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
1446 			if ((strcmp(ksp->ks_class, "bus") == 0) &&
1447 				(strcmp(ksp->ks_name, pic) == 0) &&
1448 				(strcmp(ksp->ks_module, dev_name) == 0)) {
1449 
1450 						return (ksp);
1451 			}
1452 		}
1453 	}
1454 	return (p_ksp);
1455 }
1456 
1457 
1458 /*
1459  * Print column titles.
1460  * Can be turned off by -n option.
1461  */
1462 void
print_banner()1463 print_banner()
1464 {
1465 	int		i;
1466 
1467 	(void) printf("time dev    ");
1468 
1469 	for (i = 0; i < max_pic_num; i++)
1470 		(void) printf("event%d               "
1471 			"pic%d        ", i, i);
1472 
1473 	(void) printf("\n");
1474 
1475 	banner = FALSE;
1476 }
1477 
1478 
1479 /*
1480  * Print the elapsed time in seconds, since the last call.
1481  */
1482 void
print_timestamp()1483 print_timestamp()
1484 {
1485 	static hrtime_t	curr_time = 0;
1486 	static hrtime_t total_elapsed = 0;
1487 	hrtime_t	new_time = 0;
1488 	hrtime_t	elapsed = 0;
1489 	hrtime_t	rem = 0;
1490 
1491 	if (initial_read)	{
1492 		curr_time = (uint64_t)gethrtime();
1493 		return;
1494 	}
1495 
1496 	new_time = gethrtime();
1497 
1498 	elapsed = (new_time - curr_time)/NANO;
1499 
1500 	/* Round up time value if necessary */
1501 	rem = (new_time - curr_time)%NANO;
1502 	if (rem >= NANO/2)
1503 		elapsed += 1;
1504 
1505 	total_elapsed += elapsed;
1506 
1507 	(void) printf("%-4llu ", total_elapsed);
1508 
1509 	curr_time = new_time;
1510 }
1511 
1512 
1513 void
usage()1514 usage()
1515 {
1516 	(void) printf(gettext("Usage : busstat [-a] [-h] [-l] [-n]\n"
1517 		"                [-e device-inst]\n"
1518 		"                [-w device-inst "
1519 					"[,pic0=<event>] [,picN=<event>] ]\n"
1520 		"                [-r device-inst]\n"
1521 		"                [ interval [count] ]\n"));
1522 
1523 	exit(2);
1524 }
1525 
1526 
1527 void *
safe_malloc(size_t size)1528 safe_malloc(size_t size)
1529 {
1530 	void *a;
1531 
1532 	if ((a = malloc(size)) == NULL) {
1533 		(void) fprintf(stderr,
1534 			gettext("%s: out of memory.\n"), pgmname);
1535 		exit(1);
1536 	}
1537 
1538 	return (a);
1539 }
1540 
1541 /*
1542  * Create and arm the timer.
1543  */
1544 void
set_timer(int interval)1545 set_timer(int interval)
1546 {
1547 	timer_t		t_id;		/* Timer id */
1548 	itimerspec_t	time_struct;
1549 	struct sigevent	sig_struct;
1550 	struct sigaction act;
1551 
1552 	bzero(&sig_struct, sizeof (struct sigevent));
1553 	bzero(&act, sizeof (struct sigaction));
1554 
1555 	/* Create timer */
1556 	sig_struct.sigev_notify = SIGEV_SIGNAL;
1557 	sig_struct.sigev_signo = SIGUSR1;
1558 	sig_struct.sigev_value.sival_int = 0;
1559 
1560 	if (timer_create(CLOCK_REALTIME, &sig_struct, &t_id) != 0) {
1561 		(void) fprintf(stderr, gettext("%s: Timer creation failed.\n"),
1562 			pgmname);
1563 		exit(1);
1564 	}
1565 
1566 	act.sa_handler = handle_sig;
1567 
1568 	if (sigaction(SIGUSR1, &act, NULL) != 0) {
1569 		(void) fprintf(stderr, gettext("%s: could not setup signal "
1570 			"handler"), pgmname);
1571 		exit(1);
1572 	}
1573 
1574 	time_struct.it_value.tv_sec = interval;
1575 	time_struct.it_value.tv_nsec = 0;
1576 	time_struct.it_interval.tv_sec = interval;
1577 	time_struct.it_interval.tv_nsec = 0;
1578 
1579 	/* Arm timer */
1580 	if ((timer_settime(t_id, 0, &time_struct, NULL)) != 0) {
1581 		(void) fprintf(stderr, gettext("%s: Setting timer failed.\n"),
1582 			pgmname);
1583 		exit(1);
1584 	}
1585 }
1586 
1587 
1588 /* ARGSUSED */
1589 void
handle_sig(int x)1590 handle_sig(int x)
1591 {
1592 }
1593 
1594 /*
1595  * return a boolean value indicating whether or not
1596  * a string consists solely of characters which are
1597  * digits 0..9
1598  */
1599 int
strisnum(const char * s)1600 strisnum(const char *s)
1601 {
1602 	for (; *s != '\0'; s++) {
1603 		if (*s < '0' || *s > '9')
1604 			return (0);
1605 	}
1606 	return (1);
1607 }
1608