filesetup.c revision b3dc7f075b85e004f8c681ebb8566475017696f3 
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
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)
15{
16	struct stat st;
17
18	if (td->filetype != FIO_TYPE_FILE ||
19	    (td->io_ops->flags & FIO_DISKLESSIO))
20		return 0;
21
22	if (lstat(f->file_name, &st) == -1)
23		return 1;
24
25	/*
26	 * if it's a special file, size is always ok for now
27	 */
28	if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))
29		return 0;
30	if (st.st_size < (off_t) f->file_size)
31		return 1;
32
33	return 0;
34}
35
36static int create_file(struct thread_data *td, struct fio_file *f)
37{
38	unsigned long long left;
39	unsigned int bs;
40	char *b;
41	int r;
42
43	f->fd = open(f->file_name, O_WRONLY | O_CREAT | O_TRUNC, 0644);
44	if (f->fd < 0) {
45		td_verror(td, errno, "open");
46		return 1;
47	}
48
49	if (ftruncate(f->fd, f->file_size) == -1) {
50		td_verror(td, errno, "ftruncate");
51		goto err;
52	}
53
54	if (posix_fallocate(f->fd, 0, f->file_size) < 0) {
55		td_verror(td, errno, "posix_fallocate");
56		goto err;
57	}
58
59	b = malloc(td->max_bs[DDIR_WRITE]);
60	memset(b, 0, td->max_bs[DDIR_WRITE]);
61
62	left = f->file_size;
63	while (left && !td->terminate) {
64		bs = td->max_bs[DDIR_WRITE];
65		if (bs > left)
66			bs = left;
67
68		r = write(f->fd, b, bs);
69
70		if (r == (int) bs) {
71			left -= bs;
72			continue;
73		} else {
74			if (r < 0)
75				td_verror(td, errno, "write");
76			else
77				td_verror(td, EIO, "write");
78
79			break;
80		}
81	}
82
83	if (td->terminate)
84		unlink(f->file_name);
85	else if (td->create_fsync)
86		fsync(f->fd);
87
88	free(b);
89	close(f->fd);
90	f->fd = -1;
91	return 0;
92err:
93	close(f->fd);
94	f->fd = -1;
95	return 1;
96}
97
98static int create_files(struct thread_data *td)
99{
100	struct fio_file *f;
101	int i, err, need_create;
102
103	for_each_file(td, f, i)
104		f->file_size = td->total_file_size / td->nr_files;
105
106	/*
107	 * unless specifically asked for overwrite, let normal io extend it
108	 */
109	if (!td->overwrite)
110		return 0;
111
112	need_create = 0;
113	if (td->filetype == FIO_TYPE_FILE) {
114		for_each_file(td, f, i) {
115			int file_there = !file_ok(td, f);
116
117			if (file_there && td_write(td) && !td->overwrite) {
118				unlink(f->file_name);
119				file_there = 0;
120			}
121
122			need_create += !file_there;
123		}
124	}
125
126	if (!need_create)
127		return 0;
128
129	if (!td->total_file_size) {
130		log_err("Need size for create\n");
131		td_verror(td, EINVAL, "file_size");
132		return 1;
133	}
134
135	temp_stall_ts = 1;
136	fprintf(f_out, "%s: Laying out IO file(s) (%u x %LuMiB == %LuMiB)\n",
137				td->name, td->nr_uniq_files,
138				(td->total_file_size >> 20) / td->nr_uniq_files,
139				td->total_file_size >> 20);
140
141	err = 0;
142	for_each_file(td, f, i) {
143		/*
144		 * Only unlink files that we created.
145		 */
146		f->unlink = 0;
147		if (file_ok(td, f)) {
148			f->unlink = td->unlink;
149			err = create_file(td, f);
150			if (err)
151				break;
152		}
153	}
154
155	temp_stall_ts = 0;
156	return err;
157}
158
159static int file_size(struct thread_data *td, struct fio_file *f)
160{
161	struct stat st;
162
163	if (td->overwrite) {
164		if (fstat(f->fd, &st) == -1) {
165			td_verror(td, errno, "fstat");
166			return 1;
167		}
168
169		f->real_file_size = st.st_size;
170
171		if (!f->file_size || f->file_size > f->real_file_size)
172			f->file_size = f->real_file_size;
173	} else
174		f->real_file_size = f->file_size;
175
176	return 0;
177}
178
179static int bdev_size(struct thread_data *td, struct fio_file *f)
180{
181	unsigned long long bytes;
182	int r;
183
184	r = blockdev_size(f->fd, &bytes);
185	if (r) {
186		td_verror(td, r, "blockdev_size");
187		return 1;
188	}
189
190	f->real_file_size = bytes;
191
192	/*
193	 * no extend possibilities, so limit size to device size if too large
194	 */
195	if (!f->file_size || f->file_size > f->real_file_size)
196		f->file_size = f->real_file_size;
197
198	f->file_size -= f->file_offset;
199	return 0;
200}
201
202static int get_file_size(struct thread_data *td, struct fio_file *f)
203{
204	int ret = 0;
205
206	if (td->filetype == FIO_TYPE_FILE)
207		ret = file_size(td, f);
208	else if (td->filetype == FIO_TYPE_BD)
209		ret = bdev_size(td, f);
210	else
211		f->real_file_size = -1;
212
213	if (ret)
214		return ret;
215
216	if (f->file_offset > f->real_file_size) {
217		log_err("%s: offset extends end (%Lu > %Lu)\n", td->name, f->file_offset, f->real_file_size);
218		return 1;
219	}
220
221	return 0;
222}
223
224int file_invalidate_cache(struct thread_data *td, struct fio_file *f)
225{
226	int ret = 0;
227
228	if (!td->invalidate_cache)
229		return 0;
230	if (td->odirect)
231		return 0;
232
233	/*
234	 * FIXME: add blockdev flushing too
235	 */
236	if (f->mmap)
237		ret = madvise(f->mmap, f->file_size, MADV_DONTNEED);
238	else if (td->filetype == FIO_TYPE_FILE) {
239		ret = fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_DONTNEED);
240	} else if (td->filetype == FIO_TYPE_BD) {
241		ret = blockdev_invalidate_cache(f->fd);
242	} else if (td->filetype == FIO_TYPE_CHAR)
243		ret = 0;
244
245	if (ret < 0) {
246		td_verror(td, errno, "invalidate_cache");
247		return 1;
248	}
249
250	return ret;
251}
252
253void generic_close_file(struct thread_data fio_unused *td, struct fio_file *f)
254{
255	close(f->fd);
256	f->fd = -1;
257}
258
259int generic_open_file(struct thread_data *td, struct fio_file *f)
260{
261	int flags = 0;
262
263	if (td->odirect)
264		flags |= OS_O_DIRECT;
265	if (td->sync_io)
266		flags |= O_SYNC;
267
268	if (td_write(td) || td_rw(td)) {
269		flags |= O_RDWR;
270
271		if (td->filetype == FIO_TYPE_FILE) {
272			if (!td->overwrite)
273				flags |= O_TRUNC;
274
275			flags |= O_CREAT;
276		}
277
278		f->fd = open(f->file_name, flags, 0600);
279	} else {
280		if (td->filetype == FIO_TYPE_CHAR)
281			flags |= O_RDWR;
282		else
283			flags |= O_RDONLY;
284
285		f->fd = open(f->file_name, flags);
286	}
287
288	if (f->fd == -1) {
289		int __e = errno;
290
291		td_verror(td, __e, "open");
292		if (__e == EINVAL && td->odirect)
293			log_err("fio: destination does not support O_DIRECT\n");
294		return 1;
295	}
296
297	if (get_file_size(td, f))
298		goto err;
299
300	if (file_invalidate_cache(td, f))
301		goto err;
302
303	if (!td_random(td)) {
304		if (fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_SEQUENTIAL) < 0) {
305			td_verror(td, errno, "fadvise");
306			goto err;
307		}
308	} else {
309		if (fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_RANDOM) < 0) {
310			td_verror(td, errno, "fadvise");
311			goto err;
312		}
313	}
314
315	return 0;
316err:
317	close(f->fd);
318	return 1;
319}
320
321int open_files(struct thread_data *td)
322{
323	struct fio_file *f;
324	int i, err = 0;
325
326	for_each_file(td, f, i) {
327		err = td_io_open_file(td, f);
328		if (err)
329			break;
330
331		if (td->open_files == td->nr_open_files)
332			break;
333	}
334
335	if (!err)
336		return 0;
337
338	for_each_file(td, f, i)
339		td_io_close_file(td, f);
340
341	return err;
342}
343
344int setup_files(struct thread_data *td)
345{
346	struct fio_file *f;
347	int err, i;
348
349	/*
350	 * if ioengine defines a setup() method, it's responsible for
351	 * setting up everything in the td->files[] area.
352	 */
353	if (td->io_ops->setup)
354		return td->io_ops->setup(td);
355
356	if (create_files(td))
357		return 1;
358
359	err = open_files(td);
360	if (err)
361		return err;
362
363	/*
364	 * Recalculate the total file size now that files are set up.
365	 */
366	td->total_file_size = 0;
367	for_each_file(td, f, i)
368		td->total_file_size += f->file_size;
369
370	td->total_file_size = (td->total_file_size * td->nr_files) / td->open_files;
371
372	td->io_size = td->total_file_size;
373	if (td->io_size == 0) {
374		log_err("%s: no io blocks\n", td->name);
375		td_verror(td, EINVAL, "total_file_size");
376		return 1;
377	}
378
379	if (!td->zone_size)
380		td->zone_size = td->io_size;
381
382	td->total_io_size = td->io_size * td->loops;
383
384	for_each_file(td, f, i)
385		td_io_close_file(td, f);
386
387	return err;
388}
389
390void close_files(struct thread_data *td)
391{
392	struct fio_file *f;
393	int i;
394
395	for_each_file(td, f, i) {
396		if (!td->filename && f->unlink &&
397		    td->filetype == FIO_TYPE_FILE) {
398			unlink(f->file_name);
399			free(f->file_name);
400			f->file_name = NULL;
401		}
402
403		td_io_close_file(td, f);
404
405		if (f->file_map)
406			free(f->file_map);
407	}
408
409	td->filename = NULL;
410	free(td->files);
411	td->files = NULL;
412	td->nr_files = 0;
413}
414