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