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