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