4 * IO engine using Ceph's RADOS interface to test low-level performance of
9 #include <rados/librados.h>
12 #include "../optgroup.h"
14 struct fio_rados_iou {
15 struct thread_data *td;
17 rados_completion_t completion;
18 rados_write_op_t write_op;
26 struct io_u **aio_events;
30 /* fio configuration options read from the job file */
31 struct rados_options {
39 static struct fio_option options[] = {
41 .name = "clustername",
42 .lname = "ceph cluster name",
43 .type = FIO_OPT_STR_STORE,
44 .help = "Cluster name for ceph",
45 .off1 = offsetof(struct rados_options, cluster_name),
46 .category = FIO_OPT_C_ENGINE,
47 .group = FIO_OPT_G_RBD,
51 .lname = "pool name to use",
52 .type = FIO_OPT_STR_STORE,
53 .help = "Ceph pool name to benchmark against",
54 .off1 = offsetof(struct rados_options, pool_name),
55 .category = FIO_OPT_C_ENGINE,
56 .group = FIO_OPT_G_RBD,
60 .lname = "rados engine clientname",
61 .type = FIO_OPT_STR_STORE,
62 .help = "Name of the ceph client to access RADOS engine",
63 .off1 = offsetof(struct rados_options, client_name),
64 .category = FIO_OPT_C_ENGINE,
65 .group = FIO_OPT_G_RBD,
69 .lname = "busy poll mode",
71 .help = "Busy poll for completions instead of sleeping",
72 .off1 = offsetof(struct rados_options, busy_poll),
74 .category = FIO_OPT_C_ENGINE,
75 .group = FIO_OPT_G_RBD,
82 static int _fio_setup_rados_data(struct thread_data *td,
83 struct rados_data **rados_data_ptr)
85 struct rados_data *rados;
90 rados = calloc(1, sizeof(struct rados_data));
94 rados->connected = false;
96 rados->aio_events = calloc(td->o.iodepth, sizeof(struct io_u *));
97 if (!rados->aio_events)
100 rados->object_count = td->o.nr_files;
101 rados->objects = calloc(rados->object_count, sizeof(char*));
105 *rados_data_ptr = rados;
110 rados->object_count = 0;
111 if (rados->aio_events)
112 free(rados->aio_events);
118 static void _fio_rados_rm_objects(struct rados_data *rados)
121 for (i = 0; i < rados->object_count; ++i) {
122 if (rados->objects[i]) {
123 rados_remove(rados->io_ctx, rados->objects[i]);
124 free(rados->objects[i]);
125 rados->objects[i] = NULL;
130 static int _fio_rados_connect(struct thread_data *td)
132 struct rados_data *rados = td->io_ops_data;
133 struct rados_options *o = td->eo;
135 const uint64_t file_size =
136 td->o.size / (td->o.nr_files ? td->o.nr_files : 1u);
139 size_t oname_len = 0;
141 if (o->cluster_name) {
142 char *client_name = NULL;
145 * If we specify cluser name, the rados_create2
146 * will not assume 'client.'. name is considered
147 * as a full type.id namestr
149 if (o->client_name) {
150 if (!index(o->client_name, '.')) {
151 client_name = calloc(1, strlen("client.") +
152 strlen(o->client_name) + 1);
153 strcat(client_name, "client.");
154 strcat(client_name, o->client_name);
156 client_name = o->client_name;
160 r = rados_create2(&rados->cluster, o->cluster_name,
163 if (client_name && !index(o->client_name, '.'))
166 r = rados_create(&rados->cluster, o->client_name);
169 log_err("rados_create failed.\n");
173 r = rados_conf_read_file(rados->cluster, NULL);
175 log_err("rados_conf_read_file failed.\n");
179 r = rados_connect(rados->cluster);
181 log_err("rados_connect failed.\n");
185 r = rados_ioctx_create(rados->cluster, o->pool_name, &rados->io_ctx);
187 log_err("rados_ioctx_create failed.\n");
188 goto failed_shutdown;
191 for (i = 0; i < rados->object_count; i++) {
193 f->real_file_size = file_size;
196 oname_len = strlen(f->file_name) + 32;
197 rados->objects[i] = malloc(oname_len);
198 /* vary objects for different jobs */
199 snprintf(rados->objects[i], oname_len - 1,
200 "fio_rados_bench.%s.%x",
201 f->file_name, td->thread_number);
202 r = rados_write(rados->io_ctx, rados->objects[i], "", 0, 0);
204 free(rados->objects[i]);
205 rados->objects[i] = NULL;
206 log_err("error creating object.\n");
207 goto failed_obj_create;
214 _fio_rados_rm_objects(rados);
215 rados_ioctx_destroy(rados->io_ctx);
216 rados->io_ctx = NULL;
218 rados_shutdown(rados->cluster);
219 rados->cluster = NULL;
224 static void _fio_rados_disconnect(struct rados_data *rados)
229 _fio_rados_rm_objects(rados);
232 rados_ioctx_destroy(rados->io_ctx);
233 rados->io_ctx = NULL;
236 if (rados->cluster) {
237 rados_shutdown(rados->cluster);
238 rados->cluster = NULL;
242 static void fio_rados_cleanup(struct thread_data *td)
244 struct rados_data *rados = td->io_ops_data;
247 _fio_rados_disconnect(rados);
248 free(rados->objects);
249 free(rados->aio_events);
254 static enum fio_q_status fio_rados_queue(struct thread_data *td,
257 struct rados_data *rados = td->io_ops_data;
258 struct fio_rados_iou *fri = io_u->engine_data;
259 char *object = rados->objects[io_u->file->engine_pos];
262 fio_ro_check(td, io_u);
264 if (io_u->ddir == DDIR_WRITE) {
265 r = rados_aio_create_completion(fri, NULL,
266 NULL, &fri->completion);
268 log_err("rados_aio_create_completion failed.\n");
272 r = rados_aio_write(rados->io_ctx, object, fri->completion,
273 io_u->xfer_buf, io_u->xfer_buflen, io_u->offset);
275 log_err("rados_write failed.\n");
279 } else if (io_u->ddir == DDIR_READ) {
280 r = rados_aio_create_completion(fri, NULL,
281 NULL, &fri->completion);
283 log_err("rados_aio_create_completion failed.\n");
286 r = rados_aio_read(rados->io_ctx, object, fri->completion,
287 io_u->xfer_buf, io_u->xfer_buflen, io_u->offset);
289 log_err("rados_aio_read failed.\n");
293 } else if (io_u->ddir == DDIR_TRIM) {
294 r = rados_aio_create_completion(fri, NULL,
295 NULL , &fri->completion);
297 log_err("rados_aio_create_completion failed.\n");
300 fri->write_op = rados_create_write_op();
301 if (fri->write_op == NULL) {
302 log_err("rados_create_write_op failed.\n");
305 rados_write_op_zero(fri->write_op, io_u->offset,
307 r = rados_aio_write_op_operate(fri->write_op, rados->io_ctx,
308 fri->completion, object, NULL, 0);
310 log_err("rados_aio_write_op_operate failed.\n");
311 goto failed_write_op;
316 log_err("WARNING: Only DDIR_READ, DDIR_WRITE and DDIR_TRIM are supported!");
319 rados_release_write_op(fri->write_op);
321 rados_aio_release(fri->completion);
324 td_verror(td, io_u->error, "xfer");
325 return FIO_Q_COMPLETED;
328 static struct io_u *fio_rados_event(struct thread_data *td, int event)
330 struct rados_data *rados = td->io_ops_data;
331 return rados->aio_events[event];
334 int fio_rados_getevents(struct thread_data *td, unsigned int min,
335 unsigned int max, const struct timespec *t)
337 struct rados_data *rados = td->io_ops_data;
338 struct rados_options *o = td->eo;
339 int busy_poll = o->busy_poll;
340 unsigned int events = 0;
342 struct fio_rados_iou *fri;
344 rados_completion_t first_unfinished;
345 int observed_new = 0;
347 /* loop through inflight ios until we find 'min' completions */
349 first_unfinished = NULL;
350 io_u_qiter(&td->io_u_all, u, i) {
351 if (!(u->flags & IO_U_F_FLIGHT))
354 fri = u->engine_data;
355 if (fri->completion) {
356 if (rados_aio_is_complete(fri->completion)) {
357 if (fri->write_op != NULL) {
358 rados_release_write_op(fri->write_op);
359 fri->write_op = NULL;
361 rados_aio_release(fri->completion);
362 fri->completion = NULL;
363 rados->aio_events[events] = u;
366 } else if (first_unfinished == NULL) {
367 first_unfinished = fri->completion;
375 if (first_unfinished == NULL || busy_poll)
379 rados_aio_wait_for_complete(first_unfinished);
384 static int fio_rados_setup(struct thread_data *td)
386 struct rados_data *rados = NULL;
388 /* allocate engine specific structure to deal with librados. */
389 r = _fio_setup_rados_data(td, &rados);
391 log_err("fio_setup_rados_data failed.\n");
394 td->io_ops_data = rados;
396 /* Force single process mode.
398 td->o.use_thread = 1;
400 /* connect in the main thread to determine to determine
401 * the size of the given RADOS block device. And disconnect
404 r = _fio_rados_connect(td);
406 log_err("fio_rados_connect failed.\n");
409 rados->connected = true;
413 fio_rados_cleanup(td);
417 /* open/invalidate are noops. we set the FIO_DISKLESSIO flag in ioengine_ops to
418 prevent fio from creating the files
420 static int fio_rados_open(struct thread_data *td, struct fio_file *f)
424 static int fio_rados_invalidate(struct thread_data *td, struct fio_file *f)
429 static void fio_rados_io_u_free(struct thread_data *td, struct io_u *io_u)
431 struct fio_rados_iou *fri = io_u->engine_data;
434 io_u->engine_data = NULL;
437 rados_aio_release(fri->completion);
439 rados_release_write_op(fri->write_op);
444 static int fio_rados_io_u_init(struct thread_data *td, struct io_u *io_u)
446 struct fio_rados_iou *fri;
447 fri = calloc(1, sizeof(*fri));
450 io_u->engine_data = fri;
454 /* ioengine_ops for get_ioengine() */
455 static struct ioengine_ops ioengine = {
457 .version = FIO_IOOPS_VERSION,
458 .flags = FIO_DISKLESSIO,
459 .setup = fio_rados_setup,
460 .queue = fio_rados_queue,
461 .getevents = fio_rados_getevents,
462 .event = fio_rados_event,
463 .cleanup = fio_rados_cleanup,
464 .open_file = fio_rados_open,
465 .invalidate = fio_rados_invalidate,
467 .io_u_init = fio_rados_io_u_init,
468 .io_u_free = fio_rados_io_u_free,
469 .option_struct_size = sizeof(struct rados_options),
472 static void fio_init fio_rados_register(void)
474 register_ioengine(&ioengine);
477 static void fio_exit fio_rados_unregister(void)
479 unregister_ioengine(&ioengine);