xref: /freebsd/usr.sbin/pmcstat/pmcstat.c (revision bf70becee6ff4798acdcfd586a88ad38b7b17495)
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 
34fbd8b34aSJoseph Koshy #include <sys/param.h>
35ea056888SAttilio Rao #include <sys/cpuset.h>
36ea056888SAttilio Rao #include <sys/event.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.
1013df5ecacSUlrich Spörlein  *					- Receives 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_displayheight = DEFAULT_DISPLAY_HEIGHT;
1090b86b1bbSFabien Thomas int		pmcstat_displaywidth  = DEFAULT_DISPLAY_WIDTH;
110*bf70beceSEd Schouten static int	pmcstat_sockpair[NSOCKPAIRFD];
111*bf70beceSEd Schouten static int	pmcstat_kq;
112*bf70beceSEd Schouten static kvm_t	*pmcstat_kvm;
113*bf70beceSEd Schouten static struct kinfo_proc *pmcstat_plist;
1140b86b1bbSFabien Thomas struct pmcstat_args args;
115ebccf1e3SJoseph Koshy 
116ea056888SAttilio Rao static void
117ea056888SAttilio Rao pmcstat_clone_event_descriptor(struct pmcstat_ev *ev, const cpuset_t *cpumask)
118ea056888SAttilio Rao {
119ea056888SAttilio Rao 	int cpu, mcpu;
120ea056888SAttilio Rao 	struct pmcstat_ev *ev_clone;
121ea056888SAttilio Rao 
122ea056888SAttilio Rao 	mcpu = sizeof(*cpumask) * NBBY;
123ea056888SAttilio Rao 	for (cpu = 0; cpu < mcpu; cpu++) {
124ea056888SAttilio Rao 		if (!CPU_ISSET(cpu, cpumask))
125ea056888SAttilio Rao 			continue;
126ea056888SAttilio Rao 
127ea056888SAttilio Rao 		if ((ev_clone = malloc(sizeof(*ev_clone))) == NULL)
128ea056888SAttilio Rao 			errx(EX_SOFTWARE, "ERROR: Out of memory");
129ea056888SAttilio Rao 		(void) memset(ev_clone, 0, sizeof(*ev_clone));
130ea056888SAttilio Rao 
131ea056888SAttilio Rao 		ev_clone->ev_count = ev->ev_count;
132ea056888SAttilio Rao 		ev_clone->ev_cpu   = cpu;
133ea056888SAttilio Rao 		ev_clone->ev_cumulative = ev->ev_cumulative;
134ea056888SAttilio Rao 		ev_clone->ev_flags = ev->ev_flags;
135ea056888SAttilio Rao 		ev_clone->ev_mode  = ev->ev_mode;
136ea056888SAttilio Rao 		ev_clone->ev_name  = strdup(ev->ev_name);
137ea056888SAttilio Rao 		ev_clone->ev_pmcid = ev->ev_pmcid;
138ea056888SAttilio Rao 		ev_clone->ev_saved = ev->ev_saved;
139ea056888SAttilio Rao 		ev_clone->ev_spec  = strdup(ev->ev_spec);
140ea056888SAttilio Rao 
141ea056888SAttilio Rao 		STAILQ_INSERT_TAIL(&args.pa_events, ev_clone, ev_next);
142ea056888SAttilio Rao 	}
143ea056888SAttilio Rao }
144ea056888SAttilio Rao 
145ea056888SAttilio Rao static void
146ea056888SAttilio Rao pmcstat_get_cpumask(const char *cpuspec, cpuset_t *cpumask)
147ea056888SAttilio Rao {
148ea056888SAttilio Rao 	int cpu;
149ea056888SAttilio Rao 	const char *s;
150ea056888SAttilio Rao 	char *end;
151ea056888SAttilio Rao 
152ea056888SAttilio Rao 	CPU_ZERO(cpumask);
153ea056888SAttilio Rao 	s = cpuspec;
154ea056888SAttilio Rao 
155ea056888SAttilio Rao 	do {
156ea056888SAttilio Rao 		cpu = strtol(s, &end, 0);
157ea056888SAttilio Rao 		if (cpu < 0 || end == s)
15837d6f8a9SDavid E. O'Brien 			errx(EX_USAGE,
15937d6f8a9SDavid E. O'Brien 			    "ERROR: Illegal CPU specification \"%s\".",
16037d6f8a9SDavid E. O'Brien 			    cpuspec);
161ea056888SAttilio Rao 		CPU_SET(cpu, cpumask);
162ea056888SAttilio Rao 		s = end + strspn(end, ", \t");
163ea056888SAttilio Rao 	} while (*s);
164ea056888SAttilio Rao }
165ea056888SAttilio Rao 
166ee4910b1SJoseph Koshy void
1670b86b1bbSFabien Thomas pmcstat_attach_pmcs(void)
168ee4910b1SJoseph Koshy {
169ee4910b1SJoseph Koshy 	struct pmcstat_ev *ev;
170fbd8b34aSJoseph Koshy 	struct pmcstat_target *pt;
171fbd8b34aSJoseph Koshy 	int count;
172ee4910b1SJoseph Koshy 
173fbd8b34aSJoseph Koshy 	/* Attach all process PMCs to target processes. */
174fbd8b34aSJoseph Koshy 	count = 0;
1750b86b1bbSFabien Thomas 	STAILQ_FOREACH(ev, &args.pa_events, ev_next) {
176fbd8b34aSJoseph Koshy 		if (PMC_IS_SYSTEM_MODE(ev->ev_mode))
177fbd8b34aSJoseph Koshy 			continue;
1780b86b1bbSFabien Thomas 		SLIST_FOREACH(pt, &args.pa_targets, pt_next)
179fbd8b34aSJoseph Koshy 			if (pmc_attach(ev->ev_pmcid, pt->pt_pid) == 0)
180fbd8b34aSJoseph Koshy 				count++;
181fbd8b34aSJoseph Koshy 			else if (errno != ESRCH)
18237d6f8a9SDavid E. O'Brien 				err(EX_OSERR,
18337d6f8a9SDavid E. O'Brien "ERROR: cannot attach pmc \"%s\" to process %d",
18437d6f8a9SDavid E. O'Brien 				    ev->ev_name, (int)pt->pt_pid);
185fbd8b34aSJoseph Koshy 	}
186ee4910b1SJoseph Koshy 
187fbd8b34aSJoseph Koshy 	if (count == 0)
188fbd8b34aSJoseph Koshy 		errx(EX_DATAERR, "ERROR: No processes were attached to.");
189ee4910b1SJoseph Koshy }
190ee4910b1SJoseph Koshy 
191ebccf1e3SJoseph Koshy 
192ebccf1e3SJoseph Koshy void
1930b86b1bbSFabien Thomas pmcstat_cleanup(void)
194ebccf1e3SJoseph Koshy {
195ebccf1e3SJoseph Koshy 	struct pmcstat_ev *ev, *tmp;
196ebccf1e3SJoseph Koshy 
197ebccf1e3SJoseph Koshy 	/* release allocated PMCs. */
1980b86b1bbSFabien Thomas 	STAILQ_FOREACH_SAFE(ev, &args.pa_events, ev_next, tmp)
199ebccf1e3SJoseph Koshy 	    if (ev->ev_pmcid != PMC_ID_INVALID) {
200b8fbd97bSJoseph Koshy 		if (pmc_stop(ev->ev_pmcid) < 0)
20137d6f8a9SDavid E. O'Brien 			err(EX_OSERR, "ERROR: cannot stop pmc 0x%x \"%s\"",
20237d6f8a9SDavid E. O'Brien 			    ev->ev_pmcid, ev->ev_name);
203ebccf1e3SJoseph Koshy 		if (pmc_release(ev->ev_pmcid) < 0)
20437d6f8a9SDavid E. O'Brien 			err(EX_OSERR, "ERROR: cannot release pmc 0x%x \"%s\"",
20537d6f8a9SDavid E. O'Brien 			    ev->ev_pmcid, ev->ev_name);
206ebccf1e3SJoseph Koshy 		free(ev->ev_name);
207ebccf1e3SJoseph Koshy 		free(ev->ev_spec);
2080b86b1bbSFabien Thomas 		STAILQ_REMOVE(&args.pa_events, ev, pmcstat_ev, ev_next);
209ebccf1e3SJoseph Koshy 		free(ev);
210ebccf1e3SJoseph Koshy 	    }
211f263522aSJoseph Koshy 
212dc1d9d2eSJoseph Koshy 	/* de-configure the log file if present. */
2130b86b1bbSFabien Thomas 	if (args.pa_flags & (FLAG_HAS_PIPE | FLAG_HAS_OUTPUT_LOGFILE))
214dc1d9d2eSJoseph Koshy 		(void) pmc_configure_logfile(-1);
215dc1d9d2eSJoseph Koshy 
2160b86b1bbSFabien Thomas 	if (args.pa_logparser) {
2170b86b1bbSFabien Thomas 		pmclog_close(args.pa_logparser);
2180b86b1bbSFabien Thomas 		args.pa_logparser = NULL;
219f263522aSJoseph Koshy 	}
22015139246SJoseph Koshy 
2210b86b1bbSFabien Thomas 	pmcstat_shutdown_logging();
222ebccf1e3SJoseph Koshy }
223ebccf1e3SJoseph Koshy 
224ebccf1e3SJoseph Koshy void
2250b86b1bbSFabien Thomas pmcstat_create_process(void)
226ee4910b1SJoseph Koshy {
227ee4910b1SJoseph Koshy 	char token;
228fbd8b34aSJoseph Koshy 	pid_t pid;
229ee4910b1SJoseph Koshy 	struct kevent kev;
230fbd8b34aSJoseph Koshy 	struct pmcstat_target *pt;
231ee4910b1SJoseph Koshy 
232ee4910b1SJoseph Koshy 	if (socketpair(AF_UNIX, SOCK_STREAM, 0, pmcstat_sockpair) < 0)
233ee4910b1SJoseph Koshy 		err(EX_OSERR, "ERROR: cannot create socket pair");
234ee4910b1SJoseph Koshy 
235fbd8b34aSJoseph Koshy 	switch (pid = fork()) {
236ee4910b1SJoseph Koshy 	case -1:
237ee4910b1SJoseph Koshy 		err(EX_OSERR, "ERROR: cannot fork");
238ee4910b1SJoseph Koshy 		/*NOTREACHED*/
239ee4910b1SJoseph Koshy 
240ee4910b1SJoseph Koshy 	case 0:		/* child */
241ee4910b1SJoseph Koshy 		(void) close(pmcstat_sockpair[PARENTSOCKET]);
242ee4910b1SJoseph Koshy 
243ee4910b1SJoseph Koshy 		/* Write a token to tell our parent we've started executing. */
244ee4910b1SJoseph Koshy 		if (write(pmcstat_sockpair[CHILDSOCKET], "+", 1) != 1)
245ee4910b1SJoseph Koshy 			err(EX_OSERR, "ERROR (child): cannot write token");
246ee4910b1SJoseph Koshy 
247ee4910b1SJoseph Koshy 		/* Wait for our parent to signal us to start. */
248ee4910b1SJoseph Koshy 		if (read(pmcstat_sockpair[CHILDSOCKET], &token, 1) < 0)
249ee4910b1SJoseph Koshy 			err(EX_OSERR, "ERROR (child): cannot read token");
250ee4910b1SJoseph Koshy 		(void) close(pmcstat_sockpair[CHILDSOCKET]);
251ee4910b1SJoseph Koshy 
252ee4910b1SJoseph Koshy 		/* exec() the program requested */
2530b86b1bbSFabien Thomas 		execvp(*args.pa_argv, args.pa_argv);
254ee4910b1SJoseph Koshy 		/* and if that fails, notify the parent */
255ee4910b1SJoseph Koshy 		kill(getppid(), SIGCHLD);
2560b86b1bbSFabien Thomas 		err(EX_OSERR, "ERROR: execvp \"%s\" failed", *args.pa_argv);
257ee4910b1SJoseph Koshy 		/*NOTREACHED*/
258ee4910b1SJoseph Koshy 
259ee4910b1SJoseph Koshy 	default:	/* parent */
260ee4910b1SJoseph Koshy 		(void) close(pmcstat_sockpair[CHILDSOCKET]);
261ee4910b1SJoseph Koshy 		break;
262ee4910b1SJoseph Koshy 	}
263ee4910b1SJoseph Koshy 
264ee4910b1SJoseph Koshy 	/* Ask to be notified via a kevent when the target process exits. */
265fbd8b34aSJoseph Koshy 	EV_SET(&kev, pid, EVFILT_PROC, EV_ADD|EV_ONESHOT, NOTE_EXIT, 0,
266ee4910b1SJoseph Koshy 	    NULL);
267ee4910b1SJoseph Koshy 	if (kevent(pmcstat_kq, &kev, 1, NULL, 0, NULL) < 0)
268fbd8b34aSJoseph Koshy 		err(EX_OSERR, "ERROR: cannot monitor child process %d", pid);
269fbd8b34aSJoseph Koshy 
270fbd8b34aSJoseph Koshy 	if ((pt = malloc(sizeof(*pt))) == NULL)
271fbd8b34aSJoseph Koshy 		errx(EX_SOFTWARE, "ERROR: Out of memory.");
272fbd8b34aSJoseph Koshy 
273fbd8b34aSJoseph Koshy 	pt->pt_pid = pid;
2740b86b1bbSFabien Thomas 	SLIST_INSERT_HEAD(&args.pa_targets, pt, pt_next);
275ee4910b1SJoseph Koshy 
276ee4910b1SJoseph Koshy 	/* Wait for the child to signal that its ready to go. */
277ee4910b1SJoseph Koshy 	if (read(pmcstat_sockpair[PARENTSOCKET], &token, 1) < 0)
278ee4910b1SJoseph Koshy 		err(EX_OSERR, "ERROR (parent): cannot read token");
279ee4910b1SJoseph Koshy 
280ee4910b1SJoseph Koshy 	return;
281ee4910b1SJoseph Koshy }
282ee4910b1SJoseph Koshy 
283fbd8b34aSJoseph Koshy void
2840b86b1bbSFabien Thomas pmcstat_find_targets(const char *spec)
285fbd8b34aSJoseph Koshy {
286fbd8b34aSJoseph Koshy 	int n, nproc, pid, rv;
287fbd8b34aSJoseph Koshy 	struct pmcstat_target *pt;
288fbd8b34aSJoseph Koshy 	char errbuf[_POSIX2_LINE_MAX], *end;
289fbd8b34aSJoseph Koshy 	static struct kinfo_proc *kp;
290fbd8b34aSJoseph Koshy 	regex_t reg;
291fbd8b34aSJoseph Koshy 	regmatch_t regmatch;
292fbd8b34aSJoseph Koshy 
293fbd8b34aSJoseph Koshy 	/* First check if we've been given a process id. */
294fbd8b34aSJoseph Koshy       	pid = strtol(spec, &end, 0);
295fbd8b34aSJoseph Koshy 	if (end != spec && pid >= 0) {
296fbd8b34aSJoseph Koshy 		if ((pt = malloc(sizeof(*pt))) == NULL)
297fbd8b34aSJoseph Koshy 			goto outofmemory;
298fbd8b34aSJoseph Koshy 		pt->pt_pid = pid;
2990b86b1bbSFabien Thomas 		SLIST_INSERT_HEAD(&args.pa_targets, pt, pt_next);
300fbd8b34aSJoseph Koshy 		return;
301fbd8b34aSJoseph Koshy 	}
302fbd8b34aSJoseph Koshy 
303fbd8b34aSJoseph Koshy 	/* Otherwise treat arg as a regular expression naming processes. */
304fbd8b34aSJoseph Koshy 	if (pmcstat_kvm == NULL) {
305fbd8b34aSJoseph Koshy 		if ((pmcstat_kvm = kvm_openfiles(NULL, "/dev/null", NULL, 0,
306fbd8b34aSJoseph Koshy 		    errbuf)) == NULL)
307fbd8b34aSJoseph Koshy 			err(EX_OSERR, "ERROR: Cannot open kernel \"%s\"",
308fbd8b34aSJoseph Koshy 			    errbuf);
309fbd8b34aSJoseph Koshy 		if ((pmcstat_plist = kvm_getprocs(pmcstat_kvm, KERN_PROC_PROC,
310fbd8b34aSJoseph Koshy 		    0, &nproc)) == NULL)
311fbd8b34aSJoseph Koshy 			err(EX_OSERR, "ERROR: Cannot get process list: %s",
312fbd8b34aSJoseph Koshy 			    kvm_geterr(pmcstat_kvm));
3135c15d3c8SFabien Thomas 	} else
3145c15d3c8SFabien Thomas 		nproc = 0;
315fbd8b34aSJoseph Koshy 
316fbd8b34aSJoseph Koshy 	if ((rv = regcomp(&reg, spec, REG_EXTENDED|REG_NOSUB)) != 0) {
317fbd8b34aSJoseph Koshy 		regerror(rv, &reg, errbuf, sizeof(errbuf));
318fbd8b34aSJoseph Koshy 		err(EX_DATAERR, "ERROR: Failed to compile regex \"%s\": %s",
319fbd8b34aSJoseph Koshy 		    spec, errbuf);
320fbd8b34aSJoseph Koshy 	}
321fbd8b34aSJoseph Koshy 
322fbd8b34aSJoseph Koshy 	for (n = 0, kp = pmcstat_plist; n < nproc; n++, kp++) {
323fbd8b34aSJoseph Koshy 		if ((rv = regexec(&reg, kp->ki_comm, 1, &regmatch, 0)) == 0) {
324fbd8b34aSJoseph Koshy 			if ((pt = malloc(sizeof(*pt))) == NULL)
325fbd8b34aSJoseph Koshy 				goto outofmemory;
326fbd8b34aSJoseph Koshy 			pt->pt_pid = kp->ki_pid;
3270b86b1bbSFabien Thomas 			SLIST_INSERT_HEAD(&args.pa_targets, pt, pt_next);
328fbd8b34aSJoseph Koshy 		} else if (rv != REG_NOMATCH) {
329fbd8b34aSJoseph Koshy 			regerror(rv, &reg, errbuf, sizeof(errbuf));
330fbd8b34aSJoseph Koshy 			errx(EX_SOFTWARE, "ERROR: Regex evalation failed: %s",
331fbd8b34aSJoseph Koshy 			    errbuf);
332fbd8b34aSJoseph Koshy 		}
333fbd8b34aSJoseph Koshy 	}
334fbd8b34aSJoseph Koshy 
335fbd8b34aSJoseph Koshy 	regfree(&reg);
336fbd8b34aSJoseph Koshy 
337fbd8b34aSJoseph Koshy 	return;
338fbd8b34aSJoseph Koshy 
339fbd8b34aSJoseph Koshy  outofmemory:
340fbd8b34aSJoseph Koshy 	errx(EX_SOFTWARE, "Out of memory.");
341fbd8b34aSJoseph Koshy 	/*NOTREACHED*/
342fbd8b34aSJoseph Koshy }
343fbd8b34aSJoseph Koshy 
344ee4910b1SJoseph Koshy void
3450b86b1bbSFabien Thomas pmcstat_kill_process(void)
346fbd8b34aSJoseph Koshy {
347fbd8b34aSJoseph Koshy 	struct pmcstat_target *pt;
348fbd8b34aSJoseph Koshy 
3490b86b1bbSFabien Thomas 	assert(args.pa_flags & FLAG_HAS_COMMANDLINE);
350fbd8b34aSJoseph Koshy 
351fbd8b34aSJoseph Koshy 	/*
352fbd8b34aSJoseph Koshy 	 * If a command line was specified, it would be the very first
353fbd8b34aSJoseph Koshy 	 * in the list, before any other processes specified by -t.
354fbd8b34aSJoseph Koshy 	 */
3550b86b1bbSFabien Thomas 	pt = SLIST_FIRST(&args.pa_targets);
356fbd8b34aSJoseph Koshy 	assert(pt != NULL);
357fbd8b34aSJoseph Koshy 
358fbd8b34aSJoseph Koshy 	if (kill(pt->pt_pid, SIGINT) != 0)
359fbd8b34aSJoseph Koshy 		err(EX_OSERR, "ERROR: cannot signal child process");
360fbd8b34aSJoseph Koshy }
361fbd8b34aSJoseph Koshy 
362fbd8b34aSJoseph Koshy void
3630b86b1bbSFabien Thomas pmcstat_start_pmcs(void)
364ebccf1e3SJoseph Koshy {
365ebccf1e3SJoseph Koshy 	struct pmcstat_ev *ev;
366ebccf1e3SJoseph Koshy 
367fbd8b34aSJoseph Koshy 	STAILQ_FOREACH(ev, &args.pa_events, ev_next) {
368ebccf1e3SJoseph Koshy 
369ebccf1e3SJoseph Koshy 	    assert(ev->ev_pmcid != PMC_ID_INVALID);
370ebccf1e3SJoseph Koshy 
371ebccf1e3SJoseph Koshy 	    if (pmc_start(ev->ev_pmcid) < 0) {
372f263522aSJoseph Koshy 	        warn("ERROR: Cannot start pmc 0x%x \"%s\"",
373ebccf1e3SJoseph Koshy 		    ev->ev_pmcid, ev->ev_name);
3740b86b1bbSFabien Thomas 		pmcstat_cleanup();
375f263522aSJoseph Koshy 		exit(EX_OSERR);
376ebccf1e3SJoseph Koshy 	    }
377ebccf1e3SJoseph Koshy 	}
378ebccf1e3SJoseph Koshy 
379ebccf1e3SJoseph Koshy }
380ebccf1e3SJoseph Koshy 
381ebccf1e3SJoseph Koshy void
3820b86b1bbSFabien Thomas pmcstat_print_headers(void)
383ebccf1e3SJoseph Koshy {
384ebccf1e3SJoseph Koshy 	struct pmcstat_ev *ev;
385ee4910b1SJoseph Koshy 	int c, w;
386ebccf1e3SJoseph Koshy 
3870b86b1bbSFabien Thomas 	(void) fprintf(args.pa_printfile, PRINT_HEADER_PREFIX);
388ebccf1e3SJoseph Koshy 
3890b86b1bbSFabien Thomas 	STAILQ_FOREACH(ev, &args.pa_events, ev_next) {
390ebccf1e3SJoseph Koshy 		if (PMC_IS_SAMPLING_MODE(ev->ev_mode))
391ebccf1e3SJoseph Koshy 			continue;
392ebccf1e3SJoseph Koshy 
393ebccf1e3SJoseph Koshy 		c = PMC_IS_SYSTEM_MODE(ev->ev_mode) ? 's' : 'p';
394ebccf1e3SJoseph Koshy 
395ee4910b1SJoseph Koshy 		if (ev->ev_fieldskip != 0)
3960b86b1bbSFabien Thomas 			(void) fprintf(args.pa_printfile, "%*s",
397ee4910b1SJoseph Koshy 			    ev->ev_fieldskip, "");
398ee4910b1SJoseph Koshy 		w = ev->ev_fieldwidth - ev->ev_fieldskip - 2;
399ee4910b1SJoseph Koshy 
400ee4910b1SJoseph Koshy 		if (c == 's')
4010b86b1bbSFabien Thomas 			(void) fprintf(args.pa_printfile, "s/%02d/%-*s ",
402ee4910b1SJoseph Koshy 			    ev->ev_cpu, w-3, ev->ev_name);
403ee4910b1SJoseph Koshy 		else
4040b86b1bbSFabien Thomas 			(void) fprintf(args.pa_printfile, "p/%*s ", w,
405ebccf1e3SJoseph Koshy 			    ev->ev_name);
406ebccf1e3SJoseph Koshy 	}
407ebccf1e3SJoseph Koshy 
4080b86b1bbSFabien Thomas 	(void) fflush(args.pa_printfile);
409ebccf1e3SJoseph Koshy }
410ebccf1e3SJoseph Koshy 
411ebccf1e3SJoseph Koshy void
4120b86b1bbSFabien Thomas pmcstat_print_counters(void)
413ebccf1e3SJoseph Koshy {
414ebccf1e3SJoseph Koshy 	int extra_width;
415ebccf1e3SJoseph Koshy 	struct pmcstat_ev *ev;
416ebccf1e3SJoseph Koshy 	pmc_value_t value;
417ebccf1e3SJoseph Koshy 
418ebccf1e3SJoseph Koshy 	extra_width = sizeof(PRINT_HEADER_PREFIX) - 1;
419ebccf1e3SJoseph Koshy 
4200b86b1bbSFabien Thomas 	STAILQ_FOREACH(ev, &args.pa_events, ev_next) {
421ebccf1e3SJoseph Koshy 
422ebccf1e3SJoseph Koshy 		/* skip sampling mode counters */
423ebccf1e3SJoseph Koshy 		if (PMC_IS_SAMPLING_MODE(ev->ev_mode))
424ebccf1e3SJoseph Koshy 			continue;
425ebccf1e3SJoseph Koshy 
426ebccf1e3SJoseph Koshy 		if (pmc_read(ev->ev_pmcid, &value) < 0)
42737d6f8a9SDavid E. O'Brien 			err(EX_OSERR, "ERROR: Cannot read pmc \"%s\"",
42837d6f8a9SDavid E. O'Brien 			    ev->ev_name);
429ebccf1e3SJoseph Koshy 
4300b86b1bbSFabien Thomas 		(void) fprintf(args.pa_printfile, "%*ju ",
43115139246SJoseph Koshy 		    ev->ev_fieldwidth + extra_width,
43215139246SJoseph Koshy 		    (uintmax_t) ev->ev_cumulative ? value :
43315139246SJoseph Koshy 		    (value - ev->ev_saved));
43415139246SJoseph Koshy 
435ebccf1e3SJoseph Koshy 		if (ev->ev_cumulative == 0)
436ebccf1e3SJoseph Koshy 			ev->ev_saved = value;
437ebccf1e3SJoseph Koshy 		extra_width = 0;
438ebccf1e3SJoseph Koshy 	}
439ebccf1e3SJoseph Koshy 
4400b86b1bbSFabien Thomas 	(void) fflush(args.pa_printfile);
441ebccf1e3SJoseph Koshy }
442ebccf1e3SJoseph Koshy 
443ebccf1e3SJoseph Koshy /*
444ebccf1e3SJoseph Koshy  * Print output
445ebccf1e3SJoseph Koshy  */
446ebccf1e3SJoseph Koshy 
447ebccf1e3SJoseph Koshy void
4480b86b1bbSFabien Thomas pmcstat_print_pmcs(void)
449ebccf1e3SJoseph Koshy {
450ebccf1e3SJoseph Koshy 	static int linecount = 0;
451ebccf1e3SJoseph Koshy 
45215139246SJoseph Koshy 	/* check if we need to print a header line */
453ebccf1e3SJoseph Koshy 	if (++linecount > pmcstat_displayheight) {
4540b86b1bbSFabien Thomas 		(void) fprintf(args.pa_printfile, "\n");
455ebccf1e3SJoseph Koshy 		linecount = 1;
456ebccf1e3SJoseph Koshy 	}
457ebccf1e3SJoseph Koshy 	if (linecount == 1)
4580b86b1bbSFabien Thomas 		pmcstat_print_headers();
4590b86b1bbSFabien Thomas 	(void) fprintf(args.pa_printfile, "\n");
460ebccf1e3SJoseph Koshy 
4610b86b1bbSFabien Thomas 	pmcstat_print_counters();
462ebccf1e3SJoseph Koshy 
463ebccf1e3SJoseph Koshy 	return;
464ebccf1e3SJoseph Koshy }
465ebccf1e3SJoseph Koshy 
466ebccf1e3SJoseph Koshy /*
467ebccf1e3SJoseph Koshy  * Do process profiling
468ebccf1e3SJoseph Koshy  *
469ebccf1e3SJoseph Koshy  * If a pid was specified, attach each allocated PMC to the target
470ebccf1e3SJoseph Koshy  * process.  Otherwise, fork a child and attach the PMCs to the child,
471ebccf1e3SJoseph Koshy  * and have the child exec() the target program.
472ebccf1e3SJoseph Koshy  */
473ebccf1e3SJoseph Koshy 
474ebccf1e3SJoseph Koshy void
475ee4910b1SJoseph Koshy pmcstat_start_process(void)
476ebccf1e3SJoseph Koshy {
477ee4910b1SJoseph Koshy 	/* Signal the child to proceed. */
478ee4910b1SJoseph Koshy 	if (write(pmcstat_sockpair[PARENTSOCKET], "!", 1) != 1)
479ee4910b1SJoseph Koshy 		err(EX_OSERR, "ERROR (parent): write of token failed");
480ebccf1e3SJoseph Koshy 
481ee4910b1SJoseph Koshy 	(void) close(pmcstat_sockpair[PARENTSOCKET]);
482ebccf1e3SJoseph Koshy }
483ebccf1e3SJoseph Koshy 
484ebccf1e3SJoseph Koshy void
485ebccf1e3SJoseph Koshy pmcstat_show_usage(void)
486ebccf1e3SJoseph Koshy {
487ebccf1e3SJoseph Koshy 	errx(EX_USAGE,
488ebccf1e3SJoseph Koshy 	    "[options] [commandline]\n"
489ebccf1e3SJoseph Koshy 	    "\t Measure process and/or system performance using hardware\n"
490ebccf1e3SJoseph Koshy 	    "\t performance monitoring counters.\n"
491ebccf1e3SJoseph Koshy 	    "\t Options include:\n"
492f263522aSJoseph Koshy 	    "\t -C\t\t (toggle) show cumulative counts\n"
493f263522aSJoseph Koshy 	    "\t -D path\t create profiles in directory \"path\"\n"
494f263522aSJoseph Koshy 	    "\t -E\t\t (toggle) show counts at process exit\n"
4950b86b1bbSFabien Thomas 	    "\t -F file\t write a system-wide callgraph (Kcachegrind format)"
4960b86b1bbSFabien Thomas 		" to \"file\"\n"
497b6010f9eSJoseph Koshy 	    "\t -G file\t write a system-wide callgraph to \"file\"\n"
49849874f6eSJoseph Koshy 	    "\t -M file\t print executable/gmon file map to \"file\"\n"
499b6010f9eSJoseph Koshy 	    "\t -N\t\t (toggle) capture callchains\n"
500f263522aSJoseph Koshy 	    "\t -O file\t send log output to \"file\"\n"
501f263522aSJoseph Koshy 	    "\t -P spec\t allocate a process-private sampling PMC\n"
502f263522aSJoseph Koshy 	    "\t -R file\t read events from \"file\"\n"
503f263522aSJoseph Koshy 	    "\t -S spec\t allocate a system-wide sampling PMC\n"
5040b86b1bbSFabien Thomas 	    "\t -T\t\t start in top mode\n"
505f263522aSJoseph Koshy 	    "\t -W\t\t (toggle) show counts per context switch\n"
506ee4910b1SJoseph Koshy 	    "\t -c cpu-list\t set cpus for subsequent system-wide PMCs\n"
507f263522aSJoseph Koshy 	    "\t -d\t\t (toggle) track descendants\n"
5080b86b1bbSFabien Thomas 	    "\t -f spec\t pass \"spec\" to as plugin option\n"
509f263522aSJoseph Koshy 	    "\t -g\t\t produce gprof(1) compatible profiles\n"
51024bffe06SRuslan Ermilov 	    "\t -k dir\t\t set the path to the kernel\n"
51133b12a85SJim Harris 	    "\t -m file\t print sampled PCs to \"file\"\n"
512ebccf1e3SJoseph Koshy 	    "\t -n rate\t set sampling rate\n"
513ebccf1e3SJoseph Koshy 	    "\t -o file\t send print output to \"file\"\n"
514f263522aSJoseph Koshy 	    "\t -p spec\t allocate a process-private counting PMC\n"
51549874f6eSJoseph Koshy 	    "\t -q\t\t suppress verbosity\n"
51649874f6eSJoseph Koshy 	    "\t -r fsroot\t specify FS root directory\n"
517f263522aSJoseph Koshy 	    "\t -s spec\t allocate a system-wide counting PMC\n"
51867442c6eSJoseph Koshy 	    "\t -t process-spec attach to running processes matching "
51967442c6eSJoseph Koshy 		"\"process-spec\"\n"
52049874f6eSJoseph Koshy 	    "\t -v\t\t increase verbosity\n"
521b6010f9eSJoseph Koshy 	    "\t -w secs\t set printing time interval\n"
522b6010f9eSJoseph Koshy 	    "\t -z depth\t limit callchain display depth"
523ebccf1e3SJoseph Koshy 	);
524ebccf1e3SJoseph Koshy }
525ebccf1e3SJoseph Koshy 
526ebccf1e3SJoseph Koshy /*
5270b86b1bbSFabien Thomas  * At exit handler for top mode
5280b86b1bbSFabien Thomas  */
5290b86b1bbSFabien Thomas 
5300b86b1bbSFabien Thomas void
5310b86b1bbSFabien Thomas pmcstat_topexit(void)
5320b86b1bbSFabien Thomas {
5330b86b1bbSFabien Thomas 	if (!args.pa_toptty)
5340b86b1bbSFabien Thomas 		return;
5350b86b1bbSFabien Thomas 
5360b86b1bbSFabien Thomas 	/*
5370b86b1bbSFabien Thomas 	 * Shutdown ncurses.
5380b86b1bbSFabien Thomas 	 */
5390b86b1bbSFabien Thomas 	clrtoeol();
5400b86b1bbSFabien Thomas 	refresh();
5410b86b1bbSFabien Thomas 	endwin();
5420b86b1bbSFabien Thomas }
5430b86b1bbSFabien Thomas 
5440b86b1bbSFabien Thomas /*
545ebccf1e3SJoseph Koshy  * Main
546ebccf1e3SJoseph Koshy  */
547ebccf1e3SJoseph Koshy 
548ebccf1e3SJoseph Koshy int
549ebccf1e3SJoseph Koshy main(int argc, char **argv)
550ebccf1e3SJoseph Koshy {
551ea056888SAttilio Rao 	cpuset_t cpumask;
552ebccf1e3SJoseph Koshy 	double interval;
553ea056888SAttilio Rao 	int hcpu, option, npmc, ncpu;
554831b9630SEitan Adler 	int c, check_driver_stats, current_sampling_count;
555b6010f9eSJoseph Koshy 	int do_callchain, do_descendants, do_logproccsw, do_logprocexit;
556dceed24aSFabien Thomas 	int do_print, do_read;
557ee4910b1SJoseph Koshy 	size_t dummy;
558b6010f9eSJoseph Koshy 	int graphdepth;
559ac708fddSFabien Thomas 	int pipefd[2], rfd;
560f263522aSJoseph Koshy 	int use_cumulative_counts;
5610b86b1bbSFabien Thomas 	short cf, cb;
56249874f6eSJoseph Koshy 	char *end, *tmp;
563b6010f9eSJoseph Koshy 	const char *errmsg, *graphfilename;
564f263522aSJoseph Koshy 	enum pmcstat_state runstate;
5657fbf3da2SJoseph Koshy 	struct pmc_driverstats ds_start, ds_end;
566ebccf1e3SJoseph Koshy 	struct pmcstat_ev *ev;
567ebccf1e3SJoseph Koshy 	struct sigaction sa;
568ebccf1e3SJoseph Koshy 	struct kevent kev;
569ebccf1e3SJoseph Koshy 	struct winsize ws;
57015139246SJoseph Koshy 	struct stat sb;
57149874f6eSJoseph Koshy 	char buffer[PATH_MAX];
572ebccf1e3SJoseph Koshy 
5737fbf3da2SJoseph Koshy 	check_driver_stats      = 0;
574ebccf1e3SJoseph Koshy 	current_sampling_count  = DEFAULT_SAMPLE_COUNT;
575b6010f9eSJoseph Koshy 	do_callchain		= 1;
576ebccf1e3SJoseph Koshy 	do_descendants          = 0;
577f263522aSJoseph Koshy 	do_logproccsw           = 0;
578f263522aSJoseph Koshy 	do_logprocexit          = 0;
579ebccf1e3SJoseph Koshy 	use_cumulative_counts   = 0;
580b6010f9eSJoseph Koshy 	graphfilename		= "-";
581f263522aSJoseph Koshy 	args.pa_required	= 0;
582ebccf1e3SJoseph Koshy 	args.pa_flags		= 0;
58349874f6eSJoseph Koshy 	args.pa_verbosity	= 1;
58415139246SJoseph Koshy 	args.pa_logfd		= -1;
58549874f6eSJoseph Koshy 	args.pa_fsroot		= "";
58649874f6eSJoseph Koshy 	args.pa_kernel		= strdup("/boot/kernel");
58715139246SJoseph Koshy 	args.pa_samplesdir	= ".";
58815139246SJoseph Koshy 	args.pa_printfile	= stderr;
589b6010f9eSJoseph Koshy 	args.pa_graphdepth	= DEFAULT_CALLGRAPH_DEPTH;
590b6010f9eSJoseph Koshy 	args.pa_graphfile	= NULL;
591ebccf1e3SJoseph Koshy 	args.pa_interval	= DEFAULT_WAIT_INTERVAL;
59249874f6eSJoseph Koshy 	args.pa_mapfilename	= NULL;
593b6010f9eSJoseph Koshy 	args.pa_inputpath	= NULL;
594b6010f9eSJoseph Koshy 	args.pa_outputpath	= NULL;
5950b86b1bbSFabien Thomas 	args.pa_pplugin		= PMCSTAT_PL_NONE;
5960b86b1bbSFabien Thomas 	args.pa_plugin		= PMCSTAT_PL_NONE;
5970b86b1bbSFabien Thomas 	args.pa_ctdumpinstr	= 1;
5980b86b1bbSFabien Thomas 	args.pa_topmode		= PMCSTAT_TOP_DELTA;
5990b86b1bbSFabien Thomas 	args.pa_toptty		= 0;
6000b86b1bbSFabien Thomas 	args.pa_topcolor	= 0;
6010b86b1bbSFabien Thomas 	args.pa_mergepmc	= 0;
602fbd8b34aSJoseph Koshy 	STAILQ_INIT(&args.pa_events);
603fbd8b34aSJoseph Koshy 	SLIST_INIT(&args.pa_targets);
604bea6aa93SJoseph Koshy 	bzero(&ds_start, sizeof(ds_start));
605bea6aa93SJoseph Koshy 	bzero(&ds_end, sizeof(ds_end));
606ebccf1e3SJoseph Koshy 	ev = NULL;
607ea056888SAttilio Rao 	CPU_ZERO(&cpumask);
608ebccf1e3SJoseph Koshy 
609b6010f9eSJoseph Koshy 	/*
610b6010f9eSJoseph Koshy 	 * The initial CPU mask specifies all non-halted CPUS in the
611b6010f9eSJoseph Koshy 	 * system.
612b6010f9eSJoseph Koshy 	 */
613b6010f9eSJoseph Koshy 	dummy = sizeof(int);
614ee4910b1SJoseph Koshy 	if (sysctlbyname("hw.ncpu", &ncpu, &dummy, NULL, 0) < 0)
615b6010f9eSJoseph Koshy 		err(EX_OSERR, "ERROR: Cannot determine the number of CPUs");
616ea056888SAttilio Rao 	for (hcpu = 0; hcpu < ncpu; hcpu++)
617ea056888SAttilio Rao 		CPU_SET(hcpu, &cpumask);
618ee4910b1SJoseph Koshy 
61949874f6eSJoseph Koshy 	while ((option = getopt(argc, argv,
6200b86b1bbSFabien Thomas 	    "CD:EF:G:M:NO:P:R:S:TWc:df:gk:m:n:o:p:qr:s:t:vw:z:")) != -1)
621ebccf1e3SJoseph Koshy 		switch (option) {
622ebccf1e3SJoseph Koshy 		case 'C':	/* cumulative values */
623ebccf1e3SJoseph Koshy 			use_cumulative_counts = !use_cumulative_counts;
624f263522aSJoseph Koshy 			args.pa_required |= FLAG_HAS_COUNTING_PMCS;
625ebccf1e3SJoseph Koshy 			break;
626ebccf1e3SJoseph Koshy 
627ebccf1e3SJoseph Koshy 		case 'c':	/* CPU */
628ee4910b1SJoseph Koshy 
629ea056888SAttilio Rao 			if (optarg[0] == '*' && optarg[1] == '\0') {
630ea056888SAttilio Rao 				for (hcpu = 0; hcpu < ncpu; hcpu++)
631ea056888SAttilio Rao 					CPU_SET(hcpu, &cpumask);
632ea056888SAttilio Rao 			} else
633ea056888SAttilio Rao 				pmcstat_get_cpumask(optarg, &cpumask);
634ee4910b1SJoseph Koshy 
635e7ef1de5SFabien Thomas 			args.pa_flags	 |= FLAGS_HAS_CPUMASK;
636f263522aSJoseph Koshy 			args.pa_required |= FLAG_HAS_SYSTEM_PMCS;
637ebccf1e3SJoseph Koshy 			break;
638ebccf1e3SJoseph Koshy 
63915139246SJoseph Koshy 		case 'D':
64015139246SJoseph Koshy 			if (stat(optarg, &sb) < 0)
64115139246SJoseph Koshy 				err(EX_OSERR, "ERROR: Cannot stat \"%s\"",
64215139246SJoseph Koshy 				    optarg);
64315139246SJoseph Koshy 			if (!S_ISDIR(sb.st_mode))
64437d6f8a9SDavid E. O'Brien 				errx(EX_USAGE,
64537d6f8a9SDavid E. O'Brien 				    "ERROR: \"%s\" is not a directory.",
64637d6f8a9SDavid E. O'Brien 				    optarg);
64715139246SJoseph Koshy 			args.pa_samplesdir = optarg;
64815139246SJoseph Koshy 			args.pa_flags     |= FLAG_HAS_SAMPLESDIR;
64915139246SJoseph Koshy 			args.pa_required  |= FLAG_DO_GPROF;
65015139246SJoseph Koshy 			break;
65115139246SJoseph Koshy 
652ebccf1e3SJoseph Koshy 		case 'd':	/* toggle descendents */
653ebccf1e3SJoseph Koshy 			do_descendants = !do_descendants;
654f263522aSJoseph Koshy 			args.pa_required |= FLAG_HAS_PROCESS_PMCS;
655f263522aSJoseph Koshy 			break;
656f263522aSJoseph Koshy 
6570b86b1bbSFabien Thomas 		case 'F':	/* produce a system-wide calltree */
6580b86b1bbSFabien Thomas 			args.pa_flags |= FLAG_DO_CALLGRAPHS;
6590b86b1bbSFabien Thomas 			args.pa_plugin = PMCSTAT_PL_CALLTREE;
6600b86b1bbSFabien Thomas 			graphfilename = optarg;
6610b86b1bbSFabien Thomas 			break;
6620b86b1bbSFabien Thomas 
6630b86b1bbSFabien Thomas 		case 'f':	/* plugins options */
6640b86b1bbSFabien Thomas 			if (args.pa_plugin == PMCSTAT_PL_NONE)
6650b86b1bbSFabien Thomas 				err(EX_USAGE, "ERROR: Need -g/-G/-m/-T.");
6660b86b1bbSFabien Thomas 			pmcstat_pluginconfigure_log(optarg);
6670b86b1bbSFabien Thomas 			break;
6680b86b1bbSFabien Thomas 
669b6010f9eSJoseph Koshy 		case 'G':	/* produce a system-wide callgraph */
670b6010f9eSJoseph Koshy 			args.pa_flags |= FLAG_DO_CALLGRAPHS;
6710b86b1bbSFabien Thomas 			args.pa_plugin = PMCSTAT_PL_CALLGRAPH;
672b6010f9eSJoseph Koshy 			graphfilename = optarg;
673b6010f9eSJoseph Koshy 			break;
674b6010f9eSJoseph Koshy 
675f263522aSJoseph Koshy 		case 'g':	/* produce gprof compatible profiles */
676f263522aSJoseph Koshy 			args.pa_flags |= FLAG_DO_GPROF;
6770b86b1bbSFabien Thomas 			args.pa_pplugin = PMCSTAT_PL_CALLGRAPH;
6780b86b1bbSFabien Thomas 			args.pa_plugin	= PMCSTAT_PL_GPROF;
679f263522aSJoseph Koshy 			break;
680f263522aSJoseph Koshy 
68115139246SJoseph Koshy 		case 'k':	/* pathname to the kernel */
68249874f6eSJoseph Koshy 			free(args.pa_kernel);
68349874f6eSJoseph Koshy 			args.pa_kernel = strdup(optarg);
684b6010f9eSJoseph Koshy 			args.pa_required |= FLAG_DO_ANALYSIS;
68515139246SJoseph Koshy 			args.pa_flags    |= FLAG_HAS_KERNELPATH;
686f263522aSJoseph Koshy 			break;
687f263522aSJoseph Koshy 
688c0252222SAttilio Rao 		case 'm':
6890b86b1bbSFabien Thomas 			args.pa_flags |= FLAG_DO_ANNOTATE;
6900b86b1bbSFabien Thomas 			args.pa_plugin = PMCSTAT_PL_ANNOTATE;
691c0252222SAttilio Rao 			graphfilename  = optarg;
692c0252222SAttilio Rao 			break;
693c0252222SAttilio Rao 
694f263522aSJoseph Koshy 		case 'E':	/* log process exit */
695f263522aSJoseph Koshy 			do_logprocexit = !do_logprocexit;
696f263522aSJoseph Koshy 			args.pa_required |= (FLAG_HAS_PROCESS_PMCS |
69715139246SJoseph Koshy 			    FLAG_HAS_COUNTING_PMCS | FLAG_HAS_OUTPUT_LOGFILE);
698ebccf1e3SJoseph Koshy 			break;
699ebccf1e3SJoseph Koshy 
70049874f6eSJoseph Koshy 		case 'M':	/* mapfile */
70149874f6eSJoseph Koshy 			args.pa_mapfilename = optarg;
70249874f6eSJoseph Koshy 			break;
70349874f6eSJoseph Koshy 
704b6010f9eSJoseph Koshy 		case 'N':
705b6010f9eSJoseph Koshy 			do_callchain = !do_callchain;
706b6010f9eSJoseph Koshy 			args.pa_required |= FLAG_HAS_SAMPLING_PMCS;
707b6010f9eSJoseph Koshy 			break;
708b6010f9eSJoseph Koshy 
709ebccf1e3SJoseph Koshy 		case 'p':	/* process virtual counting PMC */
710ebccf1e3SJoseph Koshy 		case 's':	/* system-wide counting PMC */
711ebccf1e3SJoseph Koshy 		case 'P':	/* process virtual sampling PMC */
712ebccf1e3SJoseph Koshy 		case 'S':	/* system-wide sampling PMC */
713ebccf1e3SJoseph Koshy 			if ((ev = malloc(sizeof(*ev))) == NULL)
714f263522aSJoseph Koshy 				errx(EX_SOFTWARE, "ERROR: Out of memory.");
715ebccf1e3SJoseph Koshy 
716ebccf1e3SJoseph Koshy 			switch (option) {
717ebccf1e3SJoseph Koshy 			case 'p': ev->ev_mode = PMC_MODE_TC; break;
718ebccf1e3SJoseph Koshy 			case 's': ev->ev_mode = PMC_MODE_SC; break;
719ebccf1e3SJoseph Koshy 			case 'P': ev->ev_mode = PMC_MODE_TS; break;
720ebccf1e3SJoseph Koshy 			case 'S': ev->ev_mode = PMC_MODE_SS; break;
721ebccf1e3SJoseph Koshy 			}
722ebccf1e3SJoseph Koshy 
723f263522aSJoseph Koshy 			if (option == 'P' || option == 'p') {
724f263522aSJoseph Koshy 				args.pa_flags |= FLAG_HAS_PROCESS_PMCS;
72515139246SJoseph Koshy 				args.pa_required |= (FLAG_HAS_COMMANDLINE |
726fbd8b34aSJoseph Koshy 				    FLAG_HAS_TARGET);
727f263522aSJoseph Koshy 			}
728ebccf1e3SJoseph Koshy 
729f263522aSJoseph Koshy 			if (option == 'P' || option == 'S') {
730f263522aSJoseph Koshy 				args.pa_flags |= FLAG_HAS_SAMPLING_PMCS;
73115139246SJoseph Koshy 				args.pa_required |= (FLAG_HAS_PIPE |
73215139246SJoseph Koshy 				    FLAG_HAS_OUTPUT_LOGFILE);
733f263522aSJoseph Koshy 			}
734ebccf1e3SJoseph Koshy 
735ebccf1e3SJoseph Koshy 			if (option == 'p' || option == 's')
736f263522aSJoseph Koshy 				args.pa_flags |= FLAG_HAS_COUNTING_PMCS;
737f263522aSJoseph Koshy 
738f263522aSJoseph Koshy 			if (option == 's' || option == 'S')
739f263522aSJoseph Koshy 				args.pa_flags |= FLAG_HAS_SYSTEM_PMCS;
740ebccf1e3SJoseph Koshy 
741ebccf1e3SJoseph Koshy 			ev->ev_spec  = strdup(optarg);
742ebccf1e3SJoseph Koshy 
743ebccf1e3SJoseph Koshy 			if (option == 'S' || option == 'P')
744ebccf1e3SJoseph Koshy 				ev->ev_count = current_sampling_count;
745ebccf1e3SJoseph Koshy 			else
746ebccf1e3SJoseph Koshy 				ev->ev_count = -1;
747ebccf1e3SJoseph Koshy 
748ea056888SAttilio Rao 			if (option == 'S' || option == 's') {
749ea056888SAttilio Rao 				hcpu = sizeof(cpumask) * NBBY;
750ea056888SAttilio Rao 				for (hcpu--; hcpu >= 0; hcpu--)
751ea056888SAttilio Rao 					if (CPU_ISSET(hcpu, &cpumask))
752ea056888SAttilio Rao 						break;
753ea056888SAttilio Rao 				ev->ev_cpu = hcpu;
754ea056888SAttilio Rao 			} else
755ebccf1e3SJoseph Koshy 				ev->ev_cpu = PMC_CPU_ANY;
756ebccf1e3SJoseph Koshy 
757f263522aSJoseph Koshy 			ev->ev_flags = 0;
758b6010f9eSJoseph Koshy 			if (do_callchain)
759b6010f9eSJoseph Koshy 				ev->ev_flags |= PMC_F_CALLCHAIN;
760f263522aSJoseph Koshy 			if (do_descendants)
761f263522aSJoseph Koshy 				ev->ev_flags |= PMC_F_DESCENDANTS;
762f263522aSJoseph Koshy 			if (do_logprocexit)
763f263522aSJoseph Koshy 				ev->ev_flags |= PMC_F_LOG_PROCEXIT;
764f263522aSJoseph Koshy 			if (do_logproccsw)
765f263522aSJoseph Koshy 				ev->ev_flags |= PMC_F_LOG_PROCCSW;
766f263522aSJoseph Koshy 
767ebccf1e3SJoseph Koshy 			ev->ev_cumulative  = use_cumulative_counts;
768ebccf1e3SJoseph Koshy 
769ebccf1e3SJoseph Koshy 			ev->ev_saved = 0LL;
770ebccf1e3SJoseph Koshy 			ev->ev_pmcid = PMC_ID_INVALID;
771ebccf1e3SJoseph Koshy 
772ebccf1e3SJoseph Koshy 			/* extract event name */
773ebccf1e3SJoseph Koshy 			c = strcspn(optarg, ", \t");
774ebccf1e3SJoseph Koshy 			ev->ev_name = malloc(c + 1);
775ebccf1e3SJoseph Koshy 			(void) strncpy(ev->ev_name, optarg, c);
776ebccf1e3SJoseph Koshy 			*(ev->ev_name + c) = '\0';
777ebccf1e3SJoseph Koshy 
778fbd8b34aSJoseph Koshy 			STAILQ_INSERT_TAIL(&args.pa_events, ev, ev_next);
779ebccf1e3SJoseph Koshy 
780ea056888SAttilio Rao 			if (option == 's' || option == 'S') {
781ea056888SAttilio Rao 				hcpu = CPU_ISSET(ev->ev_cpu, &cpumask);
782ea056888SAttilio Rao 				CPU_CLR(ev->ev_cpu, &cpumask);
783ea056888SAttilio Rao 				pmcstat_clone_event_descriptor(ev, &cpumask);
784ea056888SAttilio Rao 				if (hcpu != 0)
785ea056888SAttilio Rao 					CPU_SET(ev->ev_cpu, &cpumask);
786ea056888SAttilio Rao 			}
787ee4910b1SJoseph Koshy 
788ebccf1e3SJoseph Koshy 			break;
789ebccf1e3SJoseph Koshy 
790ebccf1e3SJoseph Koshy 		case 'n':	/* sampling count */
791ebccf1e3SJoseph Koshy 			current_sampling_count = strtol(optarg, &end, 0);
792ebccf1e3SJoseph Koshy 			if (*end != '\0' || current_sampling_count <= 0)
793ebccf1e3SJoseph Koshy 				errx(EX_USAGE,
794f263522aSJoseph Koshy 				    "ERROR: Illegal count value \"%s\".",
795ebccf1e3SJoseph Koshy 				    optarg);
796f263522aSJoseph Koshy 			args.pa_required |= FLAG_HAS_SAMPLING_PMCS;
797ebccf1e3SJoseph Koshy 			break;
798ebccf1e3SJoseph Koshy 
799ebccf1e3SJoseph Koshy 		case 'o':	/* outputfile */
80066ce9936SFabien Thomas 			if (args.pa_printfile != NULL &&
80166ce9936SFabien Thomas 			    args.pa_printfile != stdout &&
80266ce9936SFabien Thomas 			    args.pa_printfile != stderr)
80315139246SJoseph Koshy 				(void) fclose(args.pa_printfile);
80415139246SJoseph Koshy 			if ((args.pa_printfile = fopen(optarg, "w")) == NULL)
80537d6f8a9SDavid E. O'Brien 				errx(EX_OSERR,
80637d6f8a9SDavid E. O'Brien 				    "ERROR: cannot open \"%s\" for writing.",
80737d6f8a9SDavid E. O'Brien 				    optarg);
80815139246SJoseph Koshy 			args.pa_flags |= FLAG_DO_PRINT;
809f263522aSJoseph Koshy 			break;
810ebccf1e3SJoseph Koshy 
811ebccf1e3SJoseph Koshy 		case 'O':	/* sampling output */
81215139246SJoseph Koshy 			if (args.pa_outputpath)
81337d6f8a9SDavid E. O'Brien 				errx(EX_USAGE,
81437d6f8a9SDavid E. O'Brien "ERROR: option -O may only be specified once.");
81515139246SJoseph Koshy 			args.pa_outputpath = optarg;
81615139246SJoseph Koshy 			args.pa_flags |= FLAG_HAS_OUTPUT_LOGFILE;
81715139246SJoseph Koshy 			break;
81815139246SJoseph Koshy 
81949874f6eSJoseph Koshy 		case 'q':	/* quiet mode */
82049874f6eSJoseph Koshy 			args.pa_verbosity = 0;
82149874f6eSJoseph Koshy 			break;
82249874f6eSJoseph Koshy 
82349874f6eSJoseph Koshy 		case 'r':	/* root FS path */
82449874f6eSJoseph Koshy 			args.pa_fsroot = optarg;
82549874f6eSJoseph Koshy 			break;
82649874f6eSJoseph Koshy 
82715139246SJoseph Koshy 		case 'R':	/* read an existing log file */
828b6010f9eSJoseph Koshy 			if (args.pa_inputpath != NULL)
82937d6f8a9SDavid E. O'Brien 				errx(EX_USAGE,
83037d6f8a9SDavid E. O'Brien "ERROR: option -R may only be specified once.");
83115139246SJoseph Koshy 			args.pa_inputpath = optarg;
83215139246SJoseph Koshy 			if (args.pa_printfile == stderr)
83315139246SJoseph Koshy 				args.pa_printfile = stdout;
83415139246SJoseph Koshy 			args.pa_flags |= FLAG_READ_LOGFILE;
835ebccf1e3SJoseph Koshy 			break;
836ebccf1e3SJoseph Koshy 
837fbd8b34aSJoseph Koshy 		case 't':	/* target pid or process name */
8380b86b1bbSFabien Thomas 			pmcstat_find_targets(optarg);
839ebccf1e3SJoseph Koshy 
840fbd8b34aSJoseph Koshy 			args.pa_flags |= FLAG_HAS_TARGET;
841f263522aSJoseph Koshy 			args.pa_required |= FLAG_HAS_PROCESS_PMCS;
842ebccf1e3SJoseph Koshy 			break;
843ebccf1e3SJoseph Koshy 
8440b86b1bbSFabien Thomas 		case 'T':	/* top mode */
8450b86b1bbSFabien Thomas 			args.pa_flags |= FLAG_DO_TOP;
8460b86b1bbSFabien Thomas 			args.pa_plugin = PMCSTAT_PL_CALLGRAPH;
8470b86b1bbSFabien Thomas 			args.pa_ctdumpinstr = 0;
8480b86b1bbSFabien Thomas 			args.pa_mergepmc = 1;
8490b86b1bbSFabien Thomas 			if (args.pa_printfile == stderr)
8500b86b1bbSFabien Thomas 				args.pa_printfile = stdout;
8510b86b1bbSFabien Thomas 			break;
8520b86b1bbSFabien Thomas 
85349874f6eSJoseph Koshy 		case 'v':	/* verbose */
85449874f6eSJoseph Koshy 			args.pa_verbosity++;
85549874f6eSJoseph Koshy 			break;
85649874f6eSJoseph Koshy 
857ebccf1e3SJoseph Koshy 		case 'w':	/* wait interval */
858ebccf1e3SJoseph Koshy 			interval = strtod(optarg, &end);
859ebccf1e3SJoseph Koshy 			if (*end != '\0' || interval <= 0)
86037d6f8a9SDavid E. O'Brien 				errx(EX_USAGE,
86137d6f8a9SDavid E. O'Brien "ERROR: Illegal wait interval value \"%s\".",
86237d6f8a9SDavid E. O'Brien 				    optarg);
863ebccf1e3SJoseph Koshy 			args.pa_flags |= FLAG_HAS_WAIT_INTERVAL;
864ebccf1e3SJoseph Koshy 			args.pa_interval = interval;
865f263522aSJoseph Koshy 			break;
866ebccf1e3SJoseph Koshy 
867f263522aSJoseph Koshy 		case 'W':	/* toggle LOG_CSW */
868f263522aSJoseph Koshy 			do_logproccsw = !do_logproccsw;
869f263522aSJoseph Koshy 			args.pa_required |= (FLAG_HAS_PROCESS_PMCS |
87015139246SJoseph Koshy 			    FLAG_HAS_COUNTING_PMCS | FLAG_HAS_OUTPUT_LOGFILE);
871ebccf1e3SJoseph Koshy 			break;
872ebccf1e3SJoseph Koshy 
873b6010f9eSJoseph Koshy 		case 'z':
874b6010f9eSJoseph Koshy 			graphdepth = strtod(optarg, &end);
875b6010f9eSJoseph Koshy 			if (*end != '\0' || graphdepth <= 0)
87637d6f8a9SDavid E. O'Brien 				errx(EX_USAGE,
87737d6f8a9SDavid E. O'Brien 				    "ERROR: Illegal callchain depth \"%s\".",
87837d6f8a9SDavid E. O'Brien 				    optarg);
879b6010f9eSJoseph Koshy 			args.pa_graphdepth = graphdepth;
880b6010f9eSJoseph Koshy 			args.pa_required |= FLAG_DO_CALLGRAPHS;
881b6010f9eSJoseph Koshy 			break;
882b6010f9eSJoseph Koshy 
883ebccf1e3SJoseph Koshy 		case '?':
884ebccf1e3SJoseph Koshy 		default:
885ebccf1e3SJoseph Koshy 			pmcstat_show_usage();
886ebccf1e3SJoseph Koshy 			break;
887ebccf1e3SJoseph Koshy 
888ebccf1e3SJoseph Koshy 		}
889ebccf1e3SJoseph Koshy 
890ebccf1e3SJoseph Koshy 	args.pa_argc = (argc -= optind);
891ebccf1e3SJoseph Koshy 	args.pa_argv = (argv += optind);
892ebccf1e3SJoseph Koshy 
893e7ef1de5SFabien Thomas 	/* If we read from logfile and no specified CPU mask use
894e7ef1de5SFabien Thomas 	 * the maximum CPU count.
895e7ef1de5SFabien Thomas 	 */
896e7ef1de5SFabien Thomas 	if ((args.pa_flags & FLAG_READ_LOGFILE) &&
897e7ef1de5SFabien Thomas 	    (args.pa_flags & FLAGS_HAS_CPUMASK) == 0)
898ea056888SAttilio Rao 		CPU_FILL(&cpumask);
899e7ef1de5SFabien Thomas 
900b6010f9eSJoseph Koshy 	args.pa_cpumask = cpumask; /* For selecting CPUs using -R. */
901b6010f9eSJoseph Koshy 
90215139246SJoseph Koshy 	if (argc)	/* command line present */
90315139246SJoseph Koshy 		args.pa_flags |= FLAG_HAS_COMMANDLINE;
904ebccf1e3SJoseph Koshy 
905c0252222SAttilio Rao 	if (args.pa_flags & (FLAG_DO_GPROF | FLAG_DO_CALLGRAPHS |
9060b86b1bbSFabien Thomas 	    FLAG_DO_ANNOTATE | FLAG_DO_TOP))
907b6010f9eSJoseph Koshy 		args.pa_flags |= FLAG_DO_ANALYSIS;
908b6010f9eSJoseph Koshy 
909ebccf1e3SJoseph Koshy 	/*
910ebccf1e3SJoseph Koshy 	 * Check invocation syntax.
911ebccf1e3SJoseph Koshy 	 */
912ebccf1e3SJoseph Koshy 
91315139246SJoseph Koshy 	/* disallow -O and -R together */
91415139246SJoseph Koshy 	if (args.pa_outputpath && args.pa_inputpath)
91537d6f8a9SDavid E. O'Brien 		errx(EX_USAGE,
91637d6f8a9SDavid E. O'Brien 		    "ERROR: options -O and -R are mutually exclusive.");
91715139246SJoseph Koshy 
918c0252222SAttilio Rao 	/* -m option is allowed with -R only. */
9190b86b1bbSFabien Thomas 	if (args.pa_flags & FLAG_DO_ANNOTATE && args.pa_inputpath == NULL)
920c0252222SAttilio Rao 		errx(EX_USAGE, "ERROR: option -m requires an input file");
921c0252222SAttilio Rao 
922c0252222SAttilio Rao 	/* -m option is not allowed combined with -g or -G. */
9230b86b1bbSFabien Thomas 	if (args.pa_flags & FLAG_DO_ANNOTATE &&
924c0252222SAttilio Rao 	    args.pa_flags & (FLAG_DO_GPROF | FLAG_DO_CALLGRAPHS))
92537d6f8a9SDavid E. O'Brien 		errx(EX_USAGE,
92637d6f8a9SDavid E. O'Brien 		    "ERROR: option -m and -g | -G are mutually exclusive");
927c0252222SAttilio Rao 
92815139246SJoseph Koshy 	if (args.pa_flags & FLAG_READ_LOGFILE) {
929f263522aSJoseph Koshy 		errmsg = NULL;
93015139246SJoseph Koshy 		if (args.pa_flags & FLAG_HAS_COMMANDLINE)
931f263522aSJoseph Koshy 			errmsg = "a command line specification";
932fbd8b34aSJoseph Koshy 		else if (args.pa_flags & FLAG_HAS_TARGET)
933f263522aSJoseph Koshy 			errmsg = "option -t";
934fbd8b34aSJoseph Koshy 		else if (!STAILQ_EMPTY(&args.pa_events))
935f263522aSJoseph Koshy 			errmsg = "a PMC event specification";
936f263522aSJoseph Koshy 		if (errmsg)
93737d6f8a9SDavid E. O'Brien 			errx(EX_USAGE,
93837d6f8a9SDavid E. O'Brien 			    "ERROR: option -R may not be used with %s.",
93937d6f8a9SDavid E. O'Brien 			    errmsg);
940fbd8b34aSJoseph Koshy 	} else if (STAILQ_EMPTY(&args.pa_events))
94115139246SJoseph Koshy 		/* All other uses require a PMC spec. */
942ebccf1e3SJoseph Koshy 		pmcstat_show_usage();
943ebccf1e3SJoseph Koshy 
944f263522aSJoseph Koshy 	/* check for -t pid without a process PMC spec */
945fbd8b34aSJoseph Koshy 	if ((args.pa_required & FLAG_HAS_TARGET) &&
946f263522aSJoseph Koshy 	    (args.pa_flags & FLAG_HAS_PROCESS_PMCS) == 0)
94737d6f8a9SDavid E. O'Brien 		errx(EX_USAGE,
94837d6f8a9SDavid E. O'Brien "ERROR: option -t requires a process mode PMC to be specified."
94937d6f8a9SDavid E. O'Brien 		    );
950f263522aSJoseph Koshy 
951f263522aSJoseph Koshy 	/* check for process-mode options without a command or -t pid */
952f263522aSJoseph Koshy 	if ((args.pa_required & FLAG_HAS_PROCESS_PMCS) &&
953fbd8b34aSJoseph Koshy 	    (args.pa_flags & (FLAG_HAS_COMMANDLINE | FLAG_HAS_TARGET)) == 0)
95437d6f8a9SDavid E. O'Brien 		errx(EX_USAGE,
95537d6f8a9SDavid E. O'Brien "ERROR: options -d, -E, -p, -P, and -W require a command line or target process."
95637d6f8a9SDavid E. O'Brien 		    );
957f263522aSJoseph Koshy 
958f263522aSJoseph Koshy 	/* check for -p | -P without a target process of some sort */
959fbd8b34aSJoseph Koshy 	if ((args.pa_required & (FLAG_HAS_COMMANDLINE | FLAG_HAS_TARGET)) &&
960fbd8b34aSJoseph Koshy 	    (args.pa_flags & (FLAG_HAS_COMMANDLINE | FLAG_HAS_TARGET)) == 0)
96137d6f8a9SDavid E. O'Brien 		errx(EX_USAGE,
96237d6f8a9SDavid E. O'Brien "ERROR: options -P and -p require a target process or a command line."
96337d6f8a9SDavid E. O'Brien 		    );
964f263522aSJoseph Koshy 
965f263522aSJoseph Koshy 	/* check for process-mode options without a process-mode PMC */
966f263522aSJoseph Koshy 	if ((args.pa_required & FLAG_HAS_PROCESS_PMCS) &&
967f263522aSJoseph Koshy 	    (args.pa_flags & FLAG_HAS_PROCESS_PMCS) == 0)
96837d6f8a9SDavid E. O'Brien 		errx(EX_USAGE,
96937d6f8a9SDavid E. O'Brien "ERROR: options -d, -E, and -W require a process mode PMC to be specified."
97037d6f8a9SDavid E. O'Brien 		    );
971f263522aSJoseph Koshy 
972b6010f9eSJoseph Koshy 	/* check for -c cpu with no system mode PMCs or logfile. */
973f263522aSJoseph Koshy 	if ((args.pa_required & FLAG_HAS_SYSTEM_PMCS) &&
974b6010f9eSJoseph Koshy 	    (args.pa_flags & FLAG_HAS_SYSTEM_PMCS) == 0 &&
975b6010f9eSJoseph Koshy 	    (args.pa_flags & FLAG_READ_LOGFILE) == 0)
97637d6f8a9SDavid E. O'Brien 		errx(EX_USAGE,
97737d6f8a9SDavid E. O'Brien "ERROR: option -c requires at least one system mode PMC to be specified."
97837d6f8a9SDavid E. O'Brien 		    );
979f263522aSJoseph Koshy 
980f263522aSJoseph Koshy 	/* check for counting mode options without a counting PMC */
981f263522aSJoseph Koshy 	if ((args.pa_required & FLAG_HAS_COUNTING_PMCS) &&
982f263522aSJoseph Koshy 	    (args.pa_flags & FLAG_HAS_COUNTING_PMCS) == 0)
98337d6f8a9SDavid E. O'Brien 		errx(EX_USAGE,
98437d6f8a9SDavid E. O'Brien "ERROR: options -C, -W and -o require at least one counting mode PMC to be specified."
98537d6f8a9SDavid E. O'Brien 		    );
986f263522aSJoseph Koshy 
987f263522aSJoseph Koshy 	/* check for sampling mode options without a sampling PMC spec */
988f263522aSJoseph Koshy 	if ((args.pa_required & FLAG_HAS_SAMPLING_PMCS) &&
989f263522aSJoseph Koshy 	    (args.pa_flags & FLAG_HAS_SAMPLING_PMCS) == 0)
99037d6f8a9SDavid E. O'Brien 		errx(EX_USAGE,
99137d6f8a9SDavid E. O'Brien "ERROR: options -N, -n and -O require at least one sampling mode PMC to be specified."
99237d6f8a9SDavid E. O'Brien 		    );
993f263522aSJoseph Koshy 
9940b86b1bbSFabien Thomas 	/* check if -g/-G/-m/-T are being used correctly */
995b6010f9eSJoseph Koshy 	if ((args.pa_flags & FLAG_DO_ANALYSIS) &&
99615139246SJoseph Koshy 	    !(args.pa_flags & (FLAG_HAS_SAMPLING_PMCS|FLAG_READ_LOGFILE)))
99737d6f8a9SDavid E. O'Brien 		errx(EX_USAGE,
99837d6f8a9SDavid E. O'Brien "ERROR: options -g/-G/-m/-T require sampling PMCs or -R to be specified."
99937d6f8a9SDavid E. O'Brien 		    );
100015139246SJoseph Koshy 
1001f263522aSJoseph Koshy 	/* check if -O was spuriously specified */
100215139246SJoseph Koshy 	if ((args.pa_flags & FLAG_HAS_OUTPUT_LOGFILE) &&
100315139246SJoseph Koshy 	    (args.pa_required & FLAG_HAS_OUTPUT_LOGFILE) == 0)
1004f263522aSJoseph Koshy 		errx(EX_USAGE,
100537d6f8a9SDavid E. O'Brien "ERROR: option -O is used only with options -E, -P, -S and -W."
100637d6f8a9SDavid E. O'Brien 		    );
1007f263522aSJoseph Koshy 
10080b86b1bbSFabien Thomas 	/* -k kernel path require -g/-G/-m/-T or -R */
100915139246SJoseph Koshy 	if ((args.pa_flags & FLAG_HAS_KERNELPATH) &&
1010b6010f9eSJoseph Koshy 	    (args.pa_flags & FLAG_DO_ANALYSIS) == 0 &&
101149874f6eSJoseph Koshy 	    (args.pa_flags & FLAG_READ_LOGFILE) == 0)
10120b86b1bbSFabien Thomas 	    errx(EX_USAGE, "ERROR: option -k is only used with -g/-R/-m/-T.");
101315139246SJoseph Koshy 
1014b6010f9eSJoseph Koshy 	/* -D only applies to gprof output mode (-g) */
101515139246SJoseph Koshy 	if ((args.pa_flags & FLAG_HAS_SAMPLESDIR) &&
1016b6010f9eSJoseph Koshy 	    (args.pa_flags & FLAG_DO_GPROF) == 0)
1017b6010f9eSJoseph Koshy 	    errx(EX_USAGE, "ERROR: option -D is only used with -g.");
101849874f6eSJoseph Koshy 
101949874f6eSJoseph Koshy 	/* -M mapfile requires -g or -R */
102049874f6eSJoseph Koshy 	if (args.pa_mapfilename != NULL &&
102149874f6eSJoseph Koshy 	    (args.pa_flags & FLAG_DO_GPROF) == 0 &&
102249874f6eSJoseph Koshy 	    (args.pa_flags & FLAG_READ_LOGFILE) == 0)
102349874f6eSJoseph Koshy 	    errx(EX_USAGE, "ERROR: option -M is only used with -g/-R.");
102415139246SJoseph Koshy 
102515139246SJoseph Koshy 	/*
102615139246SJoseph Koshy 	 * Disallow textual output of sampling PMCs if counting PMCs
102715139246SJoseph Koshy 	 * have also been asked for, mostly because the combined output
102815139246SJoseph Koshy 	 * is difficult to make sense of.
102915139246SJoseph Koshy 	 */
103015139246SJoseph Koshy 	if ((args.pa_flags & FLAG_HAS_COUNTING_PMCS) &&
103115139246SJoseph Koshy 	    (args.pa_flags & FLAG_HAS_SAMPLING_PMCS) &&
103200a22dc5SJoseph Koshy 	    ((args.pa_flags & FLAG_HAS_OUTPUT_LOGFILE) == 0))
103337d6f8a9SDavid E. O'Brien 		errx(EX_USAGE,
103437d6f8a9SDavid E. O'Brien "ERROR: option -O is required if counting and sampling PMCs are specified together."
103537d6f8a9SDavid E. O'Brien 		    );
103615139246SJoseph Koshy 
103749874f6eSJoseph Koshy 	/*
1038b6010f9eSJoseph Koshy 	 * Check if "-k kerneldir" was specified, and if whether
10393b6dc18eSEitan Adler 	 * 'kerneldir' actually refers to a file.  If so, use
1040b6010f9eSJoseph Koshy 	 * `dirname path` to determine the kernel directory.
104149874f6eSJoseph Koshy 	 */
104249874f6eSJoseph Koshy 	if (args.pa_flags & FLAG_HAS_KERNELPATH) {
104349874f6eSJoseph Koshy 		(void) snprintf(buffer, sizeof(buffer), "%s%s", args.pa_fsroot,
104449874f6eSJoseph Koshy 		    args.pa_kernel);
104549874f6eSJoseph Koshy 		if (stat(buffer, &sb) < 0)
104649874f6eSJoseph Koshy 			err(EX_OSERR, "ERROR: Cannot locate kernel \"%s\"",
104749874f6eSJoseph Koshy 			    buffer);
104849874f6eSJoseph Koshy 		if (!S_ISREG(sb.st_mode) && !S_ISDIR(sb.st_mode))
104949874f6eSJoseph Koshy 			errx(EX_USAGE, "ERROR: \"%s\": Unsupported file type.",
105049874f6eSJoseph Koshy 			    buffer);
105149874f6eSJoseph Koshy 		if (!S_ISDIR(sb.st_mode)) {
105249874f6eSJoseph Koshy 			tmp = args.pa_kernel;
105349874f6eSJoseph Koshy 			args.pa_kernel = strdup(dirname(args.pa_kernel));
105449874f6eSJoseph Koshy 			free(tmp);
105549874f6eSJoseph Koshy 			(void) snprintf(buffer, sizeof(buffer), "%s%s",
105649874f6eSJoseph Koshy 			    args.pa_fsroot, args.pa_kernel);
105749874f6eSJoseph Koshy 			if (stat(buffer, &sb) < 0)
105849874f6eSJoseph Koshy 				err(EX_OSERR, "ERROR: Cannot stat \"%s\"",
105949874f6eSJoseph Koshy 				    buffer);
106049874f6eSJoseph Koshy 			if (!S_ISDIR(sb.st_mode))
106137d6f8a9SDavid E. O'Brien 				errx(EX_USAGE,
106237d6f8a9SDavid E. O'Brien 				    "ERROR: \"%s\" is not a directory.",
106337d6f8a9SDavid E. O'Brien 				    buffer);
106449874f6eSJoseph Koshy 		}
106549874f6eSJoseph Koshy 	}
106649874f6eSJoseph Koshy 
1067b6010f9eSJoseph Koshy 	/*
1068b6010f9eSJoseph Koshy 	 * If we have a callgraph be created, select the outputfile.
1069b6010f9eSJoseph Koshy 	 */
1070b6010f9eSJoseph Koshy 	if (args.pa_flags & FLAG_DO_CALLGRAPHS) {
1071b6010f9eSJoseph Koshy 		if (strcmp(graphfilename, "-") == 0)
1072b6010f9eSJoseph Koshy 		    args.pa_graphfile = args.pa_printfile;
1073b6010f9eSJoseph Koshy 		else {
1074b6010f9eSJoseph Koshy 			args.pa_graphfile = fopen(graphfilename, "w");
1075b6010f9eSJoseph Koshy 			if (args.pa_graphfile == NULL)
107637d6f8a9SDavid E. O'Brien 				err(EX_OSERR,
107737d6f8a9SDavid E. O'Brien 				    "ERROR: cannot open \"%s\" for writing",
107837d6f8a9SDavid E. O'Brien 				    graphfilename);
1079b6010f9eSJoseph Koshy 		}
1080b6010f9eSJoseph Koshy 	}
10810b86b1bbSFabien Thomas 	if (args.pa_flags & FLAG_DO_ANNOTATE) {
1082c0252222SAttilio Rao 		args.pa_graphfile = fopen(graphfilename, "w");
1083c0252222SAttilio Rao 		if (args.pa_graphfile == NULL)
1084c0252222SAttilio Rao 			err(EX_OSERR, "ERROR: cannot open \"%s\" for writing",
1085c0252222SAttilio Rao 			    graphfilename);
1086c0252222SAttilio Rao 	}
1087b6010f9eSJoseph Koshy 
1088ac708fddSFabien Thomas 	/* if we've been asked to process a log file, skip init */
1089ac708fddSFabien Thomas 	if ((args.pa_flags & FLAG_READ_LOGFILE) == 0) {
1090ac708fddSFabien Thomas 		if (pmc_init() < 0)
1091ac708fddSFabien Thomas 			err(EX_UNAVAILABLE,
109237d6f8a9SDavid E. O'Brien 			    "ERROR: Initialization of the pmc(3) library failed"
109337d6f8a9SDavid E. O'Brien 			    );
1094ac708fddSFabien Thomas 
1095ac708fddSFabien Thomas 		if ((npmc = pmc_npmc(0)) < 0) /* assume all CPUs are identical */
109637d6f8a9SDavid E. O'Brien 			err(EX_OSERR,
109737d6f8a9SDavid E. O'Brien "ERROR: Cannot determine the number of PMCs on CPU %d",
109837d6f8a9SDavid E. O'Brien 			    0);
1099ac708fddSFabien Thomas 	}
1100ac708fddSFabien Thomas 
1101ac708fddSFabien Thomas 	/* Allocate a kqueue */
1102ac708fddSFabien Thomas 	if ((pmcstat_kq = kqueue()) < 0)
1103ac708fddSFabien Thomas 		err(EX_OSERR, "ERROR: Cannot allocate kqueue");
1104ac708fddSFabien Thomas 
1105ac708fddSFabien Thomas 	/* Setup the logfile as the source. */
110615139246SJoseph Koshy 	if (args.pa_flags & FLAG_READ_LOGFILE) {
110715139246SJoseph Koshy 		/*
110815139246SJoseph Koshy 		 * Print the log in textual form if we haven't been
1109b6010f9eSJoseph Koshy 		 * asked to generate profiling information.
111015139246SJoseph Koshy 		 */
1111b6010f9eSJoseph Koshy 		if ((args.pa_flags & FLAG_DO_ANALYSIS) == 0)
111215139246SJoseph Koshy 			args.pa_flags |= FLAG_DO_PRINT;
111315139246SJoseph Koshy 
11140b86b1bbSFabien Thomas 		pmcstat_initialize_logging();
1115ac708fddSFabien Thomas 		rfd = pmcstat_open_log(args.pa_inputpath,
1116302cbb90SJoseph Koshy 		    PMCSTAT_OPEN_FOR_READ);
1117ac708fddSFabien Thomas 		if ((args.pa_logparser = pmclog_open(rfd)) == NULL)
111815139246SJoseph Koshy 			err(EX_OSERR, "ERROR: Cannot create parser");
1119ac708fddSFabien Thomas 		if (fcntl(rfd, F_SETFL, O_NONBLOCK) < 0)
1120ac708fddSFabien Thomas 			err(EX_OSERR, "ERROR: fcntl(2) failed");
1121ac708fddSFabien Thomas 		EV_SET(&kev, rfd, EVFILT_READ, EV_ADD,
1122ac708fddSFabien Thomas 		    0, 0, NULL);
1123ac708fddSFabien Thomas 		if (kevent(pmcstat_kq, &kev, 1, NULL, 0, NULL) < 0)
1124ac708fddSFabien Thomas 			err(EX_OSERR, "ERROR: Cannot register kevent");
1125f263522aSJoseph Koshy 	}
112615139246SJoseph Koshy 	/*
112715139246SJoseph Koshy 	 * Configure the specified log file or setup a default log
112815139246SJoseph Koshy 	 * consumer via a pipe.
112915139246SJoseph Koshy 	 */
113015139246SJoseph Koshy 	if (args.pa_required & FLAG_HAS_OUTPUT_LOGFILE) {
1131302cbb90SJoseph Koshy 		if (args.pa_outputpath)
1132302cbb90SJoseph Koshy 			args.pa_logfd = pmcstat_open_log(args.pa_outputpath,
1133302cbb90SJoseph Koshy 			    PMCSTAT_OPEN_FOR_WRITE);
1134302cbb90SJoseph Koshy 		else {
113515139246SJoseph Koshy 			/*
113615139246SJoseph Koshy 			 * process the log on the fly by reading it in
113715139246SJoseph Koshy 			 * through a pipe.
113815139246SJoseph Koshy 			 */
113915139246SJoseph Koshy 			if (pipe(pipefd) < 0)
114015139246SJoseph Koshy 				err(EX_OSERR, "ERROR: pipe(2) failed");
114115139246SJoseph Koshy 
114215139246SJoseph Koshy 			if (fcntl(pipefd[READPIPEFD], F_SETFL, O_NONBLOCK) < 0)
114315139246SJoseph Koshy 				err(EX_OSERR, "ERROR: fcntl(2) failed");
114415139246SJoseph Koshy 
114515139246SJoseph Koshy 			EV_SET(&kev, pipefd[READPIPEFD], EVFILT_READ, EV_ADD,
114615139246SJoseph Koshy 			    0, 0, NULL);
114715139246SJoseph Koshy 
114815139246SJoseph Koshy 			if (kevent(pmcstat_kq, &kev, 1, NULL, 0, NULL) < 0)
114915139246SJoseph Koshy 				err(EX_OSERR, "ERROR: Cannot register kevent");
115015139246SJoseph Koshy 
115115139246SJoseph Koshy 			args.pa_logfd = pipefd[WRITEPIPEFD];
115215139246SJoseph Koshy 
11530b86b1bbSFabien Thomas 			args.pa_flags |= FLAG_HAS_PIPE;
11540b86b1bbSFabien Thomas 			if ((args.pa_flags & FLAG_DO_TOP) == 0)
11550b86b1bbSFabien Thomas 				args.pa_flags |= FLAG_DO_PRINT;
115615139246SJoseph Koshy 			args.pa_logparser = pmclog_open(pipefd[READPIPEFD]);
115715139246SJoseph Koshy 		}
115815139246SJoseph Koshy 
115915139246SJoseph Koshy 		if (pmc_configure_logfile(args.pa_logfd) < 0)
116015139246SJoseph Koshy 			err(EX_OSERR, "ERROR: Cannot configure log file");
116115139246SJoseph Koshy 	}
116215139246SJoseph Koshy 
11637fbf3da2SJoseph Koshy 	/* remember to check for driver errors if we are sampling or logging */
11647fbf3da2SJoseph Koshy 	check_driver_stats = (args.pa_flags & FLAG_HAS_SAMPLING_PMCS) ||
11657fbf3da2SJoseph Koshy 	    (args.pa_flags & FLAG_HAS_OUTPUT_LOGFILE);
11667fbf3da2SJoseph Koshy 
1167ebccf1e3SJoseph Koshy 	/*
1168ac708fddSFabien Thomas 	if (args.pa_flags & FLAG_READ_LOGFILE) {
1169ebccf1e3SJoseph Koshy 	 * Allocate PMCs.
1170ebccf1e3SJoseph Koshy 	 */
1171ebccf1e3SJoseph Koshy 
1172fbd8b34aSJoseph Koshy 	STAILQ_FOREACH(ev, &args.pa_events, ev_next) {
1173ebccf1e3SJoseph Koshy 		if (pmc_allocate(ev->ev_spec, ev->ev_mode,
1174f263522aSJoseph Koshy 		    ev->ev_flags, ev->ev_cpu, &ev->ev_pmcid) < 0)
117537d6f8a9SDavid E. O'Brien 			err(EX_OSERR,
117637d6f8a9SDavid E. O'Brien "ERROR: Cannot allocate %s-mode pmc with specification \"%s\"",
117737d6f8a9SDavid E. O'Brien 			    PMC_IS_SYSTEM_MODE(ev->ev_mode) ?
117837d6f8a9SDavid E. O'Brien 			    "system" : "process", ev->ev_spec);
1179ebccf1e3SJoseph Koshy 
118015139246SJoseph Koshy 		if (PMC_IS_SAMPLING_MODE(ev->ev_mode) &&
118115139246SJoseph Koshy 		    pmc_set(ev->ev_pmcid, ev->ev_count) < 0)
118237d6f8a9SDavid E. O'Brien 			err(EX_OSERR,
118337d6f8a9SDavid E. O'Brien 			    "ERROR: Cannot set sampling count for PMC \"%s\"",
118437d6f8a9SDavid E. O'Brien 			    ev->ev_name);
118515139246SJoseph Koshy 	}
118615139246SJoseph Koshy 
1187ebccf1e3SJoseph Koshy 	/* compute printout widths */
1188fbd8b34aSJoseph Koshy 	STAILQ_FOREACH(ev, &args.pa_events, ev_next) {
1189c5153e19SJoseph Koshy 		int counter_width;
1190c5153e19SJoseph Koshy 		int display_width;
1191c5153e19SJoseph Koshy 		int header_width;
1192ebccf1e3SJoseph Koshy 
1193c5153e19SJoseph Koshy 		(void) pmc_width(ev->ev_pmcid, &counter_width);
1194ee4910b1SJoseph Koshy 		header_width = strlen(ev->ev_name) + 2; /* prefix '%c/' */
1195c5153e19SJoseph Koshy 		display_width = (int) floor(counter_width / 3.32193) + 1;
1196ebccf1e3SJoseph Koshy 
1197ee4910b1SJoseph Koshy 		if (PMC_IS_SYSTEM_MODE(ev->ev_mode))
1198ee4910b1SJoseph Koshy 			header_width += 3; /* 2 digit CPU number + '/' */
1199ee4910b1SJoseph Koshy 
1200c5153e19SJoseph Koshy 		if (header_width > display_width) {
1201ebccf1e3SJoseph Koshy 			ev->ev_fieldskip = 0;
1202c5153e19SJoseph Koshy 			ev->ev_fieldwidth = header_width;
1203ebccf1e3SJoseph Koshy 		} else {
1204c5153e19SJoseph Koshy 			ev->ev_fieldskip = display_width -
1205c5153e19SJoseph Koshy 			    header_width;
1206c5153e19SJoseph Koshy 			ev->ev_fieldwidth = display_width;
1207ebccf1e3SJoseph Koshy 		}
1208ebccf1e3SJoseph Koshy 	}
1209ebccf1e3SJoseph Koshy 
1210ebccf1e3SJoseph Koshy 	/*
1211ebccf1e3SJoseph Koshy 	 * If our output is being set to a terminal, register a handler
1212ebccf1e3SJoseph Koshy 	 * for window size changes.
1213ebccf1e3SJoseph Koshy 	 */
1214ebccf1e3SJoseph Koshy 
121515139246SJoseph Koshy 	if (isatty(fileno(args.pa_printfile))) {
1216ebccf1e3SJoseph Koshy 
121715139246SJoseph Koshy 		if (ioctl(fileno(args.pa_printfile), TIOCGWINSZ, &ws) < 0)
1218ebccf1e3SJoseph Koshy 			err(EX_OSERR, "ERROR: Cannot determine window size");
1219ebccf1e3SJoseph Koshy 
1220ebccf1e3SJoseph Koshy 		pmcstat_displayheight = ws.ws_row - 1;
12210b86b1bbSFabien Thomas 		pmcstat_displaywidth  = ws.ws_col - 1;
1222ebccf1e3SJoseph Koshy 
1223ebccf1e3SJoseph Koshy 		EV_SET(&kev, SIGWINCH, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
1224ebccf1e3SJoseph Koshy 
1225ebccf1e3SJoseph Koshy 		if (kevent(pmcstat_kq, &kev, 1, NULL, 0, NULL) < 0)
122637d6f8a9SDavid E. O'Brien 			err(EX_OSERR,
122737d6f8a9SDavid E. O'Brien 			    "ERROR: Cannot register kevent for SIGWINCH");
12280b86b1bbSFabien Thomas 
12290b86b1bbSFabien Thomas 		args.pa_toptty = 1;
12300b86b1bbSFabien Thomas 	}
12310b86b1bbSFabien Thomas 
12320b86b1bbSFabien Thomas 	/*
12330b86b1bbSFabien Thomas 	 * Listen to key input in top mode.
12340b86b1bbSFabien Thomas 	 */
12350b86b1bbSFabien Thomas 	if (args.pa_flags & FLAG_DO_TOP) {
12360b86b1bbSFabien Thomas 		EV_SET(&kev, fileno(stdin), EVFILT_READ, EV_ADD, 0, 0, NULL);
12370b86b1bbSFabien Thomas 		if (kevent(pmcstat_kq, &kev, 1, NULL, 0, NULL) < 0)
12380b86b1bbSFabien Thomas 			err(EX_OSERR, "ERROR: Cannot register kevent");
1239ebccf1e3SJoseph Koshy 	}
1240ebccf1e3SJoseph Koshy 
1241ebccf1e3SJoseph Koshy 	EV_SET(&kev, SIGINT, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
1242ebccf1e3SJoseph Koshy 	if (kevent(pmcstat_kq, &kev, 1, NULL, 0, NULL) < 0)
1243ebccf1e3SJoseph Koshy 		err(EX_OSERR, "ERROR: Cannot register kevent for SIGINT");
1244ebccf1e3SJoseph Koshy 
1245f263522aSJoseph Koshy 	EV_SET(&kev, SIGIO, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
1246f263522aSJoseph Koshy 	if (kevent(pmcstat_kq, &kev, 1, NULL, 0, NULL) < 0)
1247f263522aSJoseph Koshy 		err(EX_OSERR, "ERROR: Cannot register kevent for SIGIO");
1248ebccf1e3SJoseph Koshy 
1249ebccf1e3SJoseph Koshy 	/*
1250f263522aSJoseph Koshy 	 * An exec() failure of a forked child is signalled by the
1251f263522aSJoseph Koshy 	 * child sending the parent a SIGCHLD.  We don't register an
1252f263522aSJoseph Koshy 	 * actual signal handler for SIGCHLD, but instead use our
1253f263522aSJoseph Koshy 	 * kqueue to pick up the signal.
1254ebccf1e3SJoseph Koshy 	 */
1255f263522aSJoseph Koshy 	EV_SET(&kev, SIGCHLD, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
1256f263522aSJoseph Koshy 	if (kevent(pmcstat_kq, &kev, 1, NULL, 0, NULL) < 0)
1257f263522aSJoseph Koshy 		err(EX_OSERR, "ERROR: Cannot register kevent for SIGCHLD");
1258ebccf1e3SJoseph Koshy 
12590b86b1bbSFabien Thomas 	/*
12600b86b1bbSFabien Thomas 	 * Setup a timer if we have counting mode PMCs needing to be printed or
12610b86b1bbSFabien Thomas 	 * top mode plugin is active.
12620b86b1bbSFabien Thomas 	 */
12630b86b1bbSFabien Thomas 	if (((args.pa_flags & FLAG_HAS_COUNTING_PMCS) &&
12640b86b1bbSFabien Thomas 	     (args.pa_required & FLAG_HAS_OUTPUT_LOGFILE) == 0) ||
12650b86b1bbSFabien Thomas 	    (args.pa_flags & FLAG_DO_TOP)) {
1266ebccf1e3SJoseph Koshy 		EV_SET(&kev, 0, EVFILT_TIMER, EV_ADD, 0,
1267ebccf1e3SJoseph Koshy 		    args.pa_interval * 1000, NULL);
1268ebccf1e3SJoseph Koshy 
1269ebccf1e3SJoseph Koshy 		if (kevent(pmcstat_kq, &kev, 1, NULL, 0, NULL) < 0)
127037d6f8a9SDavid E. O'Brien 			err(EX_OSERR,
127137d6f8a9SDavid E. O'Brien 			    "ERROR: Cannot register kevent for timer");
1272ebccf1e3SJoseph Koshy 	}
1273ebccf1e3SJoseph Koshy 
1274ebccf1e3SJoseph Koshy 	/* attach PMCs to the target process, starting it if specified */
1275ee4910b1SJoseph Koshy 	if (args.pa_flags & FLAG_HAS_COMMANDLINE)
12760b86b1bbSFabien Thomas 		pmcstat_create_process();
1277ebccf1e3SJoseph Koshy 
12787fbf3da2SJoseph Koshy 	if (check_driver_stats && pmc_get_driver_stats(&ds_start) < 0)
12797fbf3da2SJoseph Koshy 		err(EX_OSERR, "ERROR: Cannot retrieve driver statistics");
12807fbf3da2SJoseph Koshy 
1281ee4910b1SJoseph Koshy 	/* Attach process pmcs to the target process. */
1282165b10b0SJoseph Koshy 	if (args.pa_flags & (FLAG_HAS_TARGET | FLAG_HAS_COMMANDLINE)) {
1283fbd8b34aSJoseph Koshy 		if (SLIST_EMPTY(&args.pa_targets))
128437d6f8a9SDavid E. O'Brien 			errx(EX_DATAERR,
128537d6f8a9SDavid E. O'Brien 			    "ERROR: No matching target processes.");
12865477328dSJoseph Koshy 		if (args.pa_flags & FLAG_HAS_PROCESS_PMCS)
12870b86b1bbSFabien Thomas 			pmcstat_attach_pmcs();
1288ee4910b1SJoseph Koshy 
1289fbd8b34aSJoseph Koshy 		if (pmcstat_kvm) {
1290fbd8b34aSJoseph Koshy 			kvm_close(pmcstat_kvm);
1291fbd8b34aSJoseph Koshy 			pmcstat_kvm = NULL;
1292fbd8b34aSJoseph Koshy 		}
1293fbd8b34aSJoseph Koshy 	}
1294fbd8b34aSJoseph Koshy 
1295ebccf1e3SJoseph Koshy 	/* start the pmcs */
12960b86b1bbSFabien Thomas 	pmcstat_start_pmcs();
1297ebccf1e3SJoseph Koshy 
1298ebccf1e3SJoseph Koshy 	/* start the (commandline) process if needed */
129915139246SJoseph Koshy 	if (args.pa_flags & FLAG_HAS_COMMANDLINE)
1300ee4910b1SJoseph Koshy 		pmcstat_start_process();
1301ebccf1e3SJoseph Koshy 
1302ac708fddSFabien Thomas 	/* initialize logging */
13030b86b1bbSFabien Thomas 	pmcstat_initialize_logging();
130415139246SJoseph Koshy 
1305ebccf1e3SJoseph Koshy 	/* Handle SIGINT using the kqueue loop */
1306ebccf1e3SJoseph Koshy 	sa.sa_handler = SIG_IGN;
1307ebccf1e3SJoseph Koshy 	sa.sa_flags   = 0;
1308ebccf1e3SJoseph Koshy 	(void) sigemptyset(&sa.sa_mask);
1309ebccf1e3SJoseph Koshy 
1310ebccf1e3SJoseph Koshy 	if (sigaction(SIGINT, &sa, NULL) < 0)
1311ebccf1e3SJoseph Koshy 		err(EX_OSERR, "ERROR: Cannot install signal handler");
1312ebccf1e3SJoseph Koshy 
1313ebccf1e3SJoseph Koshy 	/*
13140b86b1bbSFabien Thomas 	 * Setup the top mode display.
13150b86b1bbSFabien Thomas 	 */
13160b86b1bbSFabien Thomas 	if (args.pa_flags & FLAG_DO_TOP) {
13170b86b1bbSFabien Thomas 		args.pa_flags &= ~FLAG_DO_PRINT;
13180b86b1bbSFabien Thomas 
13190b86b1bbSFabien Thomas 		if (args.pa_toptty) {
13200b86b1bbSFabien Thomas 			/*
13210b86b1bbSFabien Thomas 			 * Init ncurses.
13220b86b1bbSFabien Thomas 			 */
13230b86b1bbSFabien Thomas 			initscr();
13240b86b1bbSFabien Thomas 			if(has_colors() == TRUE) {
13250b86b1bbSFabien Thomas 				args.pa_topcolor = 1;
13260b86b1bbSFabien Thomas 				start_color();
13270b86b1bbSFabien Thomas 				use_default_colors();
13280b86b1bbSFabien Thomas 				pair_content(0, &cf, &cb);
13290b86b1bbSFabien Thomas 				init_pair(1, COLOR_RED, cb);
13300b86b1bbSFabien Thomas 				init_pair(2, COLOR_YELLOW, cb);
13310b86b1bbSFabien Thomas 				init_pair(3, COLOR_GREEN, cb);
13320b86b1bbSFabien Thomas 			}
13330b86b1bbSFabien Thomas 			cbreak();
13340b86b1bbSFabien Thomas 			noecho();
13350b86b1bbSFabien Thomas 			nonl();
13360b86b1bbSFabien Thomas 			nodelay(stdscr, 1);
13370b86b1bbSFabien Thomas 			intrflush(stdscr, FALSE);
13380b86b1bbSFabien Thomas 			keypad(stdscr, TRUE);
13390b86b1bbSFabien Thomas 			clear();
13402aa983e5SFabien Thomas 			/* Get terminal width / height with ncurses. */
134137d6f8a9SDavid E. O'Brien 			getmaxyx(stdscr,
134237d6f8a9SDavid E. O'Brien 			    pmcstat_displayheight, pmcstat_displaywidth);
13432aa983e5SFabien Thomas 			pmcstat_displayheight--; pmcstat_displaywidth--;
13440b86b1bbSFabien Thomas 			atexit(pmcstat_topexit);
13450b86b1bbSFabien Thomas 		}
13460b86b1bbSFabien Thomas 	}
13470b86b1bbSFabien Thomas 
13480b86b1bbSFabien Thomas 	/*
1349ebccf1e3SJoseph Koshy 	 * loop till either the target process (if any) exits, or we
1350ebccf1e3SJoseph Koshy 	 * are killed by a SIGINT.
1351ebccf1e3SJoseph Koshy 	 */
1352f263522aSJoseph Koshy 	runstate = PMCSTAT_RUNNING;
1353dceed24aSFabien Thomas 	do_print = do_read = 0;
1354ebccf1e3SJoseph Koshy 	do {
1355ebccf1e3SJoseph Koshy 		if ((c = kevent(pmcstat_kq, NULL, 0, &kev, 1, NULL)) <= 0) {
1356ebccf1e3SJoseph Koshy 			if (errno != EINTR)
1357ebccf1e3SJoseph Koshy 				err(EX_OSERR, "ERROR: kevent failed");
1358ebccf1e3SJoseph Koshy 			else
1359ebccf1e3SJoseph Koshy 				continue;
1360ebccf1e3SJoseph Koshy 		}
1361ebccf1e3SJoseph Koshy 
1362ebccf1e3SJoseph Koshy 		if (kev.flags & EV_ERROR)
1363ebccf1e3SJoseph Koshy 			errc(EX_OSERR, kev.data, "ERROR: kevent failed");
1364ebccf1e3SJoseph Koshy 
1365ebccf1e3SJoseph Koshy 		switch (kev.filter) {
1366f263522aSJoseph Koshy 		case EVFILT_PROC:  /* target has exited */
13670b86b1bbSFabien Thomas 			runstate = pmcstat_close_log();
136838fc5f34SJoseph Koshy 			do_print = 1;
1369f263522aSJoseph Koshy 			break;
1370ebccf1e3SJoseph Koshy 
1371f263522aSJoseph Koshy 		case EVFILT_READ:  /* log file data is present */
1372ac708fddSFabien Thomas 			if (kev.ident == (unsigned)fileno(stdin) &&
1373ac708fddSFabien Thomas 			    (args.pa_flags & FLAG_DO_TOP)) {
13740b86b1bbSFabien Thomas 				if (pmcstat_keypress_log())
13750b86b1bbSFabien Thomas 					runstate = pmcstat_close_log();
1376dceed24aSFabien Thomas 			} else {
1377dceed24aSFabien Thomas 				do_read = 0;
13780b86b1bbSFabien Thomas 				runstate = pmcstat_process_log();
1379dceed24aSFabien Thomas 			}
1380ebccf1e3SJoseph Koshy 			break;
1381ebccf1e3SJoseph Koshy 
1382ebccf1e3SJoseph Koshy 		case EVFILT_SIGNAL:
1383f263522aSJoseph Koshy 			if (kev.ident == SIGCHLD) {
1384f263522aSJoseph Koshy 				/*
1385f263522aSJoseph Koshy 				 * The child process sends us a
1386f263522aSJoseph Koshy 				 * SIGCHLD if its exec() failed.  We
1387f263522aSJoseph Koshy 				 * wait for it to exit and then exit
1388f263522aSJoseph Koshy 				 * ourselves.
1389f263522aSJoseph Koshy 				 */
1390f263522aSJoseph Koshy 				(void) wait(&c);
1391f263522aSJoseph Koshy 				runstate = PMCSTAT_FINISHED;
1392f263522aSJoseph Koshy 			} else if (kev.ident == SIGIO) {
1393f263522aSJoseph Koshy 				/*
1394f263522aSJoseph Koshy 				 * We get a SIGIO if a PMC loses all
1395f263522aSJoseph Koshy 				 * of its targets, or if logfile
1396f263522aSJoseph Koshy 				 * writes encounter an error.
1397f263522aSJoseph Koshy 				 */
13980b86b1bbSFabien Thomas 				runstate = pmcstat_close_log();
1399f263522aSJoseph Koshy 				do_print = 1; /* print PMCs at exit */
1400f263522aSJoseph Koshy 			} else if (kev.ident == SIGINT) {
140115139246SJoseph Koshy 				/* Kill the child process if we started it */
140215139246SJoseph Koshy 				if (args.pa_flags & FLAG_HAS_COMMANDLINE)
14030b86b1bbSFabien Thomas 					pmcstat_kill_process();
1404ac708fddSFabien Thomas 				runstate = pmcstat_close_log();
1405ebccf1e3SJoseph Koshy 			} else if (kev.ident == SIGWINCH) {
140615139246SJoseph Koshy 				if (ioctl(fileno(args.pa_printfile),
1407ebccf1e3SJoseph Koshy 					TIOCGWINSZ, &ws) < 0)
140837d6f8a9SDavid E. O'Brien 				    err(EX_OSERR,
140937d6f8a9SDavid E. O'Brien 				        "ERROR: Cannot determine window size");
1410ebccf1e3SJoseph Koshy 				pmcstat_displayheight = ws.ws_row - 1;
14110b86b1bbSFabien Thomas 				pmcstat_displaywidth  = ws.ws_col - 1;
1412ebccf1e3SJoseph Koshy 			} else
1413ebccf1e3SJoseph Koshy 				assert(0);
1414ebccf1e3SJoseph Koshy 
1415ebccf1e3SJoseph Koshy 			break;
1416f263522aSJoseph Koshy 
1417f263522aSJoseph Koshy 		case EVFILT_TIMER: /* print out counting PMCs */
1418dceed24aSFabien Thomas 			if ((args.pa_flags & FLAG_DO_TOP) &&
141966ce9936SFabien Thomas 			     pmc_flush_logfile() == 0)
1420dceed24aSFabien Thomas 				do_read = 1;
1421f263522aSJoseph Koshy 			do_print = 1;
1422f263522aSJoseph Koshy 			break;
1423f263522aSJoseph Koshy 
1424ebccf1e3SJoseph Koshy 		}
1425ebccf1e3SJoseph Koshy 
1426dceed24aSFabien Thomas 		if (do_print && !do_read) {
14270b86b1bbSFabien Thomas 			if ((args.pa_required & FLAG_HAS_OUTPUT_LOGFILE) == 0) {
14280b86b1bbSFabien Thomas 				pmcstat_print_pmcs();
142937d6f8a9SDavid E. O'Brien 				if (runstate == PMCSTAT_FINISHED &&
143037d6f8a9SDavid E. O'Brien 				    /* final newline */
143115139246SJoseph Koshy 				    (args.pa_flags & FLAG_DO_PRINT) == 0)
143215139246SJoseph Koshy 					(void) fprintf(args.pa_printfile, "\n");
14330b86b1bbSFabien Thomas 			}
14340b86b1bbSFabien Thomas 			if (args.pa_flags & FLAG_DO_TOP)
14350b86b1bbSFabien Thomas 				pmcstat_display_log();
1436f263522aSJoseph Koshy 			do_print = 0;
1437f263522aSJoseph Koshy 		}
1438f263522aSJoseph Koshy 
1439f263522aSJoseph Koshy 	} while (runstate != PMCSTAT_FINISHED);
1440f263522aSJoseph Koshy 
14410b86b1bbSFabien Thomas 	if ((args.pa_flags & FLAG_DO_TOP) && args.pa_toptty) {
14420b86b1bbSFabien Thomas 		pmcstat_topexit();
14430b86b1bbSFabien Thomas 		args.pa_toptty = 0;
14440b86b1bbSFabien Thomas 	}
14450b86b1bbSFabien Thomas 
1446f263522aSJoseph Koshy 	/* flush any pending log entries */
144715139246SJoseph Koshy 	if (args.pa_flags & (FLAG_HAS_OUTPUT_LOGFILE | FLAG_HAS_PIPE))
1448dceed24aSFabien Thomas 		pmc_close_logfile();
1449ebccf1e3SJoseph Koshy 
14500b86b1bbSFabien Thomas 	pmcstat_cleanup();
1451ebccf1e3SJoseph Koshy 
145249874f6eSJoseph Koshy 	free(args.pa_kernel);
145349874f6eSJoseph Koshy 
14547fbf3da2SJoseph Koshy 	/* check if the driver lost any samples or events */
14557fbf3da2SJoseph Koshy 	if (check_driver_stats) {
14567fbf3da2SJoseph Koshy 		if (pmc_get_driver_stats(&ds_end) < 0)
145737d6f8a9SDavid E. O'Brien 			err(EX_OSERR,
145837d6f8a9SDavid E. O'Brien 			    "ERROR: Cannot retrieve driver statistics");
145949874f6eSJoseph Koshy 		if (ds_start.pm_intr_bufferfull != ds_end.pm_intr_bufferfull &&
146049874f6eSJoseph Koshy 		    args.pa_verbosity > 0)
146137d6f8a9SDavid E. O'Brien 			warnx("WARNING: some samples were dropped.\n"
146237d6f8a9SDavid E. O'Brien "Please consider tuning the \"kern.hwpmc.nsamples\" tunable."
146337d6f8a9SDavid E. O'Brien 			    );
14647fbf3da2SJoseph Koshy 		if (ds_start.pm_buffer_requests_failed !=
146549874f6eSJoseph Koshy 		    ds_end.pm_buffer_requests_failed &&
146649874f6eSJoseph Koshy 		    args.pa_verbosity > 0)
146737d6f8a9SDavid E. O'Brien 			warnx("WARNING: some events were discarded.\n"
146837d6f8a9SDavid E. O'Brien "Please consider tuning the \"kern.hwpmc.nbuffers\" tunable."
146937d6f8a9SDavid E. O'Brien 			    );
14707fbf3da2SJoseph Koshy 	}
14717fbf3da2SJoseph Koshy 
14727fbf3da2SJoseph Koshy 	exit(EX_OK);
1473ebccf1e3SJoseph Koshy }
1474