ceph/src/libradosstriper/libradosstriper.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3 /*
   4  * Ceph - scalable distributed file system
   5  *
   6  * Copyright (C) 2014 Sebastien Ponce <sebastien.ponce@cern.ch>
   7  *
   8  * This is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License version 2.1, as published by the Free Software
  11  * Foundation.  See file COPYING.
  12  *
  13  */
  14
  15 #include <errno.h>
  16
  17 #include "libradosstriper/RadosStriperImpl.h"
  18 #include "libradosstriper/MultiAioCompletionImpl.h"
  19
  20 #include "include/types.h"
  21
  22 #include "include/radosstriper/libradosstriper.h"
  23 #include "include/radosstriper/libradosstriper.hpp"
  24 #include "librados/RadosXattrIter.h"
  25
  26 /*
  27  * This file implements the rados striper API.
  28  * There are 2 flavours of it :
  29  *   - the C API, found in include/rados/libradosstriper.h
  30  *   - the C++ API, found in include/rados/libradosstriper.hpp
  31  */
  32
  33 ///////////////////////////// C++ API //////////////////////////////
  34
  35 libradosstriper::MultiAioCompletion::~MultiAioCompletion()
  36 {
  37   delete pc;
  38 }
  39
  40 int libradosstriper::MultiAioCompletion::set_complete_callback
  41 (void *cb_arg, rados_callback_t cb)
  42 {
  43   MultiAioCompletionImpl *c = (MultiAioCompletionImpl *)pc;
  44   return c->set_complete_callback(cb_arg, cb);
  45 }
  46
  47 int libradosstriper::MultiAioCompletion::set_safe_callback
  48 (void *cb_arg, rados_callback_t cb)
  49 {
  50   MultiAioCompletionImpl *c = (MultiAioCompletionImpl *)pc;
  51   return c->set_safe_callback(cb_arg, cb);
  52 }
  53
  54 void libradosstriper::MultiAioCompletion::wait_for_complete()
  55 {
  56   MultiAioCompletionImpl *c = (MultiAioCompletionImpl *)pc;
  57   c->wait_for_complete();
  58 }
  59
  60 void libradosstriper::MultiAioCompletion::wait_for_safe()
  61 {
  62   MultiAioCompletionImpl *c = (MultiAioCompletionImpl *)pc;
  63   c->wait_for_safe();
  64 }
  65
  66 bool libradosstriper::MultiAioCompletion::is_complete()
  67 {
  68   MultiAioCompletionImpl *c = (MultiAioCompletionImpl *)pc;
  69   return c->is_complete();
  70 }
  71
  72 bool libradosstriper::MultiAioCompletion::is_safe()
  73 {
  74   MultiAioCompletionImpl *c = (MultiAioCompletionImpl *)pc;
  75   return c->is_safe();
  76 }
  77
  78 void libradosstriper::MultiAioCompletion::wait_for_complete_and_cb()
  79 {
  80   MultiAioCompletionImpl *c = (MultiAioCompletionImpl *)pc;
  81   c->wait_for_complete_and_cb();
  82 }
  83
  84 void libradosstriper::MultiAioCompletion::MultiAioCompletion::wait_for_safe_and_cb()
  85 {
  86   MultiAioCompletionImpl *c = (MultiAioCompletionImpl *)pc;
  87   c->wait_for_safe_and_cb();
  88 }
  89
  90 bool libradosstriper::MultiAioCompletion::is_complete_and_cb()
  91 {
  92   MultiAioCompletionImpl *c = (MultiAioCompletionImpl *)pc;
  93   return c->is_complete_and_cb();
  94 }
  95
  96 bool libradosstriper::MultiAioCompletion::is_safe_and_cb()
  97 {
  98   MultiAioCompletionImpl *c = (MultiAioCompletionImpl *)pc;
  99   return c->is_safe_and_cb();
 100 }
 101
 102 int libradosstriper::MultiAioCompletion::get_return_value()
 103 {
 104   MultiAioCompletionImpl *c = (MultiAioCompletionImpl *)pc;
 105   return c->get_return_value();
 106 }
 107
 108 void libradosstriper::MultiAioCompletion::release()
 109 {
 110   MultiAioCompletionImpl *c = (MultiAioCompletionImpl *)pc;
 111   c->put();
 112   delete this;
 113 }
 114
 115 libradosstriper::RadosStriper::RadosStriper() :
 116   rados_striper_impl(0)
 117 {
 118 }
 119
 120 void libradosstriper::RadosStriper::to_rados_striper_t(RadosStriper &striper, rados_striper_t *s)
 121 {
 122   *s = (rados_striper_t)striper.rados_striper_impl;
 123   striper.rados_striper_impl->get();
 124 }
 125
 126 libradosstriper::RadosStriper::RadosStriper(const RadosStriper& rs)
 127 {
 128   rados_striper_impl = rs.rados_striper_impl;
 129   if (rados_striper_impl) {
 130     rados_striper_impl->get();
 131   }
 132 }
 133
 134 libradosstriper::RadosStriper& libradosstriper::RadosStriper::operator=(const RadosStriper& rs)
 135 {
 136   if (rados_striper_impl)
 137     rados_striper_impl->put();
 138   rados_striper_impl = rs.rados_striper_impl;
 139   rados_striper_impl->get();
 140   return *this;
 141 }
 142
 143 libradosstriper::RadosStriper::~RadosStriper()
 144 {
 145   if (rados_striper_impl)
 146     rados_striper_impl->put();
 147   rados_striper_impl = 0;
 148 }
 149
 150 int libradosstriper::RadosStriper::striper_create(librados::IoCtx& ioctx,
 151                                                   RadosStriper *striper)
 152 {
 153   try {
 154     striper->rados_striper_impl = new libradosstriper::RadosStriperImpl(ioctx, ioctx.io_ctx_impl);
 155     striper->rados_striper_impl->get();
 156   } catch (int rc) {
 157     return rc;
 158   }
 159   return 0;
 160 }
 161
 162 int libradosstriper::RadosStriper::set_object_layout_stripe_unit
 163 (unsigned int stripe_unit)
 164 {
 165   return rados_striper_impl->setObjectLayoutStripeUnit(stripe_unit);
 166 }
 167
 168 int libradosstriper::RadosStriper::set_object_layout_stripe_count
 169 (unsigned int stripe_count)
 170 {
 171   return rados_striper_impl->setObjectLayoutStripeCount(stripe_count);
 172 }
 173
 174 int libradosstriper::RadosStriper::set_object_layout_object_size
 175 (unsigned int object_size)
 176 {
 177   return rados_striper_impl->setObjectLayoutObjectSize(object_size);
 178 }
 179
 180 int libradosstriper::RadosStriper::getxattr(const std::string& oid, const char *name, bufferlist& bl)
 181 {
 182   return rados_striper_impl->getxattr(oid, name, bl);
 183 }
 184
 185 int libradosstriper::RadosStriper::setxattr(const std::string& oid, const char *name, bufferlist& bl)
 186 {
 187   return rados_striper_impl->setxattr(oid, name, bl);
 188 }
 189
 190 int libradosstriper::RadosStriper::rmxattr(const std::string& oid, const char *name)
 191 {
 192   return rados_striper_impl->rmxattr(oid, name);
 193 }
 194
 195 int libradosstriper::RadosStriper::getxattrs(const std::string& oid,
 196                                              std::map<std::string, bufferlist>& attrset)
 197 {
 198   return rados_striper_impl->getxattrs(oid, attrset);
 199 }
 200
 201 int libradosstriper::RadosStriper::write(const std::string& soid,
 202                                          const bufferlist& bl,
 203                                          size_t len,
 204                                          uint64_t off)
 205 {
 206   return rados_striper_impl->write(soid, bl, len, off);
 207 }
 208
 209 int libradosstriper::RadosStriper::write_full(const std::string& soid,
 210                                               const bufferlist& bl)
 211 {
 212   return rados_striper_impl->write_full(soid, bl);
 213 }
 214
 215 int libradosstriper::RadosStriper::append(const std::string& soid,
 216                                           const bufferlist& bl,
 217                                           size_t len)
 218 {
 219   return rados_striper_impl->append(soid, bl, len);
 220 }
 221
 222 int libradosstriper::RadosStriper::aio_write(const std::string& soid,
 223                                              librados::AioCompletion *c,
 224                                              const bufferlist& bl,
 225                                              size_t len,
 226                                              uint64_t off)
 227 {
 228   return rados_striper_impl->aio_write(soid, c->pc, bl, len, off);
 229 }
 230
 231 int libradosstriper::RadosStriper::aio_write_full(const std::string& soid,
 232                                                   librados::AioCompletion *c,
 233                                                   const bufferlist& bl)
 234 {
 235   return rados_striper_impl->aio_write_full(soid, c->pc, bl);
 236 }
 237
 238 int libradosstriper::RadosStriper::aio_append(const std::string& soid,
 239                                               librados::AioCompletion *c,
 240                                               const bufferlist& bl,
 241                                               size_t len)
 242 {
 243   return rados_striper_impl->aio_append(soid, c->pc, bl, len);
 244 }
 245
 246 int libradosstriper::RadosStriper::read(const std::string& soid,
 247                                         bufferlist* bl,
 248                                         size_t len,
 249                                         uint64_t off)
 250 {
 251   bl->clear();
 252   bl->push_back(buffer::create(len));
 253   return rados_striper_impl->read(soid, bl, len, off);
 254 }
 255
 256 int libradosstriper::RadosStriper::aio_read(const std::string& soid,
 257                                             librados::AioCompletion *c,
 258                                             bufferlist* bl,
 259                                             size_t len,
 260                                             uint64_t off)
 261 {
 262   bl->clear();
 263   bl->push_back(buffer::create(len));
 264   return rados_striper_impl->aio_read(soid, c->pc, bl, len, off);
 265 }
 266
 267 int libradosstriper::RadosStriper::stat(const std::string& soid, uint64_t *psize, time_t *pmtime)
 268 {
 269   return rados_striper_impl->stat(soid, psize, pmtime);
 270 }
 271
 272 int libradosstriper::RadosStriper::aio_stat(const std::string& soid,
 273                                             librados::AioCompletion *c,
 274                                             uint64_t *psize,
 275                                             time_t *pmtime)
 276 {
 277   return rados_striper_impl->aio_stat(soid, c->pc, psize, pmtime);
 278 }
 279
 280 int libradosstriper::RadosStriper::stat2(const std::string& soid, uint64_t *psize, struct timespec *pts)
 281 {
 282   return rados_striper_impl->stat2(soid, psize, pts);
 283 }
 284
 285 int libradosstriper::RadosStriper::aio_stat2(const std::string& soid,
 286                                             librados::AioCompletion *c,
 287                                             uint64_t *psize,
 288                                             struct timespec *pts)
 289 {
 290   return rados_striper_impl->aio_stat2(soid, c->pc, psize, pts);
 291 }
 292
 293 int libradosstriper::RadosStriper::remove(const std::string& soid)
 294 {
 295   return rados_striper_impl->remove(soid);
 296 }
 297
 298 int libradosstriper::RadosStriper::aio_remove(const std::string& soid,
 299                                               librados::AioCompletion *c)
 300 {
 301   return rados_striper_impl->aio_remove(soid, c->pc);
 302 }
 303
 304 int libradosstriper::RadosStriper::remove(const std::string& soid, int flags)
 305 {
 306   return rados_striper_impl->remove(soid, flags);
 307 }
 308
 309 int libradosstriper::RadosStriper::aio_remove(const std::string& soid,
 310                                               librados::AioCompletion *c,
 311                                               int flags)
 312 {
 313   return rados_striper_impl->aio_remove(soid, c->pc, flags);
 314 }
 315
 316 int libradosstriper::RadosStriper::trunc(const std::string& soid, uint64_t size)
 317 {
 318   return rados_striper_impl->trunc(soid, size);
 319 }
 320
 321 int libradosstriper::RadosStriper::aio_flush()
 322 {
 323   return rados_striper_impl->aio_flush();
 324 }
 325
 326 libradosstriper::MultiAioCompletion* libradosstriper::RadosStriper::multi_aio_create_completion()
 327 {
 328   MultiAioCompletionImpl *c = new MultiAioCompletionImpl;
 329   return new MultiAioCompletion(c);
 330 }
 331
 332 libradosstriper::MultiAioCompletion*
 333 libradosstriper::RadosStriper::multi_aio_create_completion(void *cb_arg,
 334                                                            librados::callback_t cb_complete,
 335                                                            librados::callback_t cb_safe)
 336 {
 337   MultiAioCompletionImpl *c;
 338   int r = rados_striper_multi_aio_create_completion(cb_arg, cb_complete, cb_safe, (void**)&c);
 339   assert(r == 0);
 340   return new MultiAioCompletion(c);
 341 }
 342
 343 ///////////////////////////// C API //////////////////////////////
 344
 345 extern "C" int rados_striper_create(rados_ioctx_t ioctx,
 346                                     rados_striper_t *striper)
 347 {
 348   librados::IoCtx ctx;
 349   librados::IoCtx::from_rados_ioctx_t(ioctx, ctx);
 350   libradosstriper::RadosStriper striperp;
 351   int rc = libradosstriper::RadosStriper::striper_create(ctx, &striperp);
 352   if (0 == rc)
 353     libradosstriper::RadosStriper::to_rados_striper_t(striperp, striper);
 354   return rc;
 355 }
 356
 357 extern "C" void rados_striper_destroy(rados_striper_t striper)
 358 {
 359   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 360   impl->put();
 361 }
 362
 363 extern "C" int rados_striper_set_object_layout_stripe_unit(rados_striper_t striper,
 364                                                            unsigned int stripe_unit)
 365 {
 366   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 367   return impl->setObjectLayoutStripeUnit(stripe_unit);
 368 }
 369
 370 extern "C" int rados_striper_set_object_layout_stripe_count(rados_striper_t striper,
 371                                                             unsigned int stripe_count)
 372 {
 373   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 374   return impl->setObjectLayoutStripeCount(stripe_count);
 375 }
 376
 377 extern "C" int rados_striper_set_object_layout_object_size(rados_striper_t striper,
 378                                                            unsigned int object_size)
 379 {
 380   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 381   return impl->setObjectLayoutObjectSize(object_size);
 382 }
 383
 384 extern "C" int rados_striper_write(rados_striper_t striper,
 385                                    const char *soid,
 386                                    const char *buf,
 387                                    size_t len,
 388                                    uint64_t off)
 389 {
 390   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 391   bufferlist bl;
 392   bl.append(buf, len);
 393   return impl->write(soid, bl, len, off);
 394 }
 395
 396 extern "C" int rados_striper_write_full(rados_striper_t striper,
 397                                         const char *soid,
 398                                         const char *buf,
 399                                         size_t len)
 400 {
 401   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 402   bufferlist bl;
 403   bl.append(buf, len);
 404   return impl->write_full(soid, bl);
 405 }
 406
 407
 408 extern "C" int rados_striper_append(rados_striper_t striper,
 409                                     const char *soid,
 410                                     const char *buf,
 411                                     size_t len)
 412 {
 413   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 414   bufferlist bl;
 415   bl.append(buf, len);
 416   return impl->append(soid, bl, len);
 417 }
 418
 419 extern "C" int rados_striper_read(rados_striper_t striper,
 420                                   const char *soid,
 421                                   char *buf,
 422                                   size_t len,
 423                                   uint64_t off)
 424 {
 425   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 426   bufferlist bl;
 427   bufferptr bp = buffer::create_static(len, buf);
 428   bl.push_back(bp);
 429   int ret = impl->read(soid, &bl, len, off);
 430   if (ret >= 0) {
 431     if (bl.length() > len)
 432       return -ERANGE;
 433     if (!bl.is_provided_buffer(buf))
 434       bl.copy(0, bl.length(), buf);
 435     ret = bl.length();    // hrm :/
 436   }
 437   return ret;
 438 }
 439
 440 extern "C" int rados_striper_remove(rados_striper_t striper, const char* soid)
 441 {
 442   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 443   return impl->remove(soid);
 444 }
 445
 446 extern "C" int rados_striper_trunc(rados_striper_t striper, const char* soid, uint64_t size)
 447 {
 448   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 449   return impl->trunc(soid, size);
 450 }
 451
 452 extern "C" int rados_striper_getxattr(rados_striper_t striper,
 453                                       const char *oid,
 454                                       const char *name,
 455                                       char *buf,
 456                                       size_t len)
 457 {
 458   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 459   object_t obj(oid);
 460   bufferlist bl;
 461   int ret = impl->getxattr(oid, name, bl);
 462   if (ret >= 0) {
 463     if (bl.length() > len)
 464       return -ERANGE;
 465     bl.copy(0, bl.length(), buf);
 466     ret = bl.length();
 467   }
 468   return ret;
 469 }
 470
 471 extern "C" int rados_striper_setxattr(rados_striper_t striper,
 472                                       const char *oid,
 473                                       const char *name,
 474                                       const char *buf,
 475                                       size_t len)
 476 {
 477   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 478   object_t obj(oid);
 479   bufferlist bl;
 480   bl.append(buf, len);
 481   return impl->setxattr(obj, name, bl);
 482 }
 483
 484 extern "C" int rados_striper_rmxattr(rados_striper_t striper,
 485                                      const char *oid,
 486                                      const char *name)
 487 {
 488   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 489   object_t obj(oid);
 490   return impl->rmxattr(obj, name);
 491 }
 492
 493 extern "C" int rados_striper_getxattrs(rados_striper_t striper,
 494                                        const char *oid,
 495                                        rados_xattrs_iter_t *iter)
 496 {
 497   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 498   object_t obj(oid);
 499   librados::RadosXattrsIter *it = new librados::RadosXattrsIter();
 500   if (!it)
 501     return -ENOMEM;
 502   int ret = impl->getxattrs(obj, it->attrset);
 503   if (ret) {
 504     delete it;
 505     return ret;
 506   }
 507   it->i = it->attrset.begin();
 508   librados::RadosXattrsIter **iret = (librados::RadosXattrsIter**)iter;
 509   *iret = it;
 510   *iter = it;
 511   return 0;
 512 }
 513
 514 extern "C" int rados_striper_getxattrs_next(rados_xattrs_iter_t iter,
 515                                             const char **name,
 516                                             const char **val,
 517                                             size_t *len)
 518 {
 519   return rados_getxattrs_next(iter, name, val, len);
 520 }
 521
 522 extern "C" void rados_striper_getxattrs_end(rados_xattrs_iter_t iter)
 523 {
 524   return rados_getxattrs_end(iter);
 525 }
 526
 527 extern "C" int rados_striper_stat(rados_striper_t striper,
 528                                   const char* soid,
 529                                   uint64_t *psize,
 530                                   time_t *pmtime)
 531 {
 532   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 533   return impl->stat(soid, psize, pmtime);
 534 }
 535
 536 extern "C" int rados_striper_multi_aio_create_completion(void *cb_arg,
 537                                                          rados_callback_t cb_complete,
 538                                                          rados_callback_t cb_safe,
 539                                                          rados_striper_multi_completion_t *pc)
 540 {
 541   libradosstriper::MultiAioCompletionImpl *c = new libradosstriper::MultiAioCompletionImpl;
 542   if (cb_complete)
 543     c->set_complete_callback(cb_arg, cb_complete);
 544   if (cb_safe)
 545     c->set_safe_callback(cb_arg, cb_safe);
 546   *pc = c;
 547   return 0;
 548 }
 549
 550 extern "C" void rados_striper_multi_aio_wait_for_complete(rados_striper_multi_completion_t c)
 551 {
 552   ((libradosstriper::MultiAioCompletionImpl*)c)->wait_for_complete();
 553 }
 554
 555 extern "C" void rados_striper_multi_aio_wait_for_safe(rados_striper_multi_completion_t c)
 556 {
 557   ((libradosstriper::MultiAioCompletionImpl*)c)->wait_for_safe();
 558 }
 559
 560 extern "C" int rados_striper_multi_aio_is_complete(rados_striper_multi_completion_t c)
 561 {
 562   return ((libradosstriper::MultiAioCompletionImpl*)c)->is_complete();
 563 }
 564
 565 extern "C" int rados_striper_multi_aio_is_safe(rados_striper_multi_completion_t c)
 566 {
 567   return ((libradosstriper::MultiAioCompletionImpl*)c)->is_safe();
 568 }
 569
 570 extern "C" void rados_striper_multi_aio_wait_for_complete_and_cb(rados_striper_multi_completion_t c)
 571 {
 572   ((libradosstriper::MultiAioCompletionImpl*)c)->wait_for_complete_and_cb();
 573 }
 574
 575 extern "C" void rados_striper_multi_aio_wait_for_safe_and_cb(rados_striper_multi_completion_t c)
 576 {
 577   ((libradosstriper::MultiAioCompletionImpl*)c)->wait_for_safe_and_cb();
 578 }
 579
 580 extern "C" int rados_striper_multi_aio_is_complete_and_cb(rados_striper_multi_completion_t c)
 581 {
 582   return ((libradosstriper::MultiAioCompletionImpl*)c)->is_complete_and_cb();
 583 }
 584
 585 extern "C" int rados_striper_multi_aio_is_safe_and_cb(rados_striper_multi_completion_t c)
 586 {
 587   return ((libradosstriper::MultiAioCompletionImpl*)c)->is_safe_and_cb();
 588 }
 589
 590 extern "C" int rados_striper_multi_aio_get_return_value(rados_striper_multi_completion_t c)
 591 {
 592   return ((libradosstriper::MultiAioCompletionImpl*)c)->get_return_value();
 593 }
 594
 595 extern "C" void rados_striper_multi_aio_release(rados_striper_multi_completion_t c)
 596 {
 597   ((libradosstriper::MultiAioCompletionImpl*)c)->put();
 598 }
 599
 600 extern "C" int rados_striper_aio_write(rados_striper_t striper,
 601                                        const char* soid,
 602                                        rados_completion_t completion,
 603                                        const char *buf,
 604                                        size_t len,
 605                                        uint64_t off)
 606 {
 607   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 608   bufferlist bl;
 609   bl.append(buf, len);
 610   return impl->aio_write(soid, (librados::AioCompletionImpl*)completion, bl, len, off);
 611 }
 612
 613 extern "C" int rados_striper_aio_append(rados_striper_t striper,
 614                                         const char* soid,
 615                                         rados_completion_t completion,
 616                                         const char *buf,
 617                                         size_t len)
 618 {
 619   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 620   bufferlist bl;
 621   bl.append(buf, len);
 622   return impl->aio_append(soid, (librados::AioCompletionImpl*)completion, bl, len);
 623 }
 624
 625 extern "C" int rados_striper_aio_write_full(rados_striper_t striper,
 626                                             const char* soid,
 627                                             rados_completion_t completion,
 628                                             const char *buf,
 629                                             size_t len)
 630 {
 631   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 632   bufferlist bl;
 633   bl.append(buf, len);
 634   return impl->aio_write_full(soid, (librados::AioCompletionImpl*)completion, bl);
 635 }
 636
 637 extern "C" int rados_striper_aio_read(rados_striper_t striper,
 638                                       const char *soid,
 639                                       rados_completion_t completion,
 640                                       char *buf,
 641                                       size_t len,
 642                                       uint64_t off)
 643 {
 644   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 645   return impl->aio_read(soid, (librados::AioCompletionImpl*)completion, buf, len, off);
 646 }
 647
 648 extern "C" int rados_striper_aio_remove(rados_striper_t striper,
 649                                         const char* soid,
 650                                         rados_completion_t completion)
 651 {
 652   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 653   return impl->aio_remove(soid, (librados::AioCompletionImpl*)completion);
 654 }
 655
 656 extern "C" void rados_striper_aio_flush(rados_striper_t striper)
 657 {
 658   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 659   impl->aio_flush();
 660 }
 661
 662 extern "C" int rados_striper_aio_stat(rados_striper_t striper,
 663                                       const char* soid,
 664                                       rados_completion_t completion,
 665                                       uint64_t *psize,
 666                                       time_t *pmtime)
 667 {
 668   libradosstriper::RadosStriperImpl *impl = (libradosstriper::RadosStriperImpl *)striper;
 669   return impl->aio_stat(soid, (librados::AioCompletionImpl*)completion, psize, pmtime);
 670 }