projects / fio.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
filesetup: don't print non-debug error on native fallocate failure
[fio.git] / filesetup.c
... / ...
CommitLineData
1#include <unistd.h>
2#include <fcntl.h>
3#include <string.h>
4#include <assert.h>
5#include <dirent.h>
6#include <libgen.h>
7#include <sys/stat.h>
8#include <sys/mman.h>
9#include <sys/types.h>
10
11#include "fio.h"
12#include "smalloc.h"
13#include "filehash.h"
14#include "options.h"
15#include "os/os.h"
16#include "hash.h"
17#include "lib/axmap.h"
18
19#ifdef CONFIG_LINUX_FALLOCATE
20#include <linux/falloc.h>
21#endif
22
23static int root_warn;
24
25static FLIST_HEAD(filename_list);
26
27/*
28 * List entry for filename_list
29 */
30struct file_name {
31 struct flist_head list;
32 char *filename;
33};
34
35static inline void clear_error(struct thread_data *td)
36{
37 td->error = 0;
38 td->verror[0] = '\0';
39}
40
41static inline int native_fallocate(struct thread_data *td, struct fio_file *f)
42{
43 bool success;
44
45 success = fio_fallocate(f, 0, f->real_file_size);
46 dprint(FD_FILE, "native fallocate of file %s size %llu was "
47 "%ssuccessful\n", f->file_name,
48 (unsigned long long) f->real_file_size,
49 !success ? "un": "");
50
51 if (success)
52 return false;
53
54 if (errno == ENOSYS)
55 dprint(FD_FILE, "native fallocate is not implemented\n");
56
57 return true;
58}
59
60static void fallocate_file(struct thread_data *td, struct fio_file *f)
61{
62 int r;
63
64 if (td->o.fill_device)
65 return;
66
67 switch (td->o.fallocate_mode) {
68 case FIO_FALLOCATE_NATIVE:
69 native_fallocate(td, f);
70 break;
71 case FIO_FALLOCATE_NONE:
72 break;
73#ifdef CONFIG_POSIX_FALLOCATE
74 case FIO_FALLOCATE_POSIX:
75 dprint(FD_FILE, "posix_fallocate file %s size %llu\n",
76 f->file_name,
77 (unsigned long long) f->real_file_size);
78
79 r = posix_fallocate(f->fd, 0, f->real_file_size);
80 if (r > 0)
81 log_err("fio: posix_fallocate fails: %s\n", strerror(r));
82 break;
83#endif /* CONFIG_POSIX_FALLOCATE */
84#ifdef CONFIG_LINUX_FALLOCATE
85 case FIO_FALLOCATE_KEEP_SIZE:
86 dprint(FD_FILE, "fallocate(FALLOC_FL_KEEP_SIZE) "
87 "file %s size %llu\n", f->file_name,
88 (unsigned long long) f->real_file_size);
89
90 r = fallocate(f->fd, FALLOC_FL_KEEP_SIZE, 0, f->real_file_size);
91 if (r != 0)
92 td_verror(td, errno, "fallocate");
93
94 break;
95#endif /* CONFIG_LINUX_FALLOCATE */
96 default:
97 log_err("fio: unknown fallocate mode: %d\n", td->o.fallocate_mode);
98 assert(0);
99 }
100}
101
102/*
103 * Leaves f->fd open on success, caller must close
104 */
105static int extend_file(struct thread_data *td, struct fio_file *f)
106{
107 int new_layout = 0, unlink_file = 0, flags;
108 unsigned long long left;
109 unsigned int bs;
110 char *b = NULL;
111
112 if (read_only) {
113 log_err("fio: refusing extend of file due to read-only\n");
114 return 0;
115 }
116
117 /*
118 * check if we need to lay the file out complete again. fio
119 * does that for operations involving reads, or for writes
120 * where overwrite is set
121 */
122 if (td_read(td) ||
123 (td_write(td) && td->o.overwrite && !td->o.file_append) ||
124 (td_write(td) && td_ioengine_flagged(td, FIO_NOEXTEND)))
125 new_layout = 1;
126 if (td_write(td) && !td->o.overwrite && !td->o.file_append)
127 unlink_file = 1;
128
129 if (unlink_file || new_layout) {
130 int ret;
131
132 dprint(FD_FILE, "layout unlink %s\n", f->file_name);
133
134 ret = td_io_unlink_file(td, f);
135 if (ret != 0 && ret != ENOENT) {
136 td_verror(td, errno, "unlink");
137 return 1;
138 }
139 }
140
141 flags = O_WRONLY;
142 if (td->o.allow_create)
143 flags |= O_CREAT;
144 if (new_layout)
145 flags |= O_TRUNC;
146
147#ifdef WIN32
148 flags |= _O_BINARY;
149#endif
150
151 dprint(FD_FILE, "open file %s, flags %x\n", f->file_name, flags);
152 f->fd = open(f->file_name, flags, 0644);
153 if (f->fd < 0) {
154 int err = errno;
155
156 if (err == ENOENT && !td->o.allow_create)
157 log_err("fio: file creation disallowed by "
158 "allow_file_create=0\n");
159 else
160 td_verror(td, err, "open");
161 return 1;
162 }
163
164 fallocate_file(td, f);
165
166 /*
167 * If our jobs don't require regular files initially, we're done.
168 */
169 if (!new_layout)
170 goto done;
171
172 /*
173 * The size will be -1ULL when fill_device is used, so don't truncate
174 * or fallocate this file, just write it
175 */
176 if (!td->o.fill_device) {
177 dprint(FD_FILE, "truncate file %s, size %llu\n", f->file_name,
178 (unsigned long long) f->real_file_size);
179 if (ftruncate(f->fd, f->real_file_size) == -1) {
180 if (errno != EFBIG) {
181 td_verror(td, errno, "ftruncate");
182 goto err;
183 }
184 }
185 }
186
187 left = f->real_file_size;
188 bs = td->o.max_bs[DDIR_WRITE];
189 if (bs > left)
190 bs = left;
191
192 b = malloc(bs);
193 if (!b) {
194 td_verror(td, errno, "malloc");
195 goto err;
196 }
197
198 while (left && !td->terminate) {
199 ssize_t r;
200
201 if (bs > left)
202 bs = left;
203
204 fill_io_buffer(td, b, bs, bs);
205
206 r = write(f->fd, b, bs);
207
208 if (r > 0) {
209 left -= r;
210 continue;
211 } else {
212 if (r < 0) {
213 int __e = errno;
214
215 if (__e == ENOSPC) {
216 if (td->o.fill_device)
217 break;
218 log_info("fio: ENOSPC on laying out "
219 "file, stopping\n");
220 break;
221 }
222 td_verror(td, errno, "write");
223 } else
224 td_verror(td, EIO, "write");
225
226 break;
227 }
228 }
229
230 if (td->terminate) {
231 dprint(FD_FILE, "terminate unlink %s\n", f->file_name);
232 td_io_unlink_file(td, f);
233 } else if (td->o.create_fsync) {
234 if (fsync(f->fd) < 0) {
235 td_verror(td, errno, "fsync");
236 goto err;
237 }
238 }
239 if (td->o.fill_device && !td_write(td)) {
240 fio_file_clear_size_known(f);
241 if (td_io_get_file_size(td, f))
242 goto err;
243 if (f->io_size > f->real_file_size)
244 f->io_size = f->real_file_size;
245 }
246
247 free(b);
248done:
249 return 0;
250err:
251 close(f->fd);
252 f->fd = -1;
253 if (b)
254 free(b);
255 return 1;
256}
257
258static int pre_read_file(struct thread_data *td, struct fio_file *f)
259{
260 int ret = 0, r, did_open = 0, old_runstate;
261 unsigned long long left;
262 unsigned int bs;
263 char *b;
264
265 if (td_ioengine_flagged(td, FIO_PIPEIO) ||
266 td_ioengine_flagged(td, FIO_NOIO))
267 return 0;
268
269 if (f->filetype == FIO_TYPE_CHAR)
270 return 0;
271
272 if (!fio_file_open(f)) {
273 if (td->io_ops->open_file(td, f)) {
274 log_err("fio: cannot pre-read, failed to open file\n");
275 return 1;
276 }
277 did_open = 1;
278 }
279
280 old_runstate = td_bump_runstate(td, TD_PRE_READING);
281
282 left = f->io_size;
283 bs = td->o.max_bs[DDIR_READ];
284 if (bs > left)
285 bs = left;
286
287 b = malloc(bs);
288 if (!b) {
289 td_verror(td, errno, "malloc");
290 ret = 1;
291 goto error;
292 }
293 memset(b, 0, bs);
294
295 if (lseek(f->fd, f->file_offset, SEEK_SET) < 0) {
296 td_verror(td, errno, "lseek");
297 log_err("fio: failed to lseek pre-read file\n");
298 ret = 1;
299 goto error;
300 }
301
302 while (left && !td->terminate) {
303 if (bs > left)
304 bs = left;
305
306 r = read(f->fd, b, bs);
307
308 if (r == (int) bs) {
309 left -= bs;
310 continue;
311 } else {
312 td_verror(td, EIO, "pre_read");
313 break;
314 }
315 }
316
317error:
318 td_restore_runstate(td, old_runstate);
319
320 if (did_open)
321 td->io_ops->close_file(td, f);
322
323 free(b);
324 return ret;
325}
326
327unsigned long long get_rand_file_size(struct thread_data *td)
328{
329 unsigned long long ret, sized;
330 uint64_t frand_max;
331 unsigned long r;
332
333 frand_max = rand_max(&td->file_size_state);
334 r = __rand(&td->file_size_state);
335 sized = td->o.file_size_high - td->o.file_size_low;
336 ret = (unsigned long long) ((double) sized * (r / (frand_max + 1.0)));
337 ret += td->o.file_size_low;
338 ret -= (ret % td->o.rw_min_bs);
339 return ret;
340}
341
342static int file_size(struct thread_data *td, struct fio_file *f)
343{
344 struct stat st;
345
346 if (stat(f->file_name, &st) == -1) {
347 td_verror(td, errno, "fstat");
348 return 1;
349 }
350
351 f->real_file_size = st.st_size;
352 return 0;
353}
354
355static int bdev_size(struct thread_data *td, struct fio_file *f)
356{
357 unsigned long long bytes = 0;
358 int r;
359
360 if (td->io_ops->open_file(td, f)) {
361 log_err("fio: failed opening blockdev %s for size check\n",
362 f->file_name);
363 return 1;
364 }
365
366 r = blockdev_size(f, &bytes);
367 if (r) {
368 td_verror(td, r, "blockdev_size");
369 goto err;
370 }
371
372 if (!bytes) {
373 log_err("%s: zero sized block device?\n", f->file_name);
374 goto err;
375 }
376
377 f->real_file_size = bytes;
378 td->io_ops->close_file(td, f);
379 return 0;
380err:
381 td->io_ops->close_file(td, f);
382 return 1;
383}
384
385static int char_size(struct thread_data *td, struct fio_file *f)
386{
387#ifdef FIO_HAVE_CHARDEV_SIZE
388 unsigned long long bytes = 0;
389 int r;
390
391 if (td->io_ops->open_file(td, f)) {
392 log_err("fio: failed opening chardev %s for size check\n",
393 f->file_name);
394 return 1;
395 }
396
397 r = chardev_size(f, &bytes);
398 if (r) {
399 td_verror(td, r, "chardev_size");
400 goto err;
401 }
402
403 if (!bytes) {
404 log_err("%s: zero sized char device?\n", f->file_name);
405 goto err;
406 }
407
408 f->real_file_size = bytes;
409 td->io_ops->close_file(td, f);
410 return 0;
411err:
412 td->io_ops->close_file(td, f);
413 return 1;
414#else
415 f->real_file_size = -1ULL;
416 return 0;
417#endif
418}
419
420static int get_file_size(struct thread_data *td, struct fio_file *f)
421{
422 int ret = 0;
423
424 if (fio_file_size_known(f))
425 return 0;
426
427 if (f->filetype == FIO_TYPE_FILE)
428 ret = file_size(td, f);
429 else if (f->filetype == FIO_TYPE_BLOCK)
430 ret = bdev_size(td, f);
431 else if (f->filetype == FIO_TYPE_CHAR)
432 ret = char_size(td, f);
433 else
434 f->real_file_size = -1ULL;
435
436 /*
437 * Leave ->real_file_size with 0 since it could be expectation
438 * of initial setup for regular files.
439 */
440 if (ret)
441 return ret;
442
443 /*
444 * If ->real_file_size is -1, a conditional for the message
445 * "offset extends end" is always true, but it makes no sense,
446 * so just return the same value here.
447 */
448 if (f->real_file_size == -1ULL) {
449 log_info("%s: failed to get file size of %s\n", td->o.name,
450 f->file_name);
451 return 1;
452 }
453
454 if (td->o.start_offset && f->file_offset == 0)
455 dprint(FD_FILE, "offset of file %s not initialized yet\n",
456 f->file_name);
457 /*
458 * ->file_offset normally hasn't been initialized yet, so this
459 * is basically always false.
460 */
461 if (f->file_offset > f->real_file_size) {
462 log_err("%s: offset extends end (%llu > %llu)\n", td->o.name,
463 (unsigned long long) f->file_offset,
464 (unsigned long long) f->real_file_size);
465 return 1;
466 }
467
468 fio_file_set_size_known(f);
469 return 0;
470}
471
472static int __file_invalidate_cache(struct thread_data *td, struct fio_file *f,
473 unsigned long long off,
474 unsigned long long len)
475{
476 int errval = 0, ret = 0;
477
478#ifdef CONFIG_ESX
479 return 0;
480#endif
481
482 if (len == -1ULL)
483 len = f->io_size;
484 if (off == -1ULL)
485 off = f->file_offset;
486
487 if (len == -1ULL || off == -1ULL)
488 return 0;
489
490 if (td->io_ops->invalidate) {
491 dprint(FD_IO, "invalidate %s cache %s\n", td->io_ops->name,
492 f->file_name);
493 ret = td->io_ops->invalidate(td, f);
494 if (ret < 0)
495 errval = -ret;
496 } else if (f->filetype == FIO_TYPE_FILE) {
497 dprint(FD_IO, "declare unneeded cache %s: %llu/%llu\n",
498 f->file_name, off, len);
499 ret = posix_fadvise(f->fd, off, len, POSIX_FADV_DONTNEED);
500 if (ret)
501 errval = ret;
502 } else if (f->filetype == FIO_TYPE_BLOCK) {
503 int retry_count = 0;
504
505 dprint(FD_IO, "drop page cache %s\n", f->file_name);
506 ret = blockdev_invalidate_cache(f);
507 while (ret < 0 && errno == EAGAIN && retry_count++ < 25) {
508 /*
509 * Linux multipath devices reject ioctl while
510 * the maps are being updated. That window can
511 * last tens of milliseconds; we'll try up to
512 * a quarter of a second.
513 */
514 usleep(10000);
515 ret = blockdev_invalidate_cache(f);
516 }
517 if (ret < 0 && errno == EACCES && geteuid()) {
518 if (!root_warn) {
519 log_err("fio: only root may flush block "
520 "devices. Cache flush bypassed!\n");
521 root_warn = 1;
522 }
523 ret = 0;
524 }
525 if (ret < 0)
526 errval = errno;
527 } else if (f->filetype == FIO_TYPE_CHAR ||
528 f->filetype == FIO_TYPE_PIPE) {
529 dprint(FD_IO, "invalidate not supported %s\n", f->file_name);
530 ret = 0;
531 }
532
533 /*
534 * Cache flushing isn't a fatal condition, and we know it will
535 * happen on some platforms where we don't have the proper
536 * function to flush eg block device caches. So just warn and
537 * continue on our way.
538 */
539 if (errval)
540 log_info("fio: cache invalidation of %s failed: %s\n",
541 f->file_name, strerror(errval));
542
543 return 0;
544
545}
546
547int file_invalidate_cache(struct thread_data *td, struct fio_file *f)
548{
549 if (!fio_file_open(f))
550 return 0;
551
552 return __file_invalidate_cache(td, f, -1ULL, -1ULL);
553}
554
555int generic_close_file(struct thread_data fio_unused *td, struct fio_file *f)
556{
557 int ret = 0;
558
559 dprint(FD_FILE, "fd close %s\n", f->file_name);
560
561 remove_file_hash(f);
562
563 if (close(f->fd) < 0)
564 ret = errno;
565
566 f->fd = -1;
567
568 if (f->shadow_fd != -1) {
569 close(f->shadow_fd);
570 f->shadow_fd = -1;
571 }
572
573 f->engine_pos = 0;
574 return ret;
575}
576
577int file_lookup_open(struct fio_file *f, int flags)
578{
579 struct fio_file *__f;
580 int from_hash;
581
582 __f = lookup_file_hash(f->file_name);
583 if (__f) {
584 dprint(FD_FILE, "found file in hash %s\n", f->file_name);
585 f->lock = __f->lock;
586 from_hash = 1;
587 } else {
588 dprint(FD_FILE, "file not found in hash %s\n", f->file_name);
589 from_hash = 0;
590 }
591
592#ifdef WIN32
593 flags |= _O_BINARY;
594#endif
595
596 f->fd = open(f->file_name, flags, 0600);
597 return from_hash;
598}
599
600static int file_close_shadow_fds(struct thread_data *td)
601{
602 struct fio_file *f;
603 int num_closed = 0;
604 unsigned int i;
605
606 for_each_file(td, f, i) {
607 if (f->shadow_fd == -1)
608 continue;
609
610 close(f->shadow_fd);
611 f->shadow_fd = -1;
612 num_closed++;
613 }
614
615 return num_closed;
616}
617
618int generic_open_file(struct thread_data *td, struct fio_file *f)
619{
620 int is_std = 0;
621 int flags = 0;
622 int from_hash = 0;
623
624 dprint(FD_FILE, "fd open %s\n", f->file_name);
625
626 if (!strcmp(f->file_name, "-")) {
627 if (td_rw(td)) {
628 log_err("fio: can't read/write to stdin/out\n");
629 return 1;
630 }
631 is_std = 1;
632
633 /*
634 * move output logging to stderr, if we are writing to stdout
635 */
636 if (td_write(td))
637 f_out = stderr;
638 }
639
640 if (td_trim(td))
641 goto skip_flags;
642 if (td->o.odirect)
643 flags |= OS_O_DIRECT;
644 if (td->o.oatomic) {
645 if (!FIO_O_ATOMIC) {
646 td_verror(td, EINVAL, "OS does not support atomic IO");
647 return 1;
648 }
649 flags |= OS_O_DIRECT | FIO_O_ATOMIC;
650 }
651 if (td->o.sync_io)
652 flags |= O_SYNC;
653 if (td->o.create_on_open && td->o.allow_create)
654 flags |= O_CREAT;
655skip_flags:
656 if (f->filetype != FIO_TYPE_FILE)
657 flags |= FIO_O_NOATIME;
658
659open_again:
660 if (td_write(td)) {
661 if (!read_only)
662 flags |= O_RDWR;
663
664 if (f->filetype == FIO_TYPE_FILE && td->o.allow_create)
665 flags |= O_CREAT;
666
667 if (is_std)
668 f->fd = dup(STDOUT_FILENO);
669 else
670 from_hash = file_lookup_open(f, flags);
671 } else if (td_read(td)) {
672 if (f->filetype == FIO_TYPE_CHAR && !read_only)
673 flags |= O_RDWR;
674 else
675 flags |= O_RDONLY;
676
677 if (is_std)
678 f->fd = dup(STDIN_FILENO);
679 else
680 from_hash = file_lookup_open(f, flags);
681 } else if (td_trim(td)) {
682 assert(!td_rw(td)); /* should have matched above */
683 flags |= O_RDWR;
684 from_hash = file_lookup_open(f, flags);
685 }
686
687 if (f->fd == -1) {
688 char buf[FIO_VERROR_SIZE];
689 int __e = errno;
690
691 if (__e == EPERM && (flags & FIO_O_NOATIME)) {
692 flags &= ~FIO_O_NOATIME;
693 goto open_again;
694 }
695 if (__e == EMFILE && file_close_shadow_fds(td))
696 goto open_again;
697
698 snprintf(buf, sizeof(buf), "open(%s)", f->file_name);
699
700 if (__e == EINVAL && (flags & OS_O_DIRECT)) {
701 log_err("fio: looks like your file system does not " \
702 "support direct=1/buffered=0\n");
703 }
704
705 td_verror(td, __e, buf);
706 return 1;
707 }
708
709 if (!from_hash && f->fd != -1) {
710 if (add_file_hash(f)) {
711 int fio_unused ret;
712
713 /*
714 * Stash away descriptor for later close. This is to
715 * work-around a "feature" on Linux, where a close of
716 * an fd that has been opened for write will trigger
717 * udev to call blkid to check partitions, fs id, etc.
718 * That pollutes the device cache, which can slow down
719 * unbuffered accesses.
720 */
721 if (f->shadow_fd == -1)
722 f->shadow_fd = f->fd;
723 else {
724 /*
725 * OK to ignore, we haven't done anything
726 * with it
727 */
728 ret = generic_close_file(td, f);
729 }
730 goto open_again;
731 }
732 }
733
734 return 0;
735}
736
737/*
738 * This function i.e. get_file_size() is the default .get_file_size
739 * implementation of majority of I/O engines.
740 */
741int generic_get_file_size(struct thread_data *td, struct fio_file *f)
742{
743 return get_file_size(td, f);
744}
745
746/*
747 * open/close all files, so that ->real_file_size gets set
748 */
749static int get_file_sizes(struct thread_data *td)
750{
751 struct fio_file *f;
752 unsigned int i;
753 int err = 0;
754
755 for_each_file(td, f, i) {
756 dprint(FD_FILE, "get file size for %p/%d/%s\n", f, i,
757 f->file_name);
758
759 if (td_io_get_file_size(td, f)) {
760 if (td->error != ENOENT) {
761 log_err("%s\n", td->verror);
762 err = 1;
763 break;
764 }
765 clear_error(td);
766 }
767
768 /*
769 * There are corner cases where we end up with -1 for
770 * ->real_file_size due to unsupported file type, etc.
771 * We then just set to size option value divided by number
772 * of files, similar to the way file ->io_size is set.
773 * stat(2) failure doesn't set ->real_file_size to -1.
774 */
775 if (f->real_file_size == -1ULL && td->o.size)
776 f->real_file_size = td->o.size / td->o.nr_files;
777 }
778
779 return err;
780}
781
782struct fio_mount {
783 struct flist_head list;
784 const char *base;
785 char __base[256];
786 unsigned int key;
787};
788
789/*
790 * Get free number of bytes for each file on each unique mount.
791 */
792static unsigned long long get_fs_free_counts(struct thread_data *td)
793{
794 struct flist_head *n, *tmp;
795 unsigned long long ret = 0;
796 struct fio_mount *fm;
797 FLIST_HEAD(list);
798 struct fio_file *f;
799 unsigned int i;
800
801 for_each_file(td, f, i) {
802 struct stat sb;
803 char buf[256];
804
805 if (f->filetype == FIO_TYPE_BLOCK || f->filetype == FIO_TYPE_CHAR) {
806 if (f->real_file_size != -1ULL)
807 ret += f->real_file_size;
808 continue;
809 } else if (f->filetype != FIO_TYPE_FILE)
810 continue;
811
812 buf[255] = '\0';
813 strncpy(buf, f->file_name, 255);
814
815 if (stat(buf, &sb) < 0) {
816 if (errno != ENOENT)
817 break;
818 strcpy(buf, ".");
819 if (stat(buf, &sb) < 0)
820 break;
821 }
822
823 fm = NULL;
824 flist_for_each(n, &list) {
825 fm = flist_entry(n, struct fio_mount, list);
826 if (fm->key == sb.st_dev)
827 break;
828
829 fm = NULL;
830 }
831
832 if (fm)
833 continue;
834
835 fm = calloc(1, sizeof(*fm));
836 strncpy(fm->__base, buf, sizeof(fm->__base) - 1);
837 fm->base = basename(fm->__base);
838 fm->key = sb.st_dev;
839 flist_add(&fm->list, &list);
840 }
841
842 flist_for_each_safe(n, tmp, &list) {
843 unsigned long long sz;
844
845 fm = flist_entry(n, struct fio_mount, list);
846 flist_del(&fm->list);
847
848 sz = get_fs_free_size(fm->base);
849 if (sz && sz != -1ULL)
850 ret += sz;
851
852 free(fm);
853 }
854
855 return ret;
856}
857
858uint64_t get_start_offset(struct thread_data *td, struct fio_file *f)
859{
860 struct thread_options *o = &td->o;
861 unsigned long long align_bs;
862 unsigned long long offset;
863
864 if (o->file_append && f->filetype == FIO_TYPE_FILE)
865 return f->real_file_size;
866
867 if (o->start_offset_percent > 0) {
868 /*
869 * if offset_align is provided, set initial offset
870 */
871 if (fio_option_is_set(o, start_offset_align)) {
872 align_bs = o->start_offset_align;
873 } else {
874 /* else take the minimum block size */
875 align_bs = td_min_bs(td);
876 }
877
878 /* calculate the raw offset */
879 offset = (f->real_file_size * o->start_offset_percent / 100) +
880 (td->subjob_number * o->offset_increment);
881
882 /*
883 * block align the offset at the next available boundary at
884 * ceiling(offset / align_bs) * align_bs
885 */
886 offset = (offset / align_bs + (offset % align_bs != 0)) * align_bs;
887
888 } else {
889 /* start_offset_percent not set */
890 offset = o->start_offset +
891 td->subjob_number * o->offset_increment;
892 }
893
894 return offset;
895}
896
897/*
898 * Open the files and setup files sizes, creating files if necessary.
899 */
900int setup_files(struct thread_data *td)
901{
902 unsigned long long total_size, extend_size;
903 struct thread_options *o = &td->o;
904 struct fio_file *f;
905 unsigned int i, nr_fs_extra = 0;
906 int err = 0, need_extend;
907 int old_state;
908 const unsigned int bs = td_min_bs(td);
909 uint64_t fs = 0;
910
911 dprint(FD_FILE, "setup files\n");
912
913 old_state = td_bump_runstate(td, TD_SETTING_UP);
914
915 if (o->read_iolog_file)
916 goto done;
917
918 /*
919 * Find out physical size of files or devices for this thread,
920 * before we determine I/O size and range of our targets.
921 * If ioengine defines a setup() method, it's responsible for
922 * opening the files and setting f->real_file_size to indicate
923 * the valid range for that file.
924 */
925 if (td->io_ops->setup)
926 err = td->io_ops->setup(td);
927 else
928 err = get_file_sizes(td);
929
930 if (err)
931 goto err_out;
932
933 /*
934 * check sizes. if the files/devices do not exist and the size
935 * isn't passed to fio, abort.
936 */
937 total_size = 0;
938 for_each_file(td, f, i) {
939 f->fileno = i;
940 if (f->real_file_size == -1ULL)
941 total_size = -1ULL;
942 else
943 total_size += f->real_file_size;
944 }
945
946 if (o->fill_device)
947 td->fill_device_size = get_fs_free_counts(td);
948
949 /*
950 * device/file sizes are zero and no size given, punt
951 */
952 if ((!total_size || total_size == -1ULL) && !o->size &&
953 !td_ioengine_flagged(td, FIO_NOIO) && !o->fill_device &&
954 !(o->nr_files && (o->file_size_low || o->file_size_high))) {
955 log_err("%s: you need to specify size=\n", o->name);
956 td_verror(td, EINVAL, "total_file_size");
957 goto err_out;
958 }
959
960 /*
961 * Calculate per-file size and potential extra size for the
962 * first files, if needed (i.e. if we don't have a fixed size).
963 */
964 if (!o->file_size_low && o->nr_files) {
965 uint64_t all_fs;
966
967 fs = o->size / o->nr_files;
968 all_fs = fs * o->nr_files;
969
970 if (all_fs < o->size)
971 nr_fs_extra = (o->size - all_fs) / bs;
972 }
973
974 /*
975 * now file sizes are known, so we can set ->io_size. if size= is
976 * not given, ->io_size is just equal to ->real_file_size. if size
977 * is given, ->io_size is size / nr_files.
978 */
979 extend_size = total_size = 0;
980 need_extend = 0;
981 for_each_file(td, f, i) {
982 f->file_offset = get_start_offset(td, f);
983
984 /*
985 * Update ->io_size depending on options specified.
986 * ->file_size_low being 0 means filesize option isn't set.
987 * Non zero ->file_size_low equals ->file_size_high means
988 * filesize option is set in a fixed size format.
989 * Non zero ->file_size_low not equals ->file_size_high means
990 * filesize option is set in a range format.
991 */
992 if (!o->file_size_low) {
993 /*
994 * no file size or range given, file size is equal to
995 * total size divided by number of files. If the size
996 * doesn't divide nicely with the min blocksize,
997 * make the first files bigger.
998 */
999 f->io_size = fs;
1000 if (nr_fs_extra) {
1001 nr_fs_extra--;
1002 f->io_size += bs;
1003 }
1004
1005 /*
1006 * We normally don't come here for regular files, but
1007 * if the result is 0 for a regular file, set it to the
1008 * real file size. This could be size of the existing
1009 * one if it already exists, but otherwise will be set
1010 * to 0. A new file won't be created because
1011 * ->io_size + ->file_offset equals ->real_file_size.
1012 */
1013 if (!f->io_size) {
1014 if (f->file_offset > f->real_file_size)
1015 goto err_offset;
1016 f->io_size = f->real_file_size - f->file_offset;
1017 if (!f->io_size)
1018 log_info("fio: file %s may be ignored\n",
1019 f->file_name);
1020 }
1021 } else if (f->real_file_size < o->file_size_low ||
1022 f->real_file_size > o->file_size_high) {
1023 if (f->file_offset > o->file_size_low)
1024 goto err_offset;
1025 /*
1026 * file size given. if it's fixed, use that. if it's a
1027 * range, generate a random size in-between.
1028 */
1029 if (o->file_size_low == o->file_size_high)
1030 f->io_size = o->file_size_low - f->file_offset;
1031 else {
1032 f->io_size = get_rand_file_size(td)
1033 - f->file_offset;
1034 }
1035 } else
1036 f->io_size = f->real_file_size - f->file_offset;
1037
1038 if (f->io_size == -1ULL)
1039 total_size = -1ULL;
1040 else {
1041 if (o->size_percent) {
1042 uint64_t file_size;
1043
1044 file_size = f->io_size + f->file_offset;
1045 f->io_size = (file_size *
1046 o->size_percent) / 100;
1047 if (f->io_size > (file_size - f->file_offset))
1048 f->io_size = file_size - f->file_offset;
1049
1050 f->io_size -= (f->io_size % td_min_bs(td));
1051 }
1052 total_size += f->io_size;
1053 }
1054
1055 if (f->filetype == FIO_TYPE_FILE &&
1056 (f->io_size + f->file_offset) > f->real_file_size &&
1057 !td_ioengine_flagged(td, FIO_DISKLESSIO)) {
1058 if (!o->create_on_open) {
1059 need_extend++;
1060 extend_size += (f->io_size + f->file_offset);
1061 fio_file_set_extend(f);
1062 } else
1063 f->real_file_size = f->io_size + f->file_offset;
1064 }
1065 }
1066
1067 if (td->o.block_error_hist) {
1068 int len;
1069
1070 assert(td->o.nr_files == 1); /* checked in fixup_options */
1071 f = td->files[0];
1072 len = f->io_size / td->o.bs[DDIR_TRIM];
1073 if (len > MAX_NR_BLOCK_INFOS || len <= 0) {
1074 log_err("fio: cannot calculate block histogram with "
1075 "%d trim blocks, maximum %d\n",
1076 len, MAX_NR_BLOCK_INFOS);
1077 td_verror(td, EINVAL, "block_error_hist");
1078 goto err_out;
1079 }
1080
1081 td->ts.nr_block_infos = len;
1082 for (i = 0; i < len; i++)
1083 td->ts.block_infos[i] =
1084 BLOCK_INFO(0, BLOCK_STATE_UNINIT);
1085 } else
1086 td->ts.nr_block_infos = 0;
1087
1088 if (!o->size || (total_size && o->size > total_size))
1089 o->size = total_size;
1090
1091 if (o->size < td_min_bs(td)) {
1092 log_err("fio: blocksize too large for data set\n");
1093 goto err_out;
1094 }
1095
1096 /*
1097 * See if we need to extend some files, typically needed when our
1098 * target regular files don't exist yet, but our jobs require them
1099 * initially due to read I/Os.
1100 */
1101 if (need_extend) {
1102 temp_stall_ts = 1;
1103 if (output_format & FIO_OUTPUT_NORMAL) {
1104 log_info("%s: Laying out IO file%s (%u file%s / %s%lluMiB)\n",
1105 o->name,
1106 need_extend > 1 ? "s" : "",
1107 need_extend,
1108 need_extend > 1 ? "s" : "",
1109 need_extend > 1 ? "total " : "",
1110 extend_size >> 20);
1111 }
1112
1113 for_each_file(td, f, i) {
1114 unsigned long long old_len = -1ULL, extend_len = -1ULL;
1115
1116 if (!fio_file_extend(f))
1117 continue;
1118
1119 assert(f->filetype == FIO_TYPE_FILE);
1120 fio_file_clear_extend(f);
1121 if (!o->fill_device) {
1122 old_len = f->real_file_size;
1123 extend_len = f->io_size + f->file_offset -
1124 old_len;
1125 }
1126 f->real_file_size = (f->io_size + f->file_offset);
1127 err = extend_file(td, f);
1128 if (err)
1129 break;
1130
1131 err = __file_invalidate_cache(td, f, old_len,
1132 extend_len);
1133
1134 /*
1135 * Shut up static checker
1136 */
1137 if (f->fd != -1)
1138 close(f->fd);
1139
1140 f->fd = -1;
1141 if (err)
1142 break;
1143 }
1144 temp_stall_ts = 0;
1145 }
1146
1147 if (err)
1148 goto err_out;
1149
1150 if (!o->zone_size)
1151 o->zone_size = o->size;
1152
1153 /*
1154 * iolog already set the total io size, if we read back
1155 * stored entries.
1156 */
1157 if (!o->read_iolog_file) {
1158 if (o->io_size)
1159 td->total_io_size = o->io_size * o->loops;
1160 else
1161 td->total_io_size = o->size * o->loops;
1162 }
1163
1164done:
1165 if (o->create_only)
1166 td->done = 1;
1167
1168 td_restore_runstate(td, old_state);
1169 return 0;
1170err_offset:
1171 log_err("%s: you need to specify valid offset=\n", o->name);
1172err_out:
1173 td_restore_runstate(td, old_state);
1174 return 1;
1175}
1176
1177int pre_read_files(struct thread_data *td)
1178{
1179 struct fio_file *f;
1180 unsigned int i;
1181
1182 dprint(FD_FILE, "pre_read files\n");
1183
1184 for_each_file(td, f, i) {
1185 if (pre_read_file(td, f))
1186 return -1;
1187 }
1188
1189 return 0;
1190}
1191
1192static int __init_rand_distribution(struct thread_data *td, struct fio_file *f)
1193{
1194 unsigned int range_size, seed;
1195 unsigned long nranges;
1196 uint64_t fsize;
1197
1198 range_size = min(td->o.min_bs[DDIR_READ], td->o.min_bs[DDIR_WRITE]);
1199 fsize = min(f->real_file_size, f->io_size);
1200
1201 nranges = (fsize + range_size - 1) / range_size;
1202
1203 seed = jhash(f->file_name, strlen(f->file_name), 0) * td->thread_number;
1204 if (!td->o.rand_repeatable)
1205 seed = td->rand_seeds[4];
1206
1207 if (td->o.random_distribution == FIO_RAND_DIST_ZIPF)
1208 zipf_init(&f->zipf, nranges, td->o.zipf_theta.u.f, seed);
1209 else if (td->o.random_distribution == FIO_RAND_DIST_PARETO)
1210 pareto_init(&f->zipf, nranges, td->o.pareto_h.u.f, seed);
1211 else if (td->o.random_distribution == FIO_RAND_DIST_GAUSS)
1212 gauss_init(&f->gauss, nranges, td->o.gauss_dev.u.f, seed);
1213
1214 return 1;
1215}
1216
1217static int init_rand_distribution(struct thread_data *td)
1218{
1219 struct fio_file *f;
1220 unsigned int i;
1221 int state;
1222
1223 if (td->o.random_distribution == FIO_RAND_DIST_RANDOM)
1224 return 0;
1225
1226 state = td_bump_runstate(td, TD_SETTING_UP);
1227
1228 for_each_file(td, f, i)
1229 __init_rand_distribution(td, f);
1230
1231 td_restore_runstate(td, state);
1232
1233 return 1;
1234}
1235
1236/*
1237 * Check if the number of blocks exceeds the randomness capability of
1238 * the selected generator. Tausworthe is 32-bit, the others are fullly
1239 * 64-bit capable.
1240 */
1241static int check_rand_gen_limits(struct thread_data *td, struct fio_file *f,
1242 uint64_t blocks)
1243{
1244 if (blocks <= FRAND32_MAX)
1245 return 0;
1246 if (td->o.random_generator != FIO_RAND_GEN_TAUSWORTHE)
1247 return 0;
1248
1249 /*
1250 * If the user hasn't specified a random generator, switch
1251 * to tausworthe64 with informational warning. If the user did
1252 * specify one, just warn.
1253 */
1254 log_info("fio: file %s exceeds 32-bit tausworthe random generator.\n",
1255 f->file_name);
1256
1257 if (!fio_option_is_set(&td->o, random_generator)) {
1258 log_info("fio: Switching to tausworthe64. Use the "
1259 "random_generator= option to get rid of this "
1260 "warning.\n");
1261 td->o.random_generator = FIO_RAND_GEN_TAUSWORTHE64;
1262 return 0;
1263 }
1264
1265 /*
1266 * Just make this information to avoid breaking scripts.
1267 */
1268 log_info("fio: Use the random_generator= option to switch to lfsr or "
1269 "tausworthe64.\n");
1270 return 0;
1271}
1272
1273int init_random_map(struct thread_data *td)
1274{
1275 unsigned long long blocks;
1276 struct fio_file *f;
1277 unsigned int i;
1278
1279 if (init_rand_distribution(td))
1280 return 0;
1281 if (!td_random(td))
1282 return 0;
1283
1284 for_each_file(td, f, i) {
1285 uint64_t fsize = min(f->real_file_size, f->io_size);
1286
1287 blocks = fsize / (unsigned long long) td->o.rw_min_bs;
1288
1289 if (check_rand_gen_limits(td, f, blocks))
1290 return 1;
1291
1292 if (td->o.random_generator == FIO_RAND_GEN_LFSR) {
1293 unsigned long seed;
1294
1295 seed = td->rand_seeds[FIO_RAND_BLOCK_OFF];
1296
1297 if (!lfsr_init(&f->lfsr, blocks, seed, 0)) {
1298 fio_file_set_lfsr(f);
1299 continue;
1300 }
1301 } else if (!td->o.norandommap) {
1302 f->io_axmap = axmap_new(blocks);
1303 if (f->io_axmap) {
1304 fio_file_set_axmap(f);
1305 continue;
1306 }
1307 } else if (td->o.norandommap)
1308 continue;
1309
1310 if (!td->o.softrandommap) {
1311 log_err("fio: failed allocating random map. If running"
1312 " a large number of jobs, try the 'norandommap'"
1313 " option or set 'softrandommap'. Or give"
1314 " a larger --alloc-size to fio.\n");
1315 return 1;
1316 }
1317
1318 log_info("fio: file %s failed allocating random map. Running "
1319 "job without.\n", f->file_name);
1320 }
1321
1322 return 0;
1323}
1324
1325void close_files(struct thread_data *td)
1326{
1327 struct fio_file *f;
1328 unsigned int i;
1329
1330 for_each_file(td, f, i) {
1331 if (fio_file_open(f))
1332 td_io_close_file(td, f);
1333 }
1334}
1335
1336void close_and_free_files(struct thread_data *td)
1337{
1338 struct fio_file *f;
1339 unsigned int i;
1340 bool use_free = td_ioengine_flagged(td, FIO_NOFILEHASH);
1341
1342 dprint(FD_FILE, "close files\n");
1343
1344 for_each_file(td, f, i) {
1345 if (td->o.unlink && f->filetype == FIO_TYPE_FILE) {
1346 dprint(FD_FILE, "free unlink %s\n", f->file_name);
1347 td_io_unlink_file(td, f);
1348 }
1349
1350 if (fio_file_open(f))
1351 td_io_close_file(td, f);
1352
1353 remove_file_hash(f);
1354
1355 if (td->o.unlink && f->filetype == FIO_TYPE_FILE) {
1356 dprint(FD_FILE, "free unlink %s\n", f->file_name);
1357 td_io_unlink_file(td, f);
1358 }
1359
1360 if (use_free)
1361 free(f->file_name);
1362 else
1363 sfree(f->file_name);
1364 f->file_name = NULL;
1365 if (fio_file_axmap(f)) {
1366 axmap_free(f->io_axmap);
1367 f->io_axmap = NULL;
1368 }
1369 if (use_free)
1370 free(f);
1371 else
1372 sfree(f);
1373 }
1374
1375 td->o.filename = NULL;
1376 free(td->files);
1377 free(td->file_locks);
1378 td->files_index = 0;
1379 td->files = NULL;
1380 td->file_locks = NULL;
1381 td->o.file_lock_mode = FILE_LOCK_NONE;
1382 td->o.nr_files = 0;
1383}
1384
1385static void get_file_type(struct fio_file *f)
1386{
1387 struct stat sb;
1388
1389 if (!strcmp(f->file_name, "-"))
1390 f->filetype = FIO_TYPE_PIPE;
1391 else
1392 f->filetype = FIO_TYPE_FILE;
1393
1394#ifdef WIN32
1395 /* \\.\ is the device namespace in Windows, where every file is
1396 * a block device */
1397 if (strncmp(f->file_name, "\\\\.\\", 4) == 0)
1398 f->filetype = FIO_TYPE_BLOCK;
1399#endif
1400
1401 if (!stat(f->file_name, &sb)) {
1402 if (S_ISBLK(sb.st_mode))
1403 f->filetype = FIO_TYPE_BLOCK;
1404 else if (S_ISCHR(sb.st_mode))
1405 f->filetype = FIO_TYPE_CHAR;
1406 else if (S_ISFIFO(sb.st_mode))
1407 f->filetype = FIO_TYPE_PIPE;
1408 }
1409}
1410
1411static bool __is_already_allocated(const char *fname, bool set)
1412{
1413 struct flist_head *entry;
1414 bool ret;
1415
1416 ret = file_bloom_exists(fname, set);
1417 if (!ret)
1418 return ret;
1419
1420 flist_for_each(entry, &filename_list) {
1421 struct file_name *fn;
1422
1423 fn = flist_entry(entry, struct file_name, list);
1424
1425 if (!strcmp(fn->filename, fname))
1426 return true;
1427 }
1428
1429 return false;
1430}
1431
1432static bool is_already_allocated(const char *fname)
1433{
1434 bool ret;
1435
1436 fio_file_hash_lock();
1437 ret = __is_already_allocated(fname, false);
1438 fio_file_hash_unlock();
1439
1440 return ret;
1441}
1442
1443static void set_already_allocated(const char *fname)
1444{
1445 struct file_name *fn;
1446
1447 fn = malloc(sizeof(struct file_name));
1448 fn->filename = strdup(fname);
1449
1450 fio_file_hash_lock();
1451 if (!__is_already_allocated(fname, true)) {
1452 flist_add_tail(&fn->list, &filename_list);
1453 fn = NULL;
1454 }
1455 fio_file_hash_unlock();
1456
1457 if (fn) {
1458 free(fn->filename);
1459 free(fn);
1460 }
1461}
1462
1463static void free_already_allocated(void)
1464{
1465 struct flist_head *entry, *tmp;
1466 struct file_name *fn;
1467
1468 if (flist_empty(&filename_list))
1469 return;
1470
1471 fio_file_hash_lock();
1472 flist_for_each_safe(entry, tmp, &filename_list) {
1473 fn = flist_entry(entry, struct file_name, list);
1474 free(fn->filename);
1475 flist_del(&fn->list);
1476 free(fn);
1477 }
1478
1479 fio_file_hash_unlock();
1480}
1481
1482static struct fio_file *alloc_new_file(struct thread_data *td)
1483{
1484 struct fio_file *f;
1485
1486 if (td_ioengine_flagged(td, FIO_NOFILEHASH))
1487 f = calloc(1, sizeof(*f));
1488 else
1489 f = smalloc(sizeof(*f));
1490 if (!f) {
1491 assert(0);
1492 return NULL;
1493 }
1494
1495 f->fd = -1;
1496 f->shadow_fd = -1;
1497 fio_file_reset(td, f);
1498 return f;
1499}
1500
1501bool exists_and_not_regfile(const char *filename)
1502{
1503 struct stat sb;
1504
1505 if (lstat(filename, &sb) == -1)
1506 return false;
1507
1508#ifndef WIN32 /* NOT Windows */
1509 if (S_ISREG(sb.st_mode))
1510 return false;
1511#else
1512 /* \\.\ is the device namespace in Windows, where every file
1513 * is a device node */
1514 if (S_ISREG(sb.st_mode) && strncmp(filename, "\\\\.\\", 4) != 0)
1515 return false;
1516#endif
1517
1518 return true;
1519}
1520
1521static int create_work_dirs(struct thread_data *td, const char *fname)
1522{
1523 char path[PATH_MAX];
1524 char *start, *end;
1525
1526 if (td->o.directory) {
1527 snprintf(path, PATH_MAX, "%s%c%s", td->o.directory,
1528 FIO_OS_PATH_SEPARATOR, fname);
1529 start = strstr(path, fname);
1530 } else {
1531 snprintf(path, PATH_MAX, "%s", fname);
1532 start = path;
1533 }
1534
1535 end = start;
1536 while ((end = strchr(end, FIO_OS_PATH_SEPARATOR)) != NULL) {
1537 if (end == start)
1538 break;
1539 *end = '\0';
1540 errno = 0;
1541#ifdef CONFIG_HAVE_MKDIR_TWO
1542 if (mkdir(path, 0600) && errno != EEXIST) {
1543#else
1544 if (mkdir(path) && errno != EEXIST) {
1545#endif
1546 log_err("fio: failed to create dir (%s): %d\n",
1547 start, errno);
1548 return 1;
1549 }
1550 *end = FIO_OS_PATH_SEPARATOR;
1551 end++;
1552 }
1553 td->flags |= TD_F_DIRS_CREATED;
1554 return 0;
1555}
1556
1557int add_file(struct thread_data *td, const char *fname, int numjob, int inc)
1558{
1559 int cur_files = td->files_index;
1560 char file_name[PATH_MAX];
1561 struct fio_file *f;
1562 int len = 0;
1563
1564 dprint(FD_FILE, "add file %s\n", fname);
1565
1566 if (td->o.directory)
1567 len = set_name_idx(file_name, PATH_MAX, td->o.directory, numjob,
1568 td->o.unique_filename);
1569
1570 sprintf(file_name + len, "%s", fname);
1571
1572 if (strchr(fname, FIO_OS_PATH_SEPARATOR) &&
1573 !(td->flags & TD_F_DIRS_CREATED) &&
1574 create_work_dirs(td, fname))
1575 return 1;
1576
1577 /* clean cloned siblings using existing files */
1578 if (numjob && is_already_allocated(file_name) &&
1579 !exists_and_not_regfile(fname))
1580 return 0;
1581
1582 f = alloc_new_file(td);
1583
1584 if (td->files_size <= td->files_index) {
1585 unsigned int new_size = td->o.nr_files + 1;
1586
1587 dprint(FD_FILE, "resize file array to %d files\n", new_size);
1588
1589 td->files = realloc(td->files, new_size * sizeof(f));
1590 if (td->files == NULL) {
1591 log_err("fio: realloc OOM\n");
1592 assert(0);
1593 }
1594 if (td->o.file_lock_mode != FILE_LOCK_NONE) {
1595 td->file_locks = realloc(td->file_locks, new_size);
1596 if (!td->file_locks) {
1597 log_err("fio: realloc OOM\n");
1598 assert(0);
1599 }
1600 td->file_locks[cur_files] = FILE_LOCK_NONE;
1601 }
1602 td->files_size = new_size;
1603 }
1604 td->files[cur_files] = f;
1605 f->fileno = cur_files;
1606
1607 /*
1608 * init function, io engine may not be loaded yet
1609 */
1610 if (td->io_ops && td_ioengine_flagged(td, FIO_DISKLESSIO))
1611 f->real_file_size = -1ULL;
1612
1613 if (td_ioengine_flagged(td, FIO_NOFILEHASH))
1614 f->file_name = strdup(file_name);
1615 else
1616 f->file_name = smalloc_strdup(file_name);
1617 if (!f->file_name)
1618 assert(0);
1619
1620 get_file_type(f);
1621
1622 switch (td->o.file_lock_mode) {
1623 case FILE_LOCK_NONE:
1624 break;
1625 case FILE_LOCK_READWRITE:
1626 f->rwlock = fio_rwlock_init();
1627 break;
1628 case FILE_LOCK_EXCLUSIVE:
1629 f->lock = fio_mutex_init(FIO_MUTEX_UNLOCKED);
1630 break;
1631 default:
1632 log_err("fio: unknown lock mode: %d\n", td->o.file_lock_mode);
1633 assert(0);
1634 }
1635
1636 td->files_index++;
1637 if (f->filetype == FIO_TYPE_FILE)
1638 td->nr_normal_files++;
1639
1640 if (td->o.numjobs > 1)
1641 set_already_allocated(file_name);
1642
1643 if (inc)
1644 td->o.nr_files++;
1645
1646 dprint(FD_FILE, "file %p \"%s\" added at %d\n", f, f->file_name,
1647 cur_files);
1648
1649 return cur_files;
1650}
1651
1652int add_file_exclusive(struct thread_data *td, const char *fname)
1653{
1654 struct fio_file *f;
1655 unsigned int i;
1656
1657 for_each_file(td, f, i) {
1658 if (!strcmp(f->file_name, fname))
1659 return i;
1660 }
1661
1662 return add_file(td, fname, 0, 1);
1663}
1664
1665void get_file(struct fio_file *f)
1666{
1667 dprint(FD_FILE, "get file %s, ref=%d\n", f->file_name, f->references);
1668 assert(fio_file_open(f));
1669 f->references++;
1670}
1671
1672int put_file(struct thread_data *td, struct fio_file *f)
1673{
1674 int f_ret = 0, ret = 0;
1675
1676 dprint(FD_FILE, "put file %s, ref=%d\n", f->file_name, f->references);
1677
1678 if (!fio_file_open(f)) {
1679 assert(f->fd == -1);
1680 return 0;
1681 }
1682
1683 assert(f->references);
1684 if (--f->references)
1685 return 0;
1686
1687 if (should_fsync(td) && td->o.fsync_on_close) {
1688 f_ret = fsync(f->fd);
1689 if (f_ret < 0)
1690 f_ret = errno;
1691 }
1692
1693 if (td->io_ops->close_file)
1694 ret = td->io_ops->close_file(td, f);
1695
1696 if (!ret)
1697 ret = f_ret;
1698
1699 td->nr_open_files--;
1700 fio_file_clear_open(f);
1701 assert(f->fd == -1);
1702 return ret;
1703}
1704
1705void lock_file(struct thread_data *td, struct fio_file *f, enum fio_ddir ddir)
1706{
1707 if (!f->lock || td->o.file_lock_mode == FILE_LOCK_NONE)
1708 return;
1709
1710 if (td->o.file_lock_mode == FILE_LOCK_READWRITE) {
1711 if (ddir == DDIR_READ)
1712 fio_rwlock_read(f->rwlock);
1713 else
1714 fio_rwlock_write(f->rwlock);
1715 } else if (td->o.file_lock_mode == FILE_LOCK_EXCLUSIVE)
1716 fio_mutex_down(f->lock);
1717
1718 td->file_locks[f->fileno] = td->o.file_lock_mode;
1719}
1720
1721void unlock_file(struct thread_data *td, struct fio_file *f)
1722{
1723 if (!f->lock || td->o.file_lock_mode == FILE_LOCK_NONE)
1724 return;
1725
1726 if (td->o.file_lock_mode == FILE_LOCK_READWRITE)
1727 fio_rwlock_unlock(f->rwlock);
1728 else if (td->o.file_lock_mode == FILE_LOCK_EXCLUSIVE)
1729 fio_mutex_up(f->lock);
1730
1731 td->file_locks[f->fileno] = FILE_LOCK_NONE;
1732}
1733
1734void unlock_file_all(struct thread_data *td, struct fio_file *f)
1735{
1736 if (td->o.file_lock_mode == FILE_LOCK_NONE || !td->file_locks)
1737 return;
1738 if (td->file_locks[f->fileno] != FILE_LOCK_NONE)
1739 unlock_file(td, f);
1740}
1741
1742static int recurse_dir(struct thread_data *td, const char *dirname)
1743{
1744 struct dirent *dir;
1745 int ret = 0;
1746 DIR *D;
1747
1748 D = opendir(dirname);
1749 if (!D) {
1750 char buf[FIO_VERROR_SIZE];
1751
1752 snprintf(buf, FIO_VERROR_SIZE, "opendir(%s)", dirname);
1753 td_verror(td, errno, buf);
1754 return 1;
1755 }
1756
1757 while ((dir = readdir(D)) != NULL) {
1758 char full_path[PATH_MAX];
1759 struct stat sb;
1760
1761 if (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, ".."))
1762 continue;
1763
1764 sprintf(full_path, "%s%c%s", dirname, FIO_OS_PATH_SEPARATOR, dir->d_name);
1765
1766 if (lstat(full_path, &sb) == -1) {
1767 if (errno != ENOENT) {
1768 td_verror(td, errno, "stat");
1769 ret = 1;
1770 break;
1771 }
1772 }
1773
1774 if (S_ISREG(sb.st_mode)) {
1775 add_file(td, full_path, 0, 1);
1776 continue;
1777 }
1778 if (!S_ISDIR(sb.st_mode))
1779 continue;
1780
1781 ret = recurse_dir(td, full_path);
1782 if (ret)
1783 break;
1784 }
1785
1786 closedir(D);
1787 return ret;
1788}
1789
1790int add_dir_files(struct thread_data *td, const char *path)
1791{
1792 int ret = recurse_dir(td, path);
1793
1794 if (!ret)
1795 log_info("fio: opendir added %d files\n", td->o.nr_files);
1796
1797 return ret;
1798}
1799
1800void dup_files(struct thread_data *td, struct thread_data *org)
1801{
1802 struct fio_file *f;
1803 unsigned int i;
1804
1805 dprint(FD_FILE, "dup files: %d\n", org->files_index);
1806
1807 if (!org->files)
1808 return;
1809
1810 td->files = malloc(org->files_index * sizeof(f));
1811
1812 if (td->o.file_lock_mode != FILE_LOCK_NONE)
1813 td->file_locks = malloc(org->files_index);
1814
1815 for_each_file(org, f, i) {
1816 struct fio_file *__f;
1817
1818 __f = alloc_new_file(td);
1819
1820 if (f->file_name) {
1821 if (td_ioengine_flagged(td, FIO_NOFILEHASH))
1822 __f->file_name = strdup(f->file_name);
1823 else
1824 __f->file_name = smalloc_strdup(f->file_name);
1825 if (!__f->file_name)
1826 assert(0);
1827
1828 __f->filetype = f->filetype;
1829 }
1830
1831 if (td->o.file_lock_mode == FILE_LOCK_EXCLUSIVE)
1832 __f->lock = f->lock;
1833 else if (td->o.file_lock_mode == FILE_LOCK_READWRITE)
1834 __f->rwlock = f->rwlock;
1835
1836 td->files[i] = __f;
1837 }
1838}
1839
1840/*
1841 * Returns the index that matches the filename, or -1 if not there
1842 */
1843int get_fileno(struct thread_data *td, const char *fname)
1844{
1845 struct fio_file *f;
1846 unsigned int i;
1847
1848 for_each_file(td, f, i)
1849 if (!strcmp(f->file_name, fname))
1850 return i;
1851
1852 return -1;
1853}
1854
1855/*
1856 * For log usage, where we add/open/close files automatically
1857 */
1858void free_release_files(struct thread_data *td)
1859{
1860 close_files(td);
1861 td->o.nr_files = 0;
1862 td->o.open_files = 0;
1863 td->files_index = 0;
1864 td->nr_normal_files = 0;
1865}
1866
1867void fio_file_reset(struct thread_data *td, struct fio_file *f)
1868{
1869 int i;
1870
1871 for (i = 0; i < DDIR_RWDIR_CNT; i++) {
1872 f->last_pos[i] = f->file_offset;
1873 f->last_start[i] = -1ULL;
1874 }
1875
1876 if (fio_file_axmap(f))
1877 axmap_reset(f->io_axmap);
1878 else if (fio_file_lfsr(f))
1879 lfsr_reset(&f->lfsr, td->rand_seeds[FIO_RAND_BLOCK_OFF]);
1880}
1881
1882bool fio_files_done(struct thread_data *td)
1883{
1884 struct fio_file *f;
1885 unsigned int i;
1886
1887 for_each_file(td, f, i)
1888 if (!fio_file_done(f))
1889 return false;
1890
1891 return true;
1892}
1893
1894/* free memory used in initialization phase only */
1895void filesetup_mem_free(void)
1896{
1897 free_already_allocated();
1898}
1899
1900/*
1901 * This function is for platforms which support direct I/O but not O_DIRECT.
1902 */
1903int fio_set_directio(struct thread_data *td, struct fio_file *f)
1904{
1905#ifdef FIO_OS_DIRECTIO
1906 int ret = fio_set_odirect(f);
1907
1908 if (ret) {
1909 td_verror(td, ret, "fio_set_directio");
1910#if defined(__sun__)
1911 if (ret == ENOTTY) { /* ENOTTY suggests RAW device or ZFS */
1912 log_err("fio: doing directIO to RAW devices or ZFS not supported\n");
1913 } else {
1914 log_err("fio: the file system does not seem to support direct IO\n");
1915 }
1916#else
1917 log_err("fio: the file system does not seem to support direct IO\n");
1918#endif
1919 return -1;
1920 }
1921
1922 return 0;
1923#else
1924 log_err("fio: direct IO is not supported on this host operating system\n");
1925 return -1;
1926#endif
1927}
fio - Flexible IO Tester