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