engines/rados.c

   1 /*
   2  *  Ceph Rados engine
   3  *
   4  * IO engine using Ceph's RADOS interface to test low-level performance of
   5  * Ceph OSDs.
   6  *
   7  */
   8
   9 #include <rados/librados.h>
  10 #include <pthread.h>
  11 #include "fio.h"
  12 #include "../optgroup.h"
  13
  14 struct fio_rados_iou {
  15         struct thread_data *td;
  16         struct io_u *io_u;
  17         rados_completion_t completion;
  18         rados_write_op_t write_op;
  19 };
  20
  21 struct rados_data {
  22         rados_t cluster;
  23         rados_ioctx_t io_ctx;
  24         char **objects;
  25         size_t object_count;
  26         struct io_u **aio_events;
  27         bool connected;
  28 };
  29
  30 /* fio configuration options read from the job file */
  31 struct rados_options {
  32         void *pad;
  33         char *cluster_name;
  34         char *pool_name;
  35         char *client_name;
  36         int busy_poll;
  37 };
  38
  39 static struct fio_option options[] = {
  40         {
  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,
  48         },
  49         {
  50                 .name     = "pool",
  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,
  57         },
  58         {
  59                 .name     = "clientname",
  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,
  66         },
  67         {
  68                 .name     = "busy_poll",
  69                 .lname    = "busy poll mode",
  70                 .type     = FIO_OPT_BOOL,
  71                 .help     = "Busy poll for completions instead of sleeping",
  72                 .off1     = offsetof(struct rados_options, busy_poll),
  73                 .def      = "0",
  74                 .category = FIO_OPT_C_ENGINE,
  75                 .group    = FIO_OPT_G_RBD,
  76         },
  77         {
  78                 .name     = NULL,
  79         },
  80 };
  81
  82 static int _fio_setup_rados_data(struct thread_data *td,
  83                                 struct rados_data **rados_data_ptr)
  84 {
  85         struct rados_data *rados;
  86
  87         if (td->io_ops_data)
  88                 return 0;
  89
  90         rados = calloc(1, sizeof(struct rados_data));
  91         if (!rados)
  92                 goto failed;
  93
  94         rados->connected = false;
  95
  96         rados->aio_events = calloc(td->o.iodepth, sizeof(struct io_u *));
  97         if (!rados->aio_events)
  98                 goto failed;
  99
 100         rados->object_count = td->o.nr_files;
 101         rados->objects = calloc(rados->object_count, sizeof(char*));
 102         if (!rados->objects)
 103                 goto failed;
 104
 105         *rados_data_ptr = rados;
 106         return 0;
 107
 108 failed:
 109         if (rados) {
 110                 rados->object_count = 0;
 111                 if (rados->aio_events)
 112                         free(rados->aio_events);
 113                 free(rados);
 114         }
 115         return 1;
 116 }
 117
 118 static void _fio_rados_rm_objects(struct rados_data *rados)
 119 {
 120         size_t i;
 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;
 126                 }
 127         }
 128 }
 129
 130 static int _fio_rados_connect(struct thread_data *td)
 131 {
 132         struct rados_data *rados = td->io_ops_data;
 133         struct rados_options *o = td->eo;
 134         int r;
 135         const uint64_t file_size =
 136                 td->o.size / (td->o.nr_files ? td->o.nr_files : 1u);
 137         struct fio_file *f;
 138         uint32_t i;
 139         size_t oname_len = 0;
 140
 141         if (o->cluster_name) {
 142                 char *client_name = NULL;
 143
 144                 /*
 145                 * If we specify cluser name, the rados_create2
 146                 * will not assume 'client.'. name is considered
 147                 * as a full type.id namestr
 148                 */
 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);
 155                         } else {
 156                                 client_name = o->client_name;
 157                         }
 158                 }
 159
 160                 r = rados_create2(&rados->cluster, o->cluster_name,
 161                         client_name, 0);
 162
 163                 if (client_name && !index(o->client_name, '.'))
 164                         free(client_name);
 165         } else
 166                 r = rados_create(&rados->cluster, o->client_name);
 167
 168         if (r < 0) {
 169                 log_err("rados_create failed.\n");
 170                 goto failed_early;
 171         }
 172
 173         r = rados_conf_read_file(rados->cluster, NULL);
 174         if (r < 0) {
 175                 log_err("rados_conf_read_file failed.\n");
 176                 goto failed_early;
 177         }
 178
 179         r = rados_connect(rados->cluster);
 180         if (r < 0) {
 181                 log_err("rados_connect failed.\n");
 182                 goto failed_early;
 183         }
 184
 185         r = rados_ioctx_create(rados->cluster, o->pool_name, &rados->io_ctx);
 186         if (r < 0) {
 187                 log_err("rados_ioctx_create failed.\n");
 188                 goto failed_shutdown;
 189         }
 190
 191         for (i = 0; i < rados->object_count; i++) {
 192                 f = td->files[i];
 193                 f->real_file_size = file_size;
 194                 f->engine_pos = i;
 195
 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);
 203                 if (r < 0) {
 204                         free(rados->objects[i]);
 205                         rados->objects[i] = NULL;
 206                         log_err("error creating object.\n");
 207                         goto failed_obj_create;
 208                 }
 209         }
 210
 211   return 0;
 212
 213 failed_obj_create:
 214         _fio_rados_rm_objects(rados);
 215         rados_ioctx_destroy(rados->io_ctx);
 216         rados->io_ctx = NULL;
 217 failed_shutdown:
 218         rados_shutdown(rados->cluster);
 219         rados->cluster = NULL;
 220 failed_early:
 221         return 1;
 222 }
 223
 224 static void _fio_rados_disconnect(struct rados_data *rados)
 225 {
 226         if (!rados)
 227                 return;
 228
 229         _fio_rados_rm_objects(rados);
 230
 231         if (rados->io_ctx) {
 232                 rados_ioctx_destroy(rados->io_ctx);
 233                 rados->io_ctx = NULL;
 234         }
 235
 236         if (rados->cluster) {
 237                 rados_shutdown(rados->cluster);
 238                 rados->cluster = NULL;
 239         }
 240 }
 241
 242 static void fio_rados_cleanup(struct thread_data *td)
 243 {
 244         struct rados_data *rados = td->io_ops_data;
 245
 246         if (rados) {
 247                 _fio_rados_disconnect(rados);
 248                 free(rados->objects);
 249                 free(rados->aio_events);
 250                 free(rados);
 251         }
 252 }
 253
 254 static int fio_rados_queue(struct thread_data *td, struct io_u *io_u)
 255 {
 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];
 259         int r = -1;
 260
 261         fio_ro_check(td, io_u);
 262
 263         if (io_u->ddir == DDIR_WRITE) {
 264                  r = rados_aio_create_completion(fri, NULL,
 265                         NULL, &fri->completion);
 266                 if (r < 0) {
 267                         log_err("rados_aio_create_completion failed.\n");
 268                         goto failed;
 269                 }
 270
 271                 r = rados_aio_write(rados->io_ctx, object, fri->completion,
 272                         io_u->xfer_buf, io_u->xfer_buflen, io_u->offset);
 273                 if (r < 0) {
 274                         log_err("rados_write failed.\n");
 275                         goto failed_comp;
 276                 }
 277                 return FIO_Q_QUEUED;
 278         } else if (io_u->ddir == DDIR_READ) {
 279                 r = rados_aio_create_completion(fri, NULL,
 280                         NULL, &fri->completion);
 281                 if (r < 0) {
 282                         log_err("rados_aio_create_completion failed.\n");
 283                         goto failed;
 284                 }
 285                 r = rados_aio_read(rados->io_ctx, object, fri->completion,
 286                         io_u->xfer_buf, io_u->xfer_buflen, io_u->offset);
 287                 if (r < 0) {
 288                         log_err("rados_aio_read failed.\n");
 289                         goto failed_comp;
 290                 }
 291                 return FIO_Q_QUEUED;
 292         } else if (io_u->ddir == DDIR_TRIM) {
 293                 r = rados_aio_create_completion(fri, NULL,
 294                         NULL , &fri->completion);
 295                 if (r < 0) {
 296                         log_err("rados_aio_create_completion failed.\n");
 297                         goto failed;
 298                 }
 299                 fri->write_op = rados_create_write_op();
 300                 if (fri->write_op == NULL) {
 301                         log_err("rados_create_write_op failed.\n");
 302                         goto failed_comp;
 303                 }
 304                 rados_write_op_zero(fri->write_op, io_u->offset,
 305                         io_u->xfer_buflen);
 306                 r = rados_aio_write_op_operate(fri->write_op, rados->io_ctx,
 307                         fri->completion, object, NULL, 0);
 308                 if (r < 0) {
 309                         log_err("rados_aio_write_op_operate failed.\n");
 310                         goto failed_write_op;
 311                 }
 312                 return FIO_Q_QUEUED;
 313          }
 314
 315         log_err("WARNING: Only DDIR_READ, DDIR_WRITE and DDIR_TRIM are supported!");
 316
 317 failed_write_op:
 318         rados_release_write_op(fri->write_op);
 319 failed_comp:
 320         rados_aio_release(fri->completion);
 321 failed:
 322         io_u->error = -r;
 323         td_verror(td, io_u->error, "xfer");
 324         return FIO_Q_COMPLETED;
 325 }
 326
 327 static struct io_u *fio_rados_event(struct thread_data *td, int event)
 328 {
 329         struct rados_data *rados = td->io_ops_data;
 330         return rados->aio_events[event];
 331 }
 332
 333 int fio_rados_getevents(struct thread_data *td, unsigned int min,
 334         unsigned int max, const struct timespec *t)
 335 {
 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;
 340         struct io_u *u;
 341         struct fio_rados_iou *fri;
 342         unsigned int i;
 343         rados_completion_t first_unfinished;
 344         int observed_new = 0;
 345
 346         /* loop through inflight ios until we find 'min' completions */
 347         do {
 348                 first_unfinished = NULL;
 349                 io_u_qiter(&td->io_u_all, u, i) {
 350                         if (!(u->flags & IO_U_F_FLIGHT))
 351                                 continue;
 352
 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;
 359                                         }
 360                                         rados_aio_release(fri->completion);
 361                                         fri->completion = NULL;
 362                                         rados->aio_events[events] = u;
 363                                         events++;
 364                                         observed_new = 1;
 365                                 } else if (first_unfinished == NULL) {
 366                                         first_unfinished = fri->completion;
 367                                 }
 368                         }
 369                         if (events >= max)
 370                                 break;
 371                 }
 372                 if (events >= min)
 373                         return events;
 374                 if (first_unfinished == NULL || busy_poll)
 375                         continue;
 376
 377                 if (!observed_new)
 378                         rados_aio_wait_for_complete(first_unfinished);
 379         } while (1);
 380   return events;
 381 }
 382
 383 static int fio_rados_setup(struct thread_data *td)
 384 {
 385         struct rados_data *rados = NULL;
 386         int r;
 387         /* allocate engine specific structure to deal with librados. */
 388         r = _fio_setup_rados_data(td, &rados);
 389         if (r) {
 390                 log_err("fio_setup_rados_data failed.\n");
 391                 goto cleanup;
 392         }
 393         td->io_ops_data = rados;
 394
 395         /* Force single process mode.
 396         */
 397         td->o.use_thread = 1;
 398
 399         /* connect in the main thread to determine to determine
 400         * the size of the given RADOS block device. And disconnect
 401         * later on.
 402         */
 403         r = _fio_rados_connect(td);
 404         if (r) {
 405                 log_err("fio_rados_connect failed.\n");
 406                 goto cleanup;
 407         }
 408         rados->connected = true;
 409
 410         return 0;
 411 cleanup:
 412         fio_rados_cleanup(td);
 413         return r;
 414 }
 415
 416 /* open/invalidate are noops. we set the FIO_DISKLESSIO flag in ioengine_ops to
 417    prevent fio from creating the files
 418 */
 419 static int fio_rados_open(struct thread_data *td, struct fio_file *f)
 420 {
 421         return 0;
 422 }
 423 static int fio_rados_invalidate(struct thread_data *td, struct fio_file *f)
 424 {
 425         return 0;
 426 }
 427
 428 static void fio_rados_io_u_free(struct thread_data *td, struct io_u *io_u)
 429 {
 430         struct fio_rados_iou *fri = io_u->engine_data;
 431
 432         if (fri) {
 433                 io_u->engine_data = NULL;
 434                 fri->td = NULL;
 435                 if (fri->completion)
 436                         rados_aio_release(fri->completion);
 437                 if (fri->write_op)
 438                         rados_release_write_op(fri->write_op);
 439                 free(fri);
 440         }
 441 }
 442
 443 static int fio_rados_io_u_init(struct thread_data *td, struct io_u *io_u)
 444 {
 445         struct fio_rados_iou *fri;
 446         fri = calloc(1, sizeof(*fri));
 447         fri->io_u = io_u;
 448         fri->td = td;
 449         io_u->engine_data = fri;
 450         return 0;
 451 }
 452
 453 /* ioengine_ops for get_ioengine() */
 454 static struct ioengine_ops ioengine = {
 455         .name = "rados",
 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,
 465         .options                = options,
 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),
 469 };
 470
 471 static void fio_init fio_rados_register(void)
 472 {
 473         register_ioengine(&ioengine);
 474 }
 475
 476 static void fio_exit fio_rados_unregister(void)
 477 {
 478         unregister_ioengine(&ioengine);
 479 }