btreplay/btrecord.c

   1 /*
   2  * Blktrace record utility - Convert binary trace data into bunches of IOs
   3  *
   4  * Copyright (C) 2007 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 static char build_date[] = __DATE__ " at "__TIME__;
  22
  23 #include <assert.h>
  24 #include <fcntl.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29 #include <sys/param.h>
  30 #include <sys/stat.h>
  31 #include <sys/types.h>
  32 #include <dirent.h>
  33 #include <stdarg.h>
  34
  35 #if !defined(_GNU_SOURCE)
  36 #       define _GNU_SOURCE
  37 #endif
  38 #include <getopt.h>
  39
  40 #include "list.h"
  41 #include "btrecord.h"
  42 #include "blktrace.h"
  43
  44 /*
  45  * Per input file information
  46  *
  47  * @head:       Used to link up on input_files
  48  * @devnm:      Device name portion of this input file
  49  * @file_name:  Fully qualified name for this input file
  50  * @cpu:        CPU that this file was collected on
  51  * @ifd:        Input file descriptor (when opened)
  52  * @tpkts:      Total number of packets processed.
  53  */
  54 struct ifile_info {
  55         struct list_head head;
  56         char *devnm, *file_name;
  57         int cpu, ifd;
  58         __u64 tpkts, genesis;
  59 };
  60
  61 /*
  62  * Per IO trace information
  63  *
  64  * @time:       Time stamp when trace was emitted
  65  * @sector:     IO sector identifier
  66  * @bytes:      Number of bytes transferred
  67  * @rw:         Read (1) or write (0)
  68  */
  69 struct io_spec {
  70         __u64 time;
  71         __u64 sector;
  72         __u32 bytes;
  73         int rw;
  74 };
  75
  76 /*
  77  * Per output file information
  78  *
  79  * @ofp:        Output file
  80  * @vfp:        Verbose output file
  81  * @file_name:  Fully qualified name for this file
  82  * @vfn:        Fully qualified name for this file
  83  * @cur:        Current IO bunch being collected
  84  * @iip:        Input file this is associated with
  85  * @start_time: Start time of th ecurrent bunch
  86  * @last_time:  Time of last packet put in
  87  * @bunches:    Number of bunches processed
  88  * @pkts:       Number of packets stored in bunches
  89  */
  90 struct io_stream {
  91         FILE *ofp, *vfp;
  92         char *file_name, *vfn;
  93         struct io_bunch *cur;
  94         struct ifile_info *iip;
  95         __u64 start_time, last_time, bunches, pkts;
  96 };
  97
  98 int data_is_native;                             // Indicates whether to swap
  99 static LIST_HEAD(input_files);                  // List of all input files
 100 static char *idir = ".";                        // Input directory base
 101 static char *odir = ".";                        // Output directory base
 102 static char *obase = "replay";                  // Output file base
 103 static __u64 max_bunch_tm = (10 * 1000 * 1000); // 10 milliseconds
 104 static __u64 max_pkts_per_bunch = 8;            // Default # of pkts per bunch
 105 static int verbose = 0;                         // Boolean: output stats
 106 static int find_traces = 0;                     // Boolean: Find traces in dir
 107
 108 static char usage_str[] =                                                  \
 109         "\n"                                                               \
 110         "\t[ -d <dir>  : --input-directory=<dir> ] Default: .\n"           \
 111         "\t[ -D <dir>  : --output-directory=<dir>] Default: .\n"           \
 112         "\t[ -F        : --find-traces           ] Default: Off\n"         \
 113         "\t[ -h        : --help                  ] Default: Off\n"         \
 114         "\t[ -m <nsec> : --max-bunch-time=<nsec> ] Default: 10 msec\n"     \
 115         "\t[ -M <pkts> : --max-pkts=<pkts>       ] Default: 8\n"           \
 116         "\t[ -o <base> : --output-base=<base>    ] Default: replay\n"      \
 117         "\t[ -v        : --verbose               ] Default: Off\n"         \
 118         "\t[ -V        : --version               ] Default: Off\n"         \
 119         "\t<dev>...                                Default: None\n"        \
 120         "\n";
 121
 122 #define S_OPTS  "d:D:Fhm:M:o:vV"
 123 static struct option l_opts[] = {
 124         {
 125                 .name = "input-directory",
 126                 .has_arg = required_argument,
 127                 .flag = NULL,
 128                 .val = 'd'
 129         },
 130         {
 131                 .name = "output-directory",
 132                 .has_arg = required_argument,
 133                 .flag = NULL,
 134                 .val = 'D'
 135         },
 136         {
 137                 .name = "find-traces",
 138                 .has_arg = no_argument,
 139                 .flag = NULL,
 140                 .val = 'F'
 141         },
 142         {
 143                 .name = "help",
 144                 .has_arg = no_argument,
 145                 .flag = NULL,
 146                 .val = 'h'
 147         },
 148         {
 149                 .name = "max-bunch-time",
 150                 .has_arg = required_argument,
 151                 .flag = NULL,
 152                 .val = 'm'
 153         },
 154         {
 155                 .name = "max_pkts",
 156                 .has_arg = required_argument,
 157                 .flag = NULL,
 158                 .val = 'M'
 159         },
 160         {
 161                 .name = "output-base",
 162                 .has_arg = required_argument,
 163                 .flag = NULL,
 164                 .val = 'o'
 165         },
 166         {
 167                 .name = "verbose",
 168                 .has_arg = no_argument,
 169                 .flag = NULL,
 170                 .val = 'v'
 171         },
 172         {
 173                 .name = "version",
 174                 .has_arg = no_argument,
 175                 .flag = NULL,
 176                 .val = 'V'
 177         },
 178         {
 179                 .name = NULL
 180         }
 181 };
 182
 183 #define ERR_ARGS                        1
 184 #define ERR_SYSCALL                     2
 185 static inline void fatal(const char *errstring, const int exitval,
 186                          const char *fmt, ...)
 187 {
 188         va_list ap;
 189
 190         if (errstring)
 191                 perror(errstring);
 192
 193         va_start(ap, fmt);
 194         vfprintf(stderr, fmt, ap);
 195         va_end(ap);
 196
 197         exit(exitval);
 198         /*NOTREACHED*/
 199 }
 200
 201 /**
 202  * match - Return true if this trace is a proper QUEUE transaction
 203  * @action: Action field from trace
 204  */
 205 static inline int match(__u32 action)
 206 {
 207         return ((action & 0xffff) == __BLK_TA_QUEUE) &&
 208                                        (action & BLK_TC_ACT(BLK_TC_QUEUE));
 209 }
 210
 211 /**
 212  * usage - Display usage string and version
 213  */
 214 static void usage(void)
 215 {
 216         fprintf(stderr, "Usage: btrecord -- version %s\n%s",
 217                 my_btversion, usage_str);
 218 }
 219
 220 /**
 221  * write_file_hdr - Seek to and write btrecord file header
 222  * @stream: Output file information
 223  * @hdr: Header to write
 224  */
 225 static void write_file_hdr(struct io_stream *stream, struct io_file_hdr *hdr)
 226 {
 227         hdr->version = mk_btversion(btver_mjr, btver_mnr, btver_sub);
 228
 229         if (verbose) {
 230                 fprintf(stderr, "\t%s: %llx %llx %llx %llx\n",
 231                         stream->file_name,
 232                         (long long unsigned)hdr->version,
 233                         (long long unsigned)hdr->genesis,
 234                         (long long unsigned)hdr->nbunches,
 235                         (long long unsigned)hdr->total_pkts);
 236         }
 237
 238         fseek(stream->ofp, 0, SEEK_SET);
 239         if (fwrite(hdr, sizeof(*hdr), 1, stream->ofp) != 1) {
 240                 fatal(stream->file_name, ERR_SYSCALL, "Hdr write failed\n");
 241                 /*NOTREACHED*/
 242         }
 243 }
 244
 245 /**
 246  * io_bunch_create - Allocate & initialize an io_bunch
 247  * @io_stream: IO stream being added to
 248  * @pre_stall: Amount of time that this bunch should be delayed by
 249  * @start_time: Records current start
 250  */
 251 static inline void io_bunch_create(struct io_stream *stream, __u64 start_time)
 252 {
 253         struct io_bunch *cur = malloc(sizeof(*cur));
 254
 255         memset(cur, 0, sizeof(*cur));
 256
 257         cur->hdr.npkts = 0;
 258         cur->hdr.time_stamp = stream->start_time = start_time;
 259
 260         stream->cur = cur;
 261 }
 262
 263 /**
 264  * io_bunch_add - Add an IO to the current bunch of IOs
 265  * @stream: Per-output file stream information
 266  * @spec: IO trace specification
 267  *
 268  * Returns update bunch information
 269  */
 270 static void io_bunch_add(struct io_stream *stream, struct io_spec *spec)
 271 {
 272         struct io_bunch *cur = stream->cur;
 273         struct io_pkt iop = {
 274                 .sector = spec->sector,
 275                 .nbytes = spec->bytes,
 276                 .rw = spec->rw
 277         };
 278
 279         assert(cur != NULL);
 280         assert(cur->hdr.npkts < BT_MAX_PKTS);
 281         assert(stream->last_time == 0 || stream->last_time <= spec->time);
 282
 283         cur->pkts[cur->hdr.npkts++] = iop;      // Struct copy
 284         stream->last_time = spec->time;
 285 }
 286
 287 /**
 288  * rem_input_file - Release resources associated with an input file
 289  * @iip: Per-input file information
 290  */
 291 static void rem_input_file(struct ifile_info *iip)
 292 {
 293         list_del(&iip->head);
 294
 295         close(iip->ifd);
 296         free(iip->file_name);
 297         free(iip->devnm);
 298         free(iip);
 299 }
 300
 301 /**
 302  * __add_input_file - Allocate and initialize per-input file structure
 303  * @cpu: CPU for this file
 304  * @devnm: Device name for this file
 305  * @file_name: Fully qualifed input file name
 306  */
 307 static void __add_input_file(int cpu, char *devnm, char *file_name)
 308 {
 309         struct ifile_info *iip = malloc(sizeof(*iip));
 310
 311         iip->cpu = cpu;
 312         iip->tpkts = 0;
 313         iip->genesis = 0;
 314         iip->devnm = strdup(devnm);
 315         iip->file_name = strdup(file_name);
 316         iip->ifd = open(file_name, O_RDONLY);
 317         if (iip->ifd < 0) {
 318                 fatal(file_name, ERR_ARGS, "Unable to open\n");
 319                 /*NOTREACHED*/
 320         }
 321
 322         list_add_tail(&iip->head, &input_files);
 323 }
 324
 325 /**
 326  * add_input_file - Set up the input file name
 327  * @devnm: Device name to use
 328  */
 329 static void add_input_file(char *devnm)
 330 {
 331         struct list_head *p;
 332         int cpu, found = 0;
 333
 334         __list_for_each(p, &input_files) {
 335                 struct ifile_info *iip = list_entry(p, struct ifile_info, head);
 336                 if (strcmp(iip->devnm, devnm) == 0)
 337                         return;
 338         }
 339
 340         for (cpu = 0; ; cpu++) {
 341                 char full_name[MAXPATHLEN];
 342
 343                 sprintf(full_name, "%s/%s.blktrace.%d", idir, devnm, cpu);
 344                 if (access(full_name, R_OK) != 0)
 345                         break;
 346
 347                 __add_input_file(cpu, devnm, full_name);
 348                 found++;
 349         }
 350
 351         if (!found) {
 352                 fatal(NULL, ERR_ARGS, "No traces found for %s\n", devnm);
 353                 /*NOTREACHED*/
 354         }
 355 }
 356
 357 static void find_input_files(char *idir)
 358 {
 359         struct dirent *ent;
 360         DIR *dir = opendir(idir);
 361
 362         if (dir == NULL) {
 363                 fatal(idir, ERR_ARGS, "Unable to open %s\n", idir);
 364                 /*NOTREACHED*/
 365         }
 366
 367         while ((ent = readdir(dir)) != NULL) {
 368                 char *p, *dsf = malloc(256);
 369
 370                 if (strstr(ent->d_name, ".blktrace.") == NULL)
 371                         continue;
 372
 373                 dsf = strdup(ent->d_name);
 374                 p = index(dsf, '.');
 375                 assert(p != NULL);
 376                 *p = '\0';
 377                 add_input_file(dsf);
 378                 free(dsf);
 379         }
 380
 381         closedir(dir);
 382 }
 383
 384 /**
 385  * handle_args - Parse passed in argument list
 386  * @argc: Number of arguments in argv
 387  * @argv: Arguments passed in
 388  *
 389  * Does rudimentary parameter verification as well.
 390  */
 391 void handle_args(int argc, char *argv[])
 392 {
 393         int c;
 394
 395         while ((c = getopt_long(argc, argv, S_OPTS, l_opts, NULL)) != -1) {
 396                 switch (c) {
 397                 case 'd':
 398                         idir = optarg;
 399                         if (access(idir, R_OK | X_OK) != 0) {
 400                                 fatal(idir, ERR_ARGS,
 401                                       "Invalid input directory specified\n");
 402                                 /*NOTREACHED*/
 403                         }
 404                         break;
 405
 406                 case 'D':
 407                         odir = optarg;
 408                         if (access(odir, R_OK | X_OK) != 0) {
 409                                 fatal(odir, ERR_ARGS,
 410                                       "Invalid output directory specified\n");
 411                                 /*NOTREACHED*/
 412                         }
 413                         break;
 414
 415                 case 'F':
 416                         find_traces = 1;
 417                         break;
 418
 419                 case 'h':
 420                         usage();
 421                         exit(0);
 422                         /*NOTREACHED*/
 423
 424                 case 'm':
 425                         max_bunch_tm = (__u64)atoll(optarg);
 426                         if (max_bunch_tm < 1) {
 427                                 fprintf(stderr, "Invalid bunch time %llu\n",
 428                                         (unsigned long long)max_bunch_tm);
 429                                 exit(ERR_ARGS);
 430                                 /*NOTREACHED*/
 431                         }
 432                         break;
 433
 434                 case 'M':
 435                         max_pkts_per_bunch = (__u64)atoll(optarg);
 436                         if (!((1 <= max_pkts_per_bunch) &&
 437                                                 (max_pkts_per_bunch < 513))) {
 438                                 fprintf(stderr, "Invalid max pkts %llu\n",
 439                                         (unsigned long long)max_pkts_per_bunch);
 440                                 exit(ERR_ARGS);
 441                                 /*NOTREACHED*/
 442                         }
 443                         break;
 444
 445                 case 'o':
 446                         obase = optarg;
 447                         break;
 448
 449                 case 'V':
 450                         fprintf(stderr, "btrecord -- version %s\n",
 451                                 my_btversion);
 452                         fprintf(stderr, "            Built on %s\n", build_date);
 453                         exit(0);
 454                         /*NOTREACHED*/
 455
 456                 case 'v':
 457                         verbose++;
 458                         break;
 459
 460                 default:
 461                         usage();
 462                         fatal(NULL, ERR_ARGS, "Invalid command line\n");
 463                         /*NOTREACHED*/
 464                 }
 465         }
 466
 467         while (optind < argc)
 468                 add_input_file(argv[optind++]);
 469
 470         if (find_traces)
 471                 find_input_files(idir);
 472
 473         if (list_len(&input_files) == 0) {
 474                 fatal(NULL, ERR_ARGS, "Missing required input file name(s)\n");
 475                 /*NOTREACHED*/
 476         }
 477 }
 478
 479 /**
 480  * next_io - Retrieve next Q trace from input stream
 481  * @iip: Per-input file information
 482  * @spec: IO specifier for trace
 483  *
 484  * Returns 0 on end of file, 1 if valid data returned.
 485  */
 486 static int next_io(struct ifile_info *iip, struct io_spec *spec)
 487 {
 488         ssize_t ret;
 489         __u32 action;
 490         __u16 pdu_len;
 491         struct blk_io_trace t;
 492
 493 again:
 494         ret = read(iip->ifd, &t, sizeof(t));
 495         if (ret < 0) {
 496                 fatal(iip->file_name, ERR_SYSCALL, "Read failed\n");
 497                 /*NOTREACHED*/
 498         }
 499         else if (ret == 0)
 500                 return 0;
 501         else if (ret < (ssize_t)sizeof(t)) {
 502                 fprintf(stderr, "WARNING: Short read on %s (%d)\n",
 503                         iip->file_name, (int)ret);
 504                 return 0;
 505         }
 506
 507         if (data_is_native == -1)
 508                 check_data_endianness(t.magic);
 509
 510         assert(data_is_native >= 0);
 511         if (data_is_native) {
 512                 spec->time = t.time;
 513                 spec->sector = t.sector;
 514                 spec->bytes = t.bytes;
 515                 action = t.action;
 516                 pdu_len = t.pdu_len;
 517         }
 518         else {
 519                 spec->time = be64_to_cpu(t.time);
 520                 spec->sector = be64_to_cpu(t.sector);
 521                 spec->bytes = be32_to_cpu(t.bytes);
 522                 action = be32_to_cpu(t.action);
 523                 pdu_len = be16_to_cpu(t.pdu_len);
 524         }
 525
 526
 527         if (pdu_len) {
 528                 char buf[pdu_len];
 529
 530                 ret = read(iip->ifd, buf, pdu_len);
 531                 if (ret < 0) {
 532                         fatal(iip->file_name, ERR_SYSCALL, "Read PDU failed\n");
 533                         /*NOTREACHED*/
 534                 }
 535                 else if (ret < (ssize_t)pdu_len) {
 536                         fprintf(stderr, "WARNING: Short PDU read on %s (%d)\n",
 537                                 iip->file_name, (int)ret);
 538                         return 0;
 539                 }
 540         }
 541
 542         iip->tpkts++;
 543         if (!match(action))
 544                 goto again;
 545
 546         spec->rw = (action & BLK_TC_ACT(BLK_TC_READ)) ? 1 : 0;
 547         if (verbose > 1)
 548                 fprintf(stderr, "%2d: %10llu+%10llu (%d) @ %10llx\n",
 549                         iip->cpu, (long long unsigned)spec->sector,
 550                         (long long unsigned)spec->bytes / 512LLU,
 551                         spec->rw, (long long unsigned)spec->time);
 552
 553         if (iip->genesis == 0) {
 554                 iip->genesis = spec->time;
 555                 if (verbose > 1)
 556                         fprintf(stderr, "\tSetting new genesis: %llx(%d)\n",
 557                                 (long long unsigned)iip->genesis, iip->cpu);
 558         }
 559         else if (iip->genesis > spec->time)
 560                 fatal(NULL, ERR_SYSCALL,
 561                         "Time inversion? %llu ... %llu\n",
 562                         (long long unsigned )iip->genesis,
 563                         (long long unsigned )spec->time);
 564
 565         return 1;
 566 }
 567
 568 /**
 569  * bunch_output_hdr - Output bunch header
 570  */
 571 static inline void bunch_output_hdr(struct io_stream *stream)
 572 {
 573         struct io_bunch_hdr *hdrp = &stream->cur->hdr;
 574
 575         assert(0 < hdrp->npkts && hdrp->npkts <= BT_MAX_PKTS);
 576         if (fwrite(hdrp, sizeof(struct io_bunch_hdr), 1, stream->ofp) != 1) {
 577                 fatal(stream->file_name, ERR_SYSCALL, "fwrite(hdr) failed\n");
 578                 /*NOTREACHED*/
 579         }
 580
 581         if (verbose) {
 582                 __u64 off = hdrp->time_stamp - stream->iip->genesis;
 583
 584                 assert(stream->vfp);
 585                 fprintf(stream->vfp, "------------------\n");
 586                 fprintf(stream->vfp, "%4llu.%09llu %3llu\n",
 587                         (unsigned long long)off / (1000 * 1000 * 1000),
 588                         (unsigned long long)off % (1000 * 1000 * 1000),
 589                         (unsigned long long)hdrp->npkts);
 590                 fprintf(stream->vfp, "------------------\n");
 591         }
 592 }
 593
 594 /**
 595  * bunch_output_pkt - Output IO packets
 596  */
 597 static inline void bunch_output_pkts(struct io_stream *stream)
 598 {
 599         struct io_pkt *p = stream->cur->pkts;
 600         size_t npkts = stream->cur->hdr.npkts;
 601
 602         assert(0 < npkts && npkts <= BT_MAX_PKTS);
 603         if (fwrite(p, sizeof(struct io_pkt), npkts, stream->ofp) != npkts) {
 604                 fatal(stream->file_name, ERR_SYSCALL, "fwrite(pkts) failed\n");
 605                 /*NOTREACHED*/
 606         }
 607
 608         if (verbose) {
 609                 size_t i;
 610
 611                 assert(stream->vfp);
 612                 for (i = 0; i < npkts; i++, p++)
 613                         fprintf(stream->vfp, "\t%1d %10llu\t%10llu\n",
 614                                 p->rw,
 615                                 (unsigned long long)p->sector,
 616                                 (unsigned long long)p->nbytes / 512);
 617         }
 618 }
 619
 620 /**
 621  * stream_flush - Flush current bunch of IOs out to the output stream
 622  * @stream: Per-output file stream information
 623  */
 624 static void stream_flush(struct io_stream *stream)
 625 {
 626         struct io_bunch *cur = stream->cur;
 627
 628         if (cur) {
 629                 if (cur->hdr.npkts) {
 630                         assert(cur->hdr.npkts <= BT_MAX_PKTS);
 631                         bunch_output_hdr(stream);
 632                         bunch_output_pkts(stream);
 633
 634                         stream->bunches++;
 635                         stream->pkts += cur->hdr.npkts;
 636                 }
 637                 free(cur);
 638         }
 639 }
 640
 641 /**
 642  * bunch_done - Returns true if current bunch is either full, or next IO is late
 643  * @stream: Output stream information
 644  * @spec: IO trace specification
 645  */
 646 static inline int bunch_done(struct io_stream *stream, struct io_spec *spec)
 647 {
 648         if (stream->cur->hdr.npkts >= max_pkts_per_bunch)
 649                 return 1;
 650
 651         if ((spec->time - stream->start_time) > max_bunch_tm)
 652                 return 1;
 653
 654         return 0;
 655 }
 656
 657 /**
 658  * stream_add_io - Add an IO trace to the current stream
 659  * @stream: Output stream information
 660  * @spec: IO trace specification
 661  */
 662 static void stream_add_io(struct io_stream *stream, struct io_spec *spec)
 663 {
 664
 665         if (stream->cur == NULL)
 666                 io_bunch_create(stream, spec->time);
 667         else if (bunch_done(stream, spec)) {
 668                 stream_flush(stream);
 669                 io_bunch_create(stream, spec->time);
 670         }
 671
 672         io_bunch_add(stream, spec);
 673 }
 674
 675 /**
 676  * stream_open - Open output stream for specified input stream
 677  * @iip: Per-input file information
 678  */
 679 static struct io_stream *stream_open(struct ifile_info *iip)
 680 {
 681         char ofile_name[MAXPATHLEN];
 682         struct io_stream *stream = malloc(sizeof(*stream));
 683         struct io_file_hdr io_file_hdr = {
 684                 .genesis = 0,
 685                 .nbunches = 0,
 686                 .total_pkts = 0
 687         };
 688
 689         memset(stream, 0, sizeof(*stream));
 690
 691         sprintf(ofile_name, "%s/%s.%s.%d", odir, iip->devnm, obase, iip->cpu);
 692         stream->ofp = fopen(ofile_name, "w");
 693         if (!stream->ofp) {
 694                 fatal(ofile_name, ERR_SYSCALL, "Open failed\n");
 695                 /*NOTREACHED*/
 696         }
 697
 698         stream->iip = iip;
 699         stream->cur = NULL;
 700         stream->bunches = stream->pkts = 0;
 701         stream->last_time = 0;
 702         stream->file_name = strdup(ofile_name);
 703
 704         write_file_hdr(stream, &io_file_hdr);
 705
 706         if (verbose) {
 707                 char vfile_name[MAXPATHLEN];
 708
 709                 sprintf(vfile_name, "%s/%s.%s.%d.rec", odir, iip->devnm,
 710                         obase, iip->cpu);
 711                 stream->vfp = fopen(vfile_name, "w");
 712                 if (!stream->vfp) {
 713                         fatal(vfile_name, ERR_SYSCALL, "Open failed\n");
 714                         /*NOTREACHED*/
 715                 }
 716
 717                 stream->vfn = strdup(vfile_name);
 718         }
 719
 720         data_is_native = -1;
 721         return stream;
 722 }
 723
 724 /**
 725  * stream_close - Release resources associated with an output stream
 726  * @stream: Stream to release
 727  */
 728 static void stream_close(struct io_stream *stream)
 729 {
 730         struct io_file_hdr io_file_hdr = {
 731                 .genesis = stream->iip->genesis,
 732                 .nbunches = stream->bunches,
 733                 .total_pkts = stream->pkts
 734         };
 735
 736         stream_flush(stream);
 737         write_file_hdr(stream, &io_file_hdr);
 738         fclose(stream->ofp);
 739
 740         if (verbose && stream->bunches) {
 741                 fprintf(stderr,
 742                         "%s:%d: %llu pkts (tot), %llu pkts (replay), "
 743                                         "%llu bunches, %.1lf pkts/bunch\n",
 744                         stream->iip->devnm, stream->iip->cpu,
 745                         (unsigned long long)stream->iip->tpkts,
 746                         (unsigned long long)stream->pkts,
 747                         (unsigned long long)stream->bunches,
 748                         (double)(stream->pkts) / (double)(stream->bunches));
 749
 750                 fclose(stream->vfp);
 751                 free(stream->vfn);
 752         }
 753
 754         free(stream->file_name);
 755         free(stream);
 756 }
 757
 758 /**
 759  * process - Process one input file to an output file
 760  * @iip: Per-input file information
 761  */
 762 static void process(struct ifile_info *iip)
 763 {
 764         struct io_spec spec;
 765         struct io_stream *stream;
 766
 767         stream = stream_open(iip);
 768         while (next_io(iip, &spec))
 769                 stream_add_io(stream, &spec);
 770         stream_close(stream);
 771
 772         rem_input_file(iip);
 773 }
 774
 775 /**
 776  * main -
 777  * @argc: Number of arguments
 778  * @argv: Array of arguments
 779  */
 780 int main(int argc, char *argv[])
 781 {
 782         struct list_head *p, *q;
 783
 784         handle_args(argc, argv);
 785         list_for_each_safe(p, q, &input_files)
 786                 process(list_entry(p, struct ifile_info, head));
 787
 788         return 0;
 789 }