blktrace: Initial checkin of ported version

Signed-off-by: San Mehat <san@google.com>
diff --git a/blkrawverify.c b/blkrawverify.c
new file mode 100644
index 0000000..e669179
--- /dev/null
+++ b/blkrawverify.c
@@ -0,0 +1,322 @@
+/*
+ * block queue tracing application
+ *
+ * Copyright (C) 2006 Alan D. Brunelle <Alan.Brunelle@hp.com>
+ *
+ *  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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include "blktrace.h"
+
+struct trace_info {
+	int bit_field;
+	char *string;
+};
+
+int data_is_native = -1;
+
+#define TRACE_TO_STRING(f)	{.bit_field = f, .string = #f}
+static struct trace_info traces[] = {
+	TRACE_TO_STRING( BLK_TC_READ ),
+	TRACE_TO_STRING( BLK_TC_WRITE ),
+	TRACE_TO_STRING( BLK_TC_BARRIER ),
+	TRACE_TO_STRING( BLK_TC_SYNC ),
+	TRACE_TO_STRING( BLK_TC_QUEUE ),
+	TRACE_TO_STRING( BLK_TC_REQUEUE ),
+	TRACE_TO_STRING( BLK_TC_ISSUE ),
+	TRACE_TO_STRING( BLK_TC_COMPLETE ),
+	TRACE_TO_STRING( BLK_TC_FS ),
+	TRACE_TO_STRING( BLK_TC_PC ),
+	TRACE_TO_STRING( BLK_TC_AHEAD ),
+	TRACE_TO_STRING( BLK_TC_META ),
+	TRACE_TO_STRING( BLK_TC_DISCARD ),
+};
+#define N_TRACES (sizeof(traces) / sizeof(struct trace_info))
+
+struct act_info {
+	__u32 val;
+	char *string;
+};
+
+#define ACT_TO_STRING(f)	{.val = f, .string = #f}
+static struct act_info acts[] = {
+	ACT_TO_STRING( __BLK_TA_QUEUE ),
+	ACT_TO_STRING( __BLK_TA_QUEUE ),
+	ACT_TO_STRING( __BLK_TA_BACKMERGE ),
+	ACT_TO_STRING( __BLK_TA_FRONTMERGE ),
+	ACT_TO_STRING( __BLK_TA_GETRQ ),
+	ACT_TO_STRING( __BLK_TA_SLEEPRQ ),
+	ACT_TO_STRING( __BLK_TA_REQUEUE ),
+	ACT_TO_STRING( __BLK_TA_ISSUE ),
+	ACT_TO_STRING( __BLK_TA_COMPLETE ),
+	ACT_TO_STRING( __BLK_TA_PLUG ),
+	ACT_TO_STRING( __BLK_TA_UNPLUG_IO ),
+	ACT_TO_STRING( __BLK_TA_UNPLUG_TIMER ),
+	ACT_TO_STRING( __BLK_TA_INSERT ),
+	ACT_TO_STRING( __BLK_TA_SPLIT ),
+	ACT_TO_STRING( __BLK_TA_BOUNCE ),
+	ACT_TO_STRING( __BLK_TA_REMAP )
+};
+#define N_ACTS (sizeof(acts) / sizeof(struct act_info))
+
+static char *act_to_str(__u32 action)
+{
+	static char buf[1024];
+	unsigned int i;
+	unsigned int act = action & 0xffff;
+	unsigned int trace = (action >> BLK_TC_SHIFT) & 0xffff;
+
+	if (act <= N_ACTS) {
+		sprintf(buf, "%s ", acts[act].string);
+		for (i = 0; i < N_TRACES; i++)
+			if (trace & (1 << i)) {
+				char buf2[1024];
+				sprintf(buf2, "| %s ", traces[i].string);
+				strcat(buf, buf2);
+			}
+	}
+	else
+		sprintf(buf, "Invalid action=%08x", action);
+
+	return buf;
+}
+
+static void dump_trace(FILE *ofp, char *prefix, struct blk_io_trace *bit)
+{
+	fprintf(ofp, "    Dump %s\n", prefix);
+	fprintf(ofp, "        %8s: %08x\n", "magic", bit->magic);
+	fprintf(ofp, "        %8s: %u\n", "sequence", bit->sequence);
+	fprintf(ofp, "        %8s: %llu\n", "time", (unsigned long long) bit->time);
+	fprintf(ofp, "        %8s: %llu\n", "sector", (unsigned long long) bit->sector);
+	fprintf(ofp, "        %8s: %u\n", "bytes", bit->bytes);
+	fprintf(ofp, "        %8s: %s\n", "action", act_to_str(bit->action));
+	fprintf(ofp, "        %8s: %u\n", "bytes", bit->bytes);
+	fprintf(ofp, "        %8s: %u\n", "cpu", bit->cpu);
+	fprintf(ofp, "        %8s: %u\n", "error", bit->error);
+	fprintf(ofp, "        %8s: %u\n", "pdu_len", bit->pdu_len);
+	fprintf(ofp, "        %8s: (%u,%u)\n\n", "device", MAJOR(bit->device),
+						           MINOR(bit->device));
+}
+
+static int process(FILE **fp, char *devname, char *file, unsigned int cpu)
+{
+#	define SWAP_BITS() do {						\
+		if (bit_save) {						\
+			struct blk_io_trace *tmp = bit_save;		\
+			bit_save = bit;					\
+			bit = tmp;					\
+		}							\
+		else {							\
+			bit_save = bit;					\
+			bit = malloc(sizeof(struct blk_io_trace));	\
+		}							\
+	} while (0)
+
+#	define INC_BAD(str) do {					\
+		nbad++;							\
+		fprintf(ofp, "    ----------------\n");			\
+		if (bit_save) dump_trace(ofp,"seq-1",bit_save);		\
+		dump_trace(ofp, str, bit);				\
+		SWAP_BITS();						\
+	} while (0)
+
+	size_t n;
+	FILE *ifp, *ofp;
+	__u32 save_device = 0, save_sequence = 0;
+	__u64 save_time = 0;
+	struct blk_io_trace *bit_save = NULL;
+	struct blk_io_trace *bit = malloc(sizeof(struct blk_io_trace));
+	unsigned int ngood = 0;
+	unsigned int nbad = 0;
+	unsigned int nbad_trace = 0, nbad_pdu = 0, nbad_cpu = 0;
+	unsigned int nbad_seq = 0, nbad_dev = 0, nbad_time = 0;
+	char ofname[1024];
+
+	ifp = fopen(file, "r");
+	if (!ifp)
+		return 0;
+
+	sprintf(ofname, "%s.verify.out", devname);
+
+	if (!*fp) {
+		*fp = fopen(ofname, "w");
+		if (*fp == NULL) {
+			fprintf(stderr,"Failed to open %s (%s), skipping\n",
+				ofname, strerror(errno));
+			fclose(ifp);
+			return 0;
+		}
+		fprintf(*fp, "\n---------------\n" );
+		fprintf(*fp, "Verifying %s\n", devname);
+	}
+
+	ofp = *fp;
+	while ((n = fread(bit, sizeof(struct blk_io_trace), 1, ifp)) == 1) {
+		if (ferror(ifp)) {
+			clearerr(ifp);
+			perror("fread");
+			break;
+		}
+		if (data_is_native == -1)
+			check_data_endianness(bit->magic);
+
+		trace_to_cpu(bit);
+
+		if (!CHECK_MAGIC(bit)) {
+			INC_BAD("bad trace");
+			continue;
+		}
+
+		if ((bit->magic & 0xff) != SUPPORTED_VERSION) {
+			fprintf(stderr, "unsupported trace version\n");
+			break;
+		}
+
+		if (bit->pdu_len) {
+			char *pdu_buf;
+
+			pdu_buf = malloc(bit->pdu_len);
+			n = fread(pdu_buf, bit->pdu_len, 1, ifp);
+			if (n == 0) {
+				INC_BAD("bad pdu");
+				nbad_seq++;
+				break;
+			}
+			free(pdu_buf);
+		}
+
+		if (bit->cpu != cpu) {
+			INC_BAD("bad cpu");
+			nbad_cpu++;
+			continue;
+		}
+
+		/*
+		 * skip notify traces, they don't have valid sequences
+		 */
+		if (bit->action & BLK_TC_ACT(BLK_TC_NOTIFY))
+			continue;
+
+		if (ngood) {
+			if (bit->sequence <= save_sequence) {
+				INC_BAD("bad seq");
+				nbad_seq++;
+				continue;
+			}
+			else if (bit->time <= save_time) {
+				INC_BAD("time regression");
+				nbad_time++;
+				continue;
+			}
+			else if (bit->device != save_device) {
+				INC_BAD("bad dev");
+				nbad_dev++;
+				continue;
+			}
+		}
+
+		save_sequence = bit->sequence;
+		save_time = bit->time;
+		save_device = bit->device;
+
+		ngood++;
+		SWAP_BITS();
+	}
+
+	if (n == 0 && !feof(ifp))
+		fprintf(stderr,"%s: fread failed %d/%s\n",
+		        file, errno, strerror(errno));
+	fclose(ifp);
+
+	fprintf(ofp, "    ---------------------\n");
+	fprintf(ofp, "    Summary for cpu %d:\n", cpu);
+	fprintf(ofp, "    %10d valid + %10d invalid (%5.1f%%) processed\n\n",
+		ngood, nbad,
+		ngood ? 100.0 * (float)ngood / (float)(ngood + nbad) : 0.0);
+
+	if (nbad) {
+		if (nbad_trace)
+			fprintf(ofp, "%8s %d traces\n", "", nbad_trace);
+		if (nbad_trace)
+			fprintf(ofp, "%8s %d pdu\n", "", nbad_pdu);
+		if (nbad_cpu)
+			fprintf(ofp, "%8s %d cpu\n", "", nbad_cpu);
+		if (nbad_seq)
+			fprintf(ofp, "%8s %d seq\n", "", nbad_seq);
+		if (nbad_dev)
+			fprintf(ofp, "%8s %d dev\n", "", nbad_dev);
+		if (nbad_time)
+			fprintf(ofp, "%8s %d time\n", "", nbad_time);
+		fprintf(ofp,"\n");
+	}
+
+	return nbad;
+}
+
+int main(int argc, char *argv[])
+{
+	char *devname;
+	struct stat st;
+	int i, cpu, nbad, rval = 0;
+	FILE *ofp;
+	char *ofname = malloc(1024);
+	char *fname = malloc(1024);
+
+	if (argc < 2) {
+		fprintf(stderr,"FATAL: Need device name(s)\n");
+		fprintf(stderr,"Usage: blkrawverify <dev> [<dev>...]\n");
+		exit(1);
+	}
+
+	for (i = 1; i < argc; i++) {
+		devname = argv[i];
+		sprintf(ofname, "%s.verify.out", devname);
+		ofp = NULL;
+
+		printf("Verifying %s\n", devname); fflush(stdout);
+		for (cpu = 0; ; cpu++) {
+			sprintf(fname, "%s.blktrace.%d", devname, cpu);
+			if (stat(fname, &st) < 0) {
+				if (cpu == 0) {
+					fprintf(stderr, "No tracefiles found for %s\n",
+						devname);
+					rval = 1;
+				}
+				break;
+			}
+			printf("    CPU %d ", cpu); fflush(stdout);
+			nbad = process(&ofp, devname, fname, cpu);
+			if (nbad) {
+				printf("-- %d bad", nbad);
+				rval = 1;
+			}
+			printf("\n");
+		}
+		if (ofp) {
+			fclose(ofp);
+			fprintf(stdout, "Wrote output to %s\n", ofname);
+		}
+	}
+
+	return rval;
+}