t/btrace2fio.c

   1 #include <stdio.h>
   2 #include <stdio.h>
   3 #include <unistd.h>
   4 #include <inttypes.h>
   5 #include <assert.h>
   6
   7 #include "../io_ddir.h"
   8 #include "../flist.h"
   9 #include "../hash.h"
  10 #include "../fifo.h"
  11 #include "../blktrace_api.h"
  12 #include "../os/os.h"
  13 #include "../log.h"
  14 #include "../lib/linux-dev-lookup.h"
  15
  16 #define TRACE_FIFO_SIZE 8192
  17
  18 static unsigned int rt_threshold = 1000000;
  19 static unsigned int ios_threshold = 10;
  20 static unsigned int rate_threshold;
  21 static unsigned int set_rate;
  22 static unsigned int max_depth = 256;
  23 static int output_ascii = 1;
  24 static char *filename;
  25
  26 struct bs {
  27         unsigned int bs;
  28         unsigned int nr;
  29         int merges;
  30 };
  31
  32 struct trace_file {
  33         char *name;
  34         int major, minor;
  35 };
  36
  37 struct btrace_out {
  38         unsigned long ios[DDIR_RWDIR_CNT];
  39         unsigned long merges[DDIR_RWDIR_CNT];
  40
  41         uint64_t last_end[DDIR_RWDIR_CNT];
  42         uint64_t seq[DDIR_RWDIR_CNT];
  43
  44         struct bs *bs[DDIR_RWDIR_CNT];
  45         unsigned int nr_bs[DDIR_RWDIR_CNT];
  46
  47         int inflight;
  48         unsigned int depth;
  49         int depth_disabled;
  50         int complete_seen;
  51
  52         uint64_t first_ttime[DDIR_RWDIR_CNT];
  53         uint64_t last_ttime[DDIR_RWDIR_CNT];
  54         uint64_t kb[DDIR_RWDIR_CNT];
  55
  56         uint64_t start_delay;
  57 };
  58
  59 struct btrace_pid {
  60         struct flist_head hash_list;
  61         struct flist_head pid_list;
  62         pid_t pid;
  63
  64         struct trace_file *files;
  65         int nr_files;
  66         unsigned int last_major, last_minor;
  67
  68         struct btrace_out o;
  69 };
  70
  71 struct inflight {
  72         struct flist_head list;
  73         struct btrace_pid *p;
  74         uint64_t end_sector;
  75 };
  76
  77 #define PID_HASH_BITS   10
  78 #define PID_HASH_SIZE   (1U << PID_HASH_BITS)
  79
  80 static struct flist_head pid_hash[PID_HASH_SIZE];
  81 static FLIST_HEAD(pid_list);
  82
  83 #define INFLIGHT_HASH_BITS      8
  84 #define INFLIGHT_HASH_SIZE      (1U << INFLIGHT_HASH_BITS)
  85 static struct flist_head inflight_hash[INFLIGHT_HASH_SIZE];
  86
  87 static uint64_t first_ttime = -1ULL;
  88
  89 static struct inflight *inflight_find(uint64_t sector)
  90 {
  91         struct flist_head *inflight_list;
  92         struct flist_head *e;
  93
  94         inflight_list = &inflight_hash[hash_long(sector, INFLIGHT_HASH_BITS)];
  95
  96         flist_for_each(e, inflight_list) {
  97                 struct inflight *i = flist_entry(e, struct inflight, list);
  98
  99                 if (i->end_sector == sector)
 100                         return i;
 101         }
 102
 103         return NULL;
 104 }
 105
 106 static void inflight_remove(struct inflight *i)
 107 {
 108         struct btrace_out *o = &i->p->o;
 109
 110         o->inflight--;
 111         assert(o->inflight >= 0);
 112         flist_del(&i->list);
 113         free(i);
 114 }
 115
 116 static void __inflight_add(struct inflight *i)
 117 {
 118         struct flist_head *list;
 119
 120         list = &inflight_hash[hash_long(i->end_sector, INFLIGHT_HASH_BITS)];
 121         flist_add_tail(&i->list, list);
 122 }
 123
 124 static void inflight_add(struct btrace_pid *p, uint64_t sector, uint32_t len)
 125 {
 126         struct btrace_out *o = &p->o;
 127         struct inflight *i;
 128
 129         i = calloc(1, sizeof(*i));
 130         i->p = p;
 131         o->inflight++;
 132         if (!o->depth_disabled) {
 133                 o->depth = max((int) o->depth, o->inflight);
 134                 if (o->depth >= max_depth && !o->complete_seen) {
 135                         o->depth_disabled = 1;
 136                         o->depth = max_depth;
 137                 }
 138         }
 139         i->end_sector = sector + (len >> 9);
 140         __inflight_add(i);
 141 }
 142
 143 static void inflight_merge(struct inflight *i, int rw, unsigned int size)
 144 {
 145         i->p->o.merges[rw]++;
 146         if (size) {
 147                 i->end_sector += (size >> 9);
 148                 flist_del(&i->list);
 149                 __inflight_add(i);
 150         }
 151 }
 152
 153 /*
 154  * fifo refill frontend, to avoid reading data in trace sized bites
 155  */
 156 static int refill_fifo(struct fifo *fifo, int fd)
 157 {
 158         char buf[TRACE_FIFO_SIZE];
 159         unsigned int total;
 160         int ret;
 161
 162         total = sizeof(buf);
 163         if (total > fifo_room(fifo))
 164                 total = fifo_room(fifo);
 165
 166         ret = read(fd, buf, total);
 167         if (ret < 0) {
 168                 perror("read refill");
 169                 return -1;
 170         }
 171
 172         if (ret > 0)
 173                 ret = fifo_put(fifo, buf, ret);
 174
 175         return ret;
 176 }
 177
 178 /*
 179  * Retrieve 'len' bytes from the fifo, refilling if necessary.
 180  */
 181 static int trace_fifo_get(struct fifo *fifo, int fd, void *buf,
 182                           unsigned int len)
 183 {
 184         if (fifo_len(fifo) < len) {
 185                 int ret = refill_fifo(fifo, fd);
 186
 187                 if (ret < 0)
 188                         return ret;
 189         }
 190
 191         return fifo_get(fifo, buf, len);
 192 }
 193
 194 /*
 195  * Just discard the pdu by seeking past it.
 196  */
 197 static int discard_pdu(struct fifo *fifo, int fd, struct blk_io_trace *t)
 198 {
 199         if (t->pdu_len == 0)
 200                 return 0;
 201
 202         return trace_fifo_get(fifo, fd, NULL, t->pdu_len);
 203 }
 204
 205 static int handle_trace_notify(struct blk_io_trace *t)
 206 {
 207         switch (t->action) {
 208         case BLK_TN_PROCESS:
 209                 //printf("got process notify: %x, %d\n", t->action, t->pid);
 210                 break;
 211         case BLK_TN_TIMESTAMP:
 212                 //printf("got timestamp notify: %x, %d\n", t->action, t->pid);
 213                 break;
 214         case BLK_TN_MESSAGE:
 215                 break;
 216         default:
 217                 log_err("unknown trace act %x\n", t->action);
 218                 return 1;
 219         }
 220
 221         return 0;
 222 }
 223
 224 static void __add_bs(struct btrace_out *o, unsigned int len, int rw)
 225 {
 226         o->bs[rw] = realloc(o->bs[rw], (o->nr_bs[rw] + 1) * sizeof(struct bs));
 227         o->bs[rw][o->nr_bs[rw]].bs = len;
 228         o->bs[rw][o->nr_bs[rw]].nr = 1;
 229         o->nr_bs[rw]++;
 230 }
 231
 232 static void add_bs(struct btrace_out *o, unsigned int len, int rw)
 233 {
 234         struct bs *bs = o->bs[rw];
 235         int i;
 236
 237         if (!o->nr_bs[rw]) {
 238                 __add_bs(o, len, rw);
 239                 return;
 240         }
 241
 242         for (i = 0; i < o->nr_bs[rw]; i++) {
 243                 if (bs[i].bs == len) {
 244                         bs[i].nr++;
 245                         return;
 246                 }
 247         }
 248
 249         __add_bs(o, len, rw);
 250 }
 251
 252 #define FMINORBITS      20
 253 #define FMINORMASK      ((1U << FMINORBITS) - 1)
 254 #define FMAJOR(dev)     ((unsigned int) ((dev) >> FMINORBITS))
 255 #define FMINOR(dev)     ((unsigned int) ((dev) & FMINORMASK))
 256
 257 static int btrace_add_file(struct btrace_pid *p, uint32_t devno)
 258 {
 259         unsigned int maj = FMAJOR(devno);
 260         unsigned int min = FMINOR(devno);
 261         struct trace_file *f;
 262         unsigned int i;
 263         char dev[256];
 264
 265         if (filename)
 266                 return 0;
 267         if (p->last_major == maj && p->last_minor == min)
 268                 return 0;
 269
 270         p->last_major = maj;
 271         p->last_minor = min;
 272
 273         /*
 274          * check for this file in our list
 275          */
 276         for (i = 0; i < p->nr_files; i++) {
 277                 f = &p->files[i];
 278
 279                 if (f->major == maj && f->minor == min)
 280                         return 0;
 281         }
 282
 283         strcpy(dev, "/dev");
 284         if (!blktrace_lookup_device(NULL, dev, maj, min)) {
 285                 log_err("fio: failed to find device %u/%u\n", maj, min);
 286                 if (!output_ascii) {
 287                         log_err("fio: use -d to specify device\n");
 288                         return 1;
 289                 }
 290                 return 0;
 291         }
 292
 293         p->files = realloc(p->files, (p->nr_files + 1) * sizeof(*f));
 294         f = &p->files[p->nr_files];
 295         f->name = strdup(dev);
 296         f->major = maj;
 297         f->minor = min;
 298         p->nr_files++;
 299         return 0;
 300 }
 301
 302 static int t_to_rwdir(struct blk_io_trace *t)
 303 {
 304         if (t->action & BLK_TC_ACT(BLK_TC_DISCARD))
 305                 return DDIR_TRIM;
 306
 307         return (t->action & BLK_TC_ACT(BLK_TC_WRITE)) != 0;
 308 }
 309
 310 static int handle_trace_discard(struct blk_io_trace *t, struct btrace_pid *p)
 311 {
 312         struct btrace_out *o = &p->o;
 313
 314         if (btrace_add_file(p, t->device))
 315                 return 1;
 316
 317         if (o->first_ttime[2] == -1ULL)
 318                 o->first_ttime[2] = t->time;
 319
 320         o->ios[DDIR_TRIM]++;
 321         add_bs(o, t->bytes, DDIR_TRIM);
 322         return 0;
 323 }
 324
 325 static int handle_trace_fs(struct blk_io_trace *t, struct btrace_pid *p)
 326 {
 327         struct btrace_out *o = &p->o;
 328         int rw;
 329
 330         if (btrace_add_file(p, t->device))
 331                 return 1;
 332
 333         first_ttime = min(first_ttime, (uint64_t) t->time);
 334
 335         rw = (t->action & BLK_TC_ACT(BLK_TC_WRITE)) != 0;
 336
 337         if (o->first_ttime[rw] == -1ULL)
 338                 o->first_ttime[rw] = t->time;
 339
 340         add_bs(o, t->bytes, rw);
 341         o->ios[rw]++;
 342
 343         if (t->sector == o->last_end[rw] || o->last_end[rw] == -1ULL)
 344                 o->seq[rw]++;
 345
 346         o->last_end[rw] = t->sector + (t->bytes >> 9);
 347         return 0;
 348 }
 349
 350 static int handle_queue_trace(struct blk_io_trace *t, struct btrace_pid *p)
 351 {
 352         if (t->action & BLK_TC_ACT(BLK_TC_NOTIFY))
 353                 return handle_trace_notify(t);
 354         else if (t->action & BLK_TC_ACT(BLK_TC_DISCARD))
 355                 return handle_trace_discard(t, p);
 356         else
 357                 return handle_trace_fs(t, p);
 358 }
 359
 360 static int handle_trace(struct blk_io_trace *t, struct btrace_pid *p)
 361 {
 362         unsigned int act = t->action & 0xffff;
 363         int ret = 0;
 364
 365         if (act == __BLK_TA_QUEUE) {
 366                 inflight_add(p, t->sector, t->bytes);
 367                 ret = handle_queue_trace(t, p);
 368         } else if (act == __BLK_TA_BACKMERGE) {
 369                 struct inflight *i;
 370
 371                 i = inflight_find(t->sector + (t->bytes >> 9));
 372                 if (i)
 373                         inflight_remove(i);
 374
 375                 i = inflight_find(t->sector);
 376                 if (i)
 377                         inflight_merge(i, t_to_rwdir(t), t->bytes);
 378         } else if (act == __BLK_TA_FRONTMERGE) {
 379                 struct inflight *i;
 380
 381                 i = inflight_find(t->sector + (t->bytes >> 9));
 382                 if (i)
 383                         inflight_remove(i);
 384
 385                 i = inflight_find(t->sector);
 386                 if (i)
 387                         inflight_merge(i, t_to_rwdir(t), 0);
 388         } else if (act == __BLK_TA_COMPLETE) {
 389                 struct inflight *i;
 390
 391                 i = inflight_find(t->sector + (t->bytes >> 9));
 392                 if (i) {
 393                         i->p->o.kb[t_to_rwdir(t)] += (t->bytes >> 10);
 394                         i->p->o.complete_seen = 1;
 395                         inflight_remove(i);
 396                 }
 397         }
 398
 399         return ret;
 400 }
 401
 402 static void byteswap_trace(struct blk_io_trace *t)
 403 {
 404         t->magic = fio_swap32(t->magic);
 405         t->sequence = fio_swap32(t->sequence);
 406         t->time = fio_swap64(t->time);
 407         t->sector = fio_swap64(t->sector);
 408         t->bytes = fio_swap32(t->bytes);
 409         t->action = fio_swap32(t->action);
 410         t->pid = fio_swap32(t->pid);
 411         t->device = fio_swap32(t->device);
 412         t->cpu = fio_swap32(t->cpu);
 413         t->error = fio_swap16(t->error);
 414         t->pdu_len = fio_swap16(t->pdu_len);
 415 }
 416
 417 static struct btrace_pid *pid_hash_find(pid_t pid, struct flist_head *list)
 418 {
 419         struct flist_head *e;
 420         struct btrace_pid *p;
 421
 422         flist_for_each(e, list) {
 423                 p = flist_entry(e, struct btrace_pid, hash_list);
 424                 if (p->pid == pid)
 425                         return p;
 426         }
 427
 428         return NULL;
 429 }
 430
 431 static struct btrace_pid *pid_hash_get(pid_t pid)
 432 {
 433         struct flist_head *hash_list;
 434         struct btrace_pid *p;
 435
 436         hash_list = &pid_hash[hash_long(pid, PID_HASH_BITS)];
 437
 438         p = pid_hash_find(pid, hash_list);
 439         if (!p) {
 440                 int i;
 441
 442                 p = calloc(1, sizeof(*p));
 443
 444                 for (i = 0; i < DDIR_RWDIR_CNT; i++) {
 445                         p->o.first_ttime[i] = -1ULL;
 446                         p->o.last_ttime[i] = -1ULL;
 447                         p->o.last_end[i] = -1ULL;
 448                 }
 449
 450                 p->pid = pid;
 451                 flist_add_tail(&p->hash_list, hash_list);
 452                 flist_add_tail(&p->pid_list, &pid_list);
 453         }
 454
 455         return p;
 456 }
 457
 458 /*
 459  * Load a blktrace file by reading all the blk_io_trace entries, and storing
 460  * them as io_pieces like the fio text version would do.
 461  */
 462 static int load_blktrace(const char *fname, int need_swap)
 463 {
 464         struct btrace_pid *p;
 465         unsigned long traces;
 466         struct blk_io_trace t;
 467         struct fifo *fifo;
 468         int fd, ret = 0;
 469
 470         fd = open(fname, O_RDONLY);
 471         if (fd < 0) {
 472                 perror("open trace file\n");
 473                 return 1;
 474         }
 475
 476         fifo = fifo_alloc(TRACE_FIFO_SIZE);
 477
 478         traces = 0;
 479         do {
 480                 ret = trace_fifo_get(fifo, fd, &t, sizeof(t));
 481                 if (ret < 0)
 482                         goto err;
 483                 else if (!ret)
 484                         break;
 485                 else if (ret < (int) sizeof(t)) {
 486                         log_err("fio: short fifo get\n");
 487                         break;
 488                 }
 489
 490                 if (need_swap)
 491                         byteswap_trace(&t);
 492
 493                 if ((t.magic & 0xffffff00) != BLK_IO_TRACE_MAGIC) {
 494                         log_err("fio: bad magic in blktrace data: %x\n", t.magic);
 495                         goto err;
 496                 }
 497                 if ((t.magic & 0xff) != BLK_IO_TRACE_VERSION) {
 498                         log_err("fio: bad blktrace version %d\n", t.magic & 0xff);
 499                         goto err;
 500                 }
 501                 ret = discard_pdu(fifo, fd, &t);
 502                 if (ret < 0) {
 503                         log_err("blktrace lseek\n");
 504                         goto err;
 505                 } else if (t.pdu_len != ret) {
 506                         log_err("fio: discarded %d of %d\n", ret, t.pdu_len);
 507                         goto err;
 508                 }
 509
 510                 p = pid_hash_get(t.pid);
 511                 ret = handle_trace(&t, p);
 512                 if (ret)
 513                         break;
 514                 p->o.last_ttime[t_to_rwdir(&t)] = t.time;
 515                 traces++;
 516         } while (1);
 517
 518         fifo_free(fifo);
 519         close(fd);
 520
 521         if (ret)
 522                 return ret;
 523
 524         if (output_ascii)
 525                 printf("Traces loaded: %lu\n", traces);
 526
 527         return 0;
 528 err:
 529         close(fd);
 530         fifo_free(fifo);
 531         return 1;
 532 }
 533
 534 static int bs_cmp(const void *ba, const void *bb)
 535 {
 536         const struct bs *bsa = ba;
 537         const struct bs *bsb = bb;
 538
 539         return bsb->nr - bsa->nr;
 540 }
 541
 542 static unsigned long o_to_kb_rate(struct btrace_out *o, int rw)
 543 {
 544         uint64_t usec = (o->last_ttime[rw] - o->first_ttime[rw]) / 1000ULL;
 545         uint64_t val;
 546
 547         if (!usec)
 548                 return 0;
 549
 550         usec /= 1000;
 551         if (!usec)
 552                 return 0;
 553
 554         val = o->kb[rw] * 1000ULL;
 555         return val / usec;
 556 }
 557
 558 static uint64_t o_first_ttime(struct btrace_out *o)
 559 {
 560         uint64_t first;
 561
 562         first = min(o->first_ttime[0], o->first_ttime[1]);
 563         return min(first, o->first_ttime[2]);
 564 }
 565
 566 static uint64_t o_longest_ttime(struct btrace_out *o)
 567 {
 568         uint64_t ret = 0;
 569         int i;
 570
 571         for (i = 0; i < DDIR_RWDIR_CNT; i++) {
 572                 uint64_t diff;
 573
 574                 diff = o->last_ttime[i] - o->first_ttime[i];
 575                 ret = max(diff, ret);
 576         }
 577
 578         return ret;
 579 }
 580
 581 static void __output_p_ascii(struct btrace_pid *p, unsigned long *ios)
 582 {
 583         const char *msg[] = { "reads", "writes", "trims" };
 584         struct btrace_out *o = &p->o;
 585         unsigned long total, usec;
 586         int i, j;
 587
 588         printf("[pid:\t%u]\n", p->pid);
 589
 590         total = ddir_rw_sum(o->ios);
 591         for (i = 0; i < DDIR_RWDIR_CNT; i++) {
 592                 float perc;
 593
 594                 if (!o->ios[i])
 595                         continue;
 596
 597                 ios[i] += o->ios[i] + o->merges[i];
 598                 printf("%s\n", msg[i]);
 599                 perc = ((float) o->ios[i] * 100.0) / (float) total;
 600                 printf("\tios:    %lu (perc=%3.2f%%)\n", o->ios[i], perc);
 601                 perc = ((float) o->merges[i] * 100.0) / (float) total;
 602                 printf("\tmerges: %lu (perc=%3.2f%%)\n", o->merges[i], perc);
 603                 perc = ((float) o->seq[i] * 100.0) / (float) o->ios[i];
 604                 printf("\tseq:    %lu (perc=%3.2f%%)\n", (unsigned long) o->seq[i], perc);
 605                 printf("\trate:   %lu KB/sec\n", o_to_kb_rate(o, i));
 606
 607                 for (j = 0; j < o->nr_bs[i]; j++) {
 608                         struct bs *bs = &o->bs[i][j];
 609
 610                         perc = (((float) bs->nr * 100.0) / (float) o->ios[i]);
 611                         printf("\tbs=%u, perc=%3.2f%%\n", bs->bs, perc);
 612                 }
 613         }
 614
 615         printf("depth:\t%u\n", o->depth);
 616         usec = o_longest_ttime(o) / 1000ULL;
 617         printf("usec:\t%lu (delay=%llu)\n", usec, (unsigned long long) o->start_delay);
 618
 619         printf("files:\t");
 620         for (i = 0; i < p->nr_files; i++)
 621                 printf("%s,", p->files[i].name);
 622         printf("\n");
 623
 624         printf("\n");
 625 }
 626
 627 static int __output_p_fio(struct btrace_pid *p, unsigned long *ios)
 628 {
 629         struct btrace_out *o = &p->o;
 630         unsigned long total;
 631         unsigned long long time;
 632         float perc;
 633         int i, j;
 634
 635         if ((o->ios[0] + o->ios[1]) && o->ios[2]) {
 636                 log_err("fio: trace has both read/write and trim\n");
 637                 return 1;
 638         }
 639         if (!p->nr_files) {
 640                 log_err("fio: no devices found\n");
 641                 return 1;
 642         }
 643
 644         printf("[pid%u]\n", p->pid);
 645         printf("direct=1\n");
 646         if (o->depth == 1)
 647                 printf("ioengine=sync\n");
 648         else
 649                 printf("ioengine=libaio\niodepth=%u\n", o->depth);
 650
 651         if (o->ios[0] && !o->ios[1])
 652                 printf("rw=randread\n");
 653         else if (!o->ios[0] && o->ios[1])
 654                 printf("rw=randwrite\n");
 655         else if (o->ios[2])
 656                 printf("rw=randtrim\n");
 657         else {
 658                 printf("rw=randrw\n");
 659                 total = ddir_rw_sum(o->ios);
 660                 perc = ((float) o->ios[0] * 100.0) / (float) total;
 661                 printf("rwmixread=%u\n", (int) (perc + 0.99));
 662         }
 663
 664         printf("percentage_random=");
 665         for (i = 0; i < DDIR_RWDIR_CNT; i++) {
 666                 if (o->seq[i] && o->ios[i]) {
 667                         perc = ((float) o->seq[i] * 100.0) / (float) o->ios[i];
 668                         if (perc >= 99.0)
 669                                 perc = 100.0;
 670                 } else
 671                         perc = 100.0;
 672
 673                 if (i)
 674                         printf(",");
 675                 perc = 100.0 - perc;
 676                 printf("%u", (int) perc);
 677         }
 678         printf("\n");
 679
 680         printf("filename=");
 681         for (i = 0; i < p->nr_files; i++) {
 682                 if (i)
 683                         printf(":");
 684                 printf("%s", p->files[i].name);
 685         }
 686         printf("\n");
 687
 688         printf("startdelay=%llus\n", o->start_delay / 1000000ULL);
 689
 690         time = o_longest_ttime(o);
 691         time = (time + 1000000000ULL - 1) / 1000000000ULL;
 692         printf("runtime=%llus\n", time);
 693
 694         printf("bssplit=");
 695         for (i = 0; i < DDIR_RWDIR_CNT; i++) {
 696
 697                 if (i && o->nr_bs[i - 1] && o->nr_bs[i])
 698                         printf(",");
 699
 700                 for (j = 0; j < o->nr_bs[i]; j++) {
 701                         struct bs *bs = &o->bs[i][j];
 702
 703                         perc = (((float) bs->nr * 100.0) / (float) o->ios[i]);
 704                         if (perc < 1.00)
 705                                 continue;
 706                         if (j)
 707                                 printf(":");
 708                         if (j + 1 == o->nr_bs[i])
 709                                 printf("%u/", bs->bs);
 710                         else
 711                                 printf("%u/%u", bs->bs, (int) perc);
 712                 }
 713         }
 714         printf("\n");
 715
 716         if (set_rate) {
 717                 printf("rate=");
 718                 for (i = 0; i < DDIR_RWDIR_CNT; i++) {
 719                         unsigned long rate;
 720
 721                         rate = o_to_kb_rate(o, i);
 722                         if (i)
 723                                 printf(",");
 724                         if (rate)
 725                                 printf("%luk", rate);
 726                 }
 727                 printf("\n");
 728         }
 729
 730         printf("\n");
 731         return 0;
 732 }
 733
 734 static int __output_p(struct btrace_pid *p, unsigned long *ios)
 735 {
 736         struct btrace_out *o = &p->o;
 737         int i, ret = 0;
 738
 739         for (i = 0; i < DDIR_RWDIR_CNT; i++) {
 740                 if (o->nr_bs[i] <= 1)
 741                         continue;
 742                 qsort(o->bs[i], o->nr_bs[i], sizeof(struct bs), bs_cmp);
 743         }
 744
 745         if (filename) {
 746                 p->files = malloc(sizeof(struct trace_file));
 747                 p->nr_files++;
 748                 p->files[0].name = filename;
 749         }
 750
 751         if (output_ascii)
 752                 __output_p_ascii(p, ios);
 753         else
 754                 ret = __output_p_fio(p, ios);
 755
 756         return ret;
 757 }
 758
 759 static void remove_ddir(struct btrace_out *o, int rw)
 760 {
 761         o->ios[rw] = 0;
 762 }
 763
 764 static int prune_entry(struct btrace_out *o)
 765 {
 766         unsigned long rate;
 767         uint64_t time;
 768         int i;
 769
 770         if (ddir_rw_sum(o->ios) < ios_threshold)
 771                 return 1;
 772
 773         time = o_longest_ttime(o) / 1000ULL;
 774         if (time < rt_threshold)
 775                 return 1;
 776
 777         rate = 0;
 778         for (i = 0; i < DDIR_RWDIR_CNT; i++) {
 779                 unsigned long this_rate;
 780
 781                 this_rate = o_to_kb_rate(o, i);
 782                 if (this_rate < rate_threshold) {
 783                         remove_ddir(o, i);
 784                         this_rate = 0;
 785                 }
 786                 rate += this_rate;
 787         }
 788
 789         if (rate < rate_threshold)
 790                 return 1;
 791
 792         return 0;
 793 }
 794
 795 static int entry_cmp(void *priv, struct flist_head *a, struct flist_head *b)
 796 {
 797         struct btrace_pid *pa = flist_entry(a, struct btrace_pid, pid_list);
 798         struct btrace_pid *pb = flist_entry(b, struct btrace_pid, pid_list);
 799
 800         return ddir_rw_sum(pb->o.ios) - ddir_rw_sum(pa->o.ios);
 801 }
 802
 803 static void free_p(struct btrace_pid *p)
 804 {
 805         struct btrace_out *o = &p->o;
 806         int i;
 807
 808         for (i = 0; i < p->nr_files; i++) {
 809                 if (p->files[i].name && p->files[i].name != filename)
 810                         free(p->files[i].name);
 811         }
 812
 813         for (i = 0; i < DDIR_RWDIR_CNT; i++)
 814                 free(o->bs[i]);
 815
 816         free(p->files);
 817         flist_del(&p->pid_list);
 818         flist_del(&p->hash_list);
 819         free(p);
 820 }
 821
 822 static int output_p(void)
 823 {
 824         unsigned long ios[DDIR_RWDIR_CNT];
 825         struct flist_head *e, *tmp;
 826         int depth_disabled = 0;
 827         int ret = 0;
 828
 829         flist_for_each_safe(e, tmp, &pid_list) {
 830                 struct btrace_pid *p;
 831
 832                 p = flist_entry(e, struct btrace_pid, pid_list);
 833                 if (prune_entry(&p->o)) {
 834                         free_p(p);
 835                         continue;
 836                 }
 837                 p->o.start_delay = (o_first_ttime(&p->o) / 1000ULL) - first_ttime;
 838                 depth_disabled += p->o.depth_disabled;
 839         }
 840
 841         if (depth_disabled)
 842                 log_err("fio: missing completion traces, depths capped at %u\n", max_depth);
 843
 844         memset(ios, 0, sizeof(ios));
 845
 846         flist_sort(NULL, &pid_list, entry_cmp);
 847
 848         flist_for_each(e, &pid_list) {
 849                 struct btrace_pid *p;
 850
 851                 p = flist_entry(e, struct btrace_pid, pid_list);
 852                 ret |= __output_p(p, ios);
 853                 if (ret && !output_ascii)
 854                         break;
 855         }
 856
 857         if (output_ascii)
 858                 printf("Total: reads=%lu, writes=%lu\n", ios[0], ios[1]);
 859
 860         return ret;
 861 }
 862
 863 static int usage(char *argv[])
 864 {
 865         log_err("%s: <blktrace bin file>\n", argv[0]);
 866         log_err("\t-t\tUsec threshold to ignore task\n");
 867         log_err("\t-n\tNumber IOS threshold to ignore task\n");
 868         log_err("\t-f\tFio job file output\n");
 869         log_err("\t-d\tUse this file/device for replay\n");
 870         log_err("\t-r\tIgnore jobs with less than this KB/sec rate\n");
 871         log_err("\t-R\tSet rate in fio job\n");
 872         log_err("\t-D\tCap queue depth at this value (def=%u)\n", max_depth);
 873         return 1;
 874 }
 875
 876 static int trace_needs_swap(const char *trace_file, int *swap)
 877 {
 878         struct blk_io_trace t;
 879         int fd, ret;
 880
 881         *swap = -1;
 882
 883         fd = open(trace_file, O_RDONLY);
 884         if (fd < 0) {
 885                 perror("open");
 886                 return 1;
 887         }
 888
 889         ret = read(fd, &t, sizeof(t));
 890         if (ret < 0) {
 891                 close(fd);
 892                 perror("read");
 893                 return 1;
 894         } else if (ret != sizeof(t)) {
 895                 close(fd);
 896                 log_err("fio: short read on trace file\n");
 897                 return 1;
 898         }
 899
 900         close(fd);
 901
 902         if ((t.magic & 0xffffff00) == BLK_IO_TRACE_MAGIC)
 903                 *swap = 0;
 904         else {
 905                 /*
 906                  * Maybe it needs to be endian swapped...
 907                  */
 908                 t.magic = fio_swap32(t.magic);
 909                 if ((t.magic & 0xffffff00) == BLK_IO_TRACE_MAGIC)
 910                         *swap = 1;
 911         }
 912
 913         if (*swap == -1) {
 914                 log_err("fio: blktrace appears corrupt\n");
 915                 return 1;
 916         }
 917
 918         return 0;
 919 }
 920
 921 int main(int argc, char *argv[])
 922 {
 923         int need_swap, i, c;
 924
 925         if (argc < 2)
 926                 return usage(argv);
 927
 928         while ((c = getopt(argc, argv, "t:n:fd:r:RD:")) != -1) {
 929                 switch (c) {
 930                 case 'R':
 931                         set_rate = 1;
 932                         break;
 933                 case 'r':
 934                         rate_threshold = atoi(optarg);
 935                         break;
 936                 case 't':
 937                         rt_threshold = atoi(optarg);
 938                         break;
 939                 case 'n':
 940                         ios_threshold = atoi(optarg);
 941                         break;
 942                 case 'f':
 943                         output_ascii = 0;
 944                         break;
 945                 case 'd':
 946                         filename = strdup(optarg);
 947                         break;
 948                 case 'D':
 949                         max_depth = atoi(optarg);
 950                         break;
 951                 case '?':
 952                 default:
 953                         return usage(argv);
 954                 }
 955         }
 956
 957         if (argc == optind)
 958                 return usage(argv);
 959
 960         if (trace_needs_swap(argv[optind], &need_swap))
 961                 return 1;
 962
 963         for (i = 0; i < PID_HASH_SIZE; i++)
 964                 INIT_FLIST_HEAD(&pid_hash[i]);
 965         for (i = 0; i < INFLIGHT_HASH_SIZE; i++)
 966                 INIT_FLIST_HEAD(&inflight_hash[i]);
 967
 968         load_blktrace(argv[optind], need_swap);
 969         first_ttime /= 1000ULL;
 970
 971         return output_p();
 972 }