ceph/src/test/librados_test_stub/LibradosTestStub.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #include "test/librados_test_stub/LibradosTestStub.h"
   5 #include "include/rados/librados.hpp"
   6 #include "include/stringify.h"
   7 #include "common/ceph_argparse.h"
   8 #include "common/ceph_context.h"
   9 #include "common/common_init.h"
  10 #include "common/config.h"
  11 #include "common/debug.h"
  12 #include "common/snap_types.h"
  13 #include "librados/AioCompletionImpl.h"
  14 #include "log/Log.h"
  15 #include "test/librados_test_stub/TestClassHandler.h"
  16 #include "test/librados_test_stub/TestIoCtxImpl.h"
  17 #include "test/librados_test_stub/TestRadosClient.h"
  18 #include "test/librados_test_stub/TestMemCluster.h"
  19 #include "test/librados_test_stub/TestMemRadosClient.h"
  20 #include "objclass/objclass.h"
  21 #include "osd/osd_types.h"
  22 #include <arpa/inet.h>
  23 #include <boost/bind.hpp>
  24 #include <boost/shared_ptr.hpp>
  25 #include <deque>
  26 #include <list>
  27 #include <vector>
  28 #include "include/ceph_assert.h"
  29 #include "include/compat.h"
  30
  31 #define dout_context g_ceph_context
  32 #define dout_subsys ceph_subsys_rados
  33
  34 namespace librados {
  35
  36 MockTestMemIoCtxImpl &get_mock_io_ctx(IoCtx &ioctx) {
  37   MockTestMemIoCtxImpl **mock =
  38     reinterpret_cast<MockTestMemIoCtxImpl **>(&ioctx);
  39   return **mock;
  40 }
  41
  42 } // namespace librados
  43
  44 namespace librados_test_stub {
  45
  46 TestClusterRef &cluster() {
  47   static TestClusterRef s_cluster;
  48   return s_cluster;
  49 }
  50
  51 void set_cluster(TestClusterRef cluster_ref) {
  52   cluster() = cluster_ref;
  53 }
  54
  55 TestClusterRef get_cluster() {
  56   auto &cluster_ref = cluster();
  57   if (cluster_ref.get() == nullptr) {
  58     cluster_ref.reset(new librados::TestMemCluster());
  59   }
  60   return cluster_ref;
  61 }
  62
  63 } // namespace librados_test_stub
  64
  65 namespace {
  66
  67 librados::TestClassHandler *get_class_handler() {
  68   static boost::shared_ptr<librados::TestClassHandler> s_class_handler;
  69   if (!s_class_handler) {
  70     s_class_handler.reset(new librados::TestClassHandler());
  71     s_class_handler->open_all_classes();
  72   }
  73   return s_class_handler.get();
  74 }
  75
  76 void do_out_buffer(bufferlist& outbl, char **outbuf, size_t *outbuflen) {
  77   if (outbuf) {
  78     if (outbl.length() > 0) {
  79       *outbuf = (char *)malloc(outbl.length());
  80       memcpy(*outbuf, outbl.c_str(), outbl.length());
  81     } else {
  82       *outbuf = NULL;
  83     }
  84   }
  85   if (outbuflen) {
  86     *outbuflen = outbl.length();
  87   }
  88 }
  89
  90 void do_out_buffer(string& outbl, char **outbuf, size_t *outbuflen) {
  91   if (outbuf) {
  92     if (outbl.length() > 0) {
  93       *outbuf = (char *)malloc(outbl.length());
  94       memcpy(*outbuf, outbl.c_str(), outbl.length());
  95     } else {
  96       *outbuf = NULL;
  97     }
  98   }
  99   if (outbuflen) {
 100     *outbuflen = outbl.length();
 101   }
 102 }
 103
 104 librados::TestRadosClient *create_rados_client() {
 105   CephInitParameters iparams(CEPH_ENTITY_TYPE_CLIENT);
 106   CephContext *cct = common_preinit(iparams, CODE_ENVIRONMENT_LIBRARY, 0);
 107   cct->_conf.parse_env(cct->get_module_type());
 108   cct->_conf.apply_changes(nullptr);
 109   cct->_log->start();
 110
 111   auto rados_client =
 112     librados_test_stub::get_cluster()->create_rados_client(cct);
 113   cct->put();
 114   return rados_client;
 115 }
 116
 117 } // anonymous namespace
 118
 119 extern "C" int rados_aio_create_completion(void *cb_arg,
 120                                            rados_callback_t cb_complete,
 121                                            rados_callback_t cb_safe,
 122                                            rados_completion_t *pc)
 123 {
 124   librados::AioCompletionImpl *c = new librados::AioCompletionImpl;
 125   if (cb_complete) {
 126     c->set_complete_callback(cb_arg, cb_complete);
 127   }
 128   if (cb_safe) {
 129     c->set_safe_callback(cb_arg, cb_safe);
 130   }
 131   *pc = c;
 132   return 0;
 133 }
 134
 135 extern "C" int rados_aio_get_return_value(rados_completion_t c) {
 136   return reinterpret_cast<librados::AioCompletionImpl*>(c)->get_return_value();
 137 }
 138
 139 extern "C" rados_config_t rados_cct(rados_t cluster)
 140 {
 141   librados::TestRadosClient *client =
 142     reinterpret_cast<librados::TestRadosClient*>(cluster);
 143   return reinterpret_cast<rados_config_t>(client->cct());
 144 }
 145
 146 extern "C" int rados_conf_set(rados_t cluster, const char *option,
 147                               const char *value) {
 148   librados::TestRadosClient *impl =
 149     reinterpret_cast<librados::TestRadosClient*>(cluster);
 150   CephContext *cct = impl->cct();
 151   return cct->_conf.set_val(option, value);
 152 }
 153
 154 extern "C" int rados_conf_parse_env(rados_t cluster, const char *var) {
 155   librados::TestRadosClient *client =
 156     reinterpret_cast<librados::TestRadosClient*>(cluster);
 157   auto& conf = client->cct()->_conf;
 158   conf.parse_env(client->cct()->get_module_type(), var);
 159   conf.apply_changes(NULL);
 160   return 0;
 161 }
 162
 163 extern "C" int rados_conf_read_file(rados_t cluster, const char *path) {
 164   librados::TestRadosClient *client =
 165     reinterpret_cast<librados::TestRadosClient*>(cluster);
 166   auto& conf = client->cct()->_conf;
 167   int ret = conf.parse_config_files(path, NULL, 0);
 168   if (ret == 0) {
 169     conf.parse_env(client->cct()->get_module_type());
 170     conf.apply_changes(NULL);
 171     conf.complain_about_parse_errors(client->cct());
 172   } else if (ret == -ENOENT) {
 173     // ignore missing client config
 174     return 0;
 175   }
 176   return ret;
 177 }
 178
 179 extern "C" int rados_connect(rados_t cluster) {
 180   librados::TestRadosClient *client =
 181     reinterpret_cast<librados::TestRadosClient*>(cluster);
 182   return client->connect();
 183 }
 184
 185 extern "C" int rados_create(rados_t *cluster, const char * const id) {
 186   *cluster = create_rados_client();
 187   return 0;
 188 }
 189
 190 extern "C" int rados_create_with_context(rados_t *cluster,
 191                                          rados_config_t cct_) {
 192   auto cct = reinterpret_cast<CephContext*>(cct_);
 193   *cluster = librados_test_stub::get_cluster()->create_rados_client(cct);
 194   return 0;
 195 }
 196
 197 extern "C" rados_config_t rados_ioctx_cct(rados_ioctx_t ioctx)
 198 {
 199   librados::TestIoCtxImpl *ctx =
 200     reinterpret_cast<librados::TestIoCtxImpl*>(ioctx);
 201   return reinterpret_cast<rados_config_t>(ctx->get_rados_client()->cct());
 202 }
 203
 204 extern "C" int rados_ioctx_create(rados_t cluster, const char *pool_name,
 205                                   rados_ioctx_t *ioctx) {
 206   librados::TestRadosClient *client =
 207     reinterpret_cast<librados::TestRadosClient*>(cluster);
 208
 209   int64_t pool_id = client->pool_lookup(pool_name);
 210   if (pool_id < 0) {
 211     return static_cast<int>(pool_id);
 212   }
 213
 214   *ioctx = reinterpret_cast<rados_ioctx_t>(
 215       client->create_ioctx(pool_id, pool_name));
 216   return 0;
 217 }
 218
 219 extern "C" int rados_ioctx_create2(rados_t cluster, int64_t pool_id,
 220                                    rados_ioctx_t *ioctx)
 221 {
 222   librados::TestRadosClient *client =
 223     reinterpret_cast<librados::TestRadosClient*>(cluster);
 224
 225   std::list<std::pair<int64_t, std::string> > pools;
 226   int r = client->pool_list(pools);
 227   if (r < 0) {
 228     return r;
 229   }
 230
 231   for (std::list<std::pair<int64_t, std::string> >::iterator it =
 232        pools.begin(); it != pools.end(); ++it) {
 233     if (it->first == pool_id) {
 234       *ioctx = reinterpret_cast<rados_ioctx_t>(
 235         client->create_ioctx(pool_id, it->second));
 236       return 0;
 237     }
 238   }
 239   return -ENOENT;
 240 }
 241
 242 extern "C" void rados_ioctx_destroy(rados_ioctx_t io) {
 243   librados::TestIoCtxImpl *ctx =
 244     reinterpret_cast<librados::TestIoCtxImpl*>(io);
 245   ctx->put();
 246 }
 247
 248 extern "C" rados_t rados_ioctx_get_cluster(rados_ioctx_t io) {
 249   librados::TestIoCtxImpl *ctx =
 250     reinterpret_cast<librados::TestIoCtxImpl*>(io);
 251   return reinterpret_cast<rados_t>(ctx->get_rados_client());
 252 }
 253
 254 extern "C" int rados_mon_command(rados_t cluster, const char **cmd,
 255                                  size_t cmdlen, const char *inbuf,
 256                                  size_t inbuflen, char **outbuf,
 257                                  size_t *outbuflen, char **outs,
 258                                  size_t *outslen) {
 259   librados::TestRadosClient *client =
 260     reinterpret_cast<librados::TestRadosClient*>(cluster);
 261
 262   vector<string> cmdvec;
 263   for (size_t i = 0; i < cmdlen; i++) {
 264     cmdvec.push_back(cmd[i]);
 265   }
 266
 267   bufferlist inbl;
 268   inbl.append(inbuf, inbuflen);
 269
 270   bufferlist outbl;
 271   string outstring;
 272   int ret = client->mon_command(cmdvec, inbl, &outbl, &outstring);
 273
 274   do_out_buffer(outbl, outbuf, outbuflen);
 275   do_out_buffer(outstring, outs, outslen);
 276   return ret;
 277 }
 278
 279 extern "C" int rados_nobjects_list_open(rados_ioctx_t io,
 280                                         rados_list_ctx_t *ctx) {
 281   librados::TestIoCtxImpl *io_ctx =
 282     reinterpret_cast<librados::TestIoCtxImpl*>(io);
 283   librados::TestRadosClient *client = io_ctx->get_rados_client();
 284
 285   std::list<librados::TestRadosClient::Object> *list =
 286     new std::list<librados::TestRadosClient::Object>();
 287
 288   client->object_list(io_ctx->get_id(), list);
 289   list->push_front(librados::TestRadosClient::Object());
 290   *ctx = reinterpret_cast<rados_list_ctx_t>(list);
 291   return 0;
 292 }
 293
 294 extern "C" int rados_nobjects_list_next(rados_list_ctx_t ctx,
 295                                         const char **entry,
 296                                         const char **key,
 297                                         const char **nspace) {
 298   std::list<librados::TestRadosClient::Object> *list =
 299     reinterpret_cast<std::list<librados::TestRadosClient::Object> *>(ctx);
 300   if (!list->empty()) {
 301     list->pop_front();
 302   }
 303   if (list->empty()) {
 304     return -ENOENT;
 305   }
 306
 307   librados::TestRadosClient::Object &obj = list->front();
 308   if (entry != NULL) {
 309     *entry = obj.oid.c_str();
 310   }
 311   if (key != NULL) {
 312     *key = obj.locator.c_str();
 313   }
 314   if (nspace != NULL) {
 315     *nspace = obj.nspace.c_str();
 316   }
 317   return 0;
 318 }
 319
 320 extern "C" void rados_nobjects_list_close(rados_list_ctx_t ctx) {
 321   std::list<librados::TestRadosClient::Object> *list =
 322     reinterpret_cast<std::list<librados::TestRadosClient::Object> *>(ctx);
 323   delete list;
 324 }
 325
 326 extern "C" int rados_pool_create(rados_t cluster, const char *pool_name) {
 327   librados::TestRadosClient *client =
 328     reinterpret_cast<librados::TestRadosClient*>(cluster);
 329   return client->pool_create(pool_name);
 330 }
 331
 332 extern "C" int rados_pool_delete(rados_t cluster, const char *pool_name) {
 333   librados::TestRadosClient *client =
 334     reinterpret_cast<librados::TestRadosClient*>(cluster);
 335   return client->pool_delete(pool_name);
 336 }
 337
 338 extern "C" void rados_shutdown(rados_t cluster) {
 339   librados::TestRadosClient *client =
 340     reinterpret_cast<librados::TestRadosClient*>(cluster);
 341   client->put();
 342 }
 343
 344 extern "C" int rados_wait_for_latest_osdmap(rados_t cluster) {
 345   librados::TestRadosClient *client =
 346     reinterpret_cast<librados::TestRadosClient*>(cluster);
 347   return client->wait_for_latest_osdmap();
 348 }
 349
 350 namespace librados {
 351
 352 void AioCompletion::release() {
 353   AioCompletionImpl *c = reinterpret_cast<AioCompletionImpl *>(pc);
 354   c->release();
 355   delete this;
 356 }
 357
 358 IoCtx::IoCtx() : io_ctx_impl(NULL) {
 359 }
 360
 361 IoCtx::~IoCtx() {
 362   close();
 363 }
 364
 365 IoCtx::IoCtx(const IoCtx& rhs) {
 366   io_ctx_impl = rhs.io_ctx_impl;
 367   if (io_ctx_impl) {
 368     TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 369     ctx->get();
 370   }
 371 }
 372
 373 IoCtx::IoCtx(IoCtx&& rhs) noexcept : io_ctx_impl(std::exchange(rhs.io_ctx_impl, nullptr))
 374 {
 375 }
 376
 377 IoCtx& IoCtx::operator=(const IoCtx& rhs) {
 378   if (io_ctx_impl) {
 379     TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 380     ctx->put();
 381   }
 382
 383   io_ctx_impl = rhs.io_ctx_impl;
 384   if (io_ctx_impl) {
 385     TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 386     ctx->get();
 387   }
 388   return *this;
 389 }
 390
 391 librados::IoCtx& librados::IoCtx::operator=(IoCtx&& rhs) noexcept
 392 {
 393   if (io_ctx_impl) {
 394     TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 395     ctx->put();
 396   }
 397
 398   io_ctx_impl = std::exchange(rhs.io_ctx_impl, nullptr);
 399   return *this;
 400 }
 401
 402 int IoCtx::aio_flush() {
 403   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 404   ctx->aio_flush();
 405   return 0;
 406 }
 407
 408 int IoCtx::aio_flush_async(AioCompletion *c) {
 409   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 410   ctx->aio_flush_async(c->pc);
 411   return 0;
 412 }
 413
 414 int IoCtx::aio_notify(const std::string& oid, AioCompletion *c, bufferlist& bl,
 415                       uint64_t timeout_ms, bufferlist *pbl) {
 416   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 417   ctx->aio_notify(oid, c->pc, bl, timeout_ms, pbl);
 418   return 0;
 419 }
 420
 421 int IoCtx::aio_operate(const std::string& oid, AioCompletion *c,
 422                        ObjectReadOperation *op, bufferlist *pbl) {
 423   return aio_operate(oid, c, op, 0, pbl);
 424 }
 425
 426 int IoCtx::aio_operate(const std::string& oid, AioCompletion *c,
 427                        ObjectReadOperation *op, int flags,
 428                        bufferlist *pbl) {
 429   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 430   TestObjectOperationImpl *ops = reinterpret_cast<TestObjectOperationImpl*>(op->impl);
 431   return ctx->aio_operate_read(oid, *ops, c->pc, flags, pbl);
 432 }
 433
 434 int IoCtx::aio_operate(const std::string& oid, AioCompletion *c,
 435                        ObjectReadOperation *op, int flags,
 436                        bufferlist *pbl, const blkin_trace_info *trace_info) {
 437   return aio_operate(oid, c, op, flags, pbl);
 438 }
 439
 440 int IoCtx::aio_operate(const std::string& oid, AioCompletion *c,
 441                        ObjectWriteOperation *op) {
 442   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 443   TestObjectOperationImpl *ops = reinterpret_cast<TestObjectOperationImpl*>(op->impl);
 444   return ctx->aio_operate(oid, *ops, c->pc, NULL, 0);
 445 }
 446
 447 int IoCtx::aio_operate(const std::string& oid, AioCompletion *c,
 448                        ObjectWriteOperation *op, snap_t seq,
 449                        std::vector<snap_t>& snaps, int flags,
 450                        const blkin_trace_info *trace_info) {
 451   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 452   TestObjectOperationImpl *ops = reinterpret_cast<TestObjectOperationImpl*>(op->impl);
 453
 454   std::vector<snapid_t> snv;
 455   snv.resize(snaps.size());
 456   for (size_t i = 0; i < snaps.size(); ++i)
 457     snv[i] = snaps[i];
 458   SnapContext snapc(seq, snv);
 459
 460   return ctx->aio_operate(oid, *ops, c->pc, &snapc, flags);
 461 }
 462
 463 int IoCtx::aio_operate(const std::string& oid, AioCompletion *c,
 464                        ObjectWriteOperation *op, snap_t seq,
 465                        std::vector<snap_t>& snaps) {
 466   return aio_operate(oid, c, op, seq, snaps, 0, nullptr);
 467 }
 468
 469 int IoCtx::aio_operate(const std::string& oid, AioCompletion *c,
 470                        ObjectWriteOperation *op, snap_t seq,
 471                        std::vector<snap_t>& snaps,
 472                        const blkin_trace_info *trace_info) {
 473   return aio_operate(oid, c, op, seq, snaps, 0, trace_info);
 474 }
 475
 476 int IoCtx::aio_remove(const std::string& oid, AioCompletion *c) {
 477   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 478   return ctx->aio_remove(oid, c->pc);
 479 }
 480
 481 int IoCtx::aio_remove(const std::string& oid, AioCompletion *c, int flags) {
 482   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 483   return ctx->aio_remove(oid, c->pc, flags);
 484 }
 485
 486 int IoCtx::aio_watch(const std::string& o, AioCompletion *c, uint64_t *handle,
 487                      librados::WatchCtx2 *watch_ctx) {
 488   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 489   return ctx->aio_watch(o, c->pc, handle, watch_ctx);
 490 }
 491
 492 int IoCtx::aio_unwatch(uint64_t handle, AioCompletion *c) {
 493   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 494   return ctx->aio_unwatch(handle, c->pc);
 495 }
 496
 497 config_t IoCtx::cct() {
 498   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 499   return reinterpret_cast<config_t>(ctx->get_rados_client()->cct());
 500 }
 501
 502 void IoCtx::close() {
 503   if (io_ctx_impl) {
 504     TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 505     ctx->put();
 506   }
 507   io_ctx_impl = NULL;
 508 }
 509
 510 int IoCtx::create(const std::string& oid, bool exclusive) {
 511   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 512   return ctx->execute_operation(
 513     oid, boost::bind(&TestIoCtxImpl::create, _1, _2, exclusive));
 514 }
 515
 516 void IoCtx::dup(const IoCtx& rhs) {
 517   close();
 518   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(rhs.io_ctx_impl);
 519   io_ctx_impl = reinterpret_cast<IoCtxImpl*>(ctx->clone());
 520 }
 521
 522 int IoCtx::exec(const std::string& oid, const char *cls, const char *method,
 523                 bufferlist& inbl, bufferlist& outbl) {
 524   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 525   return ctx->execute_operation(
 526     oid, boost::bind(&TestIoCtxImpl::exec, _1, _2, get_class_handler(), cls,
 527                      method, inbl, &outbl, ctx->get_snap_context()));
 528 }
 529
 530 void IoCtx::from_rados_ioctx_t(rados_ioctx_t p, IoCtx &io) {
 531   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(p);
 532   ctx->get();
 533
 534   io.close();
 535   io.io_ctx_impl = reinterpret_cast<IoCtxImpl*>(ctx);
 536 }
 537
 538 uint64_t IoCtx::get_instance_id() const {
 539   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 540   return ctx->get_instance_id();
 541 }
 542
 543 int64_t IoCtx::get_id() {
 544   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 545   return ctx->get_id();
 546 }
 547
 548 uint64_t IoCtx::get_last_version() {
 549   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 550   return ctx->get_last_version();
 551 }
 552
 553 std::string IoCtx::get_pool_name() {
 554   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 555   return ctx->get_pool_name();
 556 }
 557
 558 int IoCtx::list_snaps(const std::string& o, snap_set_t *out_snaps) {
 559   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 560   return ctx->execute_operation(
 561     o, boost::bind(&TestIoCtxImpl::list_snaps, _1, _2, out_snaps));
 562 }
 563
 564 int IoCtx::list_watchers(const std::string& o,
 565                          std::list<obj_watch_t> *out_watchers) {
 566   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 567   return ctx->execute_operation(
 568     o, boost::bind(&TestIoCtxImpl::list_watchers, _1, _2, out_watchers));
 569 }
 570
 571 int IoCtx::notify(const std::string& o, uint64_t ver, bufferlist& bl) {
 572   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 573   return ctx->notify(o, bl, 0, NULL);
 574 }
 575
 576 int IoCtx::notify2(const std::string& o, bufferlist& bl,
 577                    uint64_t timeout_ms, bufferlist *pbl) {
 578   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 579   return ctx->notify(o, bl, timeout_ms, pbl);
 580 }
 581
 582 void IoCtx::notify_ack(const std::string& o, uint64_t notify_id,
 583                        uint64_t handle, bufferlist& bl) {
 584   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 585   ctx->notify_ack(o, notify_id, handle, bl);
 586 }
 587
 588 int IoCtx::omap_get_vals(const std::string& oid,
 589                          const std::string& start_after,
 590                          uint64_t max_return,
 591                          std::map<std::string, bufferlist> *out_vals) {
 592   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 593   return ctx->execute_operation(
 594     oid, boost::bind(&TestIoCtxImpl::omap_get_vals, _1, _2, start_after, "",
 595                      max_return, out_vals));
 596 }
 597
 598 int IoCtx::operate(const std::string& oid, ObjectWriteOperation *op) {
 599   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 600   TestObjectOperationImpl *ops = reinterpret_cast<TestObjectOperationImpl*>(op->impl);
 601   return ctx->operate(oid, *ops);
 602 }
 603
 604 int IoCtx::operate(const std::string& oid, ObjectReadOperation *op,
 605                    bufferlist *pbl) {
 606   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 607   TestObjectOperationImpl *ops = reinterpret_cast<TestObjectOperationImpl*>(op->impl);
 608   return ctx->operate_read(oid, *ops, pbl);
 609 }
 610
 611 int IoCtx::read(const std::string& oid, bufferlist& bl, size_t len,
 612                 uint64_t off) {
 613   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 614   return ctx->execute_operation(
 615     oid, boost::bind(&TestIoCtxImpl::read, _1, _2, len, off, &bl));
 616 }
 617
 618 int IoCtx::remove(const std::string& oid) {
 619   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 620   return ctx->execute_operation(
 621     oid, boost::bind(&TestIoCtxImpl::remove, _1, _2, ctx->get_snap_context()));
 622 }
 623
 624 int IoCtx::selfmanaged_snap_create(uint64_t *snapid) {
 625   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 626   return ctx->selfmanaged_snap_create(snapid);
 627 }
 628
 629 void IoCtx::aio_selfmanaged_snap_create(uint64_t *snapid, AioCompletion* c) {
 630   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 631   return ctx->aio_selfmanaged_snap_create(snapid, c->pc);
 632 }
 633
 634 int IoCtx::selfmanaged_snap_remove(uint64_t snapid) {
 635   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 636   return ctx->selfmanaged_snap_remove(snapid);
 637 }
 638
 639 void IoCtx::aio_selfmanaged_snap_remove(uint64_t snapid, AioCompletion* c) {
 640   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 641   ctx->aio_selfmanaged_snap_remove(snapid, c->pc);
 642 }
 643
 644 int IoCtx::selfmanaged_snap_rollback(const std::string& oid,
 645                                      uint64_t snapid) {
 646   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 647   return ctx->selfmanaged_snap_rollback(oid, snapid);
 648 }
 649
 650 int IoCtx::selfmanaged_snap_set_write_ctx(snap_t seq,
 651                                           std::vector<snap_t>& snaps) {
 652   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 653   return ctx->selfmanaged_snap_set_write_ctx(seq, snaps);
 654 }
 655
 656 void IoCtx::snap_set_read(snap_t seq) {
 657   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 658   ctx->set_snap_read(seq);
 659 }
 660
 661 int IoCtx::sparse_read(const std::string& oid, std::map<uint64_t,uint64_t>& m,
 662                        bufferlist& bl, size_t len, uint64_t off) {
 663   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 664   return ctx->execute_operation(
 665     oid, boost::bind(&TestIoCtxImpl::sparse_read, _1, _2, off, len, &m, &bl));
 666 }
 667
 668 int IoCtx::stat(const std::string& oid, uint64_t *psize, time_t *pmtime) {
 669   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 670   return ctx->execute_operation(
 671     oid, boost::bind(&TestIoCtxImpl::stat, _1, _2, psize, pmtime));
 672 }
 673
 674 int IoCtx::tmap_update(const std::string& oid, bufferlist& cmdbl) {
 675   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 676   return ctx->execute_operation(
 677     oid, boost::bind(&TestIoCtxImpl::tmap_update, _1, _2, cmdbl));
 678 }
 679
 680 int IoCtx::trunc(const std::string& oid, uint64_t off) {
 681   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 682   return ctx->execute_operation(
 683     oid, boost::bind(&TestIoCtxImpl::truncate, _1, _2, off,
 684                      ctx->get_snap_context()));
 685 }
 686
 687 int IoCtx::unwatch2(uint64_t handle) {
 688   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 689   return ctx->unwatch(handle);
 690 }
 691
 692 int IoCtx::unwatch(const std::string& o, uint64_t handle) {
 693   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 694   return ctx->unwatch(handle);
 695 }
 696
 697 int IoCtx::watch(const std::string& o, uint64_t ver, uint64_t *handle,
 698                  librados::WatchCtx *wctx) {
 699   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 700   return ctx->watch(o, handle, wctx, NULL);
 701 }
 702
 703 int IoCtx::watch2(const std::string& o, uint64_t *handle,
 704                   librados::WatchCtx2 *wctx) {
 705   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 706   return ctx->watch(o, handle, NULL, wctx);
 707 }
 708
 709 int IoCtx::write(const std::string& oid, bufferlist& bl, size_t len,
 710                  uint64_t off) {
 711   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 712   return ctx->execute_operation(
 713     oid, boost::bind(&TestIoCtxImpl::write, _1, _2, bl, len, off,
 714                      ctx->get_snap_context()));
 715 }
 716
 717 int IoCtx::write_full(const std::string& oid, bufferlist& bl) {
 718   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 719   return ctx->execute_operation(
 720     oid, boost::bind(&TestIoCtxImpl::write_full, _1, _2, bl,
 721                      ctx->get_snap_context()));
 722 }
 723
 724 int IoCtx::writesame(const std::string& oid, bufferlist& bl, size_t len,
 725                      uint64_t off) {
 726   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 727   return ctx->execute_operation(
 728     oid, boost::bind(&TestIoCtxImpl::writesame, _1, _2, bl, len, off,
 729                      ctx->get_snap_context()));
 730 }
 731
 732 int IoCtx::cmpext(const std::string& oid, uint64_t off, bufferlist& cmp_bl) {
 733   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 734   return ctx->execute_operation(
 735     oid, boost::bind(&TestIoCtxImpl::cmpext, _1, _2, off, cmp_bl));
 736 }
 737
 738 int IoCtx::application_enable(const std::string& app_name, bool force) {
 739   return 0;
 740 }
 741
 742 int IoCtx::application_enable_async(const std::string& app_name,
 743                                     bool force, PoolAsyncCompletion *c) {
 744   return -EOPNOTSUPP;
 745 }
 746
 747 int IoCtx::application_list(std::set<std::string> *app_names) {
 748   return -EOPNOTSUPP;
 749 }
 750
 751 int IoCtx::application_metadata_get(const std::string& app_name,
 752                                     const std::string &key,
 753                                     std::string *value) {
 754   return -EOPNOTSUPP;
 755 }
 756
 757 int IoCtx::application_metadata_set(const std::string& app_name,
 758                                     const std::string &key,
 759                                     const std::string& value) {
 760   return -EOPNOTSUPP;
 761 }
 762
 763 int IoCtx::application_metadata_remove(const std::string& app_name,
 764                                        const std::string &key) {
 765   return -EOPNOTSUPP;
 766 }
 767
 768 int IoCtx::application_metadata_list(const std::string& app_name,
 769                                      std::map<std::string, std::string> *values) {
 770   return -EOPNOTSUPP;
 771 }
 772
 773 void IoCtx::set_namespace(const std::string& nspace) {
 774   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 775   ctx->set_namespace(nspace);
 776 }
 777
 778 std::string IoCtx::get_namespace() const {
 779   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 780   return ctx->get_namespace();
 781 }
 782
 783 static int save_operation_result(int result, int *pval) {
 784   if (pval != NULL) {
 785     *pval = result;
 786   }
 787   return result;
 788 }
 789
 790 ObjectOperation::ObjectOperation() {
 791   TestObjectOperationImpl *o = new TestObjectOperationImpl();
 792   o->get();
 793   impl = reinterpret_cast<ObjectOperationImpl*>(o);
 794 }
 795
 796 ObjectOperation::~ObjectOperation() {
 797   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 798   if (o) {
 799     o->put();
 800     o = NULL;
 801   }
 802 }
 803
 804 void ObjectOperation::assert_exists() {
 805   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 806   o->ops.push_back(boost::bind(&TestIoCtxImpl::assert_exists, _1, _2));
 807 }
 808
 809 void ObjectOperation::exec(const char *cls, const char *method,
 810                            bufferlist& inbl) {
 811   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 812   o->ops.push_back(boost::bind(&TestIoCtxImpl::exec, _1, _2,
 813                                get_class_handler(), cls, method, inbl, _3, _4));
 814 }
 815
 816 void ObjectOperation::set_op_flags2(int flags) {
 817 }
 818
 819 size_t ObjectOperation::size() {
 820   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 821   return o->ops.size();
 822 }
 823
 824 void ObjectOperation::cmpext(uint64_t off, const bufferlist& cmp_bl,
 825                              int *prval) {
 826   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 827   ObjectOperationTestImpl op = boost::bind(&TestIoCtxImpl::cmpext, _1, _2, off, cmp_bl);
 828   if (prval != NULL) {
 829     op = boost::bind(save_operation_result,
 830                      boost::bind(op, _1, _2, _3, _4), prval);
 831   }
 832   o->ops.push_back(op);
 833 }
 834
 835 void ObjectReadOperation::list_snaps(snap_set_t *out_snaps, int *prval) {
 836   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 837
 838   ObjectOperationTestImpl op = boost::bind(&TestIoCtxImpl::list_snaps, _1, _2,
 839                                            out_snaps);
 840   if (prval != NULL) {
 841     op = boost::bind(save_operation_result,
 842                      boost::bind(op, _1, _2, _3, _4), prval);
 843   }
 844   o->ops.push_back(op);
 845 }
 846
 847 void ObjectReadOperation::list_watchers(std::list<obj_watch_t> *out_watchers,
 848                                         int *prval) {
 849   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 850
 851   ObjectOperationTestImpl op = boost::bind(&TestIoCtxImpl::list_watchers, _1,
 852                                            _2, out_watchers);
 853   if (prval != NULL) {
 854     op = boost::bind(save_operation_result,
 855                      boost::bind(op, _1, _2, _3, _4), prval);
 856   }
 857   o->ops.push_back(op);
 858 }
 859
 860 void ObjectReadOperation::read(size_t off, uint64_t len, bufferlist *pbl,
 861                                int *prval) {
 862   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 863
 864   ObjectOperationTestImpl op;
 865   if (pbl != NULL) {
 866     op = boost::bind(&TestIoCtxImpl::read, _1, _2, len, off, pbl);
 867   } else {
 868     op = boost::bind(&TestIoCtxImpl::read, _1, _2, len, off, _3);
 869   }
 870
 871   if (prval != NULL) {
 872     op = boost::bind(save_operation_result,
 873                      boost::bind(op, _1, _2, _3, _4), prval);
 874   }
 875   o->ops.push_back(op);
 876 }
 877
 878 void ObjectReadOperation::sparse_read(uint64_t off, uint64_t len,
 879                                       std::map<uint64_t,uint64_t> *m,
 880                                       bufferlist *pbl, int *prval) {
 881   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 882
 883   ObjectOperationTestImpl op;
 884   if (pbl != NULL) {
 885     op = boost::bind(&TestIoCtxImpl::sparse_read, _1, _2, off, len, m, pbl);
 886   } else {
 887     op = boost::bind(&TestIoCtxImpl::sparse_read, _1, _2, off, len, m, _3);
 888   }
 889
 890   if (prval != NULL) {
 891     op = boost::bind(save_operation_result,
 892                      boost::bind(op, _1, _2, _3, _4), prval);
 893   }
 894   o->ops.push_back(op);
 895 }
 896
 897 void ObjectReadOperation::stat(uint64_t *psize, time_t *pmtime, int *prval) {
 898   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 899
 900   ObjectOperationTestImpl op = boost::bind(&TestIoCtxImpl::stat, _1, _2,
 901                                            psize, pmtime);
 902
 903   if (prval != NULL) {
 904     op = boost::bind(save_operation_result,
 905                      boost::bind(op, _1, _2, _3, _4), prval);
 906   }
 907   o->ops.push_back(op);
 908 }
 909
 910 void ObjectWriteOperation::append(const bufferlist &bl) {
 911   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 912   o->ops.push_back(boost::bind(&TestIoCtxImpl::append, _1, _2, bl, _4));
 913 }
 914
 915 void ObjectWriteOperation::create(bool exclusive) {
 916   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 917   o->ops.push_back(boost::bind(&TestIoCtxImpl::create, _1, _2, exclusive));
 918 }
 919
 920 void ObjectWriteOperation::omap_set(const std::map<std::string, bufferlist> &map) {
 921   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 922   o->ops.push_back(boost::bind(&TestIoCtxImpl::omap_set, _1, _2, boost::ref(map)));
 923 }
 924
 925 void ObjectWriteOperation::remove() {
 926   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 927   o->ops.push_back(boost::bind(&TestIoCtxImpl::remove, _1, _2, _4));
 928 }
 929
 930 void ObjectWriteOperation::selfmanaged_snap_rollback(uint64_t snapid) {
 931   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 932   o->ops.push_back(boost::bind(&TestIoCtxImpl::selfmanaged_snap_rollback,
 933                                _1, _2, snapid));
 934 }
 935
 936 void ObjectWriteOperation::set_alloc_hint(uint64_t expected_object_size,
 937                                           uint64_t expected_write_size) {
 938   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 939   o->ops.push_back(boost::bind(&TestIoCtxImpl::set_alloc_hint, _1, _2,
 940                                expected_object_size, expected_write_size, _4));
 941 }
 942
 943
 944 void ObjectWriteOperation::tmap_update(const bufferlist& cmdbl) {
 945   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 946   o->ops.push_back(boost::bind(&TestIoCtxImpl::tmap_update, _1, _2,
 947                                cmdbl));
 948 }
 949
 950 void ObjectWriteOperation::truncate(uint64_t off) {
 951   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 952   o->ops.push_back(boost::bind(&TestIoCtxImpl::truncate, _1, _2, off, _4));
 953 }
 954
 955 void ObjectWriteOperation::write(uint64_t off, const bufferlist& bl) {
 956   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 957   o->ops.push_back(boost::bind(&TestIoCtxImpl::write, _1, _2, bl, bl.length(),
 958                                off, _4));
 959 }
 960
 961 void ObjectWriteOperation::write_full(const bufferlist& bl) {
 962   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 963   o->ops.push_back(boost::bind(&TestIoCtxImpl::write_full, _1, _2, bl, _4));
 964 }
 965
 966 void ObjectWriteOperation::writesame(uint64_t off, uint64_t len, const bufferlist& bl) {
 967   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 968   o->ops.push_back(boost::bind(&TestIoCtxImpl::writesame, _1, _2, bl, len,
 969                                off, _4));
 970 }
 971
 972 void ObjectWriteOperation::zero(uint64_t off, uint64_t len) {
 973   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 974   o->ops.push_back(boost::bind(&TestIoCtxImpl::zero, _1, _2, off, len, _4));
 975 }
 976
 977 Rados::Rados() : client(NULL) {
 978 }
 979
 980 Rados::Rados(IoCtx& ioctx) {
 981   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(ioctx.io_ctx_impl);
 982   TestRadosClient *impl = ctx->get_rados_client();
 983   impl->get();
 984
 985   client = reinterpret_cast<RadosClient*>(impl);
 986   ceph_assert(client != NULL);
 987 }
 988
 989 Rados::~Rados() {
 990   shutdown();
 991 }
 992
 993 AioCompletion *Rados::aio_create_completion(void *cb_arg,
 994                                             callback_t cb_complete,
 995                                             callback_t cb_safe) {
 996   AioCompletionImpl *c;
 997   int r = rados_aio_create_completion(cb_arg, cb_complete, cb_safe,
 998       reinterpret_cast<void**>(&c));
 999   ceph_assert(r == 0);
1000   return new AioCompletion(c);
1001 }
1002
1003 int Rados::aio_watch_flush(AioCompletion* c) {
1004   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1005   return impl->aio_watch_flush(c->pc);
1006 }
1007
1008 int Rados::blacklist_add(const std::string& client_address,
1009                          uint32_t expire_seconds) {
1010   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1011   return impl->blacklist_add(client_address, expire_seconds);
1012 }
1013
1014 config_t Rados::cct() {
1015   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1016   return reinterpret_cast<config_t>(impl->cct());
1017 }
1018
1019 int Rados::cluster_fsid(std::string* fsid) {
1020   *fsid = "00000000-1111-2222-3333-444444444444";
1021   return 0;
1022 }
1023
1024 int Rados::conf_set(const char *option, const char *value) {
1025   return rados_conf_set(reinterpret_cast<rados_t>(client), option, value);
1026 }
1027
1028 int Rados::conf_get(const char *option, std::string &val) {
1029   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1030   CephContext *cct = impl->cct();
1031
1032   char *str = NULL;
1033   int ret = cct->_conf.get_val(option, &str, -1);
1034   if (ret != 0) {
1035     free(str);
1036     return ret;
1037   }
1038
1039   val = str;
1040   free(str);
1041   return 0;
1042 }
1043
1044 int Rados::conf_parse_env(const char *env) const {
1045   return rados_conf_parse_env(reinterpret_cast<rados_t>(client), env);
1046 }
1047
1048 int Rados::conf_read_file(const char * const path) const {
1049   return rados_conf_read_file(reinterpret_cast<rados_t>(client), path);
1050 }
1051
1052 int Rados::connect() {
1053   return rados_connect(reinterpret_cast<rados_t>(client));
1054 }
1055
1056 uint64_t Rados::get_instance_id() {
1057   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1058   return impl->get_instance_id();
1059 }
1060
1061 int Rados::get_min_compatible_osd(int8_t* require_osd_release) {
1062   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1063   return impl->get_min_compatible_osd(require_osd_release);
1064 }
1065
1066 int Rados::get_min_compatible_client(int8_t* min_compat_client,
1067                                      int8_t* require_min_compat_client) {
1068   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1069   return impl->get_min_compatible_client(min_compat_client,
1070                                          require_min_compat_client);
1071 }
1072
1073 int Rados::init(const char * const id) {
1074   return rados_create(reinterpret_cast<rados_t *>(&client), id);
1075 }
1076
1077 int Rados::init_with_context(config_t cct_) {
1078   return rados_create_with_context(reinterpret_cast<rados_t *>(&client), cct_);
1079 }
1080
1081 int Rados::ioctx_create(const char *name, IoCtx &io) {
1082   rados_ioctx_t p;
1083   int ret = rados_ioctx_create(reinterpret_cast<rados_t>(client), name, &p);
1084   if (ret) {
1085     return ret;
1086   }
1087
1088   io.close();
1089   io.io_ctx_impl = reinterpret_cast<IoCtxImpl*>(p);
1090   return 0;
1091 }
1092
1093 int Rados::ioctx_create2(int64_t pool_id, IoCtx &io)
1094 {
1095   rados_ioctx_t p;
1096   int ret = rados_ioctx_create2(reinterpret_cast<rados_t>(client), pool_id, &p);
1097   if (ret) {
1098     return ret;
1099   }
1100
1101   io.close();
1102   io.io_ctx_impl = reinterpret_cast<IoCtxImpl*>(p);
1103   return 0;
1104 }
1105
1106 int Rados::mon_command(std::string cmd, const bufferlist& inbl,
1107                        bufferlist *outbl, std::string *outs) {
1108   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1109
1110   std::vector<std::string> cmds;
1111   cmds.push_back(cmd);
1112   return impl->mon_command(cmds, inbl, outbl, outs);
1113 }
1114
1115 int Rados::service_daemon_register(const std::string& service,
1116                                    const std::string& name,
1117                                    const std::map<std::string,std::string>& metadata) {
1118   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1119   return impl->service_daemon_register(service, name, metadata);
1120 }
1121
1122 int Rados::service_daemon_update_status(std::map<std::string,std::string>&& status) {
1123   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1124   return impl->service_daemon_update_status(std::move(status));
1125 }
1126
1127 int Rados::pool_create(const char *name) {
1128   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1129   return impl->pool_create(name);
1130 }
1131
1132 int Rados::pool_delete(const char *name) {
1133   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1134   return impl->pool_delete(name);
1135 }
1136
1137 int Rados::pool_get_base_tier(int64_t pool, int64_t* base_tier) {
1138   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1139   return impl->pool_get_base_tier(pool, base_tier);
1140 }
1141
1142 int Rados::pool_list(std::list<std::string>& v) {
1143   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1144   std::list<std::pair<int64_t, std::string> > pools;
1145   int r = impl->pool_list(pools);
1146   if (r < 0) {
1147     return r;
1148   }
1149
1150   v.clear();
1151   for (std::list<std::pair<int64_t, std::string> >::iterator it = pools.begin();
1152        it != pools.end(); ++it) {
1153     v.push_back(it->second);
1154   }
1155   return 0;
1156 }
1157
1158 int Rados::pool_list2(std::list<std::pair<int64_t, std::string> >& v)
1159 {
1160   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1161   return impl->pool_list(v);
1162 }
1163
1164 int64_t Rados::pool_lookup(const char *name) {
1165   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1166   return impl->pool_lookup(name);
1167 }
1168
1169 int Rados::pool_reverse_lookup(int64_t id, std::string *name) {
1170   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1171   return impl->pool_reverse_lookup(id, name);
1172 }
1173
1174 void Rados::shutdown() {
1175   if (client == NULL) {
1176     return;
1177   }
1178   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1179   impl->put();
1180   client = NULL;
1181 }
1182
1183 void Rados::test_blacklist_self(bool set) {
1184 }
1185
1186 int Rados::wait_for_latest_osdmap() {
1187   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1188   return impl->wait_for_latest_osdmap();
1189 }
1190
1191 int Rados::watch_flush() {
1192   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1193   return impl->watch_flush();
1194 }
1195
1196 WatchCtx::~WatchCtx() {
1197 }
1198
1199 WatchCtx2::~WatchCtx2() {
1200 }
1201
1202 } // namespace librados
1203
1204 int cls_cxx_create(cls_method_context_t hctx, bool exclusive) {
1205   librados::TestClassHandler::MethodContext *ctx =
1206     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1207   return ctx->io_ctx_impl->create(ctx->oid, exclusive);
1208 }
1209
1210 int cls_cxx_remove(cls_method_context_t hctx) {
1211   librados::TestClassHandler::MethodContext *ctx =
1212     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1213   return ctx->io_ctx_impl->remove(ctx->oid, ctx->io_ctx_impl->get_snap_context());
1214 }
1215
1216 int cls_get_request_origin(cls_method_context_t hctx, entity_inst_t *origin) {
1217   librados::TestClassHandler::MethodContext *ctx =
1218     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1219
1220   librados::TestRadosClient *rados_client =
1221     ctx->io_ctx_impl->get_rados_client();
1222
1223   struct sockaddr_in sin;
1224   memset(&sin, 0, sizeof(sin));
1225   sin.sin_family = AF_INET;
1226   sin.sin_port = 0;
1227   inet_pton(AF_INET, "127.0.0.1", &sin.sin_addr);
1228
1229   entity_addr_t entity_addr(entity_addr_t::TYPE_DEFAULT,
1230                             rados_client->get_nonce());
1231   entity_addr.in4_addr() = sin;
1232
1233   *origin = entity_inst_t(
1234     entity_name_t::CLIENT(rados_client->get_instance_id()),
1235     entity_addr);
1236   return 0;
1237 }
1238
1239 int cls_cxx_getxattr(cls_method_context_t hctx, const char *name,
1240                      bufferlist *outbl) {
1241   std::map<string, bufferlist> attrs;
1242   int r = cls_cxx_getxattrs(hctx, &attrs);
1243   if (r < 0) {
1244     return r;
1245   }
1246
1247   std::map<string, bufferlist>::iterator it = attrs.find(name);
1248   if (it == attrs.end()) {
1249     return -ENODATA;
1250   }
1251   *outbl = it->second;
1252   return 0;
1253 }
1254
1255 int cls_cxx_getxattrs(cls_method_context_t hctx, std::map<string, bufferlist> *attrset) {
1256   librados::TestClassHandler::MethodContext *ctx =
1257     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1258   return ctx->io_ctx_impl->xattr_get(ctx->oid, attrset);
1259 }
1260
1261 int cls_cxx_map_get_keys(cls_method_context_t hctx, const string &start_obj,
1262                          uint64_t max_to_get, std::set<string> *keys, bool *more) {
1263   librados::TestClassHandler::MethodContext *ctx =
1264     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1265
1266   keys->clear();
1267   std::map<string, bufferlist> vals;
1268   int r = ctx->io_ctx_impl->omap_get_vals2(ctx->oid, start_obj, "", max_to_get,
1269                                            &vals, more);
1270   if (r < 0) {
1271     return r;
1272   }
1273
1274   for (std::map<string, bufferlist>::iterator it = vals.begin();
1275        it != vals.end(); ++it) {
1276     keys->insert(it->first);
1277   }
1278   return keys->size();
1279 }
1280
1281 int cls_cxx_map_get_val(cls_method_context_t hctx, const string &key,
1282                         bufferlist *outbl) {
1283   librados::TestClassHandler::MethodContext *ctx =
1284     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1285
1286   std::map<string, bufferlist> vals;
1287   int r = ctx->io_ctx_impl->omap_get_vals(ctx->oid, "", key, 1024, &vals);
1288   if (r < 0) {
1289     return r;
1290   }
1291
1292   std::map<string, bufferlist>::iterator it = vals.find(key);
1293   if (it == vals.end()) {
1294     return -ENOENT;
1295   }
1296
1297   *outbl = it->second;
1298   return 0;
1299 }
1300
1301 int cls_cxx_map_get_vals(cls_method_context_t hctx, const string &start_obj,
1302                          const string &filter_prefix, uint64_t max_to_get,
1303                          std::map<string, bufferlist> *vals, bool *more) {
1304   librados::TestClassHandler::MethodContext *ctx =
1305     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1306   int r = ctx->io_ctx_impl->omap_get_vals2(ctx->oid, start_obj, filter_prefix,
1307                                           max_to_get, vals, more);
1308   if (r < 0) {
1309     return r;
1310   }
1311   return vals->size();
1312 }
1313
1314 int cls_cxx_map_remove_key(cls_method_context_t hctx, const string &key) {
1315   std::set<std::string> keys;
1316   keys.insert(key);
1317
1318   librados::TestClassHandler::MethodContext *ctx =
1319     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1320   return ctx->io_ctx_impl->omap_rm_keys(ctx->oid, keys);
1321 }
1322
1323 int cls_cxx_map_set_val(cls_method_context_t hctx, const string &key,
1324                         bufferlist *inbl) {
1325   std::map<std::string, bufferlist> m;
1326   m[key] = *inbl;
1327   return cls_cxx_map_set_vals(hctx, &m);
1328 }
1329
1330 int cls_cxx_map_set_vals(cls_method_context_t hctx,
1331                          const std::map<string, bufferlist> *map) {
1332   librados::TestClassHandler::MethodContext *ctx =
1333     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1334   return ctx->io_ctx_impl->omap_set(ctx->oid, *map);
1335 }
1336
1337 int cls_cxx_read(cls_method_context_t hctx, int ofs, int len,
1338                  bufferlist *outbl) {
1339   return cls_cxx_read2(hctx, ofs, len, outbl, 0);
1340 }
1341
1342 int cls_cxx_read2(cls_method_context_t hctx, int ofs, int len,
1343                   bufferlist *outbl, uint32_t op_flags) {
1344   librados::TestClassHandler::MethodContext *ctx =
1345     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1346   return ctx->io_ctx_impl->read(ctx->oid, len, ofs, outbl);
1347 }
1348
1349 int cls_cxx_setxattr(cls_method_context_t hctx, const char *name,
1350                      bufferlist *inbl) {
1351   librados::TestClassHandler::MethodContext *ctx =
1352     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1353   return ctx->io_ctx_impl->xattr_set(ctx->oid, name, *inbl);
1354 }
1355
1356 int cls_cxx_stat(cls_method_context_t hctx, uint64_t *size, time_t *mtime) {
1357   librados::TestClassHandler::MethodContext *ctx =
1358     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1359   return ctx->io_ctx_impl->stat(ctx->oid, size, mtime);
1360 }
1361
1362 int cls_cxx_write(cls_method_context_t hctx, int ofs, int len,
1363                   bufferlist *inbl) {
1364   return cls_cxx_write2(hctx, ofs, len, inbl, 0);
1365 }
1366
1367 int cls_cxx_write2(cls_method_context_t hctx, int ofs, int len,
1368                    bufferlist *inbl, uint32_t op_flags) {
1369   librados::TestClassHandler::MethodContext *ctx =
1370     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1371   return ctx->io_ctx_impl->write(ctx->oid, *inbl, len, ofs, ctx->snapc);
1372 }
1373
1374 int cls_cxx_write_full(cls_method_context_t hctx, bufferlist *inbl) {
1375   librados::TestClassHandler::MethodContext *ctx =
1376     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1377   return ctx->io_ctx_impl->write_full(ctx->oid, *inbl, ctx->snapc);
1378 }
1379
1380 int cls_cxx_replace(cls_method_context_t hctx, int ofs, int len,
1381                     bufferlist *inbl) {
1382   librados::TestClassHandler::MethodContext *ctx =
1383     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1384   int r = ctx->io_ctx_impl->truncate(ctx->oid, 0, ctx->snapc);
1385   if (r < 0) {
1386     return r;
1387   }
1388   return ctx->io_ctx_impl->write(ctx->oid, *inbl, len, ofs, ctx->snapc);
1389 }
1390
1391 int cls_cxx_list_watchers(cls_method_context_t hctx,
1392                           obj_list_watch_response_t *watchers) {
1393   librados::TestClassHandler::MethodContext *ctx =
1394     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1395
1396   std::list<obj_watch_t> obj_watchers;
1397   int r = ctx->io_ctx_impl->list_watchers(ctx->oid, &obj_watchers);
1398   if (r < 0) {
1399     return r;
1400   }
1401
1402   for (auto &w : obj_watchers) {
1403     watch_item_t watcher;
1404     watcher.name = entity_name_t::CLIENT(w.watcher_id);
1405     watcher.cookie = w.cookie;
1406     watcher.timeout_seconds = w.timeout_seconds;
1407     watcher.addr.parse(w.addr, 0);
1408     watchers->entries.push_back(watcher);
1409   }
1410
1411   return 0;
1412 }
1413
1414 uint64_t cls_get_features(cls_method_context_t hctx) {
1415   return CEPH_FEATURES_SUPPORTED_DEFAULT;
1416 }
1417
1418 uint64_t cls_get_client_features(cls_method_context_t hctx) {
1419   return CEPH_FEATURES_SUPPORTED_DEFAULT;
1420 }
1421
1422 int cls_get_snapset_seq(cls_method_context_t hctx, uint64_t *snap_seq) {
1423   librados::TestClassHandler::MethodContext *ctx =
1424     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1425   librados::snap_set_t snapset;
1426   int r = ctx->io_ctx_impl->list_snaps(ctx->oid, &snapset);
1427   if (r < 0) {
1428     return r;
1429   }
1430
1431   *snap_seq = snapset.seq;
1432   return 0;
1433 }
1434
1435 int cls_log(int level, const char *format, ...) {
1436   int size = 256;
1437   va_list ap;
1438   while (1) {
1439     char buf[size];
1440     va_start(ap, format);
1441     int n = vsnprintf(buf, size, format, ap);
1442     va_end(ap);
1443     if ((n > -1 && n < size) || size > 8196) {
1444       dout(ceph::dout::need_dynamic(level)) << buf << dendl;
1445       return n;
1446     }
1447     size *= 2;
1448   }
1449   return 0;
1450 }
1451
1452 int cls_register(const char *name, cls_handle_t *handle) {
1453   librados::TestClassHandler *cls = get_class_handler();
1454   return cls->create(name, handle);
1455 }
1456
1457 int cls_register_cxx_method(cls_handle_t hclass, const char *method,
1458     int flags,
1459     cls_method_cxx_call_t class_call,
1460     cls_method_handle_t *handle) {
1461   librados::TestClassHandler *cls = get_class_handler();
1462   return cls->create_method(hclass, method, class_call, handle);
1463 }
1464
1465 int cls_register_cxx_filter(cls_handle_t hclass,
1466                             const std::string &filter_name,
1467                             cls_cxx_filter_factory_t fn,
1468                             cls_filter_handle_t *)
1469 {
1470   librados::TestClassHandler *cls = get_class_handler();
1471   return cls->create_filter(hclass, filter_name, fn);
1472 }
1473
1474 int8_t cls_get_required_osd_release(cls_handle_t hclass) {
1475   return CEPH_FEATURE_SERVER_NAUTILUS;
1476 }