init.c

   1 /*
   2  * This file contains job initialization and setup functions.
   3  */
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <unistd.h>
   7 #include <fcntl.h>
   8 #include <ctype.h>
   9 #include <string.h>
  10 #include <errno.h>
  11 #include <getopt.h>
  12 #include <sys/ipc.h>
  13 #include <sys/shm.h>
  14 #include <sys/types.h>
  15 #include <sys/stat.h>
  16
  17 #include "fio.h"
  18 #include "parse.h"
  19
  20 static char fio_version_string[] = "fio 1.14a";
  21
  22 #define FIO_RANDSEED            (0xb1899bedUL)
  23
  24 static char **ini_file;
  25 static int max_jobs = MAX_JOBS;
  26
  27 struct thread_data def_thread;
  28 struct thread_data *threads = NULL;
  29
  30 int exitall_on_terminate = 0;
  31 int terse_output = 0;
  32 unsigned long long mlock_size = 0;
  33 FILE *f_out = NULL;
  34 FILE *f_err = NULL;
  35
  36 int write_bw_log = 0;
  37
  38 static int def_timeout = 0;
  39 static int write_lat_log = 0;
  40
  41 static int prev_group_jobs;
  42
  43 /*
  44  * Command line options. These will contain the above, plus a few
  45  * extra that only pertain to fio itself and not jobs.
  46  */
  47 static struct option long_options[FIO_NR_OPTIONS] = {
  48         {
  49                 .name           = "output",
  50                 .has_arg        = required_argument,
  51                 .val            = 'o',
  52         },
  53         {
  54                 .name           = "timeout",
  55                 .has_arg        = required_argument,
  56                 .val            = 't',
  57         },
  58         {
  59                 .name           = "latency-log",
  60                 .has_arg        = required_argument,
  61                 .val            = 'l',
  62         },
  63         {
  64                 .name           = "bandwidth-log",
  65                 .has_arg        = required_argument,
  66                 .val            = 'b',
  67         },
  68         {
  69                 .name           = "minimal",
  70                 .has_arg        = optional_argument,
  71                 .val            = 'm',
  72         },
  73         {
  74                 .name           = "version",
  75                 .has_arg        = no_argument,
  76                 .val            = 'v',
  77         },
  78         {
  79                 .name           = "help",
  80                 .has_arg        = no_argument,
  81                 .val            = 'h',
  82         },
  83         {
  84                 .name           = "cmdhelp",
  85                 .has_arg        = optional_argument,
  86                 .val            = 'c',
  87         },
  88         {
  89                 .name           = NULL,
  90         },
  91 };
  92
  93 FILE *get_f_out()
  94 {
  95         return f_out;
  96 }
  97
  98 FILE *get_f_err()
  99 {
 100         return f_err;
 101 }
 102
 103 /*
 104  * Return a free job structure.
 105  */
 106 static struct thread_data *get_new_job(int global, struct thread_data *parent)
 107 {
 108         struct thread_data *td;
 109
 110         if (global)
 111                 return &def_thread;
 112         if (thread_number >= max_jobs)
 113                 return NULL;
 114
 115         td = &threads[thread_number++];
 116         *td = *parent;
 117
 118         td->thread_number = thread_number;
 119         return td;
 120 }
 121
 122 static void put_job(struct thread_data *td)
 123 {
 124         if (td == &def_thread)
 125                 return;
 126
 127         if (td->error)
 128                 log_info("fio: %s\n", td->verror);
 129
 130         memset(&threads[td->thread_number - 1], 0, sizeof(*td));
 131         thread_number--;
 132 }
 133
 134 static int setup_rate(struct thread_data *td)
 135 {
 136         unsigned long nr_reads_per_msec;
 137         unsigned long long rate;
 138         unsigned int bs;
 139
 140         if (!td->rate && !td->rate_iops)
 141                 return 0;
 142
 143         if (td_rw(td))
 144                 bs = td->rw_min_bs;
 145         else if (td_read(td))
 146                 bs = td->min_bs[DDIR_READ];
 147         else
 148                 bs = td->min_bs[DDIR_WRITE];
 149
 150         if (td->rate) {
 151                 rate = td->rate;
 152                 nr_reads_per_msec = (rate * 1024 * 1000LL) / bs;
 153         } else
 154                 nr_reads_per_msec = td->rate_iops * 1000UL;
 155
 156         if (!nr_reads_per_msec) {
 157                 log_err("rate lower than supported\n");
 158                 return -1;
 159         }
 160
 161         td->rate_usec_cycle = 1000000000ULL / nr_reads_per_msec;
 162         td->rate_pending_usleep = 0;
 163         return 0;
 164 }
 165
 166 /*
 167  * Lazy way of fixing up options that depend on each other. We could also
 168  * define option callback handlers, but this is easier.
 169  */
 170 static int fixup_options(struct thread_data *td)
 171 {
 172         if (!td->rwmixread && td->rwmixwrite)
 173                 td->rwmixread = 100 - td->rwmixwrite;
 174
 175         if (td->write_iolog_file && td->read_iolog_file) {
 176                 log_err("fio: read iolog overrides write_iolog\n");
 177                 free(td->write_iolog_file);
 178                 td->write_iolog_file = NULL;
 179         }
 180
 181         if (td->io_ops->flags & FIO_SYNCIO)
 182                 td->iodepth = 1;
 183         else {
 184                 if (!td->iodepth)
 185                         td->iodepth = td->open_files;
 186         }
 187
 188         /*
 189          * only really works for sequential io for now, and with 1 file
 190          */
 191         if (td->zone_size && td_random(td) && td->open_files == 1)
 192                 td->zone_size = 0;
 193
 194         /*
 195          * Reads can do overwrites, we always need to pre-create the file
 196          */
 197         if (td_read(td) || td_rw(td))
 198                 td->overwrite = 1;
 199
 200         if (!td->min_bs[DDIR_READ])
 201                 td->min_bs[DDIR_READ]= td->bs[DDIR_READ];
 202         if (!td->max_bs[DDIR_READ])
 203                 td->max_bs[DDIR_READ] = td->bs[DDIR_READ];
 204         if (!td->min_bs[DDIR_WRITE])
 205                 td->min_bs[DDIR_WRITE]= td->bs[DDIR_WRITE];
 206         if (!td->max_bs[DDIR_WRITE])
 207                 td->max_bs[DDIR_WRITE] = td->bs[DDIR_WRITE];
 208
 209         td->rw_min_bs = min(td->min_bs[DDIR_READ], td->min_bs[DDIR_WRITE]);
 210
 211         if (!td->file_size_high)
 212                 td->file_size_high = td->file_size_low;
 213
 214         if (td_read(td) && !td_rw(td))
 215                 td->verify = 0;
 216
 217         if (td->norandommap && td->verify != VERIFY_NONE) {
 218                 log_err("fio: norandommap given, verify disabled\n");
 219                 td->verify = VERIFY_NONE;
 220         }
 221         if (td->bs_unaligned && (td->odirect || td->io_ops->flags & FIO_RAWIO))
 222                 log_err("fio: bs_unaligned may not work with raw io\n");
 223
 224         /*
 225          * thinktime_spin must be less than thinktime
 226          */
 227         if (td->thinktime_spin > td->thinktime)
 228                 td->thinktime_spin = td->thinktime;
 229
 230         /*
 231          * The low water mark cannot be bigger than the iodepth
 232          */
 233         if (td->iodepth_low > td->iodepth || !td->iodepth_low) {
 234                 /*
 235                  * syslet work around - if the workload is sequential,
 236                  * we want to let the queue drain all the way down to
 237                  * avoid seeking between async threads
 238                  */
 239                 if (!strcmp(td->io_ops->name, "syslet-rw") && !td_random(td))
 240                         td->iodepth_low = 1;
 241                 else
 242                         td->iodepth_low = td->iodepth;
 243         }
 244
 245         /*
 246          * If batch number isn't set, default to the same as iodepth
 247          */
 248         if (td->iodepth_batch > td->iodepth || !td->iodepth_batch)
 249                 td->iodepth_batch = td->iodepth;
 250
 251         if (td->nr_files > td->files_index)
 252                 td->nr_files = td->files_index;
 253
 254         if (td->open_files > td->nr_files || !td->open_files)
 255                 td->open_files = td->nr_files;
 256
 257         if ((td->rate && td->rate_iops) || (td->ratemin && td->rate_iops_min)) {
 258                 log_err("fio: rate and rate_iops are mutually exclusive\n");
 259                 return 1;
 260         }
 261         if ((td->rate < td->ratemin) || (td->rate_iops < td->rate_iops_min)) {
 262                 log_err("fio: minimum rate exceeds rate\n");
 263                 return 1;
 264         }
 265
 266         return 0;
 267 }
 268
 269 /*
 270  * This function leaks the buffer
 271  */
 272 static char *to_kmg(unsigned int val)
 273 {
 274         char *buf = malloc(32);
 275         char post[] = { 0, 'K', 'M', 'G', 'P', 'E', 0 };
 276         char *p = post;
 277
 278         do {
 279                 if (val & 1023)
 280                         break;
 281
 282                 val >>= 10;
 283                 p++;
 284         } while (*p);
 285
 286         snprintf(buf, 31, "%u%c", val, *p);
 287         return buf;
 288 }
 289
 290 /* External engines are specified by "external:name.o") */
 291 static const char *get_engine_name(const char *str)
 292 {
 293         char *p = strstr(str, ":");
 294
 295         if (!p)
 296                 return str;
 297
 298         p++;
 299         strip_blank_front(&p);
 300         strip_blank_end(p);
 301         return p;
 302 }
 303
 304 static int exists_and_not_file(const char *filename)
 305 {
 306         struct stat sb;
 307
 308         if (lstat(filename, &sb) == -1)
 309                 return 0;
 310
 311         if (S_ISREG(sb.st_mode))
 312                 return 0;
 313
 314         return 1;
 315 }
 316
 317 /*
 318  * Initialize the various random states we need (random io, block size ranges,
 319  * read/write mix, etc).
 320  */
 321 static int init_random_state(struct thread_data *td)
 322 {
 323         unsigned long seeds[6];
 324         int fd, num_maps, blocks;
 325         struct fio_file *f;
 326         unsigned int i;
 327
 328         fd = open("/dev/urandom", O_RDONLY);
 329         if (fd == -1) {
 330                 td_verror(td, errno, "open");
 331                 return 1;
 332         }
 333
 334         if (read(fd, seeds, sizeof(seeds)) < (int) sizeof(seeds)) {
 335                 td_verror(td, EIO, "read");
 336                 close(fd);
 337                 return 1;
 338         }
 339
 340         close(fd);
 341
 342         os_random_seed(seeds[0], &td->bsrange_state);
 343         os_random_seed(seeds[1], &td->verify_state);
 344         os_random_seed(seeds[2], &td->rwmix_state);
 345
 346         if (td->file_service_type == FIO_FSERVICE_RANDOM)
 347                 os_random_seed(seeds[3], &td->next_file_state);
 348
 349         os_random_seed(seeds[5], &td->file_size_state);
 350
 351         if (!td_random(td))
 352                 return 0;
 353
 354         if (td->rand_repeatable)
 355                 seeds[4] = FIO_RANDSEED * td->thread_number;
 356
 357         if (!td->norandommap) {
 358                 for_each_file(td, f, i) {
 359                         blocks = (f->real_file_size + td->rw_min_bs - 1) / td->rw_min_bs;
 360                         num_maps = (blocks + BLOCKS_PER_MAP-1)/ BLOCKS_PER_MAP;
 361                         f->file_map = malloc(num_maps * sizeof(long));
 362                         if (!f->file_map) {
 363                                 log_err("fio: failed allocating random map. If running a large number of jobs, try the 'norandommap' option\n");
 364                                 return 1;
 365                         }
 366                         f->num_maps = num_maps;
 367                         memset(f->file_map, 0, num_maps * sizeof(long));
 368                 }
 369         }
 370
 371         os_random_seed(seeds[4], &td->random_state);
 372         return 0;
 373 }
 374
 375
 376 /*
 377  * Adds a job to the list of things todo. Sanitizes the various options
 378  * to make sure we don't have conflicts, and initializes various
 379  * members of td.
 380  */
 381 static int add_job(struct thread_data *td, const char *jobname, int job_add_num)
 382 {
 383         const char *ddir_str[] = { NULL, "read", "write", "rw", NULL,
 384                                    "randread", "randwrite", "randrw" };
 385         unsigned int i;
 386         struct fio_file *f;
 387         const char *engine;
 388         char fname[PATH_MAX];
 389         int numjobs, file_alloced;
 390
 391         /*
 392          * the def_thread is just for options, it's not a real job
 393          */
 394         if (td == &def_thread)
 395                 return 0;
 396
 397         engine = get_engine_name(td->ioengine);
 398         td->io_ops = load_ioengine(td, engine);
 399         if (!td->io_ops) {
 400                 log_err("fio: failed to load engine %s\n", engine);
 401                 goto err;
 402         }
 403
 404         if (td->use_thread)
 405                 nr_thread++;
 406         else
 407                 nr_process++;
 408
 409         if (td->odirect)
 410                 td->io_ops->flags |= FIO_RAWIO;
 411
 412         file_alloced = 0;
 413         if (!td->filename && !td->files_index) {
 414                 file_alloced = 1;
 415
 416                 if (td->nr_files == 1 && exists_and_not_file(jobname))
 417                         add_file(td, jobname);
 418                 else {
 419                         for (i = 0; i < td->nr_files; i++) {
 420                                 sprintf(fname, "%s.%d.%d", jobname, td->thread_number, i);
 421                                 add_file(td, fname);
 422                         }
 423                 }
 424         }
 425
 426         if (fixup_options(td))
 427                 goto err;
 428
 429         for_each_file(td, f, i) {
 430                 if (td->directory && f->filetype == FIO_TYPE_FILE) {
 431                         sprintf(fname, "%s/%s", td->directory, f->file_name);
 432                         f->file_name = strdup(fname);
 433                 }
 434         }
 435
 436         td->mutex = fio_sem_init(0);
 437
 438         td->ts.clat_stat[0].min_val = td->ts.clat_stat[1].min_val = ULONG_MAX;
 439         td->ts.slat_stat[0].min_val = td->ts.slat_stat[1].min_val = ULONG_MAX;
 440         td->ts.bw_stat[0].min_val = td->ts.bw_stat[1].min_val = ULONG_MAX;
 441
 442         if ((td->stonewall || td->numjobs > 1) && prev_group_jobs) {
 443                 prev_group_jobs = 0;
 444                 groupid++;
 445         }
 446
 447         td->groupid = groupid;
 448         prev_group_jobs++;
 449
 450         if (init_random_state(td))
 451                 goto err;
 452
 453         if (setup_rate(td))
 454                 goto err;
 455
 456         if (td->write_lat_log) {
 457                 setup_log(&td->ts.slat_log);
 458                 setup_log(&td->ts.clat_log);
 459         }
 460         if (td->write_bw_log)
 461                 setup_log(&td->ts.bw_log);
 462
 463         if (!td->name)
 464                 td->name = strdup(jobname);
 465
 466         if (!terse_output) {
 467                 if (!job_add_num) {
 468                         if (!strcmp(td->io_ops->name, "cpuio"))
 469                                 log_info("%s: ioengine=cpu, cpuload=%u, cpucycle=%u\n", td->name, td->cpuload, td->cpucycle);
 470                         else {
 471                                 char *c1, *c2, *c3, *c4;
 472
 473                                 c1 = to_kmg(td->min_bs[DDIR_READ]);
 474                                 c2 = to_kmg(td->max_bs[DDIR_READ]);
 475                                 c3 = to_kmg(td->min_bs[DDIR_WRITE]);
 476                                 c4 = to_kmg(td->max_bs[DDIR_WRITE]);
 477
 478                                 log_info("%s: (g=%d): rw=%s, bs=%s-%s/%s-%s, ioengine=%s, iodepth=%u\n", td->name, td->groupid, ddir_str[td->td_ddir], c1, c2, c3, c4, td->io_ops->name, td->iodepth);
 479
 480                                 free(c1);
 481                                 free(c2);
 482                                 free(c3);
 483                                 free(c4);
 484                         }
 485                 } else if (job_add_num == 1)
 486                         log_info("...\n");
 487         }
 488
 489         /*
 490          * recurse add identical jobs, clear numjobs and stonewall options
 491          * as they don't apply to sub-jobs
 492          */
 493         numjobs = td->numjobs;
 494         while (--numjobs) {
 495                 struct thread_data *td_new = get_new_job(0, td);
 496
 497                 if (!td_new)
 498                         goto err;
 499
 500                 td_new->numjobs = 1;
 501                 td_new->stonewall = 0;
 502
 503                 if (file_alloced) {
 504                         td_new->filename = NULL;
 505                         td_new->files_index = 0;
 506                         td_new->files = NULL;
 507                 }
 508
 509                 job_add_num = numjobs - 1;
 510
 511                 if (add_job(td_new, jobname, job_add_num))
 512                         goto err;
 513         }
 514
 515         if (td->numjobs > 1) {
 516                 groupid++;
 517                 prev_group_jobs = 0;
 518         }
 519
 520         return 0;
 521 err:
 522         put_job(td);
 523         return -1;
 524 }
 525
 526 static int is_empty_or_comment(char *line)
 527 {
 528         unsigned int i;
 529
 530         for (i = 0; i < strlen(line); i++) {
 531                 if (line[i] == ';')
 532                         return 1;
 533                 if (line[i] == '#')
 534                         return 1;
 535                 if (!isspace(line[i]) && !iscntrl(line[i]))
 536                         return 0;
 537         }
 538
 539         return 1;
 540 }
 541
 542 /*
 543  * This is our [ini] type file parser.
 544  */
 545 static int parse_jobs_ini(char *file, int stonewall_flag)
 546 {
 547         unsigned int global;
 548         struct thread_data *td;
 549         char *string, *name;
 550         fpos_t off;
 551         FILE *f;
 552         char *p;
 553         int ret = 0, stonewall;
 554
 555         f = fopen(file, "r");
 556         if (!f) {
 557                 perror("fopen job file");
 558                 return 1;
 559         }
 560
 561         string = malloc(4096);
 562         name = malloc(256);
 563         memset(name, 0, 256);
 564
 565         stonewall = stonewall_flag;
 566         do {
 567                 p = fgets(string, 4095, f);
 568                 if (!p)
 569                         break;
 570                 if (is_empty_or_comment(p))
 571                         continue;
 572                 if (sscanf(p, "[%255s]", name) != 1)
 573                         continue;
 574
 575                 global = !strncmp(name, "global", 6);
 576
 577                 name[strlen(name) - 1] = '\0';
 578
 579                 td = get_new_job(global, &def_thread);
 580                 if (!td) {
 581                         ret = 1;
 582                         break;
 583                 }
 584
 585                 /*
 586                  * Seperate multiple job files by a stonewall
 587                  */
 588                 if (!global && stonewall) {
 589                         td->stonewall = stonewall;
 590                         stonewall = 0;
 591                 }
 592
 593                 fgetpos(f, &off);
 594                 while ((p = fgets(string, 4096, f)) != NULL) {
 595                         if (is_empty_or_comment(p))
 596                                 continue;
 597
 598                         strip_blank_front(&p);
 599
 600                         if (p[0] == '[')
 601                                 break;
 602
 603                         strip_blank_end(p);
 604
 605                         fgetpos(f, &off);
 606
 607                         /*
 608                          * Don't break here, continue parsing options so we
 609                          * dump all the bad ones. Makes trial/error fixups
 610                          * easier on the user.
 611                          */
 612                         ret |= fio_option_parse(td, p);
 613                 }
 614
 615                 if (!ret) {
 616                         fsetpos(f, &off);
 617                         ret = add_job(td, name, 0);
 618                 } else {
 619                         log_err("fio: job %s dropped\n", name);
 620                         put_job(td);
 621                 }
 622         } while (!ret);
 623
 624         free(string);
 625         free(name);
 626         fclose(f);
 627         return ret;
 628 }
 629
 630 static int fill_def_thread(void)
 631 {
 632         memset(&def_thread, 0, sizeof(def_thread));
 633
 634         if (fio_getaffinity(getpid(), &def_thread.cpumask) == -1) {
 635                 perror("sched_getaffinity");
 636                 return 1;
 637         }
 638
 639         /*
 640          * fill default options
 641          */
 642         fio_fill_default_options(&def_thread);
 643
 644         def_thread.timeout = def_timeout;
 645         def_thread.write_bw_log = write_bw_log;
 646         def_thread.write_lat_log = write_lat_log;
 647
 648 #ifdef FIO_HAVE_DISK_UTIL
 649         def_thread.do_disk_util = 1;
 650 #endif
 651
 652         return 0;
 653 }
 654
 655 static void free_shm(void)
 656 {
 657         struct shmid_ds sbuf;
 658
 659         if (threads) {
 660                 shmdt((void *) threads);
 661                 threads = NULL;
 662                 shmctl(shm_id, IPC_RMID, &sbuf);
 663         }
 664 }
 665
 666 /*
 667  * The thread area is shared between the main process and the job
 668  * threads/processes. So setup a shared memory segment that will hold
 669  * all the job info.
 670  */
 671 static int setup_thread_area(void)
 672 {
 673         /*
 674          * 1024 is too much on some machines, scale max_jobs if
 675          * we get a failure that looks like too large a shm segment
 676          */
 677         do {
 678                 size_t size = max_jobs * sizeof(struct thread_data);
 679
 680                 shm_id = shmget(0, size, IPC_CREAT | 0600);
 681                 if (shm_id != -1)
 682                         break;
 683                 if (errno != EINVAL) {
 684                         perror("shmget");
 685                         break;
 686                 }
 687
 688                 max_jobs >>= 1;
 689         } while (max_jobs);
 690
 691         if (shm_id == -1)
 692                 return 1;
 693
 694         threads = shmat(shm_id, NULL, 0);
 695         if (threads == (void *) -1) {
 696                 perror("shmat");
 697                 return 1;
 698         }
 699
 700         atexit(free_shm);
 701         return 0;
 702 }
 703
 704 static void usage(void)
 705 {
 706         printf("%s\n", fio_version_string);
 707         printf("\t--output\tWrite output to file\n");
 708         printf("\t--timeout\tRuntime in seconds\n");
 709         printf("\t--latency-log\tGenerate per-job latency logs\n");
 710         printf("\t--bandwidth-log\tGenerate per-job bandwidth logs\n");
 711         printf("\t--minimal\tMinimal (terse) output\n");
 712         printf("\t--version\tPrint version info and exit\n");
 713         printf("\t--help\t\tPrint this page\n");
 714         printf("\t--cmdhelp=cmd\tPrint command help, \"all\" for all of them\n");
 715 }
 716
 717 static int parse_cmd_line(int argc, char *argv[])
 718 {
 719         struct thread_data *td = NULL;
 720         int c, ini_idx = 0, lidx, ret, dont_add_job = 0;
 721
 722         while ((c = getopt_long_only(argc, argv, "", long_options, &lidx)) != -1) {
 723                 switch (c) {
 724                 case 't':
 725                         def_timeout = atoi(optarg);
 726                         break;
 727                 case 'l':
 728                         write_lat_log = 1;
 729                         break;
 730                 case 'w':
 731                         write_bw_log = 1;
 732                         break;
 733                 case 'o':
 734                         f_out = fopen(optarg, "w+");
 735                         if (!f_out) {
 736                                 perror("fopen output");
 737                                 exit(1);
 738                         }
 739                         f_err = f_out;
 740                         break;
 741                 case 'm':
 742                         terse_output = 1;
 743                         break;
 744                 case 'h':
 745                         usage();
 746                         exit(0);
 747                 case 'c':
 748                         exit(fio_show_option_help(optarg));
 749                 case 'v':
 750                         printf("%s\n", fio_version_string);
 751                         exit(0);
 752                 case FIO_GETOPT_JOB: {
 753                         const char *opt = long_options[lidx].name;
 754                         char *val = optarg;
 755
 756                         if (!strncmp(opt, "name", 4) && td) {
 757                                 ret = add_job(td, td->name ?: "fio", 0);
 758                                 if (ret) {
 759                                         put_job(td);
 760                                         return 0;
 761                                 }
 762                                 td = NULL;
 763                         }
 764                         if (!td) {
 765                                 int global = !strncmp(val, "global", 6);
 766
 767                                 td = get_new_job(global, &def_thread);
 768                                 if (!td)
 769                                         return 0;
 770                         }
 771
 772                         ret = fio_cmd_option_parse(td, opt, val);
 773                         if (ret)
 774                                 dont_add_job = 1;
 775                         break;
 776                 }
 777                 default:
 778                         break;
 779                 }
 780         }
 781
 782         if (td) {
 783                 if (dont_add_job)
 784                         put_job(td);
 785                 else {
 786                         ret = add_job(td, td->name ?: "fio", 0);
 787                         if (ret)
 788                                 put_job(td);
 789                 }
 790         }
 791
 792         while (optind < argc) {
 793                 ini_idx++;
 794                 ini_file = realloc(ini_file, ini_idx * sizeof(char *));
 795                 ini_file[ini_idx - 1] = strdup(argv[optind]);
 796                 optind++;
 797         }
 798
 799         return ini_idx;
 800 }
 801
 802
 803 int parse_options(int argc, char *argv[])
 804 {
 805         int job_files, i;
 806
 807         f_out = stdout;
 808         f_err = stderr;
 809
 810         fio_options_dup_and_init(long_options);
 811
 812         if (setup_thread_area())
 813                 return 1;
 814         if (fill_def_thread())
 815                 return 1;
 816
 817         job_files = parse_cmd_line(argc, argv);
 818
 819         for (i = 0; i < job_files; i++) {
 820                 if (fill_def_thread())
 821                         return 1;
 822                 if (parse_jobs_ini(ini_file[i], i))
 823                         return 1;
 824                 free(ini_file[i]);
 825         }
 826
 827         free(ini_file);
 828
 829         if (!thread_number) {
 830                 log_err("No jobs defined(s)\n");
 831                 return 1;
 832         }
 833
 834         return 0;
 835 }