filesetup.c

   1 #include <unistd.h>
   2 #include <fcntl.h>
   3 #include <string.h>
   4 #include <assert.h>
   5 #include <sys/stat.h>
   6 #include <sys/mman.h>
   7
   8 #include "fio.h"
   9 #include "os.h"
  10
  11 int open_file(struct thread_data *td, struct fio_file *f, int flags, int perm)
  12 {
  13         if (flags & O_CREAT)
  14                 f->fd = open(f->file_name, flags, perm);
  15         else
  16                 f->fd = open(f->file_name, flags);
  17
  18         if (f->fd != -1) {
  19                 td->nr_open_files++;
  20                 return 0;
  21         }
  22
  23         return 1;
  24 }
  25
  26 void close_file(struct thread_data *td, struct fio_file *f)
  27 {
  28         if (f->fd != -1) {
  29                 close(f->fd);
  30                 f->fd = -1;
  31                 td->nr_open_files--;
  32         }
  33 }
  34
  35 /*
  36  * Check if the file exists and it's large enough.
  37  */
  38 static int file_ok(struct thread_data *td, struct fio_file *f)
  39 {
  40         struct stat st;
  41
  42         if (td->filetype != FIO_TYPE_FILE || (td->io_ops->flags & FIO_NULLIO))
  43                 return 0;
  44
  45         if (lstat(f->file_name, &st) == -1)
  46                 return 1;
  47
  48         /*
  49          * if it's a special file, size is always ok for now
  50          */
  51         if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))
  52                 return 0;
  53         if (st.st_size < (off_t) f->file_size)
  54                 return 1;
  55
  56         return 0;
  57 }
  58
  59 static int create_file(struct thread_data *td, struct fio_file *f)
  60 {
  61         unsigned long long left;
  62         unsigned int bs;
  63         char *b;
  64         int r;
  65
  66         f->fd = open(f->file_name, O_WRONLY | O_CREAT | O_TRUNC, 0644);
  67         if (f->fd < 0) {
  68                 td_verror(td, errno, "open");
  69                 return 1;
  70         }
  71
  72         if (ftruncate(f->fd, f->file_size) == -1) {
  73                 td_verror(td, errno, "ftruncate");
  74                 goto err;
  75         }
  76
  77         if (posix_fallocate(f->fd, 0, f->file_size) < 0) {
  78                 td_verror(td, errno, "posix_fallocate");
  79                 goto err;
  80         }
  81
  82         b = malloc(td->max_bs[DDIR_WRITE]);
  83         memset(b, 0, td->max_bs[DDIR_WRITE]);
  84
  85         left = f->file_size;
  86         while (left && !td->terminate) {
  87                 bs = td->max_bs[DDIR_WRITE];
  88                 if (bs > left)
  89                         bs = left;
  90
  91                 r = write(f->fd, b, bs);
  92
  93                 if (r == (int) bs) {
  94                         left -= bs;
  95                         continue;
  96                 } else {
  97                         if (r < 0)
  98                                 td_verror(td, errno, "write");
  99                         else
 100                                 td_verror(td, EIO, "write");
 101
 102                         break;
 103                 }
 104         }
 105
 106         if (td->terminate)
 107                 unlink(f->file_name);
 108         else if (td->create_fsync)
 109                 fsync(f->fd);
 110
 111         free(b);
 112         close(f->fd);
 113         f->fd = -1;
 114         return 0;
 115 err:
 116         close(f->fd);
 117         f->fd = -1;
 118         return 1;
 119 }
 120
 121 static int create_files(struct thread_data *td)
 122 {
 123         struct fio_file *f;
 124         int i, err, need_create;
 125
 126         for_each_file(td, f, i)
 127                 f->file_size = td->total_file_size / td->nr_files;
 128
 129         /*
 130          * unless specifically asked for overwrite, let normal io extend it
 131          */
 132         if (!td->overwrite)
 133                 return 0;
 134
 135         need_create = 0;
 136         if (td->filetype == FIO_TYPE_FILE) {
 137                 for_each_file(td, f, i) {
 138                         int file_there = !file_ok(td, f);
 139
 140                         if (file_there && td_write(td) && !td->overwrite) {
 141                                 unlink(f->file_name);
 142                                 file_there = 0;
 143                         }
 144
 145                         need_create += !file_there;
 146                 }
 147         }
 148
 149         if (!need_create)
 150                 return 0;
 151
 152         if (!td->total_file_size) {
 153                 log_err("Need size for create\n");
 154                 td_verror(td, EINVAL, "file_size");
 155                 return 1;
 156         }
 157
 158         temp_stall_ts = 1;
 159         fprintf(f_out, "%s: Laying out IO file(s) (%u x %LuMiB == %LuMiB)\n",
 160                                 td->name, td->nr_uniq_files,
 161                                 (td->total_file_size >> 20) / td->nr_uniq_files,
 162                                 td->total_file_size >> 20);
 163
 164         err = 0;
 165         for_each_file(td, f, i) {
 166                 /*
 167                  * Only unlink files that we created.
 168                  */
 169                 f->unlink = 0;
 170                 if (file_ok(td, f)) {
 171                         f->unlink = td->unlink;
 172                         err = create_file(td, f);
 173                         if (err)
 174                                 break;
 175                 }
 176         }
 177
 178         temp_stall_ts = 0;
 179         return err;
 180 }
 181
 182 static int file_size(struct thread_data *td, struct fio_file *f)
 183 {
 184         struct stat st;
 185
 186         /*
 187          * if we are not doing real io, just pretend the file is as large
 188          * as the size= given. this works fine with nrfiles > 1 as well,
 189          * we only really care about it being at least as big as size=
 190          */
 191         if (td->io_ops->flags & FIO_NULLIO) {
 192                 f->real_file_size = f->file_size = td->total_file_size;
 193                 return 0;
 194         }
 195
 196         if (td->overwrite) {
 197                 if (fstat(f->fd, &st) == -1) {
 198                         td_verror(td, errno, "fstat");
 199                         return 1;
 200                 }
 201
 202                 f->real_file_size = st.st_size;
 203
 204                 if (!f->file_size || f->file_size > f->real_file_size)
 205                         f->file_size = f->real_file_size;
 206         } else
 207                 f->real_file_size = f->file_size;
 208
 209         return 0;
 210 }
 211
 212 static int bdev_size(struct thread_data *td, struct fio_file *f)
 213 {
 214         unsigned long long bytes;
 215         int r;
 216
 217         r = blockdev_size(f->fd, &bytes);
 218         if (r) {
 219                 td_verror(td, r, "blockdev_size");
 220                 return 1;
 221         }
 222
 223         f->real_file_size = bytes;
 224
 225         /*
 226          * no extend possibilities, so limit size to device size if too large
 227          */
 228         if (!f->file_size || f->file_size > f->real_file_size)
 229                 f->file_size = f->real_file_size;
 230
 231         f->file_size -= f->file_offset;
 232         return 0;
 233 }
 234
 235 static int get_file_size(struct thread_data *td, struct fio_file *f)
 236 {
 237         int ret = 0;
 238
 239         if (td->filetype == FIO_TYPE_FILE)
 240                 ret = file_size(td, f);
 241         else if (td->filetype == FIO_TYPE_BD)
 242                 ret = bdev_size(td, f);
 243         else
 244                 f->real_file_size = -1;
 245
 246         if (ret)
 247                 return ret;
 248
 249         if (f->file_offset > f->real_file_size) {
 250                 log_err("%s: offset extends end (%Lu > %Lu)\n", td->name, f->file_offset, f->real_file_size);
 251                 return 1;
 252         }
 253
 254         return 0;
 255 }
 256
 257 int file_invalidate_cache(struct thread_data *td, struct fio_file *f)
 258 {
 259         int ret = 0;
 260
 261         /*
 262          * FIXME: add blockdev flushing too
 263          */
 264         if (td->io_ops->flags & FIO_MMAPIO)
 265                 ret = madvise(f->mmap, f->file_size, MADV_DONTNEED);
 266         else if (td->filetype == FIO_TYPE_FILE) {
 267                 if (!td->odirect)
 268                         ret = fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_DONTNEED);
 269         } else if (td->filetype == FIO_TYPE_BD) {
 270                 if (!td->odirect)
 271                         ret = blockdev_invalidate_cache(f->fd);
 272         } else if (td->filetype == FIO_TYPE_CHAR)
 273                 ret = 0;
 274
 275         if (ret < 0) {
 276                 td_verror(td, errno, "invalidate_cache");
 277                 return 1;
 278         }
 279
 280         return ret;
 281 }
 282
 283 static int __setup_file_mmap(struct thread_data *td, struct fio_file *f)
 284 {
 285         int flags;
 286
 287         if (td_rw(td))
 288                 flags = PROT_READ | PROT_WRITE;
 289         else if (td_write(td)) {
 290                 flags = PROT_WRITE;
 291
 292                 if (td->verify != VERIFY_NONE)
 293                         flags |= PROT_READ;
 294         } else
 295                 flags = PROT_READ;
 296
 297         f->mmap = mmap(NULL, f->file_size, flags, MAP_SHARED, f->fd, f->file_offset);
 298         if (f->mmap == MAP_FAILED) {
 299                 f->mmap = NULL;
 300                 td_verror(td, errno, "mmap");
 301                 return 1;
 302         }
 303
 304         if (td->invalidate_cache && file_invalidate_cache(td, f))
 305                 return 1;
 306
 307         if (!td_random(td)) {
 308                 if (madvise(f->mmap, f->file_size, MADV_SEQUENTIAL) < 0) {
 309                         td_verror(td, errno, "madvise");
 310                         return 1;
 311                 }
 312         } else {
 313                 if (madvise(f->mmap, f->file_size, MADV_RANDOM) < 0) {
 314                         td_verror(td, errno, "madvise");
 315                         return 1;
 316                 }
 317         }
 318
 319         return 0;
 320 }
 321
 322 static int setup_files_mmap(struct thread_data *td)
 323 {
 324         struct fio_file *f;
 325         int i, err = 0;
 326
 327         for_each_file(td, f, i) {
 328                 err = __setup_file_mmap(td, f);
 329                 if (err)
 330                         break;
 331         }
 332
 333         return err;
 334 }
 335
 336 static int __setup_file_plain(struct thread_data *td, struct fio_file *f)
 337 {
 338         if (td->invalidate_cache && file_invalidate_cache(td, f))
 339                 return 1;
 340
 341         if (!td_random(td)) {
 342                 if (fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_SEQUENTIAL) < 0) {
 343                         td_verror(td, errno, "fadvise");
 344                         return 1;
 345                 }
 346         } else {
 347                 if (fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_RANDOM) < 0) {
 348                         td_verror(td, errno, "fadvise");
 349                         return 1;
 350                 }
 351         }
 352
 353         return 0;
 354 }
 355
 356 static int setup_files_plain(struct thread_data *td)
 357 {
 358         struct fio_file *f;
 359         int i, err = 0;
 360
 361         for_each_file(td, f, i) {
 362                 err = __setup_file_plain(td, f);
 363                 if (err)
 364                         break;
 365         }
 366
 367         return err;
 368 }
 369
 370 static int setup_file(struct thread_data *td, struct fio_file *f)
 371 {
 372         int flags = 0;
 373
 374         if (td->io_ops->flags & FIO_SELFOPEN)
 375                 return 0;
 376
 377         /*
 378          * we need a valid file descriptor, but don't create a real file.
 379          * lets just dup stdout, seems like a sensible approach.
 380          */
 381         if (td->io_ops->flags & FIO_NULLIO)
 382                 f->fd = dup(STDOUT_FILENO);
 383         else {
 384                 if (td->odirect)
 385                         flags |= OS_O_DIRECT;
 386                 if (td->sync_io)
 387                         flags |= O_SYNC;
 388
 389                 if (td_write(td) || td_rw(td)) {
 390                         flags |= O_RDWR;
 391
 392                         if (td->filetype == FIO_TYPE_FILE) {
 393                                 if (!td->overwrite)
 394                                         flags |= O_TRUNC;
 395
 396                                 flags |= O_CREAT;
 397                         }
 398
 399                         open_file(td, f, flags, 0600);
 400                 } else {
 401                         if (td->filetype == FIO_TYPE_CHAR)
 402                                 flags |= O_RDWR;
 403                         else
 404                                 flags |= O_RDONLY;
 405
 406                         open_file(td, f, flags, 0);
 407                 }
 408         }
 409
 410         if (f->fd == -1) {
 411                 int __e = errno;
 412
 413                 td_verror(td, __e, "open");
 414                 if (__e == EINVAL && td->odirect)
 415                         log_err("fio: destination does not support O_DIRECT\n");
 416                 return 1;
 417         }
 418
 419         if (get_file_size(td, f)) {
 420                 close_file(td, f);
 421                 return 1;
 422         }
 423
 424         return 0;
 425 }
 426
 427 int open_files(struct thread_data *td)
 428 {
 429         struct fio_file *f;
 430         int i, err = 0;
 431
 432         for_each_file(td, f, i) {
 433                 err = setup_file(td, f);
 434                 if (err)
 435                         break;
 436         }
 437
 438         if (!err)
 439                 return 0;
 440
 441         for_each_file(td, f, i)
 442                 close_file(td, f);
 443
 444         return err;
 445 }
 446
 447 int setup_files(struct thread_data *td)
 448 {
 449         struct fio_file *f;
 450         int err, i;
 451
 452         /*
 453          * if ioengine defines a setup() method, it's responsible for
 454          * setting up everything in the td->files[] area.
 455          */
 456         if (td->io_ops->setup)
 457                 return td->io_ops->setup(td);
 458
 459         if (create_files(td))
 460                 return 1;
 461
 462         err = open_files(td);
 463         if (err)
 464                 return err;
 465
 466         /*
 467          * Recalculate the total file size now that files are set up.
 468          */
 469         td->total_file_size = 0;
 470         for_each_file(td, f, i)
 471                 td->total_file_size += f->file_size;
 472
 473         td->io_size = td->total_file_size;
 474         if (td->io_size == 0) {
 475                 log_err("%s: no io blocks\n", td->name);
 476                 td_verror(td, EINVAL, "total_file_size");
 477                 return 1;
 478         }
 479
 480         if (!td->zone_size)
 481                 td->zone_size = td->io_size;
 482
 483         td->total_io_size = td->io_size * td->loops;
 484
 485         if (td->io_ops->flags & FIO_MMAPIO)
 486                 err = setup_files_mmap(td);
 487         else
 488                 err = setup_files_plain(td);
 489
 490         for_each_file(td, f, i)
 491                 close_file(td, f);
 492
 493         return err;
 494 }
 495
 496 void close_files(struct thread_data *td)
 497 {
 498         struct fio_file *f;
 499         int i;
 500
 501         for_each_file(td, f, i) {
 502                 if (!td->filename && f->unlink &&
 503                     td->filetype == FIO_TYPE_FILE) {
 504                         unlink(f->file_name);
 505                         free(f->file_name);
 506                         f->file_name = NULL;
 507                 }
 508
 509                 close_file(td, f);
 510
 511                 if (f->mmap) {
 512                         munmap(f->mmap, f->file_size);
 513                         f->mmap = NULL;
 514                 }
 515         }
 516
 517         td->filename = NULL;
 518         free(td->files);
 519         td->files = NULL;
 520         td->nr_files = 0;
 521 }