filesetup.c revision 814452bd47e0f2bb4825b8042b664f32de0aff8d
1#include <unistd.h> 2#include <fcntl.h> 3#include <string.h> 4#include <assert.h> 5#include <dirent.h> 6#include <sys/stat.h> 7#include <sys/mman.h> 8#include <sys/types.h> 9 10#include "fio.h" 11#include "smalloc.h" 12#include "filehash.h" 13 14static int root_warn; 15 16/* 17 * Leaves f->fd open on success, caller must close 18 */ 19static int extend_file(struct thread_data *td, struct fio_file *f) 20{ 21 int r, new_layout = 0, unlink_file = 0, flags; 22 unsigned long long left; 23 unsigned int bs; 24 char *b; 25 26 if (read_only) { 27 log_err("fio: refusing extend of file due to read-only\n"); 28 return 0; 29 } 30 31 /* 32 * check if we need to lay the file out complete again. fio 33 * does that for operations involving reads, or for writes 34 * where overwrite is set 35 */ 36 if (td_read(td) || (td_write(td) && td->o.overwrite) || 37 (td_write(td) && td->io_ops->flags & FIO_NOEXTEND)) 38 new_layout = 1; 39 if (td_write(td) && !td->o.overwrite) 40 unlink_file = 1; 41 42 if (unlink_file || new_layout) { 43 dprint(FD_FILE, "layout unlink %s\n", f->file_name); 44 if ((unlink(f->file_name) < 0) && (errno != ENOENT)) { 45 td_verror(td, errno, "unlink"); 46 return 1; 47 } 48 } 49 50 flags = O_WRONLY | O_CREAT; 51 if (new_layout) 52 flags |= O_TRUNC; 53 54 dprint(FD_FILE, "open file %s, flags %x\n", f->file_name, flags); 55 f->fd = open(f->file_name, flags, 0644); 56 if (f->fd < 0) { 57 td_verror(td, errno, "open"); 58 return 1; 59 } 60 61 if (!new_layout) 62 goto done; 63 64 dprint(FD_FILE, "truncate file %s, size %llu\n", f->file_name, 65 f->real_file_size); 66 if (ftruncate(f->fd, f->real_file_size) == -1) { 67 td_verror(td, errno, "ftruncate"); 68 goto err; 69 } 70 71#ifdef FIO_HAVE_FALLOCATE 72 dprint(FD_FILE, "fallocate file %s, size %llu\n", f->file_name, 73 f->real_file_size); 74 r = posix_fallocate(f->fd, 0, f->real_file_size); 75 if (r < 0) 76 log_err("fio: posix_fallocate fails: %s\n", strerror(-r)); 77#endif 78 79 b = malloc(td->o.max_bs[DDIR_WRITE]); 80 memset(b, 0, td->o.max_bs[DDIR_WRITE]); 81 82 left = f->real_file_size; 83 while (left && !td->terminate) { 84 bs = td->o.max_bs[DDIR_WRITE]; 85 if (bs > left) 86 bs = left; 87 88 r = write(f->fd, b, bs); 89 90 if (r == (int) bs) { 91 left -= bs; 92 continue; 93 } else { 94 if (r < 0) 95 td_verror(td, errno, "write"); 96 else 97 td_verror(td, EIO, "write"); 98 99 break; 100 } 101 } 102 103 if (td->terminate) { 104 dprint(FD_FILE, "terminate unlink %s\n", f->file_name); 105 unlink(f->file_name); 106 } else if (td->o.create_fsync) { 107 if (fsync(f->fd) < 0) { 108 td_verror(td, errno, "fsync"); 109 goto err; 110 } 111 } 112 113 free(b); 114done: 115 return 0; 116err: 117 close(f->fd); 118 f->fd = -1; 119 return 1; 120} 121 122static unsigned long long get_rand_file_size(struct thread_data *td) 123{ 124 unsigned long long ret, sized; 125 long r; 126 127 r = os_random_long(&td->file_size_state); 128 sized = td->o.file_size_high - td->o.file_size_low; 129 ret = (unsigned long long) ((double) sized * (r / (OS_RAND_MAX + 1.0))); 130 ret += td->o.file_size_low; 131 ret -= (ret % td->o.rw_min_bs); 132 return ret; 133} 134 135static int file_size(struct thread_data *td, struct fio_file *f) 136{ 137 struct stat st; 138 139 if (fstat(f->fd, &st) == -1) { 140 td_verror(td, errno, "fstat"); 141 return 1; 142 } 143 144 f->real_file_size = st.st_size; 145 return 0; 146} 147 148static int bdev_size(struct thread_data *td, struct fio_file *f) 149{ 150 unsigned long long bytes; 151 int r; 152 153 r = blockdev_size(f->fd, &bytes); 154 if (r) { 155 td_verror(td, r, "blockdev_size"); 156 return 1; 157 } 158 159 if (!bytes) { 160 log_err("%s: zero sized block device?\n", f->file_name); 161 return 1; 162 } 163 164 f->real_file_size = bytes; 165 return 0; 166} 167 168static int get_file_size(struct thread_data *td, struct fio_file *f) 169{ 170 int ret = 0; 171 172 if (f->flags & FIO_SIZE_KNOWN) 173 return 0; 174 175 if (f->filetype == FIO_TYPE_FILE) 176 ret = file_size(td, f); 177 else if (f->filetype == FIO_TYPE_BD) 178 ret = bdev_size(td, f); 179 else 180 f->real_file_size = -1; 181 182 if (ret) 183 return ret; 184 185 if (f->file_offset > f->real_file_size) { 186 log_err("%s: offset extends end (%Lu > %Lu)\n", td->o.name, 187 f->file_offset, f->real_file_size); 188 return 1; 189 } 190 191 f->flags |= FIO_SIZE_KNOWN; 192 return 0; 193} 194 195static int __file_invalidate_cache(struct thread_data *td, struct fio_file *f, 196 unsigned long long off, 197 unsigned long long len) 198{ 199 int ret = 0; 200 201 if (len == -1ULL) 202 len = f->io_size; 203 if (off == -1ULL) 204 off = f->file_offset; 205 206 dprint(FD_IO, "invalidate cache %s: %llu/%llu\n", f->file_name, off, 207 len); 208 209 /* 210 * FIXME: add blockdev flushing too 211 */ 212 if (f->mmap) 213 ret = madvise(f->mmap, len, MADV_DONTNEED); 214 else if (f->filetype == FIO_TYPE_FILE) { 215 ret = fadvise(f->fd, off, len, POSIX_FADV_DONTNEED); 216 } else if (f->filetype == FIO_TYPE_BD) { 217 ret = blockdev_invalidate_cache(f->fd); 218 if (ret < 0 && errno == EACCES && geteuid()) { 219 if (!root_warn) { 220 log_err("fio: only root may flush block " 221 "devices. Cache flush bypassed!\n"); 222 root_warn = 1; 223 } 224 ret = 0; 225 } 226 } else if (f->filetype == FIO_TYPE_CHAR || f->filetype == FIO_TYPE_PIPE) 227 ret = 0; 228 229 if (ret < 0) { 230 td_verror(td, errno, "invalidate_cache"); 231 return 1; 232 } else if (ret > 0) { 233 td_verror(td, ret, "invalidate_cache"); 234 return 1; 235 } 236 237 return ret; 238 239} 240 241int file_invalidate_cache(struct thread_data *td, struct fio_file *f) 242{ 243 if (!(f->flags & FIO_FILE_OPEN)) 244 return 0; 245 246 return __file_invalidate_cache(td, f, -1, -1); 247} 248 249int generic_close_file(struct thread_data fio_unused *td, struct fio_file *f) 250{ 251 int ret = 0; 252 253 dprint(FD_FILE, "fd close %s\n", f->file_name); 254 255 remove_file_hash(f); 256 257 if (close(f->fd) < 0) 258 ret = errno; 259 260 f->fd = -1; 261 return ret; 262} 263 264static int file_lookup_open(struct fio_file *f, int flags) 265{ 266 struct fio_file *__f; 267 int from_hash; 268 269 __f = lookup_file_hash(f->file_name); 270 if (__f) { 271 dprint(FD_FILE, "found file in hash %s\n", f->file_name); 272 /* 273 * racy, need the __f->lock locked 274 */ 275 f->lock = __f->lock; 276 f->lock_owner = __f->lock_owner; 277 f->lock_batch = __f->lock_batch; 278 f->lock_ddir = __f->lock_ddir; 279 from_hash = 1; 280 } else { 281 dprint(FD_FILE, "file not found in hash %s\n", f->file_name); 282 from_hash = 0; 283 } 284 285 f->fd = open(f->file_name, flags, 0600); 286 return from_hash; 287} 288 289int generic_open_file(struct thread_data *td, struct fio_file *f) 290{ 291 int is_std = 0; 292 int flags = 0; 293 int from_hash = 0; 294 295 dprint(FD_FILE, "fd open %s\n", f->file_name); 296 297 if (!strcmp(f->file_name, "-")) { 298 if (td_rw(td)) { 299 log_err("fio: can't read/write to stdin/out\n"); 300 return 1; 301 } 302 is_std = 1; 303 304 /* 305 * move output logging to stderr, if we are writing to stdout 306 */ 307 if (td_write(td)) 308 f_out = stderr; 309 } 310 311 if (td->o.odirect) 312 flags |= OS_O_DIRECT; 313 if (td->o.sync_io) 314 flags |= O_SYNC; 315 if (f->filetype != FIO_TYPE_FILE) 316 flags |= FIO_O_NOATIME; 317 if (td->o.create_on_open) 318 flags |= O_CREAT; 319 320open_again: 321 if (td_write(td)) { 322 if (!read_only) 323 flags |= O_RDWR; 324 325 if (f->filetype == FIO_TYPE_FILE) 326 flags |= O_CREAT; 327 328 if (is_std) 329 f->fd = dup(STDOUT_FILENO); 330 else 331 from_hash = file_lookup_open(f, flags); 332 } else { 333 if (f->filetype == FIO_TYPE_CHAR && !read_only) 334 flags |= O_RDWR; 335 else 336 flags |= O_RDONLY; 337 338 if (is_std) 339 f->fd = dup(STDIN_FILENO); 340 else 341 from_hash = file_lookup_open(f, flags); 342 } 343 344 if (f->fd == -1) { 345 char buf[FIO_VERROR_SIZE]; 346 int __e = errno; 347 348 if (errno == EPERM && (flags & FIO_O_NOATIME)) { 349 flags &= ~FIO_O_NOATIME; 350 goto open_again; 351 } 352 353 snprintf(buf, sizeof(buf) - 1, "open(%s)", f->file_name); 354 355 td_verror(td, __e, buf); 356 } 357 358 if (get_file_size(td, f)) 359 goto err; 360 361 if (!from_hash && f->fd != -1) { 362 if (add_file_hash(f)) { 363 int ret; 364 365 /* 366 * OK to ignore, we haven't done anything with it 367 */ 368 ret = generic_close_file(td, f); 369 goto open_again; 370 } 371 } 372 373 return 0; 374err: 375 close(f->fd); 376 return 1; 377} 378 379int open_files(struct thread_data *td) 380{ 381 struct fio_file *f; 382 unsigned int i; 383 int err = 0; 384 385 dprint(FD_FILE, "open files\n"); 386 387 for_each_file(td, f, i) { 388 err = td_io_open_file(td, f); 389 if (err) { 390 if (td->error == EMFILE) { 391 log_err("fio: limited open files to: %d\n", 392 td->nr_open_files); 393 td->o.open_files = td->nr_open_files; 394 err = 0; 395 clear_error(td); 396 } 397 break; 398 } 399 400 if (td->o.open_files == td->nr_open_files) 401 break; 402 } 403 404 if (!err) 405 return 0; 406 407 for_each_file(td, f, i) 408 td_io_close_file(td, f); 409 410 return err; 411} 412 413/* 414 * open/close all files, so that ->real_file_size gets set 415 */ 416static int get_file_sizes(struct thread_data *td) 417{ 418 struct fio_file *f; 419 unsigned int i; 420 int err = 0; 421 422 for_each_file(td, f, i) { 423 dprint(FD_FILE, "get file size for %p/%d/%p\n", f, i, 424 f->file_name); 425 426 if (td->io_ops->open_file(td, f)) { 427 if (td->error != ENOENT) { 428 log_err("%s\n", td->verror); 429 err = 1; 430 } 431 clear_error(td); 432 } else { 433 if (td->io_ops->close_file) 434 td->io_ops->close_file(td, f); 435 } 436 437 if (f->real_file_size == -1ULL && td->o.size) 438 f->real_file_size = td->o.size / td->o.nr_files; 439 } 440 441 return err; 442} 443 444/* 445 * Open the files and setup files sizes, creating files if necessary. 446 */ 447int setup_files(struct thread_data *td) 448{ 449 unsigned long long total_size, extend_size; 450 struct fio_file *f; 451 unsigned int i; 452 int err = 0, need_extend; 453 454 dprint(FD_FILE, "setup files\n"); 455 456 if (td->o.read_iolog_file) 457 return 0; 458 459 /* 460 * if ioengine defines a setup() method, it's responsible for 461 * opening the files and setting f->real_file_size to indicate 462 * the valid range for that file. 463 */ 464 if (td->io_ops->setup) 465 err = td->io_ops->setup(td); 466 else 467 err = get_file_sizes(td); 468 469 if (err) 470 return err; 471 472 /* 473 * check sizes. if the files/devices do not exist and the size 474 * isn't passed to fio, abort. 475 */ 476 total_size = 0; 477 for_each_file(td, f, i) { 478 if (f->real_file_size == -1ULL) 479 total_size = -1ULL; 480 else 481 total_size += f->real_file_size; 482 } 483 484 /* 485 * device/file sizes are zero and no size given, punt 486 */ 487 if ((!total_size || total_size == -1ULL) && !td->o.size && 488 !(td->io_ops->flags & FIO_NOIO) && !td->o.fill_device) { 489 log_err("%s: you need to specify size=\n", td->o.name); 490 td_verror(td, EINVAL, "total_file_size"); 491 return 1; 492 } 493 494 /* 495 * now file sizes are known, so we can set ->io_size. if size= is 496 * not given, ->io_size is just equal to ->real_file_size. if size 497 * is given, ->io_size is size / nr_files. 498 */ 499 extend_size = total_size = 0; 500 need_extend = 0; 501 for_each_file(td, f, i) { 502 f->file_offset = td->o.start_offset; 503 504 if (!td->o.file_size_low) { 505 /* 506 * no file size range given, file size is equal to 507 * total size divided by number of files. if that is 508 * zero, set it to the real file size. 509 */ 510 f->io_size = td->o.size / td->o.nr_files; 511 if (!f->io_size) 512 f->io_size = f->real_file_size - f->file_offset; 513 } else if (f->real_file_size < td->o.file_size_low || 514 f->real_file_size > td->o.file_size_high) { 515 if (f->file_offset > td->o.file_size_low) 516 goto err_offset; 517 /* 518 * file size given. if it's fixed, use that. if it's a 519 * range, generate a random size in-between. 520 */ 521 if (td->o.file_size_low == td->o.file_size_high) { 522 f->io_size = td->o.file_size_low 523 - f->file_offset; 524 } else { 525 f->io_size = get_rand_file_size(td) 526 - f->file_offset; 527 } 528 } else 529 f->io_size = f->real_file_size - f->file_offset; 530 531 if (f->io_size == -1ULL) 532 total_size = -1ULL; 533 else 534 total_size += f->io_size; 535 536 if (f->filetype == FIO_TYPE_FILE && 537 (f->io_size + f->file_offset) > f->real_file_size && 538 !(td->io_ops->flags & FIO_DISKLESSIO)) { 539 if (!td->o.create_on_open) { 540 need_extend++; 541 extend_size += (f->io_size + f->file_offset); 542 } else 543 f->real_file_size = f->io_size + f->file_offset; 544 f->flags |= FIO_FILE_EXTEND; 545 } 546 } 547 548 if (!td->o.size || td->o.size > total_size) 549 td->o.size = total_size; 550 551 /* 552 * See if we need to extend some files 553 */ 554 if (need_extend) { 555 temp_stall_ts = 1; 556 if (!terse_output) 557 log_info("%s: Laying out IO file(s) (%u file(s) /" 558 " %LuMiB)\n", td->o.name, need_extend, 559 extend_size >> 20); 560 561 for_each_file(td, f, i) { 562 unsigned long long old_len, extend_len; 563 564 if (!(f->flags & FIO_FILE_EXTEND)) 565 continue; 566 567 assert(f->filetype == FIO_TYPE_FILE); 568 f->flags &= ~FIO_FILE_EXTEND; 569 old_len = f->real_file_size; 570 extend_len = f->io_size + f->file_offset - old_len; 571 f->real_file_size = (f->io_size + f->file_offset); 572 err = extend_file(td, f); 573 if (err) 574 break; 575 576 err = __file_invalidate_cache(td, f, old_len, 577 extend_len); 578 close(f->fd); 579 f->fd = -1; 580 if (err) 581 break; 582 } 583 temp_stall_ts = 0; 584 } 585 586 if (err) 587 return err; 588 589 if (!td->o.zone_size) 590 td->o.zone_size = td->o.size; 591 592 /* 593 * iolog already set the total io size, if we read back 594 * stored entries. 595 */ 596 if (!td->o.read_iolog_file) 597 td->total_io_size = td->o.size * td->o.loops; 598 return 0; 599err_offset: 600 log_err("%s: you need to specify valid offset=\n", td->o.name); 601 return 1; 602} 603 604int init_random_map(struct thread_data *td) 605{ 606 unsigned long long blocks, num_maps; 607 struct fio_file *f; 608 unsigned int i; 609 610 if (td->o.norandommap || !td_random(td)) 611 return 0; 612 613 for_each_file(td, f, i) { 614 blocks = (f->real_file_size + td->o.rw_min_bs - 1) / 615 (unsigned long long) td->o.rw_min_bs; 616 num_maps = (blocks + BLOCKS_PER_MAP - 1) / 617 (unsigned long long) BLOCKS_PER_MAP; 618 f->file_map = smalloc(num_maps * sizeof(int)); 619 if (f->file_map) { 620 f->num_maps = num_maps; 621 continue; 622 } 623 if (!td->o.softrandommap) { 624 log_err("fio: failed allocating random map. If running" 625 " a large number of jobs, try the 'norandommap'" 626 " option or set 'softrandommap'. Or give" 627 " a larger --alloc-size to fio.\n"); 628 return 1; 629 } 630 631 log_info("fio: file %s failed allocating random map. Running " 632 "job without.\n", f->file_name); 633 f->num_maps = 0; 634 } 635 636 return 0; 637} 638 639void close_files(struct thread_data *td) 640{ 641 struct fio_file *f; 642 unsigned int i; 643 644 for_each_file(td, f, i) 645 td_io_close_file(td, f); 646} 647 648void close_and_free_files(struct thread_data *td) 649{ 650 struct fio_file *f; 651 unsigned int i; 652 653 dprint(FD_FILE, "close files\n"); 654 655 for_each_file(td, f, i) { 656 if (td->o.unlink && f->filetype == FIO_TYPE_FILE) { 657 dprint(FD_FILE, "free unlink %s\n", f->file_name); 658 unlink(f->file_name); 659 } 660 661 td_io_close_file(td, f); 662 remove_file_hash(f); 663 664 sfree(f->file_name); 665 f->file_name = NULL; 666 667 if (f->file_map) { 668 sfree(f->file_map); 669 f->file_map = NULL; 670 } 671 sfree(f); 672 } 673 674 td->o.filename = NULL; 675 free(td->files); 676 td->files_index = 0; 677 td->files = NULL; 678 td->o.nr_files = 0; 679} 680 681static void get_file_type(struct fio_file *f) 682{ 683 struct stat sb; 684 685 if (!strcmp(f->file_name, "-")) 686 f->filetype = FIO_TYPE_PIPE; 687 else 688 f->filetype = FIO_TYPE_FILE; 689 690 if (!lstat(f->file_name, &sb)) { 691 if (S_ISBLK(sb.st_mode)) 692 f->filetype = FIO_TYPE_BD; 693 else if (S_ISCHR(sb.st_mode)) 694 f->filetype = FIO_TYPE_CHAR; 695 else if (S_ISFIFO(sb.st_mode)) 696 f->filetype = FIO_TYPE_PIPE; 697 } 698} 699 700int add_file(struct thread_data *td, const char *fname) 701{ 702 int cur_files = td->files_index; 703 char file_name[PATH_MAX]; 704 struct fio_file *f; 705 int len = 0; 706 707 dprint(FD_FILE, "add file %s\n", fname); 708 709 f = smalloc(sizeof(*f)); 710 if (!f) { 711 log_err("fio: smalloc OOM\n"); 712 assert(0); 713 } 714 715 f->fd = -1; 716 717 dprint(FD_FILE, "resize file array to %d files\n", cur_files + 1); 718 719 td->files = realloc(td->files, (cur_files + 1) * sizeof(f)); 720 td->files[cur_files] = f; 721 722 /* 723 * init function, io engine may not be loaded yet 724 */ 725 if (td->io_ops && (td->io_ops->flags & FIO_DISKLESSIO)) 726 f->real_file_size = -1ULL; 727 728 if (td->o.directory) 729 len = sprintf(file_name, "%s/", td->o.directory); 730 731 sprintf(file_name + len, "%s", fname); 732 f->file_name = smalloc_strdup(file_name); 733 if (!f->file_name) { 734 log_err("fio: smalloc OOM\n"); 735 assert(0); 736 } 737 738 get_file_type(f); 739 740 switch (td->o.file_lock_mode) { 741 case FILE_LOCK_NONE: 742 break; 743 case FILE_LOCK_READWRITE: 744 f->lock = fio_mutex_rw_init(); 745 break; 746 case FILE_LOCK_EXCLUSIVE: 747 f->lock = fio_mutex_init(1); 748 break; 749 default: 750 log_err("fio: unknown lock mode: %d\n", td->o.file_lock_mode); 751 assert(0); 752 } 753 754 td->files_index++; 755 if (f->filetype == FIO_TYPE_FILE) 756 td->nr_normal_files++; 757 758 dprint(FD_FILE, "file %p \"%s\" added at %d\n", f, f->file_name, 759 cur_files); 760 761 return cur_files; 762} 763 764void get_file(struct fio_file *f) 765{ 766 dprint(FD_FILE, "get file %s, ref=%d\n", f->file_name, f->references); 767 assert(f->flags & FIO_FILE_OPEN); 768 f->references++; 769} 770 771int put_file(struct thread_data *td, struct fio_file *f) 772{ 773 int f_ret = 0, ret = 0; 774 775 dprint(FD_FILE, "put file %s, ref=%d\n", f->file_name, f->references); 776 777 if (!(f->flags & FIO_FILE_OPEN)) 778 return 0; 779 780 assert(f->references); 781 if (--f->references) 782 return 0; 783 784 if (should_fsync(td) && td->o.fsync_on_close) 785 f_ret = fsync(f->fd); 786 787 if (td->io_ops->close_file) 788 ret = td->io_ops->close_file(td, f); 789 790 if (!ret) 791 ret = f_ret; 792 793 td->nr_open_files--; 794 f->flags &= ~FIO_FILE_OPEN; 795 return ret; 796} 797 798void lock_file(struct thread_data *td, struct fio_file *f, enum fio_ddir ddir) 799{ 800 if (!f->lock || td->o.file_lock_mode == FILE_LOCK_NONE) 801 return; 802 803 if (f->lock_owner == td && f->lock_batch--) 804 return; 805 806 if (td->o.file_lock_mode == FILE_LOCK_READWRITE) { 807 if (ddir == DDIR_READ) 808 fio_mutex_down_read(f->lock); 809 else 810 fio_mutex_down_write(f->lock); 811 } else if (td->o.file_lock_mode == FILE_LOCK_EXCLUSIVE) 812 fio_mutex_down(f->lock); 813 814 f->lock_owner = td; 815 f->lock_batch = td->o.lockfile_batch; 816 f->lock_ddir = ddir; 817} 818 819void unlock_file(struct thread_data *td, struct fio_file *f) 820{ 821 if (!f->lock || td->o.file_lock_mode == FILE_LOCK_NONE) 822 return; 823 if (f->lock_batch) 824 return; 825 826 if (td->o.file_lock_mode == FILE_LOCK_READWRITE) { 827 const int is_read = f->lock_ddir == DDIR_READ; 828 int val = fio_mutex_getval(f->lock); 829 830 if ((is_read && val == 1) || (!is_read && val == -1)) 831 f->lock_owner = NULL; 832 833 if (is_read) 834 fio_mutex_up_read(f->lock); 835 else 836 fio_mutex_up_write(f->lock); 837 } else if (td->o.file_lock_mode == FILE_LOCK_EXCLUSIVE) { 838 int val = fio_mutex_getval(f->lock); 839 840 if (val == 0) 841 f->lock_owner = NULL; 842 843 fio_mutex_up(f->lock); 844 } 845} 846 847void unlock_file_all(struct thread_data *td, struct fio_file *f) 848{ 849 if (f->lock_owner != td) 850 return; 851 852 f->lock_batch = 0; 853 unlock_file(td, f); 854} 855 856static int recurse_dir(struct thread_data *td, const char *dirname) 857{ 858 struct dirent *dir; 859 int ret = 0; 860 DIR *D; 861 862 D = opendir(dirname); 863 if (!D) { 864 char buf[FIO_VERROR_SIZE]; 865 866 snprintf(buf, FIO_VERROR_SIZE - 1, "opendir(%s)", dirname); 867 td_verror(td, errno, buf); 868 return 1; 869 } 870 871 while ((dir = readdir(D)) != NULL) { 872 char full_path[PATH_MAX]; 873 struct stat sb; 874 875 if (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, "..")) 876 continue; 877 878 sprintf(full_path, "%s/%s", dirname, dir->d_name); 879 880 if (lstat(full_path, &sb) == -1) { 881 if (errno != ENOENT) { 882 td_verror(td, errno, "stat"); 883 return 1; 884 } 885 } 886 887 if (S_ISREG(sb.st_mode)) { 888 add_file(td, full_path); 889 td->o.nr_files++; 890 continue; 891 } 892 if (!S_ISDIR(sb.st_mode)) 893 continue; 894 895 ret = recurse_dir(td, full_path); 896 if (ret) 897 break; 898 } 899 900 closedir(D); 901 return ret; 902} 903 904int add_dir_files(struct thread_data *td, const char *path) 905{ 906 int ret = recurse_dir(td, path); 907 908 if (!ret) 909 log_info("fio: opendir added %d files\n", td->o.nr_files); 910 911 return ret; 912} 913 914void dup_files(struct thread_data *td, struct thread_data *org) 915{ 916 struct fio_file *f; 917 unsigned int i; 918 919 dprint(FD_FILE, "dup files: %d\n", org->files_index); 920 921 if (!org->files) 922 return; 923 924 td->files = malloc(org->files_index * sizeof(f)); 925 926 for_each_file(org, f, i) { 927 struct fio_file *__f; 928 929 __f = smalloc(sizeof(*__f)); 930 if (!__f) { 931 log_err("fio: smalloc OOM\n"); 932 assert(0); 933 } 934 935 if (f->file_name) { 936 __f->file_name = smalloc_strdup(f->file_name); 937 if (!__f->file_name) { 938 log_err("fio: smalloc OOM\n"); 939 assert(0); 940 } 941 942 __f->filetype = f->filetype; 943 } 944 945 td->files[i] = __f; 946 } 947} 948 949/* 950 * Returns the index that matches the filename, or -1 if not there 951 */ 952int get_fileno(struct thread_data *td, const char *fname) 953{ 954 struct fio_file *f; 955 unsigned int i; 956 957 for_each_file(td, f, i) 958 if (!strcmp(f->file_name, fname)) 959 return i; 960 961 return -1; 962} 963 964/* 965 * For log usage, where we add/open/close files automatically 966 */ 967void free_release_files(struct thread_data *td) 968{ 969 close_files(td); 970 td->files_index = 0; 971 td->nr_normal_files = 0; 972} 973