blkrawverify.c

   1 /*
   2  * block queue tracing application
   3  *
   4  * Copyright (C) 2006 Alan D. Brunelle <Alan.Brunelle@hp.com>
   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  *
  20  */
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <errno.h>
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <unistd.h>
  28
  29 #include "blktrace.h"
  30
  31 struct trace_info {
  32         int bit_field;
  33         char *string;
  34 };
  35
  36 int data_is_native = -1;
  37
  38 #define TRACE_TO_STRING(f)      {.bit_field = f, .string = #f}
  39 static struct trace_info traces[] = {
  40         TRACE_TO_STRING( BLK_TC_READ ),
  41         TRACE_TO_STRING( BLK_TC_WRITE ),
  42         TRACE_TO_STRING( BLK_TC_FLUSH ),
  43         TRACE_TO_STRING( BLK_TC_SYNC ),
  44         TRACE_TO_STRING( BLK_TC_QUEUE ),
  45         TRACE_TO_STRING( BLK_TC_REQUEUE ),
  46         TRACE_TO_STRING( BLK_TC_ISSUE ),
  47         TRACE_TO_STRING( BLK_TC_COMPLETE ),
  48         TRACE_TO_STRING( BLK_TC_FS ),
  49         TRACE_TO_STRING( BLK_TC_PC ),
  50         TRACE_TO_STRING( BLK_TC_AHEAD ),
  51         TRACE_TO_STRING( BLK_TC_META ),
  52         TRACE_TO_STRING( BLK_TC_DISCARD ),
  53         TRACE_TO_STRING( BLK_TC_FUA ),
  54 };
  55 #define N_TRACES (sizeof(traces) / sizeof(struct trace_info))
  56
  57 struct act_info {
  58         __u32 val;
  59         char *string;
  60 };
  61
  62 #define ACT_TO_STRING(f)        {.val = f, .string = #f}
  63 static struct act_info acts[] = {
  64         ACT_TO_STRING( __BLK_TA_QUEUE ),
  65         ACT_TO_STRING( __BLK_TA_QUEUE ),
  66         ACT_TO_STRING( __BLK_TA_BACKMERGE ),
  67         ACT_TO_STRING( __BLK_TA_FRONTMERGE ),
  68         ACT_TO_STRING( __BLK_TA_GETRQ ),
  69         ACT_TO_STRING( __BLK_TA_SLEEPRQ ),
  70         ACT_TO_STRING( __BLK_TA_REQUEUE ),
  71         ACT_TO_STRING( __BLK_TA_ISSUE ),
  72         ACT_TO_STRING( __BLK_TA_COMPLETE ),
  73         ACT_TO_STRING( __BLK_TA_PLUG ),
  74         ACT_TO_STRING( __BLK_TA_UNPLUG_IO ),
  75         ACT_TO_STRING( __BLK_TA_UNPLUG_TIMER ),
  76         ACT_TO_STRING( __BLK_TA_INSERT ),
  77         ACT_TO_STRING( __BLK_TA_SPLIT ),
  78         ACT_TO_STRING( __BLK_TA_BOUNCE ),
  79         ACT_TO_STRING( __BLK_TA_REMAP )
  80 };
  81 #define N_ACTS (sizeof(acts) / sizeof(struct act_info))
  82
  83 static char *act_to_str(__u32 action)
  84 {
  85         static char buf[1024];
  86         unsigned int i;
  87         unsigned int act = action & 0xffff;
  88         unsigned int trace = (action >> BLK_TC_SHIFT) & 0xffff;
  89
  90         if (act < N_ACTS) {
  91                 sprintf(buf, "%s ", acts[act].string);
  92                 for (i = 0; i < N_TRACES; i++)
  93                         if (trace & (1 << i)) {
  94                                 char buf2[1024];
  95                                 sprintf(buf2, "| %s ", traces[i].string);
  96                                 strcat(buf, buf2);
  97                         }
  98         }
  99         else
 100                 sprintf(buf, "Invalid action=%08x", action);
 101
 102         return buf;
 103 }
 104
 105 static void dump_trace(FILE *ofp, char *prefix, struct blk_io_trace *bit)
 106 {
 107         fprintf(ofp, "    Dump %s\n", prefix);
 108         fprintf(ofp, "        %8s: %08x\n", "magic", bit->magic);
 109         fprintf(ofp, "        %8s: %u\n", "sequence", bit->sequence);
 110         fprintf(ofp, "        %8s: %llu\n", "time", (unsigned long long) bit->time);
 111         fprintf(ofp, "        %8s: %llu\n", "sector", (unsigned long long) bit->sector);
 112         fprintf(ofp, "        %8s: %u\n", "bytes", bit->bytes);
 113         fprintf(ofp, "        %8s: %s\n", "action", act_to_str(bit->action));
 114         fprintf(ofp, "        %8s: %u\n", "bytes", bit->bytes);
 115         fprintf(ofp, "        %8s: %u\n", "cpu", bit->cpu);
 116         fprintf(ofp, "        %8s: %u\n", "error", bit->error);
 117         fprintf(ofp, "        %8s: %u\n", "pdu_len", bit->pdu_len);
 118         fprintf(ofp, "        %8s: (%u,%u)\n\n", "device", MAJOR(bit->device),
 119                                                            MINOR(bit->device));
 120 }
 121
 122 static int process(FILE **fp, char *devname, char *file, unsigned int cpu)
 123 {
 124 #       define SWAP_BITS() do {                                         \
 125                 if (bit_save) {                                         \
 126                         struct blk_io_trace *tmp = bit_save;            \
 127                         bit_save = bit;                                 \
 128                         bit = tmp;                                      \
 129                 }                                                       \
 130                 else {                                                  \
 131                         bit_save = bit;                                 \
 132                         bit = malloc(sizeof(struct blk_io_trace));      \
 133                 }                                                       \
 134         } while (0)
 135
 136 #       define INC_BAD(str) do {                                        \
 137                 nbad++;                                                 \
 138                 fprintf(ofp, "    ----------------\n");                 \
 139                 if (bit_save) dump_trace(ofp,"seq-1",bit_save);         \
 140                 dump_trace(ofp, str, bit);                              \
 141                 SWAP_BITS();                                            \
 142         } while (0)
 143
 144         size_t n;
 145         FILE *ifp, *ofp;
 146         __u32 save_device = 0, save_sequence = 0;
 147         __u64 save_time = 0;
 148         struct blk_io_trace *bit_save = NULL;
 149         struct blk_io_trace *bit = malloc(sizeof(struct blk_io_trace));
 150         unsigned int ngood = 0;
 151         unsigned int nbad = 0;
 152         unsigned int nbad_trace = 0, nbad_pdu = 0, nbad_cpu = 0;
 153         unsigned int nbad_seq = 0, nbad_dev = 0, nbad_time = 0;
 154         char ofname[1024];
 155
 156         ifp = fopen(file, "r");
 157         if (!ifp)
 158                 return 0;
 159
 160         sprintf(ofname, "%s.verify.out", devname);
 161
 162         if (!*fp) {
 163                 *fp = fopen(ofname, "w");
 164                 if (*fp == NULL) {
 165                         fprintf(stderr,"Failed to open %s (%s), skipping\n",
 166                                 ofname, strerror(errno));
 167                         fclose(ifp);
 168                         return 0;
 169                 }
 170                 fprintf(*fp, "\n---------------\n" );
 171                 fprintf(*fp, "Verifying %s\n", devname);
 172         }
 173
 174         ofp = *fp;
 175         while ((n = fread(bit, sizeof(struct blk_io_trace), 1, ifp)) == 1) {
 176                 if (ferror(ifp)) {
 177                         clearerr(ifp);
 178                         perror("fread");
 179                         break;
 180                 }
 181                 if (data_is_native == -1)
 182                         check_data_endianness(bit->magic);
 183
 184                 trace_to_cpu(bit);
 185
 186                 if (!CHECK_MAGIC(bit)) {
 187                         INC_BAD("bad trace");
 188                         continue;
 189                 }
 190
 191                 if ((bit->magic & 0xff) != SUPPORTED_VERSION) {
 192                         fprintf(stderr, "unsupported trace version\n");
 193                         break;
 194                 }
 195
 196                 if (bit->pdu_len) {
 197                         char *pdu_buf;
 198
 199                         pdu_buf = malloc(bit->pdu_len);
 200                         n = fread(pdu_buf, bit->pdu_len, 1, ifp);
 201                         if (n == 0) {
 202                                 INC_BAD("bad pdu");
 203                                 nbad_seq++;
 204                                 free(pdu_buf);
 205                                 break;
 206                         }
 207                         free(pdu_buf);
 208                 }
 209
 210                 if (bit->cpu != cpu) {
 211                         INC_BAD("bad cpu");
 212                         nbad_cpu++;
 213                         continue;
 214                 }
 215
 216                 /*
 217                  * skip notify traces, they don't have valid sequences
 218                  */
 219                 if (bit->action & BLK_TC_ACT(BLK_TC_NOTIFY))
 220                         continue;
 221
 222                 if (ngood) {
 223                         if (bit->sequence <= save_sequence) {
 224                                 INC_BAD("bad seq");
 225                                 nbad_seq++;
 226                                 continue;
 227                         }
 228                         else if (bit->time <= save_time) {
 229                                 INC_BAD("time regression");
 230                                 nbad_time++;
 231                                 continue;
 232                         }
 233                         else if (bit->device != save_device) {
 234                                 INC_BAD("bad dev");
 235                                 nbad_dev++;
 236                                 continue;
 237                         }
 238                 }
 239
 240                 save_sequence = bit->sequence;
 241                 save_time = bit->time;
 242                 save_device = bit->device;
 243
 244                 ngood++;
 245                 SWAP_BITS();
 246         }
 247
 248         if (n == 0 && !feof(ifp))
 249                 fprintf(stderr,"%s: fread failed %d/%s\n",
 250                         file, errno, strerror(errno));
 251         fclose(ifp);
 252
 253         fprintf(ofp, "    ---------------------\n");
 254         fprintf(ofp, "    Summary for cpu %d:\n", cpu);
 255         fprintf(ofp, "    %10d valid + %10d invalid (%5.1f%%) processed\n\n",
 256                 ngood, nbad,
 257                 ngood ? 100.0 * (float)ngood / (float)(ngood + nbad) : 0.0);
 258
 259         if (nbad) {
 260                 if (nbad_trace)
 261                         fprintf(ofp, "%8s %d traces\n", "", nbad_trace);
 262                 if (nbad_trace)
 263                         fprintf(ofp, "%8s %d pdu\n", "", nbad_pdu);
 264                 if (nbad_cpu)
 265                         fprintf(ofp, "%8s %d cpu\n", "", nbad_cpu);
 266                 if (nbad_seq)
 267                         fprintf(ofp, "%8s %d seq\n", "", nbad_seq);
 268                 if (nbad_dev)
 269                         fprintf(ofp, "%8s %d dev\n", "", nbad_dev);
 270                 if (nbad_time)
 271                         fprintf(ofp, "%8s %d time\n", "", nbad_time);
 272                 fprintf(ofp,"\n");
 273         }
 274
 275         return nbad;
 276 }
 277
 278 int main(int argc, char *argv[])
 279 {
 280         char *devname;
 281         struct stat st;
 282         int i, cpu, nbad, rval = 0;
 283         FILE *ofp;
 284         char *ofname = malloc(1024);
 285         char *fname = malloc(1024);
 286
 287         if (argc < 2) {
 288                 fprintf(stderr,"FATAL: Need device name(s)\n");
 289                 fprintf(stderr,"Usage: blkrawverify <dev> [<dev>...]\n");
 290                 exit(1);
 291         }
 292
 293         for (i = 1; i < argc; i++) {
 294                 devname = argv[i];
 295                 sprintf(ofname, "%s.verify.out", devname);
 296                 ofp = NULL;
 297
 298                 printf("Verifying %s\n", devname); fflush(stdout);
 299                 for (cpu = 0; ; cpu++) {
 300                         sprintf(fname, "%s.blktrace.%d", devname, cpu);
 301                         if (stat(fname, &st) < 0) {
 302                                 if (cpu == 0) {
 303                                         fprintf(stderr, "No tracefiles found for %s\n",
 304                                                 devname);
 305                                         rval = 1;
 306                                 }
 307                                 break;
 308                         }
 309                         printf("    CPU %d ", cpu); fflush(stdout);
 310                         nbad = process(&ofp, devname, fname, cpu);
 311                         if (nbad) {
 312                                 printf("-- %d bad", nbad);
 313                                 rval = 1;
 314                         }
 315                         printf("\n");
 316                 }
 317                 if (ofp) {
 318                         fclose(ofp);
 319                         fprintf(stdout, "Wrote output to %s\n", ofname);
 320                 }
 321         }
 322
 323         return rval;
 324 }