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 "os.h"
  12
  13 static int extend_file(struct thread_data *td, struct fio_file *f)
  14 {
  15         unsigned long long left;
  16         unsigned int bs;
  17         char *b;
  18         int r;
  19
  20         if (f->flags & FIO_FILE_EXISTS) {
  21                 if (unlink(f->file_name) < 0) {
  22                         td_verror(td, errno, "unlink");
  23                         return 1;
  24                 }
  25         }
  26
  27         f->fd = open(f->file_name, O_WRONLY | O_CREAT | O_TRUNC, 0644);
  28         if (f->fd < 0) {
  29                 td_verror(td, errno, "open");
  30                 return 1;
  31         }
  32
  33         if (ftruncate(f->fd, f->real_file_size) == -1) {
  34                 td_verror(td, errno, "ftruncate");
  35                 goto err;
  36         }
  37
  38         if (posix_fallocate(f->fd, 0, f->real_file_size) < 0) {
  39                 td_verror(td, errno, "posix_fallocate");
  40                 goto err;
  41         }
  42
  43         b = malloc(td->o.max_bs[DDIR_WRITE]);
  44         memset(b, 0, td->o.max_bs[DDIR_WRITE]);
  45
  46         left = f->real_file_size;
  47         while (left && !td->terminate) {
  48                 bs = td->o.max_bs[DDIR_WRITE];
  49                 if (bs > left)
  50                         bs = left;
  51
  52                 r = write(f->fd, b, bs);
  53
  54                 if (r == (int) bs) {
  55                         left -= bs;
  56                         continue;
  57                 } else {
  58                         if (r < 0)
  59                                 td_verror(td, errno, "write");
  60                         else
  61                                 td_verror(td, EIO, "write");
  62
  63                         break;
  64                 }
  65         }
  66
  67         if (td->terminate)
  68                 unlink(f->file_name);
  69         else if (td->o.create_fsync)
  70                 fsync(f->fd);
  71
  72         free(b);
  73         close(f->fd);
  74         f->fd = -1;
  75         return 0;
  76 err:
  77         close(f->fd);
  78         f->fd = -1;
  79         return 1;
  80 }
  81
  82 static unsigned long long get_rand_file_size(struct thread_data *td)
  83 {
  84         unsigned long long ret;
  85         long r;
  86
  87         r = os_random_long(&td->file_size_state);
  88         ret = td->o.file_size_low + (unsigned long long) ((double) td->o.file_size_high * (r / (RAND_MAX + 1.0)));
  89         ret -= (ret % td->o.rw_min_bs);
  90         return ret;
  91 }
  92
  93 static int file_size(struct thread_data *td, struct fio_file *f)
  94 {
  95         struct stat st;
  96
  97         if (fstat(f->fd, &st) == -1) {
  98                 td_verror(td, errno, "fstat");
  99                 return 1;
 100         }
 101
 102         f->real_file_size = st.st_size;
 103         return 0;
 104 }
 105
 106 static int bdev_size(struct thread_data *td, struct fio_file *f)
 107 {
 108         unsigned long long bytes;
 109         int r;
 110
 111         r = blockdev_size(f->fd, &bytes);
 112         if (r) {
 113                 td_verror(td, r, "blockdev_size");
 114                 return 1;
 115         }
 116
 117         f->real_file_size = bytes;
 118         return 0;
 119 }
 120
 121 static int get_file_size(struct thread_data *td, struct fio_file *f)
 122 {
 123         int ret = 0;
 124
 125         if (f->filetype == FIO_TYPE_FILE)
 126                 ret = file_size(td, f);
 127         else if (f->filetype == FIO_TYPE_BD)
 128                 ret = bdev_size(td, f);
 129         else
 130                 f->real_file_size = -1;
 131
 132         if (ret)
 133                 return ret;
 134
 135         if (f->file_offset > f->real_file_size) {
 136                 log_err("%s: offset extends end (%Lu > %Lu)\n", td->o.name, f->file_offset, f->real_file_size);
 137                 return 1;
 138         }
 139
 140         return 0;
 141 }
 142
 143 int file_invalidate_cache(struct thread_data *td, struct fio_file *f)
 144 {
 145         int ret = 0;
 146
 147         if (td->o.odirect)
 148                 return 0;
 149
 150         /*
 151          * FIXME: add blockdev flushing too
 152          */
 153         if (f->mmap)
 154                 ret = madvise(f->mmap, f->io_size, MADV_DONTNEED);
 155         else if (f->filetype == FIO_TYPE_FILE)
 156                 ret = fadvise(f->fd, f->file_offset, f->io_size, POSIX_FADV_DONTNEED);
 157         else if (f->filetype == FIO_TYPE_BD) {
 158                 ret = blockdev_invalidate_cache(f->fd);
 159                 if (ret < 0 && errno == EACCES && geteuid()) {
 160                         log_err("fio: only root may flush block devices. Cache flush bypassed!\n");
 161                         ret = 0;
 162                 }
 163         } else if (f->filetype == FIO_TYPE_CHAR)
 164                 ret = 0;
 165
 166         if (ret < 0) {
 167                 td_verror(td, errno, "invalidate_cache");
 168                 return 1;
 169         }
 170
 171         return ret;
 172 }
 173
 174 void generic_close_file(struct thread_data fio_unused *td, struct fio_file *f)
 175 {
 176         close(f->fd);
 177         f->fd = -1;
 178 }
 179
 180 int generic_open_file(struct thread_data *td, struct fio_file *f)
 181 {
 182         int flags = 0;
 183
 184         if (td->o.odirect)
 185                 flags |= OS_O_DIRECT;
 186         if (td->o.sync_io)
 187                 flags |= O_SYNC;
 188
 189         if (td_write(td) || td_rw(td)) {
 190                 flags |= O_RDWR;
 191
 192                 if (f->filetype == FIO_TYPE_FILE)
 193                         flags |= O_CREAT;
 194
 195                 f->fd = open(f->file_name, flags, 0600);
 196         } else {
 197                 if (f->filetype == FIO_TYPE_CHAR)
 198                         flags |= O_RDWR;
 199                 else
 200                         flags |= O_RDONLY;
 201
 202                 f->fd = open(f->file_name, flags);
 203         }
 204
 205         if (f->fd == -1) {
 206                 char buf[FIO_VERROR_SIZE];
 207                 int __e = errno;
 208
 209                 snprintf(buf, sizeof(buf) - 1, "open(%s)", f->file_name);
 210
 211                 td_verror(td, __e, buf);
 212         }
 213
 214         if (get_file_size(td, f))
 215                 goto err;
 216
 217         return 0;
 218 err:
 219         close(f->fd);
 220         return 1;
 221 }
 222
 223 int open_files(struct thread_data *td)
 224 {
 225         struct fio_file *f;
 226         unsigned int i;
 227         int err = 0;
 228
 229         for_each_file(td, f, i) {
 230                 err = td_io_open_file(td, f);
 231                 if (err)
 232                         break;
 233
 234                 if (td->o.open_files == td->nr_open_files)
 235                         break;
 236         }
 237
 238         if (!err)
 239                 return 0;
 240
 241         for_each_file(td, f, i)
 242                 td_io_close_file(td, f);
 243
 244         return err;
 245 }
 246
 247 /*
 248  * open/close all files, so that ->real_file_size gets set
 249  */
 250 static int get_file_sizes(struct thread_data *td)
 251 {
 252         struct fio_file *f;
 253         unsigned int i;
 254         int err = 0;
 255
 256         for_each_file(td, f, i) {
 257                 err = td->io_ops->open_file(td, f);
 258                 if (err) {
 259                         td->error = 0;
 260                         memset(td->verror, 0, sizeof(td->verror));
 261                         err = 0;
 262                         continue;
 263                 }
 264
 265                 td->io_ops->close_file(td, f);
 266         }
 267
 268         return err;
 269 }
 270
 271 /*
 272  * Open the files and setup files sizes, creating files if necessary.
 273  */
 274 int setup_files(struct thread_data *td)
 275 {
 276         unsigned long long total_size, extend_size;
 277         struct fio_file *f;
 278         unsigned int i;
 279         int err, need_extend;
 280
 281         /*
 282          * if ioengine defines a setup() method, it's responsible for
 283          * opening the files and setting f->real_file_size to indicate
 284          * the valid range for that file.
 285          */
 286         if (td->io_ops->setup)
 287                 err = td->io_ops->setup(td);
 288         else
 289                 err = get_file_sizes(td);
 290
 291         if (err)
 292                 return err;
 293
 294         /*
 295          * check sizes. if the files/devices do not exist and the size
 296          * isn't passed to fio, abort.
 297          */
 298         total_size = 0;
 299         for_each_file(td, f, i) {
 300                 if (f->real_file_size == -1ULL)
 301                         total_size = -1ULL;
 302                 else
 303                         total_size += f->real_file_size;
 304         }
 305
 306         /*
 307          * device/file sizes are zero and no size given, punt
 308          */
 309         if (!total_size && !td->o.size) {
 310                 log_err("%s: you need to specify size=\n", td->o.name);
 311                 td_verror(td, EINVAL, "total_file_size");
 312                 return 1;
 313         }
 314
 315         /*
 316          * now file sizes are known, so we can set ->io_size. if size= is
 317          * not given, ->io_size is just equal to ->real_file_size. if size
 318          * is given, ->io_size is size / nr_files.
 319          */
 320         extend_size = total_size = 0;
 321         need_extend = 0;
 322         for_each_file(td, f, i) {
 323                 if (!td->o.file_size_low) {
 324                         /*
 325                          * no file size range given, file size is equal to
 326                          * total size divided by number of files. if that is
 327                          * zero, set it to the real file size.
 328                          */
 329                         f->io_size = td->o.size / td->o.nr_files;
 330                         if (!f->io_size)
 331                                 f->io_size = f->real_file_size;
 332                 } else if (f->real_file_size < td->o.file_size_low ||
 333                            f->real_file_size > td->o.file_size_high) {
 334                         /*
 335                          * file size given. if it's fixed, use that. if it's a
 336                          * range, generate a random size in-between.
 337                          */
 338                         if (td->o.file_size_low == td->o.file_size_high)
 339                                 f->io_size = td->o.file_size_low;
 340                         else
 341                                 f->io_size = get_rand_file_size(td);
 342                 } else
 343                         f->io_size = f->real_file_size;
 344
 345                 if (f->io_size == -1ULL)
 346                         total_size = -1ULL;
 347                 else
 348                         total_size += f->io_size;
 349
 350                 if (f->filetype == FIO_TYPE_FILE &&
 351                     f->io_size > f->real_file_size &&
 352                     !(td->io_ops->flags & FIO_DISKLESSIO)) {
 353                         need_extend++;
 354                         extend_size += f->io_size;
 355                         f->flags |= FIO_FILE_EXTEND;
 356                 }
 357         }
 358
 359         if (!td->o.size)
 360                 td->o.size = total_size;
 361
 362         /*
 363          * See if we need to extend some files
 364          */
 365         if (need_extend) {
 366                 temp_stall_ts = 1;
 367                 log_info("%s: Laying out IO file(s) (%u files / %LuMiB)\n",
 368                         td->o.name, need_extend, extend_size >> 20);
 369
 370                 for_each_file(td, f, i) {
 371                         if (!(f->flags & FIO_FILE_EXTEND))
 372                                 continue;
 373
 374                         f->flags &= ~FIO_FILE_EXTEND;
 375                         f->real_file_size = f->io_size;
 376                         err = extend_file(td, f);
 377                         if (err)
 378                                 break;
 379                 }
 380                 temp_stall_ts = 0;
 381         }
 382
 383         if (err)
 384                 return err;
 385
 386         if (!td->o.zone_size)
 387                 td->o.zone_size = td->o.size;
 388
 389         td->total_io_size = td->o.size * td->o.loops;
 390         return 0;
 391 }
 392
 393 int init_random_map(struct thread_data *td)
 394 {
 395         int num_maps, blocks;
 396         struct fio_file *f;
 397         unsigned int i;
 398
 399         if (td->o.norandommap)
 400                 return 0;
 401
 402         for_each_file(td, f, i) {
 403                 blocks = (f->real_file_size + td->o.rw_min_bs - 1) / td->o.rw_min_bs;
 404                 num_maps = (blocks + BLOCKS_PER_MAP-1)/ BLOCKS_PER_MAP;
 405                 f->file_map = malloc(num_maps * sizeof(long));
 406                 if (!f->file_map) {
 407                         log_err("fio: failed allocating random map. If running a large number of jobs, try the 'norandommap' option\n");
 408                         return 1;
 409                 }
 410                 f->num_maps = num_maps;
 411                 memset(f->file_map, 0, num_maps * sizeof(long));
 412         }
 413
 414         return 0;
 415 }
 416
 417 void close_files(struct thread_data *td)
 418 {
 419         struct fio_file *f;
 420         unsigned int i;
 421
 422         for_each_file(td, f, i) {
 423                 if ((f->flags & FIO_FILE_UNLINK) &&
 424                     f->filetype == FIO_TYPE_FILE)
 425                         unlink(f->file_name);
 426
 427                 td_io_close_file(td, f);
 428
 429                 free(f->file_name);
 430                 f->file_name = NULL;
 431
 432                 if (f->file_map) {
 433                         free(f->file_map);
 434                         f->file_map = NULL;
 435                 }
 436         }
 437
 438         td->o.filename = NULL;
 439         free(td->files);
 440         td->files = NULL;
 441         td->o.nr_files = 0;
 442 }
 443
 444 static void get_file_type(struct fio_file *f)
 445 {
 446         struct stat sb;
 447
 448         f->filetype = FIO_TYPE_FILE;
 449
 450         if (!lstat(f->file_name, &sb)) {
 451                 if (S_ISBLK(sb.st_mode))
 452                         f->filetype = FIO_TYPE_BD;
 453                 else if (S_ISCHR(sb.st_mode))
 454                         f->filetype = FIO_TYPE_CHAR;
 455         }
 456 }
 457
 458 void add_file(struct thread_data *td, const char *fname)
 459 {
 460         int cur_files = td->files_index;
 461         char file_name[PATH_MAX];
 462         struct fio_file *f;
 463         int len = 0;
 464
 465         td->files = realloc(td->files, (cur_files + 1) * sizeof(*f));
 466
 467         f = &td->files[cur_files];
 468         memset(f, 0, sizeof(*f));
 469         f->fd = -1;
 470
 471         if (td->o.directory)
 472                 len = sprintf(file_name, "%s/", td->o.directory);
 473
 474         sprintf(file_name + len, "%s", fname);
 475         f->file_name = strdup(file_name);
 476
 477         get_file_type(f);
 478
 479         td->files_index++;
 480         if (f->filetype == FIO_TYPE_FILE)
 481                 td->nr_normal_files++;
 482 }
 483
 484 void get_file(struct fio_file *f)
 485 {
 486         f->references++;
 487 }
 488
 489 void put_file(struct thread_data *td, struct fio_file *f)
 490 {
 491         if (!(f->flags & FIO_FILE_OPEN))
 492                 return;
 493
 494         assert(f->references);
 495         if (--f->references)
 496                 return;
 497
 498         if (should_fsync(td) && td->o.fsync_on_close)
 499                 fsync(f->fd);
 500
 501         if (td->io_ops->close_file)
 502                 td->io_ops->close_file(td, f);
 503         td->nr_open_files--;
 504         f->flags &= ~FIO_FILE_OPEN;
 505 }
 506
 507 static int recurse_dir(struct thread_data *td, const char *dirname)
 508 {
 509         struct dirent *dir;
 510         int ret = 0;
 511         DIR *D;
 512
 513         D = opendir(dirname);
 514         if (!D) {
 515                 td_verror(td, errno, "opendir");
 516                 return 1;
 517         }
 518
 519         while ((dir = readdir(D)) != NULL) {
 520                 char full_path[PATH_MAX];
 521                 struct stat sb;
 522
 523                 if (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, ".."))
 524                         continue;
 525
 526                 sprintf(full_path, "%s/%s", dirname, dir->d_name);
 527
 528                 if (lstat(full_path, &sb) == -1) {
 529                         if (errno != ENOENT) {
 530                                 td_verror(td, errno, "stat");
 531                                 return 1;
 532                         }
 533                 }
 534
 535                 if (S_ISREG(sb.st_mode)) {
 536                         add_file(td, full_path);
 537                         td->o.nr_files++;
 538                         continue;
 539                 }
 540
 541                 if ((ret = recurse_dir(td, full_path)) != 0)
 542                         break;
 543         }
 544
 545         closedir(D);
 546         return ret;
 547 }
 548
 549 int add_dir_files(struct thread_data *td, const char *path)
 550 {
 551         return recurse_dir(td, path);
 552 }
 553
 554 void dup_files(struct thread_data *td, struct thread_data *org)
 555 {
 556         struct fio_file *f;
 557         unsigned int i;
 558         size_t bytes;
 559
 560         if (!org->files)
 561                 return;
 562
 563         bytes = org->files_index * sizeof(*f);
 564         td->files = malloc(bytes);
 565         memcpy(td->files, org->files, bytes);
 566
 567         for_each_file(td, f, i) {
 568                 if (f->file_name)
 569                         f->file_name = strdup(f->file_name);
 570         }
 571 }