init.c revision e0a223354342cc45a916b669343718b80a20c2ea
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 <assert.h> 13#include <sys/ipc.h> 14#include <sys/shm.h> 15#include <sys/types.h> 16#include <sys/stat.h> 17 18#include "fio.h" 19#include "parse.h" 20 21/* 22 * The default options 23 */ 24#define DEF_BS (4096) 25#define DEF_TIMEOUT (0) 26#define DEF_RATE_CYCLE (1000) 27#define DEF_ODIRECT (1) 28#define DEF_IO_ENGINE (FIO_SYNCIO) 29#define DEF_IO_ENGINE_NAME "sync" 30#define DEF_SEQUENTIAL (1) 31#define DEF_RAND_REPEAT (1) 32#define DEF_OVERWRITE (0) 33#define DEF_INVALIDATE (1) 34#define DEF_SYNCIO (0) 35#define DEF_RANDSEED (0xb1899bedUL) 36#define DEF_BWAVGTIME (500) 37#define DEF_CREATE_SER (1) 38#define DEF_CREATE_FSYNC (1) 39#define DEF_LOOPS (1) 40#define DEF_VERIFY (0) 41#define DEF_STONEWALL (0) 42#define DEF_NUMJOBS (1) 43#define DEF_USE_THREAD (0) 44#define DEF_FILE_SIZE (1024 * 1024 * 1024UL) 45#define DEF_ZONE_SIZE (0) 46#define DEF_ZONE_SKIP (0) 47#define DEF_RWMIX_CYCLE (500) 48#define DEF_RWMIX_READ (50) 49#define DEF_NICE (0) 50#define DEF_NR_FILES (1) 51#define DEF_UNLINK (1) 52#define DEF_WRITE_BW_LOG (0) 53#define DEF_WRITE_LAT_LOG (0) 54#define DEF_NO_RAND_MAP (0) 55 56#define td_var_offset(var) ((size_t) &((struct thread_data *)0)->var) 57 58static int str_rw_cb(void *, const char *); 59static int str_ioengine_cb(void *, const char *); 60static int str_mem_cb(void *, const char *); 61static int str_verify_cb(void *, const char *); 62static int str_lockmem_cb(void *, unsigned long *); 63#ifdef FIO_HAVE_IOPRIO 64static int str_prio_cb(void *, unsigned int *); 65static int str_prioclass_cb(void *, unsigned int *); 66#endif 67static int str_exitall_cb(void); 68static int str_cpumask_cb(void *, unsigned int *); 69 70/* 71 * Map of job/command line options 72 */ 73static struct fio_option options[] = { 74 { 75 .name = "name", 76 .type = FIO_OPT_STR_STORE, 77 .off1 = td_var_offset(name), 78 }, 79 { 80 .name = "directory", 81 .type = FIO_OPT_STR_STORE, 82 .off1 = td_var_offset(directory), 83 }, 84 { 85 .name = "filename", 86 .type = FIO_OPT_STR_STORE, 87 .off1 = td_var_offset(filename), 88 }, 89 { 90 .name = "rw", 91 .type = FIO_OPT_STR, 92 .cb = str_rw_cb, 93 }, 94 { 95 .name = "ioengine", 96 .type = FIO_OPT_STR, 97 .cb = str_ioengine_cb, 98 }, 99 { 100 .name = "mem", 101 .type = FIO_OPT_STR, 102 .cb = str_mem_cb, 103 }, 104 { 105 .name = "verify", 106 .type = FIO_OPT_STR, 107 .cb = str_verify_cb, 108 }, 109 { 110 .name = "write_iolog", 111 .type = FIO_OPT_STR_STORE, 112 .off1 = td_var_offset(write_iolog_file), 113 }, 114 { 115 .name = "read_iolog", 116 .type = FIO_OPT_STR_STORE, 117 .off1 = td_var_offset(read_iolog_file), 118 }, 119 { 120 .name = "exec_prerun", 121 .type = FIO_OPT_STR_STORE, 122 .off1 = td_var_offset(exec_prerun), 123 }, 124 { 125 .name = "exec_postrun", 126 .type = FIO_OPT_STR_STORE, 127 .off1 = td_var_offset(exec_postrun), 128 }, 129#ifdef FIO_HAVE_IOSCHED_SWITCH 130 { 131 .name = "ioscheduler", 132 .type = FIO_OPT_STR_STORE, 133 .off1 = td_var_offset(ioscheduler), 134 }, 135#endif 136 { 137 .name = "size", 138 .type = FIO_OPT_STR_VAL, 139 .off1 = td_var_offset(total_file_size), 140 }, 141 { 142 .name = "bs", 143 .type = FIO_OPT_STR_VAL_INT, 144 .off1 = td_var_offset(bs[DDIR_READ]), 145 .off2 = td_var_offset(bs[DDIR_WRITE]), 146 }, 147 { 148 .name = "offset", 149 .type = FIO_OPT_STR_VAL, 150 .off1 = td_var_offset(start_offset), 151 }, 152 { 153 .name = "zonesize", 154 .type = FIO_OPT_STR_VAL, 155 .off1 = td_var_offset(zone_size), 156 }, 157 { 158 .name = "zoneskip", 159 .type = FIO_OPT_STR_VAL, 160 .off1 = td_var_offset(zone_skip), 161 }, 162 { 163 .name = "lockmem", 164 .type = FIO_OPT_STR_VAL, 165 .cb = str_lockmem_cb, 166 }, 167 { 168 .name = "bsrange", 169 .type = FIO_OPT_RANGE, 170 .off1 = td_var_offset(min_bs[DDIR_READ]), 171 .off2 = td_var_offset(max_bs[DDIR_READ]), 172 .off3 = td_var_offset(min_bs[DDIR_WRITE]), 173 .off4 = td_var_offset(max_bs[DDIR_WRITE]), 174 }, 175 { 176 .name = "nrfiles", 177 .type = FIO_OPT_INT, 178 .off1 = td_var_offset(nr_files), 179 }, 180 { 181 .name = "iodepth", 182 .type = FIO_OPT_INT, 183 .off1 = td_var_offset(iodepth), 184 }, 185 { 186 .name = "fsync", 187 .type = FIO_OPT_INT, 188 .off1 = td_var_offset(fsync_blocks), 189 }, 190 { 191 .name = "rwmixcycle", 192 .type = FIO_OPT_INT, 193 .off1 = td_var_offset(rwmixcycle), 194 }, 195 { 196 .name = "rwmixread", 197 .type = FIO_OPT_INT, 198 .off1 = td_var_offset(rwmixread), 199 .max_val= 100, 200 }, 201 { 202 .name = "rwmixwrite", 203 .type = FIO_OPT_INT, 204 .off1 = td_var_offset(rwmixwrite), 205 .max_val= 100, 206 }, 207 { 208 .name = "nice", 209 .type = FIO_OPT_INT, 210 .off1 = td_var_offset(nice), 211 }, 212#ifdef FIO_HAVE_IOPRIO 213 { 214 .name = "prio", 215 .type = FIO_OPT_INT, 216 .cb = str_prio_cb, 217 }, 218 { 219 .name = "prioclass", 220 .type = FIO_OPT_INT, 221 .cb = str_prioclass_cb, 222 }, 223#endif 224 { 225 .name = "thinktime", 226 .type = FIO_OPT_INT, 227 .off1 = td_var_offset(thinktime) 228 }, 229 { 230 .name = "rate", 231 .type = FIO_OPT_INT, 232 .off1 = td_var_offset(rate) 233 }, 234 { 235 .name = "ratemin", 236 .type = FIO_OPT_INT, 237 .off1 = td_var_offset(ratemin) 238 }, 239 { 240 .name = "ratecycle", 241 .type = FIO_OPT_INT, 242 .off1 = td_var_offset(ratecycle) 243 }, 244 { 245 .name = "startdelay", 246 .type = FIO_OPT_INT, 247 .off1 = td_var_offset(start_delay) 248 }, 249 { 250 .name = "timeout", 251 .type = FIO_OPT_STR_VAL_TIME, 252 .off1 = td_var_offset(timeout) 253 }, 254 { 255 .name = "invalidate", 256 .type = FIO_OPT_INT, 257 .off1 = td_var_offset(invalidate_cache) 258 }, 259 { 260 .name = "sync", 261 .type = FIO_OPT_INT, 262 .off1 = td_var_offset(sync_io) 263 }, 264 { 265 .name = "bwavgtime", 266 .type = FIO_OPT_INT, 267 .off1 = td_var_offset(bw_avg_time) 268 }, 269 { 270 .name = "create_serialize", 271 .type = FIO_OPT_INT, 272 .off1 = td_var_offset(create_serialize) 273 }, 274 { 275 .name = "create_fsync", 276 .type = FIO_OPT_INT, 277 .off1 = td_var_offset(create_fsync) 278 }, 279 { 280 .name = "loops", 281 .type = FIO_OPT_INT, 282 .off1 = td_var_offset(loops) 283 }, 284 { 285 .name = "numjobs", 286 .type = FIO_OPT_INT, 287 .off1 = td_var_offset(numjobs) 288 }, 289 { 290 .name = "cpuload", 291 .type = FIO_OPT_INT, 292 .off1 = td_var_offset(cpuload) 293 }, 294 { 295 .name = "cpuchunks", 296 .type = FIO_OPT_INT, 297 .off1 = td_var_offset(cpucycle) 298 }, 299 { 300 .name = "direct", 301 .type = FIO_OPT_INT, 302 .off1 = td_var_offset(odirect) 303 }, 304 { 305 .name = "overwrite", 306 .type = FIO_OPT_INT, 307 .off1 = td_var_offset(overwrite) 308 }, 309#ifdef FIO_HAVE_CPU_AFFINITY 310 { 311 .name = "cpumask", 312 .type = FIO_OPT_INT, 313 .cb = str_cpumask_cb, 314 }, 315#endif 316 { 317 .name = "end_fsync", 318 .type = FIO_OPT_INT, 319 .off1 = td_var_offset(end_fsync) 320 }, 321 { 322 .name = "unlink", 323 .type = FIO_OPT_STR_SET, 324 .off1 = td_var_offset(unlink), 325 }, 326 { 327 .name = "exitall", 328 .type = FIO_OPT_STR_SET, 329 .cb = str_exitall_cb, 330 }, 331 { 332 .name = "stonewall", 333 .type = FIO_OPT_STR_SET, 334 .off1 = td_var_offset(stonewall), 335 }, 336 { 337 .name = "thread", 338 .type = FIO_OPT_STR_SET, 339 .off1 = td_var_offset(thread), 340 }, 341 { 342 .name = "write_bw_log", 343 .type = FIO_OPT_STR_SET, 344 .off1 = td_var_offset(write_bw_log), 345 }, 346 { 347 .name = "write_lat_log", 348 .type = FIO_OPT_STR_SET, 349 .off1 = td_var_offset(write_lat_log), 350 }, 351 { 352 .name = "norandommap", 353 .type = FIO_OPT_STR_SET, 354 .off1 = td_var_offset(norandommap), 355 }, 356 { 357 .name = "bs_unaligned", 358 .type = FIO_OPT_STR_SET, 359 .off1 = td_var_offset(bs_unaligned), 360 }, 361 { 362 .name = NULL, 363 }, 364}; 365 366#define FIO_JOB_OPTS (sizeof(options) / sizeof(struct fio_option)) 367#define FIO_CMD_OPTS (16) 368#define FIO_GETOPT_JOB (0x89988998) 369 370/* 371 * Command line options. These will contain the above, plus a few 372 * extra that only pertain to fio itself and not jobs. 373 */ 374static struct option long_options[FIO_JOB_OPTS + FIO_CMD_OPTS] = { 375 { 376 .name = "output", 377 .has_arg = required_argument, 378 .val = 'o', 379 }, 380 { 381 .name = "timeout", 382 .has_arg = required_argument, 383 .val = 't', 384 }, 385 { 386 .name = "latency-log", 387 .has_arg = required_argument, 388 .val = 'l', 389 }, 390 { 391 .name = "bandwidth-log", 392 .has_arg = required_argument, 393 .val = 'b', 394 }, 395 { 396 .name = "minimal", 397 .has_arg = optional_argument, 398 .val = 'm', 399 }, 400 { 401 .name = "version", 402 .has_arg = no_argument, 403 .val = 'v', 404 }, 405 { 406 .name = NULL, 407 }, 408}; 409 410static int def_timeout = DEF_TIMEOUT; 411 412static char fio_version_string[] = "fio 1.9"; 413 414static char **ini_file; 415static int max_jobs = MAX_JOBS; 416 417struct thread_data def_thread; 418struct thread_data *threads = NULL; 419 420int exitall_on_terminate = 0; 421int terse_output = 0; 422unsigned long long mlock_size = 0; 423FILE *f_out = NULL; 424FILE *f_err = NULL; 425 426static int write_lat_log = DEF_WRITE_LAT_LOG; 427static int write_bw_log = DEF_WRITE_BW_LOG; 428 429/* 430 * Return a free job structure. 431 */ 432static struct thread_data *get_new_job(int global, struct thread_data *parent) 433{ 434 struct thread_data *td; 435 436 if (global) 437 return &def_thread; 438 if (thread_number >= max_jobs) 439 return NULL; 440 441 td = &threads[thread_number++]; 442 *td = *parent; 443 444 td->thread_number = thread_number; 445 return td; 446} 447 448static void put_job(struct thread_data *td) 449{ 450 if (td == &def_thread) 451 return; 452 453 memset(&threads[td->thread_number - 1], 0, sizeof(*td)); 454 thread_number--; 455} 456 457/* 458 * Lazy way of fixing up options that depend on each other. We could also 459 * define option callback handlers, but this is easier. 460 */ 461static void fixup_options(struct thread_data *td) 462{ 463 if (!td->rwmixread && td->rwmixwrite) 464 td->rwmixread = 100 - td->rwmixwrite; 465 466 if (td->write_iolog_file && td->read_iolog_file) { 467 log_err("fio: read iolog overrides write_iolog\n"); 468 free(td->write_iolog_file); 469 td->write_iolog_file = NULL; 470 } 471 472 if (td->io_ops->flags & FIO_SYNCIO) 473 td->iodepth = 1; 474 else { 475 if (!td->iodepth) 476 td->iodepth = td->nr_files; 477 } 478 479 /* 480 * only really works for sequential io for now, and with 1 file 481 */ 482 if (td->zone_size && !td->sequential && td->nr_files == 1) 483 td->zone_size = 0; 484 485 /* 486 * Reads can do overwrites, we always need to pre-create the file 487 */ 488 if (td_read(td) || td_rw(td)) 489 td->overwrite = 1; 490 491 if (!td->min_bs[DDIR_READ]) 492 td->min_bs[DDIR_READ]= td->bs[DDIR_READ]; 493 if (!td->max_bs[DDIR_READ]) 494 td->max_bs[DDIR_READ] = td->bs[DDIR_READ]; 495 if (!td->min_bs[DDIR_WRITE]) 496 td->min_bs[DDIR_WRITE]= td->bs[DDIR_WRITE]; 497 if (!td->max_bs[DDIR_WRITE]) 498 td->max_bs[DDIR_WRITE] = td->bs[DDIR_WRITE]; 499 500 td->rw_min_bs = min(td->min_bs[DDIR_READ], td->min_bs[DDIR_WRITE]); 501 502 if (td_read(td) && !td_rw(td)) 503 td->verify = 0; 504 505 if (td->norandommap && td->verify != VERIFY_NONE) { 506 log_err("fio: norandommap given, verify disabled\n"); 507 td->verify = VERIFY_NONE; 508 } 509 if (td->bs_unaligned && (td->odirect || td->io_ops->flags & FIO_RAWIO)) 510 log_err("fio: bs_unaligned may not work with raw io\n"); 511 512 /* 513 * O_DIRECT and char doesn't mix, clear that flag if necessary. 514 */ 515 if (td->filetype == FIO_TYPE_CHAR && td->odirect) 516 td->odirect = 0; 517} 518 519/* 520 * This function leaks the buffer 521 */ 522static char *to_kmg(unsigned int val) 523{ 524 char *buf = malloc(32); 525 char post[] = { 0, 'K', 'M', 'G', 'P', 0 }; 526 char *p = post; 527 528 do { 529 if (val & 1023) 530 break; 531 532 val >>= 10; 533 p++; 534 } while (*p); 535 536 snprintf(buf, 31, "%u%c", val, *p); 537 return buf; 538} 539 540/* 541 * Adds a job to the list of things todo. Sanitizes the various options 542 * to make sure we don't have conflicts, and initializes various 543 * members of td. 544 */ 545static int add_job(struct thread_data *td, const char *jobname, int job_add_num) 546{ 547 const char *ddir_str[] = { "read", "write", "randread", "randwrite", 548 "rw", NULL, "randrw" }; 549 struct stat sb; 550 int numjobs, ddir, i; 551 struct fio_file *f; 552 553 /* 554 * the def_thread is just for options, it's not a real job 555 */ 556 if (td == &def_thread) 557 return 0; 558 559 /* 560 * Set default io engine, if none set 561 */ 562 if (!td->io_ops) { 563 td->io_ops = load_ioengine(td, DEF_IO_ENGINE_NAME); 564 if (!td->io_ops) { 565 log_err("default engine %s not there?\n", DEF_IO_ENGINE_NAME); 566 return 1; 567 } 568 } 569 570 if (td->odirect) 571 td->io_ops->flags |= FIO_RAWIO; 572 573 td->filetype = FIO_TYPE_FILE; 574 if (!stat(jobname, &sb)) { 575 if (S_ISBLK(sb.st_mode)) 576 td->filetype = FIO_TYPE_BD; 577 else if (S_ISCHR(sb.st_mode)) 578 td->filetype = FIO_TYPE_CHAR; 579 } 580 581 fixup_options(td); 582 583 if (td->filename) 584 td->nr_uniq_files = 1; 585 else 586 td->nr_uniq_files = td->nr_files; 587 588 if (td->filetype == FIO_TYPE_FILE || td->filename) { 589 char tmp[PATH_MAX]; 590 int len = 0; 591 592 if (td->directory && td->directory[0] != '\0') 593 sprintf(tmp, "%s/", td->directory); 594 595 td->files = malloc(sizeof(struct fio_file) * td->nr_files); 596 597 for_each_file(td, f, i) { 598 memset(f, 0, sizeof(*f)); 599 f->fd = -1; 600 601 if (td->filename) 602 sprintf(tmp + len, "%s", td->filename); 603 else 604 sprintf(tmp + len, "%s.%d.%d", jobname, td->thread_number, i); 605 f->file_name = strdup(tmp); 606 } 607 } else { 608 td->nr_files = 1; 609 td->files = malloc(sizeof(struct fio_file)); 610 f = &td->files[0]; 611 612 memset(f, 0, sizeof(*f)); 613 f->fd = -1; 614 f->file_name = strdup(jobname); 615 } 616 617 for_each_file(td, f, i) { 618 f->file_size = td->total_file_size / td->nr_files; 619 f->file_offset = td->start_offset; 620 } 621 622 fio_sem_init(&td->mutex, 0); 623 624 td->clat_stat[0].min_val = td->clat_stat[1].min_val = ULONG_MAX; 625 td->slat_stat[0].min_val = td->slat_stat[1].min_val = ULONG_MAX; 626 td->bw_stat[0].min_val = td->bw_stat[1].min_val = ULONG_MAX; 627 628 if (td->stonewall && td->thread_number > 1) 629 groupid++; 630 631 td->groupid = groupid; 632 633 if (setup_rate(td)) 634 goto err; 635 636 if (td->write_lat_log) { 637 setup_log(&td->slat_log); 638 setup_log(&td->clat_log); 639 } 640 if (td->write_bw_log) 641 setup_log(&td->bw_log); 642 643 if (!td->name) 644 td->name = strdup(jobname); 645 646 ddir = td->ddir + (!td->sequential << 1) + (td->iomix << 2); 647 648 if (!terse_output) { 649 if (!job_add_num) { 650 if (td->io_ops->flags & FIO_CPUIO) 651 fprintf(f_out, "%s: ioengine=cpu, cpuload=%u, cpucycle=%u\n", td->name, td->cpuload, td->cpucycle); 652 else { 653 char *c1, *c2, *c3, *c4; 654 655 c1 = to_kmg(td->min_bs[DDIR_READ]); 656 c2 = to_kmg(td->max_bs[DDIR_READ]); 657 c3 = to_kmg(td->min_bs[DDIR_WRITE]); 658 c4 = to_kmg(td->max_bs[DDIR_WRITE]); 659 660 fprintf(f_out, "%s: (g=%d): rw=%s, odir=%u, bs=%s-%s/%s-%s, rate=%u, ioengine=%s, iodepth=%u\n", td->name, td->groupid, ddir_str[ddir], td->odirect, c1, c2, c3, c4, td->rate, td->io_ops->name, td->iodepth); 661 662 free(c1); 663 free(c2); 664 free(c3); 665 free(c4); 666 } 667 } else if (job_add_num == 1) 668 fprintf(f_out, "...\n"); 669 } 670 671 /* 672 * recurse add identical jobs, clear numjobs and stonewall options 673 * as they don't apply to sub-jobs 674 */ 675 numjobs = td->numjobs; 676 while (--numjobs) { 677 struct thread_data *td_new = get_new_job(0, td); 678 679 if (!td_new) 680 goto err; 681 682 td_new->numjobs = 1; 683 td_new->stonewall = 0; 684 job_add_num = numjobs - 1; 685 686 if (add_job(td_new, jobname, job_add_num)) 687 goto err; 688 } 689 return 0; 690err: 691 put_job(td); 692 return -1; 693} 694 695/* 696 * Initialize the various random states we need (random io, block size ranges, 697 * read/write mix, etc). 698 */ 699int init_random_state(struct thread_data *td) 700{ 701 unsigned long seeds[4]; 702 int fd, num_maps, blocks, i; 703 struct fio_file *f; 704 705 if (td->io_ops->flags & FIO_CPUIO) 706 return 0; 707 708 fd = open("/dev/urandom", O_RDONLY); 709 if (fd == -1) { 710 td_verror(td, errno); 711 return 1; 712 } 713 714 if (read(fd, seeds, sizeof(seeds)) < (int) sizeof(seeds)) { 715 td_verror(td, EIO); 716 close(fd); 717 return 1; 718 } 719 720 close(fd); 721 722 os_random_seed(seeds[0], &td->bsrange_state); 723 os_random_seed(seeds[1], &td->verify_state); 724 os_random_seed(seeds[2], &td->rwmix_state); 725 726 if (td->sequential) 727 return 0; 728 729 if (td->rand_repeatable) 730 seeds[3] = DEF_RANDSEED; 731 732 if (!td->norandommap) { 733 for_each_file(td, f, i) { 734 blocks = (f->file_size + td->rw_min_bs - 1) / td->rw_min_bs; 735 num_maps = (blocks + BLOCKS_PER_MAP-1)/ BLOCKS_PER_MAP; 736 f->file_map = malloc(num_maps * sizeof(long)); 737 f->num_maps = num_maps; 738 memset(f->file_map, 0, num_maps * sizeof(long)); 739 } 740 } 741 742 os_random_seed(seeds[3], &td->random_state); 743 return 0; 744} 745 746static void fill_cpu_mask(os_cpu_mask_t cpumask, int cpu) 747{ 748#ifdef FIO_HAVE_CPU_AFFINITY 749 unsigned int i; 750 751 CPU_ZERO(&cpumask); 752 753 for (i = 0; i < sizeof(int) * 8; i++) { 754 if ((1 << i) & cpu) 755 CPU_SET(i, &cpumask); 756 } 757#endif 758} 759 760static int is_empty_or_comment(char *line) 761{ 762 unsigned int i; 763 764 for (i = 0; i < strlen(line); i++) { 765 if (line[i] == ';') 766 return 1; 767 if (!isspace(line[i]) && !iscntrl(line[i])) 768 return 0; 769 } 770 771 return 1; 772} 773 774static int str_rw_cb(void *data, const char *mem) 775{ 776 struct thread_data *td = data; 777 778 if (!strncmp(mem, "read", 4) || !strncmp(mem, "0", 1)) { 779 td->ddir = DDIR_READ; 780 td->sequential = 1; 781 return 0; 782 } else if (!strncmp(mem, "randread", 8)) { 783 td->ddir = DDIR_READ; 784 td->sequential = 0; 785 return 0; 786 } else if (!strncmp(mem, "write", 5) || !strncmp(mem, "1", 1)) { 787 td->ddir = DDIR_WRITE; 788 td->sequential = 1; 789 return 0; 790 } else if (!strncmp(mem, "randwrite", 9)) { 791 td->ddir = DDIR_WRITE; 792 td->sequential = 0; 793 return 0; 794 } else if (!strncmp(mem, "rw", 2)) { 795 td->ddir = DDIR_READ; 796 td->iomix = 1; 797 td->sequential = 1; 798 return 0; 799 } else if (!strncmp(mem, "randrw", 6)) { 800 td->ddir = DDIR_READ; 801 td->iomix = 1; 802 td->sequential = 0; 803 return 0; 804 } 805 806 log_err("fio: data direction: read, write, randread, randwrite, rw, randrw\n"); 807 return 1; 808} 809 810static int str_verify_cb(void *data, const char *mem) 811{ 812 struct thread_data *td = data; 813 814 if (!strncmp(mem, "0", 1)) { 815 td->verify = VERIFY_NONE; 816 return 0; 817 } else if (!strncmp(mem, "md5", 3) || !strncmp(mem, "1", 1)) { 818 td->verify = VERIFY_MD5; 819 return 0; 820 } else if (!strncmp(mem, "crc32", 5)) { 821 td->verify = VERIFY_CRC32; 822 return 0; 823 } 824 825 log_err("fio: verify types: md5, crc32\n"); 826 return 1; 827} 828 829static int str_mem_cb(void *data, const char *mem) 830{ 831 struct thread_data *td = data; 832 833 if (!strncmp(mem, "malloc", 6)) { 834 td->mem_type = MEM_MALLOC; 835 return 0; 836 } else if (!strncmp(mem, "mmap", 4)) { 837 td->mem_type = MEM_MMAP; 838 return 0; 839 } else if (!strncmp(mem, "shmhuge", 7)) { 840#ifdef FIO_HAVE_HUGETLB 841 td->mem_type = MEM_SHMHUGE; 842 return 0; 843#else 844 log_err("fio: shmhuge not available\n"); 845 return 1; 846#endif 847 } else if (!strncmp(mem, "shm", 3)) { 848 td->mem_type = MEM_SHM; 849 return 0; 850 } 851 852 log_err("fio: mem type: malloc, shm, mmap, shmhuge\n"); 853 return 1; 854} 855 856static int str_ioengine_cb(void *data, const char *str) 857{ 858 struct thread_data *td = data; 859 860 td->io_ops = load_ioengine(td, str); 861 if (td->io_ops) 862 return 0; 863 864 log_err("fio: ioengine= libaio, posixaio, sync, mmap, sgio, splice, cpu, null\n"); 865 log_err("fio: or specify path to dynamic ioengine module\n"); 866 return 1; 867} 868 869static int str_lockmem_cb(void fio_unused *data, unsigned long *val) 870{ 871 mlock_size = *val; 872 return 0; 873} 874 875#ifdef FIO_HAVE_IOPRIO 876static int str_prioclass_cb(void *data, unsigned int *val) 877{ 878 struct thread_data *td = data; 879 880 td->ioprio |= *val << IOPRIO_CLASS_SHIFT; 881 return 0; 882} 883 884static int str_prio_cb(void *data, unsigned int *val) 885{ 886 struct thread_data *td = data; 887 888 td->ioprio |= *val; 889 return 0; 890} 891#endif 892 893static int str_exitall_cb(void) 894{ 895 exitall_on_terminate = 1; 896 return 0; 897} 898 899static int str_cpumask_cb(void *data, unsigned int *val) 900{ 901 struct thread_data *td = data; 902 903 fill_cpu_mask(td->cpumask, *val); 904 return 0; 905} 906 907/* 908 * This is our [ini] type file parser. 909 */ 910static int parse_jobs_ini(char *file, int stonewall_flag) 911{ 912 unsigned int global; 913 struct thread_data *td; 914 char *string, *name; 915 fpos_t off; 916 FILE *f; 917 char *p; 918 int ret = 0, stonewall; 919 920 f = fopen(file, "r"); 921 if (!f) { 922 perror("fopen job file"); 923 return 1; 924 } 925 926 string = malloc(4096); 927 name = malloc(256); 928 memset(name, 0, 256); 929 930 stonewall = stonewall_flag; 931 do { 932 p = fgets(string, 4095, f); 933 if (!p) 934 break; 935 if (is_empty_or_comment(p)) 936 continue; 937 if (sscanf(p, "[%255s]", name) != 1) 938 continue; 939 940 global = !strncmp(name, "global", 6); 941 942 name[strlen(name) - 1] = '\0'; 943 944 td = get_new_job(global, &def_thread); 945 if (!td) { 946 ret = 1; 947 break; 948 } 949 950 /* 951 * Seperate multiple job files by a stonewall 952 */ 953 if (!global && stonewall) { 954 td->stonewall = stonewall; 955 stonewall = 0; 956 } 957 958 fgetpos(f, &off); 959 while ((p = fgets(string, 4096, f)) != NULL) { 960 if (is_empty_or_comment(p)) 961 continue; 962 963 strip_blank_front(&p); 964 965 if (p[0] == '[') 966 break; 967 968 strip_blank_end(p); 969 970 fgetpos(f, &off); 971 972 /* 973 * Don't break here, continue parsing options so we 974 * dump all the bad ones. Makes trial/error fixups 975 * easier on the user. 976 */ 977 ret |= parse_option(p, options, td); 978 } 979 980 if (!ret) { 981 fsetpos(f, &off); 982 ret = add_job(td, name, 0); 983 } else { 984 log_err("fio: job %s dropped\n", name); 985 put_job(td); 986 } 987 } while (!ret); 988 989 free(string); 990 free(name); 991 fclose(f); 992 return ret; 993} 994 995static int fill_def_thread(void) 996{ 997 memset(&def_thread, 0, sizeof(def_thread)); 998 999 if (fio_getaffinity(getpid(), &def_thread.cpumask) == -1) { 1000 perror("sched_getaffinity"); 1001 return 1; 1002 } 1003 1004 /* 1005 * fill globals 1006 */ 1007 def_thread.ddir = DDIR_READ; 1008 def_thread.iomix = 0; 1009 def_thread.bs[DDIR_READ] = DEF_BS; 1010 def_thread.bs[DDIR_WRITE] = DEF_BS; 1011 def_thread.min_bs[DDIR_READ] = def_thread.min_bs[DDIR_WRITE] = 0; 1012 def_thread.max_bs[DDIR_READ] = def_thread.max_bs[DDIR_WRITE] = 0; 1013 def_thread.odirect = DEF_ODIRECT; 1014 def_thread.ratecycle = DEF_RATE_CYCLE; 1015 def_thread.sequential = DEF_SEQUENTIAL; 1016 def_thread.timeout = def_timeout; 1017 def_thread.overwrite = DEF_OVERWRITE; 1018 def_thread.invalidate_cache = DEF_INVALIDATE; 1019 def_thread.sync_io = DEF_SYNCIO; 1020 def_thread.mem_type = MEM_MALLOC; 1021 def_thread.bw_avg_time = DEF_BWAVGTIME; 1022 def_thread.create_serialize = DEF_CREATE_SER; 1023 def_thread.create_fsync = DEF_CREATE_FSYNC; 1024 def_thread.loops = DEF_LOOPS; 1025 def_thread.verify = DEF_VERIFY; 1026 def_thread.stonewall = DEF_STONEWALL; 1027 def_thread.numjobs = DEF_NUMJOBS; 1028 def_thread.use_thread = DEF_USE_THREAD; 1029 def_thread.rwmixcycle = DEF_RWMIX_CYCLE; 1030 def_thread.rwmixread = DEF_RWMIX_READ; 1031 def_thread.nice = DEF_NICE; 1032 def_thread.rand_repeatable = DEF_RAND_REPEAT; 1033 def_thread.nr_files = DEF_NR_FILES; 1034 def_thread.unlink = DEF_UNLINK; 1035 def_thread.write_bw_log = write_bw_log; 1036 def_thread.write_lat_log = write_lat_log; 1037 def_thread.norandommap = DEF_NO_RAND_MAP; 1038#ifdef FIO_HAVE_DISK_UTIL 1039 def_thread.do_disk_util = 1; 1040#endif 1041 1042 return 0; 1043} 1044 1045static void usage(void) 1046{ 1047 printf("%s\n", fio_version_string); 1048 printf("\t--output\tWrite output to file\n"); 1049 printf("\t--timeout\tRuntime in seconds\n"); 1050 printf("\t--latency-log\tGenerate per-job latency logs\n"); 1051 printf("\t--bandwidth-log\tGenerate per-job bandwidth logs\n"); 1052 printf("\t--minimal\tMinimal (terse) output\n"); 1053 printf("\t--version\tPrint version info and exit\n"); 1054} 1055 1056static int parse_cmd_line(int argc, char *argv[]) 1057{ 1058 struct thread_data *td = NULL; 1059 int c, ini_idx = 0, lidx, ret; 1060 1061 while ((c = getopt_long(argc, argv, "", long_options, &lidx)) != -1) { 1062 switch (c) { 1063 case 't': 1064 def_timeout = atoi(optarg); 1065 break; 1066 case 'l': 1067 write_lat_log = 1; 1068 break; 1069 case 'w': 1070 write_bw_log = 1; 1071 break; 1072 case 'o': 1073 f_out = fopen(optarg, "w+"); 1074 if (!f_out) { 1075 perror("fopen output"); 1076 exit(1); 1077 } 1078 f_err = f_out; 1079 break; 1080 case 'm': 1081 terse_output = 1; 1082 break; 1083 case 'h': 1084 usage(); 1085 exit(0); 1086 case 'v': 1087 printf("%s\n", fio_version_string); 1088 exit(0); 1089 case FIO_GETOPT_JOB: { 1090 const char *opt = long_options[lidx].name; 1091 char *val = optarg; 1092 1093 if (!strncmp(opt, "name", 4) && td) { 1094 ret = add_job(td, td->name ?: "fio", 0); 1095 if (ret) { 1096 put_job(td); 1097 return 0; 1098 } 1099 td = NULL; 1100 } 1101 if (!td) { 1102 int global = !strncmp(val, "global", 6); 1103 1104 td = get_new_job(global, &def_thread); 1105 if (!td) 1106 return 0; 1107 } 1108 1109 ret = parse_cmd_option(opt, val, options, td); 1110 if (ret) { 1111 log_err("fio: job dropped\n"); 1112 put_job(td); 1113 td = NULL; 1114 } 1115 break; 1116 } 1117 default: 1118 printf("optarg <<%s>>\n", argv[optind]); 1119 break; 1120 } 1121 } 1122 1123 if (td) { 1124 ret = add_job(td, td->name ?: "fio", 0); 1125 if (ret) 1126 put_job(td); 1127 } 1128 1129 while (optind < argc) { 1130 ini_idx++; 1131 ini_file = realloc(ini_file, ini_idx * sizeof(char *)); 1132 ini_file[ini_idx - 1] = strdup(argv[optind]); 1133 optind++; 1134 } 1135 1136 return ini_idx; 1137} 1138 1139static void free_shm(void) 1140{ 1141 struct shmid_ds sbuf; 1142 1143 if (threads) { 1144 shmdt((void *) threads); 1145 threads = NULL; 1146 shmctl(shm_id, IPC_RMID, &sbuf); 1147 } 1148} 1149 1150/* 1151 * The thread area is shared between the main process and the job 1152 * threads/processes. So setup a shared memory segment that will hold 1153 * all the job info. 1154 */ 1155static int setup_thread_area(void) 1156{ 1157 /* 1158 * 1024 is too much on some machines, scale max_jobs if 1159 * we get a failure that looks like too large a shm segment 1160 */ 1161 do { 1162 size_t size = max_jobs * sizeof(struct thread_data); 1163 1164 shm_id = shmget(0, size, IPC_CREAT | 0600); 1165 if (shm_id != -1) 1166 break; 1167 if (errno != EINVAL) { 1168 perror("shmget"); 1169 break; 1170 } 1171 1172 max_jobs >>= 1; 1173 } while (max_jobs); 1174 1175 if (shm_id == -1) 1176 return 1; 1177 1178 threads = shmat(shm_id, NULL, 0); 1179 if (threads == (void *) -1) { 1180 perror("shmat"); 1181 return 1; 1182 } 1183 1184 atexit(free_shm); 1185 return 0; 1186} 1187 1188/* 1189 * Copy the fio options into the long options map, so we mirror 1190 * job and cmd line options. 1191 */ 1192static void dupe_job_options(void) 1193{ 1194 struct fio_option *o; 1195 unsigned int i; 1196 1197 i = 0; 1198 while (long_options[i].name) 1199 i++; 1200 1201 o = &options[0]; 1202 while (o->name) { 1203 long_options[i].name = o->name; 1204 long_options[i].val = FIO_GETOPT_JOB; 1205 if (o->type == FIO_OPT_STR_SET) 1206 long_options[i].has_arg = no_argument; 1207 else 1208 long_options[i].has_arg = required_argument; 1209 1210 i++; 1211 o++; 1212 assert(i < FIO_JOB_OPTS + FIO_CMD_OPTS); 1213 } 1214} 1215 1216int parse_options(int argc, char *argv[]) 1217{ 1218 int job_files, i; 1219 1220 f_out = stdout; 1221 f_err = stderr; 1222 1223 dupe_job_options(); 1224 1225 if (setup_thread_area()) 1226 return 1; 1227 if (fill_def_thread()) 1228 return 1; 1229 1230 job_files = parse_cmd_line(argc, argv); 1231 1232 for (i = 0; i < job_files; i++) { 1233 if (fill_def_thread()) 1234 return 1; 1235 if (parse_jobs_ini(ini_file[i], i)) 1236 return 1; 1237 free(ini_file[i]); 1238 } 1239 1240 free(ini_file); 1241 1242 if (!thread_number) { 1243 log_err("No jobs defined(s)\n"); 1244 return 1; 1245 } 1246 1247 return 0; 1248} 1249