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