1#include <unistd.h> 2#include <fcntl.h> 3#include <string.h> 4#include <assert.h> 5#include <dirent.h> 6#include <libgen.h> 7#include <sys/stat.h> 8#include <sys/mman.h> 9#include <sys/types.h> 10 11#include "fio.h" 12#include "smalloc.h" 13#include "filehash.h" 14#include "options.h" 15#include "os/os.h" 16#include "hash.h" 17#include "lib/axmap.h" 18 19#ifdef CONFIG_LINUX_FALLOCATE 20#include <linux/falloc.h> 21#endif 22 23static int root_warn; 24 25static FLIST_HEAD(filename_list); 26 27/* 28 * List entry for filename_list 29 */ 30struct file_name { 31 struct flist_head list; 32 char *filename; 33}; 34 35static inline void clear_error(struct thread_data *td) 36{ 37 td->error = 0; 38 td->verror[0] = '\0'; 39} 40 41/* 42 * Leaves f->fd open on success, caller must close 43 */ 44static int extend_file(struct thread_data *td, struct fio_file *f) 45{ 46 int r, new_layout = 0, unlink_file = 0, flags; 47 unsigned long long left; 48 unsigned int bs; 49 char *b = NULL; 50 51 if (read_only) { 52 log_err("fio: refusing extend of file due to read-only\n"); 53 return 0; 54 } 55 56 /* 57 * check if we need to lay the file out complete again. fio 58 * does that for operations involving reads, or for writes 59 * where overwrite is set 60 */ 61 if (td_read(td) || 62 (td_write(td) && td->o.overwrite && !td->o.file_append) || 63 (td_write(td) && td_ioengine_flagged(td, FIO_NOEXTEND))) 64 new_layout = 1; 65 if (td_write(td) && !td->o.overwrite && !td->o.file_append) 66 unlink_file = 1; 67 68 if (unlink_file || new_layout) { 69 int ret; 70 71 dprint(FD_FILE, "layout unlink %s\n", f->file_name); 72 73 ret = td_io_unlink_file(td, f); 74 if (ret != 0 && ret != ENOENT) { 75 td_verror(td, errno, "unlink"); 76 return 1; 77 } 78 } 79 80 flags = O_WRONLY; 81 if (td->o.allow_create) 82 flags |= O_CREAT; 83 if (new_layout) 84 flags |= O_TRUNC; 85 86#ifdef WIN32 87 flags |= _O_BINARY; 88#endif 89 90 dprint(FD_FILE, "open file %s, flags %x\n", f->file_name, flags); 91 f->fd = open(f->file_name, flags, 0644); 92 if (f->fd < 0) { 93 int err = errno; 94 95 if (err == ENOENT && !td->o.allow_create) 96 log_err("fio: file creation disallowed by " 97 "allow_file_create=0\n"); 98 else 99 td_verror(td, err, "open"); 100 return 1; 101 } 102 103#ifdef CONFIG_POSIX_FALLOCATE 104 if (!td->o.fill_device) { 105 switch (td->o.fallocate_mode) { 106 case FIO_FALLOCATE_NONE: 107 break; 108 case FIO_FALLOCATE_POSIX: 109 dprint(FD_FILE, "posix_fallocate file %s size %llu\n", 110 f->file_name, 111 (unsigned long long) f->real_file_size); 112 113 r = posix_fallocate(f->fd, 0, f->real_file_size); 114 if (r > 0) { 115 log_err("fio: posix_fallocate fails: %s\n", 116 strerror(r)); 117 } 118 break; 119#ifdef CONFIG_LINUX_FALLOCATE 120 case FIO_FALLOCATE_KEEP_SIZE: 121 dprint(FD_FILE, 122 "fallocate(FALLOC_FL_KEEP_SIZE) " 123 "file %s size %llu\n", f->file_name, 124 (unsigned long long) f->real_file_size); 125 126 r = fallocate(f->fd, FALLOC_FL_KEEP_SIZE, 0, 127 f->real_file_size); 128 if (r != 0) 129 td_verror(td, errno, "fallocate"); 130 131 break; 132#endif /* CONFIG_LINUX_FALLOCATE */ 133 default: 134 log_err("fio: unknown fallocate mode: %d\n", 135 td->o.fallocate_mode); 136 assert(0); 137 } 138 } 139#endif /* CONFIG_POSIX_FALLOCATE */ 140 141 /* 142 * If our jobs don't require regular files initially, we're done. 143 */ 144 if (!new_layout) 145 goto done; 146 147 /* 148 * The size will be -1ULL when fill_device is used, so don't truncate 149 * or fallocate this file, just write it 150 */ 151 if (!td->o.fill_device) { 152 dprint(FD_FILE, "truncate file %s, size %llu\n", f->file_name, 153 (unsigned long long) f->real_file_size); 154 if (ftruncate(f->fd, f->real_file_size) == -1) { 155 if (errno != EFBIG) { 156 td_verror(td, errno, "ftruncate"); 157 goto err; 158 } 159 } 160 } 161 162 left = f->real_file_size; 163 bs = td->o.max_bs[DDIR_WRITE]; 164 if (bs > left) 165 bs = left; 166 167 b = malloc(bs); 168 if (!b) { 169 td_verror(td, errno, "malloc"); 170 goto err; 171 } 172 173 while (left && !td->terminate) { 174 if (bs > left) 175 bs = left; 176 177 fill_io_buffer(td, b, bs, bs); 178 179 r = write(f->fd, b, bs); 180 181 if (r > 0) { 182 left -= r; 183 continue; 184 } else { 185 if (r < 0) { 186 int __e = errno; 187 188 if (__e == ENOSPC) { 189 if (td->o.fill_device) 190 break; 191 log_info("fio: ENOSPC on laying out " 192 "file, stopping\n"); 193 break; 194 } 195 td_verror(td, errno, "write"); 196 } else 197 td_verror(td, EIO, "write"); 198 199 break; 200 } 201 } 202 203 if (td->terminate) { 204 dprint(FD_FILE, "terminate unlink %s\n", f->file_name); 205 td_io_unlink_file(td, f); 206 } else if (td->o.create_fsync) { 207 if (fsync(f->fd) < 0) { 208 td_verror(td, errno, "fsync"); 209 goto err; 210 } 211 } 212 if (td->o.fill_device && !td_write(td)) { 213 fio_file_clear_size_known(f); 214 if (td_io_get_file_size(td, f)) 215 goto err; 216 if (f->io_size > f->real_file_size) 217 f->io_size = f->real_file_size; 218 } 219 220 free(b); 221done: 222 return 0; 223err: 224 close(f->fd); 225 f->fd = -1; 226 if (b) 227 free(b); 228 return 1; 229} 230 231static int pre_read_file(struct thread_data *td, struct fio_file *f) 232{ 233 int ret = 0, r, did_open = 0, old_runstate; 234 unsigned long long left; 235 unsigned int bs; 236 char *b; 237 238 if (td_ioengine_flagged(td, FIO_PIPEIO) || 239 td_ioengine_flagged(td, FIO_NOIO)) 240 return 0; 241 242 if (f->filetype == FIO_TYPE_CHAR) 243 return 0; 244 245 if (!fio_file_open(f)) { 246 if (td->io_ops->open_file(td, f)) { 247 log_err("fio: cannot pre-read, failed to open file\n"); 248 return 1; 249 } 250 did_open = 1; 251 } 252 253 old_runstate = td_bump_runstate(td, TD_PRE_READING); 254 255 left = f->io_size; 256 bs = td->o.max_bs[DDIR_READ]; 257 if (bs > left) 258 bs = left; 259 260 b = malloc(bs); 261 if (!b) { 262 td_verror(td, errno, "malloc"); 263 ret = 1; 264 goto error; 265 } 266 memset(b, 0, bs); 267 268 if (lseek(f->fd, f->file_offset, SEEK_SET) < 0) { 269 td_verror(td, errno, "lseek"); 270 log_err("fio: failed to lseek pre-read file\n"); 271 ret = 1; 272 goto error; 273 } 274 275 while (left && !td->terminate) { 276 if (bs > left) 277 bs = left; 278 279 r = read(f->fd, b, bs); 280 281 if (r == (int) bs) { 282 left -= bs; 283 continue; 284 } else { 285 td_verror(td, EIO, "pre_read"); 286 break; 287 } 288 } 289 290error: 291 td_restore_runstate(td, old_runstate); 292 293 if (did_open) 294 td->io_ops->close_file(td, f); 295 296 free(b); 297 return ret; 298} 299 300unsigned long long get_rand_file_size(struct thread_data *td) 301{ 302 unsigned long long ret, sized; 303 uint64_t frand_max; 304 unsigned long r; 305 306 frand_max = rand_max(&td->file_size_state); 307 r = __rand(&td->file_size_state); 308 sized = td->o.file_size_high - td->o.file_size_low; 309 ret = (unsigned long long) ((double) sized * (r / (frand_max + 1.0))); 310 ret += td->o.file_size_low; 311 ret -= (ret % td->o.rw_min_bs); 312 return ret; 313} 314 315static int file_size(struct thread_data *td, struct fio_file *f) 316{ 317 struct stat st; 318 319 if (stat(f->file_name, &st) == -1) { 320 td_verror(td, errno, "fstat"); 321 return 1; 322 } 323 324 f->real_file_size = st.st_size; 325 return 0; 326} 327 328static int bdev_size(struct thread_data *td, struct fio_file *f) 329{ 330 unsigned long long bytes = 0; 331 int r; 332 333 if (td->io_ops->open_file(td, f)) { 334 log_err("fio: failed opening blockdev %s for size check\n", 335 f->file_name); 336 return 1; 337 } 338 339 r = blockdev_size(f, &bytes); 340 if (r) { 341 td_verror(td, r, "blockdev_size"); 342 goto err; 343 } 344 345 if (!bytes) { 346 log_err("%s: zero sized block device?\n", f->file_name); 347 goto err; 348 } 349 350 f->real_file_size = bytes; 351 td->io_ops->close_file(td, f); 352 return 0; 353err: 354 td->io_ops->close_file(td, f); 355 return 1; 356} 357 358static int char_size(struct thread_data *td, struct fio_file *f) 359{ 360#ifdef FIO_HAVE_CHARDEV_SIZE 361 unsigned long long bytes = 0; 362 int r; 363 364 if (td->io_ops->open_file(td, f)) { 365 log_err("fio: failed opening chardev %s for size check\n", 366 f->file_name); 367 return 1; 368 } 369 370 r = chardev_size(f, &bytes); 371 if (r) { 372 td_verror(td, r, "chardev_size"); 373 goto err; 374 } 375 376 if (!bytes) { 377 log_err("%s: zero sized char device?\n", f->file_name); 378 goto err; 379 } 380 381 f->real_file_size = bytes; 382 td->io_ops->close_file(td, f); 383 return 0; 384err: 385 td->io_ops->close_file(td, f); 386 return 1; 387#else 388 f->real_file_size = -1ULL; 389 return 0; 390#endif 391} 392 393static int get_file_size(struct thread_data *td, struct fio_file *f) 394{ 395 int ret = 0; 396 397 if (fio_file_size_known(f)) 398 return 0; 399 400 if (f->filetype == FIO_TYPE_FILE) 401 ret = file_size(td, f); 402 else if (f->filetype == FIO_TYPE_BLOCK) 403 ret = bdev_size(td, f); 404 else if (f->filetype == FIO_TYPE_CHAR) 405 ret = char_size(td, f); 406 else 407 f->real_file_size = -1ULL; 408 409 /* 410 * Leave ->real_file_size with 0 since it could be expectation 411 * of initial setup for regular files. 412 */ 413 if (ret) 414 return ret; 415 416 /* 417 * If ->real_file_size is -1, a conditional for the message 418 * "offset extends end" is always true, but it makes no sense, 419 * so just return the same value here. 420 */ 421 if (f->real_file_size == -1ULL) { 422 log_info("%s: failed to get file size of %s\n", td->o.name, 423 f->file_name); 424 return 1; 425 } 426 427 if (td->o.start_offset && f->file_offset == 0) 428 dprint(FD_FILE, "offset of file %s not initialized yet\n", 429 f->file_name); 430 /* 431 * ->file_offset normally hasn't been initialized yet, so this 432 * is basically always false. 433 */ 434 if (f->file_offset > f->real_file_size) { 435 log_err("%s: offset extends end (%llu > %llu)\n", td->o.name, 436 (unsigned long long) f->file_offset, 437 (unsigned long long) f->real_file_size); 438 return 1; 439 } 440 441 fio_file_set_size_known(f); 442 return 0; 443} 444 445static int __file_invalidate_cache(struct thread_data *td, struct fio_file *f, 446 unsigned long long off, 447 unsigned long long len) 448{ 449 int errval = 0, ret = 0; 450 451#ifdef CONFIG_ESX 452 return 0; 453#endif 454 455 if (len == -1ULL) 456 len = f->io_size; 457 if (off == -1ULL) 458 off = f->file_offset; 459 460 if (len == -1ULL || off == -1ULL) 461 return 0; 462 463 if (td->io_ops->invalidate) { 464 dprint(FD_IO, "invalidate %s cache %s\n", td->io_ops->name, 465 f->file_name); 466 ret = td->io_ops->invalidate(td, f); 467 if (ret < 0) 468 errval = -ret; 469 } else if (f->filetype == FIO_TYPE_FILE) { 470 dprint(FD_IO, "declare unneeded cache %s: %llu/%llu\n", 471 f->file_name, off, len); 472 ret = posix_fadvise(f->fd, off, len, POSIX_FADV_DONTNEED); 473 if (ret) 474 errval = ret; 475 } else if (f->filetype == FIO_TYPE_BLOCK) { 476 int retry_count = 0; 477 478 dprint(FD_IO, "drop page cache %s\n", f->file_name); 479 ret = blockdev_invalidate_cache(f); 480 while (ret < 0 && errno == EAGAIN && retry_count++ < 25) { 481 /* 482 * Linux multipath devices reject ioctl while 483 * the maps are being updated. That window can 484 * last tens of milliseconds; we'll try up to 485 * a quarter of a second. 486 */ 487 usleep(10000); 488 ret = blockdev_invalidate_cache(f); 489 } 490 if (ret < 0 && errno == EACCES && geteuid()) { 491 if (!root_warn) { 492 log_err("fio: only root may flush block " 493 "devices. Cache flush bypassed!\n"); 494 root_warn = 1; 495 } 496 ret = 0; 497 } 498 if (ret < 0) 499 errval = errno; 500 else if (ret) /* probably not supported */ 501 errval = ret; 502 } else if (f->filetype == FIO_TYPE_CHAR || 503 f->filetype == FIO_TYPE_PIPE) { 504 dprint(FD_IO, "invalidate not supported %s\n", f->file_name); 505 ret = 0; 506 } 507 508 /* 509 * Cache flushing isn't a fatal condition, and we know it will 510 * happen on some platforms where we don't have the proper 511 * function to flush eg block device caches. So just warn and 512 * continue on our way. 513 */ 514 if (errval) 515 log_info("fio: cache invalidation of %s failed: %s\n", 516 f->file_name, strerror(errval)); 517 518 return 0; 519 520} 521 522int file_invalidate_cache(struct thread_data *td, struct fio_file *f) 523{ 524 if (!fio_file_open(f)) 525 return 0; 526 527 return __file_invalidate_cache(td, f, -1ULL, -1ULL); 528} 529 530int generic_close_file(struct thread_data fio_unused *td, struct fio_file *f) 531{ 532 int ret = 0; 533 534 dprint(FD_FILE, "fd close %s\n", f->file_name); 535 536 remove_file_hash(f); 537 538 if (close(f->fd) < 0) 539 ret = errno; 540 541 f->fd = -1; 542 543 if (f->shadow_fd != -1) { 544 close(f->shadow_fd); 545 f->shadow_fd = -1; 546 } 547 548 f->engine_pos = 0; 549 return ret; 550} 551 552int file_lookup_open(struct fio_file *f, int flags) 553{ 554 struct fio_file *__f; 555 int from_hash; 556 557 __f = lookup_file_hash(f->file_name); 558 if (__f) { 559 dprint(FD_FILE, "found file in hash %s\n", f->file_name); 560 f->lock = __f->lock; 561 from_hash = 1; 562 } else { 563 dprint(FD_FILE, "file not found in hash %s\n", f->file_name); 564 from_hash = 0; 565 } 566 567#ifdef WIN32 568 flags |= _O_BINARY; 569#endif 570 571 f->fd = open(f->file_name, flags, 0600); 572 return from_hash; 573} 574 575static int file_close_shadow_fds(struct thread_data *td) 576{ 577 struct fio_file *f; 578 int num_closed = 0; 579 unsigned int i; 580 581 for_each_file(td, f, i) { 582 if (f->shadow_fd == -1) 583 continue; 584 585 close(f->shadow_fd); 586 f->shadow_fd = -1; 587 num_closed++; 588 } 589 590 return num_closed; 591} 592 593int generic_open_file(struct thread_data *td, struct fio_file *f) 594{ 595 int is_std = 0; 596 int flags = 0; 597 int from_hash = 0; 598 599 dprint(FD_FILE, "fd open %s\n", f->file_name); 600 601 if (!strcmp(f->file_name, "-")) { 602 if (td_rw(td)) { 603 log_err("fio: can't read/write to stdin/out\n"); 604 return 1; 605 } 606 is_std = 1; 607 608 /* 609 * move output logging to stderr, if we are writing to stdout 610 */ 611 if (td_write(td)) 612 f_out = stderr; 613 } 614 615 if (td_trim(td)) 616 goto skip_flags; 617 if (td->o.odirect) 618 flags |= OS_O_DIRECT; 619 if (td->o.oatomic) { 620 if (!FIO_O_ATOMIC) { 621 td_verror(td, EINVAL, "OS does not support atomic IO"); 622 return 1; 623 } 624 flags |= OS_O_DIRECT | FIO_O_ATOMIC; 625 } 626 if (td->o.sync_io) 627 flags |= O_SYNC; 628 if (td->o.create_on_open && td->o.allow_create) 629 flags |= O_CREAT; 630skip_flags: 631 if (f->filetype != FIO_TYPE_FILE) 632 flags |= FIO_O_NOATIME; 633 634open_again: 635 if (td_write(td)) { 636 if (!read_only) 637 flags |= O_RDWR; 638 639 if (f->filetype == FIO_TYPE_FILE && td->o.allow_create) 640 flags |= O_CREAT; 641 642 if (is_std) 643 f->fd = dup(STDOUT_FILENO); 644 else 645 from_hash = file_lookup_open(f, flags); 646 } else if (td_read(td)) { 647 if (f->filetype == FIO_TYPE_CHAR && !read_only) 648 flags |= O_RDWR; 649 else 650 flags |= O_RDONLY; 651 652 if (is_std) 653 f->fd = dup(STDIN_FILENO); 654 else 655 from_hash = file_lookup_open(f, flags); 656 } else if (td_trim(td)) { 657 assert(!td_rw(td)); /* should have matched above */ 658 flags |= O_RDWR; 659 from_hash = file_lookup_open(f, flags); 660 } 661 662 if (f->fd == -1) { 663 char buf[FIO_VERROR_SIZE]; 664 int __e = errno; 665 666 if (__e == EPERM && (flags & FIO_O_NOATIME)) { 667 flags &= ~FIO_O_NOATIME; 668 goto open_again; 669 } 670 if (__e == EMFILE && file_close_shadow_fds(td)) 671 goto open_again; 672 673 snprintf(buf, sizeof(buf), "open(%s)", f->file_name); 674 675 if (__e == EINVAL && (flags & OS_O_DIRECT)) { 676 log_err("fio: looks like your file system does not " \ 677 "support direct=1/buffered=0\n"); 678 } 679 680 td_verror(td, __e, buf); 681 return 1; 682 } 683 684 if (!from_hash && f->fd != -1) { 685 if (add_file_hash(f)) { 686 int fio_unused ret; 687 688 /* 689 * Stash away descriptor for later close. This is to 690 * work-around a "feature" on Linux, where a close of 691 * an fd that has been opened for write will trigger 692 * udev to call blkid to check partitions, fs id, etc. 693 * That pollutes the device cache, which can slow down 694 * unbuffered accesses. 695 */ 696 if (f->shadow_fd == -1) 697 f->shadow_fd = f->fd; 698 else { 699 /* 700 * OK to ignore, we haven't done anything 701 * with it 702 */ 703 ret = generic_close_file(td, f); 704 } 705 goto open_again; 706 } 707 } 708 709 return 0; 710} 711 712/* 713 * This function i.e. get_file_size() is the default .get_file_size 714 * implementation of majority of I/O engines. 715 */ 716int generic_get_file_size(struct thread_data *td, struct fio_file *f) 717{ 718 return get_file_size(td, f); 719} 720 721/* 722 * open/close all files, so that ->real_file_size gets set 723 */ 724static int get_file_sizes(struct thread_data *td) 725{ 726 struct fio_file *f; 727 unsigned int i; 728 int err = 0; 729 730 for_each_file(td, f, i) { 731 dprint(FD_FILE, "get file size for %p/%d/%s\n", f, i, 732 f->file_name); 733 734 if (td_io_get_file_size(td, f)) { 735 if (td->error != ENOENT) { 736 log_err("%s\n", td->verror); 737 err = 1; 738 break; 739 } 740 clear_error(td); 741 } 742 743 /* 744 * There are corner cases where we end up with -1 for 745 * ->real_file_size due to unsupported file type, etc. 746 * We then just set to size option value divided by number 747 * of files, similar to the way file ->io_size is set. 748 * stat(2) failure doesn't set ->real_file_size to -1. 749 */ 750 if (f->real_file_size == -1ULL && td->o.size) 751 f->real_file_size = td->o.size / td->o.nr_files; 752 } 753 754 return err; 755} 756 757struct fio_mount { 758 struct flist_head list; 759 const char *base; 760 char __base[256]; 761 unsigned int key; 762}; 763 764/* 765 * Get free number of bytes for each file on each unique mount. 766 */ 767static unsigned long long get_fs_free_counts(struct thread_data *td) 768{ 769 struct flist_head *n, *tmp; 770 unsigned long long ret = 0; 771 struct fio_mount *fm; 772 FLIST_HEAD(list); 773 struct fio_file *f; 774 unsigned int i; 775 776 for_each_file(td, f, i) { 777 struct stat sb; 778 char buf[256]; 779 780 if (f->filetype == FIO_TYPE_BLOCK || f->filetype == FIO_TYPE_CHAR) { 781 if (f->real_file_size != -1ULL) 782 ret += f->real_file_size; 783 continue; 784 } else if (f->filetype != FIO_TYPE_FILE) 785 continue; 786 787 buf[255] = '\0'; 788 strncpy(buf, f->file_name, 255); 789 790 if (stat(buf, &sb) < 0) { 791 if (errno != ENOENT) 792 break; 793 strcpy(buf, "."); 794 if (stat(buf, &sb) < 0) 795 break; 796 } 797 798 fm = NULL; 799 flist_for_each(n, &list) { 800 fm = flist_entry(n, struct fio_mount, list); 801 if (fm->key == sb.st_dev) 802 break; 803 804 fm = NULL; 805 } 806 807 if (fm) 808 continue; 809 810 fm = calloc(1, sizeof(*fm)); 811 strncpy(fm->__base, buf, sizeof(fm->__base) - 1); 812 fm->base = basename(fm->__base); 813 fm->key = sb.st_dev; 814 flist_add(&fm->list, &list); 815 } 816 817 flist_for_each_safe(n, tmp, &list) { 818 unsigned long long sz; 819 820 fm = flist_entry(n, struct fio_mount, list); 821 flist_del(&fm->list); 822 823 sz = get_fs_free_size(fm->base); 824 if (sz && sz != -1ULL) 825 ret += sz; 826 827 free(fm); 828 } 829 830 return ret; 831} 832 833uint64_t get_start_offset(struct thread_data *td, struct fio_file *f) 834{ 835 struct thread_options *o = &td->o; 836 837 if (o->file_append && f->filetype == FIO_TYPE_FILE) 838 return f->real_file_size; 839 840 return td->o.start_offset + 841 td->subjob_number * td->o.offset_increment; 842} 843 844/* 845 * Open the files and setup files sizes, creating files if necessary. 846 */ 847int setup_files(struct thread_data *td) 848{ 849 unsigned long long total_size, extend_size; 850 struct thread_options *o = &td->o; 851 struct fio_file *f; 852 unsigned int i, nr_fs_extra = 0; 853 int err = 0, need_extend; 854 int old_state; 855 const unsigned int bs = td_min_bs(td); 856 uint64_t fs = 0; 857 858 dprint(FD_FILE, "setup files\n"); 859 860 old_state = td_bump_runstate(td, TD_SETTING_UP); 861 862 if (o->read_iolog_file) 863 goto done; 864 865 /* 866 * Find out physical size of files or devices for this thread, 867 * before we determine I/O size and range of our targets. 868 * If ioengine defines a setup() method, it's responsible for 869 * opening the files and setting f->real_file_size to indicate 870 * the valid range for that file. 871 */ 872 if (td->io_ops->setup) 873 err = td->io_ops->setup(td); 874 else 875 err = get_file_sizes(td); 876 877 if (err) 878 goto err_out; 879 880 /* 881 * check sizes. if the files/devices do not exist and the size 882 * isn't passed to fio, abort. 883 */ 884 total_size = 0; 885 for_each_file(td, f, i) { 886 f->fileno = i; 887 if (f->real_file_size == -1ULL) 888 total_size = -1ULL; 889 else 890 total_size += f->real_file_size; 891 } 892 893 if (o->fill_device) 894 td->fill_device_size = get_fs_free_counts(td); 895 896 /* 897 * device/file sizes are zero and no size given, punt 898 */ 899 if ((!total_size || total_size == -1ULL) && !o->size && 900 !td_ioengine_flagged(td, FIO_NOIO) && !o->fill_device && 901 !(o->nr_files && (o->file_size_low || o->file_size_high))) { 902 log_err("%s: you need to specify size=\n", o->name); 903 td_verror(td, EINVAL, "total_file_size"); 904 goto err_out; 905 } 906 907 /* 908 * Calculate per-file size and potential extra size for the 909 * first files, if needed (i.e. if we don't have a fixed size). 910 */ 911 if (!o->file_size_low && o->nr_files) { 912 uint64_t all_fs; 913 914 fs = o->size / o->nr_files; 915 all_fs = fs * o->nr_files; 916 917 if (all_fs < o->size) 918 nr_fs_extra = (o->size - all_fs) / bs; 919 } 920 921 /* 922 * now file sizes are known, so we can set ->io_size. if size= is 923 * not given, ->io_size is just equal to ->real_file_size. if size 924 * is given, ->io_size is size / nr_files. 925 */ 926 extend_size = total_size = 0; 927 need_extend = 0; 928 for_each_file(td, f, i) { 929 f->file_offset = get_start_offset(td, f); 930 931 /* 932 * Update ->io_size depending on options specified. 933 * ->file_size_low being 0 means filesize option isn't set. 934 * Non zero ->file_size_low equals ->file_size_high means 935 * filesize option is set in a fixed size format. 936 * Non zero ->file_size_low not equals ->file_size_high means 937 * filesize option is set in a range format. 938 */ 939 if (!o->file_size_low) { 940 /* 941 * no file size or range given, file size is equal to 942 * total size divided by number of files. If the size 943 * doesn't divide nicely with the min blocksize, 944 * make the first files bigger. 945 */ 946 f->io_size = fs; 947 if (nr_fs_extra) { 948 nr_fs_extra--; 949 f->io_size += bs; 950 } 951 952 /* 953 * We normally don't come here for regular files, but 954 * if the result is 0 for a regular file, set it to the 955 * real file size. This could be size of the existing 956 * one if it already exists, but otherwise will be set 957 * to 0. A new file won't be created because 958 * ->io_size + ->file_offset equals ->real_file_size. 959 */ 960 if (!f->io_size) { 961 if (f->file_offset > f->real_file_size) 962 goto err_offset; 963 f->io_size = f->real_file_size - f->file_offset; 964 if (!f->io_size) 965 log_info("fio: file %s may be ignored\n", 966 f->file_name); 967 } 968 } else if (f->real_file_size < o->file_size_low || 969 f->real_file_size > o->file_size_high) { 970 if (f->file_offset > o->file_size_low) 971 goto err_offset; 972 /* 973 * file size given. if it's fixed, use that. if it's a 974 * range, generate a random size in-between. 975 */ 976 if (o->file_size_low == o->file_size_high) 977 f->io_size = o->file_size_low - f->file_offset; 978 else { 979 f->io_size = get_rand_file_size(td) 980 - f->file_offset; 981 } 982 } else 983 f->io_size = f->real_file_size - f->file_offset; 984 985 if (f->io_size == -1ULL) 986 total_size = -1ULL; 987 else { 988 if (o->size_percent) { 989 f->io_size = (f->io_size * o->size_percent) / 100; 990 f->io_size -= (f->io_size % td_min_bs(td)); 991 } 992 total_size += f->io_size; 993 } 994 995 if (f->filetype == FIO_TYPE_FILE && 996 (f->io_size + f->file_offset) > f->real_file_size && 997 !td_ioengine_flagged(td, FIO_DISKLESSIO)) { 998 if (!o->create_on_open) { 999 need_extend++; 1000 extend_size += (f->io_size + f->file_offset); 1001 fio_file_set_extend(f); 1002 } else 1003 f->real_file_size = f->io_size + f->file_offset; 1004 } 1005 } 1006 1007 if (td->o.block_error_hist) { 1008 int len; 1009 1010 assert(td->o.nr_files == 1); /* checked in fixup_options */ 1011 f = td->files[0]; 1012 len = f->io_size / td->o.bs[DDIR_TRIM]; 1013 if (len > MAX_NR_BLOCK_INFOS || len <= 0) { 1014 log_err("fio: cannot calculate block histogram with " 1015 "%d trim blocks, maximum %d\n", 1016 len, MAX_NR_BLOCK_INFOS); 1017 td_verror(td, EINVAL, "block_error_hist"); 1018 goto err_out; 1019 } 1020 1021 td->ts.nr_block_infos = len; 1022 for (i = 0; i < len; i++) 1023 td->ts.block_infos[i] = 1024 BLOCK_INFO(0, BLOCK_STATE_UNINIT); 1025 } else 1026 td->ts.nr_block_infos = 0; 1027 1028 if (!o->size || (total_size && o->size > total_size)) 1029 o->size = total_size; 1030 1031 if (o->size < td_min_bs(td)) { 1032 log_err("fio: blocksize too large for data set\n"); 1033 goto err_out; 1034 } 1035 1036 /* 1037 * See if we need to extend some files, typically needed when our 1038 * target regular files don't exist yet, but our jobs require them 1039 * initially due to read I/Os. 1040 */ 1041 if (need_extend) { 1042 temp_stall_ts = 1; 1043 if (output_format & FIO_OUTPUT_NORMAL) { 1044 log_info("%s: Laying out IO file%s (%u file%s / %s%lluMiB)\n", 1045 o->name, 1046 need_extend > 1 ? "s" : "", 1047 need_extend, 1048 need_extend > 1 ? "s" : "", 1049 need_extend > 1 ? "total " : "", 1050 extend_size >> 20); 1051 } 1052 1053 for_each_file(td, f, i) { 1054 unsigned long long old_len = -1ULL, extend_len = -1ULL; 1055 1056 if (!fio_file_extend(f)) 1057 continue; 1058 1059 assert(f->filetype == FIO_TYPE_FILE); 1060 fio_file_clear_extend(f); 1061 if (!o->fill_device) { 1062 old_len = f->real_file_size; 1063 extend_len = f->io_size + f->file_offset - 1064 old_len; 1065 } 1066 f->real_file_size = (f->io_size + f->file_offset); 1067 err = extend_file(td, f); 1068 if (err) 1069 break; 1070 1071 err = __file_invalidate_cache(td, f, old_len, 1072 extend_len); 1073 1074 /* 1075 * Shut up static checker 1076 */ 1077 if (f->fd != -1) 1078 close(f->fd); 1079 1080 f->fd = -1; 1081 if (err) 1082 break; 1083 } 1084 temp_stall_ts = 0; 1085 } 1086 1087 if (err) 1088 goto err_out; 1089 1090 if (!o->zone_size) 1091 o->zone_size = o->size; 1092 1093 /* 1094 * iolog already set the total io size, if we read back 1095 * stored entries. 1096 */ 1097 if (!o->read_iolog_file) { 1098 if (o->io_size) 1099 td->total_io_size = o->io_size * o->loops; 1100 else 1101 td->total_io_size = o->size * o->loops; 1102 } 1103 1104done: 1105 if (o->create_only) 1106 td->done = 1; 1107 1108 td_restore_runstate(td, old_state); 1109 return 0; 1110err_offset: 1111 log_err("%s: you need to specify valid offset=\n", o->name); 1112err_out: 1113 td_restore_runstate(td, old_state); 1114 return 1; 1115} 1116 1117int pre_read_files(struct thread_data *td) 1118{ 1119 struct fio_file *f; 1120 unsigned int i; 1121 1122 dprint(FD_FILE, "pre_read files\n"); 1123 1124 for_each_file(td, f, i) { 1125 if (pre_read_file(td, f)) 1126 return -1; 1127 } 1128 1129 return 0; 1130} 1131 1132static int __init_rand_distribution(struct thread_data *td, struct fio_file *f) 1133{ 1134 unsigned int range_size, seed; 1135 unsigned long nranges; 1136 uint64_t fsize; 1137 1138 range_size = min(td->o.min_bs[DDIR_READ], td->o.min_bs[DDIR_WRITE]); 1139 fsize = min(f->real_file_size, f->io_size); 1140 1141 nranges = (fsize + range_size - 1) / range_size; 1142 1143 seed = jhash(f->file_name, strlen(f->file_name), 0) * td->thread_number; 1144 if (!td->o.rand_repeatable) 1145 seed = td->rand_seeds[4]; 1146 1147 if (td->o.random_distribution == FIO_RAND_DIST_ZIPF) 1148 zipf_init(&f->zipf, nranges, td->o.zipf_theta.u.f, seed); 1149 else if (td->o.random_distribution == FIO_RAND_DIST_PARETO) 1150 pareto_init(&f->zipf, nranges, td->o.pareto_h.u.f, seed); 1151 else if (td->o.random_distribution == FIO_RAND_DIST_GAUSS) 1152 gauss_init(&f->gauss, nranges, td->o.gauss_dev.u.f, seed); 1153 1154 return 1; 1155} 1156 1157static int init_rand_distribution(struct thread_data *td) 1158{ 1159 struct fio_file *f; 1160 unsigned int i; 1161 int state; 1162 1163 if (td->o.random_distribution == FIO_RAND_DIST_RANDOM) 1164 return 0; 1165 1166 state = td_bump_runstate(td, TD_SETTING_UP); 1167 1168 for_each_file(td, f, i) 1169 __init_rand_distribution(td, f); 1170 1171 td_restore_runstate(td, state); 1172 1173 return 1; 1174} 1175 1176/* 1177 * Check if the number of blocks exceeds the randomness capability of 1178 * the selected generator. Tausworthe is 32-bit, the others are fullly 1179 * 64-bit capable. 1180 */ 1181static int check_rand_gen_limits(struct thread_data *td, struct fio_file *f, 1182 uint64_t blocks) 1183{ 1184 if (blocks <= FRAND32_MAX) 1185 return 0; 1186 if (td->o.random_generator != FIO_RAND_GEN_TAUSWORTHE) 1187 return 0; 1188 1189 /* 1190 * If the user hasn't specified a random generator, switch 1191 * to tausworthe64 with informational warning. If the user did 1192 * specify one, just warn. 1193 */ 1194 log_info("fio: file %s exceeds 32-bit tausworthe random generator.\n", 1195 f->file_name); 1196 1197 if (!fio_option_is_set(&td->o, random_generator)) { 1198 log_info("fio: Switching to tausworthe64. Use the " 1199 "random_generator= option to get rid of this " 1200 "warning.\n"); 1201 td->o.random_generator = FIO_RAND_GEN_TAUSWORTHE64; 1202 return 0; 1203 } 1204 1205 /* 1206 * Just make this information to avoid breaking scripts. 1207 */ 1208 log_info("fio: Use the random_generator= option to switch to lfsr or " 1209 "tausworthe64.\n"); 1210 return 0; 1211} 1212 1213int init_random_map(struct thread_data *td) 1214{ 1215 unsigned long long blocks; 1216 struct fio_file *f; 1217 unsigned int i; 1218 1219 if (init_rand_distribution(td)) 1220 return 0; 1221 if (!td_random(td)) 1222 return 0; 1223 1224 for_each_file(td, f, i) { 1225 uint64_t fsize = min(f->real_file_size, f->io_size); 1226 1227 blocks = fsize / (unsigned long long) td->o.rw_min_bs; 1228 1229 if (check_rand_gen_limits(td, f, blocks)) 1230 return 1; 1231 1232 if (td->o.random_generator == FIO_RAND_GEN_LFSR) { 1233 unsigned long seed; 1234 1235 seed = td->rand_seeds[FIO_RAND_BLOCK_OFF]; 1236 1237 if (!lfsr_init(&f->lfsr, blocks, seed, 0)) { 1238 fio_file_set_lfsr(f); 1239 continue; 1240 } 1241 } else if (!td->o.norandommap) { 1242 f->io_axmap = axmap_new(blocks); 1243 if (f->io_axmap) { 1244 fio_file_set_axmap(f); 1245 continue; 1246 } 1247 } else if (td->o.norandommap) 1248 continue; 1249 1250 if (!td->o.softrandommap) { 1251 log_err("fio: failed allocating random map. If running" 1252 " a large number of jobs, try the 'norandommap'" 1253 " option or set 'softrandommap'. Or give" 1254 " a larger --alloc-size to fio.\n"); 1255 return 1; 1256 } 1257 1258 log_info("fio: file %s failed allocating random map. Running " 1259 "job without.\n", f->file_name); 1260 } 1261 1262 return 0; 1263} 1264 1265void close_files(struct thread_data *td) 1266{ 1267 struct fio_file *f; 1268 unsigned int i; 1269 1270 for_each_file(td, f, i) { 1271 if (fio_file_open(f)) 1272 td_io_close_file(td, f); 1273 } 1274} 1275 1276void close_and_free_files(struct thread_data *td) 1277{ 1278 struct fio_file *f; 1279 unsigned int i; 1280 1281 dprint(FD_FILE, "close files\n"); 1282 1283 for_each_file(td, f, i) { 1284 if (td->o.unlink && f->filetype == FIO_TYPE_FILE) { 1285 dprint(FD_FILE, "free unlink %s\n", f->file_name); 1286 td_io_unlink_file(td, f); 1287 } 1288 1289 if (fio_file_open(f)) 1290 td_io_close_file(td, f); 1291 1292 remove_file_hash(f); 1293 1294 if (td->o.unlink && f->filetype == FIO_TYPE_FILE) { 1295 dprint(FD_FILE, "free unlink %s\n", f->file_name); 1296 td_io_unlink_file(td, f); 1297 } 1298 1299 sfree(f->file_name); 1300 f->file_name = NULL; 1301 if (fio_file_axmap(f)) { 1302 axmap_free(f->io_axmap); 1303 f->io_axmap = NULL; 1304 } 1305 sfree(f); 1306 } 1307 1308 td->o.filename = NULL; 1309 free(td->files); 1310 free(td->file_locks); 1311 td->files_index = 0; 1312 td->files = NULL; 1313 td->file_locks = NULL; 1314 td->o.file_lock_mode = FILE_LOCK_NONE; 1315 td->o.nr_files = 0; 1316} 1317 1318static void get_file_type(struct fio_file *f) 1319{ 1320 struct stat sb; 1321 1322 if (!strcmp(f->file_name, "-")) 1323 f->filetype = FIO_TYPE_PIPE; 1324 else 1325 f->filetype = FIO_TYPE_FILE; 1326 1327#ifdef WIN32 1328 /* \\.\ is the device namespace in Windows, where every file is 1329 * a block device */ 1330 if (strncmp(f->file_name, "\\\\.\\", 4) == 0) 1331 f->filetype = FIO_TYPE_BLOCK; 1332#endif 1333 1334 if (!stat(f->file_name, &sb)) { 1335 if (S_ISBLK(sb.st_mode)) 1336 f->filetype = FIO_TYPE_BLOCK; 1337 else if (S_ISCHR(sb.st_mode)) 1338 f->filetype = FIO_TYPE_CHAR; 1339 else if (S_ISFIFO(sb.st_mode)) 1340 f->filetype = FIO_TYPE_PIPE; 1341 } 1342} 1343 1344static bool __is_already_allocated(const char *fname, bool set) 1345{ 1346 struct flist_head *entry; 1347 bool ret; 1348 1349 ret = file_bloom_exists(fname, set); 1350 if (!ret) 1351 return ret; 1352 1353 flist_for_each(entry, &filename_list) { 1354 struct file_name *fn; 1355 1356 fn = flist_entry(entry, struct file_name, list); 1357 1358 if (!strcmp(fn->filename, fname)) 1359 return true; 1360 } 1361 1362 return false; 1363} 1364 1365static bool is_already_allocated(const char *fname) 1366{ 1367 bool ret; 1368 1369 fio_file_hash_lock(); 1370 ret = __is_already_allocated(fname, false); 1371 fio_file_hash_unlock(); 1372 1373 return ret; 1374} 1375 1376static void set_already_allocated(const char *fname) 1377{ 1378 struct file_name *fn; 1379 1380 fn = malloc(sizeof(struct file_name)); 1381 fn->filename = strdup(fname); 1382 1383 fio_file_hash_lock(); 1384 if (!__is_already_allocated(fname, true)) { 1385 flist_add_tail(&fn->list, &filename_list); 1386 fn = NULL; 1387 } 1388 fio_file_hash_unlock(); 1389 1390 if (fn) { 1391 free(fn->filename); 1392 free(fn); 1393 } 1394} 1395 1396static void free_already_allocated(void) 1397{ 1398 struct flist_head *entry, *tmp; 1399 struct file_name *fn; 1400 1401 if (flist_empty(&filename_list)) 1402 return; 1403 1404 fio_file_hash_lock(); 1405 flist_for_each_safe(entry, tmp, &filename_list) { 1406 fn = flist_entry(entry, struct file_name, list); 1407 free(fn->filename); 1408 flist_del(&fn->list); 1409 free(fn); 1410 } 1411 1412 fio_file_hash_unlock(); 1413} 1414 1415static struct fio_file *alloc_new_file(struct thread_data *td) 1416{ 1417 struct fio_file *f; 1418 1419 f = smalloc(sizeof(*f)); 1420 if (!f) { 1421 assert(0); 1422 return NULL; 1423 } 1424 1425 f->fd = -1; 1426 f->shadow_fd = -1; 1427 fio_file_reset(td, f); 1428 return f; 1429} 1430 1431bool exists_and_not_regfile(const char *filename) 1432{ 1433 struct stat sb; 1434 1435 if (lstat(filename, &sb) == -1) 1436 return false; 1437 1438#ifndef WIN32 /* NOT Windows */ 1439 if (S_ISREG(sb.st_mode)) 1440 return false; 1441#else 1442 /* \\.\ is the device namespace in Windows, where every file 1443 * is a device node */ 1444 if (S_ISREG(sb.st_mode) && strncmp(filename, "\\\\.\\", 4) != 0) 1445 return false; 1446#endif 1447 1448 return true; 1449} 1450 1451int add_file(struct thread_data *td, const char *fname, int numjob, int inc) 1452{ 1453 int cur_files = td->files_index; 1454 char file_name[PATH_MAX]; 1455 struct fio_file *f; 1456 int len = 0; 1457 1458 dprint(FD_FILE, "add file %s\n", fname); 1459 1460 if (td->o.directory) 1461 len = set_name_idx(file_name, PATH_MAX, td->o.directory, numjob, 1462 td->o.unique_filename); 1463 1464 sprintf(file_name + len, "%s", fname); 1465 1466 /* clean cloned siblings using existing files */ 1467 if (numjob && is_already_allocated(file_name) && 1468 !exists_and_not_regfile(fname)) 1469 return 0; 1470 1471 f = alloc_new_file(td); 1472 1473 if (td->files_size <= td->files_index) { 1474 unsigned int new_size = td->o.nr_files + 1; 1475 1476 dprint(FD_FILE, "resize file array to %d files\n", new_size); 1477 1478 td->files = realloc(td->files, new_size * sizeof(f)); 1479 if (td->files == NULL) { 1480 log_err("fio: realloc OOM\n"); 1481 assert(0); 1482 } 1483 if (td->o.file_lock_mode != FILE_LOCK_NONE) { 1484 td->file_locks = realloc(td->file_locks, new_size); 1485 if (!td->file_locks) { 1486 log_err("fio: realloc OOM\n"); 1487 assert(0); 1488 } 1489 td->file_locks[cur_files] = FILE_LOCK_NONE; 1490 } 1491 td->files_size = new_size; 1492 } 1493 td->files[cur_files] = f; 1494 f->fileno = cur_files; 1495 1496 /* 1497 * init function, io engine may not be loaded yet 1498 */ 1499 if (td->io_ops && td_ioengine_flagged(td, FIO_DISKLESSIO)) 1500 f->real_file_size = -1ULL; 1501 1502 f->file_name = smalloc_strdup(file_name); 1503 if (!f->file_name) 1504 assert(0); 1505 1506 get_file_type(f); 1507 1508 switch (td->o.file_lock_mode) { 1509 case FILE_LOCK_NONE: 1510 break; 1511 case FILE_LOCK_READWRITE: 1512 f->rwlock = fio_rwlock_init(); 1513 break; 1514 case FILE_LOCK_EXCLUSIVE: 1515 f->lock = fio_mutex_init(FIO_MUTEX_UNLOCKED); 1516 break; 1517 default: 1518 log_err("fio: unknown lock mode: %d\n", td->o.file_lock_mode); 1519 assert(0); 1520 } 1521 1522 td->files_index++; 1523 if (f->filetype == FIO_TYPE_FILE) 1524 td->nr_normal_files++; 1525 1526 set_already_allocated(file_name); 1527 1528 if (inc) 1529 td->o.nr_files++; 1530 1531 dprint(FD_FILE, "file %p \"%s\" added at %d\n", f, f->file_name, 1532 cur_files); 1533 1534 return cur_files; 1535} 1536 1537int add_file_exclusive(struct thread_data *td, const char *fname) 1538{ 1539 struct fio_file *f; 1540 unsigned int i; 1541 1542 for_each_file(td, f, i) { 1543 if (!strcmp(f->file_name, fname)) 1544 return i; 1545 } 1546 1547 return add_file(td, fname, 0, 1); 1548} 1549 1550void get_file(struct fio_file *f) 1551{ 1552 dprint(FD_FILE, "get file %s, ref=%d\n", f->file_name, f->references); 1553 assert(fio_file_open(f)); 1554 f->references++; 1555} 1556 1557int put_file(struct thread_data *td, struct fio_file *f) 1558{ 1559 int f_ret = 0, ret = 0; 1560 1561 dprint(FD_FILE, "put file %s, ref=%d\n", f->file_name, f->references); 1562 1563 if (!fio_file_open(f)) { 1564 assert(f->fd == -1); 1565 return 0; 1566 } 1567 1568 assert(f->references); 1569 if (--f->references) 1570 return 0; 1571 1572 if (should_fsync(td) && td->o.fsync_on_close) { 1573 f_ret = fsync(f->fd); 1574 if (f_ret < 0) 1575 f_ret = errno; 1576 } 1577 1578 if (td->io_ops->close_file) 1579 ret = td->io_ops->close_file(td, f); 1580 1581 if (!ret) 1582 ret = f_ret; 1583 1584 td->nr_open_files--; 1585 fio_file_clear_open(f); 1586 assert(f->fd == -1); 1587 return ret; 1588} 1589 1590void lock_file(struct thread_data *td, struct fio_file *f, enum fio_ddir ddir) 1591{ 1592 if (!f->lock || td->o.file_lock_mode == FILE_LOCK_NONE) 1593 return; 1594 1595 if (td->o.file_lock_mode == FILE_LOCK_READWRITE) { 1596 if (ddir == DDIR_READ) 1597 fio_rwlock_read(f->rwlock); 1598 else 1599 fio_rwlock_write(f->rwlock); 1600 } else if (td->o.file_lock_mode == FILE_LOCK_EXCLUSIVE) 1601 fio_mutex_down(f->lock); 1602 1603 td->file_locks[f->fileno] = td->o.file_lock_mode; 1604} 1605 1606void unlock_file(struct thread_data *td, struct fio_file *f) 1607{ 1608 if (!f->lock || td->o.file_lock_mode == FILE_LOCK_NONE) 1609 return; 1610 1611 if (td->o.file_lock_mode == FILE_LOCK_READWRITE) 1612 fio_rwlock_unlock(f->rwlock); 1613 else if (td->o.file_lock_mode == FILE_LOCK_EXCLUSIVE) 1614 fio_mutex_up(f->lock); 1615 1616 td->file_locks[f->fileno] = FILE_LOCK_NONE; 1617} 1618 1619void unlock_file_all(struct thread_data *td, struct fio_file *f) 1620{ 1621 if (td->o.file_lock_mode == FILE_LOCK_NONE || !td->file_locks) 1622 return; 1623 if (td->file_locks[f->fileno] != FILE_LOCK_NONE) 1624 unlock_file(td, f); 1625} 1626 1627static int recurse_dir(struct thread_data *td, const char *dirname) 1628{ 1629 struct dirent *dir; 1630 int ret = 0; 1631 DIR *D; 1632 1633 D = opendir(dirname); 1634 if (!D) { 1635 char buf[FIO_VERROR_SIZE]; 1636 1637 snprintf(buf, FIO_VERROR_SIZE, "opendir(%s)", dirname); 1638 td_verror(td, errno, buf); 1639 return 1; 1640 } 1641 1642 while ((dir = readdir(D)) != NULL) { 1643 char full_path[PATH_MAX]; 1644 struct stat sb; 1645 1646 if (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, "..")) 1647 continue; 1648 1649 sprintf(full_path, "%s%s%s", dirname, FIO_OS_PATH_SEPARATOR, dir->d_name); 1650 1651 if (lstat(full_path, &sb) == -1) { 1652 if (errno != ENOENT) { 1653 td_verror(td, errno, "stat"); 1654 ret = 1; 1655 break; 1656 } 1657 } 1658 1659 if (S_ISREG(sb.st_mode)) { 1660 add_file(td, full_path, 0, 1); 1661 continue; 1662 } 1663 if (!S_ISDIR(sb.st_mode)) 1664 continue; 1665 1666 ret = recurse_dir(td, full_path); 1667 if (ret) 1668 break; 1669 } 1670 1671 closedir(D); 1672 return ret; 1673} 1674 1675int add_dir_files(struct thread_data *td, const char *path) 1676{ 1677 int ret = recurse_dir(td, path); 1678 1679 if (!ret) 1680 log_info("fio: opendir added %d files\n", td->o.nr_files); 1681 1682 return ret; 1683} 1684 1685void dup_files(struct thread_data *td, struct thread_data *org) 1686{ 1687 struct fio_file *f; 1688 unsigned int i; 1689 1690 dprint(FD_FILE, "dup files: %d\n", org->files_index); 1691 1692 if (!org->files) 1693 return; 1694 1695 td->files = malloc(org->files_index * sizeof(f)); 1696 1697 if (td->o.file_lock_mode != FILE_LOCK_NONE) 1698 td->file_locks = malloc(org->files_index); 1699 1700 for_each_file(org, f, i) { 1701 struct fio_file *__f; 1702 1703 __f = alloc_new_file(td); 1704 1705 if (f->file_name) { 1706 __f->file_name = smalloc_strdup(f->file_name); 1707 if (!__f->file_name) 1708 assert(0); 1709 1710 __f->filetype = f->filetype; 1711 } 1712 1713 if (td->o.file_lock_mode == FILE_LOCK_EXCLUSIVE) 1714 __f->lock = f->lock; 1715 else if (td->o.file_lock_mode == FILE_LOCK_READWRITE) 1716 __f->rwlock = f->rwlock; 1717 1718 td->files[i] = __f; 1719 } 1720} 1721 1722/* 1723 * Returns the index that matches the filename, or -1 if not there 1724 */ 1725int get_fileno(struct thread_data *td, const char *fname) 1726{ 1727 struct fio_file *f; 1728 unsigned int i; 1729 1730 for_each_file(td, f, i) 1731 if (!strcmp(f->file_name, fname)) 1732 return i; 1733 1734 return -1; 1735} 1736 1737/* 1738 * For log usage, where we add/open/close files automatically 1739 */ 1740void free_release_files(struct thread_data *td) 1741{ 1742 close_files(td); 1743 td->o.nr_files = 0; 1744 td->o.open_files = 0; 1745 td->files_index = 0; 1746 td->nr_normal_files = 0; 1747} 1748 1749void fio_file_reset(struct thread_data *td, struct fio_file *f) 1750{ 1751 int i; 1752 1753 for (i = 0; i < DDIR_RWDIR_CNT; i++) { 1754 f->last_pos[i] = f->file_offset; 1755 f->last_start[i] = -1ULL; 1756 } 1757 1758 if (fio_file_axmap(f)) 1759 axmap_reset(f->io_axmap); 1760 else if (fio_file_lfsr(f)) 1761 lfsr_reset(&f->lfsr, td->rand_seeds[FIO_RAND_BLOCK_OFF]); 1762} 1763 1764bool fio_files_done(struct thread_data *td) 1765{ 1766 struct fio_file *f; 1767 unsigned int i; 1768 1769 for_each_file(td, f, i) 1770 if (!fio_file_done(f)) 1771 return false; 1772 1773 return true; 1774} 1775 1776/* free memory used in initialization phase only */ 1777void filesetup_mem_free(void) 1778{ 1779 free_already_allocated(); 1780} 1781