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