init.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <unistd.h>
   4 #include <fcntl.h>
   5 #include <ctype.h>
   6 #include <string.h>
   7 #include <errno.h>
   8 #include <sys/ipc.h>
   9 #include <sys/shm.h>
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12
  13 #include "fio.h"
  14
  15 #define DEF_BS                  (4096)
  16 #define DEF_TIMEOUT             (0)
  17 #define DEF_RATE_CYCLE          (1000)
  18 #define DEF_ODIRECT             (1)
  19 #define DEF_IO_ENGINE           (FIO_SYNCIO)
  20 #define DEF_IO_ENGINE_NAME      "sync"
  21 #define DEF_SEQUENTIAL          (1)
  22 #define DEF_RAND_REPEAT         (1)
  23 #define DEF_OVERWRITE           (1)
  24 #define DEF_CREATE              (1)
  25 #define DEF_INVALIDATE          (1)
  26 #define DEF_SYNCIO              (0)
  27 #define DEF_RANDSEED            (0xb1899bedUL)
  28 #define DEF_BWAVGTIME           (500)
  29 #define DEF_CREATE_SER          (1)
  30 #define DEF_CREATE_FSYNC        (1)
  31 #define DEF_LOOPS               (1)
  32 #define DEF_VERIFY              (0)
  33 #define DEF_STONEWALL           (0)
  34 #define DEF_NUMJOBS             (1)
  35 #define DEF_USE_THREAD          (0)
  36 #define DEF_FILE_SIZE           (1024 * 1024 * 1024UL)
  37 #define DEF_ZONE_SIZE           (0)
  38 #define DEF_ZONE_SKIP           (0)
  39 #define DEF_RWMIX_CYCLE         (500)
  40 #define DEF_RWMIX_READ          (50)
  41 #define DEF_NICE                (0)
  42
  43 static int def_sequential = DEF_SEQUENTIAL;
  44 static int def_bs = DEF_BS;
  45 static int def_timeout = DEF_TIMEOUT;
  46 static int def_repeatable = DEF_RAND_REPEAT;
  47 static int def_odirect = DEF_ODIRECT;
  48
  49 static char fio_version_string[] = "fio 1.4";
  50
  51 static char **ini_file;
  52 static int max_jobs = MAX_JOBS;
  53
  54 struct thread_data def_thread;
  55 struct thread_data *threads = NULL;
  56
  57 int rate_quit = 0;
  58 int write_lat_log = 0;
  59 int write_bw_log = 0;
  60 int exitall_on_terminate = 0;
  61 unsigned long long mlock_size = 0;
  62 FILE *f_out = NULL;
  63 FILE *f_err = NULL;
  64
  65 static struct thread_data *get_new_job(int global, struct thread_data *parent)
  66 {
  67         struct thread_data *td;
  68
  69         if (global)
  70                 return &def_thread;
  71         if (thread_number >= max_jobs)
  72                 return NULL;
  73
  74         td = &threads[thread_number++];
  75         *td = *parent;
  76         td->name[0] = '\0';
  77
  78         td->fd = -1;
  79         td->thread_number = thread_number;
  80         return td;
  81 }
  82
  83 static void put_job(struct thread_data *td)
  84 {
  85         memset(&threads[td->thread_number - 1], 0, sizeof(*td));
  86         thread_number--;
  87 }
  88
  89 static int add_job(struct thread_data *td, const char *jobname, int job_add_num)
  90 {
  91         char *ddir_str[] = { "read", "write", "randread", "randwrite",
  92                              "rw", NULL, "randrw" };
  93         struct stat sb;
  94         int numjobs, ddir;
  95
  96 #ifndef FIO_HAVE_LIBAIO
  97         if (td->io_engine == FIO_LIBAIO) {
  98                 log_err("Linux libaio not available\n");
  99                 return 1;
 100         }
 101 #endif
 102 #ifndef FIO_HAVE_POSIXAIO
 103         if (td->io_engine == FIO_POSIXAIO) {
 104                 log_err("posix aio not available\n");
 105                 return 1;
 106         }
 107 #endif
 108
 109         /*
 110          * the def_thread is just for options, it's not a real job
 111          */
 112         if (td == &def_thread)
 113                 return 0;
 114
 115         if (td->io_engine & FIO_SYNCIO)
 116                 td->iodepth = 1;
 117         else {
 118                 if (!td->iodepth)
 119                         td->iodepth = 1;
 120         }
 121
 122         /*
 123          * only really works for sequential io for now
 124          */
 125         if (td->zone_size && !td->sequential)
 126                 td->zone_size = 0;
 127
 128         td->filetype = FIO_TYPE_FILE;
 129         if (!stat(jobname, &sb)) {
 130                 if (S_ISBLK(sb.st_mode))
 131                         td->filetype = FIO_TYPE_BD;
 132                 else if (S_ISCHR(sb.st_mode))
 133                         td->filetype = FIO_TYPE_CHAR;
 134         }
 135
 136         if (td->filetype == FIO_TYPE_FILE) {
 137                 char tmp[PATH_MAX];
 138
 139                 if (td->directory && td->directory[0] != '\0')
 140                         sprintf(tmp, "%s/%s.%d", td->directory, jobname, td->jobnum);
 141                 else
 142                         sprintf(tmp, "%s.%d", jobname, td->jobnum);
 143                 td->file_name = strdup(tmp);
 144         } else
 145                 td->file_name = strdup(jobname);
 146
 147         fio_sem_init(&td->mutex, 0);
 148
 149         td->clat_stat[0].min_val = td->clat_stat[1].min_val = ULONG_MAX;
 150         td->slat_stat[0].min_val = td->slat_stat[1].min_val = ULONG_MAX;
 151         td->bw_stat[0].min_val = td->bw_stat[1].min_val = ULONG_MAX;
 152
 153         if (td->min_bs == -1U)
 154                 td->min_bs = td->bs;
 155         if (td->max_bs == -1U)
 156                 td->max_bs = td->bs;
 157         if (td_read(td) && !td_rw(td))
 158                 td->verify = 0;
 159
 160         if (td->stonewall && td->thread_number > 1)
 161                 groupid++;
 162
 163         td->groupid = groupid;
 164
 165         if (setup_rate(td))
 166                 goto err;
 167
 168         if (write_lat_log) {
 169                 setup_log(&td->slat_log);
 170                 setup_log(&td->clat_log);
 171         }
 172         if (write_bw_log)
 173                 setup_log(&td->bw_log);
 174
 175         if (td->name[0] == '\0')
 176                 snprintf(td->name, sizeof(td->name)-1, "client%d", td->thread_number);
 177
 178         ddir = td->ddir + (!td->sequential << 1) + (td->iomix << 2);
 179
 180         if (!job_add_num)
 181                 fprintf(f_out, "%s: (g=%d): rw=%s, odir=%d, bs=%d-%d, rate=%d, ioengine=%s, iodepth=%d\n", td->name, td->groupid, ddir_str[ddir], td->odirect, td->min_bs, td->max_bs, td->rate, td->io_engine_name, td->iodepth);
 182         else if (job_add_num == 1)
 183                 fprintf(f_out, "...\n");
 184
 185         /*
 186          * recurse add identical jobs, clear numjobs and stonewall options
 187          * as they don't apply to sub-jobs
 188          */
 189         numjobs = td->numjobs;
 190         while (--numjobs) {
 191                 struct thread_data *td_new = get_new_job(0, td);
 192
 193                 if (!td_new)
 194                         goto err;
 195
 196                 td_new->numjobs = 1;
 197                 td_new->stonewall = 0;
 198                 td_new->jobnum = numjobs;
 199                 job_add_num = numjobs - 1;
 200
 201                 if (add_job(td_new, jobname, job_add_num))
 202                         goto err;
 203         }
 204         return 0;
 205 err:
 206         put_job(td);
 207         return -1;
 208 }
 209
 210 int init_random_state(struct thread_data *td)
 211 {
 212         unsigned long seeds[4];
 213         int fd, num_maps, blocks;
 214
 215         fd = open("/dev/urandom", O_RDONLY);
 216         if (fd == -1) {
 217                 td_verror(td, errno);
 218                 return 1;
 219         }
 220
 221         if (read(fd, seeds, sizeof(seeds)) < (int) sizeof(seeds)) {
 222                 td_verror(td, EIO);
 223                 close(fd);
 224                 return 1;
 225         }
 226
 227         close(fd);
 228
 229         os_random_seed(seeds[0], &td->bsrange_state);
 230         os_random_seed(seeds[1], &td->verify_state);
 231         os_random_seed(seeds[2], &td->rwmix_state);
 232
 233         if (td->sequential)
 234                 return 0;
 235
 236         if (def_repeatable)
 237                 seeds[3] = DEF_RANDSEED;
 238
 239         blocks = (td->io_size + td->min_bs - 1) / td->min_bs;
 240         num_maps = blocks / BLOCKS_PER_MAP;
 241         td->file_map = malloc(num_maps * sizeof(long));
 242         td->num_maps = num_maps;
 243         memset(td->file_map, 0, num_maps * sizeof(long));
 244
 245         os_random_seed(seeds[3], &td->random_state);
 246         return 0;
 247 }
 248
 249 static void fill_cpu_mask(os_cpu_mask_t cpumask, int cpu)
 250 {
 251 #ifdef FIO_HAVE_CPU_AFFINITY
 252         unsigned int i;
 253
 254         CPU_ZERO(&cpumask);
 255
 256         for (i = 0; i < sizeof(int) * 8; i++) {
 257                 if ((1 << i) & cpu)
 258                         CPU_SET(i, &cpumask);
 259         }
 260 #endif
 261 }
 262
 263 static unsigned long get_mult(char c)
 264 {
 265         switch (c) {
 266                 case 'k':
 267                 case 'K':
 268                         return 1024;
 269                 case 'm':
 270                 case 'M':
 271                         return 1024 * 1024;
 272                 case 'g':
 273                 case 'G':
 274                         return 1024 * 1024 * 1024;
 275                 default:
 276                         return 1;
 277         }
 278 }
 279
 280 /*
 281  * convert string after '=' into decimal value, noting any size suffix
 282  */
 283 static int str_cnv(char *p, unsigned long long *val)
 284 {
 285         char *str;
 286         int len;
 287
 288         str = strchr(p, '=');
 289         if (!str)
 290                 return 1;
 291
 292         str++;
 293         len = strlen(str);
 294
 295         *val = strtoul(str, NULL, 10);
 296         if (*val == ULONG_MAX && errno == ERANGE)
 297                 return 1;
 298
 299         *val *= get_mult(str[len - 1]);
 300         return 0;
 301 }
 302
 303 static int check_strcnv(char *p, char *name, unsigned long long *val)
 304 {
 305         if (strncmp(p, name, strlen(name) - 1))
 306                 return 1;
 307
 308         return str_cnv(p, val);
 309 }
 310
 311 static void strip_blank_front(char **p)
 312 {
 313         char *s = *p;
 314
 315         while (isspace(*s))
 316                 s++;
 317 }
 318
 319 static void strip_blank_end(char *p)
 320 {
 321         char *s = p + strlen(p) - 1;
 322
 323         while (isspace(*s) || iscntrl(*s))
 324                 s--;
 325
 326         *(s + 1) = '\0';
 327 }
 328
 329 typedef int (str_cb_fn)(struct thread_data *, char *);
 330
 331 static int check_str(char *p, char *name, str_cb_fn *cb, struct thread_data *td)
 332 {
 333         char *s;
 334
 335         if (strncmp(p, name, strlen(name)))
 336                 return 1;
 337
 338         s = strstr(p, name);
 339         if (!s)
 340                 return 1;
 341
 342         s = strchr(s, '=');
 343         if (!s)
 344                 return 1;
 345
 346         s++;
 347         strip_blank_front(&s);
 348         return cb(td, s);
 349 }
 350
 351 static int check_strstore(char *p, char *name, char *dest)
 352 {
 353         char *s;
 354
 355         if (strncmp(p, name, strlen(name)))
 356                 return 1;
 357
 358         s = strstr(p, name);
 359         if (!s)
 360                 return 1;
 361
 362         s = strchr(p, '=');
 363         if (!s)
 364                 return 1;
 365
 366         s++;
 367         strip_blank_front(&s);
 368
 369         strcpy(dest, s);
 370         return 0;
 371 }
 372
 373 static int __check_range(char *str, unsigned long *val)
 374 {
 375         char suffix;
 376
 377         if (sscanf(str, "%lu%c", val, &suffix) == 2) {
 378                 *val *= get_mult(suffix);
 379                 return 0;
 380         }
 381
 382         if (sscanf(str, "%lu", val) == 1)
 383                 return 0;
 384
 385         return 1;
 386 }
 387
 388 static int check_range(char *p, char *name, unsigned long *s, unsigned long *e)
 389 {
 390         char option[128];
 391         char *str, *p1, *p2;
 392
 393         if (strncmp(p, name, strlen(name)))
 394                 return 1;
 395
 396         strcpy(option, p);
 397         p = option;
 398
 399         str = strstr(p, name);
 400         if (!str)
 401                 return 1;
 402
 403         p += strlen(name);
 404
 405         str = strchr(p, '=');
 406         if (!str)
 407                 return 1;
 408
 409         /*
 410          * 'p' now holds whatever is after the '=' sign
 411          */
 412         p1 = str + 1;
 413
 414         /*
 415          * terminate p1 at the '-' sign
 416          */
 417         p = strchr(p1, '-');
 418         if (!p)
 419                 return 1;
 420
 421         p2 = p + 1;
 422         *p = '\0';
 423
 424         if (!__check_range(p1, s) && !__check_range(p2, e))
 425                 return 0;
 426
 427         return 1;
 428 }
 429
 430 static int check_int(char *p, char *name, unsigned int *val)
 431 {
 432         char *str;
 433
 434         if (strncmp(p, name, strlen(name)))
 435                 return 1;
 436
 437         str = strstr(p, name);
 438         if (!str)
 439                 return 1;
 440
 441         str = strchr(p, '=');
 442         if (!str)
 443                 return 1;
 444
 445         str++;
 446
 447         if (sscanf(str, "%u", val) == 1)
 448                 return 0;
 449
 450         return 1;
 451 }
 452
 453 static int check_strset(char *p, char *name)
 454 {
 455         return strncmp(p, name, strlen(name));
 456 }
 457
 458 static int is_empty_or_comment(char *line)
 459 {
 460         unsigned int i;
 461
 462         for (i = 0; i < strlen(line); i++) {
 463                 if (line[i] == ';')
 464                         return 1;
 465                 if (!isspace(line[i]) && !iscntrl(line[i]))
 466                         return 0;
 467         }
 468
 469         return 1;
 470 }
 471
 472 static int str_rw_cb(struct thread_data *td, char *mem)
 473 {
 474         if (!strncmp(mem, "read", 4) || !strncmp(mem, "0", 1)) {
 475                 td->ddir = DDIR_READ;
 476                 td->sequential = 1;
 477                 return 0;
 478         } else if (!strncmp(mem, "randread", 8)) {
 479                 td->ddir = DDIR_READ;
 480                 td->sequential = 0;
 481                 return 0;
 482         } else if (!strncmp(mem, "write", 5) || !strncmp(mem, "1", 1)) {
 483                 td->ddir = DDIR_WRITE;
 484                 td->sequential = 1;
 485                 return 0;
 486         } else if (!strncmp(mem, "randwrite", 9)) {
 487                 td->ddir = DDIR_WRITE;
 488                 td->sequential = 0;
 489                 return 0;
 490         } else if (!strncmp(mem, "rw", 2)) {
 491                 td->ddir = 0;
 492                 td->iomix = 1;
 493                 td->sequential = 1;
 494                 return 0;
 495         } else if (!strncmp(mem, "randrw", 6)) {
 496                 td->ddir = 0;
 497                 td->iomix = 1;
 498                 td->sequential = 0;
 499                 return 0;
 500         }
 501
 502         log_err("fio: data direction: read, write, randread, randwrite, rw, randrw\n");
 503         return 1;
 504 }
 505
 506 static int str_verify_cb(struct thread_data *td, char *mem)
 507 {
 508         if (!strncmp(mem, "0", 1)) {
 509                 td->verify = VERIFY_NONE;
 510                 return 0;
 511         } else if (!strncmp(mem, "md5", 3) || !strncmp(mem, "1", 1)) {
 512                 td->verify = VERIFY_MD5;
 513                 return 0;
 514         } else if (!strncmp(mem, "crc32", 5)) {
 515                 td->verify = VERIFY_CRC32;
 516                 return 0;
 517         }
 518
 519         log_err("fio: verify types: md5, crc32\n");
 520         return 1;
 521 }
 522
 523 static int str_mem_cb(struct thread_data *td, char *mem)
 524 {
 525         if (!strncmp(mem, "malloc", 6)) {
 526                 td->mem_type = MEM_MALLOC;
 527                 return 0;
 528         } else if (!strncmp(mem, "shm", 3)) {
 529                 td->mem_type = MEM_SHM;
 530                 return 0;
 531         } else if (!strncmp(mem, "mmap", 4)) {
 532                 td->mem_type = MEM_MMAP;
 533                 return 0;
 534         }
 535
 536         log_err("fio: mem type: malloc, shm, mmap\n");
 537         return 1;
 538 }
 539
 540 static int str_ioengine_cb(struct thread_data *td, char *str)
 541 {
 542         if (!strncmp(str, "linuxaio", 8) || !strncmp(str, "aio", 3) ||
 543             !strncmp(str, "libaio", 6)) {
 544                 strcpy(td->io_engine_name, "libaio");
 545                 td->io_engine = FIO_LIBAIO;
 546                 return 0;
 547         } else if (!strncmp(str, "posixaio", 8)) {
 548                 strcpy(td->io_engine_name, "posixaio");
 549                 td->io_engine = FIO_POSIXAIO;
 550                 return 0;
 551         } else if (!strncmp(str, "sync", 4)) {
 552                 strcpy(td->io_engine_name, "sync");
 553                 td->io_engine = FIO_SYNCIO;
 554                 return 0;
 555         } else if (!strncmp(str, "mmap", 4)) {
 556                 strcpy(td->io_engine_name, "mmap");
 557                 td->io_engine = FIO_MMAPIO;
 558                 return 0;
 559         } else if (!strncmp(str, "sgio", 4)) {
 560                 strcpy(td->io_engine_name, "sgio");
 561                 td->io_engine = FIO_SGIO;
 562                 return 0;
 563         } else if (!strncmp(str, "splice", 6)) {
 564                 strcpy(td->io_engine_name, "splice");
 565                 td->io_engine = FIO_SPLICEIO;
 566                 return 0;
 567         }
 568
 569         log_err("fio: ioengine: { linuxaio, aio, libaio }, posixaio, sync, mmap, sgio, splice\n");
 570         return 1;
 571 }
 572
 573 /*
 574  * This is our [ini] type file parser.
 575  */
 576 int parse_jobs_ini(char *file)
 577 {
 578         unsigned int prioclass, prio, cpu, global, il;
 579         unsigned long long ull;
 580         unsigned long ul1, ul2;
 581         struct thread_data *td;
 582         char *string, *name, *tmpbuf;
 583         fpos_t off;
 584         FILE *f;
 585         char *p;
 586         int ret = 0, stonewall = 1;
 587
 588         f = fopen(file, "r");
 589         if (!f) {
 590                 perror("fopen job file");
 591                 return 1;
 592         }
 593
 594         string = malloc(4096);
 595         name = malloc(256);
 596         tmpbuf = malloc(4096);
 597
 598         while ((p = fgets(string, 4096, f)) != NULL) {
 599                 if (ret)
 600                         break;
 601                 if (is_empty_or_comment(p))
 602                         continue;
 603                 if (sscanf(p, "[%s]", name) != 1)
 604                         continue;
 605
 606                 global = !strncmp(name, "global", 6);
 607
 608                 name[strlen(name) - 1] = '\0';
 609
 610                 td = get_new_job(global, &def_thread);
 611                 if (!td) {
 612                         ret = 1;
 613                         break;
 614                 }
 615
 616                 /*
 617                  * Seperate multiple job files by a stonewall
 618                  */
 619                 if (stonewall) {
 620                         td->stonewall = stonewall;
 621                         stonewall = 0;
 622                 }
 623
 624                 fgetpos(f, &off);
 625                 while ((p = fgets(string, 4096, f)) != NULL) {
 626                         if (is_empty_or_comment(p))
 627                                 continue;
 628                         if (strstr(p, "["))
 629                                 break;
 630                         strip_blank_front(&p);
 631                         strip_blank_end(p);
 632
 633                         if (!check_int(p, "prio", &prio)) {
 634 #ifndef FIO_HAVE_IOPRIO
 635                                 log_err("io priorities not available\n");
 636                                 ret = 1;
 637                                 break;
 638 #endif
 639                                 td->ioprio |= prio;
 640                                 fgetpos(f, &off);
 641                                 continue;
 642                         }
 643                         if (!check_int(p, "prioclass", &prioclass)) {
 644 #ifndef FIO_HAVE_IOPRIO
 645                                 log_err("io priorities not available\n");
 646                                 ret = 1;
 647                                 break;
 648 #else
 649                                 td->ioprio |= prioclass << IOPRIO_CLASS_SHIFT;
 650                                 fgetpos(f, &off);
 651                                 continue;
 652 #endif
 653                         }
 654                         if (!check_int(p, "direct", &il)) {
 655                                 td->odirect = il;
 656                                 fgetpos(f, &off);
 657                                 continue;
 658                         }
 659                         if (!check_int(p, "rate", &td->rate)) {
 660                                 fgetpos(f, &off);
 661                                 continue;
 662                         }
 663                         if (!check_int(p, "ratemin", &td->ratemin)) {
 664                                 fgetpos(f, &off);
 665                                 continue;
 666                         }
 667                         if (!check_int(p, "ratecycle", &td->ratecycle)) {
 668                                 fgetpos(f, &off);
 669                                 continue;
 670                         }
 671                         if (!check_int(p, "thinktime", &td->thinktime)) {
 672                                 fgetpos(f, &off);
 673                                 continue;
 674                         }
 675                         if (!check_int(p, "cpumask", &cpu)) {
 676 #ifndef FIO_HAVE_CPU_AFFINITY
 677                                 log_err("cpu affinity not available\n");
 678                                 ret = 1;
 679                                 break;
 680 #endif
 681                                 fill_cpu_mask(td->cpumask, cpu);
 682                                 fgetpos(f, &off);
 683                                 continue;
 684                         }
 685                         if (!check_int(p, "fsync", &td->fsync_blocks)) {
 686                                 fgetpos(f, &off);
 687                                 td->end_fsync = 1;
 688                                 continue;
 689                         }
 690                         if (!check_int(p, "startdelay", &td->start_delay)) {
 691                                 fgetpos(f, &off);
 692                                 continue;
 693                         }
 694                         if (!check_int(p, "timeout", &td->timeout)) {
 695                                 fgetpos(f, &off);
 696                                 continue;
 697                         }
 698                         if (!check_int(p, "invalidate", &il)) {
 699                                 td->invalidate_cache = il;
 700                                 fgetpos(f, &off);
 701                                 continue;
 702                         }
 703                         if (!check_int(p, "iodepth", &td->iodepth)) {
 704                                 fgetpos(f, &off);
 705                                 continue;
 706                         }
 707                         if (!check_int(p, "sync", &il)) {
 708                                 td->sync_io = il;
 709                                 fgetpos(f, &off);
 710                                 continue;
 711                         }
 712                         if (!check_int(p, "bwavgtime", &td->bw_avg_time)) {
 713                                 fgetpos(f, &off);
 714                                 continue;
 715                         }
 716                         if (!check_int(p, "create_serialize", &il)) {
 717                                 td->create_serialize = il;
 718                                 fgetpos(f, &off);
 719                                 continue;
 720                         }
 721                         if (!check_int(p, "create_fsync", &il)) {
 722                                 td->create_fsync = il;
 723                                 fgetpos(f, &off);
 724                                 continue;
 725                         }
 726                         if (!check_int(p, "end_fsync", &il)) {
 727                                 td->end_fsync = il;
 728                                 fgetpos(f, &off);
 729                                 continue;
 730                         }
 731                         if (!check_int(p, "loops", &td->loops)) {
 732                                 fgetpos(f, &off);
 733                                 continue;
 734                         }
 735                         if (!check_int(p, "numjobs", &td->numjobs)) {
 736                                 fgetpos(f, &off);
 737                                 continue;
 738                         }
 739                         if (!check_int(p, "overwrite", &il)) {
 740                                 td->overwrite = il;
 741                                 fgetpos(f, &off);
 742                                 continue;
 743                         }
 744                         if (!check_int(p, "rwmixcycle", &td->rwmixcycle)) {
 745                                 fgetpos(f, &off);
 746                                 continue;
 747                         }
 748                         if (!check_int(p, "rwmixread", &il)) {
 749                                 if (il > 100)
 750                                         il = 100;
 751                                 td->rwmixread = il;
 752                                 fgetpos(f, &off);
 753                                 continue;
 754                         }
 755                         if (!check_int(p, "rwmixwrite", &il)) {
 756                                 if (il > 100)
 757                                         il = 100;
 758                                 td->rwmixread = 100 - il;
 759                                 fgetpos(f, &off);
 760                                 continue;
 761                         }
 762                         if (!check_int(p, "nice", &td->nice)) {
 763                                 fgetpos(f, &off);
 764                                 continue;
 765                         }
 766                         if (!check_range(p, "bsrange", &ul1, &ul2)) {
 767                                 if (ul1 > ul2) {
 768                                         td->max_bs = ul1;
 769                                         td->min_bs = ul2;
 770                                 } else {
 771                                         td->max_bs = ul2;
 772                                         td->min_bs = ul1;
 773                                 }
 774                                 fgetpos(f, &off);
 775                                 continue;
 776                         }
 777                         if (!check_strcnv(p, "bs", &ull)) {
 778                                 td->bs = ull;
 779                                 fgetpos(f, &off);
 780                                 continue;
 781                         }
 782                         if (!check_strcnv(p, "size", &td->file_size)) {
 783                                 fgetpos(f, &off);
 784                                 continue;
 785                         }
 786                         if (!check_strcnv(p, "offset", &td->file_offset)) {
 787                                 fgetpos(f, &off);
 788                                 continue;
 789                         }
 790                         if (!check_strcnv(p, "zonesize", &td->zone_size)) {
 791                                 fgetpos(f, &off);
 792                                 continue;
 793                         }
 794                         if (!check_strcnv(p, "zoneskip", &td->zone_skip)) {
 795                                 fgetpos(f, &off);
 796                                 continue;
 797                         }
 798                         if (!check_strcnv(p, "lockmem", &mlock_size)) {
 799                                 fgetpos(f, &off);
 800                                 continue;
 801                         }
 802                         if (!check_strstore(p, "directory", tmpbuf)) {
 803                                 td->directory = strdup(tmpbuf);
 804                                 fgetpos(f, &off);
 805                                 continue;
 806                         }
 807                         if (!check_strstore(p, "name", tmpbuf)) {
 808                                 snprintf(td->name, sizeof(td->name)-1, "%s%d", tmpbuf, td->thread_number);
 809                                 fgetpos(f, &off);
 810                                 continue;
 811                         }
 812                         if (!check_str(p, "mem", str_mem_cb, td)) {
 813                                 fgetpos(f, &off);
 814                                 continue;
 815                         }
 816                         if (!check_str(p, "verify", str_verify_cb, td)) {
 817                                 fgetpos(f, &off);
 818                                 continue;
 819                         }
 820                         if (!check_str(p, "rw", str_rw_cb, td)) {
 821                                 fgetpos(f, &off);
 822                                 continue;
 823                         }
 824                         if (!check_str(p, "ioengine", str_ioengine_cb, td)) {
 825                                 fgetpos(f, &off);
 826                                 continue;
 827                         }
 828                         if (!check_strset(p, "create")) {
 829                                 td->create_file = 1;
 830                                 fgetpos(f, &off);
 831                                 continue;
 832                         }
 833                         if (!check_strset(p, "exitall")) {
 834                                 exitall_on_terminate = 1;
 835                                 fgetpos(f, &off);
 836                                 continue;
 837                         }
 838                         if (!check_strset(p, "stonewall")) {
 839                                 td->stonewall = 1;
 840                                 fgetpos(f, &off);
 841                                 continue;
 842                         }
 843                         if (!check_strset(p, "thread")) {
 844                                 td->use_thread = 1;
 845                                 fgetpos(f, &off);
 846                                 continue;
 847                         }
 848                         if (!check_strstore(p, "iolog", tmpbuf)) {
 849                                 if (td->write_iolog) {
 850                                         log_err("fio: read iolog overrides given write_iolog\n");
 851                                         free(td->iolog_file);
 852                                         td->write_iolog = 0;
 853                                 }
 854                                 td->iolog_file = strdup(tmpbuf);
 855                                 td->read_iolog = 1;
 856                                 fgetpos(f, &off);
 857                                 continue;
 858                         }
 859                         if (!check_strstore(p, "write_iolog", tmpbuf)) {
 860                                 if (!td->read_iolog) {
 861                                         td->iolog_file = strdup(tmpbuf);
 862                                         td->write_iolog = 1;
 863                                 } else
 864                                         log_err("fio: read iolog overrides given write_iolog\n");
 865                                 fgetpos(f, &off);
 866                                 continue;
 867                         }
 868                         if (!check_strstore(p, "exec_prerun", tmpbuf)) {
 869                                 td->exec_prerun = strdup(tmpbuf);
 870                                 fgetpos(f, &off);
 871                                 continue;
 872                         }
 873                         if (!check_strstore(p, "exec_postrun", tmpbuf)) {
 874                                 td->exec_postrun = strdup(tmpbuf);
 875                                 fgetpos(f, &off);
 876                                 continue;
 877                         }
 878                         if (!check_strstore(p, "ioscheduler", tmpbuf)) {
 879 #ifndef FIO_HAVE_IOSCHED_SWITCH
 880                                 log_err("io scheduler switching not available\n");
 881                                 ret = 1;
 882                                 break;
 883 #else
 884                                 td->ioscheduler = strdup(tmpbuf);
 885                                 fgetpos(f, &off);
 886                                 continue;
 887 #endif
 888                         }
 889
 890                         /*
 891                          * Don't break here, continue parsing options so we
 892                          * dump all the bad ones. Makes trial/error fixups
 893                          * easier on the user.
 894                          */
 895                         printf("Client%d: bad option %s\n",td->thread_number,p);
 896                         ret = 1;
 897                 }
 898
 899                 if (!ret) {
 900                         fsetpos(f, &off);
 901                         ret = add_job(td, name, 0);
 902                 }
 903                 if (ret)
 904                         break;
 905         }
 906
 907         free(string);
 908         free(name);
 909         free(tmpbuf);
 910         fclose(f);
 911         return ret;
 912 }
 913
 914 static int fill_def_thread(void)
 915 {
 916         memset(&def_thread, 0, sizeof(def_thread));
 917
 918         if (fio_getaffinity(getpid(), &def_thread.cpumask) == -1) {
 919                 perror("sched_getaffinity");
 920                 return 1;
 921         }
 922
 923         /*
 924          * fill globals
 925          */
 926         def_thread.ddir = DDIR_READ;
 927         def_thread.iomix = 0;
 928         def_thread.bs = def_bs;
 929         def_thread.min_bs = -1;
 930         def_thread.max_bs = -1;
 931         def_thread.io_engine = DEF_IO_ENGINE;
 932         strcpy(def_thread.io_engine_name, DEF_IO_ENGINE_NAME);
 933         def_thread.odirect = def_odirect;
 934         def_thread.ratecycle = DEF_RATE_CYCLE;
 935         def_thread.sequential = def_sequential;
 936         def_thread.timeout = def_timeout;
 937         def_thread.create_file = DEF_CREATE;
 938         def_thread.overwrite = DEF_OVERWRITE;
 939         def_thread.invalidate_cache = DEF_INVALIDATE;
 940         def_thread.sync_io = DEF_SYNCIO;
 941         def_thread.mem_type = MEM_MALLOC;
 942         def_thread.bw_avg_time = DEF_BWAVGTIME;
 943         def_thread.create_serialize = DEF_CREATE_SER;
 944         def_thread.create_fsync = DEF_CREATE_FSYNC;
 945         def_thread.loops = DEF_LOOPS;
 946         def_thread.verify = DEF_VERIFY;
 947         def_thread.stonewall = DEF_STONEWALL;
 948         def_thread.numjobs = DEF_NUMJOBS;
 949         def_thread.use_thread = DEF_USE_THREAD;
 950         def_thread.rwmixcycle = DEF_RWMIX_CYCLE;
 951         def_thread.rwmixread = DEF_RWMIX_READ;
 952         def_thread.nice = DEF_NICE;
 953 #ifdef FIO_HAVE_DISK_UTIL
 954         def_thread.do_disk_util = 1;
 955 #endif
 956
 957         return 0;
 958 }
 959
 960 static void usage(char *name)
 961 {
 962         printf("%s\n", fio_version_string);
 963         printf("\t-s IO is sequential\n");
 964         printf("\t-b Block size in KiB for each IO\n");
 965         printf("\t-t Runtime in seconds\n");
 966         printf("\t-R Exit all threads on failure to meet rate goal\n");
 967         printf("\t-o Use O_DIRECT\n");
 968         printf("\t-l Generate per-job latency logs\n");
 969         printf("\t-w Generate per-job bandwidth logs\n");
 970         printf("\t-f Job file (Required)\n");
 971         printf("\t-v Print version info and exit\n");
 972 }
 973
 974 static int parse_cmd_line(int argc, char *argv[])
 975 {
 976         int c, idx = 1, ini_idx = 0;
 977
 978         while ((c = getopt(argc, argv, "s:b:t:r:R:o:f:lwvhO:")) != EOF) {
 979                 switch (c) {
 980                         case 's':
 981                                 def_sequential = !!atoi(optarg);
 982                                 idx++;
 983                                 break;
 984                         case 'b':
 985                                 def_bs = atoi(optarg);
 986                                 def_bs <<= 10;
 987                                 if (!def_bs) {
 988                                         printf("bad block size\n");
 989                                         def_bs = DEF_BS;
 990                                 }
 991                                 idx++;
 992                                 break;
 993                         case 't':
 994                                 def_timeout = atoi(optarg);
 995                                 idx++;
 996                                 break;
 997                         case 'r':
 998                                 def_repeatable = !!atoi(optarg);
 999                                 idx++;
1000                                 break;
1001                         case 'R':
1002                                 rate_quit = !!atoi(optarg);
1003                                 idx++;
1004                                 break;
1005                         case 'o':
1006                                 def_odirect = !!atoi(optarg);
1007                                 idx++;
1008                                 break;
1009                         case 'f':
1010                                 ini_idx++;
1011                                 ini_file = realloc(ini_file, ini_idx * sizeof(char *));
1012                                 ini_file[ini_idx - 1] = strdup(optarg);
1013                                 idx++;
1014                                 break;
1015                         case 'l':
1016                                 write_lat_log = 1;
1017                                 idx++;
1018                                 break;
1019                         case 'w':
1020                                 write_bw_log = 1;
1021                                 idx++;
1022                                 break;
1023                         case 'O':
1024                                 f_out = fopen(optarg, "w+");
1025                                 if (!f_out) {
1026                                         perror("fopen output");
1027                                         exit(1);
1028                                 }
1029                                 f_err = f_out;
1030                                 idx++;
1031                                 break;
1032                         case 'h':
1033                                 usage(argv[0]);
1034                                 exit(0);
1035                         case 'v':
1036                                 printf("%s\n", fio_version_string);
1037                                 exit(0);
1038                 }
1039         }
1040
1041         while (idx < argc) {
1042                 ini_idx++;
1043                 ini_file = realloc(ini_file, ini_idx * sizeof(char *));
1044                 ini_file[ini_idx - 1] = strdup(argv[idx]);
1045                 idx++;
1046         }
1047
1048         if (!f_out) {
1049                 f_out = stdout;
1050                 f_err = stderr;
1051         }
1052
1053         return ini_idx;
1054 }
1055
1056 static void free_shm(void)
1057 {
1058         struct shmid_ds sbuf;
1059
1060         if (threads) {
1061                 shmdt((void *) threads);
1062                 threads = NULL;
1063                 shmctl(shm_id, IPC_RMID, &sbuf);
1064         }
1065 }
1066
1067 static int setup_thread_area(void)
1068 {
1069         /*
1070          * 1024 is too much on some machines, scale max_jobs if
1071          * we get a failure that looks like too large a shm segment
1072          */
1073         do {
1074                 int s = max_jobs * sizeof(struct thread_data);
1075
1076                 shm_id = shmget(0, s, IPC_CREAT | 0600);
1077                 if (shm_id != -1)
1078                         break;
1079                 if (errno != EINVAL) {
1080                         perror("shmget");
1081                         break;
1082                 }
1083
1084                 max_jobs >>= 1;
1085         } while (max_jobs);
1086
1087         if (shm_id == -1)
1088                 return 1;
1089
1090         threads = shmat(shm_id, NULL, 0);
1091         if (threads == (void *) -1) {
1092                 perror("shmat");
1093                 return 1;
1094         }
1095
1096         atexit(free_shm);
1097         return 0;
1098 }
1099
1100 int parse_options(int argc, char *argv[])
1101 {
1102         int job_files, i;
1103
1104         if (setup_thread_area())
1105                 return 1;
1106         if (fill_def_thread())
1107                 return 1;
1108
1109         job_files = parse_cmd_line(argc, argv);
1110         if (!job_files) {
1111                 log_err("Need job file(s)\n");
1112                 usage(argv[0]);
1113                 return 1;
1114         }
1115
1116         for (i = 0; i < job_files; i++) {
1117                 if (fill_def_thread())
1118                         return 1;
1119                 if (parse_jobs_ini(ini_file[i]))
1120                         return 1;
1121                 free(ini_file[i]);
1122         }
1123
1124         free(ini_file);
1125         return 0;
1126 }