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