init.c revision 245142ff7554290cf666e3ef6b7b57512bf17d75
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 (1) 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 (0) 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/* 514 * This function leaks the buffer 515 */ 516static char *to_kmg(unsigned int val) 517{ 518 char *buf = malloc(32); 519 char post[] = { 0, 'K', 'M', 'G', 'P', 0 }; 520 char *p = post; 521 522 do { 523 if (val & 1023) 524 break; 525 526 val >>= 10; 527 p++; 528 } while (*p); 529 530 snprintf(buf, 31, "%u%c", val, *p); 531 return buf; 532} 533 534/* 535 * Adds a job to the list of things todo. Sanitizes the various options 536 * to make sure we don't have conflicts, and initializes various 537 * members of td. 538 */ 539static int add_job(struct thread_data *td, const char *jobname, int job_add_num) 540{ 541 const char *ddir_str[] = { "read", "write", "randread", "randwrite", 542 "rw", NULL, "randrw" }; 543 struct stat sb; 544 int numjobs, ddir, i; 545 struct fio_file *f; 546 547 /* 548 * the def_thread is just for options, it's not a real job 549 */ 550 if (td == &def_thread) 551 return 0; 552 553 /* 554 * Set default io engine, if none set 555 */ 556 if (!td->io_ops) { 557 td->io_ops = load_ioengine(td, DEF_IO_ENGINE_NAME); 558 if (!td->io_ops) { 559 log_err("default engine %s not there?\n", DEF_IO_ENGINE_NAME); 560 return 1; 561 } 562 } 563 564 if (td->odirect) 565 td->io_ops->flags |= FIO_RAWIO; 566 567 fixup_options(td); 568 569 td->filetype = FIO_TYPE_FILE; 570 if (!stat(jobname, &sb)) { 571 if (S_ISBLK(sb.st_mode)) 572 td->filetype = FIO_TYPE_BD; 573 else if (S_ISCHR(sb.st_mode)) 574 td->filetype = FIO_TYPE_CHAR; 575 } 576 577 if (td->filename) 578 td->nr_uniq_files = 1; 579 else 580 td->nr_uniq_files = td->nr_files; 581 582 if (td->filetype == FIO_TYPE_FILE || td->filename) { 583 char tmp[PATH_MAX]; 584 int len = 0; 585 int i; 586 587 if (td->directory && td->directory[0] != '\0') 588 sprintf(tmp, "%s/", td->directory); 589 590 td->files = malloc(sizeof(struct fio_file) * td->nr_files); 591 592 for_each_file(td, f, i) { 593 memset(f, 0, sizeof(*f)); 594 f->fd = -1; 595 596 if (td->filename) 597 sprintf(tmp + len, "%s", td->filename); 598 else 599 sprintf(tmp + len, "%s.%d.%d", jobname, td->thread_number, i); 600 f->file_name = strdup(tmp); 601 } 602 } else { 603 td->nr_files = 1; 604 td->files = malloc(sizeof(struct fio_file)); 605 f = &td->files[0]; 606 607 memset(f, 0, sizeof(*f)); 608 f->fd = -1; 609 f->file_name = strdup(jobname); 610 } 611 612 for_each_file(td, f, i) { 613 f->file_size = td->total_file_size / td->nr_files; 614 f->file_offset = td->start_offset; 615 } 616 617 fio_sem_init(&td->mutex, 0); 618 619 td->clat_stat[0].min_val = td->clat_stat[1].min_val = ULONG_MAX; 620 td->slat_stat[0].min_val = td->slat_stat[1].min_val = ULONG_MAX; 621 td->bw_stat[0].min_val = td->bw_stat[1].min_val = ULONG_MAX; 622 623 if (td->stonewall && td->thread_number > 1) 624 groupid++; 625 626 td->groupid = groupid; 627 628 if (setup_rate(td)) 629 goto err; 630 631 if (td->write_lat_log) { 632 setup_log(&td->slat_log); 633 setup_log(&td->clat_log); 634 } 635 if (td->write_bw_log) 636 setup_log(&td->bw_log); 637 638 if (!td->name) 639 td->name = strdup(jobname); 640 641 ddir = td->ddir + (!td->sequential << 1) + (td->iomix << 2); 642 643 if (!terse_output) { 644 if (!job_add_num) { 645 if (td->io_ops->flags & FIO_CPUIO) 646 fprintf(f_out, "%s: ioengine=cpu, cpuload=%u, cpucycle=%u\n", td->name, td->cpuload, td->cpucycle); 647 else { 648 char *c1, *c2, *c3, *c4; 649 650 c1 = to_kmg(td->min_bs[DDIR_READ]); 651 c2 = to_kmg(td->max_bs[DDIR_READ]); 652 c3 = to_kmg(td->min_bs[DDIR_WRITE]); 653 c4 = to_kmg(td->max_bs[DDIR_WRITE]); 654 655 fprintf(f_out, "%s: (g=%d): rw=%s, odir=%d, bs=%s-%s/%s-%s, rate=%d, ioengine=%s, iodepth=%d\n", td->name, td->groupid, ddir_str[ddir], td->odirect, c1, c2, c3, c4, td->rate, td->io_ops->name, td->iodepth); 656 657 free(c1); 658 free(c2); 659 free(c3); 660 free(c4); 661 } 662 } else if (job_add_num == 1) 663 fprintf(f_out, "...\n"); 664 } 665 666 /* 667 * recurse add identical jobs, clear numjobs and stonewall options 668 * as they don't apply to sub-jobs 669 */ 670 numjobs = td->numjobs; 671 while (--numjobs) { 672 struct thread_data *td_new = get_new_job(0, td); 673 674 if (!td_new) 675 goto err; 676 677 td_new->numjobs = 1; 678 td_new->stonewall = 0; 679 job_add_num = numjobs - 1; 680 681 if (add_job(td_new, jobname, job_add_num)) 682 goto err; 683 } 684 return 0; 685err: 686 put_job(td); 687 return -1; 688} 689 690/* 691 * Initialize the various random states we need (random io, block size ranges, 692 * read/write mix, etc). 693 */ 694int init_random_state(struct thread_data *td) 695{ 696 unsigned long seeds[4]; 697 int fd, num_maps, blocks, i; 698 struct fio_file *f; 699 700 if (td->io_ops->flags & FIO_CPUIO) 701 return 0; 702 703 fd = open("/dev/urandom", O_RDONLY); 704 if (fd == -1) { 705 td_verror(td, errno); 706 return 1; 707 } 708 709 if (read(fd, seeds, sizeof(seeds)) < (int) sizeof(seeds)) { 710 td_verror(td, EIO); 711 close(fd); 712 return 1; 713 } 714 715 close(fd); 716 717 os_random_seed(seeds[0], &td->bsrange_state); 718 os_random_seed(seeds[1], &td->verify_state); 719 os_random_seed(seeds[2], &td->rwmix_state); 720 721 if (td->sequential) 722 return 0; 723 724 if (td->rand_repeatable) 725 seeds[3] = DEF_RANDSEED; 726 727 if (!td->norandommap) { 728 for_each_file(td, f, i) { 729 blocks = (f->file_size + td->rw_min_bs - 1) / td->rw_min_bs; 730 num_maps = (blocks + BLOCKS_PER_MAP-1)/ BLOCKS_PER_MAP; 731 f->file_map = malloc(num_maps * sizeof(long)); 732 f->num_maps = num_maps; 733 memset(f->file_map, 0, num_maps * sizeof(long)); 734 } 735 } 736 737 os_random_seed(seeds[3], &td->random_state); 738 return 0; 739} 740 741static void fill_cpu_mask(os_cpu_mask_t cpumask, int cpu) 742{ 743#ifdef FIO_HAVE_CPU_AFFINITY 744 unsigned int i; 745 746 CPU_ZERO(&cpumask); 747 748 for (i = 0; i < sizeof(int) * 8; i++) { 749 if ((1 << i) & cpu) 750 CPU_SET(i, &cpumask); 751 } 752#endif 753} 754 755static int is_empty_or_comment(char *line) 756{ 757 unsigned int i; 758 759 for (i = 0; i < strlen(line); i++) { 760 if (line[i] == ';') 761 return 1; 762 if (!isspace(line[i]) && !iscntrl(line[i])) 763 return 0; 764 } 765 766 return 1; 767} 768 769static int str_rw_cb(void *data, const char *mem) 770{ 771 struct thread_data *td = data; 772 773 if (!strncmp(mem, "read", 4) || !strncmp(mem, "0", 1)) { 774 td->ddir = DDIR_READ; 775 td->sequential = 1; 776 return 0; 777 } else if (!strncmp(mem, "randread", 8)) { 778 td->ddir = DDIR_READ; 779 td->sequential = 0; 780 return 0; 781 } else if (!strncmp(mem, "write", 5) || !strncmp(mem, "1", 1)) { 782 td->ddir = DDIR_WRITE; 783 td->sequential = 1; 784 return 0; 785 } else if (!strncmp(mem, "randwrite", 9)) { 786 td->ddir = DDIR_WRITE; 787 td->sequential = 0; 788 return 0; 789 } else if (!strncmp(mem, "rw", 2)) { 790 td->ddir = 0; 791 td->iomix = 1; 792 td->sequential = 1; 793 return 0; 794 } else if (!strncmp(mem, "randrw", 6)) { 795 td->ddir = 0; 796 td->iomix = 1; 797 td->sequential = 0; 798 return 0; 799 } 800 801 log_err("fio: data direction: read, write, randread, randwrite, rw, randrw\n"); 802 return 1; 803} 804 805static int str_verify_cb(void *data, const char *mem) 806{ 807 struct thread_data *td = data; 808 809 if (!strncmp(mem, "0", 1)) { 810 td->verify = VERIFY_NONE; 811 return 0; 812 } else if (!strncmp(mem, "md5", 3) || !strncmp(mem, "1", 1)) { 813 td->verify = VERIFY_MD5; 814 return 0; 815 } else if (!strncmp(mem, "crc32", 5)) { 816 td->verify = VERIFY_CRC32; 817 return 0; 818 } 819 820 log_err("fio: verify types: md5, crc32\n"); 821 return 1; 822} 823 824static int str_mem_cb(void *data, const char *mem) 825{ 826 struct thread_data *td = data; 827 828 if (!strncmp(mem, "malloc", 6)) { 829 td->mem_type = MEM_MALLOC; 830 return 0; 831 } else if (!strncmp(mem, "shm", 3)) { 832 td->mem_type = MEM_SHM; 833 return 0; 834 } else if (!strncmp(mem, "mmap", 4)) { 835 td->mem_type = MEM_MMAP; 836 return 0; 837 } 838 839 log_err("fio: mem type: malloc, shm, mmap\n"); 840 return 1; 841} 842 843static int str_ioengine_cb(void *data, const char *str) 844{ 845 struct thread_data *td = data; 846 847 td->io_ops = load_ioengine(td, str); 848 if (td->io_ops) 849 return 0; 850 851 log_err("fio: ioengine: { linuxaio, aio, libaio }, posixaio, sync, mmap, sgio, splice, cpu\n"); 852 log_err("fio: or specify path to dynamic ioengine module\n"); 853 return 1; 854} 855 856static int str_lockmem_cb(void fio_unused *data, unsigned long *val) 857{ 858 mlock_size = *val; 859 return 0; 860} 861 862#ifdef FIO_HAVE_IOPRIO 863static int str_prioclass_cb(void *data, unsigned int *val) 864{ 865 struct thread_data *td = data; 866 867 td->ioprio |= *val << IOPRIO_CLASS_SHIFT; 868 return 0; 869} 870 871static int str_prio_cb(void *data, unsigned int *val) 872{ 873 struct thread_data *td = data; 874 875 td->ioprio |= *val; 876 return 0; 877} 878#endif 879 880static int str_exitall_cb(void) 881{ 882 exitall_on_terminate = 1; 883 return 0; 884} 885 886static int str_cpumask_cb(void *data, unsigned int *val) 887{ 888 struct thread_data *td = data; 889 890 fill_cpu_mask(td->cpumask, *val); 891 return 0; 892} 893 894/* 895 * This is our [ini] type file parser. 896 */ 897int parse_jobs_ini(char *file, int stonewall_flag) 898{ 899 unsigned int global; 900 struct thread_data *td; 901 char *string, *name; 902 fpos_t off; 903 FILE *f; 904 char *p; 905 int ret = 0, stonewall; 906 907 f = fopen(file, "r"); 908 if (!f) { 909 perror("fopen job file"); 910 return 1; 911 } 912 913 string = malloc(4096); 914 name = malloc(256); 915 memset(name, 0, 256); 916 917 stonewall = stonewall_flag; 918 do { 919 p = fgets(string, 4095, f); 920 if (!p) 921 break; 922 if (is_empty_or_comment(p)) 923 continue; 924 if (sscanf(p, "[%255s]", name) != 1) 925 continue; 926 927 global = !strncmp(name, "global", 6); 928 929 name[strlen(name) - 1] = '\0'; 930 931 td = get_new_job(global, &def_thread); 932 if (!td) { 933 ret = 1; 934 break; 935 } 936 937 /* 938 * Seperate multiple job files by a stonewall 939 */ 940 if (!global && stonewall) { 941 td->stonewall = stonewall; 942 stonewall = 0; 943 } 944 945 fgetpos(f, &off); 946 while ((p = fgets(string, 4096, f)) != NULL) { 947 if (is_empty_or_comment(p)) 948 continue; 949 950 strip_blank_front(&p); 951 952 if (p[0] == '[') 953 break; 954 955 strip_blank_end(p); 956 957 fgetpos(f, &off); 958 959 /* 960 * Don't break here, continue parsing options so we 961 * dump all the bad ones. Makes trial/error fixups 962 * easier on the user. 963 */ 964 ret |= parse_option(p, options, td); 965 } 966 967 if (!ret) { 968 fsetpos(f, &off); 969 ret = add_job(td, name, 0); 970 } else { 971 log_err("fio: job %s dropped\n", name); 972 put_job(td); 973 } 974 } while (!ret); 975 976 free(string); 977 free(name); 978 fclose(f); 979 return ret; 980} 981 982static int fill_def_thread(void) 983{ 984 memset(&def_thread, 0, sizeof(def_thread)); 985 986 if (fio_getaffinity(getpid(), &def_thread.cpumask) == -1) { 987 perror("sched_getaffinity"); 988 return 1; 989 } 990 991 /* 992 * fill globals 993 */ 994 def_thread.ddir = DDIR_READ; 995 def_thread.iomix = 0; 996 def_thread.bs[DDIR_READ] = DEF_BS; 997 def_thread.bs[DDIR_WRITE] = DEF_BS; 998 def_thread.min_bs[DDIR_READ] = def_thread.min_bs[DDIR_WRITE] = 0; 999 def_thread.max_bs[DDIR_READ] = def_thread.max_bs[DDIR_WRITE] = 0; 1000 def_thread.odirect = DEF_ODIRECT; 1001 def_thread.ratecycle = DEF_RATE_CYCLE; 1002 def_thread.sequential = DEF_SEQUENTIAL; 1003 def_thread.timeout = def_timeout; 1004 def_thread.overwrite = DEF_OVERWRITE; 1005 def_thread.invalidate_cache = DEF_INVALIDATE; 1006 def_thread.sync_io = DEF_SYNCIO; 1007 def_thread.mem_type = MEM_MALLOC; 1008 def_thread.bw_avg_time = DEF_BWAVGTIME; 1009 def_thread.create_serialize = DEF_CREATE_SER; 1010 def_thread.create_fsync = DEF_CREATE_FSYNC; 1011 def_thread.loops = DEF_LOOPS; 1012 def_thread.verify = DEF_VERIFY; 1013 def_thread.stonewall = DEF_STONEWALL; 1014 def_thread.numjobs = DEF_NUMJOBS; 1015 def_thread.use_thread = DEF_USE_THREAD; 1016 def_thread.rwmixcycle = DEF_RWMIX_CYCLE; 1017 def_thread.rwmixread = DEF_RWMIX_READ; 1018 def_thread.nice = DEF_NICE; 1019 def_thread.rand_repeatable = DEF_RAND_REPEAT; 1020 def_thread.nr_files = DEF_NR_FILES; 1021 def_thread.unlink = DEF_UNLINK; 1022 def_thread.write_bw_log = write_bw_log; 1023 def_thread.write_lat_log = write_lat_log; 1024 def_thread.norandommap = DEF_NO_RAND_MAP; 1025#ifdef FIO_HAVE_DISK_UTIL 1026 def_thread.do_disk_util = 1; 1027#endif 1028 1029 return 0; 1030} 1031 1032static void usage(void) 1033{ 1034 printf("%s\n", fio_version_string); 1035 printf("\t--output\tWrite output to file\n"); 1036 printf("\t--timeout\tRuntime in seconds\n"); 1037 printf("\t--latency-log\tGenerate per-job latency logs\n"); 1038 printf("\t--bandwidth-log\tGenerate per-job bandwidth logs\n"); 1039 printf("\t--minimal\tMinimal (terse) output\n"); 1040 printf("\t--version\tPrint version info and exit\n"); 1041} 1042 1043static int parse_cmd_line(int argc, char *argv[]) 1044{ 1045 struct thread_data *td = NULL; 1046 int c, ini_idx = 0, lidx, ret; 1047 1048 while ((c = getopt_long(argc, argv, "", long_options, &lidx)) != -1) { 1049 switch (c) { 1050 case 't': 1051 def_timeout = atoi(optarg); 1052 break; 1053 case 'l': 1054 write_lat_log = 1; 1055 break; 1056 case 'w': 1057 write_bw_log = 1; 1058 break; 1059 case 'o': 1060 f_out = fopen(optarg, "w+"); 1061 if (!f_out) { 1062 perror("fopen output"); 1063 exit(1); 1064 } 1065 f_err = f_out; 1066 break; 1067 case 'm': 1068 terse_output = 1; 1069 break; 1070 case 'h': 1071 usage(); 1072 exit(0); 1073 case 'v': 1074 printf("%s\n", fio_version_string); 1075 exit(0); 1076 case FIO_GETOPT_JOB: { 1077 const char *opt = long_options[lidx].name; 1078 char *val = optarg; 1079 1080 if (!strncmp(opt, "name", 4) && td) { 1081 ret = add_job(td, td->name ?: "fio", 0); 1082 if (ret) { 1083 put_job(td); 1084 return 0; 1085 } 1086 td = NULL; 1087 } 1088 if (!td) { 1089 int global = !strncmp(val, "global", 6); 1090 1091 td = get_new_job(global, &def_thread); 1092 if (!td) 1093 return 0; 1094 } 1095 1096 ret = parse_cmd_option(opt, val, options, td); 1097 if (ret) { 1098 log_err("fio: job dropped\n"); 1099 put_job(td); 1100 td = NULL; 1101 } 1102 break; 1103 } 1104 default: 1105 printf("optarg <<%s>>\n", argv[optind]); 1106 break; 1107 } 1108 } 1109 1110 if (td) { 1111 ret = add_job(td, td->name ?: "fio", 0); 1112 if (ret) 1113 put_job(td); 1114 } 1115 1116 while (optind < argc) { 1117 ini_idx++; 1118 ini_file = realloc(ini_file, ini_idx * sizeof(char *)); 1119 ini_file[ini_idx - 1] = strdup(argv[optind]); 1120 optind++; 1121 } 1122 1123 return ini_idx; 1124} 1125 1126static void free_shm(void) 1127{ 1128 struct shmid_ds sbuf; 1129 1130 if (threads) { 1131 shmdt((void *) threads); 1132 threads = NULL; 1133 shmctl(shm_id, IPC_RMID, &sbuf); 1134 } 1135} 1136 1137/* 1138 * The thread area is shared between the main process and the job 1139 * threads/processes. So setup a shared memory segment that will hold 1140 * all the job info. 1141 */ 1142static int setup_thread_area(void) 1143{ 1144 /* 1145 * 1024 is too much on some machines, scale max_jobs if 1146 * we get a failure that looks like too large a shm segment 1147 */ 1148 do { 1149 size_t size = max_jobs * sizeof(struct thread_data); 1150 1151 shm_id = shmget(0, size, IPC_CREAT | 0600); 1152 if (shm_id != -1) 1153 break; 1154 if (errno != EINVAL) { 1155 perror("shmget"); 1156 break; 1157 } 1158 1159 max_jobs >>= 1; 1160 } while (max_jobs); 1161 1162 if (shm_id == -1) 1163 return 1; 1164 1165 threads = shmat(shm_id, NULL, 0); 1166 if (threads == (void *) -1) { 1167 perror("shmat"); 1168 return 1; 1169 } 1170 1171 atexit(free_shm); 1172 return 0; 1173} 1174 1175/* 1176 * Copy the fio options into the long options map, so we mirror 1177 * job and cmd line options. 1178 */ 1179static void dupe_job_options(void) 1180{ 1181 struct fio_option *o; 1182 unsigned int i; 1183 1184 i = 0; 1185 while (long_options[i].name) 1186 i++; 1187 1188 o = &options[0]; 1189 while (o->name) { 1190 long_options[i].name = o->name; 1191 long_options[i].val = FIO_GETOPT_JOB; 1192 if (o->type == FIO_OPT_STR_SET) 1193 long_options[i].has_arg = no_argument; 1194 else 1195 long_options[i].has_arg = required_argument; 1196 1197 i++; 1198 o++; 1199 assert(i < FIO_JOB_OPTS + FIO_CMD_OPTS); 1200 } 1201} 1202 1203int parse_options(int argc, char *argv[]) 1204{ 1205 int job_files, i; 1206 1207 f_out = stdout; 1208 f_err = stderr; 1209 1210 dupe_job_options(); 1211 1212 if (setup_thread_area()) 1213 return 1; 1214 if (fill_def_thread()) 1215 return 1; 1216 1217 job_files = parse_cmd_line(argc, argv); 1218 1219 for (i = 0; i < job_files; i++) { 1220 if (fill_def_thread()) 1221 return 1; 1222 if (parse_jobs_ini(ini_file[i], i)) 1223 return 1; 1224 free(ini_file[i]); 1225 } 1226 1227 free(ini_file); 1228 1229 if (!thread_number) { 1230 log_err("No jobs defined(s)\n"); 1231 return 1; 1232 } 1233 1234 return 0; 1235} 1236