[blktrace.git] / blktrace.c

/*
 * block queue tracing application
 *
 * Copyright (C) 2005 Jens Axboe <axboe@suse.de>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <locale.h>
#include <signal.h>
#include <fcntl.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/param.h>
#include <stdio.h>
#include <stdlib.h>
#include <sched.h>
#include <ctype.h>
#include <getopt.h>

#include "blktrace.h"

#define BUF_SIZE	(128 *1024)
#define BUF_NR		(4)

#define DECLARE_MASK_MAP(mask)          { BLK_TC_##mask, #mask, "BLK_TC_"#mask }
#define COMPARE_MASK_MAP(mmp, str)                                      \
        (!strcasecmp((mmp)->short_form, (str)) ||                      \
         !strcasecmp((mmp)->long_form, (str)))

#define VALID_SET(x)	((1 <= (x)) && ((x) < (1 << BLK_TC_SHIFT)))

struct mask_map {
	int mask;
	char *short_form;
	char *long_form;
};

struct mask_map mask_maps[] = {
	DECLARE_MASK_MAP(READ),
	DECLARE_MASK_MAP(WRITE),
	DECLARE_MASK_MAP(BARRIER),
	DECLARE_MASK_MAP(SYNC),
	DECLARE_MASK_MAP(QUEUE),
	DECLARE_MASK_MAP(REQUEUE),
	DECLARE_MASK_MAP(ISSUE),
	DECLARE_MASK_MAP(COMPLETE),
	DECLARE_MASK_MAP(FS),
	DECLARE_MASK_MAP(PC),
};

#define S_OPTS	"d:a:A:r:o:k"
static struct option l_opts[] = {
	{
		.name = "dev",
		.has_arg = 1,
		.flag = NULL,
		.val = 'd'
	},
	{
		.name = "act-mask",
		.has_arg = 1,
		.flag = NULL,
		.val = 'a'
	},
	{
		.name = "set-mask",
		.has_arg = 1,
		.flag = NULL,
		.val = 'A'
	},
	{
		.name = "relay",
		.has_arg = 1,
		.flag = NULL,
		.val = 'r'
	},
	{
		.name = "output",
		.has_arg = 1,
		.flag = NULL,
		.val = 'o'
	},
	{
		.name = "kill",
		.has_arg = 0,
		.flag = NULL,
		.val = 'k'
	},
	{
		.name = NULL,
		.has_arg = 0,
		.flag = NULL,
		.val = 0
	}
};

struct thread_information {
	int cpu;
	pthread_t thread;

	int fd;
	char fn[MAXPATHLEN + 64];

	pthread_mutex_t *fd_lock;
	int ofd;

	unsigned long events_processed;
};

static char *relay_path;

#define is_done()	(*(volatile int *)(&done))
static volatile int done;

static int devfd, ncpus;
static struct thread_information *thread_information;
static char *buts_name_p;
static char *dev;
static char *output_name;
static int act_mask = ~0U;
static int trace_started;
static int kill_running_trace;

static pthread_mutex_t stdout_mutex = PTHREAD_MUTEX_INITIALIZER;

static void exit_trace(int status);

static int find_mask_map(char *string)
{
	int i;

	for (i = 0; i < sizeof(mask_maps)/sizeof(mask_maps[0]); i++)
		if (COMPARE_MASK_MAP(&mask_maps[i], string))
			return mask_maps[i].mask;

	return -1;
}

static int start_trace(char *dev)
{
	struct blk_user_trace_setup buts;

	memset(&buts, 0, sizeof(buts));
	buts.buf_size = BUF_SIZE;
	buts.buf_nr = BUF_NR;
	buts.act_mask = act_mask;

	if (ioctl(devfd, BLKSTARTTRACE, &buts) < 0) {
		perror("BLKSTARTTRACE");
		return 1;
	}

	trace_started = 1;
	buts_name_p = strdup(buts.name);
	return 0;
}

static void stop_trace(void)
{
	if (trace_started || kill_running_trace) {
		if (ioctl(devfd, BLKSTOPTRACE) < 0)
			perror("BLKSTOPTRACE");

		trace_started = 0;
	}
}

static void extract_data(struct thread_information *tip, char *ofn, int nb)
{
	int ret, bytes_left;
	unsigned char *buf, *p;

	buf = malloc(nb);
	p = buf;
	bytes_left = nb;
	while (bytes_left > 0) {
		ret = read(tip->fd, p, bytes_left);
		if (!ret)
			usleep(1000);
		else if (ret < 0) {
			perror(tip->fn);
			fprintf(stderr, "Thread %d extract_data %s failed\n",
				tip->cpu, tip->fn);
			free(buf);
			exit_trace(1);
		} else {
			p += ret;
			bytes_left -= ret;
		}
	}

	ret = write(tip->ofd, buf, nb);
	if (ret != nb) {
		perror(ofn);
		fprintf(stderr,"Thread %d extract_data %s failed\n", tip->cpu, ofn);
		free(buf);
		exit_trace(1);
	}

	free(buf);
}

static inline void tip_fd_unlock(struct thread_information *tip)
{
	if (tip->fd_lock)
		pthread_mutex_unlock(tip->fd_lock);
}

static inline void tip_fd_lock(struct thread_information *tip)
{
	if (tip->fd_lock)
		pthread_mutex_lock(tip->fd_lock);
}

static void *extract(void *arg)
{
	struct thread_information *tip = arg;
	int ret, pdu_len;
	char dp[64];
	struct blk_io_trace t;
	pid_t pid = getpid();
	cpu_set_t cpu_mask;

	CPU_ZERO(&cpu_mask);
	CPU_SET((tip->cpu), &cpu_mask);

	if (sched_setaffinity(pid, sizeof(cpu_mask), &cpu_mask) == -1) {
		perror("sched_setaffinity");
		exit_trace(1);
	}

	snprintf(tip->fn, sizeof(tip->fn),
		 "%s/block/%s/trace%d", relay_path, buts_name_p, tip->cpu);
	tip->fd = open(tip->fn, O_RDONLY);
	if (tip->fd < 0) {
		perror(tip->fn);
		fprintf(stderr,"Thread %d failed open of %s\n", tip->cpu,
			tip->fn);
		exit_trace(1);
	}

	while (!is_done()) {
		ret = read(tip->fd, &t, sizeof(t));
		if (ret != sizeof(t)) {
			if (ret < 0) {
				perror(tip->fn);
				fprintf(stderr,"Thread %d failed read of %s\n",
					tip->cpu, tip->fn);
				exit_trace(1);
			} else if (ret > 0) {
				fprintf(stderr,"Thread %d misread %s %d,%d\n",
					tip->cpu, tip->fn, ret, (int)sizeof(t));
				exit_trace(1);
			} else {
				usleep(10000);
				continue;
			}
		}

		if (verify_trace(&t))
			exit_trace(1);

		pdu_len = t.pdu_len;

		trace_to_be(&t);

		tip_fd_lock(tip);

		ret = write(tip->ofd, &t, sizeof(t));
		if (ret < 0) {
			fprintf(stderr,"Thread %d failed write\n", tip->cpu);
			tip_fd_unlock(tip);
			exit_trace(1);
		}

		if (pdu_len)
			extract_data(tip, dp, pdu_len);

		tip_fd_unlock(tip);

		tip->events_processed++;
	}

	return NULL;
}

static int start_threads(void)
{
	struct thread_information *tip;
	char op[64];
	int i;

	ncpus = sysconf(_SC_NPROCESSORS_ONLN);
	if (ncpus < 0) {
		fprintf(stderr, "sysconf(_SC_NPROCESSORS_ONLN) failed\n");
		return 0;
	}

	thread_information = malloc(ncpus * sizeof(struct thread_information));
	for (i = 0, tip = thread_information; i < ncpus; i++, tip++) {
		tip->fd_lock = NULL;
		tip->cpu = i;
		tip->events_processed = 0;

		if (!strcmp(output_name, "-")) {
			tip->ofd = dup(STDOUT_FILENO);
			tip->fd_lock = &stdout_mutex;
		} else {
			sprintf(op, "%s_out.%d", output_name, tip->cpu);
			tip->ofd = open(op, O_CREAT|O_TRUNC|O_WRONLY, 0644);
		}

		if (tip->ofd < 0) {
			perror(op);
			return 0;
		}

		if (pthread_create(&tip->thread, NULL, extract, tip)) {
			perror( "pthread_create");
			return 0;
		}
	}

	return ncpus;
}

static void close_thread(struct thread_information *tip)
{
	if (tip->fd != -1)
		close(tip->fd);
	if (tip->ofd != -1)
		close(tip->ofd);
	tip->fd = tip->ofd = -1;
}

static void stop_threads(void)
{
	struct thread_information *tip = thread_information;
	int i;

	for (i = 0; i < ncpus; i++, tip++) {
		int ret;

		if (pthread_join(tip->thread, (void *) &ret))
			perror("thread_join");
		close_thread(tip);
	}
}

static void stop_tracing(void)
{
	struct thread_information *tip = thread_information;
	int i;

	for (i = 0; i < ncpus; i++, tip++)
		close_thread(tip);
	stop_trace();
}

static void exit_trace(int status)
{
	stop_tracing();
	exit(status);
}

static void show_stats(void)
{
	int i;
	struct thread_information *tip;
	unsigned long events_processed = 0;

	if (!strcmp(output_name, "-"))
		return;

	for (i = 0, tip = thread_information; i < ncpus; i++, tip++) {
		printf("CPU%3d: %20ld events\n",
		       tip->cpu, tip->events_processed);
		events_processed += tip->events_processed;
	}

	printf("Total:  %20ld events\n", events_processed);
}

static void handle_sigint(int sig)
{
	done = 1;
}

int main(int argc, char *argv[])
{
	static char default_relay_path[] = "/relay";
	struct stat st;
	int i, c;
	int act_mask_tmp = 0;

	while ((c = getopt_long(argc, argv, S_OPTS, l_opts, NULL)) >= 0) {
		switch (c) {
		case 'a':
			i = find_mask_map(optarg);
			if (i < 0) {
				fprintf(stderr,"Invalid action mask %s\n", 
					optarg);
				return 4;
			}
			act_mask_tmp |= i;
			break;

		case 'A':
			if ((sscanf(optarg, "%x", &i) != 1) || !VALID_SET(i)) {
				fprintf(stderr,
					"Invalid set action mask %s/0x%x\n", 
					optarg, i);
				return 4;
			}
			act_mask_tmp = i;
			break;

		case 'd':
			dev = strdup(optarg);
			break;

		case 'r':
			relay_path = optarg;
			break;

		case 'o':
			output_name = strdup(optarg);
			break;
		case 'k':
			kill_running_trace = 1;
			break;

		default:
			fprintf(stderr,"Usage: %s -d <dev> "
				       "[-a <trace> [-a <trace>]]\n", argv[0]);
			return 4;
		}
	}

	if ((dev == NULL) || (optind < argc)) {
		fprintf(stderr,"Usage: %s -d <dev> "
			       "[-a <trace> [-a <trace>]]\n", argv[0]);
		return 4;
	}

	if (!relay_path)
		relay_path = default_relay_path;

	if (act_mask_tmp != 0)
		act_mask = act_mask_tmp;

	if (stat(relay_path, &st) < 0) {
		fprintf(stderr,"%s does not appear to be mounted\n",
			relay_path);
		return 2;
	}

	devfd = open(dev, O_RDONLY);
	if (devfd < 0) {
		perror(dev);
		return 3;
	}

	if (kill_running_trace) {
		stop_trace();
		exit(0);
	}

	if (start_trace(dev)) {
		close(devfd);
		fprintf(stderr, "Failed to start trace on %s\n", dev);
		return 4;
	}

	setlocale(LC_NUMERIC, "en_US");

	if (!output_name)
		output_name = strdup(buts_name_p);

	i = start_threads();
	if (!i) {
		fprintf(stderr, "Failed to start worker threads\n");
		stop_trace();
		return 5;
	}

	signal(SIGINT, handle_sigint);
	signal(SIGHUP, handle_sigint);
	signal(SIGTERM, handle_sigint);

	atexit(stop_tracing);

	while (!is_done())
		sleep(1);

	stop_threads();
	stop_trace();
	show_stats();
	close(devfd);

	return 0;
}
Commit	Line	Data
d0ca268b JA	1	/*
	2	* block queue tracing application
	3	*
d956a2cd JA	4	* Copyright (C) 2005 Jens Axboe <axboe@suse.de>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	19	*
d0ca268b JA	20	*/
	21	#include <pthread.h>
	22	#include <sys/types.h>
	23	#include <sys/stat.h>
	24	#include <unistd.h>
	25	#include <locale.h>
	26	#include <signal.h>
	27	#include <fcntl.h>
	28	#include <string.h>
	29	#include <sys/ioctl.h>
b9d4294e	30	#include <sys/param.h>
d0ca268b JA	31	#include <stdio.h>
	32	#include <stdlib.h>
	33	#include <sched.h>
d39c04ca AB	34	#include <ctype.h>
d39c04ca AB	35	#include <getopt.h>
d0ca268b JA	36
	37	#include "blktrace.h"
	38
	39	#define BUF_SIZE (128 *1024)
	40	#define BUF_NR (4)
	41
d39c04ca AB	42	#define DECLARE_MASK_MAP(mask) { BLK_TC_##mask, #mask, "BLK_TC_"#mask }
d39c04ca AB	43	#define COMPARE_MASK_MAP(mmp, str) \
75da3c6a NS	44	(!strcasecmp((mmp)->short_form, (str)) \|\| \
75da3c6a NS	45	!strcasecmp((mmp)->long_form, (str)))
d39c04ca AB	46
	47	#define VALID_SET(x) ((1 <= (x)) && ((x) < (1 << BLK_TC_SHIFT)))
	48
	49	struct mask_map {
	50	int mask;
	51	char *short_form;
	52	char *long_form;
	53	};
	54
	55	struct mask_map mask_maps[] = {
5c86134e JA	56	DECLARE_MASK_MAP(READ),
	57	DECLARE_MASK_MAP(WRITE),
	58	DECLARE_MASK_MAP(BARRIER),
	59	DECLARE_MASK_MAP(SYNC),
	60	DECLARE_MASK_MAP(QUEUE),
	61	DECLARE_MASK_MAP(REQUEUE),
	62	DECLARE_MASK_MAP(ISSUE),
	63	DECLARE_MASK_MAP(COMPLETE),
	64	DECLARE_MASK_MAP(FS),
	65	DECLARE_MASK_MAP(PC),
d39c04ca AB	66	};
d39c04ca AB	67
bc39777c	68	#define S_OPTS "d:a:A:r:o:k"
d5396421	69	static struct option l_opts[] = {
5c86134e	70	{
d39c04ca AB	71	.name = "dev",
	72	.has_arg = 1,
	73	.flag = NULL,
	74	.val = 'd'
	75	},
5c86134e	76	{
d39c04ca AB	77	.name = "act-mask",
	78	.has_arg = 1,
	79	.flag = NULL,
	80	.val = 'a'
	81	},
5c86134e	82	{
d39c04ca AB	83	.name = "set-mask",
	84	.has_arg = 1,
	85	.flag = NULL,
	86	.val = 'A'
	87	},
5c86134e	88	{
5270dddd JA	89	.name = "relay",
	90	.has_arg = 1,
	91	.flag = NULL,
	92	.val = 'r'
	93	},
d5396421 JA	94	{
	95	.name = "output",
	96	.has_arg = 1,
	97	.flag = NULL,
	98	.val = 'o'
	99	},
bc39777c JA	100	{
	101	.name = "kill",
	102	.has_arg = 0,
	103	.flag = NULL,
	104	.val = 'k'
	105	},
d39c04ca AB	106	{
	107	.name = NULL,
	108	.has_arg = 0,
	109	.flag = NULL,
	110	.val = 0
	111	}
	112	};
	113
d0ca268b JA	114	struct thread_information {
	115	int cpu;
	116	pthread_t thread;
b9d4294e JA	117
	118	int fd;
	119	char fn[MAXPATHLEN + 64];
	120
d5396421 JA	121	pthread_mutex_t *fd_lock;
	122	int ofd;
	123
d0ca268b JA	124	unsigned long events_processed;
	125	};
	126
5270dddd	127	static char *relay_path;
d0ca268b JA	128
	129	#define is_done() ((volatile int )(&done))
	130	static volatile int done;
	131
	132	static int devfd, ncpus;
	133	static struct thread_information *thread_information;
	134	static char *buts_name_p;
d39c04ca	135	static char *dev;
d5396421	136	static char *output_name;
5c86134e	137	static int act_mask = ~0U;
830fd65c	138	static int trace_started;
bc39777c	139	static int kill_running_trace;
d39c04ca	140
d5396421 JA	141	static pthread_mutex_t stdout_mutex = PTHREAD_MUTEX_INITIALIZER;
d5396421 JA	142
72ca8801 NS	143	static void exit_trace(int status);
72ca8801 NS	144
1f79c4a0	145	static int find_mask_map(char *string)
d39c04ca	146	{
5c86134e JA	147	int i;
	148
	149	for (i = 0; i < sizeof(mask_maps)/sizeof(mask_maps[0]); i++)
75da3c6a	150	if (COMPARE_MASK_MAP(&mask_maps[i], string))
5c86134e	151	return mask_maps[i].mask;
d39c04ca	152
d39c04ca AB	153	return -1;
d39c04ca AB	154	}
d0ca268b	155
3aabcd89	156	static int start_trace(char *dev)
d0ca268b JA	157	{
	158	struct blk_user_trace_setup buts;
	159
1f79c4a0	160	memset(&buts, 0, sizeof(buts));
d0ca268b JA	161	buts.buf_size = BUF_SIZE;
d0ca268b JA	162	buts.buf_nr = BUF_NR;
d39c04ca	163	buts.act_mask = act_mask;
d0ca268b	164
d0ca268b JA	165	if (ioctl(devfd, BLKSTARTTRACE, &buts) < 0) {
	166	perror("BLKSTARTTRACE");
	167	return 1;
	168	}
	169
830fd65c	170	trace_started = 1;
d0ca268b JA	171	buts_name_p = strdup(buts.name);
	172	return 0;
	173	}
	174
3aabcd89	175	static void stop_trace(void)
d0ca268b	176	{
bc39777c	177	if (trace_started \|\| kill_running_trace) {
707b0914 JA	178	if (ioctl(devfd, BLKSTOPTRACE) < 0)
707b0914 JA	179	perror("BLKSTOPTRACE");
d0ca268b	180
707b0914 JA	181	trace_started = 0;
707b0914 JA	182	}
d0ca268b JA	183	}
d0ca268b JA	184
d5396421	185	static void extract_data(struct thread_information tip, char ofn, int nb)
d0ca268b JA	186	{
d0ca268b JA	187	int ret, bytes_left;
87b72777	188	unsigned char buf, p;
d0ca268b	189
87b72777	190	buf = malloc(nb);
d0ca268b JA	191	p = buf;
	192	bytes_left = nb;
	193	while (bytes_left > 0) {
b9d4294e	194	ret = read(tip->fd, p, bytes_left);
3aabcd89 JA	195	if (!ret)
	196	usleep(1000);
	197	else if (ret < 0) {
b9d4294e	198	perror(tip->fn);
d0ca268b	199	fprintf(stderr, "Thread %d extract_data %s failed\n",
b9d4294e	200	tip->cpu, tip->fn);
87b72777	201	free(buf);
76718bcd	202	exit_trace(1);
3aabcd89	203	} else {
d0ca268b JA	204	p += ret;
	205	bytes_left -= ret;
	206	}
	207	}
	208
d5396421	209	ret = write(tip->ofd, buf, nb);
d0ca268b JA	210	if (ret != nb) {
d0ca268b JA	211	perror(ofn);
b9d4294e	212	fprintf(stderr,"Thread %d extract_data %s failed\n", tip->cpu, ofn);
87b72777	213	free(buf);
76718bcd	214	exit_trace(1);
d0ca268b	215	}
87b72777 JA	216
87b72777 JA	217	free(buf);
d0ca268b JA	218	}
d0ca268b JA	219
d5396421 JA	220	static inline void tip_fd_unlock(struct thread_information *tip)
	221	{
	222	if (tip->fd_lock)
	223	pthread_mutex_unlock(tip->fd_lock);
	224	}
	225
	226	static inline void tip_fd_lock(struct thread_information *tip)
	227	{
	228	if (tip->fd_lock)
	229	pthread_mutex_lock(tip->fd_lock);
	230	}
	231
3aabcd89	232	static void extract(void arg)
d0ca268b JA	233	{
d0ca268b JA	234	struct thread_information *tip = arg;
d5396421 JA	235	int ret, pdu_len;
d5396421 JA	236	char dp[64];
d0ca268b JA	237	struct blk_io_trace t;
	238	pid_t pid = getpid();
	239	cpu_set_t cpu_mask;
	240
	241	CPU_ZERO(&cpu_mask);
b9d4294e	242	CPU_SET((tip->cpu), &cpu_mask);
d0ca268b JA	243
	244	if (sched_setaffinity(pid, sizeof(cpu_mask), &cpu_mask) == -1) {
	245	perror("sched_setaffinity");
76718bcd	246	exit_trace(1);
d0ca268b JA	247	}
d0ca268b JA	248
b9d4294e JA	249	snprintf(tip->fn, sizeof(tip->fn),
	250	"%s/block/%s/trace%d", relay_path, buts_name_p, tip->cpu);
	251	tip->fd = open(tip->fn, O_RDONLY);
	252	if (tip->fd < 0) {
	253	perror(tip->fn);
5c86134e JA	254	fprintf(stderr,"Thread %d failed open of %s\n", tip->cpu,
5c86134e JA	255	tip->fn);
76718bcd	256	exit_trace(1);
d0ca268b JA	257	}
	258
	259	while (!is_done()) {
b9d4294e	260	ret = read(tip->fd, &t, sizeof(t));
d0ca268b JA	261	if (ret != sizeof(t)) {
d0ca268b JA	262	if (ret < 0) {
b9d4294e	263	perror(tip->fn);
d0ca268b	264	fprintf(stderr,"Thread %d failed read of %s\n",
b9d4294e	265	tip->cpu, tip->fn);
76718bcd	266	exit_trace(1);
d0ca268b	267	} else if (ret > 0) {
8fc0abbc	268	fprintf(stderr,"Thread %d misread %s %d,%d\n",
b9d4294e	269	tip->cpu, tip->fn, ret, (int)sizeof(t));
76718bcd	270	exit_trace(1);
d0ca268b JA	271	} else {
	272	usleep(10000);
	273	continue;
	274	}
	275	}
	276
	277	if (verify_trace(&t))
76718bcd	278	exit_trace(1);
d0ca268b	279
18ada3d4 JA	280	pdu_len = t.pdu_len;
18ada3d4 JA	281
6fe4709e JA	282	trace_to_be(&t);
6fe4709e JA	283
d5396421 JA	284	tip_fd_lock(tip);
	285
	286	ret = write(tip->ofd, &t, sizeof(t));
d0ca268b	287	if (ret < 0) {
d5396421 JA	288	fprintf(stderr,"Thread %d failed write\n", tip->cpu);
d5396421 JA	289	tip_fd_unlock(tip);
76718bcd	290	exit_trace(1);
d0ca268b JA	291	}
d0ca268b JA	292
18ada3d4	293	if (pdu_len)
d5396421 JA	294	extract_data(tip, dp, pdu_len);
	295
	296	tip_fd_unlock(tip);
87b72777	297
d0ca268b JA	298	tip->events_processed++;
	299	}
	300
	301	return NULL;
	302	}
	303
3aabcd89	304	static int start_threads(void)
d0ca268b JA	305	{
d0ca268b JA	306	struct thread_information *tip;
d5396421	307	char op[64];
d0ca268b JA	308	int i;
	309
	310	ncpus = sysconf(_SC_NPROCESSORS_ONLN);
	311	if (ncpus < 0) {
	312	fprintf(stderr, "sysconf(_SC_NPROCESSORS_ONLN) failed\n");
1f79c4a0	313	return 0;
d0ca268b	314	}
d0ca268b JA	315
	316	thread_information = malloc(ncpus * sizeof(struct thread_information));
	317	for (i = 0, tip = thread_information; i < ncpus; i++, tip++) {
d5396421	318	tip->fd_lock = NULL;
d0ca268b JA	319	tip->cpu = i;
	320	tip->events_processed = 0;
	321
d5396421	322	if (!strcmp(output_name, "-")) {
1f79c4a0	323	tip->ofd = dup(STDOUT_FILENO);
d5396421 JA	324	tip->fd_lock = &stdout_mutex;
	325	} else {
	326	sprintf(op, "%s_out.%d", output_name, tip->cpu);
	327	tip->ofd = open(op, O_CREAT\|O_TRUNC\|O_WRONLY, 0644);
	328	}
	329
	330	if (tip->ofd < 0) {
	331	perror(op);
1f79c4a0	332	return 0;
d5396421 JA	333	}
d5396421 JA	334
d0ca268b JA	335	if (pthread_create(&tip->thread, NULL, extract, tip)) {
	336	perror( "pthread_create");
	337	return 0;
	338	}
	339	}
	340
	341	return ncpus;
	342	}
	343
72ca8801 NS	344	static void close_thread(struct thread_information *tip)
	345	{
	346	if (tip->fd != -1)
	347	close(tip->fd);
	348	if (tip->ofd != -1)
	349	close(tip->ofd);
	350	tip->fd = tip->ofd = -1;
	351	}
	352
3aabcd89 JA	353	static void stop_threads(void)
	354	{
	355	struct thread_information *tip = thread_information;
	356	int i;
	357
	358	for (i = 0; i < ncpus; i++, tip++) {
	359	int ret;
	360
	361	if (pthread_join(tip->thread, (void *) &ret))
	362	perror("thread_join");
72ca8801	363	close_thread(tip);
3aabcd89 JA	364	}
	365	}
	366
72ca8801 NS	367	static void stop_tracing(void)
	368	{
	369	struct thread_information *tip = thread_information;
	370	int i;
	371
	372	for (i = 0; i < ncpus; i++, tip++)
	373	close_thread(tip);
	374	stop_trace();
	375	}
	376
	377	static void exit_trace(int status)
	378	{
	379	stop_tracing();
	380	exit(status);
	381	}
	382
1f79c4a0	383	static void show_stats(void)
d0ca268b JA	384	{
	385	int i;
	386	struct thread_information *tip;
	387	unsigned long events_processed = 0;
	388
d5396421 JA	389	if (!strcmp(output_name, "-"))
	390	return;
	391
d0ca268b JA	392	for (i = 0, tip = thread_information; i < ncpus; i++, tip++) {
	393	printf("CPU%3d: %20ld events\n",
	394	tip->cpu, tip->events_processed);
	395	events_processed += tip->events_processed;
	396	}
	397
	398	printf("Total: %20ld events\n", events_processed);
	399	}
	400
1f79c4a0	401	static void handle_sigint(int sig)
d0ca268b	402	{
d0ca268b JA	403	done = 1;
	404	}
	405
	406	int main(int argc, char *argv[])
	407	{
5270dddd	408	static char default_relay_path[] = "/relay";
d0ca268b	409	struct stat st;
d39c04ca AB	410	int i, c;
	411	int act_mask_tmp = 0;
	412
	413	while ((c = getopt_long(argc, argv, S_OPTS, l_opts, NULL)) >= 0) {
	414	switch (c) {
	415	case 'a':
	416	i = find_mask_map(optarg);
	417	if (i < 0) {
	418	fprintf(stderr,"Invalid action mask %s\n",
	419	optarg);
	420	return 4;
	421	}
	422	act_mask_tmp \|= i;
	423	break;
	424
	425	case 'A':
	426	if ((sscanf(optarg, "%x", &i) != 1) \|\| !VALID_SET(i)) {
	427	fprintf(stderr,
	428	"Invalid set action mask %s/0x%x\n",
	429	optarg, i);
	430	return 4;
	431	}
	432	act_mask_tmp = i;
	433	break;
d0ca268b	434
d39c04ca AB	435	case 'd':
	436	dev = strdup(optarg);
	437	break;
	438
5270dddd JA	439	case 'r':
	440	relay_path = optarg;
	441	break;
	442
d5396421 JA	443	case 'o':
	444	output_name = strdup(optarg);
	445	break;
bc39777c JA	446	case 'k':
	447	kill_running_trace = 1;
	448	break;
d5396421	449
d39c04ca AB	450	default:
	451	fprintf(stderr,"Usage: %s -d <dev> "
	452	"[-a <trace> [-a <trace>]]\n", argv[0]);
	453	return 4;
	454	}
	455	}
	456
	457	if ((dev == NULL) \|\| (optind < argc)) {
	458	fprintf(stderr,"Usage: %s -d <dev> "
	459	"[-a <trace> [-a <trace>]]\n", argv[0]);
	460	return 4;
	461	}
	462
5270dddd JA	463	if (!relay_path)
	464	relay_path = default_relay_path;
	465
d5396421	466	if (act_mask_tmp != 0)
d39c04ca	467	act_mask = act_mask_tmp;
d0ca268b JA	468
d0ca268b JA	469	if (stat(relay_path, &st) < 0) {
d39c04ca	470	fprintf(stderr,"%s does not appear to be mounted\n",
d0ca268b JA	471	relay_path);
	472	return 2;
	473	}
	474
bc39777c JA	475	devfd = open(dev, O_RDONLY);
	476	if (devfd < 0) {
	477	perror(dev);
	478	return 3;
	479	}
	480
	481	if (kill_running_trace) {
	482	stop_trace();
	483	exit(0);
	484	}
	485
d39c04ca	486	if (start_trace(dev)) {
5270dddd	487	close(devfd);
d39c04ca	488	fprintf(stderr, "Failed to start trace on %s\n", dev);
bc39777c	489	return 4;
d0ca268b JA	490	}
	491
	492	setlocale(LC_NUMERIC, "en_US");
	493
d5396421 JA	494	if (!output_name)
	495	output_name = strdup(buts_name_p);
	496
d0ca268b JA	497	i = start_threads();
	498	if (!i) {
	499	fprintf(stderr, "Failed to start worker threads\n");
	500	stop_trace();
bc39777c	501	return 5;
d0ca268b JA	502	}
d0ca268b JA	503
d0ca268b JA	504	signal(SIGINT, handle_sigint);
	505	signal(SIGHUP, handle_sigint);
	506	signal(SIGTERM, handle_sigint);
	507
72ca8801	508	atexit(stop_tracing);
830fd65c	509
d0ca268b JA	510	while (!is_done())
	511	sleep(1);
	512
b9d4294e	513	stop_threads();
3a9995b9	514	stop_trace();
d0ca268b	515	show_stats();
bc39777c	516	close(devfd);
d0ca268b JA	517
	518	return 0;
	519	}
	520