filesetup.c

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