ioengines.c revision 6977bcd0e4ee3faa7ffd8f208e4031bdf906ed88
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 166int td_io_prep(struct thread_data *td, struct io_u *io_u) 167{ 168 dprint_io_u(io_u, "prep"); 169 fio_ro_check(td, io_u); 170 171 if (td->io_ops->prep) { 172 int ret = td->io_ops->prep(td, io_u); 173 174 dprint(FD_IO, "->prep(%p)=%d\n", io_u, ret); 175 return ret; 176 } 177 178 return 0; 179} 180 181int td_io_getevents(struct thread_data *td, unsigned int min, unsigned int max, 182 struct timespec *t) 183{ 184 int r = 0; 185 186 if (min > 0 && td->io_ops->commit) { 187 r = td->io_ops->commit(td); 188 if (r < 0) 189 goto out; 190 } 191 192 r = 0; 193 if (td->io_ops->getevents) 194 r = td->io_ops->getevents(td, min, max, t); 195out: 196 dprint(FD_IO, "getevents: %d\n", r); 197 return r; 198} 199 200int td_io_queue(struct thread_data *td, struct io_u *io_u) 201{ 202 int ret; 203 204 dprint_io_u(io_u, "queue"); 205 fio_ro_check(td, io_u); 206 207 assert((io_u->flags & IO_U_F_FLIGHT) == 0); 208 io_u->flags |= IO_U_F_FLIGHT; 209 210 assert(io_u->file->flags & FIO_FILE_OPEN); 211 212 io_u->error = 0; 213 io_u->resid = 0; 214 215 if (td->io_ops->flags & FIO_SYNCIO) { 216 fio_gettime(&io_u->issue_time, NULL); 217 memcpy(&td->last_issue, &io_u->issue_time, sizeof(struct timeval)); 218 219 /* 220 * for a sync engine, set the timeout upfront 221 */ 222 if (mtime_since(&td->timeout_end, &io_u->issue_time) < IO_U_TIMEOUT) 223 io_u_set_timeout(td); 224 } 225 226 if (io_u->ddir != DDIR_SYNC) 227 td->io_issues[io_u->ddir]++; 228 229 ret = td->io_ops->queue(td, io_u); 230 231 if (ret != FIO_Q_BUSY) 232 io_u_mark_depth(td, io_u); 233 234 if (ret == FIO_Q_QUEUED) { 235 int r; 236 237 td->io_u_queued++; 238 if (td->io_u_queued > td->o.iodepth_batch) { 239 r = td_io_commit(td); 240 if (r < 0) 241 return r; 242 } 243 } 244 245 if ((td->io_ops->flags & FIO_SYNCIO) == 0) { 246 fio_gettime(&io_u->issue_time, NULL); 247 memcpy(&td->last_issue, &io_u->issue_time, sizeof(struct timeval)); 248 249 /* 250 * async engine, set the timeout here 251 */ 252 if (ret == FIO_Q_QUEUED && 253 mtime_since(&td->timeout_end, &io_u->issue_time) < IO_U_TIMEOUT) 254 io_u_set_timeout(td); 255 } 256 257 return ret; 258} 259 260int td_io_init(struct thread_data *td) 261{ 262 int ret = 0; 263 264 if (td->io_ops->init) { 265 ret = td->io_ops->init(td); 266 if (ret && td->o.iodepth > 1) 267 log_err("fio: io engine init failed. Perhaps try reducing io depth?\n"); 268 } 269 270 return ret; 271} 272 273int td_io_commit(struct thread_data *td) 274{ 275 dprint(FD_IO, "calling ->commit(), depth %d\n", td->cur_depth); 276 277 if (!td->cur_depth) 278 return 0; 279 280 td->io_u_queued = 0; 281 if (td->io_ops->commit) 282 return td->io_ops->commit(td); 283 284 return 0; 285} 286 287int td_io_open_file(struct thread_data *td, struct fio_file *f) 288{ 289 if (td->io_ops->open_file(td, f)) { 290 if (td->error == EINVAL && td->o.odirect) 291 log_err("fio: destination does not support O_DIRECT\n"); 292 if (td->error == EMFILE) 293 log_err("fio: try reducing/setting openfiles (failed at %u of %u)\n", td->nr_open_files, td->o.nr_files); 294 295 return 1; 296 } 297 298 if (f->filetype == FIO_TYPE_PIPE) { 299 if (td_random(td)) { 300 log_err("fio: can't seek on pipes (no random io)\n"); 301 goto err; 302 } 303 } 304 305 f->last_free_lookup = 0; 306 f->last_completed_pos = 0; 307 f->last_pos = f->file_offset; 308 f->flags |= FIO_FILE_OPEN; 309 f->flags &= ~FIO_FILE_CLOSING; 310 311 if (td->io_ops->flags & FIO_DISKLESSIO) 312 goto done; 313 314 if (td->o.invalidate_cache && file_invalidate_cache(td, f)) 315 goto err; 316 317 if (td->o.fadvise_hint && 318 (f->filetype == FIO_TYPE_BD || f->filetype == FIO_TYPE_FILE)) { 319 320 int flags; 321 322 if (td_random(td)) 323 flags = POSIX_FADV_RANDOM; 324 else 325 flags = POSIX_FADV_SEQUENTIAL; 326 327 if (fadvise(f->fd, f->file_offset, f->io_size, flags) < 0) { 328 td_verror(td, errno, "fadvise"); 329 goto err; 330 } 331 } 332 333 if (f->file_map) 334 memset(f->file_map, 0, f->num_maps * sizeof(long)); 335 336done: 337 log_file(td, f, FIO_LOG_OPEN_FILE); 338 td->nr_open_files++; 339 get_file(f); 340 return 0; 341err: 342 if (td->io_ops->close_file) 343 td->io_ops->close_file(td, f); 344 return 1; 345} 346 347int td_io_close_file(struct thread_data *td, struct fio_file *f) 348{ 349 if (!(f->flags & FIO_FILE_CLOSING)) 350 log_file(td, f, FIO_LOG_CLOSE_FILE); 351 352 /* 353 * mark as closing, do real close when last io on it has completed 354 */ 355 f->flags |= FIO_FILE_CLOSING; 356 357 return put_file(td, f); 358} 359