xref: /freebsd/usr.sbin/pmcstat/pmcstat.c (revision 0b86b1bb019bf449a62d1247b678069ee1cbe430)
1ebccf1e3SJoseph Koshy /*-
2165b10b0SJoseph Koshy  * Copyright (c) 2003-2008, Joseph Koshy
3b6010f9eSJoseph Koshy  * Copyright (c) 2007 The FreeBSD Foundation
4ebccf1e3SJoseph Koshy  * All rights reserved.
5ebccf1e3SJoseph Koshy  *
6b6010f9eSJoseph Koshy  * Portions of this software were developed by A. Joseph Koshy under
7b6010f9eSJoseph Koshy  * sponsorship from the FreeBSD Foundation and Google, Inc.
8b6010f9eSJoseph Koshy  *
9ebccf1e3SJoseph Koshy  * Redistribution and use in source and binary forms, with or without
10ebccf1e3SJoseph Koshy  * modification, are permitted provided that the following conditions
11ebccf1e3SJoseph Koshy  * are met:
12ebccf1e3SJoseph Koshy  * 1. Redistributions of source code must retain the above copyright
13ebccf1e3SJoseph Koshy  *    notice, this list of conditions and the following disclaimer.
14ebccf1e3SJoseph Koshy  * 2. Redistributions in binary form must reproduce the above copyright
15ebccf1e3SJoseph Koshy  *    notice, this list of conditions and the following disclaimer in the
16ebccf1e3SJoseph Koshy  *    documentation and/or other materials provided with the distribution.
17ebccf1e3SJoseph Koshy  *
18ebccf1e3SJoseph Koshy  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19ebccf1e3SJoseph Koshy  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20ebccf1e3SJoseph Koshy  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21ebccf1e3SJoseph Koshy  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22ebccf1e3SJoseph Koshy  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23ebccf1e3SJoseph Koshy  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24ebccf1e3SJoseph Koshy  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25ebccf1e3SJoseph Koshy  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26ebccf1e3SJoseph Koshy  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27ebccf1e3SJoseph Koshy  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28ebccf1e3SJoseph Koshy  * SUCH DAMAGE.
29ebccf1e3SJoseph Koshy  */
30ebccf1e3SJoseph Koshy 
31ebccf1e3SJoseph Koshy #include <sys/cdefs.h>
32ebccf1e3SJoseph Koshy __FBSDID("$FreeBSD$");
33ebccf1e3SJoseph Koshy 
34ebccf1e3SJoseph Koshy #include <sys/types.h>
35ebccf1e3SJoseph Koshy #include <sys/event.h>
36fbd8b34aSJoseph Koshy #include <sys/param.h>
37ebccf1e3SJoseph Koshy #include <sys/queue.h>
3815139246SJoseph Koshy #include <sys/socket.h>
3915139246SJoseph Koshy #include <sys/stat.h>
40ee4910b1SJoseph Koshy #include <sys/sysctl.h>
41ebccf1e3SJoseph Koshy #include <sys/time.h>
42ebccf1e3SJoseph Koshy #include <sys/ttycom.h>
43fbd8b34aSJoseph Koshy #include <sys/user.h>
44ebccf1e3SJoseph Koshy #include <sys/wait.h>
45ebccf1e3SJoseph Koshy 
46ebccf1e3SJoseph Koshy #include <assert.h>
470b86b1bbSFabien Thomas #include <curses.h>
48ebccf1e3SJoseph Koshy #include <err.h>
49ebccf1e3SJoseph Koshy #include <errno.h>
50ebccf1e3SJoseph Koshy #include <fcntl.h>
51fbd8b34aSJoseph Koshy #include <kvm.h>
5249874f6eSJoseph Koshy #include <libgen.h>
53ebccf1e3SJoseph Koshy #include <limits.h>
54ebccf1e3SJoseph Koshy #include <math.h>
55ebccf1e3SJoseph Koshy #include <pmc.h>
56f263522aSJoseph Koshy #include <pmclog.h>
57fbd8b34aSJoseph Koshy #include <regex.h>
58ebccf1e3SJoseph Koshy #include <signal.h>
59ebccf1e3SJoseph Koshy #include <stdarg.h>
60ebccf1e3SJoseph Koshy #include <stdint.h>
6115139246SJoseph Koshy #include <stdio.h>
62ebccf1e3SJoseph Koshy #include <stdlib.h>
63ebccf1e3SJoseph Koshy #include <string.h>
64ebccf1e3SJoseph Koshy #include <sysexits.h>
65ebccf1e3SJoseph Koshy #include <unistd.h>
66ebccf1e3SJoseph Koshy 
6715139246SJoseph Koshy #include "pmcstat.h"
6815139246SJoseph Koshy 
69f263522aSJoseph Koshy /*
70f263522aSJoseph Koshy  * A given invocation of pmcstat(8) can manage multiple PMCs of both
71f263522aSJoseph Koshy  * the system-wide and per-process variety.  Each of these could be in
72f263522aSJoseph Koshy  * 'counting mode' or in 'sampling mode'.
73f263522aSJoseph Koshy  *
74f263522aSJoseph Koshy  * For 'counting mode' PMCs, pmcstat(8) will periodically issue a
75f263522aSJoseph Koshy  * pmc_read() at the configured time interval and print out the value
76f263522aSJoseph Koshy  * of the requested PMCs.
77f263522aSJoseph Koshy  *
78f263522aSJoseph Koshy  * For 'sampling mode' PMCs it can log to a file for offline analysis,
79f263522aSJoseph Koshy  * or can analyse sampling data "on the fly", either by converting
80f263522aSJoseph Koshy  * samples to printed textual form or by creating gprof(1) compatible
81f263522aSJoseph Koshy  * profiles, one per program executed.  When creating gprof(1)
82f263522aSJoseph Koshy  * profiles it can optionally merge entries from multiple processes
83f263522aSJoseph Koshy  * for a given executable into a single profile file.
84ee4910b1SJoseph Koshy  *
85ee4910b1SJoseph Koshy  * pmcstat(8) can also execute a command line and attach PMCs to the
86ee4910b1SJoseph Koshy  * resulting child process.  The protocol used is as follows:
87ee4910b1SJoseph Koshy  *
88ee4910b1SJoseph Koshy  * - parent creates a socketpair for two way communication and
89ee4910b1SJoseph Koshy  *   fork()s.
90ee4910b1SJoseph Koshy  * - subsequently:
91ee4910b1SJoseph Koshy  *
92ee4910b1SJoseph Koshy  *   /Parent/				/Child/
93ee4910b1SJoseph Koshy  *
94ee4910b1SJoseph Koshy  *   - Wait for childs token.
95ee4910b1SJoseph Koshy  *					- Sends token.
96ee4910b1SJoseph Koshy  *					- Awaits signal to start.
97ee4910b1SJoseph Koshy  *  - Attaches PMCs to the child's pid
98ee4910b1SJoseph Koshy  *    and starts them. Sets up
99ee4910b1SJoseph Koshy  *    monitoring for the child.
100ee4910b1SJoseph Koshy  *  - Signals child to start.
101ee4910b1SJoseph Koshy  *					- Recieves signal, attempts exec().
102ee4910b1SJoseph Koshy  *
103ee4910b1SJoseph Koshy  * After this point normal processing can happen.
104f263522aSJoseph Koshy  */
105f263522aSJoseph Koshy 
10615139246SJoseph Koshy /* Globals */
107ebccf1e3SJoseph Koshy 
108ebccf1e3SJoseph Koshy int	pmcstat_interrupt = 0;
109ebccf1e3SJoseph Koshy int	pmcstat_displayheight = DEFAULT_DISPLAY_HEIGHT;
1100b86b1bbSFabien Thomas int	pmcstat_displaywidth  = DEFAULT_DISPLAY_WIDTH;
111ee4910b1SJoseph Koshy int	pmcstat_sockpair[NSOCKPAIRFD];
112ebccf1e3SJoseph Koshy int	pmcstat_kq;
113fbd8b34aSJoseph Koshy kvm_t	*pmcstat_kvm;
114fbd8b34aSJoseph Koshy struct kinfo_proc *pmcstat_plist;
1150b86b1bbSFabien Thomas struct pmcstat_args args;
116ebccf1e3SJoseph Koshy 
117ee4910b1SJoseph Koshy void
1180b86b1bbSFabien Thomas pmcstat_attach_pmcs(void)
119ee4910b1SJoseph Koshy {
120ee4910b1SJoseph Koshy 	struct pmcstat_ev *ev;
121fbd8b34aSJoseph Koshy 	struct pmcstat_target *pt;
122fbd8b34aSJoseph Koshy 	int count;
123ee4910b1SJoseph Koshy 
124fbd8b34aSJoseph Koshy 	/* Attach all process PMCs to target processes. */
125fbd8b34aSJoseph Koshy 	count = 0;
1260b86b1bbSFabien Thomas 	STAILQ_FOREACH(ev, &args.pa_events, ev_next) {
127fbd8b34aSJoseph Koshy 		if (PMC_IS_SYSTEM_MODE(ev->ev_mode))
128fbd8b34aSJoseph Koshy 			continue;
1290b86b1bbSFabien Thomas 		SLIST_FOREACH(pt, &args.pa_targets, pt_next)
130fbd8b34aSJoseph Koshy 			if (pmc_attach(ev->ev_pmcid, pt->pt_pid) == 0)
131fbd8b34aSJoseph Koshy 				count++;
132fbd8b34aSJoseph Koshy 			else if (errno != ESRCH)
133fbd8b34aSJoseph Koshy 				err(EX_OSERR, "ERROR: cannot attach pmc "
134fbd8b34aSJoseph Koshy 				    "\"%s\" to process %d", ev->ev_name,
135fbd8b34aSJoseph Koshy 				    (int) pt->pt_pid);
136fbd8b34aSJoseph Koshy 	}
137ee4910b1SJoseph Koshy 
138fbd8b34aSJoseph Koshy 	if (count == 0)
139fbd8b34aSJoseph Koshy 		errx(EX_DATAERR, "ERROR: No processes were attached to.");
140ee4910b1SJoseph Koshy }
141ee4910b1SJoseph Koshy 
142ebccf1e3SJoseph Koshy 
143ebccf1e3SJoseph Koshy void
1440b86b1bbSFabien Thomas pmcstat_cleanup(void)
145ebccf1e3SJoseph Koshy {
146ebccf1e3SJoseph Koshy 	struct pmcstat_ev *ev, *tmp;
147ebccf1e3SJoseph Koshy 
148ebccf1e3SJoseph Koshy 	/* release allocated PMCs. */
1490b86b1bbSFabien Thomas 	STAILQ_FOREACH_SAFE(ev, &args.pa_events, ev_next, tmp)
150ebccf1e3SJoseph Koshy 	    if (ev->ev_pmcid != PMC_ID_INVALID) {
151b8fbd97bSJoseph Koshy 		if (pmc_stop(ev->ev_pmcid) < 0)
152b8fbd97bSJoseph Koshy 			err(EX_OSERR, "ERROR: cannot stop pmc 0x%x "
153b8fbd97bSJoseph Koshy 			    "\"%s\"", ev->ev_pmcid, ev->ev_name);
154ebccf1e3SJoseph Koshy 		if (pmc_release(ev->ev_pmcid) < 0)
155ebccf1e3SJoseph Koshy 			err(EX_OSERR, "ERROR: cannot release pmc "
156f263522aSJoseph Koshy 			    "0x%x \"%s\"", ev->ev_pmcid, ev->ev_name);
157ebccf1e3SJoseph Koshy 		free(ev->ev_name);
158ebccf1e3SJoseph Koshy 		free(ev->ev_spec);
1590b86b1bbSFabien Thomas 		STAILQ_REMOVE(&args.pa_events, ev, pmcstat_ev, ev_next);
160ebccf1e3SJoseph Koshy 		free(ev);
161ebccf1e3SJoseph Koshy 	    }
162f263522aSJoseph Koshy 
163dc1d9d2eSJoseph Koshy 	/* de-configure the log file if present. */
1640b86b1bbSFabien Thomas 	if (args.pa_flags & (FLAG_HAS_PIPE | FLAG_HAS_OUTPUT_LOGFILE))
165dc1d9d2eSJoseph Koshy 		(void) pmc_configure_logfile(-1);
166dc1d9d2eSJoseph Koshy 
1670b86b1bbSFabien Thomas 	if (args.pa_logparser) {
1680b86b1bbSFabien Thomas 		pmclog_close(args.pa_logparser);
1690b86b1bbSFabien Thomas 		args.pa_logparser = NULL;
170f263522aSJoseph Koshy 	}
17115139246SJoseph Koshy 
1720b86b1bbSFabien Thomas 	if (args.pa_flags & (FLAG_HAS_PIPE | FLAG_HAS_OUTPUT_LOGFILE))
1730b86b1bbSFabien Thomas 		pmcstat_shutdown_logging();
174ebccf1e3SJoseph Koshy }
175ebccf1e3SJoseph Koshy 
176ebccf1e3SJoseph Koshy void
1770b86b1bbSFabien Thomas pmcstat_clone_event_descriptor(struct pmcstat_ev *ev,
178ee4910b1SJoseph Koshy     uint32_t cpumask)
179ee4910b1SJoseph Koshy {
180ee4910b1SJoseph Koshy 	int cpu;
181ee4910b1SJoseph Koshy 	struct pmcstat_ev *ev_clone;
182ee4910b1SJoseph Koshy 
183ee4910b1SJoseph Koshy 	while ((cpu = ffs(cpumask)) > 0) {
184ee4910b1SJoseph Koshy 		cpu--;
185ee4910b1SJoseph Koshy 
186ee4910b1SJoseph Koshy 		if ((ev_clone = malloc(sizeof(*ev_clone))) == NULL)
187ee4910b1SJoseph Koshy 			errx(EX_SOFTWARE, "ERROR: Out of memory");
188ee4910b1SJoseph Koshy 		(void) memset(ev_clone, 0, sizeof(*ev_clone));
189ee4910b1SJoseph Koshy 
190ee4910b1SJoseph Koshy 		ev_clone->ev_count = ev->ev_count;
191ee4910b1SJoseph Koshy 		ev_clone->ev_cpu   = cpu;
192ee4910b1SJoseph Koshy 		ev_clone->ev_cumulative = ev->ev_cumulative;
193ee4910b1SJoseph Koshy 		ev_clone->ev_flags = ev->ev_flags;
194ee4910b1SJoseph Koshy 		ev_clone->ev_mode  = ev->ev_mode;
195ee4910b1SJoseph Koshy 		ev_clone->ev_name  = strdup(ev->ev_name);
196ee4910b1SJoseph Koshy 		ev_clone->ev_pmcid = ev->ev_pmcid;
197ee4910b1SJoseph Koshy 		ev_clone->ev_saved = ev->ev_saved;
198ee4910b1SJoseph Koshy 		ev_clone->ev_spec  = strdup(ev->ev_spec);
199ee4910b1SJoseph Koshy 
2000b86b1bbSFabien Thomas 		STAILQ_INSERT_TAIL(&args.pa_events, ev_clone, ev_next);
201ee4910b1SJoseph Koshy 
202ee4910b1SJoseph Koshy 		cpumask &= ~(1 << cpu);
203ee4910b1SJoseph Koshy 	}
204ee4910b1SJoseph Koshy }
205ee4910b1SJoseph Koshy 
206ee4910b1SJoseph Koshy void
2070b86b1bbSFabien Thomas pmcstat_create_process(void)
208ee4910b1SJoseph Koshy {
209ee4910b1SJoseph Koshy 	char token;
210fbd8b34aSJoseph Koshy 	pid_t pid;
211ee4910b1SJoseph Koshy 	struct kevent kev;
212fbd8b34aSJoseph Koshy 	struct pmcstat_target *pt;
213ee4910b1SJoseph Koshy 
214ee4910b1SJoseph Koshy 	if (socketpair(AF_UNIX, SOCK_STREAM, 0, pmcstat_sockpair) < 0)
215ee4910b1SJoseph Koshy 		err(EX_OSERR, "ERROR: cannot create socket pair");
216ee4910b1SJoseph Koshy 
217fbd8b34aSJoseph Koshy 	switch (pid = fork()) {
218ee4910b1SJoseph Koshy 	case -1:
219ee4910b1SJoseph Koshy 		err(EX_OSERR, "ERROR: cannot fork");
220ee4910b1SJoseph Koshy 		/*NOTREACHED*/
221ee4910b1SJoseph Koshy 
222ee4910b1SJoseph Koshy 	case 0:		/* child */
223ee4910b1SJoseph Koshy 		(void) close(pmcstat_sockpair[PARENTSOCKET]);
224ee4910b1SJoseph Koshy 
225ee4910b1SJoseph Koshy 		/* Write a token to tell our parent we've started executing. */
226ee4910b1SJoseph Koshy 		if (write(pmcstat_sockpair[CHILDSOCKET], "+", 1) != 1)
227ee4910b1SJoseph Koshy 			err(EX_OSERR, "ERROR (child): cannot write token");
228ee4910b1SJoseph Koshy 
229ee4910b1SJoseph Koshy 		/* Wait for our parent to signal us to start. */
230ee4910b1SJoseph Koshy 		if (read(pmcstat_sockpair[CHILDSOCKET], &token, 1) < 0)
231ee4910b1SJoseph Koshy 			err(EX_OSERR, "ERROR (child): cannot read token");
232ee4910b1SJoseph Koshy 		(void) close(pmcstat_sockpair[CHILDSOCKET]);
233ee4910b1SJoseph Koshy 
234ee4910b1SJoseph Koshy 		/* exec() the program requested */
2350b86b1bbSFabien Thomas 		execvp(*args.pa_argv, args.pa_argv);
236ee4910b1SJoseph Koshy 		/* and if that fails, notify the parent */
237ee4910b1SJoseph Koshy 		kill(getppid(), SIGCHLD);
2380b86b1bbSFabien Thomas 		err(EX_OSERR, "ERROR: execvp \"%s\" failed", *args.pa_argv);
239ee4910b1SJoseph Koshy 		/*NOTREACHED*/
240ee4910b1SJoseph Koshy 
241ee4910b1SJoseph Koshy 	default:	/* parent */
242ee4910b1SJoseph Koshy 		(void) close(pmcstat_sockpair[CHILDSOCKET]);
243ee4910b1SJoseph Koshy 		break;
244ee4910b1SJoseph Koshy 	}
245ee4910b1SJoseph Koshy 
246ee4910b1SJoseph Koshy 	/* Ask to be notified via a kevent when the target process exits. */
247fbd8b34aSJoseph Koshy 	EV_SET(&kev, pid, EVFILT_PROC, EV_ADD|EV_ONESHOT, NOTE_EXIT, 0,
248ee4910b1SJoseph Koshy 	    NULL);
249ee4910b1SJoseph Koshy 	if (kevent(pmcstat_kq, &kev, 1, NULL, 0, NULL) < 0)
250fbd8b34aSJoseph Koshy 		err(EX_OSERR, "ERROR: cannot monitor child process %d", pid);
251fbd8b34aSJoseph Koshy 
252fbd8b34aSJoseph Koshy 	if ((pt = malloc(sizeof(*pt))) == NULL)
253fbd8b34aSJoseph Koshy 		errx(EX_SOFTWARE, "ERROR: Out of memory.");
254fbd8b34aSJoseph Koshy 
255fbd8b34aSJoseph Koshy 	pt->pt_pid = pid;
2560b86b1bbSFabien Thomas 	SLIST_INSERT_HEAD(&args.pa_targets, pt, pt_next);
257ee4910b1SJoseph Koshy 
258ee4910b1SJoseph Koshy 	/* Wait for the child to signal that its ready to go. */
259ee4910b1SJoseph Koshy 	if (read(pmcstat_sockpair[PARENTSOCKET], &token, 1) < 0)
260ee4910b1SJoseph Koshy 		err(EX_OSERR, "ERROR (parent): cannot read token");
261ee4910b1SJoseph Koshy 
262ee4910b1SJoseph Koshy 	return;
263ee4910b1SJoseph Koshy }
264ee4910b1SJoseph Koshy 
265fbd8b34aSJoseph Koshy void
2660b86b1bbSFabien Thomas pmcstat_find_targets(const char *spec)
267fbd8b34aSJoseph Koshy {
268fbd8b34aSJoseph Koshy 	int n, nproc, pid, rv;
269fbd8b34aSJoseph Koshy 	struct pmcstat_target *pt;
270fbd8b34aSJoseph Koshy 	char errbuf[_POSIX2_LINE_MAX], *end;
271fbd8b34aSJoseph Koshy 	static struct kinfo_proc *kp;
272fbd8b34aSJoseph Koshy 	regex_t reg;
273fbd8b34aSJoseph Koshy 	regmatch_t regmatch;
274fbd8b34aSJoseph Koshy 
275fbd8b34aSJoseph Koshy 	/* First check if we've been given a process id. */
276fbd8b34aSJoseph Koshy       	pid = strtol(spec, &end, 0);
277fbd8b34aSJoseph Koshy 	if (end != spec && pid >= 0) {
278fbd8b34aSJoseph Koshy 		if ((pt = malloc(sizeof(*pt))) == NULL)
279fbd8b34aSJoseph Koshy 			goto outofmemory;
280fbd8b34aSJoseph Koshy 		pt->pt_pid = pid;
2810b86b1bbSFabien Thomas 		SLIST_INSERT_HEAD(&args.pa_targets, pt, pt_next);
282fbd8b34aSJoseph Koshy 		return;
283fbd8b34aSJoseph Koshy 	}
284fbd8b34aSJoseph Koshy 
285fbd8b34aSJoseph Koshy 	/* Otherwise treat arg as a regular expression naming processes. */
286fbd8b34aSJoseph Koshy 	if (pmcstat_kvm == NULL) {
287fbd8b34aSJoseph Koshy 		if ((pmcstat_kvm = kvm_openfiles(NULL, "/dev/null", NULL, 0,
288fbd8b34aSJoseph Koshy 		    errbuf)) == NULL)
289fbd8b34aSJoseph Koshy 			err(EX_OSERR, "ERROR: Cannot open kernel \"%s\"",
290fbd8b34aSJoseph Koshy 			    errbuf);
291fbd8b34aSJoseph Koshy 		if ((pmcstat_plist = kvm_getprocs(pmcstat_kvm, KERN_PROC_PROC,
292fbd8b34aSJoseph Koshy 		    0, &nproc)) == NULL)
293fbd8b34aSJoseph Koshy 			err(EX_OSERR, "ERROR: Cannot get process list: %s",
294fbd8b34aSJoseph Koshy 			    kvm_geterr(pmcstat_kvm));
295fbd8b34aSJoseph Koshy 	}
296fbd8b34aSJoseph Koshy 
297fbd8b34aSJoseph Koshy 	if ((rv = regcomp(&reg, spec, REG_EXTENDED|REG_NOSUB)) != 0) {
298fbd8b34aSJoseph Koshy 		regerror(rv, &reg, errbuf, sizeof(errbuf));
299fbd8b34aSJoseph Koshy 		err(EX_DATAERR, "ERROR: Failed to compile regex \"%s\": %s",
300fbd8b34aSJoseph Koshy 		    spec, errbuf);
301fbd8b34aSJoseph Koshy 	}
302fbd8b34aSJoseph Koshy 
303fbd8b34aSJoseph Koshy 	for (n = 0, kp = pmcstat_plist; n < nproc; n++, kp++) {
304fbd8b34aSJoseph Koshy 		if ((rv = regexec(&reg, kp->ki_comm, 1, &regmatch, 0)) == 0) {
305fbd8b34aSJoseph Koshy 			if ((pt = malloc(sizeof(*pt))) == NULL)
306fbd8b34aSJoseph Koshy 				goto outofmemory;
307fbd8b34aSJoseph Koshy 			pt->pt_pid = kp->ki_pid;
3080b86b1bbSFabien Thomas 			SLIST_INSERT_HEAD(&args.pa_targets, pt, pt_next);
309fbd8b34aSJoseph Koshy 		} else if (rv != REG_NOMATCH) {
310fbd8b34aSJoseph Koshy 			regerror(rv, &reg, errbuf, sizeof(errbuf));
311fbd8b34aSJoseph Koshy 			errx(EX_SOFTWARE, "ERROR: Regex evalation failed: %s",
312fbd8b34aSJoseph Koshy 			    errbuf);
313fbd8b34aSJoseph Koshy 		}
314fbd8b34aSJoseph Koshy 	}
315fbd8b34aSJoseph Koshy 
316fbd8b34aSJoseph Koshy 	regfree(&reg);
317fbd8b34aSJoseph Koshy 
318fbd8b34aSJoseph Koshy 	return;
319fbd8b34aSJoseph Koshy 
320fbd8b34aSJoseph Koshy  outofmemory:
321fbd8b34aSJoseph Koshy 	errx(EX_SOFTWARE, "Out of memory.");
322fbd8b34aSJoseph Koshy 	/*NOTREACHED*/
323fbd8b34aSJoseph Koshy }
324fbd8b34aSJoseph Koshy 
325ee4910b1SJoseph Koshy uint32_t
326ee4910b1SJoseph Koshy pmcstat_get_cpumask(const char *cpuspec)
327ee4910b1SJoseph Koshy {
328ee4910b1SJoseph Koshy 	uint32_t cpumask;
329ee4910b1SJoseph Koshy 	int cpu;
330ee4910b1SJoseph Koshy 	const char *s;
331ee4910b1SJoseph Koshy 	char *end;
332ee4910b1SJoseph Koshy 
333ee4910b1SJoseph Koshy 	s = cpuspec;
334ee4910b1SJoseph Koshy 	cpumask = 0ULL;
335ee4910b1SJoseph Koshy 
336ee4910b1SJoseph Koshy 	do {
337ee4910b1SJoseph Koshy 		cpu = strtol(s, &end, 0);
338ee4910b1SJoseph Koshy 		if (cpu < 0 || end == s)
339ee4910b1SJoseph Koshy 			errx(EX_USAGE, "ERROR: Illegal CPU specification "
340ee4910b1SJoseph Koshy 			    "\"%s\".", cpuspec);
341ee4910b1SJoseph Koshy 		cpumask |= (1 << cpu);
342ee4910b1SJoseph Koshy 		s = end + strspn(end, ", \t");
343ee4910b1SJoseph Koshy 	} while (*s);
344ee4910b1SJoseph Koshy 
345ee4910b1SJoseph Koshy 	return (cpumask);
346ee4910b1SJoseph Koshy }
347ee4910b1SJoseph Koshy 
348ee4910b1SJoseph Koshy void
3490b86b1bbSFabien Thomas pmcstat_kill_process(void)
350fbd8b34aSJoseph Koshy {
351fbd8b34aSJoseph Koshy 	struct pmcstat_target *pt;
352fbd8b34aSJoseph Koshy 
3530b86b1bbSFabien Thomas 	assert(args.pa_flags & FLAG_HAS_COMMANDLINE);
354fbd8b34aSJoseph Koshy 
355fbd8b34aSJoseph Koshy 	/*
356fbd8b34aSJoseph Koshy 	 * If a command line was specified, it would be the very first
357fbd8b34aSJoseph Koshy 	 * in the list, before any other processes specified by -t.
358fbd8b34aSJoseph Koshy 	 */
3590b86b1bbSFabien Thomas 	pt = SLIST_FIRST(&args.pa_targets);
360fbd8b34aSJoseph Koshy 	assert(pt != NULL);
361fbd8b34aSJoseph Koshy 
362fbd8b34aSJoseph Koshy 	if (kill(pt->pt_pid, SIGINT) != 0)
363fbd8b34aSJoseph Koshy 		err(EX_OSERR, "ERROR: cannot signal child process");
364fbd8b34aSJoseph Koshy }
365fbd8b34aSJoseph Koshy 
366fbd8b34aSJoseph Koshy void
3670b86b1bbSFabien Thomas pmcstat_start_pmcs(void)
368ebccf1e3SJoseph Koshy {
369ebccf1e3SJoseph Koshy 	struct pmcstat_ev *ev;
370ebccf1e3SJoseph Koshy 
371fbd8b34aSJoseph Koshy 	STAILQ_FOREACH(ev, &args.pa_events, ev_next) {
372ebccf1e3SJoseph Koshy 
373ebccf1e3SJoseph Koshy 	    assert(ev->ev_pmcid != PMC_ID_INVALID);
374ebccf1e3SJoseph Koshy 
375ebccf1e3SJoseph Koshy 	    if (pmc_start(ev->ev_pmcid) < 0) {
376f263522aSJoseph Koshy 	        warn("ERROR: Cannot start pmc 0x%x \"%s\"",
377ebccf1e3SJoseph Koshy 		    ev->ev_pmcid, ev->ev_name);
3780b86b1bbSFabien Thomas 		pmcstat_cleanup();
379f263522aSJoseph Koshy 		exit(EX_OSERR);
380ebccf1e3SJoseph Koshy 	    }
381ebccf1e3SJoseph Koshy 	}
382ebccf1e3SJoseph Koshy 
383ebccf1e3SJoseph Koshy }
384ebccf1e3SJoseph Koshy 
385ebccf1e3SJoseph Koshy void
3860b86b1bbSFabien Thomas pmcstat_print_headers(void)
387ebccf1e3SJoseph Koshy {
388ebccf1e3SJoseph Koshy 	struct pmcstat_ev *ev;
389ee4910b1SJoseph Koshy 	int c, w;
390ebccf1e3SJoseph Koshy 
3910b86b1bbSFabien Thomas 	(void) fprintf(args.pa_printfile, PRINT_HEADER_PREFIX);
392ebccf1e3SJoseph Koshy 
3930b86b1bbSFabien Thomas 	STAILQ_FOREACH(ev, &args.pa_events, ev_next) {
394ebccf1e3SJoseph Koshy 		if (PMC_IS_SAMPLING_MODE(ev->ev_mode))
395ebccf1e3SJoseph Koshy 			continue;
396ebccf1e3SJoseph Koshy 
397ebccf1e3SJoseph Koshy 		c = PMC_IS_SYSTEM_MODE(ev->ev_mode) ? 's' : 'p';
398ebccf1e3SJoseph Koshy 
399ee4910b1SJoseph Koshy 		if (ev->ev_fieldskip != 0)
4000b86b1bbSFabien Thomas 			(void) fprintf(args.pa_printfile, "%*s",
401ee4910b1SJoseph Koshy 			    ev->ev_fieldskip, "");
402ee4910b1SJoseph Koshy 		w = ev->ev_fieldwidth - ev->ev_fieldskip - 2;
403ee4910b1SJoseph Koshy 
404ee4910b1SJoseph Koshy 		if (c == 's')
4050b86b1bbSFabien Thomas 			(void) fprintf(args.pa_printfile, "s/%02d/%-*s ",
406ee4910b1SJoseph Koshy 			    ev->ev_cpu, w-3, ev->ev_name);
407ee4910b1SJoseph Koshy 		else
4080b86b1bbSFabien Thomas 			(void) fprintf(args.pa_printfile, "p/%*s ", w,
409ebccf1e3SJoseph Koshy 			    ev->ev_name);
410ebccf1e3SJoseph Koshy 	}
411ebccf1e3SJoseph Koshy 
4120b86b1bbSFabien Thomas 	(void) fflush(args.pa_printfile);
413ebccf1e3SJoseph Koshy }
414ebccf1e3SJoseph Koshy 
415ebccf1e3SJoseph Koshy void
4160b86b1bbSFabien Thomas pmcstat_print_counters(void)
417ebccf1e3SJoseph Koshy {
418ebccf1e3SJoseph Koshy 	int extra_width;
419ebccf1e3SJoseph Koshy 	struct pmcstat_ev *ev;
420ebccf1e3SJoseph Koshy 	pmc_value_t value;
421ebccf1e3SJoseph Koshy 
422ebccf1e3SJoseph Koshy 	extra_width = sizeof(PRINT_HEADER_PREFIX) - 1;
423ebccf1e3SJoseph Koshy 
4240b86b1bbSFabien Thomas 	STAILQ_FOREACH(ev, &args.pa_events, ev_next) {
425ebccf1e3SJoseph Koshy 
426ebccf1e3SJoseph Koshy 		/* skip sampling mode counters */
427ebccf1e3SJoseph Koshy 		if (PMC_IS_SAMPLING_MODE(ev->ev_mode))
428ebccf1e3SJoseph Koshy 			continue;
429ebccf1e3SJoseph Koshy 
430ebccf1e3SJoseph Koshy 		if (pmc_read(ev->ev_pmcid, &value) < 0)
431ebccf1e3SJoseph Koshy 			err(EX_OSERR, "ERROR: Cannot read pmc "
432ebccf1e3SJoseph Koshy 			    "\"%s\"", ev->ev_name);
433ebccf1e3SJoseph Koshy 
4340b86b1bbSFabien Thomas 		(void) fprintf(args.pa_printfile, "%*ju ",
43515139246SJoseph Koshy 		    ev->ev_fieldwidth + extra_width,
43615139246SJoseph Koshy 		    (uintmax_t) ev->ev_cumulative ? value :
43715139246SJoseph Koshy 		    (value - ev->ev_saved));
43815139246SJoseph Koshy 
439ebccf1e3SJoseph Koshy 		if (ev->ev_cumulative == 0)
440ebccf1e3SJoseph Koshy 			ev->ev_saved = value;
441ebccf1e3SJoseph Koshy 		extra_width = 0;
442ebccf1e3SJoseph Koshy 	}
443ebccf1e3SJoseph Koshy 
4440b86b1bbSFabien Thomas 	(void) fflush(args.pa_printfile);
445ebccf1e3SJoseph Koshy }
446ebccf1e3SJoseph Koshy 
447ebccf1e3SJoseph Koshy /*
448ebccf1e3SJoseph Koshy  * Print output
449ebccf1e3SJoseph Koshy  */
450ebccf1e3SJoseph Koshy 
451ebccf1e3SJoseph Koshy void
4520b86b1bbSFabien Thomas pmcstat_print_pmcs(void)
453ebccf1e3SJoseph Koshy {
454ebccf1e3SJoseph Koshy 	static int linecount = 0;
455ebccf1e3SJoseph Koshy 
45615139246SJoseph Koshy 	/* check if we need to print a header line */
457ebccf1e3SJoseph Koshy 	if (++linecount > pmcstat_displayheight) {
4580b86b1bbSFabien Thomas 		(void) fprintf(args.pa_printfile, "\n");
459ebccf1e3SJoseph Koshy 		linecount = 1;
460ebccf1e3SJoseph Koshy 	}
461ebccf1e3SJoseph Koshy 	if (linecount == 1)
4620b86b1bbSFabien Thomas 		pmcstat_print_headers();
4630b86b1bbSFabien Thomas 	(void) fprintf(args.pa_printfile, "\n");
464ebccf1e3SJoseph Koshy 
4650b86b1bbSFabien Thomas 	pmcstat_print_counters();
466ebccf1e3SJoseph Koshy 
467ebccf1e3SJoseph Koshy 	return;
468ebccf1e3SJoseph Koshy }
469ebccf1e3SJoseph Koshy 
470ebccf1e3SJoseph Koshy /*
471ebccf1e3SJoseph Koshy  * Do process profiling
472ebccf1e3SJoseph Koshy  *
473ebccf1e3SJoseph Koshy  * If a pid was specified, attach each allocated PMC to the target
474ebccf1e3SJoseph Koshy  * process.  Otherwise, fork a child and attach the PMCs to the child,
475ebccf1e3SJoseph Koshy  * and have the child exec() the target program.
476ebccf1e3SJoseph Koshy  */
477ebccf1e3SJoseph Koshy 
478ebccf1e3SJoseph Koshy void
479ee4910b1SJoseph Koshy pmcstat_start_process(void)
480ebccf1e3SJoseph Koshy {
481ee4910b1SJoseph Koshy 	/* Signal the child to proceed. */
482ee4910b1SJoseph Koshy 	if (write(pmcstat_sockpair[PARENTSOCKET], "!", 1) != 1)
483ee4910b1SJoseph Koshy 		err(EX_OSERR, "ERROR (parent): write of token failed");
484ebccf1e3SJoseph Koshy 
485ee4910b1SJoseph Koshy 	(void) close(pmcstat_sockpair[PARENTSOCKET]);
486ebccf1e3SJoseph Koshy }
487ebccf1e3SJoseph Koshy 
488ebccf1e3SJoseph Koshy void
489ebccf1e3SJoseph Koshy pmcstat_show_usage(void)
490ebccf1e3SJoseph Koshy {
491ebccf1e3SJoseph Koshy 	errx(EX_USAGE,
492ebccf1e3SJoseph Koshy 	    "[options] [commandline]\n"
493ebccf1e3SJoseph Koshy 	    "\t Measure process and/or system performance using hardware\n"
494ebccf1e3SJoseph Koshy 	    "\t performance monitoring counters.\n"
495ebccf1e3SJoseph Koshy 	    "\t Options include:\n"
496f263522aSJoseph Koshy 	    "\t -C\t\t (toggle) show cumulative counts\n"
497f263522aSJoseph Koshy 	    "\t -D path\t create profiles in directory \"path\"\n"
498f263522aSJoseph Koshy 	    "\t -E\t\t (toggle) show counts at process exit\n"
4990b86b1bbSFabien Thomas 	    "\t -F file\t write a system-wide callgraph (Kcachegrind format)"
5000b86b1bbSFabien Thomas 		" to \"file\"\n"
501b6010f9eSJoseph Koshy 	    "\t -G file\t write a system-wide callgraph to \"file\"\n"
50249874f6eSJoseph Koshy 	    "\t -M file\t print executable/gmon file map to \"file\"\n"
503b6010f9eSJoseph Koshy 	    "\t -N\t\t (toggle) capture callchains\n"
504f263522aSJoseph Koshy 	    "\t -O file\t send log output to \"file\"\n"
505f263522aSJoseph Koshy 	    "\t -P spec\t allocate a process-private sampling PMC\n"
506f263522aSJoseph Koshy 	    "\t -R file\t read events from \"file\"\n"
507f263522aSJoseph Koshy 	    "\t -S spec\t allocate a system-wide sampling PMC\n"
5080b86b1bbSFabien Thomas 	    "\t -T\t\t start in top mode\n"
509f263522aSJoseph Koshy 	    "\t -W\t\t (toggle) show counts per context switch\n"
510ee4910b1SJoseph Koshy 	    "\t -c cpu-list\t set cpus for subsequent system-wide PMCs\n"
511f263522aSJoseph Koshy 	    "\t -d\t\t (toggle) track descendants\n"
5120b86b1bbSFabien Thomas 	    "\t -f spec\t pass \"spec\" to as plugin option\n"
513f263522aSJoseph Koshy 	    "\t -g\t\t produce gprof(1) compatible profiles\n"
51424bffe06SRuslan Ermilov 	    "\t -k dir\t\t set the path to the kernel\n"
515ebccf1e3SJoseph Koshy 	    "\t -n rate\t set sampling rate\n"
516ebccf1e3SJoseph Koshy 	    "\t -o file\t send print output to \"file\"\n"
517f263522aSJoseph Koshy 	    "\t -p spec\t allocate a process-private counting PMC\n"
51849874f6eSJoseph Koshy 	    "\t -q\t\t suppress verbosity\n"
51949874f6eSJoseph Koshy 	    "\t -r fsroot\t specify FS root directory\n"
520f263522aSJoseph Koshy 	    "\t -s spec\t allocate a system-wide counting PMC\n"
52167442c6eSJoseph Koshy 	    "\t -t process-spec attach to running processes matching "
52267442c6eSJoseph Koshy 		"\"process-spec\"\n"
52349874f6eSJoseph Koshy 	    "\t -v\t\t increase verbosity\n"
524b6010f9eSJoseph Koshy 	    "\t -w secs\t set printing time interval\n"
525b6010f9eSJoseph Koshy 	    "\t -z depth\t limit callchain display depth"
526ebccf1e3SJoseph Koshy 	);
527ebccf1e3SJoseph Koshy }
528ebccf1e3SJoseph Koshy 
529ebccf1e3SJoseph Koshy /*
5300b86b1bbSFabien Thomas  * At exit handler for top mode
5310b86b1bbSFabien Thomas  */
5320b86b1bbSFabien Thomas 
5330b86b1bbSFabien Thomas void
5340b86b1bbSFabien Thomas pmcstat_topexit(void)
5350b86b1bbSFabien Thomas {
5360b86b1bbSFabien Thomas 	if (!args.pa_toptty)
5370b86b1bbSFabien Thomas 		return;
5380b86b1bbSFabien Thomas 
5390b86b1bbSFabien Thomas 	/*
5400b86b1bbSFabien Thomas 	 * Shutdown ncurses.
5410b86b1bbSFabien Thomas 	 */
5420b86b1bbSFabien Thomas 	clrtoeol();
5430b86b1bbSFabien Thomas 	refresh();
5440b86b1bbSFabien Thomas 	endwin();
5450b86b1bbSFabien Thomas }
5460b86b1bbSFabien Thomas 
5470b86b1bbSFabien Thomas /*
548ebccf1e3SJoseph Koshy  * Main
549ebccf1e3SJoseph Koshy  */
550ebccf1e3SJoseph Koshy 
551ebccf1e3SJoseph Koshy int
552ebccf1e3SJoseph Koshy main(int argc, char **argv)
553ebccf1e3SJoseph Koshy {
554ebccf1e3SJoseph Koshy 	double interval;
555b6010f9eSJoseph Koshy 	int option, npmc, ncpu, haltedcpus;
5567fbf3da2SJoseph Koshy 	int c, check_driver_stats, current_cpu, current_sampling_count;
557b6010f9eSJoseph Koshy 	int do_callchain, do_descendants, do_logproccsw, do_logprocexit;
558b6010f9eSJoseph Koshy 	int do_print;
559ee4910b1SJoseph Koshy 	size_t dummy;
560b6010f9eSJoseph Koshy 	int graphdepth;
561f263522aSJoseph Koshy 	int pipefd[2];
562f263522aSJoseph Koshy 	int use_cumulative_counts;
5630b86b1bbSFabien Thomas 	short cf, cb;
564ee4910b1SJoseph Koshy 	uint32_t cpumask;
56549874f6eSJoseph Koshy 	char *end, *tmp;
566b6010f9eSJoseph Koshy 	const char *errmsg, *graphfilename;
567f263522aSJoseph Koshy 	enum pmcstat_state runstate;
5687fbf3da2SJoseph Koshy 	struct pmc_driverstats ds_start, ds_end;
569ebccf1e3SJoseph Koshy 	struct pmcstat_ev *ev;
570ebccf1e3SJoseph Koshy 	struct sigaction sa;
571ebccf1e3SJoseph Koshy 	struct kevent kev;
572ebccf1e3SJoseph Koshy 	struct winsize ws;
57315139246SJoseph Koshy 	struct stat sb;
57449874f6eSJoseph Koshy 	char buffer[PATH_MAX];
575ebccf1e3SJoseph Koshy 
5767fbf3da2SJoseph Koshy 	check_driver_stats      = 0;
577ebccf1e3SJoseph Koshy 	current_cpu 		= 0;
578ebccf1e3SJoseph Koshy 	current_sampling_count  = DEFAULT_SAMPLE_COUNT;
579b6010f9eSJoseph Koshy 	do_callchain		= 1;
580ebccf1e3SJoseph Koshy 	do_descendants          = 0;
581f263522aSJoseph Koshy 	do_logproccsw           = 0;
582f263522aSJoseph Koshy 	do_logprocexit          = 0;
583ebccf1e3SJoseph Koshy 	use_cumulative_counts   = 0;
584b6010f9eSJoseph Koshy 	graphfilename		= "-";
585f263522aSJoseph Koshy 	args.pa_required	= 0;
586ebccf1e3SJoseph Koshy 	args.pa_flags		= 0;
58749874f6eSJoseph Koshy 	args.pa_verbosity	= 1;
58815139246SJoseph Koshy 	args.pa_logfd		= -1;
58949874f6eSJoseph Koshy 	args.pa_fsroot		= "";
59049874f6eSJoseph Koshy 	args.pa_kernel		= strdup("/boot/kernel");
59115139246SJoseph Koshy 	args.pa_samplesdir	= ".";
59215139246SJoseph Koshy 	args.pa_printfile	= stderr;
593b6010f9eSJoseph Koshy 	args.pa_graphdepth	= DEFAULT_CALLGRAPH_DEPTH;
594b6010f9eSJoseph Koshy 	args.pa_graphfile	= NULL;
595ebccf1e3SJoseph Koshy 	args.pa_interval	= DEFAULT_WAIT_INTERVAL;
59649874f6eSJoseph Koshy 	args.pa_mapfilename	= NULL;
597b6010f9eSJoseph Koshy 	args.pa_inputpath	= NULL;
598b6010f9eSJoseph Koshy 	args.pa_outputpath	= NULL;
5990b86b1bbSFabien Thomas 	args.pa_pplugin		= PMCSTAT_PL_NONE;
6000b86b1bbSFabien Thomas 	args.pa_plugin		= PMCSTAT_PL_NONE;
6010b86b1bbSFabien Thomas 	args.pa_ctdumpinstr	= 1;
6020b86b1bbSFabien Thomas 	args.pa_topmode		= PMCSTAT_TOP_DELTA;
6030b86b1bbSFabien Thomas 	args.pa_toptty		= 0;
6040b86b1bbSFabien Thomas 	args.pa_topcolor	= 0;
6050b86b1bbSFabien Thomas 	args.pa_mergepmc	= 0;
606fbd8b34aSJoseph Koshy 	STAILQ_INIT(&args.pa_events);
607fbd8b34aSJoseph Koshy 	SLIST_INIT(&args.pa_targets);
608bea6aa93SJoseph Koshy 	bzero(&ds_start, sizeof(ds_start));
609bea6aa93SJoseph Koshy 	bzero(&ds_end, sizeof(ds_end));
610ebccf1e3SJoseph Koshy 	ev = NULL;
611ebccf1e3SJoseph Koshy 
612b6010f9eSJoseph Koshy 	/*
613b6010f9eSJoseph Koshy 	 * The initial CPU mask specifies all non-halted CPUS in the
614b6010f9eSJoseph Koshy 	 * system.
615b6010f9eSJoseph Koshy 	 */
616b6010f9eSJoseph Koshy 	dummy = sizeof(int);
617ee4910b1SJoseph Koshy 	if (sysctlbyname("hw.ncpu", &ncpu, &dummy, NULL, 0) < 0)
618b6010f9eSJoseph Koshy 		err(EX_OSERR, "ERROR: Cannot determine the number of CPUs");
619ee4910b1SJoseph Koshy 	cpumask = (1 << ncpu) - 1;
6205477328dSJoseph Koshy 	haltedcpus = 0;
621bcba261aSJung-uk Kim 	if (ncpu > 1) {
622b6010f9eSJoseph Koshy 		if (sysctlbyname("machdep.hlt_cpus", &haltedcpus, &dummy,
623b6010f9eSJoseph Koshy 		    NULL, 0) < 0)
624bcba261aSJung-uk Kim 			err(EX_OSERR, "ERROR: Cannot determine which CPUs are "
625bcba261aSJung-uk Kim 			    "halted");
626b6010f9eSJoseph Koshy 		cpumask &= ~haltedcpus;
627bcba261aSJung-uk Kim 	}
628ee4910b1SJoseph Koshy 
62949874f6eSJoseph Koshy 	while ((option = getopt(argc, argv,
6300b86b1bbSFabien Thomas 	    "CD:EF:G:M:NO:P:R:S:TWc:df:gk:m:n:o:p:qr:s:t:vw:z:")) != -1)
631ebccf1e3SJoseph Koshy 		switch (option) {
632ebccf1e3SJoseph Koshy 		case 'C':	/* cumulative values */
633ebccf1e3SJoseph Koshy 			use_cumulative_counts = !use_cumulative_counts;
634f263522aSJoseph Koshy 			args.pa_required |= FLAG_HAS_COUNTING_PMCS;
635ebccf1e3SJoseph Koshy 			break;
636ebccf1e3SJoseph Koshy 
637ebccf1e3SJoseph Koshy 		case 'c':	/* CPU */
638ee4910b1SJoseph Koshy 
639ee4910b1SJoseph Koshy 			if (optarg[0] == '*' && optarg[1] == '\0')
6405477328dSJoseph Koshy 				cpumask = ((1 << ncpu) - 1) & ~haltedcpus;
641ee4910b1SJoseph Koshy 			else
642ee4910b1SJoseph Koshy 				cpumask = pmcstat_get_cpumask(optarg);
643ee4910b1SJoseph Koshy 
644f263522aSJoseph Koshy 			args.pa_required |= FLAG_HAS_SYSTEM_PMCS;
645ebccf1e3SJoseph Koshy 			break;
646ebccf1e3SJoseph Koshy 
64715139246SJoseph Koshy 		case 'D':
64815139246SJoseph Koshy 			if (stat(optarg, &sb) < 0)
64915139246SJoseph Koshy 				err(EX_OSERR, "ERROR: Cannot stat \"%s\"",
65015139246SJoseph Koshy 				    optarg);
65115139246SJoseph Koshy 			if (!S_ISDIR(sb.st_mode))
65215139246SJoseph Koshy 				errx(EX_USAGE, "ERROR: \"%s\" is not a "
653ee4910b1SJoseph Koshy 				    "directory.", optarg);
65415139246SJoseph Koshy 			args.pa_samplesdir = optarg;
65515139246SJoseph Koshy 			args.pa_flags     |= FLAG_HAS_SAMPLESDIR;
65615139246SJoseph Koshy 			args.pa_required  |= FLAG_DO_GPROF;
65715139246SJoseph Koshy 			break;
65815139246SJoseph Koshy 
659ebccf1e3SJoseph Koshy 		case 'd':	/* toggle descendents */
660ebccf1e3SJoseph Koshy 			do_descendants = !do_descendants;
661f263522aSJoseph Koshy 			args.pa_required |= FLAG_HAS_PROCESS_PMCS;
662f263522aSJoseph Koshy 			break;
663f263522aSJoseph Koshy 
6640b86b1bbSFabien Thomas 		case 'F':	/* produce a system-wide calltree */
6650b86b1bbSFabien Thomas 			args.pa_flags |= FLAG_DO_CALLGRAPHS;
6660b86b1bbSFabien Thomas 			args.pa_plugin = PMCSTAT_PL_CALLTREE;
6670b86b1bbSFabien Thomas 			graphfilename = optarg;
6680b86b1bbSFabien Thomas 			break;
6690b86b1bbSFabien Thomas 
6700b86b1bbSFabien Thomas 		case 'f':	/* plugins options */
6710b86b1bbSFabien Thomas 			if (args.pa_plugin == PMCSTAT_PL_NONE)
6720b86b1bbSFabien Thomas 				err(EX_USAGE, "ERROR: Need -g/-G/-m/-T.");
6730b86b1bbSFabien Thomas 			pmcstat_pluginconfigure_log(optarg);
6740b86b1bbSFabien Thomas 			break;
6750b86b1bbSFabien Thomas 
676b6010f9eSJoseph Koshy 		case 'G':	/* produce a system-wide callgraph */
677b6010f9eSJoseph Koshy 			args.pa_flags |= FLAG_DO_CALLGRAPHS;
6780b86b1bbSFabien Thomas 			args.pa_plugin = PMCSTAT_PL_CALLGRAPH;
679b6010f9eSJoseph Koshy 			graphfilename = optarg;
680b6010f9eSJoseph Koshy 			break;
681b6010f9eSJoseph Koshy 
682f263522aSJoseph Koshy 		case 'g':	/* produce gprof compatible profiles */
683f263522aSJoseph Koshy 			args.pa_flags |= FLAG_DO_GPROF;
6840b86b1bbSFabien Thomas 			args.pa_pplugin = PMCSTAT_PL_CALLGRAPH;
6850b86b1bbSFabien Thomas 			args.pa_plugin	= PMCSTAT_PL_GPROF;
686f263522aSJoseph Koshy 			break;
687f263522aSJoseph Koshy 
68815139246SJoseph Koshy 		case 'k':	/* pathname to the kernel */
68949874f6eSJoseph Koshy 			free(args.pa_kernel);
69049874f6eSJoseph Koshy 			args.pa_kernel = strdup(optarg);
691b6010f9eSJoseph Koshy 			args.pa_required |= FLAG_DO_ANALYSIS;
69215139246SJoseph Koshy 			args.pa_flags    |= FLAG_HAS_KERNELPATH;
693f263522aSJoseph Koshy 			break;
694f263522aSJoseph Koshy 
695c0252222SAttilio Rao 		case 'm':
6960b86b1bbSFabien Thomas 			args.pa_flags |= FLAG_DO_ANNOTATE;
6970b86b1bbSFabien Thomas 			args.pa_plugin = PMCSTAT_PL_ANNOTATE;
698c0252222SAttilio Rao 			graphfilename  = optarg;
699c0252222SAttilio Rao 			break;
700c0252222SAttilio Rao 
701f263522aSJoseph Koshy 		case 'E':	/* log process exit */
702f263522aSJoseph Koshy 			do_logprocexit = !do_logprocexit;
703f263522aSJoseph Koshy 			args.pa_required |= (FLAG_HAS_PROCESS_PMCS |
70415139246SJoseph Koshy 			    FLAG_HAS_COUNTING_PMCS | FLAG_HAS_OUTPUT_LOGFILE);
705ebccf1e3SJoseph Koshy 			break;
706ebccf1e3SJoseph Koshy 
70749874f6eSJoseph Koshy 		case 'M':	/* mapfile */
70849874f6eSJoseph Koshy 			args.pa_mapfilename = optarg;
70949874f6eSJoseph Koshy 			break;
71049874f6eSJoseph Koshy 
711b6010f9eSJoseph Koshy 		case 'N':
712b6010f9eSJoseph Koshy 			do_callchain = !do_callchain;
713b6010f9eSJoseph Koshy 			args.pa_required |= FLAG_HAS_SAMPLING_PMCS;
714b6010f9eSJoseph Koshy 			break;
715b6010f9eSJoseph Koshy 
716ebccf1e3SJoseph Koshy 		case 'p':	/* process virtual counting PMC */
717ebccf1e3SJoseph Koshy 		case 's':	/* system-wide counting PMC */
718ebccf1e3SJoseph Koshy 		case 'P':	/* process virtual sampling PMC */
719ebccf1e3SJoseph Koshy 		case 'S':	/* system-wide sampling PMC */
720ebccf1e3SJoseph Koshy 			if ((ev = malloc(sizeof(*ev))) == NULL)
721f263522aSJoseph Koshy 				errx(EX_SOFTWARE, "ERROR: Out of memory.");
722ebccf1e3SJoseph Koshy 
723ebccf1e3SJoseph Koshy 			switch (option) {
724ebccf1e3SJoseph Koshy 			case 'p': ev->ev_mode = PMC_MODE_TC; break;
725ebccf1e3SJoseph Koshy 			case 's': ev->ev_mode = PMC_MODE_SC; break;
726ebccf1e3SJoseph Koshy 			case 'P': ev->ev_mode = PMC_MODE_TS; break;
727ebccf1e3SJoseph Koshy 			case 'S': ev->ev_mode = PMC_MODE_SS; break;
728ebccf1e3SJoseph Koshy 			}
729ebccf1e3SJoseph Koshy 
730f263522aSJoseph Koshy 			if (option == 'P' || option == 'p') {
731f263522aSJoseph Koshy 				args.pa_flags |= FLAG_HAS_PROCESS_PMCS;
73215139246SJoseph Koshy 				args.pa_required |= (FLAG_HAS_COMMANDLINE |
733fbd8b34aSJoseph Koshy 				    FLAG_HAS_TARGET);
734f263522aSJoseph Koshy 			}
735ebccf1e3SJoseph Koshy 
736f263522aSJoseph Koshy 			if (option == 'P' || option == 'S') {
737f263522aSJoseph Koshy 				args.pa_flags |= FLAG_HAS_SAMPLING_PMCS;
73815139246SJoseph Koshy 				args.pa_required |= (FLAG_HAS_PIPE |
73915139246SJoseph Koshy 				    FLAG_HAS_OUTPUT_LOGFILE);
740f263522aSJoseph Koshy 			}
741ebccf1e3SJoseph Koshy 
742ebccf1e3SJoseph Koshy 			if (option == 'p' || option == 's')
743f263522aSJoseph Koshy 				args.pa_flags |= FLAG_HAS_COUNTING_PMCS;
744f263522aSJoseph Koshy 
745f263522aSJoseph Koshy 			if (option == 's' || option == 'S')
746f263522aSJoseph Koshy 				args.pa_flags |= FLAG_HAS_SYSTEM_PMCS;
747ebccf1e3SJoseph Koshy 
748ebccf1e3SJoseph Koshy 			ev->ev_spec  = strdup(optarg);
749ebccf1e3SJoseph Koshy 
750ebccf1e3SJoseph Koshy 			if (option == 'S' || option == 'P')
751ebccf1e3SJoseph Koshy 				ev->ev_count = current_sampling_count;
752ebccf1e3SJoseph Koshy 			else
753ebccf1e3SJoseph Koshy 				ev->ev_count = -1;
754ebccf1e3SJoseph Koshy 
755ebccf1e3SJoseph Koshy 			if (option == 'S' || option == 's')
756ee4910b1SJoseph Koshy 				ev->ev_cpu = ffs(cpumask) - 1;
757ebccf1e3SJoseph Koshy 			else
758ebccf1e3SJoseph Koshy 				ev->ev_cpu = PMC_CPU_ANY;
759ebccf1e3SJoseph Koshy 
760f263522aSJoseph Koshy 			ev->ev_flags = 0;
761b6010f9eSJoseph Koshy 			if (do_callchain)
762b6010f9eSJoseph Koshy 				ev->ev_flags |= PMC_F_CALLCHAIN;
763f263522aSJoseph Koshy 			if (do_descendants)
764f263522aSJoseph Koshy 				ev->ev_flags |= PMC_F_DESCENDANTS;
765f263522aSJoseph Koshy 			if (do_logprocexit)
766f263522aSJoseph Koshy 				ev->ev_flags |= PMC_F_LOG_PROCEXIT;
767f263522aSJoseph Koshy 			if (do_logproccsw)
768f263522aSJoseph Koshy 				ev->ev_flags |= PMC_F_LOG_PROCCSW;
769f263522aSJoseph Koshy 
770ebccf1e3SJoseph Koshy 			ev->ev_cumulative  = use_cumulative_counts;
771ebccf1e3SJoseph Koshy 
772ebccf1e3SJoseph Koshy 			ev->ev_saved = 0LL;
773ebccf1e3SJoseph Koshy 			ev->ev_pmcid = PMC_ID_INVALID;
774ebccf1e3SJoseph Koshy 
775ebccf1e3SJoseph Koshy 			/* extract event name */
776ebccf1e3SJoseph Koshy 			c = strcspn(optarg, ", \t");
777ebccf1e3SJoseph Koshy 			ev->ev_name = malloc(c + 1);
778ebccf1e3SJoseph Koshy 			(void) strncpy(ev->ev_name, optarg, c);
779ebccf1e3SJoseph Koshy 			*(ev->ev_name + c) = '\0';
780ebccf1e3SJoseph Koshy 
781fbd8b34aSJoseph Koshy 			STAILQ_INSERT_TAIL(&args.pa_events, ev, ev_next);
782ebccf1e3SJoseph Koshy 
783ee4910b1SJoseph Koshy 			if (option == 's' || option == 'S')
7840b86b1bbSFabien Thomas 				pmcstat_clone_event_descriptor(ev,
785ee4910b1SJoseph Koshy 				    cpumask & ~(1 << ev->ev_cpu));
786ee4910b1SJoseph Koshy 
787ebccf1e3SJoseph Koshy 			break;
788ebccf1e3SJoseph Koshy 
789ebccf1e3SJoseph Koshy 		case 'n':	/* sampling count */
790ebccf1e3SJoseph Koshy 			current_sampling_count = strtol(optarg, &end, 0);
791ebccf1e3SJoseph Koshy 			if (*end != '\0' || current_sampling_count <= 0)
792ebccf1e3SJoseph Koshy 				errx(EX_USAGE,
793f263522aSJoseph Koshy 				    "ERROR: Illegal count value \"%s\".",
794ebccf1e3SJoseph Koshy 				    optarg);
795f263522aSJoseph Koshy 			args.pa_required |= FLAG_HAS_SAMPLING_PMCS;
796ebccf1e3SJoseph Koshy 			break;
797ebccf1e3SJoseph Koshy 
798ebccf1e3SJoseph Koshy 		case 'o':	/* outputfile */
79915139246SJoseph Koshy 			if (args.pa_printfile != NULL)
80015139246SJoseph Koshy 				(void) fclose(args.pa_printfile);
80115139246SJoseph Koshy 			if ((args.pa_printfile = fopen(optarg, "w")) == NULL)
802ebccf1e3SJoseph Koshy 				errx(EX_OSERR, "ERROR: cannot open \"%s\" for "
803f263522aSJoseph Koshy 				    "writing.", optarg);
80415139246SJoseph Koshy 			args.pa_flags |= FLAG_DO_PRINT;
805f263522aSJoseph Koshy 			break;
806ebccf1e3SJoseph Koshy 
807ebccf1e3SJoseph Koshy 		case 'O':	/* sampling output */
80815139246SJoseph Koshy 			if (args.pa_outputpath)
80915139246SJoseph Koshy 				errx(EX_USAGE, "ERROR: option -O may only be "
810f263522aSJoseph Koshy 				    "specified once.");
81115139246SJoseph Koshy 			args.pa_outputpath = optarg;
81215139246SJoseph Koshy 			args.pa_flags |= FLAG_HAS_OUTPUT_LOGFILE;
81315139246SJoseph Koshy 			break;
81415139246SJoseph Koshy 
81549874f6eSJoseph Koshy 		case 'q':	/* quiet mode */
81649874f6eSJoseph Koshy 			args.pa_verbosity = 0;
81749874f6eSJoseph Koshy 			break;
81849874f6eSJoseph Koshy 
81949874f6eSJoseph Koshy 		case 'r':	/* root FS path */
82049874f6eSJoseph Koshy 			args.pa_fsroot = optarg;
82149874f6eSJoseph Koshy 			break;
82249874f6eSJoseph Koshy 
82315139246SJoseph Koshy 		case 'R':	/* read an existing log file */
824b6010f9eSJoseph Koshy 			if (args.pa_inputpath != NULL)
82515139246SJoseph Koshy 				errx(EX_USAGE, "ERROR: option -R may only be "
82615139246SJoseph Koshy 				    "specified once.");
82715139246SJoseph Koshy 			args.pa_inputpath = optarg;
82815139246SJoseph Koshy 			if (args.pa_printfile == stderr)
82915139246SJoseph Koshy 				args.pa_printfile = stdout;
83015139246SJoseph Koshy 			args.pa_flags |= FLAG_READ_LOGFILE;
831ebccf1e3SJoseph Koshy 			break;
832ebccf1e3SJoseph Koshy 
833fbd8b34aSJoseph Koshy 		case 't':	/* target pid or process name */
8340b86b1bbSFabien Thomas 			pmcstat_find_targets(optarg);
835ebccf1e3SJoseph Koshy 
836fbd8b34aSJoseph Koshy 			args.pa_flags |= FLAG_HAS_TARGET;
837f263522aSJoseph Koshy 			args.pa_required |= FLAG_HAS_PROCESS_PMCS;
838ebccf1e3SJoseph Koshy 			break;
839ebccf1e3SJoseph Koshy 
8400b86b1bbSFabien Thomas 		case 'T':	/* top mode */
8410b86b1bbSFabien Thomas 			args.pa_flags |= FLAG_DO_TOP;
8420b86b1bbSFabien Thomas 			args.pa_plugin = PMCSTAT_PL_CALLGRAPH;
8430b86b1bbSFabien Thomas 			args.pa_ctdumpinstr = 0;
8440b86b1bbSFabien Thomas 			args.pa_mergepmc = 1;
8450b86b1bbSFabien Thomas 			if (args.pa_printfile == stderr)
8460b86b1bbSFabien Thomas 				args.pa_printfile = stdout;
8470b86b1bbSFabien Thomas 			break;
8480b86b1bbSFabien Thomas 
84949874f6eSJoseph Koshy 		case 'v':	/* verbose */
85049874f6eSJoseph Koshy 			args.pa_verbosity++;
85149874f6eSJoseph Koshy 			break;
85249874f6eSJoseph Koshy 
853ebccf1e3SJoseph Koshy 		case 'w':	/* wait interval */
854ebccf1e3SJoseph Koshy 			interval = strtod(optarg, &end);
855ebccf1e3SJoseph Koshy 			if (*end != '\0' || interval <= 0)
856ebccf1e3SJoseph Koshy 				errx(EX_USAGE, "ERROR: Illegal wait interval "
857f263522aSJoseph Koshy 				    "value \"%s\".", optarg);
858ebccf1e3SJoseph Koshy 			args.pa_flags |= FLAG_HAS_WAIT_INTERVAL;
859ebccf1e3SJoseph Koshy 			args.pa_interval = interval;
860f263522aSJoseph Koshy 			break;
861ebccf1e3SJoseph Koshy 
862f263522aSJoseph Koshy 		case 'W':	/* toggle LOG_CSW */
863f263522aSJoseph Koshy 			do_logproccsw = !do_logproccsw;
864f263522aSJoseph Koshy 			args.pa_required |= (FLAG_HAS_PROCESS_PMCS |
86515139246SJoseph Koshy 			    FLAG_HAS_COUNTING_PMCS | FLAG_HAS_OUTPUT_LOGFILE);
866ebccf1e3SJoseph Koshy 			break;
867ebccf1e3SJoseph Koshy 
868b6010f9eSJoseph Koshy 		case 'z':
869b6010f9eSJoseph Koshy 			graphdepth = strtod(optarg, &end);
870b6010f9eSJoseph Koshy 			if (*end != '\0' || graphdepth <= 0)
871b6010f9eSJoseph Koshy 				errx(EX_USAGE, "ERROR: Illegal callchain "
872b6010f9eSJoseph Koshy 				    "depth \"%s\".", optarg);
873b6010f9eSJoseph Koshy 			args.pa_graphdepth = graphdepth;
874b6010f9eSJoseph Koshy 			args.pa_required |= FLAG_DO_CALLGRAPHS;
875b6010f9eSJoseph Koshy 			break;
876b6010f9eSJoseph Koshy 
877ebccf1e3SJoseph Koshy 		case '?':
878ebccf1e3SJoseph Koshy 		default:
879ebccf1e3SJoseph Koshy 			pmcstat_show_usage();
880ebccf1e3SJoseph Koshy 			break;
881ebccf1e3SJoseph Koshy 
882ebccf1e3SJoseph Koshy 		}
883ebccf1e3SJoseph Koshy 
884ebccf1e3SJoseph Koshy 	args.pa_argc = (argc -= optind);
885ebccf1e3SJoseph Koshy 	args.pa_argv = (argv += optind);
886ebccf1e3SJoseph Koshy 
887b6010f9eSJoseph Koshy 	args.pa_cpumask = cpumask; /* For selecting CPUs using -R. */
888b6010f9eSJoseph Koshy 
88915139246SJoseph Koshy 	if (argc)	/* command line present */
89015139246SJoseph Koshy 		args.pa_flags |= FLAG_HAS_COMMANDLINE;
891ebccf1e3SJoseph Koshy 
892c0252222SAttilio Rao 	if (args.pa_flags & (FLAG_DO_GPROF | FLAG_DO_CALLGRAPHS |
8930b86b1bbSFabien Thomas 	    FLAG_DO_ANNOTATE | FLAG_DO_TOP))
894b6010f9eSJoseph Koshy 		args.pa_flags |= FLAG_DO_ANALYSIS;
895b6010f9eSJoseph Koshy 
896ebccf1e3SJoseph Koshy 	/*
897ebccf1e3SJoseph Koshy 	 * Check invocation syntax.
898ebccf1e3SJoseph Koshy 	 */
899ebccf1e3SJoseph Koshy 
90015139246SJoseph Koshy 	/* disallow -O and -R together */
90115139246SJoseph Koshy 	if (args.pa_outputpath && args.pa_inputpath)
90215139246SJoseph Koshy 		errx(EX_USAGE, "ERROR: options -O and -R are mutually "
90315139246SJoseph Koshy 		    "exclusive.");
90415139246SJoseph Koshy 
905c0252222SAttilio Rao 	/* -m option is allowed with -R only. */
9060b86b1bbSFabien Thomas 	if (args.pa_flags & FLAG_DO_ANNOTATE && args.pa_inputpath == NULL)
907c0252222SAttilio Rao 		errx(EX_USAGE, "ERROR: option -m requires an input file");
908c0252222SAttilio Rao 
909c0252222SAttilio Rao 	/* -m option is not allowed combined with -g or -G. */
9100b86b1bbSFabien Thomas 	if (args.pa_flags & FLAG_DO_ANNOTATE &&
911c0252222SAttilio Rao 	    args.pa_flags & (FLAG_DO_GPROF | FLAG_DO_CALLGRAPHS))
912c0252222SAttilio Rao 		errx(EX_USAGE, "ERROR: option -m and -g | -G are mutually "
913c0252222SAttilio Rao 		    "exclusive");
914c0252222SAttilio Rao 
91515139246SJoseph Koshy 	if (args.pa_flags & FLAG_READ_LOGFILE) {
916f263522aSJoseph Koshy 		errmsg = NULL;
91715139246SJoseph Koshy 		if (args.pa_flags & FLAG_HAS_COMMANDLINE)
918f263522aSJoseph Koshy 			errmsg = "a command line specification";
919fbd8b34aSJoseph Koshy 		else if (args.pa_flags & FLAG_HAS_TARGET)
920f263522aSJoseph Koshy 			errmsg = "option -t";
921fbd8b34aSJoseph Koshy 		else if (!STAILQ_EMPTY(&args.pa_events))
922f263522aSJoseph Koshy 			errmsg = "a PMC event specification";
923f263522aSJoseph Koshy 		if (errmsg)
924f263522aSJoseph Koshy 			errx(EX_USAGE, "ERROR: option -R may not be used with "
925f263522aSJoseph Koshy 			    "%s.", errmsg);
926fbd8b34aSJoseph Koshy 	} else if (STAILQ_EMPTY(&args.pa_events))
92715139246SJoseph Koshy 		/* All other uses require a PMC spec. */
928ebccf1e3SJoseph Koshy 		pmcstat_show_usage();
929ebccf1e3SJoseph Koshy 
930f263522aSJoseph Koshy 	/* check for -t pid without a process PMC spec */
931fbd8b34aSJoseph Koshy 	if ((args.pa_required & FLAG_HAS_TARGET) &&
932f263522aSJoseph Koshy 	    (args.pa_flags & FLAG_HAS_PROCESS_PMCS) == 0)
933f263522aSJoseph Koshy 		errx(EX_USAGE, "ERROR: option -t requires a process mode PMC "
934f263522aSJoseph Koshy 		    "to be specified.");
935f263522aSJoseph Koshy 
936f263522aSJoseph Koshy 	/* check for process-mode options without a command or -t pid */
937f263522aSJoseph Koshy 	if ((args.pa_required & FLAG_HAS_PROCESS_PMCS) &&
938fbd8b34aSJoseph Koshy 	    (args.pa_flags & (FLAG_HAS_COMMANDLINE | FLAG_HAS_TARGET)) == 0)
93915139246SJoseph Koshy 		errx(EX_USAGE, "ERROR: options -d, -E, -p, -P, and -W require "
94015139246SJoseph Koshy 		    "a command line or target process.");
941f263522aSJoseph Koshy 
942f263522aSJoseph Koshy 	/* check for -p | -P without a target process of some sort */
943fbd8b34aSJoseph Koshy 	if ((args.pa_required & (FLAG_HAS_COMMANDLINE | FLAG_HAS_TARGET)) &&
944fbd8b34aSJoseph Koshy 	    (args.pa_flags & (FLAG_HAS_COMMANDLINE | FLAG_HAS_TARGET)) == 0)
94515139246SJoseph Koshy 		errx(EX_USAGE, "ERROR: options -P and -p require a "
946f263522aSJoseph Koshy 		    "target process or a command line.");
947f263522aSJoseph Koshy 
948f263522aSJoseph Koshy 	/* check for process-mode options without a process-mode PMC */
949f263522aSJoseph Koshy 	if ((args.pa_required & FLAG_HAS_PROCESS_PMCS) &&
950f263522aSJoseph Koshy 	    (args.pa_flags & FLAG_HAS_PROCESS_PMCS) == 0)
95115139246SJoseph Koshy 		errx(EX_USAGE, "ERROR: options -d, -E, and -W require a "
952f263522aSJoseph Koshy 		    "process mode PMC to be specified.");
953f263522aSJoseph Koshy 
954b6010f9eSJoseph Koshy 	/* check for -c cpu with no system mode PMCs or logfile. */
955f263522aSJoseph Koshy 	if ((args.pa_required & FLAG_HAS_SYSTEM_PMCS) &&
956b6010f9eSJoseph Koshy 	    (args.pa_flags & FLAG_HAS_SYSTEM_PMCS) == 0 &&
957b6010f9eSJoseph Koshy 	    (args.pa_flags & FLAG_READ_LOGFILE) == 0)
958f263522aSJoseph Koshy 		errx(EX_USAGE, "ERROR: option -c requires at least one "
959f263522aSJoseph Koshy 		    "system mode PMC to be specified.");
960f263522aSJoseph Koshy 
961f263522aSJoseph Koshy 	/* check for counting mode options without a counting PMC */
962f263522aSJoseph Koshy 	if ((args.pa_required & FLAG_HAS_COUNTING_PMCS) &&
963f263522aSJoseph Koshy 	    (args.pa_flags & FLAG_HAS_COUNTING_PMCS) == 0)
9640b86b1bbSFabien Thomas 		errx(EX_USAGE, "ERROR: options -C, -W and -o require at "
9654525db8cSJoseph Koshy 		    "least one counting mode PMC to be specified.");
966f263522aSJoseph Koshy 
967f263522aSJoseph Koshy 	/* check for sampling mode options without a sampling PMC spec */
968f263522aSJoseph Koshy 	if ((args.pa_required & FLAG_HAS_SAMPLING_PMCS) &&
969f263522aSJoseph Koshy 	    (args.pa_flags & FLAG_HAS_SAMPLING_PMCS) == 0)
970b6010f9eSJoseph Koshy 		errx(EX_USAGE, "ERROR: options -N, -n and -O require at "
971b6010f9eSJoseph Koshy 		    "least one sampling mode PMC to be specified.");
972f263522aSJoseph Koshy 
9730b86b1bbSFabien Thomas 	/* check if -g/-G/-m/-T are being used correctly */
974b6010f9eSJoseph Koshy 	if ((args.pa_flags & FLAG_DO_ANALYSIS) &&
97515139246SJoseph Koshy 	    !(args.pa_flags & (FLAG_HAS_SAMPLING_PMCS|FLAG_READ_LOGFILE)))
9760b86b1bbSFabien Thomas 		errx(EX_USAGE, "ERROR: options -g/-G/-m/-T require sampling PMCs "
977b6010f9eSJoseph Koshy 		    "or -R to be specified.");
97815139246SJoseph Koshy 
979f263522aSJoseph Koshy 	/* check if -O was spuriously specified */
98015139246SJoseph Koshy 	if ((args.pa_flags & FLAG_HAS_OUTPUT_LOGFILE) &&
98115139246SJoseph Koshy 	    (args.pa_required & FLAG_HAS_OUTPUT_LOGFILE) == 0)
982f263522aSJoseph Koshy 		errx(EX_USAGE,
983f263522aSJoseph Koshy 		    "ERROR: option -O is used only with options "
984f263522aSJoseph Koshy 		    "-E, -P, -S and -W.");
985f263522aSJoseph Koshy 
9860b86b1bbSFabien Thomas 	/* -k kernel path require -g/-G/-m/-T or -R */
98715139246SJoseph Koshy 	if ((args.pa_flags & FLAG_HAS_KERNELPATH) &&
988b6010f9eSJoseph Koshy 	    (args.pa_flags & FLAG_DO_ANALYSIS) == 0 &&
98949874f6eSJoseph Koshy 	    (args.pa_flags & FLAG_READ_LOGFILE) == 0)
9900b86b1bbSFabien Thomas 	    errx(EX_USAGE, "ERROR: option -k is only used with -g/-R/-m/-T.");
99115139246SJoseph Koshy 
992b6010f9eSJoseph Koshy 	/* -D only applies to gprof output mode (-g) */
99315139246SJoseph Koshy 	if ((args.pa_flags & FLAG_HAS_SAMPLESDIR) &&
994b6010f9eSJoseph Koshy 	    (args.pa_flags & FLAG_DO_GPROF) == 0)
995b6010f9eSJoseph Koshy 	    errx(EX_USAGE, "ERROR: option -D is only used with -g.");
99649874f6eSJoseph Koshy 
99749874f6eSJoseph Koshy 	/* -M mapfile requires -g or -R */
99849874f6eSJoseph Koshy 	if (args.pa_mapfilename != NULL &&
99949874f6eSJoseph Koshy 	    (args.pa_flags & FLAG_DO_GPROF) == 0 &&
100049874f6eSJoseph Koshy 	    (args.pa_flags & FLAG_READ_LOGFILE) == 0)
100149874f6eSJoseph Koshy 	    errx(EX_USAGE, "ERROR: option -M is only used with -g/-R.");
100215139246SJoseph Koshy 
10030b86b1bbSFabien Thomas 	/* -T is incompatible with -R (replay logfile is a TODO) */
10040b86b1bbSFabien Thomas 	if ((args.pa_flags & FLAG_DO_TOP) &&
10050b86b1bbSFabien Thomas 	    (args.pa_flags & FLAG_READ_LOGFILE))
10060b86b1bbSFabien Thomas 		errx(EX_USAGE, "ERROR: option -T is incompatible with -R.");
10070b86b1bbSFabien Thomas 
100815139246SJoseph Koshy 	/*
100915139246SJoseph Koshy 	 * Disallow textual output of sampling PMCs if counting PMCs
101015139246SJoseph Koshy 	 * have also been asked for, mostly because the combined output
101115139246SJoseph Koshy 	 * is difficult to make sense of.
101215139246SJoseph Koshy 	 */
101315139246SJoseph Koshy 	if ((args.pa_flags & FLAG_HAS_COUNTING_PMCS) &&
101415139246SJoseph Koshy 	    (args.pa_flags & FLAG_HAS_SAMPLING_PMCS) &&
101500a22dc5SJoseph Koshy 	    ((args.pa_flags & FLAG_HAS_OUTPUT_LOGFILE) == 0))
101615139246SJoseph Koshy 		errx(EX_USAGE, "ERROR: option -O is required if counting and "
101715139246SJoseph Koshy 		    "sampling PMCs are specified together.");
101815139246SJoseph Koshy 
101949874f6eSJoseph Koshy 	/*
1020b6010f9eSJoseph Koshy 	 * Check if "-k kerneldir" was specified, and if whether
1021b6010f9eSJoseph Koshy 	 * 'kerneldir' actually refers to a a file.  If so, use
1022b6010f9eSJoseph Koshy 	 * `dirname path` to determine the kernel directory.
102349874f6eSJoseph Koshy 	 */
102449874f6eSJoseph Koshy 	if (args.pa_flags & FLAG_HAS_KERNELPATH) {
102549874f6eSJoseph Koshy 		(void) snprintf(buffer, sizeof(buffer), "%s%s", args.pa_fsroot,
102649874f6eSJoseph Koshy 		    args.pa_kernel);
102749874f6eSJoseph Koshy 		if (stat(buffer, &sb) < 0)
102849874f6eSJoseph Koshy 			err(EX_OSERR, "ERROR: Cannot locate kernel \"%s\"",
102949874f6eSJoseph Koshy 			    buffer);
103049874f6eSJoseph Koshy 		if (!S_ISREG(sb.st_mode) && !S_ISDIR(sb.st_mode))
103149874f6eSJoseph Koshy 			errx(EX_USAGE, "ERROR: \"%s\": Unsupported file type.",
103249874f6eSJoseph Koshy 			    buffer);
103349874f6eSJoseph Koshy 		if (!S_ISDIR(sb.st_mode)) {
103449874f6eSJoseph Koshy 			tmp = args.pa_kernel;
103549874f6eSJoseph Koshy 			args.pa_kernel = strdup(dirname(args.pa_kernel));
103649874f6eSJoseph Koshy 			free(tmp);
103749874f6eSJoseph Koshy 			(void) snprintf(buffer, sizeof(buffer), "%s%s",
103849874f6eSJoseph Koshy 			    args.pa_fsroot, args.pa_kernel);
103949874f6eSJoseph Koshy 			if (stat(buffer, &sb) < 0)
104049874f6eSJoseph Koshy 				err(EX_OSERR, "ERROR: Cannot stat \"%s\"",
104149874f6eSJoseph Koshy 				    buffer);
104249874f6eSJoseph Koshy 			if (!S_ISDIR(sb.st_mode))
104349874f6eSJoseph Koshy 				errx(EX_USAGE, "ERROR: \"%s\" is not a "
104449874f6eSJoseph Koshy 				    "directory.", buffer);
104549874f6eSJoseph Koshy 		}
104649874f6eSJoseph Koshy 	}
104749874f6eSJoseph Koshy 
1048b6010f9eSJoseph Koshy 	/*
1049b6010f9eSJoseph Koshy 	 * If we have a callgraph be created, select the outputfile.
1050b6010f9eSJoseph Koshy 	 */
1051b6010f9eSJoseph Koshy 	if (args.pa_flags & FLAG_DO_CALLGRAPHS) {
1052b6010f9eSJoseph Koshy 		if (strcmp(graphfilename, "-") == 0)
1053b6010f9eSJoseph Koshy 		    args.pa_graphfile = args.pa_printfile;
1054b6010f9eSJoseph Koshy 		else {
1055b6010f9eSJoseph Koshy 			args.pa_graphfile = fopen(graphfilename, "w");
1056b6010f9eSJoseph Koshy 			if (args.pa_graphfile == NULL)
1057b6010f9eSJoseph Koshy 				err(EX_OSERR, "ERROR: cannot open \"%s\" "
1058b6010f9eSJoseph Koshy 				    "for writing", graphfilename);
1059b6010f9eSJoseph Koshy 		}
1060b6010f9eSJoseph Koshy 	}
10610b86b1bbSFabien Thomas 	if (args.pa_flags & FLAG_DO_ANNOTATE) {
1062c0252222SAttilio Rao 		args.pa_graphfile = fopen(graphfilename, "w");
1063c0252222SAttilio Rao 		if (args.pa_graphfile == NULL)
1064c0252222SAttilio Rao 			err(EX_OSERR, "ERROR: cannot open \"%s\" for writing",
1065c0252222SAttilio Rao 			    graphfilename);
1066c0252222SAttilio Rao 	}
1067b6010f9eSJoseph Koshy 
1068f263522aSJoseph Koshy 	/* if we've been asked to process a log file, do that and exit */
106915139246SJoseph Koshy 	if (args.pa_flags & FLAG_READ_LOGFILE) {
107015139246SJoseph Koshy 		/*
107115139246SJoseph Koshy 		 * Print the log in textual form if we haven't been
1072b6010f9eSJoseph Koshy 		 * asked to generate profiling information.
107315139246SJoseph Koshy 		 */
1074b6010f9eSJoseph Koshy 		if ((args.pa_flags & FLAG_DO_ANALYSIS) == 0)
107515139246SJoseph Koshy 			args.pa_flags |= FLAG_DO_PRINT;
107615139246SJoseph Koshy 
10770b86b1bbSFabien Thomas 		pmcstat_initialize_logging();
1078302cbb90SJoseph Koshy 		args.pa_logfd = pmcstat_open_log(args.pa_inputpath,
1079302cbb90SJoseph Koshy 		    PMCSTAT_OPEN_FOR_READ);
108015139246SJoseph Koshy 		if ((args.pa_logparser = pmclog_open(args.pa_logfd)) == NULL)
108115139246SJoseph Koshy 			err(EX_OSERR, "ERROR: Cannot create parser");
10820b86b1bbSFabien Thomas 		pmcstat_process_log();
10830b86b1bbSFabien Thomas 		pmcstat_shutdown_logging();
1084f263522aSJoseph Koshy 		exit(EX_OK);
1085f263522aSJoseph Koshy 	}
1086f263522aSJoseph Koshy 
1087f263522aSJoseph Koshy 	/* otherwise, we've been asked to collect data */
1088ebccf1e3SJoseph Koshy 	if (pmc_init() < 0)
1089ebccf1e3SJoseph Koshy 		err(EX_UNAVAILABLE,
1090ebccf1e3SJoseph Koshy 		    "ERROR: Initialization of the pmc(3) library failed");
1091ebccf1e3SJoseph Koshy 
1092ebccf1e3SJoseph Koshy 	if ((npmc = pmc_npmc(0)) < 0) /* assume all CPUs are identical */
1093ebccf1e3SJoseph Koshy 		err(EX_OSERR, "ERROR: Cannot determine the number of PMCs "
1094ebccf1e3SJoseph Koshy 		    "on CPU %d", 0);
1095ebccf1e3SJoseph Koshy 
109615139246SJoseph Koshy 	/* Allocate a kqueue */
109715139246SJoseph Koshy 	if ((pmcstat_kq = kqueue()) < 0)
109815139246SJoseph Koshy 		err(EX_OSERR, "ERROR: Cannot allocate kqueue");
109915139246SJoseph Koshy 
110015139246SJoseph Koshy 	/*
110115139246SJoseph Koshy 	 * Configure the specified log file or setup a default log
110215139246SJoseph Koshy 	 * consumer via a pipe.
110315139246SJoseph Koshy 	 */
110415139246SJoseph Koshy 	if (args.pa_required & FLAG_HAS_OUTPUT_LOGFILE) {
1105302cbb90SJoseph Koshy 		if (args.pa_outputpath)
1106302cbb90SJoseph Koshy 			args.pa_logfd = pmcstat_open_log(args.pa_outputpath,
1107302cbb90SJoseph Koshy 			    PMCSTAT_OPEN_FOR_WRITE);
1108302cbb90SJoseph Koshy 		else {
110915139246SJoseph Koshy 			/*
111015139246SJoseph Koshy 			 * process the log on the fly by reading it in
111115139246SJoseph Koshy 			 * through a pipe.
111215139246SJoseph Koshy 			 */
111315139246SJoseph Koshy 			if (pipe(pipefd) < 0)
111415139246SJoseph Koshy 				err(EX_OSERR, "ERROR: pipe(2) failed");
111515139246SJoseph Koshy 
111615139246SJoseph Koshy 			if (fcntl(pipefd[READPIPEFD], F_SETFL, O_NONBLOCK) < 0)
111715139246SJoseph Koshy 				err(EX_OSERR, "ERROR: fcntl(2) failed");
111815139246SJoseph Koshy 
111915139246SJoseph Koshy 			EV_SET(&kev, pipefd[READPIPEFD], EVFILT_READ, EV_ADD,
112015139246SJoseph Koshy 			    0, 0, NULL);
112115139246SJoseph Koshy 
112215139246SJoseph Koshy 			if (kevent(pmcstat_kq, &kev, 1, NULL, 0, NULL) < 0)
112315139246SJoseph Koshy 				err(EX_OSERR, "ERROR: Cannot register kevent");
112415139246SJoseph Koshy 
112515139246SJoseph Koshy 			args.pa_logfd = pipefd[WRITEPIPEFD];
112615139246SJoseph Koshy 
11270b86b1bbSFabien Thomas 			args.pa_flags |= FLAG_HAS_PIPE;
11280b86b1bbSFabien Thomas 			if ((args.pa_flags & FLAG_DO_TOP) == 0)
11290b86b1bbSFabien Thomas 				args.pa_flags |= FLAG_DO_PRINT;
113015139246SJoseph Koshy 			args.pa_logparser = pmclog_open(pipefd[READPIPEFD]);
113115139246SJoseph Koshy 		}
113215139246SJoseph Koshy 
113315139246SJoseph Koshy 		if (pmc_configure_logfile(args.pa_logfd) < 0)
113415139246SJoseph Koshy 			err(EX_OSERR, "ERROR: Cannot configure log file");
113515139246SJoseph Koshy 	}
113615139246SJoseph Koshy 
11377fbf3da2SJoseph Koshy 	/* remember to check for driver errors if we are sampling or logging */
11387fbf3da2SJoseph Koshy 	check_driver_stats = (args.pa_flags & FLAG_HAS_SAMPLING_PMCS) ||
11397fbf3da2SJoseph Koshy 	    (args.pa_flags & FLAG_HAS_OUTPUT_LOGFILE);
11407fbf3da2SJoseph Koshy 
1141ebccf1e3SJoseph Koshy 	/*
1142ebccf1e3SJoseph Koshy 	 * Allocate PMCs.
1143ebccf1e3SJoseph Koshy 	 */
1144ebccf1e3SJoseph Koshy 
1145fbd8b34aSJoseph Koshy 	STAILQ_FOREACH(ev, &args.pa_events, ev_next) {
1146ebccf1e3SJoseph Koshy 	    if (pmc_allocate(ev->ev_spec, ev->ev_mode,
1147f263522aSJoseph Koshy 		    ev->ev_flags, ev->ev_cpu, &ev->ev_pmcid) < 0)
1148ebccf1e3SJoseph Koshy 		    err(EX_OSERR, "ERROR: Cannot allocate %s-mode pmc with "
1149ebccf1e3SJoseph Koshy 			"specification \"%s\"",
1150ebccf1e3SJoseph Koshy 			PMC_IS_SYSTEM_MODE(ev->ev_mode) ? "system" : "process",
1151ebccf1e3SJoseph Koshy 			ev->ev_spec);
1152ebccf1e3SJoseph Koshy 
115315139246SJoseph Koshy 	    if (PMC_IS_SAMPLING_MODE(ev->ev_mode) &&
115415139246SJoseph Koshy 		pmc_set(ev->ev_pmcid, ev->ev_count) < 0)
115515139246SJoseph Koshy 		    err(EX_OSERR, "ERROR: Cannot set sampling count "
115615139246SJoseph Koshy 			"for PMC \"%s\"", ev->ev_name);
115715139246SJoseph Koshy 	}
115815139246SJoseph Koshy 
1159ebccf1e3SJoseph Koshy 	/* compute printout widths */
1160fbd8b34aSJoseph Koshy 	STAILQ_FOREACH(ev, &args.pa_events, ev_next) {
1161c5153e19SJoseph Koshy 		int counter_width;
1162c5153e19SJoseph Koshy 		int display_width;
1163c5153e19SJoseph Koshy 		int header_width;
1164ebccf1e3SJoseph Koshy 
1165c5153e19SJoseph Koshy 		(void) pmc_width(ev->ev_pmcid, &counter_width);
1166ee4910b1SJoseph Koshy 		header_width = strlen(ev->ev_name) + 2; /* prefix '%c/' */
1167c5153e19SJoseph Koshy 		display_width = (int) floor(counter_width / 3.32193) + 1;
1168ebccf1e3SJoseph Koshy 
1169ee4910b1SJoseph Koshy 		if (PMC_IS_SYSTEM_MODE(ev->ev_mode))
1170ee4910b1SJoseph Koshy 			header_width += 3; /* 2 digit CPU number + '/' */
1171ee4910b1SJoseph Koshy 
1172c5153e19SJoseph Koshy 		if (header_width > display_width) {
1173ebccf1e3SJoseph Koshy 			ev->ev_fieldskip = 0;
1174c5153e19SJoseph Koshy 			ev->ev_fieldwidth = header_width;
1175ebccf1e3SJoseph Koshy 		} else {
1176c5153e19SJoseph Koshy 			ev->ev_fieldskip = display_width -
1177c5153e19SJoseph Koshy 			    header_width;
1178c5153e19SJoseph Koshy 			ev->ev_fieldwidth = display_width;
1179ebccf1e3SJoseph Koshy 		}
1180ebccf1e3SJoseph Koshy 	}
1181ebccf1e3SJoseph Koshy 
1182ebccf1e3SJoseph Koshy 	/*
1183ebccf1e3SJoseph Koshy 	 * If our output is being set to a terminal, register a handler
1184ebccf1e3SJoseph Koshy 	 * for window size changes.
1185ebccf1e3SJoseph Koshy 	 */
1186ebccf1e3SJoseph Koshy 
118715139246SJoseph Koshy 	if (isatty(fileno(args.pa_printfile))) {
1188ebccf1e3SJoseph Koshy 
118915139246SJoseph Koshy 		if (ioctl(fileno(args.pa_printfile), TIOCGWINSZ, &ws) < 0)
1190ebccf1e3SJoseph Koshy 			err(EX_OSERR, "ERROR: Cannot determine window size");
1191ebccf1e3SJoseph Koshy 
1192ebccf1e3SJoseph Koshy 		pmcstat_displayheight = ws.ws_row - 1;
11930b86b1bbSFabien Thomas 		pmcstat_displaywidth  = ws.ws_col - 1;
1194ebccf1e3SJoseph Koshy 
1195ebccf1e3SJoseph Koshy 		EV_SET(&kev, SIGWINCH, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
1196ebccf1e3SJoseph Koshy 
1197ebccf1e3SJoseph Koshy 		if (kevent(pmcstat_kq, &kev, 1, NULL, 0, NULL) < 0)
1198ebccf1e3SJoseph Koshy 			err(EX_OSERR, "ERROR: Cannot register kevent for "
1199ebccf1e3SJoseph Koshy 			    "SIGWINCH");
12000b86b1bbSFabien Thomas 
12010b86b1bbSFabien Thomas 		args.pa_toptty = 1;
12020b86b1bbSFabien Thomas 	}
12030b86b1bbSFabien Thomas 
12040b86b1bbSFabien Thomas 	/*
12050b86b1bbSFabien Thomas 	 * Listen to key input in top mode.
12060b86b1bbSFabien Thomas 	 */
12070b86b1bbSFabien Thomas 	if (args.pa_flags & FLAG_DO_TOP) {
12080b86b1bbSFabien Thomas 		EV_SET(&kev, fileno(stdin), EVFILT_READ, EV_ADD, 0, 0, NULL);
12090b86b1bbSFabien Thomas 		if (kevent(pmcstat_kq, &kev, 1, NULL, 0, NULL) < 0)
12100b86b1bbSFabien Thomas 			err(EX_OSERR, "ERROR: Cannot register kevent");
1211ebccf1e3SJoseph Koshy 	}
1212ebccf1e3SJoseph Koshy 
1213ebccf1e3SJoseph Koshy 	EV_SET(&kev, SIGINT, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
1214ebccf1e3SJoseph Koshy 	if (kevent(pmcstat_kq, &kev, 1, NULL, 0, NULL) < 0)
1215ebccf1e3SJoseph Koshy 		err(EX_OSERR, "ERROR: Cannot register kevent for SIGINT");
1216ebccf1e3SJoseph Koshy 
1217f263522aSJoseph Koshy 	EV_SET(&kev, SIGIO, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
1218f263522aSJoseph Koshy 	if (kevent(pmcstat_kq, &kev, 1, NULL, 0, NULL) < 0)
1219f263522aSJoseph Koshy 		err(EX_OSERR, "ERROR: Cannot register kevent for SIGIO");
1220ebccf1e3SJoseph Koshy 
1221ebccf1e3SJoseph Koshy 	/*
1222f263522aSJoseph Koshy 	 * An exec() failure of a forked child is signalled by the
1223f263522aSJoseph Koshy 	 * child sending the parent a SIGCHLD.  We don't register an
1224f263522aSJoseph Koshy 	 * actual signal handler for SIGCHLD, but instead use our
1225f263522aSJoseph Koshy 	 * kqueue to pick up the signal.
1226ebccf1e3SJoseph Koshy 	 */
1227f263522aSJoseph Koshy 	EV_SET(&kev, SIGCHLD, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
1228f263522aSJoseph Koshy 	if (kevent(pmcstat_kq, &kev, 1, NULL, 0, NULL) < 0)
1229f263522aSJoseph Koshy 		err(EX_OSERR, "ERROR: Cannot register kevent for SIGCHLD");
1230ebccf1e3SJoseph Koshy 
12310b86b1bbSFabien Thomas 	/*
12320b86b1bbSFabien Thomas 	 * Setup a timer if we have counting mode PMCs needing to be printed or
12330b86b1bbSFabien Thomas 	 * top mode plugin is active.
12340b86b1bbSFabien Thomas 	 */
12350b86b1bbSFabien Thomas 	if (((args.pa_flags & FLAG_HAS_COUNTING_PMCS) &&
12360b86b1bbSFabien Thomas 	     (args.pa_required & FLAG_HAS_OUTPUT_LOGFILE) == 0) ||
12370b86b1bbSFabien Thomas 	    (args.pa_flags & FLAG_DO_TOP)) {
1238ebccf1e3SJoseph Koshy 		EV_SET(&kev, 0, EVFILT_TIMER, EV_ADD, 0,
1239ebccf1e3SJoseph Koshy 		    args.pa_interval * 1000, NULL);
1240ebccf1e3SJoseph Koshy 
1241ebccf1e3SJoseph Koshy 		if (kevent(pmcstat_kq, &kev, 1, NULL, 0, NULL) < 0)
1242ebccf1e3SJoseph Koshy 			err(EX_OSERR, "ERROR: Cannot register kevent for "
1243ebccf1e3SJoseph Koshy 			    "timer");
1244ebccf1e3SJoseph Koshy 	}
1245ebccf1e3SJoseph Koshy 
1246ebccf1e3SJoseph Koshy 	/* attach PMCs to the target process, starting it if specified */
1247ee4910b1SJoseph Koshy 	if (args.pa_flags & FLAG_HAS_COMMANDLINE)
12480b86b1bbSFabien Thomas 		pmcstat_create_process();
1249ebccf1e3SJoseph Koshy 
12507fbf3da2SJoseph Koshy 	if (check_driver_stats && pmc_get_driver_stats(&ds_start) < 0)
12517fbf3da2SJoseph Koshy 		err(EX_OSERR, "ERROR: Cannot retrieve driver statistics");
12527fbf3da2SJoseph Koshy 
1253ee4910b1SJoseph Koshy 	/* Attach process pmcs to the target process. */
1254165b10b0SJoseph Koshy 	if (args.pa_flags & (FLAG_HAS_TARGET | FLAG_HAS_COMMANDLINE)) {
1255fbd8b34aSJoseph Koshy 		if (SLIST_EMPTY(&args.pa_targets))
1256fbd8b34aSJoseph Koshy 			errx(EX_DATAERR, "ERROR: No matching target "
1257fbd8b34aSJoseph Koshy 			    "processes.");
12585477328dSJoseph Koshy 		if (args.pa_flags & FLAG_HAS_PROCESS_PMCS)
12590b86b1bbSFabien Thomas 			pmcstat_attach_pmcs();
1260ee4910b1SJoseph Koshy 
1261fbd8b34aSJoseph Koshy 		if (pmcstat_kvm) {
1262fbd8b34aSJoseph Koshy 			kvm_close(pmcstat_kvm);
1263fbd8b34aSJoseph Koshy 			pmcstat_kvm = NULL;
1264fbd8b34aSJoseph Koshy 		}
1265fbd8b34aSJoseph Koshy 	}
1266fbd8b34aSJoseph Koshy 
1267ebccf1e3SJoseph Koshy 	/* start the pmcs */
12680b86b1bbSFabien Thomas 	pmcstat_start_pmcs();
1269ebccf1e3SJoseph Koshy 
1270ebccf1e3SJoseph Koshy 	/* start the (commandline) process if needed */
127115139246SJoseph Koshy 	if (args.pa_flags & FLAG_HAS_COMMANDLINE)
1272ee4910b1SJoseph Koshy 		pmcstat_start_process();
1273ebccf1e3SJoseph Koshy 
127415139246SJoseph Koshy 	/* initialize logging if printing the configured log */
12750b86b1bbSFabien Thomas 	if ((args.pa_flags & (FLAG_DO_PRINT | FLAG_DO_TOP)) &&
127615139246SJoseph Koshy 	    (args.pa_flags & (FLAG_HAS_PIPE | FLAG_HAS_OUTPUT_LOGFILE)))
12770b86b1bbSFabien Thomas 		pmcstat_initialize_logging();
127815139246SJoseph Koshy 
1279ebccf1e3SJoseph Koshy 	/* Handle SIGINT using the kqueue loop */
1280ebccf1e3SJoseph Koshy 	sa.sa_handler = SIG_IGN;
1281ebccf1e3SJoseph Koshy 	sa.sa_flags   = 0;
1282ebccf1e3SJoseph Koshy 	(void) sigemptyset(&sa.sa_mask);
1283ebccf1e3SJoseph Koshy 
1284ebccf1e3SJoseph Koshy 	if (sigaction(SIGINT, &sa, NULL) < 0)
1285ebccf1e3SJoseph Koshy 		err(EX_OSERR, "ERROR: Cannot install signal handler");
1286ebccf1e3SJoseph Koshy 
1287ebccf1e3SJoseph Koshy 	/*
12880b86b1bbSFabien Thomas 	 * Setup the top mode display.
12890b86b1bbSFabien Thomas 	 */
12900b86b1bbSFabien Thomas 	if (args.pa_flags & FLAG_DO_TOP) {
12910b86b1bbSFabien Thomas 		args.pa_flags &= ~FLAG_DO_PRINT;
12920b86b1bbSFabien Thomas 
12930b86b1bbSFabien Thomas 		if (args.pa_toptty) {
12940b86b1bbSFabien Thomas 			/*
12950b86b1bbSFabien Thomas 			 * Init ncurses.
12960b86b1bbSFabien Thomas 			 */
12970b86b1bbSFabien Thomas 			initscr();
12980b86b1bbSFabien Thomas 			if(has_colors() == TRUE) {
12990b86b1bbSFabien Thomas 				args.pa_topcolor = 1;
13000b86b1bbSFabien Thomas 				start_color();
13010b86b1bbSFabien Thomas 				use_default_colors();
13020b86b1bbSFabien Thomas 				pair_content(0, &cf, &cb);
13030b86b1bbSFabien Thomas 				init_pair(1, COLOR_RED, cb);
13040b86b1bbSFabien Thomas 				init_pair(2, COLOR_YELLOW, cb);
13050b86b1bbSFabien Thomas 				init_pair(3, COLOR_GREEN, cb);
13060b86b1bbSFabien Thomas 			}
13070b86b1bbSFabien Thomas 			cbreak();
13080b86b1bbSFabien Thomas 			noecho();
13090b86b1bbSFabien Thomas 			nonl();
13100b86b1bbSFabien Thomas 			nodelay(stdscr, 1);
13110b86b1bbSFabien Thomas 			intrflush(stdscr, FALSE);
13120b86b1bbSFabien Thomas 			keypad(stdscr, TRUE);
13130b86b1bbSFabien Thomas 			clear();
13140b86b1bbSFabien Thomas 			atexit(pmcstat_topexit);
13150b86b1bbSFabien Thomas 		}
13160b86b1bbSFabien Thomas 	}
13170b86b1bbSFabien Thomas 
13180b86b1bbSFabien Thomas 	/*
1319ebccf1e3SJoseph Koshy 	 * loop till either the target process (if any) exits, or we
1320ebccf1e3SJoseph Koshy 	 * are killed by a SIGINT.
1321ebccf1e3SJoseph Koshy 	 */
1322f263522aSJoseph Koshy 	runstate = PMCSTAT_RUNNING;
1323f263522aSJoseph Koshy 	do_print = 0;
1324ebccf1e3SJoseph Koshy 	do {
1325ebccf1e3SJoseph Koshy 		if ((c = kevent(pmcstat_kq, NULL, 0, &kev, 1, NULL)) <= 0) {
1326ebccf1e3SJoseph Koshy 			if (errno != EINTR)
1327ebccf1e3SJoseph Koshy 				err(EX_OSERR, "ERROR: kevent failed");
1328ebccf1e3SJoseph Koshy 			else
1329ebccf1e3SJoseph Koshy 				continue;
1330ebccf1e3SJoseph Koshy 		}
1331ebccf1e3SJoseph Koshy 
1332ebccf1e3SJoseph Koshy 		if (kev.flags & EV_ERROR)
1333ebccf1e3SJoseph Koshy 			errc(EX_OSERR, kev.data, "ERROR: kevent failed");
1334ebccf1e3SJoseph Koshy 
1335ebccf1e3SJoseph Koshy 		switch (kev.filter) {
1336f263522aSJoseph Koshy 		case EVFILT_PROC:  /* target has exited */
133715139246SJoseph Koshy 			if (args.pa_flags & (FLAG_HAS_OUTPUT_LOGFILE |
133815139246SJoseph Koshy 				FLAG_HAS_PIPE))
13390b86b1bbSFabien Thomas 				runstate = pmcstat_close_log();
134038fc5f34SJoseph Koshy 			else
134138fc5f34SJoseph Koshy 				runstate = PMCSTAT_FINISHED;
134238fc5f34SJoseph Koshy 			do_print = 1;
1343f263522aSJoseph Koshy 			break;
1344ebccf1e3SJoseph Koshy 
1345f263522aSJoseph Koshy 		case EVFILT_READ:  /* log file data is present */
13460b86b1bbSFabien Thomas 			if (kev.ident == (unsigned)fileno(stdin)) {
13470b86b1bbSFabien Thomas 				if (pmcstat_keypress_log())
13480b86b1bbSFabien Thomas 					runstate = pmcstat_close_log();
13490b86b1bbSFabien Thomas 			} else
13500b86b1bbSFabien Thomas 				runstate = pmcstat_process_log();
1351ebccf1e3SJoseph Koshy 			break;
1352ebccf1e3SJoseph Koshy 
1353ebccf1e3SJoseph Koshy 		case EVFILT_SIGNAL:
1354f263522aSJoseph Koshy 			if (kev.ident == SIGCHLD) {
1355f263522aSJoseph Koshy 				/*
1356f263522aSJoseph Koshy 				 * The child process sends us a
1357f263522aSJoseph Koshy 				 * SIGCHLD if its exec() failed.  We
1358f263522aSJoseph Koshy 				 * wait for it to exit and then exit
1359f263522aSJoseph Koshy 				 * ourselves.
1360f263522aSJoseph Koshy 				 */
1361f263522aSJoseph Koshy 				(void) wait(&c);
1362f263522aSJoseph Koshy 				runstate = PMCSTAT_FINISHED;
1363f263522aSJoseph Koshy 			} else if (kev.ident == SIGIO) {
1364f263522aSJoseph Koshy 				/*
1365f263522aSJoseph Koshy 				 * We get a SIGIO if a PMC loses all
1366f263522aSJoseph Koshy 				 * of its targets, or if logfile
1367f263522aSJoseph Koshy 				 * writes encounter an error.
1368f263522aSJoseph Koshy 				 */
136915139246SJoseph Koshy 				if (args.pa_flags & (FLAG_HAS_OUTPUT_LOGFILE |
137015139246SJoseph Koshy 				    FLAG_HAS_PIPE)) {
13710b86b1bbSFabien Thomas 					runstate = pmcstat_close_log();
137215139246SJoseph Koshy 					if (args.pa_flags &
1373b6010f9eSJoseph Koshy 					    (FLAG_DO_PRINT|FLAG_DO_ANALYSIS))
13740b86b1bbSFabien Thomas 						pmcstat_process_log();
137515139246SJoseph Koshy 				}
1376f263522aSJoseph Koshy 				do_print = 1; /* print PMCs at exit */
1377f263522aSJoseph Koshy 				runstate = PMCSTAT_FINISHED;
1378f263522aSJoseph Koshy 			} else if (kev.ident == SIGINT) {
137915139246SJoseph Koshy 				/* Kill the child process if we started it */
138015139246SJoseph Koshy 				if (args.pa_flags & FLAG_HAS_COMMANDLINE)
13810b86b1bbSFabien Thomas 					pmcstat_kill_process();
13828cfb4353SJoseph Koshy 				/* Close the pipe to self, if present. */
13838cfb4353SJoseph Koshy 				if (args.pa_flags & FLAG_HAS_PIPE)
13848cfb4353SJoseph Koshy 					(void) close(pipefd[READPIPEFD]);
1385f263522aSJoseph Koshy 				runstate = PMCSTAT_FINISHED;
1386ebccf1e3SJoseph Koshy 			} else if (kev.ident == SIGWINCH) {
138715139246SJoseph Koshy 				if (ioctl(fileno(args.pa_printfile),
1388ebccf1e3SJoseph Koshy 					TIOCGWINSZ, &ws) < 0)
1389ebccf1e3SJoseph Koshy 				    err(EX_OSERR, "ERROR: Cannot determine "
1390ebccf1e3SJoseph Koshy 					"window size");
1391ebccf1e3SJoseph Koshy 				pmcstat_displayheight = ws.ws_row - 1;
13920b86b1bbSFabien Thomas 				pmcstat_displaywidth  = ws.ws_col - 1;
1393ebccf1e3SJoseph Koshy 			} else
1394ebccf1e3SJoseph Koshy 				assert(0);
1395ebccf1e3SJoseph Koshy 
1396ebccf1e3SJoseph Koshy 			break;
1397f263522aSJoseph Koshy 
1398f263522aSJoseph Koshy 		case EVFILT_TIMER: /* print out counting PMCs */
1399f263522aSJoseph Koshy 			do_print = 1;
1400f263522aSJoseph Koshy 			break;
1401f263522aSJoseph Koshy 
1402ebccf1e3SJoseph Koshy 		}
1403ebccf1e3SJoseph Koshy 
14040b86b1bbSFabien Thomas 		if (do_print) {
14050b86b1bbSFabien Thomas 			if ((args.pa_required & FLAG_HAS_OUTPUT_LOGFILE) == 0) {
14060b86b1bbSFabien Thomas 				pmcstat_print_pmcs();
140715139246SJoseph Koshy 				if (runstate == PMCSTAT_FINISHED && /* final newline */
140815139246SJoseph Koshy 				    (args.pa_flags & FLAG_DO_PRINT) == 0)
140915139246SJoseph Koshy 					(void) fprintf(args.pa_printfile, "\n");
14100b86b1bbSFabien Thomas 			}
14110b86b1bbSFabien Thomas 			if (args.pa_flags & FLAG_DO_TOP)
14120b86b1bbSFabien Thomas 				pmcstat_display_log();
1413f263522aSJoseph Koshy 			do_print = 0;
1414f263522aSJoseph Koshy 		}
1415f263522aSJoseph Koshy 
1416f263522aSJoseph Koshy 	} while (runstate != PMCSTAT_FINISHED);
1417f263522aSJoseph Koshy 
14180b86b1bbSFabien Thomas 	if ((args.pa_flags & FLAG_DO_TOP) && args.pa_toptty) {
14190b86b1bbSFabien Thomas 		pmcstat_topexit();
14200b86b1bbSFabien Thomas 		args.pa_toptty = 0;
14210b86b1bbSFabien Thomas 	}
14220b86b1bbSFabien Thomas 
1423f263522aSJoseph Koshy 	/* flush any pending log entries */
142415139246SJoseph Koshy 	if (args.pa_flags & (FLAG_HAS_OUTPUT_LOGFILE | FLAG_HAS_PIPE))
1425f263522aSJoseph Koshy 		pmc_flush_logfile();
1426ebccf1e3SJoseph Koshy 
14270b86b1bbSFabien Thomas 	pmcstat_cleanup();
1428ebccf1e3SJoseph Koshy 
142949874f6eSJoseph Koshy 	free(args.pa_kernel);
143049874f6eSJoseph Koshy 
14317fbf3da2SJoseph Koshy 	/* check if the driver lost any samples or events */
14327fbf3da2SJoseph Koshy 	if (check_driver_stats) {
14337fbf3da2SJoseph Koshy 		if (pmc_get_driver_stats(&ds_end) < 0)
14347fbf3da2SJoseph Koshy 			err(EX_OSERR, "ERROR: Cannot retrieve driver "
14357fbf3da2SJoseph Koshy 			    "statistics");
143649874f6eSJoseph Koshy 		if (ds_start.pm_intr_bufferfull != ds_end.pm_intr_bufferfull &&
143749874f6eSJoseph Koshy 		    args.pa_verbosity > 0)
1438bea6aa93SJoseph Koshy 			warnx("WARNING: some samples were dropped.  Please "
14397fbf3da2SJoseph Koshy 			    "consider tuning the \"kern.hwpmc.nsamples\" "
14407fbf3da2SJoseph Koshy 			    "tunable.");
14417fbf3da2SJoseph Koshy 		if (ds_start.pm_buffer_requests_failed !=
144249874f6eSJoseph Koshy 		    ds_end.pm_buffer_requests_failed &&
144349874f6eSJoseph Koshy 		    args.pa_verbosity > 0)
1444bea6aa93SJoseph Koshy 			warnx("WARNING: some events were discarded.  Please "
14457fbf3da2SJoseph Koshy 			    "consider tuning the \"kern.hwpmc.nbuffers\" "
14467fbf3da2SJoseph Koshy 			    "tunable.");
14477fbf3da2SJoseph Koshy 	}
14487fbf3da2SJoseph Koshy 
14497fbf3da2SJoseph Koshy 	exit(EX_OK);
1450ebccf1e3SJoseph Koshy }
1451