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