ioengines.c revision ee56ad500f6692381e131cc37299d23fa910a24a
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 <assert.h> 18 19#include "fio.h" 20 21static LIST_HEAD(engine_list); 22 23static int check_engine_ops(struct ioengine_ops *ops) 24{ 25 if (ops->version != FIO_IOOPS_VERSION) { 26 log_err("bad ioops version %d (want %d)\n", ops->version, FIO_IOOPS_VERSION); 27 return 1; 28 } 29 30 if (!ops->queue) { 31 log_err("%s: no queue handler\n", ops->name); 32 return 1; 33 } 34 35 /* 36 * sync engines only need a ->queue() 37 */ 38 if (ops->flags & FIO_SYNCIO) 39 return 0; 40 41 if (!ops->event) { 42 log_err("%s: no event handler\n", ops->name); 43 return 1; 44 } 45 if (!ops->getevents) { 46 log_err("%s: no getevents handler\n", ops->name); 47 return 1; 48 } 49 if (!ops->queue) { 50 log_err("%s: no queue handler\n", ops->name); 51 return 1; 52 } 53 54 return 0; 55} 56 57void unregister_ioengine(struct ioengine_ops *ops) 58{ 59 dprint(FD_IO, "ioengine %s unregistered\n", ops->name); 60 list_del(&ops->list); 61 INIT_LIST_HEAD(&ops->list); 62} 63 64void register_ioengine(struct ioengine_ops *ops) 65{ 66 dprint(FD_IO, "ioengine %s registered\n", ops->name); 67 INIT_LIST_HEAD(&ops->list); 68 list_add_tail(&ops->list, &engine_list); 69} 70 71static struct ioengine_ops *find_ioengine(const char *name) 72{ 73 struct ioengine_ops *ops; 74 struct list_head *entry; 75 76 list_for_each(entry, &engine_list) { 77 ops = list_entry(entry, struct ioengine_ops, list); 78 if (!strcmp(name, ops->name)) 79 return ops; 80 } 81 82 return NULL; 83} 84 85static struct ioengine_ops *dlopen_ioengine(struct thread_data *td, 86 const char *engine_lib) 87{ 88 struct ioengine_ops *ops; 89 void *dlhandle; 90 91 dprint(FD_IO, "dload engine %s\n", engine_lib); 92 93 dlerror(); 94 dlhandle = dlopen(engine_lib, RTLD_LAZY); 95 if (!dlhandle) { 96 td_vmsg(td, -1, dlerror(), "dlopen"); 97 return NULL; 98 } 99 100 /* 101 * Unlike the included modules, external engines should have a 102 * non-static ioengine structure that we can reference. 103 */ 104 ops = dlsym(dlhandle, "ioengine"); 105 if (!ops) { 106 td_vmsg(td, -1, dlerror(), "dlsym"); 107 dlclose(dlhandle); 108 return NULL; 109 } 110 111 ops->dlhandle = dlhandle; 112 return ops; 113} 114 115struct ioengine_ops *load_ioengine(struct thread_data *td, const char *name) 116{ 117 struct ioengine_ops *ops, *ret; 118 char engine[16]; 119 120 dprint(FD_IO, "load ioengine %s\n", name); 121 122 strncpy(engine, name, sizeof(engine) - 1); 123 124 /* 125 * linux libaio has alias names, so convert to what we want 126 */ 127 if (!strncmp(engine, "linuxaio", 8) || !strncmp(engine, "aio", 3)) 128 strcpy(engine, "libaio"); 129 130 ops = find_ioengine(engine); 131 if (!ops) 132 ops = dlopen_ioengine(td, name); 133 134 if (!ops) { 135 log_err("fio: engine %s not loadable\n", name); 136 return NULL; 137 } 138 139 /* 140 * Check that the required methods are there. 141 */ 142 if (check_engine_ops(ops)) 143 return NULL; 144 145 ret = malloc(sizeof(*ret)); 146 memcpy(ret, ops, sizeof(*ret)); 147 ret->data = NULL; 148 149 return ret; 150} 151 152void close_ioengine(struct thread_data *td) 153{ 154 dprint(FD_IO, "close ioengine %s\n", td->io_ops->name); 155 156 if (td->io_ops->cleanup) 157 td->io_ops->cleanup(td); 158 159 if (td->io_ops->dlhandle) 160 dlclose(td->io_ops->dlhandle); 161 162 free(td->io_ops); 163 td->io_ops = NULL; 164} 165 166static void dprint_io_u(struct io_u *io_u, const char *p) 167{ 168 struct fio_file *f = io_u->file; 169 170 dprint(FD_IO, "%s: off=%llu/len=%lu/ddir=%d", p, io_u->offset, 171 io_u->buflen, io_u->ddir); 172 if (f) 173 dprint(FD_IO, "/%s", f->file_name); 174 dprint(FD_IO, "\n"); 175} 176 177int td_io_prep(struct thread_data *td, struct io_u *io_u) 178{ 179 dprint_io_u(io_u, "prep"); 180 fio_ro_check(td, io_u); 181 182 if (td->io_ops->prep) 183 return td->io_ops->prep(td, io_u); 184 185 return 0; 186} 187 188int td_io_getevents(struct thread_data *td, unsigned int min, unsigned int max, 189 struct timespec *t) 190{ 191 int r = 0; 192 193 if (min > 0 && td->io_ops->commit) { 194 r = td->io_ops->commit(td); 195 if (r < 0) 196 goto out; 197 } 198 199 r = 0; 200 if (td->io_ops->getevents) 201 r = td->io_ops->getevents(td, min, max, t); 202out: 203 dprint(FD_IO, "getevents: %d\n", r); 204 return r; 205} 206 207int td_io_queue(struct thread_data *td, struct io_u *io_u) 208{ 209 int ret; 210 211 dprint_io_u(io_u, "queue"); 212 fio_ro_check(td, io_u); 213 214 assert((io_u->flags & IO_U_F_FLIGHT) == 0); 215 io_u->flags |= IO_U_F_FLIGHT; 216 217 assert(io_u->file->flags & FIO_FILE_OPEN); 218 219 io_u->error = 0; 220 io_u->resid = 0; 221 222 if (td->io_ops->flags & FIO_SYNCIO) { 223 fio_gettime(&io_u->issue_time, NULL); 224 memcpy(&td->last_issue, &io_u->issue_time, sizeof(struct timeval)); 225 226 /* 227 * for a sync engine, set the timeout upfront 228 */ 229 if (mtime_since(&td->timeout_end, &io_u->issue_time) < IO_U_TIMEOUT) 230 io_u_set_timeout(td); 231 } 232 233 if (io_u->ddir != DDIR_SYNC) 234 td->io_issues[io_u->ddir]++; 235 236 io_u_mark_depth(td, io_u); 237 238 ret = td->io_ops->queue(td, io_u); 239 240 if (ret == FIO_Q_QUEUED) { 241 int r; 242 243 td->io_u_queued++; 244 if (td->io_u_queued > td->o.iodepth_batch) { 245 r = td_io_commit(td); 246 if (r < 0) 247 return r; 248 } 249 } 250 251 if ((td->io_ops->flags & FIO_SYNCIO) == 0) { 252 fio_gettime(&io_u->issue_time, NULL); 253 memcpy(&td->last_issue, &io_u->issue_time, sizeof(struct timeval)); 254 255 /* 256 * async engine, set the timeout here 257 */ 258 if (ret == FIO_Q_QUEUED && 259 mtime_since(&td->timeout_end, &io_u->issue_time) < IO_U_TIMEOUT) 260 io_u_set_timeout(td); 261 } 262 263 return ret; 264} 265 266int td_io_init(struct thread_data *td) 267{ 268 int ret = 0; 269 270 if (td->io_ops->init) { 271 ret = td->io_ops->init(td); 272 if (ret && td->o.iodepth > 1) 273 log_err("fio: io engine init failed. Perhaps try reducing io depth?\n"); 274 } 275 276 return ret; 277} 278 279int td_io_commit(struct thread_data *td) 280{ 281 dprint(FD_IO, "calling ->commit(), depth %d\n", td->cur_depth); 282 283 if (!td->cur_depth) 284 return 0; 285 286 td->io_u_queued = 0; 287 if (td->io_ops->commit) 288 return td->io_ops->commit(td); 289 290 return 0; 291} 292 293int td_io_open_file(struct thread_data *td, struct fio_file *f) 294{ 295 if (td->io_ops->open_file(td, f)) { 296 if (td->error == EINVAL && td->o.odirect) 297 log_err("fio: destination does not support O_DIRECT\n"); 298 if (td->error == EMFILE) 299 log_err("fio: try reducing/setting openfiles (failed at %u of %u)\n", td->nr_open_files, td->o.nr_files); 300 301 return 1; 302 } 303 304 if (f->filetype == FIO_TYPE_PIPE) { 305 if (td_random(td)) { 306 log_err("fio: can't seek on pipes (no random io)\n"); 307 goto err; 308 } 309 } 310 311 f->last_free_lookup = 0; 312 f->last_completed_pos = 0; 313 f->last_pos = f->file_offset; 314 f->flags |= FIO_FILE_OPEN; 315 f->flags &= ~FIO_FILE_CLOSING; 316 317 if (td->io_ops->flags & FIO_DISKLESSIO) 318 goto done; 319 320 if (td->o.invalidate_cache && file_invalidate_cache(td, f)) 321 goto err; 322 323 if (td->o.fadvise_hint && 324 (f->filetype == FIO_TYPE_BD || f->filetype == FIO_TYPE_FILE)) { 325 326 int flags; 327 328 if (td_random(td)) 329 flags = POSIX_FADV_RANDOM; 330 else 331 flags = POSIX_FADV_SEQUENTIAL; 332 333 if (fadvise(f->fd, f->file_offset, f->io_size, flags) < 0) { 334 td_verror(td, errno, "fadvise"); 335 goto err; 336 } 337 } 338 339 if (f->file_map) 340 memset(f->file_map, 0, f->num_maps * sizeof(long)); 341 342done: 343 log_file(td, f, FIO_LOG_OPEN_FILE); 344 td->nr_open_files++; 345 get_file(f); 346 return 0; 347err: 348 if (td->io_ops->close_file) 349 td->io_ops->close_file(td, f); 350 return 1; 351} 352 353void td_io_close_file(struct thread_data *td, struct fio_file *f) 354{ 355 if (!(f->flags & FIO_FILE_CLOSING)) 356 log_file(td, f, FIO_LOG_CLOSE_FILE); 357 358 /* 359 * mark as closing, do real close when last io on it has completed 360 */ 361 f->flags |= FIO_FILE_CLOSING; 362 363 put_file(td, f); 364} 365