[blktrace.git] / blkparse.c

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>

#include "blktrace.h"
#include "rbtree.h"

#define MAX_CPUS	(512)

struct per_file_info {
	int cpu;
	int nelems;

	int fd;
	char fname[128];

	FILE *ofp;
	char ofname[128];

	unsigned long long start_time;

	unsigned long qreads, qwrites, creads, cwrites, mreads, mwrites;
	unsigned long long qread_kb, qwrite_kb, cread_kb, cwrite_kb;
};

static struct rb_root rb_root;

struct trace {
	struct blk_io_trace *bit;
	unsigned int cpu;
	struct rb_node rb_node;
};

static struct per_file_info per_file_info[MAX_CPUS];
static struct per_file_info *cur_file;

static unsigned long long events;

static int max_cpus;

static inline void account_m(struct per_file_info *pfi, int rw,
			     unsigned int bytes)
{
	if (rw) {
		pfi->mwrites++;
		pfi->qwrite_kb += bytes >> 10;
	} else {
		pfi->mreads++;
		pfi->qread_kb += bytes >> 10;
	}
}

static inline void account_q(struct per_file_info *pfi, int rw,
			     unsigned int bytes)
{
	if (rw) {
		pfi->qwrites++;
		pfi->qwrite_kb += bytes >> 10;
	} else {
		pfi->qreads++;
		pfi->qread_kb += bytes >> 10;
	}
}

static inline void account_c(struct per_file_info *pfi, int rw,
			     unsigned int bytes)
{
	if (rw) {
		pfi->cwrites++;
		pfi->cwrite_kb += bytes >> 10;
	} else {
		pfi->creads++;
		pfi->cread_kb += bytes >> 10;
	}
}

static void output(char *s)
{
	printf("%s", s);
	fprintf(cur_file->ofp,"%s",s);
}

static char hstring[256];
static char tstring[256];

static inline char *setup_header(struct blk_io_trace *t, char act)
{
	int w = t->action & BLK_TC_ACT(BLK_TC_WRITE);
	int b = t->action & BLK_TC_ACT(BLK_TC_BARRIER);
	int s = t->action & BLK_TC_ACT(BLK_TC_SYNC);
	char rwbs[4];
	int i = 0;

	if (w)
		rwbs[i++] = 'W';
	else
		rwbs[i++] = 'R';
	if (b)
		rwbs[i++] = 'B';
	if (s)
		rwbs[i++] = 'S';

	rwbs[i] = '\0';

	sprintf(hstring, "%3d %15ld %12Lu %5u %c %3s", cur_file->cpu,
		(unsigned long)t->sequence, (unsigned long long)t->time, t->pid,
		act, rwbs);

	return hstring;
}

static void log_complete(struct blk_io_trace *t, char act)
{
	sprintf(tstring,"%s %Lu + %u [%d]\n", setup_header(t, act),
		(unsigned long long)t->sector, t->bytes >> 9, t->error);
	output(tstring);
}

static void log_queue(struct blk_io_trace *t, char act)
{
	sprintf(tstring,"%s %Lu + %u\n", setup_header(t, act),
		(unsigned long long)t->sector, t->bytes >> 9);
	output(tstring);
}

static void log_issue(struct blk_io_trace *t, char act)
{
	sprintf(tstring,"%s %Lu + %u\n", setup_header(t, act),
		(unsigned long long)t->sector, t->bytes >> 9);
	output(tstring);
}

static void log_merge(struct blk_io_trace *t, char act)
{
	sprintf(tstring,"%s   %Lu + %u\n", setup_header(t, act),
		(unsigned long long)t->sector, t->bytes >> 9);
	output(tstring);
}

static void log_generic(struct blk_io_trace *t, char act)
{
	sprintf(tstring,"%s %Lu + %u\n", setup_header(t, act),
		(unsigned long long)t->sector, t->bytes >> 9);
	output(tstring);
}

static int log_pc(struct blk_io_trace *t, char act)
{
	unsigned char *buf;
	int i;

	sprintf(tstring,"%s ", setup_header(t, act));
	output(tstring);

	buf = (unsigned char *) t + sizeof(*t);
	for (i = 0; i < t->pdu_len; i++) {
		sprintf(tstring,"%02x ", buf[i]);
		output(tstring);
	}

	if (act == 'C') {
		sprintf(tstring,"[%d]", t->error);
		output(tstring);
	}

	printf("\n");
	return 0;
}

static int dump_trace_pc(struct blk_io_trace *t, struct per_file_info *pfi)
{
	int ret = 0;

	switch (t->action & 0xffff) {
		case __BLK_TA_QUEUE:
			log_generic(t, 'Q');
			break;
		case __BLK_TA_GETRQ:
			log_generic(t, 'G');
			break;
		case __BLK_TA_SLEEPRQ:
			log_generic(t, 'S');
			break;
		case __BLK_TA_REQUEUE:
			log_generic(t, 'R');
			break;
		case __BLK_TA_ISSUE:
			ret = log_pc(t, 'D');
			break;
		case __BLK_TA_COMPLETE:
			log_pc(t, 'C');
			break;
		default:
			fprintf(stderr, "Bad pc action %x\n", t->action);
			ret = 1;
			break;
	}
	
	return ret;
}

static void dump_trace_fs(struct blk_io_trace *t, struct per_file_info *pfi)
{
	int w = t->action & BLK_TC_ACT(BLK_TC_WRITE);

	switch (t->action & 0xffff) {
		case __BLK_TA_QUEUE:
			account_q(pfi, w, t->bytes);
			log_queue(t, 'Q');
			break;
		case __BLK_TA_BACKMERGE:
			account_m(pfi, w, t->bytes);
			log_merge(t, 'M');
			break;
		case __BLK_TA_FRONTMERGE:
			account_m(pfi, w, t->bytes);
			log_merge(t, 'F');
			break;
		case __BLK_TA_GETRQ:
			log_generic(t, 'G');
			break;
		case __BLK_TA_SLEEPRQ:
			log_generic(t, 'S');
			break;
		case __BLK_TA_REQUEUE:
			account_c(pfi, w, -t->bytes);
			log_queue(t, 'R');
			break;
		case __BLK_TA_ISSUE:
			log_issue(t, 'D');
			break;
		case __BLK_TA_COMPLETE:
			account_c(pfi, w, t->bytes);
			log_complete(t, 'C');
			break;
		default:
			fprintf(stderr, "Bad fs action %x\n", t->action);
			return;
	}
}

static int dump_trace(struct blk_io_trace *t, struct per_file_info *pfi)
{
	int ret = 0;

	if (t->action & BLK_TC_ACT(BLK_TC_PC))
		ret = dump_trace_pc(t, pfi);
	else
		dump_trace_fs(t, pfi);

	events++;
	return ret;
}

static void dump_pfi_stats(struct per_file_info *pfi)
{
	printf("\tReads:\n");
	printf("\t\tQueued:    %'8lu, %'8LuKiB\n", pfi->qreads, pfi->qread_kb);
	printf("\t\tCompleted: %'8lu, %'8LuKiB\n", pfi->creads, pfi->cread_kb);
	printf("\t\tMerges:    %'8lu\n", pfi->mreads);

	printf("\tWrites:\n");
	printf("\t\tQueued:    %'8lu, %'8LuKiB\n", pfi->qwrites,pfi->qwrite_kb);
	printf("\t\tCompleted: %'8lu, %'8LuKiB\n", pfi->cwrites,pfi->cwrite_kb);
	printf("\t\tMerges:    %'8lu\n", pfi->mwrites);
}

static void show_stats(int nfiles)
{
	struct per_file_info foo, *pfi;
	int i;

	memset(&foo, 0, sizeof(foo));

	for (i = 0; i < nfiles; i++) {
		pfi = &per_file_info[i];

		foo.qreads += pfi->qreads;
		foo.qwrites += pfi->qwrites;
		foo.creads += pfi->creads;
		foo.cwrites += pfi->cwrites;
		foo.mreads += pfi->mreads;
		foo.mwrites += pfi->mwrites;
		foo.qread_kb += pfi->qread_kb;
		foo.qwrite_kb += pfi->qwrite_kb;
		foo.cread_kb += pfi->cread_kb;
		foo.cwrite_kb += pfi->cwrite_kb;

		printf("CPU%d:\n", i);
		dump_pfi_stats(pfi);
	}

	if (nfiles > 1) {
		printf("Total:\n");
		dump_pfi_stats(&foo);
	}

	printf("Events: %'Lu\n", events);
}

static inline int trace_rb_insert(struct trace *t)
{
	struct rb_node **p = &rb_root.rb_node;
	struct rb_node *parent = NULL;
	struct trace *__t;

	while (*p) {
		parent = *p;
		__t = rb_entry(parent, struct trace, rb_node);

		if (t->bit->sequence < __t->bit->sequence)
			p = &(*p)->rb_left;
		else if (t->bit->sequence > __t->bit->sequence)
			p = &(*p)->rb_right;
		else {
			fprintf(stderr, "sequence alias!\n");
			return 1;
		}
	}

	rb_link_node(&t->rb_node, parent, p);
	rb_insert_color(&t->rb_node, &rb_root);
	return 0;
}

static int sort_entries(void *traces, unsigned long offset, int cpu)
{
	struct blk_io_trace *bit;
	struct trace *t;
	void *start = traces;
	int nelems = 0;

	while (traces - start <= offset - sizeof(*bit)) {
		bit = traces;

		t = malloc(sizeof(*t));
		t->bit = bit;
		t->cpu = cpu;
		memset(&t->rb_node, 0, sizeof(t->rb_node));

		trace_to_cpu(bit);

		if (verify_trace(bit))
			break;

		if (trace_rb_insert(t))
			return -1;

		traces += sizeof(*bit) + bit->pdu_len;
		nelems++;
	}

	return nelems;
}

static void show_entries(void)
{
	struct blk_io_trace *bit;
	struct rb_node *n;
	struct trace *t;
	int cpu;

	n = rb_first(&rb_root);
	if (!n)
		return;

	do {
		t = rb_entry(n, struct trace, rb_node);
		bit = t->bit;

		cpu = t->cpu;
		if (cpu > max_cpus) {
			fprintf(stderr, "CPU number too large (%d)\n", cpu);
			break;
		}

		cur_file = &per_file_info[cpu];

		/*
		 * offset time by first trace event.
		 *
		 * NOTE: This is *cpu* relative, thus you can not
		 * compare times ACROSS cpus.
		 */
		if (cur_file->start_time == 0)
			cur_file->start_time = bit->time;

		bit->time -= cur_file->start_time;

		if (dump_trace(bit, cur_file))
			break;

	} while ((n = rb_next(n)) != NULL);
}

int main(int argc, char *argv[])
{
	int i, nfiles, ret;
	char *dev;

	if (argc != 2) {
		fprintf(stderr, "Usage: %s <dev>\n", argv[0]);
		return 1;
	}

	dev = argv[1];

	memset(&rb_root, 0, sizeof(rb_root));
	memset(per_file_info, 0, sizeof(per_file_info));

	for (max_cpus = 0, i = 0, nfiles = 0; i < MAX_CPUS; i++) {
		struct per_file_info *pfi = &per_file_info[i];
		struct stat st;
		void *tb;

		pfi->cpu = i;
		pfi->start_time = 0;

		snprintf(pfi->fname, sizeof(pfi->fname)-1,"%s_out.%d", dev, i);
		if (stat(pfi->fname, &st) < 0)
			break;

		snprintf(pfi->ofname, sizeof(pfi->ofname)-1, "%s_log.%d", dev, i);
		pfi->ofp = fopen(pfi->ofname, "w");
		if (pfi->ofp == NULL) {
			perror(pfi->ofname);
			break;
		}

		printf("Processing %s\n", pfi->fname);

		tb = malloc(st.st_size);

		pfi->fd = open(pfi->fname, O_RDONLY);
		if (pfi->fd < 0) {
			perror(pfi->fname);
			break;
		}
		if (read(pfi->fd, tb, st.st_size) != st.st_size) {
			fprintf(stderr, "error reading\n");
			break;
		}

		ret = sort_entries(tb, st.st_size, i);
		if (ret == -1)
			break;

		close(pfi->fd);
		nfiles++;
		max_cpus++;
		pfi->nelems = ret;
		printf("\t%2d %10s %15d\n", i, pfi->fname, pfi->nelems);

	}

	if (nfiles) {
		show_entries();
		show_stats(nfiles);
		return 0;
	}

	fprintf(stderr, "No files found\n");
	return 1;
}
Commit	Line	Data
d0ca268b JA	1	#include <sys/types.h>
	2	#include <sys/stat.h>
	3	#include <unistd.h>
	4	#include <stdio.h>
	5	#include <fcntl.h>
	6	#include <stdlib.h>
8fc0abbc	7	#include <string.h>
d0ca268b	8
8fc0abbc JA	9	#include "blktrace.h"
8fc0abbc JA	10	#include "rbtree.h"
d0ca268b	11
fd92da24	12	#define MAX_CPUS (512)
d0ca268b JA	13
	14	struct per_file_info {
	15	int cpu;
	16	int nelems;
d0ca268b JA	17
d0ca268b JA	18	int fd;
87b72777	19	char fname[128];
d0ca268b	20
87b72777 JA	21	FILE *ofp;
87b72777 JA	22	char ofname[128];
8fc0abbc	23
d0ca268b	24	unsigned long long start_time;
5c017e4b JA	25
	26	unsigned long qreads, qwrites, creads, cwrites, mreads, mwrites;
	27	unsigned long long qread_kb, qwrite_kb, cread_kb, cwrite_kb;
d0ca268b JA	28	};
d0ca268b JA	29
8fc0abbc JA	30	static struct rb_root rb_root;
	31
	32	struct trace {
	33	struct blk_io_trace *bit;
66fa7233	34	unsigned int cpu;
8fc0abbc JA	35	struct rb_node rb_node;
	36	};
	37
87b72777 JA	38	static struct per_file_info per_file_info[MAX_CPUS];
87b72777 JA	39	static struct per_file_info *cur_file;
d0ca268b	40
87b72777 JA	41	static unsigned long long events;
	42
	43	static int max_cpus;
d0ca268b	44
5c017e4b JA	45	static inline void account_m(struct per_file_info *pfi, int rw,
5c017e4b JA	46	unsigned int bytes)
d0ca268b JA	47	{
d0ca268b JA	48	if (rw) {
5c017e4b JA	49	pfi->mwrites++;
5c017e4b JA	50	pfi->qwrite_kb += bytes >> 10;
d0ca268b	51	} else {
5c017e4b JA	52	pfi->mreads++;
5c017e4b JA	53	pfi->qread_kb += bytes >> 10;
d0ca268b JA	54	}
	55	}
	56
5c017e4b JA	57	static inline void account_q(struct per_file_info *pfi, int rw,
5c017e4b JA	58	unsigned int bytes)
d0ca268b JA	59	{
d0ca268b JA	60	if (rw) {
5c017e4b JA	61	pfi->qwrites++;
5c017e4b JA	62	pfi->qwrite_kb += bytes >> 10;
d0ca268b	63	} else {
5c017e4b JA	64	pfi->qreads++;
5c017e4b JA	65	pfi->qread_kb += bytes >> 10;
d0ca268b JA	66	}
	67	}
	68
5c017e4b JA	69	static inline void account_c(struct per_file_info *pfi, int rw,
5c017e4b JA	70	unsigned int bytes)
d0ca268b JA	71	{
d0ca268b JA	72	if (rw) {
5c017e4b JA	73	pfi->cwrites++;
5c017e4b JA	74	pfi->cwrite_kb += bytes >> 10;
d0ca268b	75	} else {
5c017e4b JA	76	pfi->creads++;
5c017e4b JA	77	pfi->cread_kb += bytes >> 10;
d0ca268b JA	78	}
	79	}
	80
3aabcd89	81	static void output(char *s)
d0ca268b JA	82	{
d0ca268b JA	83	printf("%s", s);
3aabcd89	84	fprintf(cur_file->ofp,"%s",s);
d0ca268b JA	85	}
d0ca268b JA	86
3aabcd89 JA	87	static char hstring[256];
3aabcd89 JA	88	static char tstring[256];
d0ca268b	89
3aabcd89	90	static inline char setup_header(struct blk_io_trace t, char act)
d0ca268b JA	91	{
	92	int w = t->action & BLK_TC_ACT(BLK_TC_WRITE);
	93	int b = t->action & BLK_TC_ACT(BLK_TC_BARRIER);
	94	int s = t->action & BLK_TC_ACT(BLK_TC_SYNC);
	95	char rwbs[4];
	96	int i = 0;
	97
	98	if (w)
	99	rwbs[i++] = 'W';
	100	else
	101	rwbs[i++] = 'R';
	102	if (b)
	103	rwbs[i++] = 'B';
	104	if (s)
	105	rwbs[i++] = 'S';
	106
	107	rwbs[i] = '\0';
	108
3aabcd89	109	sprintf(hstring, "%3d %15ld %12Lu %5u %c %3s", cur_file->cpu,
d0ca268b JA	110	(unsigned long)t->sequence, (unsigned long long)t->time, t->pid,
	111	act, rwbs);
	112
	113	return hstring;
	114	}
	115
3aabcd89	116	static void log_complete(struct blk_io_trace *t, char act)
d0ca268b JA	117	{
	118	sprintf(tstring,"%s %Lu + %u [%d]\n", setup_header(t, act),
	119	(unsigned long long)t->sector, t->bytes >> 9, t->error);
	120	output(tstring);
	121	}
	122
3aabcd89	123	static void log_queue(struct blk_io_trace *t, char act)
d0ca268b JA	124	{
	125	sprintf(tstring,"%s %Lu + %u\n", setup_header(t, act),
	126	(unsigned long long)t->sector, t->bytes >> 9);
	127	output(tstring);
	128	}
	129
3aabcd89	130	static void log_issue(struct blk_io_trace *t, char act)
d0ca268b JA	131	{
	132	sprintf(tstring,"%s %Lu + %u\n", setup_header(t, act),
	133	(unsigned long long)t->sector, t->bytes >> 9);
	134	output(tstring);
	135	}
	136
3aabcd89	137	static void log_merge(struct blk_io_trace *t, char act)
d0ca268b JA	138	{
	139	sprintf(tstring,"%s %Lu + %u\n", setup_header(t, act),
	140	(unsigned long long)t->sector, t->bytes >> 9);
	141	output(tstring);
	142	}
	143
3aabcd89	144	static void log_generic(struct blk_io_trace *t, char act)
d0ca268b JA	145	{
	146	sprintf(tstring,"%s %Lu + %u\n", setup_header(t, act),
	147	(unsigned long long)t->sector, t->bytes >> 9);
	148	output(tstring);
	149	}
	150
87b72777	151	static int log_pc(struct blk_io_trace *t, char act)
d0ca268b	152	{
87b72777 JA	153	unsigned char *buf;
87b72777 JA	154	int i;
d0ca268b	155
87b72777	156	sprintf(tstring,"%s ", setup_header(t, act));
d0ca268b JA	157	output(tstring);
d0ca268b JA	158
87b72777	159	buf = (unsigned char ) t + sizeof(t);
d0ca268b JA	160	for (i = 0; i < t->pdu_len; i++) {
	161	sprintf(tstring,"%02x ", buf[i]);
	162	output(tstring);
	163	}
	164
	165	if (act == 'C') {
	166	sprintf(tstring,"[%d]", t->error);
	167	output(tstring);
	168	}
	169
	170	printf("\n");
87b72777	171	return 0;
d0ca268b JA	172	}
d0ca268b JA	173
5c017e4b	174	static int dump_trace_pc(struct blk_io_trace t, struct per_file_info pfi)
d0ca268b	175	{
87b72777 JA	176	int ret = 0;
87b72777 JA	177
d0ca268b JA	178	switch (t->action & 0xffff) {
	179	case __BLK_TA_QUEUE:
	180	log_generic(t, 'Q');
	181	break;
	182	case __BLK_TA_GETRQ:
	183	log_generic(t, 'G');
	184	break;
	185	case __BLK_TA_SLEEPRQ:
	186	log_generic(t, 'S');
	187	break;
	188	case __BLK_TA_REQUEUE:
	189	log_generic(t, 'R');
	190	break;
	191	case __BLK_TA_ISSUE:
87b72777	192	ret = log_pc(t, 'D');
d0ca268b JA	193	break;
	194	case __BLK_TA_COMPLETE:
	195	log_pc(t, 'C');
	196	break;
	197	default:
	198	fprintf(stderr, "Bad pc action %x\n", t->action);
87b72777 JA	199	ret = 1;
87b72777 JA	200	break;
d0ca268b JA	201	}
d0ca268b JA	202
87b72777	203	return ret;
d0ca268b JA	204	}
d0ca268b JA	205
5c017e4b	206	static void dump_trace_fs(struct blk_io_trace t, struct per_file_info pfi)
d0ca268b JA	207	{
	208	int w = t->action & BLK_TC_ACT(BLK_TC_WRITE);
	209
	210	switch (t->action & 0xffff) {
	211	case __BLK_TA_QUEUE:
5c017e4b	212	account_q(pfi, w, t->bytes);
d0ca268b JA	213	log_queue(t, 'Q');
	214	break;
	215	case __BLK_TA_BACKMERGE:
5c017e4b	216	account_m(pfi, w, t->bytes);
d0ca268b JA	217	log_merge(t, 'M');
	218	break;
	219	case __BLK_TA_FRONTMERGE:
5c017e4b	220	account_m(pfi, w, t->bytes);
d0ca268b JA	221	log_merge(t, 'F');
	222	break;
	223	case __BLK_TA_GETRQ:
	224	log_generic(t, 'G');
	225	break;
	226	case __BLK_TA_SLEEPRQ:
	227	log_generic(t, 'S');
	228	break;
	229	case __BLK_TA_REQUEUE:
5c017e4b	230	account_c(pfi, w, -t->bytes);
d0ca268b JA	231	log_queue(t, 'R');
	232	break;
	233	case __BLK_TA_ISSUE:
	234	log_issue(t, 'D');
	235	break;
	236	case __BLK_TA_COMPLETE:
5c017e4b	237	account_c(pfi, w, t->bytes);
d0ca268b JA	238	log_complete(t, 'C');
	239	break;
	240	default:
	241	fprintf(stderr, "Bad fs action %x\n", t->action);
	242	return;
	243	}
d0ca268b JA	244	}
d0ca268b JA	245
5c017e4b	246	static int dump_trace(struct blk_io_trace t, struct per_file_info pfi)
d0ca268b	247	{
87b72777 JA	248	int ret = 0;
87b72777 JA	249
d0ca268b	250	if (t->action & BLK_TC_ACT(BLK_TC_PC))
5c017e4b	251	ret = dump_trace_pc(t, pfi);
d0ca268b	252	else
5c017e4b	253	dump_trace_fs(t, pfi);
87b72777 JA	254
	255	events++;
	256	return ret;
d0ca268b JA	257	}
d0ca268b JA	258
5c017e4b JA	259	static void dump_pfi_stats(struct per_file_info *pfi)
	260	{
	261	printf("\tReads:\n");
	262	printf("\t\tQueued: %'8lu, %'8LuKiB\n", pfi->qreads, pfi->qread_kb);
	263	printf("\t\tCompleted: %'8lu, %'8LuKiB\n", pfi->creads, pfi->cread_kb);
	264	printf("\t\tMerges: %'8lu\n", pfi->mreads);
	265
	266	printf("\tWrites:\n");
	267	printf("\t\tQueued: %'8lu, %'8LuKiB\n", pfi->qwrites,pfi->qwrite_kb);
	268	printf("\t\tCompleted: %'8lu, %'8LuKiB\n", pfi->cwrites,pfi->cwrite_kb);
	269	printf("\t\tMerges: %'8lu\n", pfi->mwrites);
	270	}
	271
	272	static void show_stats(int nfiles)
d0ca268b	273	{
5c017e4b JA	274	struct per_file_info foo, *pfi;
	275	int i;
	276
	277	memset(&foo, 0, sizeof(foo));
d0ca268b	278
5c017e4b JA	279	for (i = 0; i < nfiles; i++) {
	280	pfi = &per_file_info[i];
	281
	282	foo.qreads += pfi->qreads;
	283	foo.qwrites += pfi->qwrites;
	284	foo.creads += pfi->creads;
	285	foo.cwrites += pfi->cwrites;
	286	foo.mreads += pfi->mreads;
	287	foo.mwrites += pfi->mwrites;
	288	foo.qread_kb += pfi->qread_kb;
	289	foo.qwrite_kb += pfi->qwrite_kb;
	290	foo.cread_kb += pfi->cread_kb;
	291	foo.cwrite_kb += pfi->cwrite_kb;
	292
	293	printf("CPU%d:\n", i);
	294	dump_pfi_stats(pfi);
	295	}
	296
	297	if (nfiles > 1) {
	298	printf("Total:\n");
	299	dump_pfi_stats(&foo);
	300	}
d0ca268b JA	301
d0ca268b JA	302	printf("Events: %'Lu\n", events);
d0ca268b JA	303	}
d0ca268b JA	304
3aabcd89	305	static inline int trace_rb_insert(struct trace *t)
8fc0abbc JA	306	{
	307	struct rb_node **p = &rb_root.rb_node;
	308	struct rb_node *parent = NULL;
	309	struct trace *__t;
	310
	311	while (*p) {
	312	parent = *p;
	313	__t = rb_entry(parent, struct trace, rb_node);
	314
	315	if (t->bit->sequence < __t->bit->sequence)
	316	p = &(*p)->rb_left;
	317	else if (t->bit->sequence > __t->bit->sequence)
	318	p = &(*p)->rb_right;
	319	else {
87b72777	320	fprintf(stderr, "sequence alias!\n");
8fc0abbc JA	321	return 1;
	322	}
	323	}
	324
	325	rb_link_node(&t->rb_node, parent, p);
	326	rb_insert_color(&t->rb_node, &rb_root);
	327	return 0;
	328	}
	329
66fa7233	330	static int sort_entries(void *traces, unsigned long offset, int cpu)
8fc0abbc JA	331	{
	332	struct blk_io_trace *bit;
	333	struct trace *t;
	334	void *start = traces;
	335	int nelems = 0;
	336
6fe4709e	337	while (traces - start <= offset - sizeof(*bit)) {
8fc0abbc	338	bit = traces;
6fe4709e	339
8fc0abbc JA	340	t = malloc(sizeof(*t));
8fc0abbc JA	341	t->bit = bit;
66fa7233	342	t->cpu = cpu;
8fc0abbc JA	343	memset(&t->rb_node, 0, sizeof(t->rb_node));
8fc0abbc JA	344
6fe4709e JA	345	trace_to_cpu(bit);
6fe4709e JA	346
66fa7233 JA	347	if (verify_trace(bit))
	348	break;
	349
8fc0abbc JA	350	if (trace_rb_insert(t))
	351	return -1;
	352
	353	traces += sizeof(*bit) + bit->pdu_len;
	354	nelems++;
6fe4709e	355	}
8fc0abbc JA	356
	357	return nelems;
	358	}
	359
3aabcd89	360	static void show_entries(void)
8fc0abbc	361	{
8fc0abbc	362	struct blk_io_trace *bit;
3aabcd89	363	struct rb_node *n;
8fc0abbc JA	364	struct trace *t;
	365	int cpu;
	366
3aabcd89 JA	367	n = rb_first(&rb_root);
	368	if (!n)
	369	return;
8fc0abbc	370
3aabcd89	371	do {
8fc0abbc JA	372	t = rb_entry(n, struct trace, rb_node);
	373	bit = t->bit;
	374
66fa7233	375	cpu = t->cpu;
87b72777	376	if (cpu > max_cpus) {
8fc0abbc	377	fprintf(stderr, "CPU number too large (%d)\n", cpu);
87b72777	378	break;
8fc0abbc JA	379	}
8fc0abbc JA	380
3aabcd89	381	cur_file = &per_file_info[cpu];
8fc0abbc JA	382
	383	/*
	384	* offset time by first trace event.
	385	*
	386	* NOTE: This is cpu relative, thus you can not
	387	* compare times ACROSS cpus.
	388	*/
3aabcd89 JA	389	if (cur_file->start_time == 0)
3aabcd89 JA	390	cur_file->start_time = bit->time;
8fc0abbc	391
3aabcd89	392	bit->time -= cur_file->start_time;
8fc0abbc	393
5c017e4b	394	if (dump_trace(bit, cur_file))
87b72777 JA	395	break;
87b72777 JA	396
8fc0abbc JA	397	} while ((n = rb_next(n)) != NULL);
	398	}
	399
d0ca268b JA	400	int main(int argc, char *argv[])
d0ca268b JA	401	{
3aabcd89 JA	402	int i, nfiles, ret;
3aabcd89 JA	403	char *dev;
d0ca268b JA	404
d0ca268b JA	405	if (argc != 2) {
87b72777	406	fprintf(stderr, "Usage: %s <dev>\n", argv[0]);
d0ca268b JA	407	return 1;
	408	}
	409
	410	dev = argv[1];
	411
df0fae6d	412	memset(&rb_root, 0, sizeof(rb_root));
5c017e4b	413	memset(per_file_info, 0, sizeof(per_file_info));
df0fae6d	414
87b72777 JA	415	for (max_cpus = 0, i = 0, nfiles = 0; i < MAX_CPUS; i++) {
	416	struct per_file_info *pfi = &per_file_info[i];
	417	struct stat st;
	418	void *tb;
	419
d0ca268b JA	420	pfi->cpu = i;
	421	pfi->start_time = 0;
	422
87b72777 JA	423	snprintf(pfi->fname, sizeof(pfi->fname)-1,"%s_out.%d", dev, i);
87b72777 JA	424	if (stat(pfi->fname, &st) < 0)
d0ca268b	425	break;
d0ca268b	426
87b72777	427	snprintf(pfi->ofname, sizeof(pfi->ofname)-1, "%s_log.%d", dev, i);
d0ca268b JA	428	pfi->ofp = fopen(pfi->ofname, "w");
	429	if (pfi->ofp == NULL) {
	430	perror(pfi->ofname);
3aabcd89	431	break;
d0ca268b JA	432	}
d0ca268b JA	433
8fc0abbc JA	434	printf("Processing %s\n", pfi->fname);
8fc0abbc JA	435
87b72777	436	tb = malloc(st.st_size);
8fc0abbc JA	437
	438	pfi->fd = open(pfi->fname, O_RDONLY);
	439	if (pfi->fd < 0) {
d0ca268b	440	perror(pfi->fname);
3aabcd89	441	break;
d0ca268b	442	}
87b72777	443	if (read(pfi->fd, tb, st.st_size) != st.st_size) {
8fc0abbc	444	fprintf(stderr, "error reading\n");
3aabcd89	445	break;
fd92da24	446	}
d0ca268b	447
66fa7233	448	ret = sort_entries(tb, st.st_size, i);
8fc0abbc	449	if (ret == -1)
3aabcd89	450	break;
d0ca268b	451
8fc0abbc JA	452	close(pfi->fd);
8fc0abbc JA	453	nfiles++;
87b72777	454	max_cpus++;
8fc0abbc	455	pfi->nelems = ret;
8fc0abbc	456	printf("\t%2d %10s %15d\n", i, pfi->fname, pfi->nelems);
d0ca268b	457
d0ca268b JA	458	}
d0ca268b JA	459
3aabcd89 JA	460	if (nfiles) {
3aabcd89 JA	461	show_entries();
5c017e4b	462	show_stats(nfiles);
3aabcd89 JA	463	return 0;
3aabcd89 JA	464	}
8fc0abbc	465
3aabcd89 JA	466	fprintf(stderr, "No files found\n");
3aabcd89 JA	467	return 1;
d0ca268b	468	}