client: fix use-after-free for client timeout
[fio.git] / ioengines.c
1 /*
2  * The io parts of the fio tool, includes workers for sync and mmap'ed
3  * io, as well as both posix and linux libaio support.
4  *
5  * sync io is implemented on top of aio.
6  *
7  * This is not really specific to fio, if the get_io_u/put_io_u and
8  * structures was pulled into this as well it would be a perfectly
9  * generic io engine that could be used for other projects.
10  *
11  */
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <unistd.h>
15 #include <string.h>
16 #include <dlfcn.h>
17 #include <fcntl.h>
18 #include <assert.h>
19
20 #include "fio.h"
21 #include "diskutil.h"
22
23 static FLIST_HEAD(engine_list);
24
25 static bool check_engine_ops(struct ioengine_ops *ops)
26 {
27         if (ops->version != FIO_IOOPS_VERSION) {
28                 log_err("bad ioops version %d (want %d)\n", ops->version,
29                                                         FIO_IOOPS_VERSION);
30                 return true;
31         }
32
33         if (!ops->queue) {
34                 log_err("%s: no queue handler\n", ops->name);
35                 return true;
36         }
37
38         /*
39          * sync engines only need a ->queue()
40          */
41         if (ops->flags & FIO_SYNCIO)
42                 return false;
43
44         if (!ops->event || !ops->getevents) {
45                 log_err("%s: no event/getevents handler\n", ops->name);
46                 return true;
47         }
48
49         return false;
50 }
51
52 void unregister_ioengine(struct ioengine_ops *ops)
53 {
54         dprint(FD_IO, "ioengine %s unregistered\n", ops->name);
55         flist_del_init(&ops->list);
56 }
57
58 void register_ioengine(struct ioengine_ops *ops)
59 {
60         dprint(FD_IO, "ioengine %s registered\n", ops->name);
61         flist_add_tail(&ops->list, &engine_list);
62 }
63
64 static struct ioengine_ops *find_ioengine(const char *name)
65 {
66         struct ioengine_ops *ops;
67         struct flist_head *entry;
68
69         flist_for_each(entry, &engine_list) {
70                 ops = flist_entry(entry, struct ioengine_ops, list);
71                 if (!strcmp(name, ops->name))
72                         return ops;
73         }
74
75         return NULL;
76 }
77
78 static struct ioengine_ops *dlopen_ioengine(struct thread_data *td,
79                                             const char *engine_lib)
80 {
81         struct ioengine_ops *ops;
82         void *dlhandle;
83
84         dprint(FD_IO, "dload engine %s\n", engine_lib);
85
86         dlerror();
87         dlhandle = dlopen(engine_lib, RTLD_LAZY);
88         if (!dlhandle) {
89                 td_vmsg(td, -1, dlerror(), "dlopen");
90                 return NULL;
91         }
92
93         /*
94          * Unlike the included modules, external engines should have a
95          * non-static ioengine structure that we can reference.
96          */
97         ops = dlsym(dlhandle, engine_lib);
98         if (!ops)
99                 ops = dlsym(dlhandle, "ioengine");
100
101         /*
102          * For some external engines (like C++ ones) it is not that trivial
103          * to provide a non-static ionengine structure that we can reference.
104          * Instead we call a method which allocates the required ioengine
105          * structure.
106          */
107         if (!ops) {
108                 get_ioengine_t get_ioengine = dlsym(dlhandle, "get_ioengine");
109
110                 if (get_ioengine)
111                         get_ioengine(&ops);
112         }
113
114         if (!ops) {
115                 td_vmsg(td, -1, dlerror(), "dlsym");
116                 dlclose(dlhandle);
117                 return NULL;
118         }
119
120         td->io_ops_dlhandle = dlhandle;
121         return ops;
122 }
123
124 static struct ioengine_ops *__load_ioengine(const char *name)
125 {
126         char engine[64];
127
128         engine[sizeof(engine) - 1] = '\0';
129         strncpy(engine, name, sizeof(engine) - 1);
130
131         /*
132          * linux libaio has alias names, so convert to what we want
133          */
134         if (!strncmp(engine, "linuxaio", 8) || !strncmp(engine, "aio", 3)) {
135                 dprint(FD_IO, "converting ioengine name: %s -> libaio\n", name);
136                 strcpy(engine, "libaio");
137         }
138
139         dprint(FD_IO, "load ioengine %s\n", engine);
140         return find_ioengine(engine);
141 }
142
143 struct ioengine_ops *load_ioengine(struct thread_data *td)
144 {
145         struct ioengine_ops *ops = NULL;
146         const char *name;
147
148         /*
149          * Use ->ioengine_so_path if an external ioengine path is specified.
150          * In this case, ->ioengine is "external" which also means the prefix
151          * for external ioengines "external:" is properly used.
152          */
153         name = td->o.ioengine_so_path ?: td->o.ioengine;
154
155         /*
156          * Try to load ->ioengine first, and if failed try to dlopen(3) either
157          * ->ioengine or ->ioengine_so_path.  This is redundant for an external
158          * ioengine with prefix, and also leaves the possibility of unexpected
159          * behavior (e.g. if the "external" ioengine exists), but we do this
160          * so as not to break job files not using the prefix.
161          */
162         ops = __load_ioengine(td->o.ioengine);
163         if (!ops)
164                 ops = dlopen_ioengine(td, name);
165
166         /*
167          * If ops is NULL, we failed to load ->ioengine, and also failed to
168          * dlopen(3) either ->ioengine or ->ioengine_so_path as a path.
169          */
170         if (!ops) {
171                 log_err("fio: engine %s not loadable\n", name);
172                 return NULL;
173         }
174
175         /*
176          * Check that the required methods are there.
177          */
178         if (check_engine_ops(ops))
179                 return NULL;
180
181         return ops;
182 }
183
184 /*
185  * For cleaning up an ioengine which never made it to init().
186  */
187 void free_ioengine(struct thread_data *td)
188 {
189         dprint(FD_IO, "free ioengine %s\n", td->io_ops->name);
190
191         if (td->eo && td->io_ops->options) {
192                 options_free(td->io_ops->options, td->eo);
193                 free(td->eo);
194                 td->eo = NULL;
195         }
196
197         if (td->io_ops_dlhandle)
198                 dlclose(td->io_ops_dlhandle);
199
200         td->io_ops = NULL;
201 }
202
203 void close_ioengine(struct thread_data *td)
204 {
205         dprint(FD_IO, "close ioengine %s\n", td->io_ops->name);
206
207         if (td->io_ops->cleanup) {
208                 td->io_ops->cleanup(td);
209                 td->io_ops_data = NULL;
210         }
211
212         free_ioengine(td);
213 }
214
215 int td_io_prep(struct thread_data *td, struct io_u *io_u)
216 {
217         dprint_io_u(io_u, "prep");
218         fio_ro_check(td, io_u);
219
220         lock_file(td, io_u->file, io_u->ddir);
221
222         if (td->io_ops->prep) {
223                 int ret = td->io_ops->prep(td, io_u);
224
225                 dprint(FD_IO, "->prep(%p)=%d\n", io_u, ret);
226                 if (ret)
227                         unlock_file(td, io_u->file);
228                 return ret;
229         }
230
231         return 0;
232 }
233
234 int td_io_getevents(struct thread_data *td, unsigned int min, unsigned int max,
235                     const struct timespec *t)
236 {
237         int r = 0;
238
239         /*
240          * For ioengine=rdma one side operation RDMA_WRITE or RDMA_READ,
241          * server side gets a message from the client
242          * side that the task is finished, and
243          * td->done is set to 1 after td_io_commit(). In this case,
244          * there is no need to reap complete event in server side.
245          */
246         if (td->done)
247                 return 0;
248
249         if (min > 0 && td->io_ops->commit) {
250                 r = td->io_ops->commit(td);
251                 if (r < 0)
252                         goto out;
253         }
254         if (max > td->cur_depth)
255                 max = td->cur_depth;
256         if (min > max)
257                 max = min;
258
259         r = 0;
260         if (max && td->io_ops->getevents)
261                 r = td->io_ops->getevents(td, min, max, t);
262 out:
263         if (r >= 0) {
264                 /*
265                  * Reflect that our submitted requests were retrieved with
266                  * whatever OS async calls are in the underlying engine.
267                  */
268                 td->io_u_in_flight -= r;
269                 io_u_mark_complete(td, r);
270         } else
271                 td_verror(td, r, "get_events");
272
273         dprint(FD_IO, "getevents: %d\n", r);
274         return r;
275 }
276
277 int td_io_queue(struct thread_data *td, struct io_u *io_u)
278 {
279         const enum fio_ddir ddir = acct_ddir(io_u);
280         unsigned long buflen = io_u->xfer_buflen;
281         int ret;
282
283         dprint_io_u(io_u, "queue");
284         fio_ro_check(td, io_u);
285
286         assert((io_u->flags & IO_U_F_FLIGHT) == 0);
287         io_u_set(td, io_u, IO_U_F_FLIGHT);
288
289         assert(fio_file_open(io_u->file));
290
291         /*
292          * If using a write iolog, store this entry.
293          */
294         log_io_u(td, io_u);
295
296         io_u->error = 0;
297         io_u->resid = 0;
298
299         if (td_ioengine_flagged(td, FIO_SYNCIO)) {
300                 if (fio_fill_issue_time(td))
301                         fio_gettime(&io_u->issue_time, NULL);
302
303                 /*
304                  * only used for iolog
305                  */
306                 if (td->o.read_iolog_file)
307                         memcpy(&td->last_issue, &io_u->issue_time,
308                                         sizeof(io_u->issue_time));
309         }
310
311         if (ddir_rw(ddir)) {
312                 td->io_issues[ddir]++;
313                 td->io_issue_bytes[ddir] += buflen;
314                 td->rate_io_issue_bytes[ddir] += buflen;
315         }
316
317         ret = td->io_ops->queue(td, io_u);
318
319         unlock_file(td, io_u->file);
320
321         if (ret == FIO_Q_BUSY && ddir_rw(ddir)) {
322                 td->io_issues[ddir]--;
323                 td->io_issue_bytes[ddir] -= buflen;
324                 td->rate_io_issue_bytes[ddir] -= buflen;
325                 io_u_clear(td, io_u, IO_U_F_FLIGHT);
326         }
327
328         /*
329          * If an error was seen and the io engine didn't propagate it
330          * back to 'td', do so.
331          */
332         if (io_u->error && !td->error)
333                 td_verror(td, io_u->error, "td_io_queue");
334
335         /*
336          * Add warning for O_DIRECT so that users have an easier time
337          * spotting potentially bad alignment. If this triggers for the first
338          * IO, then it's likely an alignment problem or because the host fs
339          * does not support O_DIRECT
340          */
341         if (io_u->error == EINVAL && td->io_issues[io_u->ddir & 1] == 1 &&
342             td->o.odirect) {
343
344                 log_info("fio: first direct IO errored. File system may not "
345                          "support direct IO, or iomem_align= is bad, or "
346                          "invalid block size. Try setting direct=0.\n");
347         }
348
349         if (!td->io_ops->commit || io_u->ddir == DDIR_TRIM) {
350                 io_u_mark_submit(td, 1);
351                 io_u_mark_complete(td, 1);
352         }
353
354         if (ret == FIO_Q_COMPLETED) {
355                 if (ddir_rw(io_u->ddir)) {
356                         io_u_mark_depth(td, 1);
357                         td->ts.total_io_u[io_u->ddir]++;
358                 }
359         } else if (ret == FIO_Q_QUEUED) {
360                 int r;
361
362                 td->io_u_queued++;
363
364                 if (ddir_rw(io_u->ddir))
365                         td->ts.total_io_u[io_u->ddir]++;
366
367                 if (td->io_u_queued >= td->o.iodepth_batch) {
368                         r = td_io_commit(td);
369                         if (r < 0)
370                                 return r;
371                 }
372         }
373
374         if (!td_ioengine_flagged(td, FIO_SYNCIO)) {
375                 if (fio_fill_issue_time(td))
376                         fio_gettime(&io_u->issue_time, NULL);
377
378                 /*
379                  * only used for iolog
380                  */
381                 if (td->o.read_iolog_file)
382                         memcpy(&td->last_issue, &io_u->issue_time,
383                                         sizeof(io_u->issue_time));
384         }
385
386         return ret;
387 }
388
389 int td_io_init(struct thread_data *td)
390 {
391         int ret = 0;
392
393         if (td->io_ops->init) {
394                 ret = td->io_ops->init(td);
395                 if (ret)
396                         log_err("fio: io engine %s init failed.%s\n",
397                                 td->io_ops->name,
398                                 td->o.iodepth > 1 ?
399                                 " Perhaps try reducing io depth?" : "");
400                 else
401                         td->io_ops_init = 1;
402                 if (!td->error)
403                         td->error = ret;
404         }
405
406         return ret;
407 }
408
409 int td_io_commit(struct thread_data *td)
410 {
411         int ret;
412
413         dprint(FD_IO, "calling ->commit(), depth %d\n", td->cur_depth);
414
415         if (!td->cur_depth || !td->io_u_queued)
416                 return 0;
417
418         io_u_mark_depth(td, td->io_u_queued);
419
420         if (td->io_ops->commit) {
421                 ret = td->io_ops->commit(td);
422                 if (ret)
423                         td_verror(td, -ret, "io commit");
424         }
425
426         /*
427          * Reflect that events were submitted as async IO requests.
428          */
429         td->io_u_in_flight += td->io_u_queued;
430         td->io_u_queued = 0;
431
432         return 0;
433 }
434
435 int td_io_open_file(struct thread_data *td, struct fio_file *f)
436 {
437         assert(!fio_file_open(f));
438         assert(f->fd == -1);
439         assert(td->io_ops->open_file);
440
441         if (td->io_ops->open_file(td, f)) {
442                 if (td->error == EINVAL && td->o.odirect)
443                         log_err("fio: destination does not support O_DIRECT\n");
444                 if (td->error == EMFILE) {
445                         log_err("fio: try reducing/setting openfiles (failed"
446                                 " at %u of %u)\n", td->nr_open_files,
447                                                         td->o.nr_files);
448                 }
449
450                 assert(f->fd == -1);
451                 assert(!fio_file_open(f));
452                 return 1;
453         }
454
455         fio_file_reset(td, f);
456         fio_file_set_open(f);
457         fio_file_clear_closing(f);
458         disk_util_inc(f->du);
459
460         td->nr_open_files++;
461         get_file(f);
462
463         if (f->filetype == FIO_TYPE_PIPE) {
464                 if (td_random(td)) {
465                         log_err("fio: can't seek on pipes (no random io)\n");
466                         goto err;
467                 }
468         }
469
470         if (td_ioengine_flagged(td, FIO_DISKLESSIO))
471                 goto done;
472
473         if (td->o.invalidate_cache && file_invalidate_cache(td, f))
474                 goto err;
475
476         if (td->o.fadvise_hint != F_ADV_NONE &&
477             (f->filetype == FIO_TYPE_BLOCK || f->filetype == FIO_TYPE_FILE)) {
478                 int flags;
479
480                 if (td->o.fadvise_hint == F_ADV_TYPE) {
481                         if (td_random(td))
482                                 flags = POSIX_FADV_RANDOM;
483                         else
484                                 flags = POSIX_FADV_SEQUENTIAL;
485                 } else if (td->o.fadvise_hint == F_ADV_RANDOM)
486                         flags = POSIX_FADV_RANDOM;
487                 else if (td->o.fadvise_hint == F_ADV_SEQUENTIAL)
488                         flags = POSIX_FADV_SEQUENTIAL;
489                 else {
490                         log_err("fio: unknown fadvise type %d\n",
491                                                         td->o.fadvise_hint);
492                         flags = POSIX_FADV_NORMAL;
493                 }
494
495                 if (posix_fadvise(f->fd, f->file_offset, f->io_size, flags) < 0) {
496                         td_verror(td, errno, "fadvise");
497                         goto err;
498                 }
499         }
500 #ifdef FIO_HAVE_WRITE_HINT
501         if (fio_option_is_set(&td->o, write_hint) &&
502             (f->filetype == FIO_TYPE_BLOCK || f->filetype == FIO_TYPE_FILE)) {
503                 uint64_t hint = td->o.write_hint;
504                 int cmd;
505
506                 /*
507                  * For direct IO, we just need/want to set the hint on
508                  * the file descriptor. For buffered IO, we need to set
509                  * it on the inode.
510                  */
511                 if (td->o.odirect)
512                         cmd = F_SET_FILE_RW_HINT;
513                 else
514                         cmd = F_SET_RW_HINT;
515
516                 if (fcntl(f->fd, cmd, &hint) < 0) {
517                         td_verror(td, errno, "fcntl write hint");
518                         goto err;
519                 }
520         }
521 #endif
522
523         if (td->o.odirect && !OS_O_DIRECT && fio_set_directio(td, f))
524                 goto err;
525
526 done:
527         log_file(td, f, FIO_LOG_OPEN_FILE);
528         return 0;
529 err:
530         disk_util_dec(f->du);
531         if (td->io_ops->close_file)
532                 td->io_ops->close_file(td, f);
533         return 1;
534 }
535
536 int td_io_close_file(struct thread_data *td, struct fio_file *f)
537 {
538         if (!fio_file_closing(f))
539                 log_file(td, f, FIO_LOG_CLOSE_FILE);
540
541         /*
542          * mark as closing, do real close when last io on it has completed
543          */
544         fio_file_set_closing(f);
545
546         disk_util_dec(f->du);
547
548         if (td->o.file_lock_mode != FILE_LOCK_NONE)
549                 unlock_file_all(td, f);
550
551         return put_file(td, f);
552 }
553
554 int td_io_unlink_file(struct thread_data *td, struct fio_file *f)
555 {
556         if (td->io_ops->unlink_file)
557                 return td->io_ops->unlink_file(td, f);
558         else {
559                 int ret;
560
561                 ret = unlink(f->file_name);
562                 if (ret < 0)
563                         return errno;
564
565                 return 0;
566         }
567 }
568
569 int td_io_get_file_size(struct thread_data *td, struct fio_file *f)
570 {
571         if (!td->io_ops->get_file_size)
572                 return 0;
573
574         return td->io_ops->get_file_size(td, f);
575 }
576
577 int fio_show_ioengine_help(const char *engine)
578 {
579         struct flist_head *entry;
580         struct ioengine_ops *io_ops;
581         char *sep;
582         int ret = 1;
583
584         if (!engine || !*engine) {
585                 log_info("Available IO engines:\n");
586                 flist_for_each(entry, &engine_list) {
587                         io_ops = flist_entry(entry, struct ioengine_ops, list);
588                         log_info("\t%s\n", io_ops->name);
589                 }
590                 return 0;
591         }
592         sep = strchr(engine, ',');
593         if (sep) {
594                 *sep = 0;
595                 sep++;
596         }
597
598         io_ops = __load_ioengine(engine);
599         if (!io_ops) {
600                 log_info("IO engine %s not found\n", engine);
601                 return 1;
602         }
603
604         if (io_ops->options)
605                 ret = show_cmd_help(io_ops->options, sep);
606         else
607                 log_info("IO engine %s has no options\n", io_ops->name);
608
609         return ret;
610 }