Add iodepth_batch setting
[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);
242 else if (td->filetype == FIO_TYPE_FILE)
243 ret = fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_DONTNEED);
244 else if (td->filetype == FIO_TYPE_BD)
245 ret = blockdev_invalidate_cache(f->fd);
246 else if (td->filetype == FIO_TYPE_CHAR)
247 ret = 0;
248
249 if (ret < 0) {
e1161c32 250 td_verror(td, errno, "invalidate_cache");
e5b401d4
JA
251 return 1;
252 }
253
254 return 0;
255}
256
53cdc686
JA
257static int __setup_file_mmap(struct thread_data *td, struct fio_file *f)
258{
259 int flags;
260
261 if (td_rw(td))
262 flags = PROT_READ | PROT_WRITE;
263 else if (td_write(td)) {
264 flags = PROT_WRITE;
265
266 if (td->verify != VERIFY_NONE)
267 flags |= PROT_READ;
268 } else
269 flags = PROT_READ;
270
271 f->mmap = mmap(NULL, f->file_size, flags, MAP_SHARED, f->fd, f->file_offset);
272 if (f->mmap == MAP_FAILED) {
273 f->mmap = NULL;
e1161c32 274 td_verror(td, errno, "mmap");
53cdc686
JA
275 return 1;
276 }
277
e5b401d4
JA
278 if (td->invalidate_cache && file_invalidate_cache(td, f))
279 return 1;
53cdc686 280
413dd459 281 if (!td_random(td)) {
53cdc686 282 if (madvise(f->mmap, f->file_size, MADV_SEQUENTIAL) < 0) {
e1161c32 283 td_verror(td, errno, "madvise");
53cdc686
JA
284 return 1;
285 }
286 } else {
287 if (madvise(f->mmap, f->file_size, MADV_RANDOM) < 0) {
e1161c32 288 td_verror(td, errno, "madvise");
53cdc686
JA
289 return 1;
290 }
291 }
292
293 return 0;
294}
295
296static int setup_files_mmap(struct thread_data *td)
297{
298 struct fio_file *f;
299 int i, err = 0;
300
301 for_each_file(td, f, i) {
302 err = __setup_file_mmap(td, f);
303 if (err)
304 break;
305 }
306
307 return err;
308}
309
310static int __setup_file_plain(struct thread_data *td, struct fio_file *f)
311{
e5b401d4
JA
312 if (td->invalidate_cache && file_invalidate_cache(td, f))
313 return 1;
53cdc686 314
413dd459 315 if (!td_random(td)) {
53cdc686 316 if (fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_SEQUENTIAL) < 0) {
e1161c32 317 td_verror(td, errno, "fadvise");
53cdc686
JA
318 return 1;
319 }
320 } else {
321 if (fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_RANDOM) < 0) {
e1161c32 322 td_verror(td, errno, "fadvise");
53cdc686
JA
323 return 1;
324 }
325 }
326
327 return 0;
328}
329
330static int setup_files_plain(struct thread_data *td)
331{
332 struct fio_file *f;
333 int i, err = 0;
334
335 for_each_file(td, f, i) {
336 err = __setup_file_plain(td, f);
337 if (err)
338 break;
339 }
340
341 return err;
342}
343
344static int setup_file(struct thread_data *td, struct fio_file *f)
345{
53cdc686
JA
346 int flags = 0;
347
ed92ac0c
JA
348 if (td->io_ops->flags & FIO_NETIO)
349 return 0;
53cdc686 350
4d9345ae
JA
351 /*
352 * we need a valid file descriptor, but don't create a real file.
353 * lets just dup stdout, seems like a sensible approach.
354 */
355 if (td->io_ops->flags & FIO_NULLIO)
356 f->fd = dup(STDOUT_FILENO);
357 else {
358 if (td->odirect)
359 flags |= OS_O_DIRECT;
360 if (td->sync_io)
361 flags |= O_SYNC;
362
363 if (td_write(td) || td_rw(td)) {
364 flags |= O_RDWR;
7abf833d 365
4d9345ae
JA
366 if (td->filetype == FIO_TYPE_FILE) {
367 if (!td->overwrite)
368 flags |= O_TRUNC;
53cdc686 369
4d9345ae
JA
370 flags |= O_CREAT;
371 }
53cdc686 372
4d9345ae
JA
373 f->fd = open(f->file_name, flags, 0600);
374 } else {
375 if (td->filetype == FIO_TYPE_CHAR)
376 flags |= O_RDWR;
377 else
378 flags |= O_RDONLY;
53cdc686 379
4d9345ae
JA
380 f->fd = open(f->file_name, flags);
381 }
53cdc686
JA
382 }
383
384 if (f->fd == -1) {
e1161c32
JA
385 int __e = errno;
386
387 td_verror(td, __e, "open");
388 if (__e == EINVAL && td->odirect)
9d80e114 389 log_err("fio: destination does not support O_DIRECT\n");
53cdc686
JA
390 return 1;
391 }
392
393 if (get_file_size(td, f))
394 return 1;
395
396 return 0;
397}
398
21972cde
JA
399int open_files(struct thread_data *td)
400{
401 struct fio_file *f;
402 int i, err = 0;
403
404 for_each_file(td, f, i) {
405 err = setup_file(td, f);
406 if (err)
407 break;
408 }
409
7abf833d
JA
410 if (!err)
411 return 0;
412
413 for_each_file(td, f, i) {
414 if (f->fd != -1) {
415 close(f->fd);
416 f->fd = -1;
417 }
418 }
419
21972cde
JA
420 return err;
421}
422
53cdc686
JA
423int setup_files(struct thread_data *td)
424{
425 struct fio_file *f;
21972cde 426 int err, i;
53cdc686
JA
427
428 /*
429 * if ioengine defines a setup() method, it's responsible for
430 * setting up everything in the td->files[] area.
431 */
432 if (td->io_ops->setup)
433 return td->io_ops->setup(td);
434
435 if (create_files(td))
436 return 1;
437
21972cde 438 err = open_files(td);
f1027063
JA
439 if (err)
440 return err;
441
0a7eb121
JA
442 /*
443 * Recalculate the total file size now that files are set up.
444 */
445 td->total_file_size = 0;
446 for_each_file(td, f, i)
447 td->total_file_size += f->file_size;
448
f1027063 449 td->io_size = td->total_file_size;
53cdc686
JA
450 if (td->io_size == 0) {
451 log_err("%s: no io blocks\n", td->name);
e1161c32 452 td_verror(td, EINVAL, "total_file_size");
53cdc686
JA
453 return 1;
454 }
455
456 if (!td->zone_size)
457 td->zone_size = td->io_size;
458
459 td->total_io_size = td->io_size * td->loops;
460
461 if (td->io_ops->flags & FIO_MMAPIO)
21972cde 462 err = setup_files_mmap(td);
53cdc686 463 else
21972cde
JA
464 err = setup_files_plain(td);
465
466 for_each_file(td, f, i) {
467 if (f->fd != -1) {
468 close(f->fd);
469 f->fd = -1;
470 }
471 }
472
473 return err;
53cdc686
JA
474}
475
476void close_files(struct thread_data *td)
477{
0ab8db89 478 struct fio_file *f;
53cdc686
JA
479 int i;
480
0ab8db89 481 for_each_file(td, f, i) {
9b031dc8 482 if (!td->filename && f->unlink &&
02bcaa8c 483 td->filetype == FIO_TYPE_FILE) {
132ad46d
JA
484 unlink(f->file_name);
485 free(f->file_name);
486 f->file_name = NULL;
487 }
21972cde
JA
488 if (f->fd != -1) {
489 close(f->fd);
490 f->fd = -1;
491 }
53cdc686
JA
492 if (f->mmap) {
493 munmap(f->mmap, f->file_size);
494 f->mmap = NULL;
495 }
496 }
b4a6a59a 497
132ad46d 498 td->filename = NULL;
b4a6a59a
JA
499 free(td->files);
500 td->files = NULL;
501 td->nr_files = 0;
53cdc686 502}