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 int fio_rados_queue(struct thread_data *td, struct io_u *io_u)
256 struct rados_data *rados = td->io_ops_data;
257 struct fio_rados_iou *fri = io_u->engine_data;
258 char *object = rados->objects[io_u->file->engine_pos];
261 fio_ro_check(td, io_u);
263 if (io_u->ddir == DDIR_WRITE) {
264 r = rados_aio_create_completion(fri, NULL,
265 NULL, &fri->completion);
267 log_err("rados_aio_create_completion failed.\n");
271 r = rados_aio_write(rados->io_ctx, object, fri->completion,
272 io_u->xfer_buf, io_u->xfer_buflen, io_u->offset);
274 log_err("rados_write failed.\n");
278 } else if (io_u->ddir == DDIR_READ) {
279 r = rados_aio_create_completion(fri, NULL,
280 NULL, &fri->completion);
282 log_err("rados_aio_create_completion failed.\n");
285 r = rados_aio_read(rados->io_ctx, object, fri->completion,
286 io_u->xfer_buf, io_u->xfer_buflen, io_u->offset);
288 log_err("rados_aio_read failed.\n");
292 } else if (io_u->ddir == DDIR_TRIM) {
293 r = rados_aio_create_completion(fri, NULL,
294 NULL , &fri->completion);
296 log_err("rados_aio_create_completion failed.\n");
299 fri->write_op = rados_create_write_op();
300 if (fri->write_op == NULL) {
301 log_err("rados_create_write_op failed.\n");
304 rados_write_op_zero(fri->write_op, io_u->offset,
306 r = rados_aio_write_op_operate(fri->write_op, rados->io_ctx,
307 fri->completion, object, NULL, 0);
309 log_err("rados_aio_write_op_operate failed.\n");
310 goto failed_write_op;
315 log_err("WARNING: Only DDIR_READ, DDIR_WRITE and DDIR_TRIM are supported!");
318 rados_release_write_op(fri->write_op);
320 rados_aio_release(fri->completion);
323 td_verror(td, io_u->error, "xfer");
324 return FIO_Q_COMPLETED;
327 static struct io_u *fio_rados_event(struct thread_data *td, int event)
329 struct rados_data *rados = td->io_ops_data;
330 return rados->aio_events[event];
333 int fio_rados_getevents(struct thread_data *td, unsigned int min,
334 unsigned int max, const struct timespec *t)
336 struct rados_data *rados = td->io_ops_data;
337 struct rados_options *o = td->eo;
338 int busy_poll = o->busy_poll;
339 unsigned int events = 0;
341 struct fio_rados_iou *fri;
343 rados_completion_t first_unfinished;
344 int observed_new = 0;
346 /* loop through inflight ios until we find 'min' completions */
348 first_unfinished = NULL;
349 io_u_qiter(&td->io_u_all, u, i) {
350 if (!(u->flags & IO_U_F_FLIGHT))
353 fri = u->engine_data;
354 if (fri->completion) {
355 if (rados_aio_is_complete(fri->completion)) {
356 if (fri->write_op != NULL) {
357 rados_release_write_op(fri->write_op);
358 fri->write_op = NULL;
360 rados_aio_release(fri->completion);
361 fri->completion = NULL;
362 rados->aio_events[events] = u;
365 } else if (first_unfinished == NULL) {
366 first_unfinished = fri->completion;
374 if (first_unfinished == NULL || busy_poll)
378 rados_aio_wait_for_complete(first_unfinished);
383 static int fio_rados_setup(struct thread_data *td)
385 struct rados_data *rados = NULL;
387 /* allocate engine specific structure to deal with librados. */
388 r = _fio_setup_rados_data(td, &rados);
390 log_err("fio_setup_rados_data failed.\n");
393 td->io_ops_data = rados;
395 /* Force single process mode.
397 td->o.use_thread = 1;
399 /* connect in the main thread to determine to determine
400 * the size of the given RADOS block device. And disconnect
403 r = _fio_rados_connect(td);
405 log_err("fio_rados_connect failed.\n");
408 rados->connected = true;
412 fio_rados_cleanup(td);
416 /* open/invalidate are noops. we set the FIO_DISKLESSIO flag in ioengine_ops to
417 prevent fio from creating the files
419 static int fio_rados_open(struct thread_data *td, struct fio_file *f)
423 static int fio_rados_invalidate(struct thread_data *td, struct fio_file *f)
428 static void fio_rados_io_u_free(struct thread_data *td, struct io_u *io_u)
430 struct fio_rados_iou *fri = io_u->engine_data;
433 io_u->engine_data = NULL;
436 rados_aio_release(fri->completion);
438 rados_release_write_op(fri->write_op);
443 static int fio_rados_io_u_init(struct thread_data *td, struct io_u *io_u)
445 struct fio_rados_iou *fri;
446 fri = calloc(1, sizeof(*fri));
449 io_u->engine_data = fri;
453 /* ioengine_ops for get_ioengine() */
454 static struct ioengine_ops ioengine = {
456 .version = FIO_IOOPS_VERSION,
457 .flags = FIO_DISKLESSIO,
458 .setup = fio_rados_setup,
459 .queue = fio_rados_queue,
460 .getevents = fio_rados_getevents,
461 .event = fio_rados_event,
462 .cleanup = fio_rados_cleanup,
463 .open_file = fio_rados_open,
464 .invalidate = fio_rados_invalidate,
466 .io_u_init = fio_rados_io_u_init,
467 .io_u_free = fio_rados_io_u_free,
468 .option_struct_size = sizeof(struct rados_options),
471 static void fio_init fio_rados_register(void)
473 register_ioengine(&ioengine);
476 static void fio_exit fio_rados_unregister(void)
478 unregister_ioengine(&ioengine);