Fix io piece logging to not have O(n) runtime
[fio.git] / filesetup.c
CommitLineData
53cdc686
JA
1#include <unistd.h>
2#include <fcntl.h>
3#include <string.h>
4#include <assert.h>
bbf6b540 5#include <dirent.h>
53cdc686
JA
6#include <sys/stat.h>
7#include <sys/mman.h>
bbf6b540 8#include <sys/types.h>
53cdc686
JA
9
10#include "fio.h"
11#include "os.h"
12
25205e97
JA
13/*
14 * Check if the file exists and it's large enough.
15 */
16static int file_ok(struct thread_data *td, struct fio_file *f)
53cdc686 17{
b2a15192 18 struct stat st;
53cdc686 19
af52b345 20 if (f->filetype != FIO_TYPE_FILE ||
b5af8293 21 (td->io_ops->flags & FIO_DISKLESSIO))
b2a15192
JA
22 return 0;
23
fa01d139 24 if (lstat(f->file_name, &st) == -1)
25205e97 25 return 1;
fa01d139
JA
26
27 /*
28 * if it's a special file, size is always ok for now
29 */
30 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))
31 return 0;
32 if (st.st_size < (off_t) f->file_size)
25205e97
JA
33 return 1;
34
35 return 0;
36}
37
38static int create_file(struct thread_data *td, struct fio_file *f)
39{
40 unsigned long long left;
41 unsigned int bs;
42 char *b;
43 int r;
b2a15192 44
53cdc686
JA
45 f->fd = open(f->file_name, O_WRONLY | O_CREAT | O_TRUNC, 0644);
46 if (f->fd < 0) {
e1161c32 47 td_verror(td, errno, "open");
53cdc686
JA
48 return 1;
49 }
50
51 if (ftruncate(f->fd, f->file_size) == -1) {
e1161c32 52 td_verror(td, errno, "ftruncate");
53cdc686
JA
53 goto err;
54 }
55
40f8298c 56 if (posix_fallocate(f->fd, 0, f->file_size) < 0) {
e1161c32 57 td_verror(td, errno, "posix_fallocate");
40f8298c
JA
58 goto err;
59 }
60
2dc1bbeb
JA
61 b = malloc(td->o.max_bs[DDIR_WRITE]);
62 memset(b, 0, td->o.max_bs[DDIR_WRITE]);
53cdc686
JA
63
64 left = f->file_size;
65 while (left && !td->terminate) {
2dc1bbeb 66 bs = td->o.max_bs[DDIR_WRITE];
53cdc686
JA
67 if (bs > left)
68 bs = left;
69
70 r = write(f->fd, b, bs);
71
72 if (r == (int) bs) {
73 left -= bs;
74 continue;
75 } else {
76 if (r < 0)
e1161c32 77 td_verror(td, errno, "write");
53cdc686 78 else
e1161c32 79 td_verror(td, EIO, "write");
53cdc686
JA
80
81 break;
82 }
83 }
84
85 if (td->terminate)
86 unlink(f->file_name);
2dc1bbeb 87 else if (td->o.create_fsync)
53cdc686
JA
88 fsync(f->fd);
89
90 free(b);
91 close(f->fd);
92 f->fd = -1;
93 return 0;
94err:
95 close(f->fd);
96 f->fd = -1;
97 return 1;
98}
99
9c60ce64
JA
100static unsigned long long set_rand_file_size(struct thread_data *td,
101 unsigned long long total_size)
102{
103 unsigned long long upper = total_size;
104 unsigned long long ret;
105 long r;
106
2dc1bbeb
JA
107 if (upper > td->o.file_size_high)
108 upper = td->o.file_size_high;
109 else if (upper < td->o.file_size_low)
9c60ce64
JA
110 return 0;
111 else if (!upper)
112 return 0;
113
114 r = os_random_long(&td->file_size_state);
2dc1bbeb
JA
115 ret = td->o.file_size_low + (unsigned long long) ((double) upper * (r / (RAND_MAX + 1.0)));
116 ret -= (ret % td->o.rw_min_bs);
9c60ce64
JA
117 if (ret > upper)
118 ret = upper;
119 return ret;
120}
121
68727076
JA
122static int fill_file_size(struct thread_data *td, struct fio_file *f,
123 unsigned long long *file_size, int new_files)
124{
125 if (!td->o.file_size_low) {
126 f->file_size = *file_size / new_files;
127 f->real_file_size = f->file_size;
128 } else {
129 /*
130 * If we don't have enough space left for a file
131 * of the minimum size, bail.
132 */
133 if (*file_size < td->o.file_size_low)
134 return 1;
135
136 f->file_size = set_rand_file_size(td, *file_size);
137 f->real_file_size = f->file_size;
138 *file_size -= f->file_size;
139 }
140
141 return 0;
142}
143
53cdc686
JA
144static int create_files(struct thread_data *td)
145{
146 struct fio_file *f;
af52b345 147 int err, need_create, can_extend;
e8be395b 148 unsigned long long total_file_size, local_file_size, create_size;
e407bec2 149 unsigned int i, new_files;
53cdc686 150
e407bec2 151 new_files = 0;
2dc1bbeb 152 total_file_size = td->o.size;
1549441c 153 for_each_file(td, f, i) {
96d32d51
JA
154 unsigned long long s;
155
2dc1bbeb 156 f->file_offset = td->o.start_offset;
96d32d51 157
1549441c
JA
158 if (f->filetype != FIO_TYPE_FILE)
159 continue;
ee3dcd95
JA
160 if (!total_file_size)
161 continue;
1549441c 162
96d32d51 163 if (f->flags & FIO_FILE_EXISTS) {
ee3dcd95
JA
164 if ((f->file_size > td->o.size / td->o.nr_files) ||
165 !f->file_size)
166 f->file_size = td->o.size / td->o.nr_files;
167
96d32d51
JA
168 s = f->file_size;
169 if (s > total_file_size)
170 s = total_file_size;
171
172 total_file_size -= s;
e407bec2
JA
173 } else
174 new_files++;
1549441c 175 }
f697125a 176
53cdc686
JA
177 /*
178 * unless specifically asked for overwrite, let normal io extend it
179 */
2dc1bbeb 180 can_extend = !td->o.overwrite && !(td->io_ops->flags & FIO_NOEXTEND);
3f344202 181 if (can_extend && new_files) {
68727076
JA
182 for_each_file(td, f, i) {
183 if (fill_file_size(td, f, &total_file_size, new_files)) {
184 log_info("fio: limited to %d files\n", i);
185 td->o.nr_files = i;
186 break;
187 }
188 }
189
53cdc686 190 return 0;
68727076 191 }
53cdc686 192
9c60ce64
JA
193 local_file_size = total_file_size;
194 if (!local_file_size)
195 local_file_size = -1;
196
f4c4f4d7
JA
197 total_file_size = 0;
198 need_create = 0;
e8be395b 199 create_size = 0;
af52b345
JA
200 for_each_file(td, f, i) {
201 int file_there;
202
203 if (f->filetype != FIO_TYPE_FILE)
204 continue;
f4c4f4d7
JA
205 if (f->flags & FIO_FILE_EXISTS) {
206 total_file_size += f->file_size;
96d32d51 207 continue;
f4c4f4d7 208 }
96d32d51 209
68727076
JA
210 if (fill_file_size(td, f, &local_file_size, new_files)) {
211 log_info("fio: limited to %d files\n", i);
212 new_files -= (td->o.nr_files - i);
213 td->o.nr_files = i;
214 break;
9c60ce64 215 }
eff6861d 216
f4c4f4d7 217 total_file_size += f->file_size;
e8be395b 218 create_size += f->file_size;
af52b345 219 file_there = !file_ok(td, f);
eff6861d 220
2dc1bbeb 221 if (file_there && td_write(td) && !td->o.overwrite) {
af52b345
JA
222 unlink(f->file_name);
223 file_there = 0;
eff6861d 224 }
af52b345
JA
225
226 need_create += !file_there;
eff6861d 227 }
25205e97 228
25205e97
JA
229 if (!need_create)
230 return 0;
231
2dc1bbeb 232 if (!td->o.size && !total_file_size) {
f1027063 233 log_err("Need size for create\n");
e1161c32 234 td_verror(td, EINVAL, "file_size");
f1027063
JA
235 return 1;
236 }
237
53cdc686 238 temp_stall_ts = 1;
6d86144d 239 log_info("%s: Laying out IO file(s) (%u files / %LuMiB)\n",
2dc1bbeb 240 td->o.name, new_files, create_size >> 20);
53cdc686
JA
241
242 err = 0;
243 for_each_file(td, f, i) {
9b031dc8
JA
244 /*
245 * Only unlink files that we created.
246 */
f11bd94d 247 f->flags &= ~FIO_FILE_UNLINK;
25205e97 248 if (file_ok(td, f)) {
2dc1bbeb 249 if (td->o.unlink)
f11bd94d
JA
250 f->flags |= FIO_FILE_UNLINK;
251
25205e97
JA
252 err = create_file(td, f);
253 if (err)
254 break;
255 }
53cdc686
JA
256 }
257
258 temp_stall_ts = 0;
259 return err;
260}
261
262static int file_size(struct thread_data *td, struct fio_file *f)
263{
264 struct stat st;
265
2dc1bbeb 266 if (td->o.overwrite) {
53cdc686 267 if (fstat(f->fd, &st) == -1) {
e1161c32 268 td_verror(td, errno, "fstat");
53cdc686
JA
269 return 1;
270 }
271
272 f->real_file_size = st.st_size;
273
274 if (!f->file_size || f->file_size > f->real_file_size)
275 f->file_size = f->real_file_size;
745508dd
JA
276 } else
277 f->real_file_size = f->file_size;
53cdc686 278
53cdc686
JA
279 return 0;
280}
281
282static int bdev_size(struct thread_data *td, struct fio_file *f)
283{
284 unsigned long long bytes;
285 int r;
286
287 r = blockdev_size(f->fd, &bytes);
288 if (r) {
e1161c32 289 td_verror(td, r, "blockdev_size");
53cdc686
JA
290 return 1;
291 }
292
293 f->real_file_size = bytes;
294
295 /*
296 * no extend possibilities, so limit size to device size if too large
297 */
298 if (!f->file_size || f->file_size > f->real_file_size)
299 f->file_size = f->real_file_size;
300
301 f->file_size -= f->file_offset;
302 return 0;
303}
304
305static int get_file_size(struct thread_data *td, struct fio_file *f)
306{
307 int ret = 0;
308
96d32d51
JA
309 if (f->filetype == FIO_TYPE_FILE) {
310 if (!(f->flags & FIO_FILE_EXISTS))
311 ret = file_size(td, f);
312 } else if (f->filetype == FIO_TYPE_BD)
53cdc686
JA
313 ret = bdev_size(td, f);
314 else
315 f->real_file_size = -1;
316
317 if (ret)
318 return ret;
319
320 if (f->file_offset > f->real_file_size) {
2dc1bbeb 321 log_err("%s: offset extends end (%Lu > %Lu)\n", td->o.name, f->file_offset, f->real_file_size);
53cdc686
JA
322 return 1;
323 }
324
53cdc686
JA
325 return 0;
326}
327
e5b401d4
JA
328int file_invalidate_cache(struct thread_data *td, struct fio_file *f)
329{
330 int ret = 0;
331
2dc1bbeb 332 if (td->o.odirect)
b5af8293
JA
333 return 0;
334
e5b401d4
JA
335 /*
336 * FIXME: add blockdev flushing too
337 */
b5af8293 338 if (f->mmap)
e5b401d4 339 ret = madvise(f->mmap, f->file_size, MADV_DONTNEED);
467d1b6b 340 else if (f->filetype == FIO_TYPE_FILE)
b5af8293 341 ret = fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_DONTNEED);
467d1b6b 342 else if (f->filetype == FIO_TYPE_BD)
b5af8293 343 ret = blockdev_invalidate_cache(f->fd);
467d1b6b 344 else if (f->filetype == FIO_TYPE_CHAR)
e5b401d4
JA
345 ret = 0;
346
347 if (ret < 0) {
e1161c32 348 td_verror(td, errno, "invalidate_cache");
e5b401d4
JA
349 return 1;
350 }
351
ad2da605 352 return ret;
e5b401d4
JA
353}
354
b5af8293 355void generic_close_file(struct thread_data fio_unused *td, struct fio_file *f)
53cdc686 356{
b5af8293
JA
357 close(f->fd);
358 f->fd = -1;
53cdc686
JA
359}
360
b5af8293 361int generic_open_file(struct thread_data *td, struct fio_file *f)
53cdc686 362{
53cdc686
JA
363 int flags = 0;
364
2dc1bbeb 365 if (td->o.odirect)
2fd233b7 366 flags |= OS_O_DIRECT;
2dc1bbeb 367 if (td->o.sync_io)
2fd233b7 368 flags |= O_SYNC;
53cdc686 369
2fd233b7
JA
370 if (td_write(td) || td_rw(td)) {
371 flags |= O_RDWR;
53cdc686 372
af52b345 373 if (f->filetype == FIO_TYPE_FILE)
2fd233b7 374 flags |= O_CREAT;
2fd233b7 375
b5af8293 376 f->fd = open(f->file_name, flags, 0600);
2fd233b7 377 } else {
af52b345 378 if (f->filetype == FIO_TYPE_CHAR)
2fd233b7
JA
379 flags |= O_RDWR;
380 else
381 flags |= O_RDONLY;
382
b5af8293 383 f->fd = open(f->file_name, flags);
53cdc686
JA
384 }
385
386 if (f->fd == -1) {
e4e33258 387 char buf[FIO_VERROR_SIZE];
e1161c32
JA
388 int __e = errno;
389
e4e33258
JA
390 snprintf(buf, sizeof(buf) - 1, "open(%s)", f->file_name);
391
392 td_verror(td, __e, buf);
2dc1bbeb 393 if (__e == EINVAL && td->o.odirect)
9d80e114 394 log_err("fio: destination does not support O_DIRECT\n");
8ab53873 395 if (__e == EMFILE)
2dc1bbeb 396 log_err("fio: try reducing/setting openfiles (failed at %u of %u)\n", td->nr_open_files, td->o.nr_files);
53cdc686
JA
397 return 1;
398 }
399
b5af8293
JA
400 if (get_file_size(td, f))
401 goto err;
402
2dc1bbeb 403 if (td->o.invalidate_cache && file_invalidate_cache(td, f))
b5af8293
JA
404 goto err;
405
d2f3ac35
JA
406 if (!td->o.fadvise_hint)
407 return 0;
408
b5af8293
JA
409 if (!td_random(td)) {
410 if (fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_SEQUENTIAL) < 0) {
411 td_verror(td, errno, "fadvise");
412 goto err;
413 }
414 } else {
415 if (fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_RANDOM) < 0) {
416 td_verror(td, errno, "fadvise");
417 goto err;
418 }
bdb4e2e9 419 }
53cdc686
JA
420
421 return 0;
b5af8293
JA
422err:
423 close(f->fd);
424 return 1;
425}
426
21972cde
JA
427int open_files(struct thread_data *td)
428{
429 struct fio_file *f;
af52b345
JA
430 unsigned int i;
431 int err = 0;
21972cde
JA
432
433 for_each_file(td, f, i) {
b5af8293 434 err = td_io_open_file(td, f);
21972cde
JA
435 if (err)
436 break;
b5af8293 437
2dc1bbeb 438 if (td->o.open_files == td->nr_open_files)
b5af8293 439 break;
21972cde
JA
440 }
441
7abf833d
JA
442 if (!err)
443 return 0;
444
bdb4e2e9 445 for_each_file(td, f, i)
b5af8293 446 td_io_close_file(td, f);
7abf833d 447
21972cde
JA
448 return err;
449}
450
53cdc686
JA
451int setup_files(struct thread_data *td)
452{
453 struct fio_file *f;
af52b345
JA
454 unsigned int i;
455 int err;
53cdc686
JA
456
457 /*
458 * if ioengine defines a setup() method, it's responsible for
459 * setting up everything in the td->files[] area.
460 */
461 if (td->io_ops->setup)
462 return td->io_ops->setup(td);
463
464 if (create_files(td))
465 return 1;
466
21972cde 467 err = open_files(td);
f1027063
JA
468 if (err)
469 return err;
470
0a7eb121
JA
471 /*
472 * Recalculate the total file size now that files are set up.
473 */
2dc1bbeb 474 td->o.size = 0;
0a7eb121 475 for_each_file(td, f, i)
2dc1bbeb 476 td->o.size += f->file_size;
0a7eb121 477
2dc1bbeb 478 td->io_size = td->o.size;
53cdc686 479 if (td->io_size == 0) {
2dc1bbeb 480 log_err("%s: no io blocks\n", td->o.name);
e1161c32 481 td_verror(td, EINVAL, "total_file_size");
53cdc686
JA
482 return 1;
483 }
484
2dc1bbeb
JA
485 if (!td->o.zone_size)
486 td->o.zone_size = td->io_size;
53cdc686 487
2dc1bbeb 488 td->total_io_size = td->io_size * td->o.loops;
53cdc686 489
bdb4e2e9 490 for_each_file(td, f, i)
b5af8293 491 td_io_close_file(td, f);
21972cde
JA
492
493 return err;
53cdc686
JA
494}
495
68727076
JA
496int init_random_map(struct thread_data *td)
497{
498 int num_maps, blocks;
499 struct fio_file *f;
500 unsigned int i;
501
502 if (td->o.norandommap)
503 return 0;
504
505 for_each_file(td, f, i) {
506 blocks = (f->real_file_size + td->o.rw_min_bs - 1) / td->o.rw_min_bs;
507 num_maps = (blocks + BLOCKS_PER_MAP-1)/ BLOCKS_PER_MAP;
508 f->file_map = malloc(num_maps * sizeof(long));
509 if (!f->file_map) {
510 log_err("fio: failed allocating random map. If running a large number of jobs, try the 'norandommap' option\n");
511 return 1;
512 }
513 f->num_maps = num_maps;
514 memset(f->file_map, 0, num_maps * sizeof(long));
515 }
516
517 return 0;
518}
519
53cdc686
JA
520void close_files(struct thread_data *td)
521{
0ab8db89 522 struct fio_file *f;
af52b345 523 unsigned int i;
53cdc686 524
0ab8db89 525 for_each_file(td, f, i) {
fa1da865
JA
526 if ((f->flags & FIO_FILE_UNLINK) &&
527 f->filetype == FIO_TYPE_FILE)
132ad46d 528 unlink(f->file_name);
bdb4e2e9 529
b5af8293 530 td_io_close_file(td, f);
b3dc7f07 531
fa1da865
JA
532 free(f->file_name);
533 f->file_name = NULL;
534
c343981b 535 if (f->file_map) {
b3dc7f07 536 free(f->file_map);
c343981b
JA
537 f->file_map = NULL;
538 }
53cdc686 539 }
b4a6a59a 540
2dc1bbeb 541 td->o.filename = NULL;
cade3ef4 542 free(td->files);
b4a6a59a 543 td->files = NULL;
2dc1bbeb 544 td->o.nr_files = 0;
53cdc686 545}
af52b345 546
e3bab463 547static void get_file_type(struct fio_file *f)
af52b345
JA
548{
549 struct stat sb;
550
551 f->filetype = FIO_TYPE_FILE;
552
e3bab463 553 if (!lstat(f->file_name, &sb)) {
96d32d51
JA
554 f->flags |= FIO_FILE_EXISTS;
555
af52b345
JA
556 if (S_ISBLK(sb.st_mode))
557 f->filetype = FIO_TYPE_BD;
558 else if (S_ISCHR(sb.st_mode))
559 f->filetype = FIO_TYPE_CHAR;
96d32d51
JA
560 else {
561 /*
562 * might as well do this here, and save a stat later on
563 */
564 f->real_file_size = sb.st_size;
565 f->file_size = f->real_file_size;
566 }
af52b345
JA
567 }
568}
569
570void add_file(struct thread_data *td, const char *fname)
571{
7b4e4fe5 572 int cur_files = td->files_index;
bd0ee748 573 char file_name[PATH_MAX];
af52b345 574 struct fio_file *f;
bd0ee748 575 int len = 0;
af52b345
JA
576
577 td->files = realloc(td->files, (cur_files + 1) * sizeof(*f));
578
579 f = &td->files[cur_files];
580 memset(f, 0, sizeof(*f));
581 f->fd = -1;
bd0ee748
JA
582
583 if (td->o.directory)
584 len = sprintf(file_name, "%s/", td->o.directory);
585
586 sprintf(file_name + len, "%s", fname);
587 f->file_name = strdup(file_name);
af52b345 588
e3bab463 589 get_file_type(f);
af52b345 590
7b4e4fe5 591 td->files_index++;
1549441c
JA
592 if (f->filetype == FIO_TYPE_FILE)
593 td->nr_normal_files++;
af52b345 594}
0ad920e7
JA
595
596void get_file(struct fio_file *f)
597{
598 f->references++;
599}
600
601void put_file(struct thread_data *td, struct fio_file *f)
602{
603 if (!(f->flags & FIO_FILE_OPEN))
604 return;
605
606 assert(f->references);
607 if (--f->references)
608 return;
609
2dc1bbeb 610 if (should_fsync(td) && td->o.fsync_on_close)
ebb1415f
JA
611 fsync(f->fd);
612
0ad920e7
JA
613 if (td->io_ops->close_file)
614 td->io_ops->close_file(td, f);
615 td->nr_open_files--;
616 f->flags &= ~FIO_FILE_OPEN;
617}
bbf6b540
JA
618
619static int recurse_dir(struct thread_data *td, const char *dirname)
620{
621 struct dirent *dir;
622 int ret = 0;
623 DIR *D;
624
625 D = opendir(dirname);
626 if (!D) {
627 td_verror(td, errno, "opendir");
628 return 1;
629 }
630
631 while ((dir = readdir(D)) != NULL) {
632 char full_path[PATH_MAX];
633 struct stat sb;
634
e85b2b83
JA
635 if (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, ".."))
636 continue;
96d32d51 637
bbf6b540
JA
638 sprintf(full_path, "%s/%s", dirname, dir->d_name);
639
640 if (lstat(full_path, &sb) == -1) {
641 if (errno != ENOENT) {
642 td_verror(td, errno, "stat");
643 return 1;
644 }
645 }
646
647 if (S_ISREG(sb.st_mode)) {
648 add_file(td, full_path);
2dc1bbeb 649 td->o.nr_files++;
bbf6b540
JA
650 continue;
651 }
652
bbf6b540
JA
653 if ((ret = recurse_dir(td, full_path)) != 0)
654 break;
655 }
656
657 closedir(D);
658 return ret;
659}
660
661int add_dir_files(struct thread_data *td, const char *path)
662{
663 return recurse_dir(td, path);
664}
cade3ef4
JA
665
666void dup_files(struct thread_data *td, struct thread_data *org)
667{
668 struct fio_file *f;
669 unsigned int i;
670 size_t bytes;
671
672 if (!org->files)
673 return;
674
675 bytes = org->files_index * sizeof(*f);
676 td->files = malloc(bytes);
677 memcpy(td->files, org->files, bytes);
678
679 for_each_file(td, f, i) {
680 if (f->file_name)
681 f->file_name = strdup(f->file_name);
682 }
683}