blkparse.c

   1 /*
   2  * block queue tracing parse application
   3  *
   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  *
  20  */
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <unistd.h>
  24 #include <stdio.h>
  25 #include <fcntl.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <getopt.h>
  29 #include <errno.h>
  30 #include <signal.h>
  31 #include <locale.h>
  32 #include <limits.h>
  33
  34 #include "blktrace.h"
  35 #include "rbtree.h"
  36
  37 #define SECONDS(x)              ((unsigned long long)(x) / 1000000000)
  38 #define NANO_SECONDS(x)         ((unsigned long long)(x) % 1000000000)
  39 #define DOUBLE_TO_NANO_ULL(d)   ((unsigned long long)((d) * 1000000000))
  40
  41 #define MINORBITS       20
  42 #define MINORMASK       ((1U << MINORBITS) - 1)
  43 #define MAJOR(dev)      ((unsigned int) ((dev) >> MINORBITS))
  44 #define MINOR(dev)      ((unsigned int) ((dev) & MINORMASK))
  45
  46 #define min(a, b)       ((a) < (b) ? (a) : (b))
  47
  48 struct io_stats {
  49         unsigned long qreads, qwrites, creads, cwrites, mreads, mwrites;
  50         unsigned long ireads, iwrites;
  51         unsigned long long qread_kb, qwrite_kb, cread_kb, cwrite_kb;
  52         unsigned long long iread_kb, iwrite_kb;
  53 };
  54
  55 struct per_cpu_info {
  56         int cpu;
  57         int nelems;
  58
  59         int fd;
  60         char fname[128];
  61
  62         struct io_stats io_stats;
  63 };
  64
  65 struct per_dev_info {
  66         dev_t id;
  67         char *name;
  68
  69         int backwards;
  70         unsigned long long events;
  71         unsigned long long last_reported_time;
  72         struct io_stats io_stats;
  73
  74         int ncpus;
  75         struct per_cpu_info *cpus;
  76 };
  77
  78 struct per_process_info {
  79         char name[16];
  80         __u32 pid;
  81         struct io_stats io_stats;
  82         struct per_process_info *hash_next, *list_next;
  83
  84         /*
  85          * individual io stats
  86          */
  87         unsigned long long longest_allocation_wait[2];
  88         unsigned long long longest_dispatch_wait[2];
  89         unsigned long long longest_completion_wait[2];
  90 };
  91
  92 #define PPI_HASH_SHIFT  (8)
  93 static struct per_process_info *ppi_hash[1 << PPI_HASH_SHIFT];
  94 static struct per_process_info *ppi_list;
  95
  96 #define S_OPTS  "i:o:b:stqw:"
  97 static struct option l_opts[] = {
  98         {
  99                 .name = "input",
 100                 .has_arg = 1,
 101                 .flag = NULL,
 102                 .val = 'i'
 103         },
 104         {
 105                 .name = "output",
 106                 .has_arg = 1,
 107                 .flag = NULL,
 108                 .val = 'o'
 109         },
 110         {
 111                 .name = "batch",
 112                 .has_arg = 1,
 113                 .flag = NULL,
 114                 .val = 'b'
 115         },
 116         {
 117                 .name = "per program stats",
 118                 .has_arg = 0,
 119                 .flag = NULL,
 120                 .val = 's'
 121         },
 122         {
 123                 .name = "track ios",
 124                 .has_arg = 0,
 125                 .flag = NULL,
 126                 .val = 't'
 127         },
 128         {
 129                 .name = "quiet",
 130                 .has_arg = 0,
 131                 .flag = NULL,
 132                 .val = 'q'
 133         },
 134         {
 135                 .name = "stopwatch",
 136                 .has_arg = 1,
 137                 .flag = NULL,
 138                 .val = 'w'
 139         },
 140         {
 141                 .name = NULL,
 142                 .has_arg = 0,
 143                 .flag = NULL,
 144                 .val = 0
 145         }
 146 };
 147
 148 static struct rb_root rb_sort_root;
 149 static struct rb_root rb_track_root;
 150
 151 /*
 152  * for sorting the displayed output
 153  */
 154 struct trace {
 155         struct blk_io_trace *bit;
 156         struct rb_node rb_node;
 157 };
 158
 159 /*
 160  * for tracking individual ios
 161  */
 162 struct io_track {
 163         struct rb_node rb_node;
 164
 165         dev_t device;
 166         __u64 sector;
 167         __u32 pid;
 168         unsigned long long allocation_time;
 169         unsigned long long queue_time;
 170         unsigned long long dispatch_time;
 171         unsigned long long completion_time;
 172 };
 173
 174 static int ndevices;
 175 static struct per_dev_info *devices;
 176 static char *get_dev_name(struct per_dev_info *, char *, int);
 177
 178 static FILE *ofp;
 179 static char *output_name;
 180
 181 static unsigned long long genesis_time;
 182 static unsigned long long stopwatch_start;      /* start from zero by default */
 183 static unsigned long long stopwatch_end = ULONG_LONG_MAX;       /* "infinity" */
 184
 185 static int per_process_stats;
 186 static int track_ios;
 187
 188 #define RB_BATCH_DEFAULT        (1024)
 189 static int rb_batch = RB_BATCH_DEFAULT;
 190
 191 static int pipeline;
 192
 193 #define is_done()       (*(volatile int *)(&done))
 194 static volatile int done;
 195
 196 static inline unsigned long hash_long(unsigned long val)
 197 {
 198 #if __WORDSIZE == 32
 199         val *= 0x9e370001UL;
 200 #elif __WORDSIZE == 64
 201         val *= 0x9e37fffffffc0001UL;
 202 #else
 203 #error unknown word size
 204 #endif
 205
 206         return val >> (__WORDSIZE - PPI_HASH_SHIFT);
 207 }
 208
 209 static inline void add_process_to_hash(struct per_process_info *ppi)
 210 {
 211         const int hash_idx = hash_long(ppi->pid);
 212
 213         ppi->hash_next = ppi_hash[hash_idx];
 214         ppi_hash[hash_idx] = ppi;
 215 }
 216
 217 static inline void add_process_to_list(struct per_process_info *ppi)
 218 {
 219         ppi->list_next = ppi_list;
 220         ppi_list = ppi;
 221 }
 222
 223 static struct per_process_info *find_process_by_pid(__u32 pid)
 224 {
 225         const int hash_idx = hash_long(pid);
 226         struct per_process_info *ppi;
 227
 228         ppi = ppi_hash[hash_idx];
 229         while (ppi) {
 230                 if (ppi->pid == pid)
 231                         return ppi;
 232
 233                 ppi = ppi->hash_next;
 234         }
 235
 236         return NULL;
 237 }
 238
 239 static inline int trace_rb_insert(struct trace *t)
 240 {
 241         struct rb_node **p = &rb_sort_root.rb_node;
 242         struct rb_node *parent = NULL;
 243         struct trace *__t;
 244
 245         if (genesis_time == 0 || t->bit->time < genesis_time)
 246                 genesis_time = t->bit->time;
 247
 248         while (*p) {
 249                 parent = *p;
 250                 __t = rb_entry(parent, struct trace, rb_node);
 251
 252                 if (t->bit->time < __t->bit->time)
 253                         p = &(*p)->rb_left;
 254                 else if (t->bit->time > __t->bit->time)
 255                         p = &(*p)->rb_right;
 256                 else if (t->bit->device < __t->bit->device)
 257                         p = &(*p)->rb_left;
 258                 else if (t->bit->device > __t->bit->device)
 259                         p = &(*p)->rb_right;
 260                 else if (t->bit->sequence < __t->bit->sequence)
 261                         p = &(*p)->rb_left;
 262                 else if (t->bit->sequence > __t->bit->sequence)
 263                         p = &(*p)->rb_right;
 264                 else if (t->bit->device == __t->bit->device) {
 265                         fprintf(stderr,
 266                                 "sequence alias (%d) on device %d,%d!\n",
 267                                 t->bit->sequence,
 268                                 MAJOR(t->bit->device), MINOR(t->bit->device));
 269                         return 1;
 270                 }
 271         }
 272
 273         rb_link_node(&t->rb_node, parent, p);
 274         rb_insert_color(&t->rb_node, &rb_sort_root);
 275         return 0;
 276 }
 277
 278 static inline int track_rb_insert(struct io_track *iot)
 279 {
 280         struct rb_node **p = &rb_track_root.rb_node;
 281         struct rb_node *parent = NULL;
 282         struct io_track *__iot;
 283
 284         while (*p) {
 285                 parent = *p;
 286
 287                 __iot = rb_entry(parent, struct io_track, rb_node);
 288
 289                 if (iot->device < __iot->device)
 290                         p = &(*p)->rb_left;
 291                 else if (iot->device > __iot->device)
 292                         p = &(*p)->rb_right;
 293                 else if (iot->sector < __iot->sector)
 294                         p = &(*p)->rb_left;
 295                 else if (iot->sector > __iot->sector)
 296                         p = &(*p)->rb_right;
 297                 else {
 298                         fprintf(stderr,
 299                                 "sector alias (%llu) on device %d,%d!\n",
 300                                 iot->sector,
 301                                 MAJOR(iot->device), MINOR(iot->device));
 302                         return 1;
 303                 }
 304         }
 305
 306         rb_link_node(&iot->rb_node, parent, p);
 307         rb_insert_color(&iot->rb_node, &rb_track_root);
 308         return 0;
 309 }
 310
 311 static struct io_track *__find_track(dev_t device, __u64 sector)
 312 {
 313         struct rb_node **p = &rb_track_root.rb_node;
 314         struct rb_node *parent = NULL;
 315         struct io_track *__iot;
 316
 317         while (*p) {
 318                 parent = *p;
 319
 320                 __iot = rb_entry(parent, struct io_track, rb_node);
 321
 322                 if (device < __iot->device)
 323                         p = &(*p)->rb_left;
 324                 else if (device > __iot->device)
 325                         p = &(*p)->rb_right;
 326                 else if (sector < __iot->sector)
 327                         p = &(*p)->rb_left;
 328                 else if (sector > __iot->sector)
 329                         p = &(*p)->rb_right;
 330                 else
 331                         return __iot;
 332         }
 333
 334         return NULL;
 335 }
 336
 337 static struct io_track *find_track(__u32 pid, dev_t device, __u64 sector)
 338 {
 339         struct io_track *iot;
 340
 341         iot = __find_track(device, sector);
 342         if (!iot) {
 343                 iot = malloc(sizeof(*iot));
 344                 iot->pid = pid;
 345                 iot->device = device;
 346                 iot->sector = sector;
 347                 track_rb_insert(iot);
 348         }
 349
 350         return iot;
 351 }
 352
 353 static void log_track_merge(struct blk_io_trace *t)
 354 {
 355         struct io_track *iot;
 356
 357         if (!track_ios)
 358                 return;
 359         if ((t->action & BLK_TC_ACT(BLK_TC_FS)) == 0)
 360                 return;
 361
 362         iot = __find_track(t->device, t->sector - (t->bytes >> 10));
 363         if (!iot) {
 364                 fprintf(stderr, "Trying to merge on non-existing request\n");
 365                 return;
 366         }
 367
 368         rb_erase(&iot->rb_node, &rb_track_root);
 369         iot->sector -= t->bytes >> 10;
 370         track_rb_insert(iot);
 371 }
 372
 373 static void log_track_getrq(struct blk_io_trace *t)
 374 {
 375         struct io_track *iot;
 376
 377         if (!track_ios)
 378                 return;
 379
 380         iot = find_track(t->pid, t->device, t->sector);
 381         iot->allocation_time = t->time;
 382 }
 383
 384
 385 /*
 386  * return time between rq allocation and queue
 387  */
 388 static unsigned long long log_track_queue(struct blk_io_trace *t)
 389 {
 390         unsigned long long elapsed;
 391         struct io_track *iot;
 392
 393         if (!track_ios)
 394                 return -1;
 395
 396         iot = find_track(t->pid, t->device, t->sector);
 397         iot->queue_time = t->time;
 398         elapsed = iot->queue_time - iot->allocation_time;
 399
 400         if (per_process_stats) {
 401                 struct per_process_info *ppi = find_process_by_pid(iot->pid);
 402                 int w = (t->action & BLK_TC_ACT(BLK_TC_WRITE)) != 0;
 403
 404                 if (ppi && elapsed > ppi->longest_allocation_wait[w])
 405                         ppi->longest_allocation_wait[w] = elapsed;
 406         }
 407
 408         return elapsed;
 409 }
 410
 411 /*
 412  * return time between queue and issue
 413  */
 414 static unsigned long long log_track_issue(struct blk_io_trace *t)
 415 {
 416         unsigned long long elapsed;
 417         struct io_track *iot;
 418
 419         if (!track_ios)
 420                 return -1;
 421         if ((t->action & BLK_TC_ACT(BLK_TC_FS)) == 0)
 422                 return -1;
 423
 424         iot = __find_track(t->device, t->sector);
 425         if (!iot) {
 426                 fprintf(stderr, "Trying to issue on non-existing request\n");
 427                 return -1;
 428         }
 429
 430         iot->dispatch_time = t->time;
 431         elapsed = iot->dispatch_time - iot->queue_time;
 432
 433         if (per_process_stats) {
 434                 struct per_process_info *ppi = find_process_by_pid(iot->pid);
 435                 int w = (t->action & BLK_TC_ACT(BLK_TC_WRITE)) != 0;
 436
 437                 if (ppi && elapsed > ppi->longest_dispatch_wait[w])
 438                         ppi->longest_dispatch_wait[w] = elapsed;
 439         }
 440
 441         return elapsed;
 442 }
 443
 444 /*
 445  * return time between dispatch and complete
 446  */
 447 static unsigned long long log_track_complete(struct blk_io_trace *t)
 448 {
 449         unsigned long long elapsed;
 450         struct io_track *iot;
 451
 452         if (!track_ios)
 453                 return -1;
 454         if ((t->action & BLK_TC_ACT(BLK_TC_FS)) == 0)
 455                 return -1;
 456
 457         iot = __find_track(t->device, t->sector);
 458         if (!iot) {
 459                 fprintf(stderr, "Trying to dispatch on non-existing request\n");
 460                 return -1;
 461         }
 462
 463         iot->completion_time = t->time;
 464         elapsed = iot->completion_time - iot->dispatch_time;
 465
 466         if (per_process_stats) {
 467                 struct per_process_info *ppi = find_process_by_pid(iot->pid);
 468                 int w = (t->action & BLK_TC_ACT(BLK_TC_WRITE)) != 0;
 469
 470                 if (ppi && elapsed > ppi->longest_completion_wait[w])
 471                         ppi->longest_completion_wait[w] = elapsed;
 472         }
 473
 474         /*
 475          * kill the trace, we don't need it after completion
 476          */
 477         rb_erase(&iot->rb_node, &rb_track_root);
 478         free(iot);
 479
 480         return elapsed;
 481 }
 482
 483
 484 static struct io_stats *find_process_io_stats(__u32 pid, char *name)
 485 {
 486         struct per_process_info *ppi = find_process_by_pid(pid);
 487
 488         if (!ppi) {
 489                 ppi = malloc(sizeof(*ppi));
 490                 memset(ppi, 0, sizeof(*ppi));
 491                 strncpy(ppi->name, name, sizeof(ppi->name));
 492                 ppi->pid = pid;
 493                 add_process_to_hash(ppi);
 494                 add_process_to_list(ppi);
 495         }
 496
 497         return &ppi->io_stats;
 498 }
 499
 500
 501 static void resize_cpu_info(struct per_dev_info *pdi, int cpu)
 502 {
 503         struct per_cpu_info *cpus = pdi->cpus;
 504         int ncpus = pdi->ncpus;
 505         int new_count = cpu + 1;
 506         int new_space, size;
 507         char *new_start;
 508
 509         size = new_count * sizeof(struct per_cpu_info);
 510         cpus = realloc(cpus, size);
 511         if (!cpus) {
 512                 char name[20];
 513                 fprintf(stderr, "Out of memory, CPU info for device %s (%d)\n",
 514                         get_dev_name(pdi, name, sizeof(name)), size);
 515                 exit(1);
 516         }
 517
 518         new_start = (char *)cpus + (ncpus * sizeof(struct per_cpu_info));
 519         new_space = (new_count - ncpus) * sizeof(struct per_cpu_info);
 520         memset(new_start, 0, new_space);
 521
 522         pdi->ncpus = new_count;
 523         pdi->cpus = cpus;
 524 }
 525
 526 static struct per_cpu_info *get_cpu_info(struct per_dev_info *pdi, int cpu)
 527 {
 528         if (cpu >= pdi->ncpus)
 529                 resize_cpu_info(pdi, cpu);
 530         return &pdi->cpus[cpu];
 531 }
 532
 533
 534 static int resize_devices(char *name)
 535 {
 536         int size = (ndevices + 1) * sizeof(struct per_dev_info);
 537
 538         devices = realloc(devices, size);
 539         if (!devices) {
 540                 fprintf(stderr, "Out of memory, device %s (%d)\n", name, size);
 541                 return 1;
 542         }
 543         memset(&devices[ndevices], 0, sizeof(struct per_dev_info));
 544         devices[ndevices].name = name;
 545         ndevices++;
 546         return 0;
 547 }
 548
 549 static struct per_dev_info *get_dev_info(dev_t id, int create)
 550 {
 551         int i;
 552
 553         for (i = 0; i < ndevices; i++)
 554                 if (devices[i].id == id)
 555                         return &devices[i];
 556         if (!create)
 557                 return NULL;
 558         if (resize_devices(NULL) != 0)
 559                 return NULL;
 560         return &devices[ndevices-1];
 561 }
 562
 563 static char *get_dev_name(struct per_dev_info *pdi, char *buffer, int size)
 564 {
 565         if (pdi->name)
 566                 snprintf(buffer, size, "%s", pdi->name);
 567         else
 568                 snprintf(buffer, size, "%d,%d", MAJOR(pdi->id), MINOR(pdi->id));
 569         return buffer;
 570 }
 571
 572
 573 static void check_time(struct per_dev_info *pdi, struct blk_io_trace *bit)
 574 {
 575         unsigned long long this = bit->time;
 576         unsigned long long last = pdi->last_reported_time;
 577
 578         pdi->backwards = (this < last) ? 'B' : ' ';
 579         pdi->last_reported_time = this;
 580 }
 581
 582
 583 static inline void __account_m(struct io_stats *ios, struct blk_io_trace *t,
 584                                int rw)
 585 {
 586         if (rw) {
 587                 ios->mwrites++;
 588                 ios->qwrite_kb += t->bytes >> 10;
 589         } else {
 590                 ios->mreads++;
 591                 ios->qread_kb += t->bytes >> 10;
 592         }
 593 }
 594
 595 static inline void account_m(struct blk_io_trace *t, struct per_cpu_info *pci,
 596                              int rw)
 597 {
 598         __account_m(&pci->io_stats, t, rw);
 599
 600         if (per_process_stats) {
 601                 struct io_stats *ios = find_process_io_stats(t->pid, t->comm);
 602
 603                 __account_m(ios, t, rw);
 604         }
 605 }
 606
 607 static inline void __account_q(struct io_stats *ios, struct blk_io_trace *t,
 608                                int rw)
 609 {
 610         if (rw) {
 611                 ios->qwrites++;
 612                 ios->qwrite_kb += t->bytes >> 10;
 613         } else {
 614                 ios->qreads++;
 615                 ios->qread_kb += t->bytes >> 10;
 616         }
 617 }
 618
 619 static inline void account_q(struct blk_io_trace *t, struct per_cpu_info *pci,
 620                              int rw)
 621 {
 622         __account_q(&pci->io_stats, t, rw);
 623
 624         if (per_process_stats) {
 625                 struct io_stats *ios = find_process_io_stats(t->pid, t->comm);
 626
 627                 __account_q(ios, t, rw);
 628         }
 629 }
 630
 631 static inline void __account_c(struct io_stats *ios, int rw, unsigned int bytes)
 632 {
 633         if (rw) {
 634                 ios->cwrites++;
 635                 ios->cwrite_kb += bytes >> 10;
 636         } else {
 637                 ios->creads++;
 638                 ios->cread_kb += bytes >> 10;
 639         }
 640 }
 641
 642 static inline void account_c(struct blk_io_trace *t, struct per_cpu_info *pci,
 643                              int rw, int bytes)
 644 {
 645         __account_c(&pci->io_stats, rw, bytes);
 646
 647         if (per_process_stats) {
 648                 struct io_stats *ios = find_process_io_stats(t->pid, t->comm);
 649
 650                 __account_c(ios, rw, bytes);
 651         }
 652 }
 653
 654 static inline void __account_i(struct io_stats *ios, int rw, unsigned int bytes)
 655 {
 656         if (rw) {
 657                 ios->iwrites++;
 658                 ios->iwrite_kb += bytes >> 10;
 659         } else {
 660                 ios->ireads++;
 661                 ios->iread_kb += bytes >> 10;
 662         }
 663 }
 664
 665 static inline void account_i(struct blk_io_trace *t, struct per_cpu_info *pci,
 666                              int rw)
 667 {
 668         __account_i(&pci->io_stats, rw, t->bytes);
 669
 670         if (per_process_stats) {
 671                 struct io_stats *ios = find_process_io_stats(t->pid, t->comm);
 672
 673                 __account_i(ios, rw, t->bytes);
 674         }
 675 }
 676
 677 static void output(struct per_cpu_info *pci, char *s)
 678 {
 679         fprintf(ofp, "%s", s);
 680 }
 681
 682 static char hstring[256];
 683 static char tstring[256];
 684
 685 static inline char *setup_header(struct per_cpu_info *pci,
 686                                  struct blk_io_trace *t, char act)
 687 {
 688         int w = t->action & BLK_TC_ACT(BLK_TC_WRITE);
 689         int b = t->action & BLK_TC_ACT(BLK_TC_BARRIER);
 690         int s = t->action & BLK_TC_ACT(BLK_TC_SYNC);
 691         char rwbs[4];
 692         int i = 0;
 693
 694         if (w)
 695                 rwbs[i++] = 'W';
 696         else
 697                 rwbs[i++] = 'R';
 698         if (b)
 699                 rwbs[i++] = 'B';
 700         if (s)
 701                 rwbs[i++] = 'S';
 702
 703         rwbs[i] = '\0';
 704
 705         sprintf(hstring, "%3d,%-3d %2d %8ld %5Lu.%09Lu %5u %c %3s",
 706                 MAJOR(t->device), MINOR(t->device), pci->cpu,
 707                 (unsigned long)t->sequence, SECONDS(t->time),
 708                 NANO_SECONDS(t->time), t->pid, act, rwbs);
 709
 710         return hstring;
 711 }
 712
 713 static void log_complete(struct per_cpu_info *pci, struct blk_io_trace *t,
 714                          char act)
 715 {
 716         unsigned long long elapsed = log_track_complete(t);
 717
 718         if (elapsed != -1ULL) {
 719                 unsigned long usec = elapsed / 1000;
 720
 721                 sprintf(tstring,"%s %Lu + %u (%8lu) [%d]\n",
 722                         setup_header(pci, t, act),
 723                         (unsigned long long)t->sector, t->bytes >> 9,
 724                         usec, t->error);
 725         } else {
 726                 sprintf(tstring,"%s %Lu + %u [%d]\n", setup_header(pci, t, act),
 727                         (unsigned long long)t->sector, t->bytes >> 9, t->error);
 728         }
 729
 730         output(pci, tstring);
 731 }
 732
 733 static void log_queue(struct per_cpu_info *pci, struct blk_io_trace *t,
 734                       char act)
 735 {
 736         unsigned long long elapsed = log_track_queue(t);
 737
 738         if (elapsed != -1ULL) {
 739                 unsigned long usec = elapsed / 1000;
 740
 741                 sprintf(tstring,"%s %Lu + %u (%8lu) [%s]\n",
 742                         setup_header(pci, t, act),
 743                         (unsigned long long)t->sector, t->bytes >> 9,
 744                         usec, t->comm);
 745         } else {
 746                 sprintf(tstring,"%s %Lu + %u [%s]\n", setup_header(pci, t, act),
 747                         (unsigned long long)t->sector, t->bytes >> 9, t->comm);
 748         }
 749         output(pci, tstring);
 750 }
 751
 752 static void log_issue(struct per_cpu_info *pci, struct blk_io_trace *t,
 753                       char act)
 754 {
 755         unsigned long long elapsed = log_track_issue(t);
 756
 757         if (elapsed != -1ULL) {
 758                 double usec = (double) elapsed / 1000;
 759
 760                 sprintf(tstring,"%s %Lu + %u (%8.2f) [%s]\n",
 761                         setup_header(pci, t, act),
 762                         (unsigned long long)t->sector, t->bytes >> 9,
 763                         usec, t->comm);
 764         } else {
 765                 sprintf(tstring,"%s %Lu + %u [%s]\n", setup_header(pci, t, act),
 766                         (unsigned long long)t->sector, t->bytes >> 9, t->comm);
 767         }
 768
 769         output(pci, tstring);
 770 }
 771
 772 static void log_merge(struct per_cpu_info *pci, struct blk_io_trace *t,
 773                       char act)
 774 {
 775         log_track_merge(t);
 776
 777         sprintf(tstring,"%s %Lu + %u [%s]\n", setup_header(pci, t, act),
 778                 (unsigned long long)t->sector, t->bytes >> 9, t->comm);
 779         output(pci, tstring);
 780 }
 781
 782 static void log_generic(struct per_cpu_info *pci, struct blk_io_trace *t,
 783                         char act)
 784 {
 785         sprintf(tstring,"%s %Lu + %u [%s]\n", setup_header(pci, t, act),
 786                 (unsigned long long)t->sector, t->bytes >> 9, t->comm);
 787         output(pci, tstring);
 788 }
 789
 790 static int log_pc(struct per_cpu_info *pci, struct blk_io_trace *t, char act)
 791 {
 792         unsigned char *buf;
 793         int i;
 794
 795         sprintf(tstring,"%s ", setup_header(pci, t, act));
 796         output(pci, tstring);
 797
 798         buf = (unsigned char *) t + sizeof(*t);
 799         for (i = 0; i < t->pdu_len; i++) {
 800                 sprintf(tstring,"%02x ", buf[i]);
 801                 output(pci, tstring);
 802         }
 803
 804         if (act == 'C') {
 805                 sprintf(tstring,"[%d]\n", t->error);
 806                 output(pci, tstring);
 807         } else {
 808                 sprintf(tstring,"[%s]\n", t->comm);
 809                 output(pci, tstring);
 810         }
 811         return 0;
 812 }
 813
 814 static int dump_trace_pc(struct blk_io_trace *t, struct per_cpu_info *pci)
 815 {
 816         int ret = 0;
 817
 818         switch (t->action & 0xffff) {
 819                 case __BLK_TA_QUEUE:
 820                         log_generic(pci, t, 'Q');
 821                         break;
 822                 case __BLK_TA_GETRQ:
 823                         log_generic(pci, t, 'G');
 824                         break;
 825                 case __BLK_TA_SLEEPRQ:
 826                         log_generic(pci, t, 'S');
 827                         break;
 828                 case __BLK_TA_REQUEUE:
 829                         log_generic(pci, t, 'R');
 830                         break;
 831                 case __BLK_TA_ISSUE:
 832                         ret = log_pc(pci, t, 'D');
 833                         break;
 834                 case __BLK_TA_COMPLETE:
 835                         log_pc(pci, t, 'C');
 836                         break;
 837                 default:
 838                         fprintf(stderr, "Bad pc action %x\n", t->action);
 839                         ret = 1;
 840                         break;
 841         }
 842
 843         return ret;
 844 }
 845
 846 static void dump_trace_fs(struct blk_io_trace *t, struct per_cpu_info *pci)
 847 {
 848         int w = t->action & BLK_TC_ACT(BLK_TC_WRITE);
 849         int act = t->action & 0xffff;
 850
 851         switch (act) {
 852                 case __BLK_TA_QUEUE:
 853                         account_q(t, pci, w);
 854                         log_queue(pci, t, 'Q');
 855                         break;
 856                 case __BLK_TA_BACKMERGE:
 857                         account_m(t, pci, w);
 858                         log_merge(pci, t, 'M');
 859                         break;
 860                 case __BLK_TA_FRONTMERGE:
 861                         account_m(t, pci, w);
 862                         log_merge(pci, t, 'F');
 863                         break;
 864                 case __BLK_TA_GETRQ:
 865                         log_track_getrq(t);
 866                         log_generic(pci, t, 'G');
 867                         break;
 868                 case __BLK_TA_SLEEPRQ:
 869                         log_generic(pci, t, 'S');
 870                         break;
 871                 case __BLK_TA_REQUEUE:
 872                         account_c(t, pci, w, -t->bytes);
 873                         log_queue(pci, t, 'R');
 874                         break;
 875                 case __BLK_TA_ISSUE:
 876                         account_i(t, pci, w);
 877                         log_issue(pci, t, 'D');
 878                         break;
 879                 case __BLK_TA_COMPLETE:
 880                         account_c(t, pci, w, t->bytes);
 881                         log_complete(pci, t, 'C');
 882                         break;
 883                 case __BLK_TA_PLUG:
 884                         log_generic(pci, t, 'P');
 885                         break;
 886                 case __BLK_TA_UNPLUG:
 887                         log_generic(pci, t, 'U');
 888                         break;
 889                 default:
 890                         fprintf(stderr, "Bad fs action %x\n", t->action);
 891                         break;
 892         }
 893 }
 894
 895 static int dump_trace(struct blk_io_trace *t, struct per_cpu_info *pci,
 896                         struct per_dev_info *pdi)
 897 {
 898         int ret = 0;
 899
 900         if (t->action & BLK_TC_ACT(BLK_TC_PC))
 901                 ret = dump_trace_pc(t, pci);
 902         else
 903                 dump_trace_fs(t, pci);
 904
 905         pdi->events++;
 906         return ret;
 907 }
 908
 909 static void dump_io_stats(struct io_stats *ios, char *msg)
 910 {
 911         fprintf(ofp, "%s\n", msg);
 912
 913         fprintf(ofp, " Reads Queued:    %'8lu, %'8LuKiB\t", ios->qreads, ios->qread_kb);
 914         fprintf(ofp, " Writes Queued:    %'8lu, %'8LuKiB\n", ios->qwrites,ios->qwrite_kb);
 915
 916         fprintf(ofp, " Read Dispatches: %'8lu, %'8LuKiB\t", ios->ireads, ios->iread_kb);
 917         fprintf(ofp, " Write Dispatches: %'8lu, %'8LuKiB\n", ios->iwrites,ios->iwrite_kb);
 918         fprintf(ofp, " Reads Completed: %'8lu, %'8LuKiB\t", ios->creads, ios->cread_kb);
 919         fprintf(ofp, " Writes Completed: %'8lu, %'8LuKiB\n", ios->cwrites,ios->cwrite_kb);
 920         fprintf(ofp, " Read Merges:     %'8lu%8c\t", ios->mreads, ' ');
 921
 922         fprintf(ofp, " Write Merges:     %'8lu\n", ios->mwrites);
 923 }
 924
 925 static void dump_wait_stats(struct per_process_info *ppi)
 926 {
 927         unsigned long rawait = ppi->longest_allocation_wait[0] / 1000;
 928         unsigned long rdwait = ppi->longest_dispatch_wait[0] / 1000;
 929         unsigned long rcwait = ppi->longest_completion_wait[0] / 1000;
 930         unsigned long wawait = ppi->longest_allocation_wait[1] / 1000;
 931         unsigned long wdwait = ppi->longest_dispatch_wait[1] / 1000;
 932         unsigned long wcwait = ppi->longest_completion_wait[1] / 1000;
 933
 934         fprintf(ofp, " Allocation wait: %'8lu%8c\t", rawait, ' ');
 935         fprintf(ofp, " Allocation wait:  %'8lu\n", wawait);
 936         fprintf(ofp, " Dispatch wait:   %'8lu%8c\t", rdwait, ' ');
 937         fprintf(ofp, " Dispatch wait:    %'8lu\n", wdwait);
 938         fprintf(ofp, " Completion wait: %'8lu%8c\t", rcwait, ' ');
 939         fprintf(ofp, " Completion wait:  %'8lu\n", wcwait);
 940 }
 941
 942 static void show_process_stats(void)
 943 {
 944         struct per_process_info *ppi;
 945
 946         ppi = ppi_list;
 947         while (ppi) {
 948                 dump_io_stats(&ppi->io_stats, ppi->name);
 949                 dump_wait_stats(ppi);
 950                 ppi = ppi->list_next;
 951         }
 952
 953         fprintf(ofp, "\n");
 954 }
 955
 956 static void show_device_and_cpu_stats(void)
 957 {
 958         struct per_dev_info *pdi;
 959         struct per_cpu_info *pci;
 960         struct io_stats total, *ios;
 961         int i, j, pci_events;
 962         char line[3 + 8/*cpu*/ + 2 + 32/*dev*/ + 3];
 963         char name[32];
 964
 965         for (pdi = devices, i = 0; i < ndevices; i++, pdi++) {
 966
 967                 memset(&total, 0, sizeof(total));
 968                 pci_events = 0;
 969
 970                 if (i > 0)
 971                         fprintf(ofp, "\n");
 972
 973                 for (pci = pdi->cpus, j = 0; j < pdi->ncpus; j++, pci++) {
 974                         if (!pci->nelems)
 975                                 continue;
 976
 977                         ios = &pci->io_stats;
 978                         total.qreads += ios->qreads;
 979                         total.qwrites += ios->qwrites;
 980                         total.creads += ios->creads;
 981                         total.cwrites += ios->cwrites;
 982                         total.mreads += ios->mreads;
 983                         total.mwrites += ios->mwrites;
 984                         total.ireads += ios->ireads;
 985                         total.iwrites += ios->iwrites;
 986                         total.qread_kb += ios->qread_kb;
 987                         total.qwrite_kb += ios->qwrite_kb;
 988                         total.cread_kb += ios->cread_kb;
 989                         total.cwrite_kb += ios->cwrite_kb;
 990                         total.iread_kb += ios->iread_kb;
 991                         total.iwrite_kb += ios->iwrite_kb;
 992
 993                         snprintf(line, sizeof(line) - 1, "CPU%d (%s):",
 994                                  j, get_dev_name(pdi, name, sizeof(name)));
 995                         dump_io_stats(ios, line);
 996                         pci_events++;
 997                 }
 998
 999                 if (pci_events > 1) {
1000                         fprintf(ofp, "\n");
1001                         snprintf(line, sizeof(line) - 1, "Total (%s):",
1002                                  get_dev_name(pdi, name, sizeof(name)));
1003                         dump_io_stats(&total, line);
1004                 }
1005
1006                 fprintf(ofp, "Events (%s): %'Lu\n",
1007                         get_dev_name(pdi, line, sizeof(line)), pdi->events);
1008         }
1009 }
1010
1011 static struct blk_io_trace *find_trace(void *p, unsigned long offset, int nr)
1012 {
1013         unsigned long max_offset = min(offset,nr * sizeof(struct blk_io_trace));
1014         unsigned long off;
1015         struct blk_io_trace *bit;
1016         __u32 magic;
1017
1018         for (off = 0; off < max_offset; off++) {
1019                 bit = p + off;
1020
1021                 magic = be32_to_cpu(bit->magic);
1022                 if ((magic & 0xffffff00) == BLK_IO_TRACE_MAGIC)
1023                         return bit;
1024         }
1025
1026         return NULL;
1027 }
1028
1029 static int sort_entries(void *traces, unsigned long offset, int nr,
1030                         struct per_dev_info *fpdi, struct per_cpu_info *fpci)
1031 {
1032         struct per_dev_info *pdi;
1033         struct per_cpu_info *pci;
1034         struct blk_io_trace *bit;
1035         struct trace *t;
1036         void *start = traces;
1037
1038         while (traces - start <= offset - sizeof(*bit)) {
1039                 if (!nr)
1040                         break;
1041
1042                 bit = find_trace(traces, offset - (traces - start), nr);
1043                 if (!bit)
1044                         break;
1045
1046                 t = malloc(sizeof(*t));
1047                 if (!t) {
1048                         fprintf(stderr, "Out of memory, seq %d on dev %d,%d\n",
1049                                 bit->sequence,
1050                                 MAJOR(bit->device), MINOR(bit->device));
1051                         return -1;
1052                 }
1053                 t->bit = bit;
1054                 memset(&t->rb_node, 0, sizeof(t->rb_node));
1055
1056                 trace_to_cpu(bit);
1057
1058                 if (verify_trace(bit)) {
1059                         free(t);
1060                         break;
1061                 }
1062
1063                 pdi = fpdi ? fpdi : get_dev_info(bit->device, 1);
1064                 pdi->id = bit->device;
1065                 pci = fpci ? fpci : get_cpu_info(pdi, bit->cpu);
1066                 pci->cpu = bit->cpu;
1067                 pci->nelems++;
1068
1069                 if (trace_rb_insert(t)) {
1070                         free(t);
1071                         return -1;
1072                 }
1073
1074                 traces += sizeof(*bit) + bit->pdu_len;
1075                 nr--;
1076         }
1077
1078         return 0;
1079 }
1080
1081 static void free_entries_rb(void)
1082 {
1083         struct rb_node *n;
1084
1085         while ((n = rb_first(&rb_sort_root)) != NULL) {
1086                 struct trace *t = rb_entry(n, struct trace, rb_node);
1087
1088                 rb_erase(&t->rb_node, &rb_sort_root);
1089                 free(t);
1090         }
1091 }
1092
1093 static void show_entries_rb(void)
1094 {
1095         struct per_dev_info *pdi;
1096         struct blk_io_trace *bit;
1097         struct rb_node *n;
1098         struct trace *t;
1099         int cpu;
1100
1101         n = rb_first(&rb_sort_root);
1102         if (!n)
1103                 return;
1104
1105         do {
1106                 t = rb_entry(n, struct trace, rb_node);
1107                 bit = t->bit;
1108
1109                 pdi = get_dev_info(bit->device, 0);
1110                 if (!pdi) {
1111                         fprintf(stderr, "Unknown device ID? (%d,%d)\n",
1112                                 MAJOR(bit->device), MINOR(bit->device));
1113                         break;
1114                 }
1115                 cpu = bit->cpu;
1116                 if (cpu > pdi->ncpus) {
1117                         fprintf(stderr, "Unknown CPU ID? (%d, device %d,%d)\n",
1118                                 cpu, MAJOR(bit->device), MINOR(bit->device));
1119                         break;
1120                 }
1121
1122                 bit->time -= genesis_time;
1123                 if (bit->time < stopwatch_start)
1124                         continue;
1125                 if (bit->time >= stopwatch_end)
1126                         break;
1127
1128                 check_time(pdi, bit);
1129
1130                 if (dump_trace(bit, &pdi->cpus[cpu], pdi))
1131                         break;
1132
1133         } while ((n = rb_next(n)) != NULL);
1134 }
1135
1136 static int read_data(int fd, void *buffer, int bytes, int block)
1137 {
1138         int ret, bytes_left, fl;
1139         void *p;
1140
1141         fl = fcntl(fd, F_GETFL);
1142
1143         if (!block)
1144                 fcntl(fd, F_SETFL, fl | O_NONBLOCK);
1145         else
1146                 fcntl(fd, F_SETFL, fl & ~O_NONBLOCK);
1147
1148         bytes_left = bytes;
1149         p = buffer;
1150         while (bytes_left > 0) {
1151                 ret = read(fd, p, bytes_left);
1152                 if (!ret)
1153                         return 1;
1154                 else if (ret < 0) {
1155                         if (errno != EAGAIN)
1156                                 perror("read");
1157                         return -1;
1158                 } else {
1159                         p += ret;
1160                         bytes_left -= ret;
1161                 }
1162         }
1163
1164         return 0;
1165 }
1166
1167 static int do_file(void)
1168 {
1169         struct per_dev_info *pdi;
1170         int i, j, nfiles = 0;
1171
1172         for (pdi = devices, i = 0; i < ndevices; i++, pdi++) {
1173                 for (j = 0;; j++, nfiles++) {
1174                         struct per_cpu_info *pci;
1175                         struct stat st;
1176                         void *tb;
1177
1178                         pci = get_cpu_info(pdi, j);
1179                         pci->cpu = j;
1180
1181                         snprintf(pci->fname, sizeof(pci->fname)-1,
1182                                  "%s_out.%d", pdi->name, j);
1183                         if (stat(pci->fname, &st) < 0)
1184                                 break;
1185                         if (!st.st_size)
1186                                 continue;
1187
1188                         printf("Processing %s\n", pci->fname);
1189
1190                         tb = malloc(st.st_size);
1191                         if (!tb) {
1192                                 fprintf(stderr, "Out of memory, skip file %s\n",
1193                                         pci->fname);
1194                                 continue;
1195                         }
1196
1197                         pci->fd = open(pci->fname, O_RDONLY);
1198                         if (pci->fd < 0) {
1199                                 perror(pci->fname);
1200                                 free(tb);
1201                                 continue;
1202                         }
1203
1204                         if (read_data(pci->fd, tb, st.st_size, 1)) {
1205                                 close(pci->fd);
1206                                 free(tb);
1207                                 continue;
1208                         }
1209
1210                         if (sort_entries(tb, st.st_size, ~0U, pdi, pci) == -1) {
1211                                 close(pci->fd);
1212                                 free(tb);
1213                                 continue;
1214                         }
1215
1216                         printf("Completed %s (CPU%d %d, entries)\n",
1217                                 pci->fname, j, pci->nelems);
1218                         close(pci->fd);
1219                 }
1220         }
1221
1222         if (!nfiles) {
1223                 fprintf(stderr, "No files found\n");
1224                 return 1;
1225         }
1226
1227         show_entries_rb();
1228         return 0;
1229 }
1230
1231 static void resize_buffer(void **buffer, long *size, long offset)
1232 {
1233         long old_size = *size;
1234
1235         if (*size == 0)
1236                 *size = 64 * sizeof(struct blk_io_trace);
1237
1238         *size *= 2;
1239         *buffer = realloc(*buffer, *size);
1240
1241         if (old_size)
1242                 memset(*buffer + offset, 0, *size - old_size);
1243 }
1244
1245 static int read_sort_events(int fd, void **buffer, long *max_offset)
1246 {
1247         long offset;
1248         int events;
1249
1250         events = offset = 0;
1251         do {
1252                 struct blk_io_trace *t;
1253                 int pdu_len;
1254                 __u32 magic;
1255
1256                 if (*max_offset - offset < sizeof(*t))
1257                         resize_buffer(buffer, max_offset, offset);
1258
1259                 if (read_data(fd, *buffer + offset, sizeof(*t), !events))
1260                         break;
1261
1262                 t = *buffer + offset;
1263                 offset += sizeof(*t);
1264
1265                 magic = be32_to_cpu(t->magic);
1266                 if ((magic & 0xffffff00) != BLK_IO_TRACE_MAGIC) {
1267                         fprintf(stderr, "Bad magic %x\n", magic);
1268                         break;
1269                 }
1270
1271                 pdu_len = be16_to_cpu(t->pdu_len);
1272                 if (pdu_len) {
1273                         if (*max_offset - offset <= pdu_len)
1274                                 resize_buffer(buffer, max_offset, offset);
1275
1276                         if (read_data(fd, *buffer + offset, pdu_len, 1))
1277                                 break;
1278
1279                         offset += pdu_len;
1280                 }
1281
1282                 events++;
1283         } while (!is_done() && events < rb_batch);
1284
1285         return events;
1286 }
1287
1288 static int do_stdin(void)
1289 {
1290         int fd;
1291         void *ptr = NULL;
1292         long max_offset;
1293
1294         fd = dup(STDIN_FILENO);
1295         max_offset = 0;
1296         do {
1297                 int events;
1298
1299                 events = read_sort_events(fd, &ptr, &max_offset);
1300                 if (!events)
1301                         break;
1302
1303                 if (sort_entries(ptr, ~0UL, events, NULL, NULL) == -1)
1304                         break;
1305
1306                 show_entries_rb();
1307                 free_entries_rb();
1308         } while (1);
1309
1310         if (ptr)
1311                 free(ptr);
1312
1313         close(fd);
1314         return 0;
1315 }
1316
1317 static void flush_output(void)
1318 {
1319         fflush(ofp);
1320 }
1321
1322 static void handle_sigint(int sig)
1323 {
1324         done = 1;
1325         flush_output();
1326 }
1327
1328 /*
1329  * Extract start and duration times from a string, allowing
1330  * us to specify a time interval of interest within a trace.
1331  * Format: "duration" (start is zero) or "start:duration".
1332  */
1333 static int find_stopwatch_interval(char *string)
1334 {
1335         double value;
1336         char *sp;
1337
1338         value = strtod(string, &sp);
1339         if (sp == string) {
1340                 fprintf(stderr,"Invalid stopwatch timer: %s\n", string);
1341                 return 1;
1342         }
1343         if (*sp == ':') {
1344                 stopwatch_start = DOUBLE_TO_NANO_ULL(value);
1345                 string = sp + 1;
1346                 value = strtod(string, &sp);
1347                 if (sp == string || *sp != '\0') {
1348                         fprintf(stderr,"Invalid stopwatch duration time: %s\n",
1349                                 string);
1350                         return 1;
1351                 }
1352         } else if (*sp != '\0') {
1353                 fprintf(stderr,"Invalid stopwatch start timer: %s\n", string);
1354                 return 1;
1355         }
1356         stopwatch_end = stopwatch_start + DOUBLE_TO_NANO_ULL(value);
1357         return 0;
1358 }
1359
1360 static void usage(char *prog)
1361 {
1362         fprintf(stderr, "Usage: %s "
1363                 "[-i <name>] [-o <output>] [-s] [-w N[:n]] <name>...\n",
1364                 prog);
1365 }
1366
1367 int main(int argc, char *argv[])
1368 {
1369         char *ofp_buffer;
1370         int c, ret, mode;
1371         int per_device_and_cpu_stats = 1;
1372
1373         while ((c = getopt_long(argc, argv, S_OPTS, l_opts, NULL)) != -1) {
1374                 switch (c) {
1375                 case 'i':
1376                         if (!strcmp(optarg, "-") && !pipeline)
1377                                 pipeline = 1;
1378                         else if (resize_devices(optarg) != 0)
1379                                 return 1;
1380                         break;
1381                 case 'o':
1382                         output_name = optarg;
1383                         break;
1384                 case 'b':
1385                         rb_batch = atoi(optarg);
1386                         if (rb_batch <= 0)
1387                                 rb_batch = RB_BATCH_DEFAULT;
1388                         break;
1389                 case 's':
1390                         per_process_stats = 1;
1391                         break;
1392                 case 't':
1393                         track_ios = 1;
1394                         break;
1395                 case 'q':
1396                         per_device_and_cpu_stats = 0;
1397                         break;
1398                 case 'w':
1399                         if (find_stopwatch_interval(optarg) != 0)
1400                                 return 1;
1401                         break;
1402                 default:
1403                         usage(argv[0]);
1404                         return 1;
1405                 }
1406         }
1407
1408         while (optind < argc) {
1409                 if (!strcmp(argv[optind], "-") && !pipeline)
1410                         pipeline = 1;
1411                 else if (resize_devices(argv[optind]) != 0)
1412                         return 1;
1413                 optind++;
1414         }
1415
1416         if (!pipeline && !ndevices) {
1417                 usage(argv[0]);
1418                 return 1;
1419         }
1420
1421         memset(&rb_sort_root, 0, sizeof(rb_sort_root));
1422         memset(&rb_track_root, 0, sizeof(rb_track_root));
1423
1424         signal(SIGINT, handle_sigint);
1425         signal(SIGHUP, handle_sigint);
1426         signal(SIGTERM, handle_sigint);
1427
1428         setlocale(LC_NUMERIC, "en_US");
1429
1430         if (!output_name) {
1431                 ofp = fdopen(STDOUT_FILENO, "w");
1432                 mode = _IOLBF;
1433         } else {
1434                 char ofname[128];
1435
1436                 snprintf(ofname, sizeof(ofname) - 1, "%s.log", output_name);
1437                 ofp = fopen(ofname, "w");
1438                 mode = _IOFBF;
1439         }
1440
1441         if (!ofp) {
1442                 perror("fopen");
1443                 return 1;
1444         }
1445
1446         ofp_buffer = malloc(4096);
1447         if (setvbuf(ofp, ofp_buffer, mode, 4096)) {
1448                 perror("setvbuf");
1449                 return 1;
1450         }
1451
1452         if (pipeline)
1453                 ret = do_stdin();
1454         else
1455                 ret = do_file();
1456
1457         if (per_process_stats)
1458                 show_process_stats();
1459
1460         if (per_device_and_cpu_stats)
1461                 show_device_and_cpu_stats();
1462
1463         flush_output();
1464         return ret;
1465 }