1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2 // vim: ts=8 sw=2 smarttab
4 * Ceph - scalable distributed file system
6 * Copyright (C) 2004-2012 Sage Weil <sage@newdream.net>
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.
17 #include "common/config.h"
18 #include "common/errno.h"
19 #include "common/ceph_argparse.h"
20 #include "common/ceph_json.h"
21 #include "common/common_init.h"
22 #include "common/TracepointProvider.h"
23 #include "common/hobject.h"
24 #include "include/rados/librados.h"
25 #include "include/rados/librados.hpp"
26 #include "include/types.h"
27 #include <include/stringify.h>
29 #include "librados/AioCompletionImpl.h"
30 #include "librados/IoCtxImpl.h"
31 #include "librados/PoolAsyncCompletionImpl.h"
32 #include "librados/RadosClient.h"
33 #include "librados/RadosXattrIter.h"
34 #include "librados/ListObjectImpl.h"
35 #include <cls/lock/cls_lock_client.h>
45 #define TRACEPOINT_DEFINE
46 #define TRACEPOINT_PROBE_DYNAMIC_LINKAGE
47 #include "tracing/librados.h"
48 #undef TRACEPOINT_PROBE_DYNAMIC_LINKAGE
49 #undef TRACEPOINT_DEFINE
51 #define tracepoint(...)
59 using std::runtime_error
;
61 #define dout_subsys ceph_subsys_rados
63 #define dout_prefix *_dout << "librados: "
65 #define RADOS_LIST_MAX_ENTRIES 1024
69 TracepointProvider::Traits
tracepoint_traits("librados_tp.so", "rados_tracing");
71 uint8_t get_checksum_op_type(rados_checksum_type_t type
) {
73 case LIBRADOS_CHECKSUM_TYPE_XXHASH32
:
74 return CEPH_OSD_CHECKSUM_OP_TYPE_XXHASH32
;
75 case LIBRADOS_CHECKSUM_TYPE_XXHASH64
:
76 return CEPH_OSD_CHECKSUM_OP_TYPE_XXHASH64
;
77 case LIBRADOS_CHECKSUM_TYPE_CRC32C
:
78 return CEPH_OSD_CHECKSUM_OP_TYPE_CRC32C
;
84 } // anonymous namespace
87 * Structure of this file
89 * RadosClient and the related classes are the internal implementation of librados.
90 * Above that layer sits the C API, found in include/rados/librados.h, and
91 * the C++ API, found in include/rados/librados.hpp
93 * The C++ API sometimes implements things in terms of the C API.
94 * Both the C++ and C API rely on RadosClient.
97 * +--------------------------------------+
99 * +--------------------+ |
101 * +--------------------+-----------------+
103 * +--------------------------------------+
108 struct ObjectOperationImpl
{
113 ObjectOperationImpl() : prt(NULL
) {}
118 size_t librados::ObjectOperation::size()
120 ::ObjectOperation
*o
= &impl
->o
;
124 static void set_op_flags(::ObjectOperation
*o
, int flags
)
127 if (flags
& LIBRADOS_OP_FLAG_EXCL
)
128 rados_flags
|= CEPH_OSD_OP_FLAG_EXCL
;
129 if (flags
& LIBRADOS_OP_FLAG_FAILOK
)
130 rados_flags
|= CEPH_OSD_OP_FLAG_FAILOK
;
131 if (flags
& LIBRADOS_OP_FLAG_FADVISE_RANDOM
)
132 rados_flags
|= CEPH_OSD_OP_FLAG_FADVISE_RANDOM
;
133 if (flags
& LIBRADOS_OP_FLAG_FADVISE_SEQUENTIAL
)
134 rados_flags
|= CEPH_OSD_OP_FLAG_FADVISE_SEQUENTIAL
;
135 if (flags
& LIBRADOS_OP_FLAG_FADVISE_WILLNEED
)
136 rados_flags
|= CEPH_OSD_OP_FLAG_FADVISE_WILLNEED
;
137 if (flags
& LIBRADOS_OP_FLAG_FADVISE_DONTNEED
)
138 rados_flags
|= CEPH_OSD_OP_FLAG_FADVISE_DONTNEED
;
139 if (flags
& LIBRADOS_OP_FLAG_FADVISE_NOCACHE
)
140 rados_flags
|= CEPH_OSD_OP_FLAG_FADVISE_NOCACHE
;
141 o
->set_last_op_flags(rados_flags
);
145 void librados::ObjectOperation::set_op_flags(ObjectOperationFlags flags
)
147 ::set_op_flags(&impl
->o
, (int)flags
);
150 void librados::ObjectOperation::set_op_flags2(int flags
)
152 ::ObjectOperation
*o
= &impl
->o
;
153 ::set_op_flags(o
, flags
);
156 void librados::ObjectOperation::cmpext(uint64_t off
,
160 ::ObjectOperation
*o
= &impl
->o
;
161 o
->cmpext(off
, cmp_bl
, prval
);
164 void librados::ObjectOperation::cmpxattr(const char *name
, uint8_t op
, const bufferlist
& v
)
166 ::ObjectOperation
*o
= &impl
->o
;
167 o
->cmpxattr(name
, op
, CEPH_OSD_CMPXATTR_MODE_STRING
, v
);
170 void librados::ObjectOperation::cmpxattr(const char *name
, uint8_t op
, uint64_t v
)
172 ::ObjectOperation
*o
= &impl
->o
;
175 o
->cmpxattr(name
, op
, CEPH_OSD_CMPXATTR_MODE_U64
, bl
);
178 void librados::ObjectOperation::assert_version(uint64_t ver
)
180 ::ObjectOperation
*o
= &impl
->o
;
181 o
->assert_version(ver
);
184 void librados::ObjectOperation::assert_exists()
186 ::ObjectOperation
*o
= &impl
->o
;
187 o
->stat(NULL
, (ceph::real_time
*) NULL
, NULL
);
190 void librados::ObjectOperation::exec(const char *cls
, const char *method
, bufferlist
& inbl
)
192 ::ObjectOperation
*o
= &impl
->o
;
193 o
->call(cls
, method
, inbl
);
196 void librados::ObjectOperation::exec(const char *cls
, const char *method
, bufferlist
& inbl
, bufferlist
*outbl
, int *prval
)
198 ::ObjectOperation
*o
= &impl
->o
;
199 o
->call(cls
, method
, inbl
, outbl
, NULL
, prval
);
202 class ObjectOpCompletionCtx
: public Context
{
203 librados::ObjectOperationCompletion
*completion
;
206 explicit ObjectOpCompletionCtx(librados::ObjectOperationCompletion
*c
) : completion(c
) {}
207 void finish(int r
) override
{
208 completion
->handle_completion(r
, bl
);
212 bufferlist
*outbl() {
217 void librados::ObjectOperation::exec(const char *cls
, const char *method
, bufferlist
& inbl
, librados::ObjectOperationCompletion
*completion
)
219 ::ObjectOperation
*o
= &impl
->o
;
221 ObjectOpCompletionCtx
*ctx
= new ObjectOpCompletionCtx(completion
);
223 o
->call(cls
, method
, inbl
, ctx
->outbl(), ctx
, NULL
);
226 void librados::ObjectReadOperation::stat(uint64_t *psize
, time_t *pmtime
, int *prval
)
228 ::ObjectOperation
*o
= &impl
->o
;
229 o
->stat(psize
, pmtime
, prval
);
232 void librados::ObjectReadOperation::stat2(uint64_t *psize
, struct timespec
*pts
, int *prval
)
234 ::ObjectOperation
*o
= &impl
->o
;
235 o
->stat(psize
, pts
, prval
);
238 void librados::ObjectReadOperation::read(size_t off
, uint64_t len
, bufferlist
*pbl
, int *prval
)
240 ::ObjectOperation
*o
= &impl
->o
;
241 o
->read(off
, len
, pbl
, prval
, NULL
);
244 void librados::ObjectReadOperation::sparse_read(uint64_t off
, uint64_t len
,
245 std::map
<uint64_t,uint64_t> *m
,
246 bufferlist
*data_bl
, int *prval
)
248 ::ObjectOperation
*o
= &impl
->o
;
249 o
->sparse_read(off
, len
, m
, data_bl
, prval
);
252 void librados::ObjectReadOperation::checksum(rados_checksum_type_t type
,
253 const bufferlist
&init_value_bl
,
254 uint64_t off
, size_t len
,
255 size_t chunk_size
, bufferlist
*pbl
,
258 ::ObjectOperation
*o
= &impl
->o
;
259 o
->checksum(get_checksum_op_type(type
), init_value_bl
, off
, len
, chunk_size
,
260 pbl
, prval
, nullptr);
263 void librados::ObjectReadOperation::tmap_get(bufferlist
*pbl
, int *prval
)
265 ::ObjectOperation
*o
= &impl
->o
;
266 o
->tmap_get(pbl
, prval
);
269 void librados::ObjectReadOperation::getxattr(const char *name
, bufferlist
*pbl
, int *prval
)
271 ::ObjectOperation
*o
= &impl
->o
;
272 o
->getxattr(name
, pbl
, prval
);
275 void librados::ObjectReadOperation::omap_get_vals(
276 const std::string
&start_after
,
277 const std::string
&filter_prefix
,
279 std::map
<std::string
, bufferlist
> *out_vals
,
282 ::ObjectOperation
*o
= &impl
->o
;
283 o
->omap_get_vals(start_after
, filter_prefix
, max_return
, out_vals
, nullptr,
287 void librados::ObjectReadOperation::omap_get_vals2(
288 const std::string
&start_after
,
289 const std::string
&filter_prefix
,
291 std::map
<std::string
, bufferlist
> *out_vals
,
295 ::ObjectOperation
*o
= &impl
->o
;
296 o
->omap_get_vals(start_after
, filter_prefix
, max_return
, out_vals
, pmore
,
300 void librados::ObjectReadOperation::omap_get_vals(
301 const std::string
&start_after
,
303 std::map
<std::string
, bufferlist
> *out_vals
,
306 ::ObjectOperation
*o
= &impl
->o
;
307 o
->omap_get_vals(start_after
, "", max_return
, out_vals
, nullptr, prval
);
310 void librados::ObjectReadOperation::omap_get_vals2(
311 const std::string
&start_after
,
313 std::map
<std::string
, bufferlist
> *out_vals
,
317 ::ObjectOperation
*o
= &impl
->o
;
318 o
->omap_get_vals(start_after
, "", max_return
, out_vals
, pmore
, prval
);
321 void librados::ObjectReadOperation::omap_get_keys(
322 const std::string
&start_after
,
324 std::set
<std::string
> *out_keys
,
327 ::ObjectOperation
*o
= &impl
->o
;
328 o
->omap_get_keys(start_after
, max_return
, out_keys
, nullptr, prval
);
331 void librados::ObjectReadOperation::omap_get_keys2(
332 const std::string
&start_after
,
334 std::set
<std::string
> *out_keys
,
338 ::ObjectOperation
*o
= &impl
->o
;
339 o
->omap_get_keys(start_after
, max_return
, out_keys
, pmore
, prval
);
342 void librados::ObjectReadOperation::omap_get_header(bufferlist
*bl
, int *prval
)
344 ::ObjectOperation
*o
= &impl
->o
;
345 o
->omap_get_header(bl
, prval
);
348 void librados::ObjectReadOperation::omap_get_vals_by_keys(
349 const std::set
<std::string
> &keys
,
350 std::map
<std::string
, bufferlist
> *map
,
353 ::ObjectOperation
*o
= &impl
->o
;
354 o
->omap_get_vals_by_keys(keys
, map
, prval
);
357 void librados::ObjectOperation::omap_cmp(
358 const std::map
<std::string
, pair
<bufferlist
, int> > &assertions
,
361 ::ObjectOperation
*o
= &impl
->o
;
362 o
->omap_cmp(assertions
, prval
);
365 void librados::ObjectReadOperation::list_watchers(
366 list
<obj_watch_t
> *out_watchers
,
369 ::ObjectOperation
*o
= &impl
->o
;
370 o
->list_watchers(out_watchers
, prval
);
373 void librados::ObjectReadOperation::list_snaps(
374 snap_set_t
*out_snaps
,
377 ::ObjectOperation
*o
= &impl
->o
;
378 o
->list_snaps(out_snaps
, prval
);
381 void librados::ObjectReadOperation::is_dirty(bool *is_dirty
, int *prval
)
383 ::ObjectOperation
*o
= &impl
->o
;
384 o
->is_dirty(is_dirty
, prval
);
387 int librados::IoCtx::omap_get_vals(const std::string
& oid
,
388 const std::string
& orig_start_after
,
389 const std::string
& filter_prefix
,
391 std::map
<std::string
, bufferlist
> *out_vals
)
394 string start_after
= orig_start_after
;
396 while (max_return
> 0 && more
) {
397 std::map
<std::string
,bufferlist
> out
;
398 ObjectReadOperation op
;
399 op
.omap_get_vals2(start_after
, filter_prefix
, max_return
, &out
, &more
,
402 int ret
= operate(oid
, &op
, &bl
);
408 return -EINVAL
; // wth
410 start_after
= out
.rbegin()->first
;
412 if (out
.size() <= max_return
) {
413 max_return
-= out
.size();
421 out_vals
->insert(out
.begin(), out
.end());
428 int librados::IoCtx::omap_get_vals2(
429 const std::string
& oid
,
430 const std::string
& start_after
,
431 const std::string
& filter_prefix
,
433 std::map
<std::string
, bufferlist
> *out_vals
,
436 ObjectReadOperation op
;
438 op
.omap_get_vals2(start_after
, filter_prefix
, max_return
, out_vals
, pmore
, &r
);
440 int ret
= operate(oid
, &op
, &bl
);
446 void librados::ObjectReadOperation::getxattrs(map
<string
, bufferlist
> *pattrs
, int *prval
)
448 ::ObjectOperation
*o
= &impl
->o
;
449 o
->getxattrs(pattrs
, prval
);
452 void librados::ObjectWriteOperation::mtime(time_t *pt
)
455 impl
->rt
= ceph::real_clock::from_time_t(*pt
);
456 impl
->prt
= &impl
->rt
;
460 void librados::ObjectWriteOperation::mtime2(struct timespec
*pts
)
463 impl
->rt
= ceph::real_clock::from_timespec(*pts
);
464 impl
->prt
= &impl
->rt
;
468 void librados::ObjectWriteOperation::create(bool exclusive
)
470 ::ObjectOperation
*o
= &impl
->o
;
471 o
->create(exclusive
);
474 void librados::ObjectWriteOperation::create(bool exclusive
,
475 const std::string
& category
) // unused
477 ::ObjectOperation
*o
= &impl
->o
;
478 o
->create(exclusive
);
481 void librados::ObjectWriteOperation::write(uint64_t off
, const bufferlist
& bl
)
483 ::ObjectOperation
*o
= &impl
->o
;
488 void librados::ObjectWriteOperation::write_full(const bufferlist
& bl
)
490 ::ObjectOperation
*o
= &impl
->o
;
495 void librados::ObjectWriteOperation::writesame(uint64_t off
, uint64_t write_len
,
496 const bufferlist
& bl
)
498 ::ObjectOperation
*o
= &impl
->o
;
500 o
->writesame(off
, write_len
, c
);
503 void librados::ObjectWriteOperation::append(const bufferlist
& bl
)
505 ::ObjectOperation
*o
= &impl
->o
;
510 void librados::ObjectWriteOperation::remove()
512 ::ObjectOperation
*o
= &impl
->o
;
516 void librados::ObjectWriteOperation::truncate(uint64_t off
)
518 ::ObjectOperation
*o
= &impl
->o
;
522 void librados::ObjectWriteOperation::zero(uint64_t off
, uint64_t len
)
524 ::ObjectOperation
*o
= &impl
->o
;
528 void librados::ObjectWriteOperation::rmxattr(const char *name
)
530 ::ObjectOperation
*o
= &impl
->o
;
534 void librados::ObjectWriteOperation::setxattr(const char *name
, const bufferlist
& v
)
536 ::ObjectOperation
*o
= &impl
->o
;
537 o
->setxattr(name
, v
);
540 void librados::ObjectWriteOperation::omap_set(
541 const map
<string
, bufferlist
> &map
)
543 ::ObjectOperation
*o
= &impl
->o
;
547 void librados::ObjectWriteOperation::omap_set_header(const bufferlist
&bl
)
550 ::ObjectOperation
*o
= &impl
->o
;
551 o
->omap_set_header(c
);
554 void librados::ObjectWriteOperation::omap_clear()
556 ::ObjectOperation
*o
= &impl
->o
;
560 void librados::ObjectWriteOperation::omap_rm_keys(
561 const std::set
<std::string
> &to_rm
)
563 ::ObjectOperation
*o
= &impl
->o
;
564 o
->omap_rm_keys(to_rm
);
567 void librados::ObjectWriteOperation::copy_from(const std::string
& src
,
568 const IoCtx
& src_ioctx
,
569 uint64_t src_version
)
571 copy_from2(src
, src_ioctx
, src_version
, 0);
574 void librados::ObjectWriteOperation::copy_from2(const std::string
& src
,
575 const IoCtx
& src_ioctx
,
576 uint64_t src_version
,
577 uint32_t src_fadvise_flags
)
579 ::ObjectOperation
*o
= &impl
->o
;
580 o
->copy_from(object_t(src
), src_ioctx
.io_ctx_impl
->snap_seq
,
581 src_ioctx
.io_ctx_impl
->oloc
, src_version
, 0, src_fadvise_flags
);
584 void librados::ObjectWriteOperation::undirty()
586 ::ObjectOperation
*o
= &impl
->o
;
590 void librados::ObjectReadOperation::cache_flush()
592 ::ObjectOperation
*o
= &impl
->o
;
596 void librados::ObjectReadOperation::cache_try_flush()
598 ::ObjectOperation
*o
= &impl
->o
;
599 o
->cache_try_flush();
602 void librados::ObjectReadOperation::cache_evict()
604 ::ObjectOperation
*o
= &impl
->o
;
608 void librados::ObjectWriteOperation::set_redirect(const std::string
& tgt_obj
,
609 const IoCtx
& tgt_ioctx
,
610 uint64_t tgt_version
)
612 ::ObjectOperation
*o
= &impl
->o
;
613 o
->set_redirect(object_t(tgt_obj
), tgt_ioctx
.io_ctx_impl
->snap_seq
,
614 tgt_ioctx
.io_ctx_impl
->oloc
, tgt_version
);
617 void librados::ObjectWriteOperation::tmap_put(const bufferlist
&bl
)
619 ::ObjectOperation
*o
= &impl
->o
;
624 void librados::ObjectWriteOperation::tmap_update(const bufferlist
& cmdbl
)
626 ::ObjectOperation
*o
= &impl
->o
;
627 bufferlist c
= cmdbl
;
631 void librados::ObjectWriteOperation::selfmanaged_snap_rollback(snap_t snapid
)
633 ::ObjectOperation
*o
= &impl
->o
;
637 // You must specify the snapid not the name normally used with pool snapshots
638 void librados::ObjectWriteOperation::snap_rollback(snap_t snapid
)
640 ::ObjectOperation
*o
= &impl
->o
;
644 void librados::ObjectWriteOperation::set_alloc_hint(
645 uint64_t expected_object_size
,
646 uint64_t expected_write_size
)
648 ::ObjectOperation
*o
= &impl
->o
;
649 o
->set_alloc_hint(expected_object_size
, expected_write_size
, 0);
651 void librados::ObjectWriteOperation::set_alloc_hint2(
652 uint64_t expected_object_size
,
653 uint64_t expected_write_size
,
656 ::ObjectOperation
*o
= &impl
->o
;
657 o
->set_alloc_hint(expected_object_size
, expected_write_size
, flags
);
660 void librados::ObjectWriteOperation::cache_pin()
662 ::ObjectOperation
*o
= &impl
->o
;
666 void librados::ObjectWriteOperation::cache_unpin()
668 ::ObjectOperation
*o
= &impl
->o
;
677 librados::WatchCtx2::
683 struct librados::ObjListCtx
{
684 librados::IoCtxImpl dupctx
;
685 librados::IoCtxImpl
*ctx
;
686 Objecter::NListContext
*nlc
;
687 bool legacy_list_api
;
689 ObjListCtx(IoCtxImpl
*c
, Objecter::NListContext
*nl
, bool legacy
=false)
691 legacy_list_api(legacy
) {
692 // Get our own private IoCtxImpl so that namespace setting isn't
693 // changed by caller between uses.
703 ///////////////////////////// NObjectIteratorImpl /////////////////////////////
704 librados::NObjectIteratorImpl::NObjectIteratorImpl(ObjListCtx
*ctx_
)
709 librados::NObjectIteratorImpl::~NObjectIteratorImpl()
714 librados::NObjectIteratorImpl::NObjectIteratorImpl(const NObjectIteratorImpl
&rhs
)
719 librados::NObjectIteratorImpl
& librados::NObjectIteratorImpl::operator=(const librados::NObjectIteratorImpl
&rhs
)
723 if (rhs
.ctx
.get() == NULL
) {
727 Objecter::NListContext
*list_ctx
= new Objecter::NListContext(*rhs
.ctx
->nlc
);
728 ctx
.reset(new ObjListCtx(rhs
.ctx
->ctx
, list_ctx
));
729 cur_obj
= rhs
.cur_obj
;
733 bool librados::NObjectIteratorImpl::operator==(const librados::NObjectIteratorImpl
& rhs
) const {
735 if (ctx
.get() == NULL
) {
736 if (rhs
.ctx
.get() == NULL
)
738 return rhs
.ctx
->nlc
->at_end();
740 if (rhs
.ctx
.get() == NULL
) {
741 // Redundant but same as ObjectIterator version
742 if (ctx
.get() == NULL
)
744 return ctx
->nlc
->at_end();
746 return ctx
.get() == rhs
.ctx
.get();
749 bool librados::NObjectIteratorImpl::operator!=(const librados::NObjectIteratorImpl
& rhs
) const {
750 return !(*this == rhs
);
753 const librados::ListObject
& librados::NObjectIteratorImpl::operator*() const {
757 const librados::ListObject
* librados::NObjectIteratorImpl::operator->() const {
761 librados::NObjectIteratorImpl
& librados::NObjectIteratorImpl::operator++()
767 librados::NObjectIteratorImpl
librados::NObjectIteratorImpl::operator++(int)
769 librados::NObjectIteratorImpl
ret(*this);
774 uint32_t librados::NObjectIteratorImpl::seek(uint32_t pos
)
776 uint32_t r
= rados_nobjects_list_seek(ctx
.get(), pos
);
781 uint32_t librados::NObjectIteratorImpl::seek(const ObjectCursor
& cursor
)
783 uint32_t r
= rados_nobjects_list_seek_cursor(ctx
.get(), (rados_object_list_cursor
)cursor
.c_cursor
);
788 librados::ObjectCursor
librados::NObjectIteratorImpl::get_cursor()
790 librados::ObjListCtx
*lh
= (librados::ObjListCtx
*)ctx
.get();
791 librados::ObjectCursor oc
;
792 oc
.set(lh
->ctx
->nlist_get_cursor(lh
->nlc
));
796 void librados::NObjectIteratorImpl::set_filter(const bufferlist
&bl
)
799 ctx
->nlc
->filter
= bl
;
802 void librados::NObjectIteratorImpl::get_next()
804 const char *entry
, *key
, *nspace
;
805 if (ctx
->nlc
->at_end())
807 int ret
= rados_nobjects_list_next(ctx
.get(), &entry
, &key
, &nspace
);
808 if (ret
== -ENOENT
) {
813 oss
<< "rados returned " << cpp_strerror(ret
);
814 throw std::runtime_error(oss
.str());
817 if (cur_obj
.impl
== NULL
)
818 cur_obj
.impl
= new ListObjectImpl();
819 cur_obj
.impl
->nspace
= nspace
;
820 cur_obj
.impl
->oid
= entry
;
821 cur_obj
.impl
->locator
= key
? key
: string();
824 uint32_t librados::NObjectIteratorImpl::get_pg_hash_position() const
826 return ctx
->nlc
->get_pg_hash_position();
829 ///////////////////////////// NObjectIterator /////////////////////////////
830 librados::NObjectIterator::NObjectIterator(ObjListCtx
*ctx_
)
832 impl
= new NObjectIteratorImpl(ctx_
);
835 librados::NObjectIterator::~NObjectIterator()
840 librados::NObjectIterator::NObjectIterator(const NObjectIterator
&rhs
)
842 if (rhs
.impl
== NULL
) {
846 impl
= new NObjectIteratorImpl();
850 librados::NObjectIterator
& librados::NObjectIterator::operator=(const librados::NObjectIterator
&rhs
)
852 if (rhs
.impl
== NULL
) {
858 impl
= new NObjectIteratorImpl();
863 bool librados::NObjectIterator::operator==(const librados::NObjectIterator
& rhs
) const
865 if (impl
&& rhs
.impl
) {
866 return *impl
== *(rhs
.impl
);
868 return impl
== rhs
.impl
;
872 bool librados::NObjectIterator::operator!=(const librados::NObjectIterator
& rhs
) const
874 return !(*this == rhs
);
877 const librados::ListObject
& librados::NObjectIterator::operator*() const {
879 return *(impl
->get_listobjectp());
882 const librados::ListObject
* librados::NObjectIterator::operator->() const {
884 return impl
->get_listobjectp();
887 librados::NObjectIterator
& librados::NObjectIterator::operator++()
894 librados::NObjectIterator
librados::NObjectIterator::operator++(int)
896 librados::NObjectIterator
ret(*this);
901 uint32_t librados::NObjectIterator::seek(uint32_t pos
)
904 return impl
->seek(pos
);
907 uint32_t librados::NObjectIterator::seek(const ObjectCursor
& cursor
)
910 return impl
->seek(cursor
);
913 librados::ObjectCursor
librados::NObjectIterator::get_cursor()
916 return impl
->get_cursor();
919 void librados::NObjectIterator::set_filter(const bufferlist
&bl
)
921 impl
->set_filter(bl
);
924 void librados::NObjectIterator::get_next()
930 uint32_t librados::NObjectIterator::get_pg_hash_position() const
933 return impl
->get_pg_hash_position();
936 const librados::NObjectIterator
librados::NObjectIterator::__EndObjectIterator(NULL
);
938 ///////////////////////////// PoolAsyncCompletion //////////////////////////////
939 int librados::PoolAsyncCompletion::PoolAsyncCompletion::set_callback(void *cb_arg
,
942 PoolAsyncCompletionImpl
*c
= (PoolAsyncCompletionImpl
*)pc
;
943 return c
->set_callback(cb_arg
, cb
);
946 int librados::PoolAsyncCompletion::PoolAsyncCompletion::wait()
948 PoolAsyncCompletionImpl
*c
= (PoolAsyncCompletionImpl
*)pc
;
952 bool librados::PoolAsyncCompletion::PoolAsyncCompletion::is_complete()
954 PoolAsyncCompletionImpl
*c
= (PoolAsyncCompletionImpl
*)pc
;
955 return c
->is_complete();
958 int librados::PoolAsyncCompletion::PoolAsyncCompletion::get_return_value()
960 PoolAsyncCompletionImpl
*c
= (PoolAsyncCompletionImpl
*)pc
;
961 return c
->get_return_value();
964 void librados::PoolAsyncCompletion::PoolAsyncCompletion::release()
966 PoolAsyncCompletionImpl
*c
= (PoolAsyncCompletionImpl
*)pc
;
971 ///////////////////////////// AioCompletion //////////////////////////////
972 int librados::AioCompletion::AioCompletion::set_complete_callback(void *cb_arg
, rados_callback_t cb
)
974 AioCompletionImpl
*c
= (AioCompletionImpl
*)pc
;
975 return c
->set_complete_callback(cb_arg
, cb
);
978 int librados::AioCompletion::AioCompletion::set_safe_callback(void *cb_arg
, rados_callback_t cb
)
980 AioCompletionImpl
*c
= (AioCompletionImpl
*)pc
;
981 return c
->set_safe_callback(cb_arg
, cb
);
984 int librados::AioCompletion::AioCompletion::wait_for_complete()
986 AioCompletionImpl
*c
= (AioCompletionImpl
*)pc
;
987 return c
->wait_for_complete();
990 int librados::AioCompletion::AioCompletion::wait_for_safe()
992 AioCompletionImpl
*c
= (AioCompletionImpl
*)pc
;
993 return c
->wait_for_safe();
996 bool librados::AioCompletion::AioCompletion::is_complete()
998 AioCompletionImpl
*c
= (AioCompletionImpl
*)pc
;
999 return c
->is_complete();
1002 bool librados::AioCompletion::AioCompletion::is_safe()
1004 AioCompletionImpl
*c
= (AioCompletionImpl
*)pc
;
1005 return c
->is_safe();
1008 int librados::AioCompletion::AioCompletion::wait_for_complete_and_cb()
1010 AioCompletionImpl
*c
= (AioCompletionImpl
*)pc
;
1011 return c
->wait_for_complete_and_cb();
1014 int librados::AioCompletion::AioCompletion::wait_for_safe_and_cb()
1016 AioCompletionImpl
*c
= (AioCompletionImpl
*)pc
;
1017 return c
->wait_for_safe_and_cb();
1020 bool librados::AioCompletion::AioCompletion::is_complete_and_cb()
1022 AioCompletionImpl
*c
= (AioCompletionImpl
*)pc
;
1023 return c
->is_complete_and_cb();
1026 bool librados::AioCompletion::AioCompletion::is_safe_and_cb()
1028 AioCompletionImpl
*c
= (AioCompletionImpl
*)pc
;
1029 return c
->is_safe_and_cb();
1032 int librados::AioCompletion::AioCompletion::get_return_value()
1034 AioCompletionImpl
*c
= (AioCompletionImpl
*)pc
;
1035 return c
->get_return_value();
1038 int librados::AioCompletion::AioCompletion::get_version()
1040 AioCompletionImpl
*c
= (AioCompletionImpl
*)pc
;
1041 return c
->get_version();
1044 uint64_t librados::AioCompletion::AioCompletion::get_version64()
1046 AioCompletionImpl
*c
= (AioCompletionImpl
*)pc
;
1047 return c
->get_version();
1050 void librados::AioCompletion::AioCompletion::release()
1052 AioCompletionImpl
*c
= (AioCompletionImpl
*)pc
;
1057 ///////////////////////////// IoCtx //////////////////////////////
1058 librados::IoCtx::IoCtx() : io_ctx_impl(NULL
)
1062 void librados::IoCtx::from_rados_ioctx_t(rados_ioctx_t p
, IoCtx
&io
)
1064 IoCtxImpl
*io_ctx_impl
= (IoCtxImpl
*)p
;
1066 io
.io_ctx_impl
= io_ctx_impl
;
1072 librados::IoCtx::IoCtx(const IoCtx
& rhs
)
1074 io_ctx_impl
= rhs
.io_ctx_impl
;
1080 librados::IoCtx
& librados::IoCtx::operator=(const IoCtx
& rhs
)
1084 io_ctx_impl
= rhs
.io_ctx_impl
;
1089 librados::IoCtx::~IoCtx()
1094 void librados::IoCtx::close()
1101 void librados::IoCtx::dup(const IoCtx
& rhs
)
1105 io_ctx_impl
= new IoCtxImpl();
1107 io_ctx_impl
->dup(*rhs
.io_ctx_impl
);
1110 int librados::IoCtx::set_auid(uint64_t auid_
)
1112 return io_ctx_impl
->pool_change_auid(auid_
);
1115 int librados::IoCtx::set_auid_async(uint64_t auid_
, PoolAsyncCompletion
*c
)
1117 return io_ctx_impl
->pool_change_auid_async(auid_
, c
->pc
);
1120 int librados::IoCtx::get_auid(uint64_t *auid_
)
1122 return rados_ioctx_pool_get_auid(io_ctx_impl
, auid_
);
1125 bool librados::IoCtx::pool_requires_alignment()
1127 return io_ctx_impl
->client
->pool_requires_alignment(get_id());
1130 int librados::IoCtx::pool_requires_alignment2(bool *requires
)
1132 return io_ctx_impl
->client
->pool_requires_alignment2(get_id(), requires
);
1135 uint64_t librados::IoCtx::pool_required_alignment()
1137 return io_ctx_impl
->client
->pool_required_alignment(get_id());
1140 int librados::IoCtx::pool_required_alignment2(uint64_t *alignment
)
1142 return io_ctx_impl
->client
->pool_required_alignment2(get_id(), alignment
);
1145 std::string
librados::IoCtx::get_pool_name()
1148 io_ctx_impl
->client
->pool_get_name(get_id(), &s
);
1152 std::string
librados::IoCtx::get_pool_name() const
1154 return io_ctx_impl
->get_cached_pool_name();
1157 uint64_t librados::IoCtx::get_instance_id() const
1159 return io_ctx_impl
->client
->get_instance_id();
1162 int librados::IoCtx::create(const std::string
& oid
, bool exclusive
)
1165 return io_ctx_impl
->create(obj
, exclusive
);
1168 int librados::IoCtx::create(const std::string
& oid
, bool exclusive
,
1169 const std::string
& category
) // unused
1172 return io_ctx_impl
->create(obj
, exclusive
);
1175 int librados::IoCtx::write(const std::string
& oid
, bufferlist
& bl
, size_t len
, uint64_t off
)
1178 return io_ctx_impl
->write(obj
, bl
, len
, off
);
1181 int librados::IoCtx::append(const std::string
& oid
, bufferlist
& bl
, size_t len
)
1184 return io_ctx_impl
->append(obj
, bl
, len
);
1187 int librados::IoCtx::write_full(const std::string
& oid
, bufferlist
& bl
)
1190 return io_ctx_impl
->write_full(obj
, bl
);
1193 int librados::IoCtx::writesame(const std::string
& oid
, bufferlist
& bl
,
1194 size_t write_len
, uint64_t off
)
1197 return io_ctx_impl
->writesame(obj
, bl
, write_len
, off
);
1201 int librados::IoCtx::read(const std::string
& oid
, bufferlist
& bl
, size_t len
, uint64_t off
)
1204 return io_ctx_impl
->read(obj
, bl
, len
, off
);
1207 int librados::IoCtx::checksum(const std::string
& oid
,
1208 rados_checksum_type_t type
,
1209 const bufferlist
&init_value_bl
, size_t len
,
1210 uint64_t off
, size_t chunk_size
, bufferlist
*pbl
)
1213 return io_ctx_impl
->checksum(obj
, get_checksum_op_type(type
), init_value_bl
,
1214 len
, off
, chunk_size
, pbl
);
1217 int librados::IoCtx::remove(const std::string
& oid
)
1220 return io_ctx_impl
->remove(obj
);
1223 int librados::IoCtx::remove(const std::string
& oid
, int flags
)
1226 return io_ctx_impl
->remove(obj
, flags
);
1229 int librados::IoCtx::trunc(const std::string
& oid
, uint64_t size
)
1232 return io_ctx_impl
->trunc(obj
, size
);
1235 int librados::IoCtx::mapext(const std::string
& oid
, uint64_t off
, size_t len
,
1236 std::map
<uint64_t,uint64_t>& m
)
1239 return io_ctx_impl
->mapext(obj
, off
, len
, m
);
1242 int librados::IoCtx::cmpext(const std::string
& oid
, uint64_t off
, bufferlist
& cmp_bl
)
1245 return io_ctx_impl
->cmpext(obj
, off
, cmp_bl
);
1248 int librados::IoCtx::sparse_read(const std::string
& oid
, std::map
<uint64_t,uint64_t>& m
,
1249 bufferlist
& bl
, size_t len
, uint64_t off
)
1252 return io_ctx_impl
->sparse_read(obj
, m
, bl
, len
, off
);
1255 int librados::IoCtx::getxattr(const std::string
& oid
, const char *name
, bufferlist
& bl
)
1258 return io_ctx_impl
->getxattr(obj
, name
, bl
);
1261 int librados::IoCtx::getxattrs(const std::string
& oid
, map
<std::string
, bufferlist
>& attrset
)
1264 return io_ctx_impl
->getxattrs(obj
, attrset
);
1267 int librados::IoCtx::setxattr(const std::string
& oid
, const char *name
, bufferlist
& bl
)
1270 return io_ctx_impl
->setxattr(obj
, name
, bl
);
1273 int librados::IoCtx::rmxattr(const std::string
& oid
, const char *name
)
1276 return io_ctx_impl
->rmxattr(obj
, name
);
1279 int librados::IoCtx::stat(const std::string
& oid
, uint64_t *psize
, time_t *pmtime
)
1282 return io_ctx_impl
->stat(obj
, psize
, pmtime
);
1285 int librados::IoCtx::stat2(const std::string
& oid
, uint64_t *psize
, struct timespec
*pts
)
1288 return io_ctx_impl
->stat2(obj
, psize
, pts
);
1291 int librados::IoCtx::exec(const std::string
& oid
, const char *cls
, const char *method
,
1292 bufferlist
& inbl
, bufferlist
& outbl
)
1295 return io_ctx_impl
->exec(obj
, cls
, method
, inbl
, outbl
);
1298 int librados::IoCtx::tmap_update(const std::string
& oid
, bufferlist
& cmdbl
)
1301 return io_ctx_impl
->tmap_update(obj
, cmdbl
);
1304 int librados::IoCtx::tmap_put(const std::string
& oid
, bufferlist
& bl
)
1307 return io_ctx_impl
->tmap_put(obj
, bl
);
1310 int librados::IoCtx::tmap_get(const std::string
& oid
, bufferlist
& bl
)
1313 return io_ctx_impl
->tmap_get(obj
, bl
);
1316 int librados::IoCtx::tmap_to_omap(const std::string
& oid
, bool nullok
)
1319 return io_ctx_impl
->tmap_to_omap(obj
, nullok
);
1322 int librados::IoCtx::omap_get_vals(const std::string
& oid
,
1323 const std::string
& start_after
,
1324 uint64_t max_return
,
1325 std::map
<std::string
, bufferlist
> *out_vals
)
1327 return omap_get_vals(oid
, start_after
, string(), max_return
, out_vals
);
1330 int librados::IoCtx::omap_get_vals2(
1331 const std::string
& oid
,
1332 const std::string
& start_after
,
1333 uint64_t max_return
,
1334 std::map
<std::string
, bufferlist
> *out_vals
,
1337 ObjectReadOperation op
;
1339 op
.omap_get_vals2(start_after
, max_return
, out_vals
, pmore
, &r
);
1341 int ret
= operate(oid
, &op
, &bl
);
1347 int librados::IoCtx::omap_get_keys(const std::string
& oid
,
1348 const std::string
& orig_start_after
,
1349 uint64_t max_return
,
1350 std::set
<std::string
> *out_keys
)
1353 string start_after
= orig_start_after
;
1355 while (max_return
> 0 && more
) {
1356 std::set
<std::string
> out
;
1357 ObjectReadOperation op
;
1358 op
.omap_get_keys2(start_after
, max_return
, &out
, &more
, nullptr);
1360 int ret
= operate(oid
, &op
, &bl
);
1366 return -EINVAL
; // wth
1368 start_after
= *out
.rbegin();
1370 if (out
.size() <= max_return
) {
1371 max_return
-= out
.size();
1376 out_keys
->swap(out
);
1379 out_keys
->insert(out
.begin(), out
.end());
1386 int librados::IoCtx::omap_get_keys2(
1387 const std::string
& oid
,
1388 const std::string
& start_after
,
1389 uint64_t max_return
,
1390 std::set
<std::string
> *out_keys
,
1393 ObjectReadOperation op
;
1395 op
.omap_get_keys2(start_after
, max_return
, out_keys
, pmore
, &r
);
1397 int ret
= operate(oid
, &op
, &bl
);
1403 int librados::IoCtx::omap_get_header(const std::string
& oid
,
1406 ObjectReadOperation op
;
1408 op
.omap_get_header(bl
, &r
);
1410 int ret
= operate(oid
, &op
, &b
);
1417 int librados::IoCtx::omap_get_vals_by_keys(const std::string
& oid
,
1418 const std::set
<std::string
>& keys
,
1419 std::map
<std::string
, bufferlist
> *vals
)
1421 ObjectReadOperation op
;
1424 op
.omap_get_vals_by_keys(keys
, vals
, &r
);
1425 int ret
= operate(oid
, &op
, &bl
);
1432 int librados::IoCtx::omap_set(const std::string
& oid
,
1433 const map
<string
, bufferlist
>& m
)
1435 ObjectWriteOperation op
;
1437 return operate(oid
, &op
);
1440 int librados::IoCtx::omap_set_header(const std::string
& oid
,
1441 const bufferlist
& bl
)
1443 ObjectWriteOperation op
;
1444 op
.omap_set_header(bl
);
1445 return operate(oid
, &op
);
1448 int librados::IoCtx::omap_clear(const std::string
& oid
)
1450 ObjectWriteOperation op
;
1452 return operate(oid
, &op
);
1455 int librados::IoCtx::omap_rm_keys(const std::string
& oid
,
1456 const std::set
<std::string
>& keys
)
1458 ObjectWriteOperation op
;
1459 op
.omap_rm_keys(keys
);
1460 return operate(oid
, &op
);
1465 static int translate_flags(int flags
)
1468 if (flags
& librados::OPERATION_BALANCE_READS
)
1469 op_flags
|= CEPH_OSD_FLAG_BALANCE_READS
;
1470 if (flags
& librados::OPERATION_LOCALIZE_READS
)
1471 op_flags
|= CEPH_OSD_FLAG_LOCALIZE_READS
;
1472 if (flags
& librados::OPERATION_ORDER_READS_WRITES
)
1473 op_flags
|= CEPH_OSD_FLAG_RWORDERED
;
1474 if (flags
& librados::OPERATION_IGNORE_CACHE
)
1475 op_flags
|= CEPH_OSD_FLAG_IGNORE_CACHE
;
1476 if (flags
& librados::OPERATION_SKIPRWLOCKS
)
1477 op_flags
|= CEPH_OSD_FLAG_SKIPRWLOCKS
;
1478 if (flags
& librados::OPERATION_IGNORE_OVERLAY
)
1479 op_flags
|= CEPH_OSD_FLAG_IGNORE_OVERLAY
;
1480 if (flags
& librados::OPERATION_FULL_TRY
)
1481 op_flags
|= CEPH_OSD_FLAG_FULL_TRY
;
1482 if (flags
& librados::OPERATION_FULL_FORCE
)
1483 op_flags
|= CEPH_OSD_FLAG_FULL_FORCE
;
1484 if (flags
& librados::OPERATION_IGNORE_REDIRECT
)
1485 op_flags
|= CEPH_OSD_FLAG_IGNORE_REDIRECT
;
1490 int librados::IoCtx::operate(const std::string
& oid
, librados::ObjectWriteOperation
*o
)
1493 return io_ctx_impl
->operate(obj
, &o
->impl
->o
, (ceph::real_time
*)o
->impl
->prt
);
1496 int librados::IoCtx::operate(const std::string
& oid
, librados::ObjectReadOperation
*o
, bufferlist
*pbl
)
1499 return io_ctx_impl
->operate_read(obj
, &o
->impl
->o
, pbl
);
1502 int librados::IoCtx::aio_operate(const std::string
& oid
, AioCompletion
*c
,
1503 librados::ObjectWriteOperation
*o
)
1506 return io_ctx_impl
->aio_operate(obj
, &o
->impl
->o
, c
->pc
,
1507 io_ctx_impl
->snapc
, 0);
1509 int librados::IoCtx::aio_operate(const std::string
& oid
, AioCompletion
*c
,
1510 ObjectWriteOperation
*o
, int flags
)
1513 return io_ctx_impl
->aio_operate(obj
, &o
->impl
->o
, c
->pc
,
1515 translate_flags(flags
));
1518 int librados::IoCtx::aio_operate(const std::string
& oid
, AioCompletion
*c
,
1519 librados::ObjectWriteOperation
*o
,
1520 snap_t snap_seq
, std::vector
<snap_t
>& snaps
)
1523 vector
<snapid_t
> snv
;
1524 snv
.resize(snaps
.size());
1525 for (size_t i
= 0; i
< snaps
.size(); ++i
)
1527 SnapContext
snapc(snap_seq
, snv
);
1528 return io_ctx_impl
->aio_operate(obj
, &o
->impl
->o
, c
->pc
,
1532 int librados::IoCtx::aio_operate(const std::string
& oid
, AioCompletion
*c
,
1533 librados::ObjectWriteOperation
*o
,
1534 snap_t snap_seq
, std::vector
<snap_t
>& snaps
,
1535 const blkin_trace_info
*trace_info
)
1538 vector
<snapid_t
> snv
;
1539 snv
.resize(snaps
.size());
1540 for (size_t i
= 0; i
< snaps
.size(); ++i
)
1542 SnapContext
snapc(snap_seq
, snv
);
1543 return io_ctx_impl
->aio_operate(obj
, &o
->impl
->o
, c
->pc
,
1544 snapc
, 0, trace_info
);
1547 int librados::IoCtx::aio_operate(const std::string
& oid
, AioCompletion
*c
,
1548 librados::ObjectReadOperation
*o
,
1552 return io_ctx_impl
->aio_operate_read(obj
, &o
->impl
->o
, c
->pc
,
1557 int librados::IoCtx::aio_operate(const std::string
& oid
, AioCompletion
*c
,
1558 librados::ObjectReadOperation
*o
,
1559 snap_t snapid_unused_deprecated
,
1560 int flags
, bufferlist
*pbl
)
1564 if (flags
& OPERATION_BALANCE_READS
)
1565 op_flags
|= CEPH_OSD_FLAG_BALANCE_READS
;
1566 if (flags
& OPERATION_LOCALIZE_READS
)
1567 op_flags
|= CEPH_OSD_FLAG_LOCALIZE_READS
;
1568 if (flags
& OPERATION_ORDER_READS_WRITES
)
1569 op_flags
|= CEPH_OSD_FLAG_RWORDERED
;
1571 return io_ctx_impl
->aio_operate_read(obj
, &o
->impl
->o
, c
->pc
,
1575 int librados::IoCtx::aio_operate(const std::string
& oid
, AioCompletion
*c
,
1576 librados::ObjectReadOperation
*o
,
1577 int flags
, bufferlist
*pbl
)
1580 return io_ctx_impl
->aio_operate_read(obj
, &o
->impl
->o
, c
->pc
,
1581 translate_flags(flags
), pbl
);
1584 int librados::IoCtx::aio_operate(const std::string
& oid
, AioCompletion
*c
,
1585 librados::ObjectReadOperation
*o
,
1586 int flags
, bufferlist
*pbl
, const blkin_trace_info
*trace_info
)
1589 return io_ctx_impl
->aio_operate_read(obj
, &o
->impl
->o
, c
->pc
,
1590 translate_flags(flags
), pbl
, trace_info
);
1593 void librados::IoCtx::snap_set_read(snap_t seq
)
1595 io_ctx_impl
->set_snap_read(seq
);
1598 int librados::IoCtx::selfmanaged_snap_set_write_ctx(snap_t seq
, vector
<snap_t
>& snaps
)
1600 vector
<snapid_t
> snv
;
1601 snv
.resize(snaps
.size());
1602 for (unsigned i
=0; i
<snaps
.size(); i
++)
1604 return io_ctx_impl
->set_snap_write_context(seq
, snv
);
1607 int librados::IoCtx::snap_create(const char *snapname
)
1609 return io_ctx_impl
->snap_create(snapname
);
1612 int librados::IoCtx::snap_lookup(const char *name
, snap_t
*snapid
)
1614 return io_ctx_impl
->snap_lookup(name
, snapid
);
1617 int librados::IoCtx::snap_get_stamp(snap_t snapid
, time_t *t
)
1619 return io_ctx_impl
->snap_get_stamp(snapid
, t
);
1622 int librados::IoCtx::snap_get_name(snap_t snapid
, std::string
*s
)
1624 return io_ctx_impl
->snap_get_name(snapid
, s
);
1627 int librados::IoCtx::snap_remove(const char *snapname
)
1629 return io_ctx_impl
->snap_remove(snapname
);
1632 int librados::IoCtx::snap_list(std::vector
<snap_t
> *snaps
)
1634 return io_ctx_impl
->snap_list(snaps
);
1637 int librados::IoCtx::snap_rollback(const std::string
& oid
, const char *snapname
)
1639 return io_ctx_impl
->rollback(oid
, snapname
);
1642 // Deprecated name kept for backward compatibility
1643 int librados::IoCtx::rollback(const std::string
& oid
, const char *snapname
)
1645 return snap_rollback(oid
, snapname
);
1648 int librados::IoCtx::selfmanaged_snap_create(uint64_t *snapid
)
1650 return io_ctx_impl
->selfmanaged_snap_create(snapid
);
1653 void librados::IoCtx::aio_selfmanaged_snap_create(uint64_t *snapid
,
1656 io_ctx_impl
->aio_selfmanaged_snap_create(snapid
, c
->pc
);
1659 int librados::IoCtx::selfmanaged_snap_remove(uint64_t snapid
)
1661 return io_ctx_impl
->selfmanaged_snap_remove(snapid
);
1664 void librados::IoCtx::aio_selfmanaged_snap_remove(uint64_t snapid
,
1667 io_ctx_impl
->aio_selfmanaged_snap_remove(snapid
, c
->pc
);
1670 int librados::IoCtx::selfmanaged_snap_rollback(const std::string
& oid
, uint64_t snapid
)
1672 return io_ctx_impl
->selfmanaged_snap_rollback_object(oid
,
1677 int librados::IoCtx::lock_exclusive(const std::string
&oid
, const std::string
&name
,
1678 const std::string
&cookie
,
1679 const std::string
&description
,
1680 struct timeval
* duration
, uint8_t flags
)
1682 utime_t dur
= utime_t();
1684 dur
.set_from_timeval(duration
);
1686 return rados::cls::lock::lock(this, oid
, name
, LOCK_EXCLUSIVE
, cookie
, "",
1687 description
, dur
, flags
);
1690 int librados::IoCtx::lock_shared(const std::string
&oid
, const std::string
&name
,
1691 const std::string
&cookie
, const std::string
&tag
,
1692 const std::string
&description
,
1693 struct timeval
* duration
, uint8_t flags
)
1695 utime_t dur
= utime_t();
1697 dur
.set_from_timeval(duration
);
1699 return rados::cls::lock::lock(this, oid
, name
, LOCK_SHARED
, cookie
, tag
,
1700 description
, dur
, flags
);
1703 int librados::IoCtx::unlock(const std::string
&oid
, const std::string
&name
,
1704 const std::string
&cookie
)
1706 return rados::cls::lock::unlock(this, oid
, name
, cookie
);
1709 struct AioUnlockCompletion
: public librados::ObjectOperationCompletion
{
1710 librados::AioCompletionImpl
*completion
;
1711 AioUnlockCompletion(librados::AioCompletion
*c
) : completion(c
->pc
) {
1714 void handle_completion(int r
, bufferlist
& outbl
) override
{
1715 rados_callback_t cb
= completion
->callback_complete
;
1716 void *cb_arg
= completion
->callback_complete_arg
;
1717 cb(completion
, cb_arg
);
1718 completion
->lock
.Lock();
1719 completion
->callback_complete
= NULL
;
1720 completion
->cond
.Signal();
1721 completion
->put_unlock();
1725 int librados::IoCtx::aio_unlock(const std::string
&oid
, const std::string
&name
,
1726 const std::string
&cookie
, AioCompletion
*c
)
1728 return rados::cls::lock::aio_unlock(this, oid
, name
, cookie
, c
);
1731 int librados::IoCtx::break_lock(const std::string
&oid
, const std::string
&name
,
1732 const std::string
&client
, const std::string
&cookie
)
1734 entity_name_t locker
;
1735 if (!locker
.parse(client
))
1737 return rados::cls::lock::break_lock(this, oid
, name
, cookie
, locker
);
1740 int librados::IoCtx::list_lockers(const std::string
&oid
, const std::string
&name
,
1743 std::list
<librados::locker_t
> *lockers
)
1745 std::list
<librados::locker_t
> tmp_lockers
;
1746 map
<rados::cls::lock::locker_id_t
, rados::cls::lock::locker_info_t
> rados_lockers
;
1747 std::string tmp_tag
;
1748 ClsLockType tmp_type
;
1749 int r
= rados::cls::lock::get_lock_info(this, oid
, name
, &rados_lockers
, &tmp_type
, &tmp_tag
);
1753 map
<rados::cls::lock::locker_id_t
, rados::cls::lock::locker_info_t
>::iterator map_it
;
1754 for (map_it
= rados_lockers
.begin(); map_it
!= rados_lockers
.end(); ++map_it
) {
1755 librados::locker_t locker
;
1756 locker
.client
= stringify(map_it
->first
.locker
);
1757 locker
.cookie
= map_it
->first
.cookie
;
1758 locker
.address
= stringify(map_it
->second
.addr
);
1759 tmp_lockers
.push_back(locker
);
1763 *lockers
= tmp_lockers
;
1767 if (tmp_type
== LOCK_EXCLUSIVE
)
1773 return tmp_lockers
.size();
1776 librados::NObjectIterator
librados::IoCtx::nobjects_begin()
1779 return nobjects_begin(bl
);
1782 librados::NObjectIterator
librados::IoCtx::nobjects_begin(
1783 const bufferlist
&filter
)
1785 rados_list_ctx_t listh
;
1786 rados_nobjects_list_open(io_ctx_impl
, &listh
);
1787 NObjectIterator
iter((ObjListCtx
*)listh
);
1788 if (filter
.length() > 0) {
1789 iter
.set_filter(filter
);
1795 librados::NObjectIterator
librados::IoCtx::nobjects_begin(uint32_t pos
)
1798 return nobjects_begin(pos
, bl
);
1801 librados::NObjectIterator
librados::IoCtx::nobjects_begin(
1802 uint32_t pos
, const bufferlist
&filter
)
1804 rados_list_ctx_t listh
;
1805 rados_nobjects_list_open(io_ctx_impl
, &listh
);
1806 NObjectIterator
iter((ObjListCtx
*)listh
);
1807 if (filter
.length() > 0) {
1808 iter
.set_filter(filter
);
1814 librados::NObjectIterator
librados::IoCtx::nobjects_begin(const ObjectCursor
& cursor
)
1817 return nobjects_begin(cursor
, bl
);
1820 librados::NObjectIterator
librados::IoCtx::nobjects_begin(
1821 const ObjectCursor
& cursor
, const bufferlist
&filter
)
1823 rados_list_ctx_t listh
;
1824 rados_nobjects_list_open(io_ctx_impl
, &listh
);
1825 NObjectIterator
iter((ObjListCtx
*)listh
);
1826 if (filter
.length() > 0) {
1827 iter
.set_filter(filter
);
1833 const librados::NObjectIterator
& librados::IoCtx::nobjects_end() const
1835 return NObjectIterator::__EndObjectIterator
;
1838 int librados::IoCtx::hit_set_list(uint32_t hash
, AioCompletion
*c
,
1839 std::list
< std::pair
<time_t, time_t> > *pls
)
1841 return io_ctx_impl
->hit_set_list(hash
, c
->pc
, pls
);
1844 int librados::IoCtx::hit_set_get(uint32_t hash
, AioCompletion
*c
, time_t stamp
,
1847 return io_ctx_impl
->hit_set_get(hash
, c
->pc
, stamp
, pbl
);
1852 uint64_t librados::IoCtx::get_last_version()
1854 return io_ctx_impl
->last_version();
1857 int librados::IoCtx::aio_read(const std::string
& oid
, librados::AioCompletion
*c
,
1858 bufferlist
*pbl
, size_t len
, uint64_t off
)
1860 return io_ctx_impl
->aio_read(oid
, c
->pc
, pbl
, len
, off
,
1861 io_ctx_impl
->snap_seq
);
1864 int librados::IoCtx::aio_read(const std::string
& oid
, librados::AioCompletion
*c
,
1865 bufferlist
*pbl
, size_t len
, uint64_t off
,
1868 return io_ctx_impl
->aio_read(oid
, c
->pc
, pbl
, len
, off
, snapid
);
1871 int librados::IoCtx::aio_exec(const std::string
& oid
,
1872 librados::AioCompletion
*c
, const char *cls
,
1873 const char *method
, bufferlist
& inbl
,
1877 return io_ctx_impl
->aio_exec(obj
, c
->pc
, cls
, method
, inbl
, outbl
);
1880 int librados::IoCtx::aio_cmpext(const std::string
& oid
,
1881 librados::AioCompletion
*c
,
1885 return io_ctx_impl
->aio_cmpext(oid
, c
->pc
, off
, cmp_bl
);
1888 int librados::IoCtx::aio_sparse_read(const std::string
& oid
, librados::AioCompletion
*c
,
1889 std::map
<uint64_t,uint64_t> *m
, bufferlist
*data_bl
,
1890 size_t len
, uint64_t off
)
1892 return io_ctx_impl
->aio_sparse_read(oid
, c
->pc
,
1893 m
, data_bl
, len
, off
,
1894 io_ctx_impl
->snap_seq
);
1897 int librados::IoCtx::aio_sparse_read(const std::string
& oid
, librados::AioCompletion
*c
,
1898 std::map
<uint64_t,uint64_t> *m
, bufferlist
*data_bl
,
1899 size_t len
, uint64_t off
, uint64_t snapid
)
1901 return io_ctx_impl
->aio_sparse_read(oid
, c
->pc
,
1902 m
, data_bl
, len
, off
, snapid
);
1905 int librados::IoCtx::aio_write(const std::string
& oid
, librados::AioCompletion
*c
,
1906 const bufferlist
& bl
, size_t len
, uint64_t off
)
1908 return io_ctx_impl
->aio_write(oid
, c
->pc
, bl
, len
, off
);
1911 int librados::IoCtx::aio_append(const std::string
& oid
, librados::AioCompletion
*c
,
1912 const bufferlist
& bl
, size_t len
)
1914 return io_ctx_impl
->aio_append(oid
, c
->pc
, bl
, len
);
1917 int librados::IoCtx::aio_write_full(const std::string
& oid
, librados::AioCompletion
*c
,
1918 const bufferlist
& bl
)
1921 return io_ctx_impl
->aio_write_full(obj
, c
->pc
, bl
);
1924 int librados::IoCtx::aio_writesame(const std::string
& oid
, librados::AioCompletion
*c
,
1925 const bufferlist
& bl
, size_t write_len
,
1928 return io_ctx_impl
->aio_writesame(oid
, c
->pc
, bl
, write_len
, off
);
1932 int librados::IoCtx::aio_remove(const std::string
& oid
, librados::AioCompletion
*c
)
1934 return io_ctx_impl
->aio_remove(oid
, c
->pc
);
1937 int librados::IoCtx::aio_remove(const std::string
& oid
, librados::AioCompletion
*c
, int flags
)
1939 return io_ctx_impl
->aio_remove(oid
, c
->pc
, flags
);
1942 int librados::IoCtx::aio_flush_async(librados::AioCompletion
*c
)
1944 io_ctx_impl
->flush_aio_writes_async(c
->pc
);
1948 int librados::IoCtx::aio_flush()
1950 io_ctx_impl
->flush_aio_writes();
1954 struct AioGetxattrDataPP
{
1955 AioGetxattrDataPP(librados::AioCompletionImpl
*c
, bufferlist
*_bl
) :
1956 bl(_bl
), completion(c
) {}
1958 struct librados::C_AioCompleteAndSafe completion
;
1961 static void rados_aio_getxattr_completepp(rados_completion_t c
, void *arg
) {
1962 AioGetxattrDataPP
*cdata
= reinterpret_cast<AioGetxattrDataPP
*>(arg
);
1963 int rc
= rados_aio_get_return_value(c
);
1965 rc
= cdata
->bl
->length();
1967 cdata
->completion
.finish(rc
);
1971 int librados::IoCtx::aio_getxattr(const std::string
& oid
, librados::AioCompletion
*c
,
1972 const char *name
, bufferlist
& bl
)
1974 // create data object to be passed to async callback
1975 AioGetxattrDataPP
*cdata
= new AioGetxattrDataPP(c
->pc
, &bl
);
1979 // create completion callback
1980 librados::AioCompletionImpl
*comp
= new librados::AioCompletionImpl
;
1981 comp
->set_complete_callback(cdata
, rados_aio_getxattr_completepp
);
1982 // call actual getxattr from IoCtxImpl
1984 return io_ctx_impl
->aio_getxattr(obj
, comp
, name
, bl
);
1987 int librados::IoCtx::aio_getxattrs(const std::string
& oid
, AioCompletion
*c
,
1988 map
<std::string
, bufferlist
>& attrset
)
1991 return io_ctx_impl
->aio_getxattrs(obj
, c
->pc
, attrset
);
1994 int librados::IoCtx::aio_setxattr(const std::string
& oid
, AioCompletion
*c
,
1995 const char *name
, bufferlist
& bl
)
1998 return io_ctx_impl
->aio_setxattr(obj
, c
->pc
, name
, bl
);
2001 int librados::IoCtx::aio_rmxattr(const std::string
& oid
, AioCompletion
*c
,
2005 return io_ctx_impl
->aio_rmxattr(obj
, c
->pc
, name
);
2008 int librados::IoCtx::aio_stat(const std::string
& oid
, librados::AioCompletion
*c
,
2009 uint64_t *psize
, time_t *pmtime
)
2012 return io_ctx_impl
->aio_stat(obj
, c
->pc
, psize
, pmtime
);
2015 int librados::IoCtx::aio_cancel(librados::AioCompletion
*c
)
2017 return io_ctx_impl
->aio_cancel(c
->pc
);
2020 int librados::IoCtx::watch(const string
& oid
, uint64_t ver
, uint64_t *cookie
,
2021 librados::WatchCtx
*ctx
)
2024 return io_ctx_impl
->watch(obj
, cookie
, ctx
, NULL
);
2027 int librados::IoCtx::watch2(const string
& oid
, uint64_t *cookie
,
2028 librados::WatchCtx2
*ctx2
)
2031 return io_ctx_impl
->watch(obj
, cookie
, NULL
, ctx2
);
2034 int librados::IoCtx::watch3(const string
& oid
, uint64_t *cookie
,
2035 librados::WatchCtx2
*ctx2
, uint32_t timeout
)
2038 return io_ctx_impl
->watch(obj
, cookie
, NULL
, ctx2
, timeout
);
2041 int librados::IoCtx::aio_watch(const string
& oid
, AioCompletion
*c
,
2043 librados::WatchCtx2
*ctx2
)
2046 return io_ctx_impl
->aio_watch(obj
, c
->pc
, cookie
, NULL
, ctx2
);
2049 int librados::IoCtx::aio_watch2(const string
& oid
, AioCompletion
*c
,
2051 librados::WatchCtx2
*ctx2
,
2055 return io_ctx_impl
->aio_watch(obj
, c
->pc
, cookie
, NULL
, ctx2
, timeout
);
2058 int librados::IoCtx::unwatch(const string
& oid
, uint64_t handle
)
2060 return io_ctx_impl
->unwatch(handle
);
2063 int librados::IoCtx::unwatch2(uint64_t handle
)
2065 return io_ctx_impl
->unwatch(handle
);
2068 int librados::IoCtx::aio_unwatch(uint64_t handle
, AioCompletion
*c
)
2070 return io_ctx_impl
->aio_unwatch(handle
, c
->pc
);
2073 int librados::IoCtx::watch_check(uint64_t handle
)
2075 return io_ctx_impl
->watch_check(handle
);
2078 int librados::IoCtx::notify(const string
& oid
, uint64_t ver
, bufferlist
& bl
)
2081 return io_ctx_impl
->notify(obj
, bl
, 0, NULL
, NULL
, NULL
);
2084 int librados::IoCtx::notify2(const string
& oid
, bufferlist
& bl
,
2085 uint64_t timeout_ms
, bufferlist
*preplybl
)
2088 return io_ctx_impl
->notify(obj
, bl
, timeout_ms
, preplybl
, NULL
, NULL
);
2091 int librados::IoCtx::aio_notify(const string
& oid
, AioCompletion
*c
,
2092 bufferlist
& bl
, uint64_t timeout_ms
,
2093 bufferlist
*preplybl
)
2096 return io_ctx_impl
->aio_notify(obj
, c
->pc
, bl
, timeout_ms
, preplybl
, NULL
,
2100 void librados::IoCtx::notify_ack(const std::string
& o
,
2101 uint64_t notify_id
, uint64_t handle
,
2104 io_ctx_impl
->notify_ack(o
, notify_id
, handle
, bl
);
2107 int librados::IoCtx::list_watchers(const std::string
& oid
,
2108 std::list
<obj_watch_t
> *out_watchers
)
2110 ObjectReadOperation op
;
2112 op
.list_watchers(out_watchers
, &r
);
2114 int ret
= operate(oid
, &op
, &bl
);
2121 int librados::IoCtx::list_snaps(const std::string
& oid
,
2122 snap_set_t
*out_snaps
)
2124 ObjectReadOperation op
;
2126 if (io_ctx_impl
->snap_seq
!= CEPH_SNAPDIR
)
2128 op
.list_snaps(out_snaps
, &r
);
2130 int ret
= operate(oid
, &op
, &bl
);
2137 void librados::IoCtx::set_notify_timeout(uint32_t timeout
)
2139 io_ctx_impl
->set_notify_timeout(timeout
);
2142 int librados::IoCtx::set_alloc_hint(const std::string
& o
,
2143 uint64_t expected_object_size
,
2144 uint64_t expected_write_size
)
2147 return io_ctx_impl
->set_alloc_hint(oid
, expected_object_size
,
2148 expected_write_size
, 0);
2151 int librados::IoCtx::set_alloc_hint2(const std::string
& o
,
2152 uint64_t expected_object_size
,
2153 uint64_t expected_write_size
,
2157 return io_ctx_impl
->set_alloc_hint(oid
, expected_object_size
,
2158 expected_write_size
, flags
);
2161 void librados::IoCtx::set_assert_version(uint64_t ver
)
2163 io_ctx_impl
->set_assert_version(ver
);
2166 void librados::IoCtx::locator_set_key(const string
& key
)
2168 io_ctx_impl
->oloc
.key
= key
;
2171 void librados::IoCtx::set_namespace(const string
& nspace
)
2173 io_ctx_impl
->oloc
.nspace
= nspace
;
2176 int64_t librados::IoCtx::get_id()
2178 return io_ctx_impl
->get_id();
2181 uint32_t librados::IoCtx::get_object_hash_position(const std::string
& oid
)
2184 int r
= io_ctx_impl
->get_object_hash_position(oid
, &hash
);
2190 uint32_t librados::IoCtx::get_object_pg_hash_position(const std::string
& oid
)
2193 int r
= io_ctx_impl
->get_object_pg_hash_position(oid
, &hash
);
2199 int librados::IoCtx::get_object_hash_position2(
2200 const std::string
& oid
, uint32_t *hash_position
)
2202 return io_ctx_impl
->get_object_hash_position(oid
, hash_position
);
2205 int librados::IoCtx::get_object_pg_hash_position2(
2206 const std::string
& oid
, uint32_t *pg_hash_position
)
2208 return io_ctx_impl
->get_object_pg_hash_position(oid
, pg_hash_position
);
2211 librados::config_t
librados::IoCtx::cct()
2213 return (config_t
)io_ctx_impl
->client
->cct
;
2216 librados::IoCtx::IoCtx(IoCtxImpl
*io_ctx_impl_
)
2217 : io_ctx_impl(io_ctx_impl_
)
2221 void librados::IoCtx::set_osdmap_full_try()
2223 io_ctx_impl
->objecter
->set_osdmap_full_try();
2226 void librados::IoCtx::unset_osdmap_full_try()
2228 io_ctx_impl
->objecter
->unset_osdmap_full_try();
2231 ///////////////////////////// Rados //////////////////////////////
2232 void librados::Rados::version(int *major
, int *minor
, int *extra
)
2234 rados_version(major
, minor
, extra
);
2237 librados::Rados::Rados() : client(NULL
)
2241 librados::Rados::Rados(IoCtx
&ioctx
)
2243 client
= ioctx
.io_ctx_impl
->client
;
2244 assert(client
!= NULL
);
2248 librados::Rados::~Rados()
2253 int librados::Rados::init(const char * const id
)
2255 return rados_create((rados_t
*)&client
, id
);
2258 int librados::Rados::init2(const char * const name
,
2259 const char * const clustername
, uint64_t flags
)
2261 return rados_create2((rados_t
*)&client
, clustername
, name
, flags
);
2264 int librados::Rados::init_with_context(config_t cct_
)
2266 return rados_create_with_context((rados_t
*)&client
, (rados_config_t
)cct_
);
2269 int librados::Rados::connect()
2271 return client
->connect();
2274 librados::config_t
librados::Rados::cct()
2276 return (config_t
)client
->cct
;
2279 int librados::Rados::watch_flush()
2283 return client
->watch_flush();
2286 int librados::Rados::aio_watch_flush(AioCompletion
*c
)
2290 return client
->async_watch_flush(c
->pc
);
2293 void librados::Rados::shutdown()
2297 if (client
->put()) {
2304 uint64_t librados::Rados::get_instance_id()
2306 return client
->get_instance_id();
2309 int librados::Rados::conf_read_file(const char * const path
) const
2311 return rados_conf_read_file((rados_t
)client
, path
);
2314 int librados::Rados::conf_parse_argv(int argc
, const char ** argv
) const
2316 return rados_conf_parse_argv((rados_t
)client
, argc
, argv
);
2319 int librados::Rados::conf_parse_argv_remainder(int argc
, const char ** argv
,
2320 const char ** remargv
) const
2322 return rados_conf_parse_argv_remainder((rados_t
)client
, argc
, argv
, remargv
);
2325 int librados::Rados::conf_parse_env(const char *name
) const
2327 return rados_conf_parse_env((rados_t
)client
, name
);
2330 int librados::Rados::conf_set(const char *option
, const char *value
)
2332 return rados_conf_set((rados_t
)client
, option
, value
);
2335 int librados::Rados::conf_get(const char *option
, std::string
&val
)
2338 md_config_t
*conf
= client
->cct
->_conf
;
2339 int ret
= conf
->get_val(option
, &str
, -1);
2349 int librados::Rados::pool_create(const char *name
)
2352 return client
->pool_create(str
);
2355 int librados::Rados::pool_create(const char *name
, uint64_t auid
)
2358 return client
->pool_create(str
, auid
);
2361 int librados::Rados::pool_create(const char *name
, uint64_t auid
, __u8 crush_rule
)
2364 return client
->pool_create(str
, auid
, crush_rule
);
2367 int librados::Rados::pool_create_async(const char *name
, PoolAsyncCompletion
*c
)
2370 return client
->pool_create_async(str
, c
->pc
);
2373 int librados::Rados::pool_create_async(const char *name
, uint64_t auid
, PoolAsyncCompletion
*c
)
2376 return client
->pool_create_async(str
, c
->pc
, auid
);
2379 int librados::Rados::pool_create_async(const char *name
, uint64_t auid
, __u8 crush_rule
,
2380 PoolAsyncCompletion
*c
)
2383 return client
->pool_create_async(str
, c
->pc
, auid
, crush_rule
);
2386 int librados::Rados::pool_get_base_tier(int64_t pool_id
, int64_t* base_tier
)
2388 tracepoint(librados
, rados_pool_get_base_tier_enter
, (rados_t
)client
, pool_id
);
2389 int retval
= client
->pool_get_base_tier(pool_id
, base_tier
);
2390 tracepoint(librados
, rados_pool_get_base_tier_exit
, retval
, *base_tier
);
2394 int librados::Rados::pool_delete(const char *name
)
2396 return client
->pool_delete(name
);
2399 int librados::Rados::pool_delete_async(const char *name
, PoolAsyncCompletion
*c
)
2401 return client
->pool_delete_async(name
, c
->pc
);
2404 int librados::Rados::pool_list(std::list
<std::string
>& v
)
2406 std::list
<std::pair
<int64_t, std::string
> > pools
;
2407 int r
= client
->pool_list(pools
);
2413 for (std::list
<std::pair
<int64_t, std::string
> >::iterator it
= pools
.begin();
2414 it
!= pools
.end(); ++it
) {
2415 v
.push_back(it
->second
);
2420 int librados::Rados::pool_list2(std::list
<std::pair
<int64_t, std::string
> >& v
)
2422 return client
->pool_list(v
);
2425 int64_t librados::Rados::pool_lookup(const char *name
)
2427 return client
->lookup_pool(name
);
2430 int librados::Rados::pool_reverse_lookup(int64_t id
, std::string
*name
)
2432 return client
->pool_get_name(id
, name
);
2435 int librados::Rados::mon_command(string cmd
, const bufferlist
& inbl
,
2436 bufferlist
*outbl
, string
*outs
)
2438 vector
<string
> cmdvec
;
2439 cmdvec
.push_back(cmd
);
2440 return client
->mon_command(cmdvec
, inbl
, outbl
, outs
);
2443 int librados::Rados::osd_command(int osdid
, std::string cmd
, const bufferlist
& inbl
,
2444 bufferlist
*outbl
, std::string
*outs
)
2446 vector
<string
> cmdvec
;
2447 cmdvec
.push_back(cmd
);
2448 return client
->osd_command(osdid
, cmdvec
, inbl
, outbl
, outs
);
2451 int librados::Rados::mgr_command(std::string cmd
, const bufferlist
& inbl
,
2452 bufferlist
*outbl
, std::string
*outs
)
2454 vector
<string
> cmdvec
;
2455 cmdvec
.push_back(cmd
);
2456 return client
->mgr_command(cmdvec
, inbl
, outbl
, outs
);
2461 int librados::Rados::pg_command(const char *pgstr
, std::string cmd
, const bufferlist
& inbl
,
2462 bufferlist
*outbl
, std::string
*outs
)
2464 vector
<string
> cmdvec
;
2465 cmdvec
.push_back(cmd
);
2468 if (!pgid
.parse(pgstr
))
2471 return client
->pg_command(pgid
, cmdvec
, inbl
, outbl
, outs
);
2474 int librados::Rados::ioctx_create(const char *name
, IoCtx
&io
)
2477 int ret
= rados_ioctx_create((rados_t
)client
, name
, &p
);
2481 io
.io_ctx_impl
= (IoCtxImpl
*)p
;
2485 int librados::Rados::ioctx_create2(int64_t pool_id
, IoCtx
&io
)
2488 int ret
= rados_ioctx_create2((rados_t
)client
, pool_id
, &p
);
2492 io
.io_ctx_impl
= (IoCtxImpl
*)p
;
2496 void librados::Rados::test_blacklist_self(bool set
)
2498 client
->blacklist_self(set
);
2501 int librados::Rados::get_pool_stats(std::list
<string
>& v
,
2504 map
<string
,::pool_stat_t
> rawresult
;
2505 int r
= client
->get_pool_stats(v
, rawresult
);
2506 for (map
<string
,::pool_stat_t
>::iterator p
= rawresult
.begin();
2507 p
!= rawresult
.end();
2509 pool_stat_t
& pv
= result
[p
->first
];
2510 object_stat_sum_t
*sum
= &p
->second
.stats
.sum
;
2511 pv
.num_kb
= SHIFT_ROUND_UP(sum
->num_bytes
, 10);
2512 pv
.num_bytes
= sum
->num_bytes
;
2513 pv
.num_objects
= sum
->num_objects
;
2514 pv
.num_object_clones
= sum
->num_object_clones
;
2515 pv
.num_object_copies
= sum
->num_object_copies
;
2516 pv
.num_objects_missing_on_primary
= sum
->num_objects_missing_on_primary
;
2517 pv
.num_objects_unfound
= sum
->num_objects_unfound
;
2518 pv
.num_objects_degraded
= sum
->num_objects_degraded
;
2519 pv
.num_rd
= sum
->num_rd
;
2520 pv
.num_rd_kb
= sum
->num_rd_kb
;
2521 pv
.num_wr
= sum
->num_wr
;
2522 pv
.num_wr_kb
= sum
->num_wr_kb
;
2527 int librados::Rados::get_pool_stats(std::list
<string
>& v
,
2528 std::map
<string
, stats_map
>& result
)
2531 int r
= get_pool_stats(v
, m
);
2534 for (map
<string
,pool_stat_t
>::iterator p
= m
.begin();
2537 result
[p
->first
][string()] = p
->second
;
2542 int librados::Rados::get_pool_stats(std::list
<string
>& v
,
2543 string
& category
, // unused
2544 std::map
<string
, stats_map
>& result
)
2549 bool librados::Rados::get_pool_is_selfmanaged_snaps_mode(const std::string
& pool
)
2551 return client
->get_pool_is_selfmanaged_snaps_mode(pool
);
2554 int librados::Rados::cluster_stat(cluster_stat_t
& result
)
2557 int r
= client
->get_fs_stats(stats
);
2558 result
.kb
= stats
.kb
;
2559 result
.kb_used
= stats
.kb_used
;
2560 result
.kb_avail
= stats
.kb_avail
;
2561 result
.num_objects
= stats
.num_objects
;
2565 int librados::Rados::cluster_fsid(string
*fsid
)
2567 return client
->get_fsid(fsid
);
2570 namespace librados
{
2571 struct PlacementGroupImpl
{
2575 PlacementGroup::PlacementGroup()
2576 : impl
{new PlacementGroupImpl
}
2579 PlacementGroup::PlacementGroup(const PlacementGroup
& pg
)
2580 : impl
{new PlacementGroupImpl
}
2582 impl
->pgid
= pg
.impl
->pgid
;
2585 PlacementGroup::~PlacementGroup()
2588 bool PlacementGroup::parse(const char* s
)
2590 return impl
->pgid
.parse(s
);
2594 std::ostream
& librados::operator<<(std::ostream
& out
,
2595 const librados::PlacementGroup
& pg
)
2597 return out
<< pg
.impl
->pgid
;
2601 int decode_json(JSONObj
*obj
, pg_t
& pg
)
2604 JSONDecoder::decode_json("pgid", pg_str
, obj
);
2605 if (pg
.parse(pg_str
.c_str())) {
2612 int get_inconsistent_pgs(librados::RadosClient
& client
,
2614 std::vector
<librados::PlacementGroup
>* pgs
)
2616 vector
<string
> cmd
= {
2617 "{\"prefix\": \"pg ls\","
2618 "\"pool\": " + std::to_string(pool_id
) + ","
2619 "\"states\": [\"inconsistent\"],"
2620 "\"format\": \"json\"}"
2622 bufferlist inbl
, outbl
;
2624 int ret
= client
.mon_command(cmd
, inbl
, &outbl
, &outstring
);
2628 if (!outbl
.length()) {
2633 if (!parser
.parse(outbl
.c_str(), outbl
.length())) {
2636 if (!parser
.is_array()) {
2639 vector
<string
> v
= parser
.get_array_elements();
2642 if (!pg_json
.parse(i
.c_str(), i
.length())) {
2645 librados::PlacementGroup pg
;
2646 if (decode_json(&pg_json
, pg
.impl
->pgid
)) {
2649 pgs
->emplace_back(pg
);
2655 int librados::Rados::get_inconsistent_pgs(int64_t pool_id
,
2656 std::vector
<PlacementGroup
>* pgs
)
2658 return ::get_inconsistent_pgs(*client
, pool_id
, pgs
);
2661 int librados::Rados::get_inconsistent_objects(const PlacementGroup
& pg
,
2662 const object_id_t
&start_after
,
2663 unsigned max_return
,
2665 std::vector
<inconsistent_obj_t
>* objects
,
2669 const pg_t pgid
= pg
.impl
->pgid
;
2670 int r
= ioctx_create2(pgid
.pool(), ioctx
);
2675 return ioctx
.io_ctx_impl
->get_inconsistent_objects(pgid
,
2683 int librados::Rados::get_inconsistent_snapsets(const PlacementGroup
& pg
,
2684 const object_id_t
&start_after
,
2685 unsigned max_return
,
2687 std::vector
<inconsistent_snapset_t
>* snapsets
,
2691 const pg_t pgid
= pg
.impl
->pgid
;
2692 int r
= ioctx_create2(pgid
.pool(), ioctx
);
2697 return ioctx
.io_ctx_impl
->get_inconsistent_snapsets(pgid
,
2705 int librados::Rados::wait_for_latest_osdmap()
2707 return client
->wait_for_latest_osdmap();
2710 int librados::Rados::blacklist_add(const std::string
& client_address
,
2711 uint32_t expire_seconds
)
2713 return client
->blacklist_add(client_address
, expire_seconds
);
2716 librados::PoolAsyncCompletion
*librados::Rados::pool_async_create_completion()
2718 PoolAsyncCompletionImpl
*c
= new PoolAsyncCompletionImpl
;
2719 return new PoolAsyncCompletion(c
);
2722 librados::AioCompletion
*librados::Rados::aio_create_completion()
2724 AioCompletionImpl
*c
= new AioCompletionImpl
;
2725 return new AioCompletion(c
);
2728 librados::AioCompletion
*librados::Rados::aio_create_completion(void *cb_arg
,
2729 callback_t cb_complete
,
2732 AioCompletionImpl
*c
;
2733 int r
= rados_aio_create_completion(cb_arg
, cb_complete
, cb_safe
, (void**)&c
);
2735 return new AioCompletion(c
);
2738 librados::ObjectOperation::ObjectOperation()
2740 impl
= new ObjectOperationImpl
;
2743 librados::ObjectOperation::~ObjectOperation()
2748 ///////////////////////////// C API //////////////////////////////
2750 static CephContext
*rados_create_cct(const char * const clustername
,
2751 CephInitParameters
*iparams
)
2753 // missing things compared to global_init:
2754 // g_ceph_context, g_conf, g_lockdep, signal handlers
2755 CephContext
*cct
= common_preinit(*iparams
, CODE_ENVIRONMENT_LIBRARY
, 0);
2757 cct
->_conf
->cluster
= clustername
;
2758 cct
->_conf
->parse_env(); // environment variables override
2759 cct
->_conf
->apply_changes(NULL
);
2761 TracepointProvider::initialize
<tracepoint_traits
>(cct
);
2765 extern "C" int rados_create(rados_t
*pcluster
, const char * const id
)
2767 CephInitParameters
iparams(CEPH_ENTITY_TYPE_CLIENT
);
2769 iparams
.name
.set(CEPH_ENTITY_TYPE_CLIENT
, id
);
2771 CephContext
*cct
= rados_create_cct("", &iparams
);
2773 tracepoint(librados
, rados_create_enter
, id
);
2774 *pcluster
= reinterpret_cast<rados_t
>(new librados::RadosClient(cct
));
2775 tracepoint(librados
, rados_create_exit
, 0, *pcluster
);
2782 // 1) don't assume 'client.'; name is a full type.id namestr
2783 // 2) allow setting clustername
2784 // 3) flags is for future expansion (maybe some of the global_init()
2785 // behavior is appropriate for some consumers of librados, for instance)
2787 extern "C" int rados_create2(rados_t
*pcluster
, const char *const clustername
,
2788 const char * const name
, uint64_t flags
)
2790 // client is assumed, but from_str will override
2792 CephInitParameters
iparams(CEPH_ENTITY_TYPE_CLIENT
);
2793 if (!name
|| !iparams
.name
.from_str(name
)) {
2797 CephContext
*cct
= rados_create_cct(clustername
, &iparams
);
2798 tracepoint(librados
, rados_create2_enter
, clustername
, name
, flags
);
2800 *pcluster
= reinterpret_cast<rados_t
>(new librados::RadosClient(cct
));
2802 tracepoint(librados
, rados_create2_exit
, retval
, *pcluster
);
2808 /* This function is intended for use by Ceph daemons. These daemons have
2809 * already called global_init and want to use that particular configuration for
2812 extern "C" int rados_create_with_context(rados_t
*pcluster
, rados_config_t cct_
)
2814 CephContext
*cct
= (CephContext
*)cct_
;
2815 TracepointProvider::initialize
<tracepoint_traits
>(cct
);
2817 tracepoint(librados
, rados_create_with_context_enter
, cct_
);
2818 librados::RadosClient
*radosp
= new librados::RadosClient(cct
);
2819 *pcluster
= (void *)radosp
;
2820 tracepoint(librados
, rados_create_with_context_exit
, 0, *pcluster
);
2824 extern "C" rados_config_t
rados_cct(rados_t cluster
)
2826 tracepoint(librados
, rados_cct_enter
, cluster
);
2827 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
2828 rados_config_t retval
= (rados_config_t
)client
->cct
;
2829 tracepoint(librados
, rados_cct_exit
, retval
);
2833 extern "C" int rados_connect(rados_t cluster
)
2835 tracepoint(librados
, rados_connect_enter
, cluster
);
2836 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
2837 int retval
= client
->connect();
2838 tracepoint(librados
, rados_connect_exit
, retval
);
2842 extern "C" void rados_shutdown(rados_t cluster
)
2844 tracepoint(librados
, rados_shutdown_enter
, cluster
);
2845 librados::RadosClient
*radosp
= (librados::RadosClient
*)cluster
;
2848 tracepoint(librados
, rados_shutdown_exit
);
2851 extern "C" uint64_t rados_get_instance_id(rados_t cluster
)
2853 tracepoint(librados
, rados_get_instance_id_enter
, cluster
);
2854 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
2855 uint64_t retval
= client
->get_instance_id();
2856 tracepoint(librados
, rados_get_instance_id_exit
, retval
);
2860 extern "C" void rados_version(int *major
, int *minor
, int *extra
)
2862 tracepoint(librados
, rados_version_enter
, major
, minor
, extra
);
2864 *major
= LIBRADOS_VER_MAJOR
;
2866 *minor
= LIBRADOS_VER_MINOR
;
2868 *extra
= LIBRADOS_VER_EXTRA
;
2869 tracepoint(librados
, rados_version_exit
, LIBRADOS_VER_MAJOR
, LIBRADOS_VER_MINOR
, LIBRADOS_VER_EXTRA
);
2874 extern "C" int rados_conf_read_file(rados_t cluster
, const char *path_list
)
2876 tracepoint(librados
, rados_conf_read_file_enter
, cluster
, path_list
);
2877 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
2878 md_config_t
*conf
= client
->cct
->_conf
;
2879 ostringstream warnings
;
2880 int ret
= conf
->parse_config_files(path_list
, &warnings
, 0);
2882 if (warnings
.tellp() > 0)
2883 lderr(client
->cct
) << warnings
.str() << dendl
;
2884 client
->cct
->_conf
->complain_about_parse_errors(client
->cct
);
2885 tracepoint(librados
, rados_conf_read_file_exit
, ret
);
2888 conf
->parse_env(); // environment variables override
2890 conf
->apply_changes(NULL
);
2891 client
->cct
->_conf
->complain_about_parse_errors(client
->cct
);
2892 tracepoint(librados
, rados_conf_read_file_exit
, 0);
2896 extern "C" int rados_conf_parse_argv(rados_t cluster
, int argc
, const char **argv
)
2898 tracepoint(librados
, rados_conf_parse_argv_enter
, cluster
, argc
);
2900 for(i
= 0; i
< argc
; i
++) {
2901 tracepoint(librados
, rados_conf_parse_argv_arg
, argv
[i
]);
2903 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
2904 md_config_t
*conf
= client
->cct
->_conf
;
2905 vector
<const char*> args
;
2906 argv_to_vec(argc
, argv
, args
);
2907 int ret
= conf
->parse_argv(args
);
2909 tracepoint(librados
, rados_conf_parse_argv_exit
, ret
);
2912 conf
->apply_changes(NULL
);
2913 tracepoint(librados
, rados_conf_parse_argv_exit
, 0);
2917 // like above, but return the remainder of argv to contain remaining
2918 // unparsed args. Must be allocated to at least argc by caller.
2919 // remargv will contain n <= argc pointers to original argv[], the end
2920 // of which may be NULL
2922 extern "C" int rados_conf_parse_argv_remainder(rados_t cluster
, int argc
,
2924 const char **remargv
)
2926 tracepoint(librados
, rados_conf_parse_argv_remainder_enter
, cluster
, argc
);
2928 for(i
= 0; i
< (unsigned int) argc
; i
++) {
2929 tracepoint(librados
, rados_conf_parse_argv_remainder_arg
, argv
[i
]);
2931 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
2932 md_config_t
*conf
= client
->cct
->_conf
;
2933 vector
<const char*> args
;
2934 for (int i
=0; i
<argc
; i
++)
2935 args
.push_back(argv
[i
]);
2936 int ret
= conf
->parse_argv(args
);
2938 tracepoint(librados
, rados_conf_parse_argv_remainder_exit
, ret
);
2941 conf
->apply_changes(NULL
);
2942 assert(args
.size() <= (unsigned int)argc
);
2943 for (i
= 0; i
< (unsigned int)argc
; ++i
) {
2944 if (i
< args
.size())
2945 remargv
[i
] = args
[i
];
2947 remargv
[i
] = (const char *)NULL
;
2948 tracepoint(librados
, rados_conf_parse_argv_remainder_remarg
, remargv
[i
]);
2950 tracepoint(librados
, rados_conf_parse_argv_remainder_exit
, 0);
2954 extern "C" int rados_conf_parse_env(rados_t cluster
, const char *env
)
2956 tracepoint(librados
, rados_conf_parse_env_enter
, cluster
, env
);
2957 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
2958 md_config_t
*conf
= client
->cct
->_conf
;
2959 vector
<const char*> args
;
2960 env_to_vec(args
, env
);
2961 int ret
= conf
->parse_argv(args
);
2963 tracepoint(librados
, rados_conf_parse_env_exit
, ret
);
2966 conf
->apply_changes(NULL
);
2967 tracepoint(librados
, rados_conf_parse_env_exit
, 0);
2971 extern "C" int rados_conf_set(rados_t cluster
, const char *option
, const char *value
)
2973 tracepoint(librados
, rados_conf_set_enter
, cluster
, option
, value
);
2974 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
2975 md_config_t
*conf
= client
->cct
->_conf
;
2976 int ret
= conf
->set_val(option
, value
);
2978 tracepoint(librados
, rados_conf_set_exit
, ret
);
2981 conf
->apply_changes(NULL
);
2982 tracepoint(librados
, rados_conf_set_exit
, 0);
2987 extern "C" int rados_cluster_stat(rados_t cluster
, rados_cluster_stat_t
*result
)
2989 tracepoint(librados
, rados_cluster_stat_enter
, cluster
);
2990 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
2993 int r
= client
->get_fs_stats(stats
);
2994 result
->kb
= stats
.kb
;
2995 result
->kb_used
= stats
.kb_used
;
2996 result
->kb_avail
= stats
.kb_avail
;
2997 result
->num_objects
= stats
.num_objects
;
2998 tracepoint(librados
, rados_cluster_stat_exit
, r
, result
->kb
, result
->kb_used
, result
->kb_avail
, result
->num_objects
);
3002 extern "C" int rados_conf_get(rados_t cluster
, const char *option
, char *buf
, size_t len
)
3004 tracepoint(librados
, rados_conf_get_enter
, cluster
, option
, len
);
3006 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
3007 md_config_t
*conf
= client
->cct
->_conf
;
3008 int retval
= conf
->get_val(option
, &tmp
, len
);
3009 tracepoint(librados
, rados_conf_get_exit
, retval
, retval
? "" : option
);
3013 extern "C" int64_t rados_pool_lookup(rados_t cluster
, const char *name
)
3015 tracepoint(librados
, rados_pool_lookup_enter
, cluster
, name
);
3016 librados::RadosClient
*radosp
= (librados::RadosClient
*)cluster
;
3017 int64_t retval
= radosp
->lookup_pool(name
);
3018 tracepoint(librados
, rados_pool_lookup_exit
, retval
);
3022 extern "C" int rados_pool_reverse_lookup(rados_t cluster
, int64_t id
,
3023 char *buf
, size_t maxlen
)
3025 tracepoint(librados
, rados_pool_reverse_lookup_enter
, cluster
, id
, maxlen
);
3026 librados::RadosClient
*radosp
= (librados::RadosClient
*)cluster
;
3028 int r
= radosp
->pool_get_name(id
, &name
);
3030 tracepoint(librados
, rados_pool_reverse_lookup_exit
, r
, "");
3033 if (name
.length() >= maxlen
) {
3034 tracepoint(librados
, rados_pool_reverse_lookup_exit
, -ERANGE
, "");
3037 strcpy(buf
, name
.c_str());
3038 int retval
= name
.length();
3039 tracepoint(librados
, rados_pool_reverse_lookup_exit
, retval
, buf
);
3043 extern "C" int rados_cluster_fsid(rados_t cluster
, char *buf
,
3046 tracepoint(librados
, rados_cluster_fsid_enter
, cluster
, maxlen
);
3047 librados::RadosClient
*radosp
= (librados::RadosClient
*)cluster
;
3049 radosp
->get_fsid(&fsid
);
3050 if (fsid
.length() >= maxlen
) {
3051 tracepoint(librados
, rados_cluster_fsid_exit
, -ERANGE
, "");
3054 strcpy(buf
, fsid
.c_str());
3055 int retval
= fsid
.length();
3056 tracepoint(librados
, rados_cluster_fsid_exit
, retval
, buf
);
3060 extern "C" int rados_wait_for_latest_osdmap(rados_t cluster
)
3062 tracepoint(librados
, rados_wait_for_latest_osdmap_enter
, cluster
);
3063 librados::RadosClient
*radosp
= (librados::RadosClient
*)cluster
;
3064 int retval
= radosp
->wait_for_latest_osdmap();
3065 tracepoint(librados
, rados_wait_for_latest_osdmap_exit
, retval
);
3069 extern "C" int rados_blacklist_add(rados_t cluster
, char *client_address
,
3070 uint32_t expire_seconds
)
3072 librados::RadosClient
*radosp
= (librados::RadosClient
*)cluster
;
3073 return radosp
->blacklist_add(client_address
, expire_seconds
);
3076 extern "C" int rados_pool_list(rados_t cluster
, char *buf
, size_t len
)
3078 tracepoint(librados
, rados_pool_list_enter
, cluster
, len
);
3079 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
3080 std::list
<std::pair
<int64_t, std::string
> > pools
;
3081 int r
= client
->pool_list(pools
);
3083 tracepoint(librados
, rados_pool_list_exit
, r
);
3087 if (len
> 0 && !buf
) {
3088 tracepoint(librados
, rados_pool_list_exit
, -EINVAL
);
3096 std::list
<std::pair
<int64_t, std::string
> >::const_iterator i
= pools
.begin();
3097 std::list
<std::pair
<int64_t, std::string
> >::const_iterator p_end
=
3099 for (; i
!= p_end
; ++i
) {
3100 int rl
= i
->second
.length() + 1;
3101 if (len
< (unsigned)rl
)
3103 const char* pool
= i
->second
.c_str();
3104 tracepoint(librados
, rados_pool_list_pool
, pool
);
3106 strncat(b
, pool
, rl
);
3112 for (; i
!= p_end
; ++i
) {
3113 int rl
= i
->second
.length() + 1;
3116 int retval
= needed
+ 1;
3117 tracepoint(librados
, rados_pool_list_exit
, retval
);
3121 CEPH_RADOS_API
int rados_inconsistent_pg_list(rados_t cluster
, int64_t pool_id
,
3122 char *buf
, size_t len
)
3124 tracepoint(librados
, rados_inconsistent_pg_list_enter
, cluster
, pool_id
, len
);
3125 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
3126 std::vector
<librados::PlacementGroup
> pgs
;
3127 int r
= ::get_inconsistent_pgs(*client
, pool_id
, &pgs
);
3129 tracepoint(librados
, rados_inconsistent_pg_list_exit
, r
);
3133 if (len
> 0 && !buf
) {
3134 tracepoint(librados
, rados_inconsistent_pg_list_exit
, -EINVAL
);
3142 for (const auto pg
: pgs
) {
3143 std::ostringstream ss
;
3146 unsigned rl
= s
.length() + 1;
3147 if (b
&& len
>= rl
) {
3148 tracepoint(librados
, rados_inconsistent_pg_list_pg
, s
.c_str());
3149 strncat(b
, s
.c_str(), rl
);
3155 int retval
= needed
+ 1;
3156 tracepoint(librados
, rados_inconsistent_pg_list_exit
, retval
);
3160 static void do_out_buffer(bufferlist
& outbl
, char **outbuf
, size_t *outbuflen
)
3163 if (outbl
.length() > 0) {
3164 *outbuf
= (char *)malloc(outbl
.length());
3165 memcpy(*outbuf
, outbl
.c_str(), outbl
.length());
3171 *outbuflen
= outbl
.length();
3174 static void do_out_buffer(string
& outbl
, char **outbuf
, size_t *outbuflen
)
3177 if (outbl
.length() > 0) {
3178 *outbuf
= (char *)malloc(outbl
.length());
3179 memcpy(*outbuf
, outbl
.c_str(), outbl
.length());
3185 *outbuflen
= outbl
.length();
3188 extern "C" int rados_ping_monitor(rados_t cluster
, const char *mon_id
,
3189 char **outstr
, size_t *outstrlen
)
3191 tracepoint(librados
, rados_ping_monitor_enter
, cluster
, mon_id
);
3192 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
3196 tracepoint(librados
, rados_ping_monitor_exit
, -EINVAL
, NULL
, NULL
);
3200 int ret
= client
->ping_monitor(mon_id
, &str
);
3202 do_out_buffer(str
, outstr
, outstrlen
);
3204 tracepoint(librados
, rados_ping_monitor_exit
, ret
, ret
< 0 ? NULL
: outstr
, ret
< 0 ? NULL
: outstrlen
);
3208 extern "C" int rados_mon_command(rados_t cluster
, const char **cmd
,
3210 const char *inbuf
, size_t inbuflen
,
3211 char **outbuf
, size_t *outbuflen
,
3212 char **outs
, size_t *outslen
)
3214 tracepoint(librados
, rados_mon_command_enter
, cluster
, cmdlen
, inbuf
, inbuflen
);
3215 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
3219 vector
<string
> cmdvec
;
3221 for (size_t i
= 0; i
< cmdlen
; i
++) {
3222 tracepoint(librados
, rados_mon_command_cmd
, cmd
[i
]);
3223 cmdvec
.push_back(cmd
[i
]);
3226 inbl
.append(inbuf
, inbuflen
);
3227 int ret
= client
->mon_command(cmdvec
, inbl
, &outbl
, &outstring
);
3229 do_out_buffer(outbl
, outbuf
, outbuflen
);
3230 do_out_buffer(outstring
, outs
, outslen
);
3231 tracepoint(librados
, rados_mon_command_exit
, ret
, outbuf
, outbuflen
, outs
, outslen
);
3235 extern "C" int rados_mon_command_target(rados_t cluster
, const char *name
,
3238 const char *inbuf
, size_t inbuflen
,
3239 char **outbuf
, size_t *outbuflen
,
3240 char **outs
, size_t *outslen
)
3242 tracepoint(librados
, rados_mon_command_target_enter
, cluster
, name
, cmdlen
, inbuf
, inbuflen
);
3243 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
3247 vector
<string
> cmdvec
;
3249 // is this a numeric id?
3252 long rank
= strtol(name
, &endptr
, 10);
3253 if ((errno
== ERANGE
&& (rank
== LONG_MAX
|| rank
== LONG_MIN
)) ||
3254 (errno
!= 0 && rank
== 0) ||
3255 endptr
== name
|| // no digits
3256 *endptr
!= '\0') { // extra characters
3260 for (size_t i
= 0; i
< cmdlen
; i
++) {
3261 tracepoint(librados
, rados_mon_command_target_cmd
, cmd
[i
]);
3262 cmdvec
.push_back(cmd
[i
]);
3265 inbl
.append(inbuf
, inbuflen
);
3268 ret
= client
->mon_command(rank
, cmdvec
, inbl
, &outbl
, &outstring
);
3270 ret
= client
->mon_command(name
, cmdvec
, inbl
, &outbl
, &outstring
);
3272 do_out_buffer(outbl
, outbuf
, outbuflen
);
3273 do_out_buffer(outstring
, outs
, outslen
);
3274 tracepoint(librados
, rados_mon_command_target_exit
, ret
, outbuf
, outbuflen
, outs
, outslen
);
3278 extern "C" int rados_osd_command(rados_t cluster
, int osdid
, const char **cmd
,
3280 const char *inbuf
, size_t inbuflen
,
3281 char **outbuf
, size_t *outbuflen
,
3282 char **outs
, size_t *outslen
)
3284 tracepoint(librados
, rados_osd_command_enter
, cluster
, osdid
, cmdlen
, inbuf
, inbuflen
);
3285 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
3289 vector
<string
> cmdvec
;
3291 for (size_t i
= 0; i
< cmdlen
; i
++) {
3292 tracepoint(librados
, rados_osd_command_cmd
, cmd
[i
]);
3293 cmdvec
.push_back(cmd
[i
]);
3296 inbl
.append(inbuf
, inbuflen
);
3297 int ret
= client
->osd_command(osdid
, cmdvec
, inbl
, &outbl
, &outstring
);
3299 do_out_buffer(outbl
, outbuf
, outbuflen
);
3300 do_out_buffer(outstring
, outs
, outslen
);
3301 tracepoint(librados
, rados_osd_command_exit
, ret
, outbuf
, outbuflen
, outs
, outslen
);
3305 extern "C" int rados_mgr_command(rados_t cluster
, const char **cmd
,
3307 const char *inbuf
, size_t inbuflen
,
3308 char **outbuf
, size_t *outbuflen
,
3309 char **outs
, size_t *outslen
)
3311 tracepoint(librados
, rados_mgr_command_enter
, cluster
, cmdlen
, inbuf
,
3314 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
3318 vector
<string
> cmdvec
;
3320 for (size_t i
= 0; i
< cmdlen
; i
++) {
3321 tracepoint(librados
, rados_mgr_command_cmd
, cmd
[i
]);
3322 cmdvec
.push_back(cmd
[i
]);
3325 inbl
.append(inbuf
, inbuflen
);
3326 int ret
= client
->mgr_command(cmdvec
, inbl
, &outbl
, &outstring
);
3328 do_out_buffer(outbl
, outbuf
, outbuflen
);
3329 do_out_buffer(outstring
, outs
, outslen
);
3330 tracepoint(librados
, rados_mgr_command_exit
, ret
, outbuf
, outbuflen
, outs
,
3335 extern "C" int rados_pg_command(rados_t cluster
, const char *pgstr
,
3336 const char **cmd
, size_t cmdlen
,
3337 const char *inbuf
, size_t inbuflen
,
3338 char **outbuf
, size_t *outbuflen
,
3339 char **outs
, size_t *outslen
)
3341 tracepoint(librados
, rados_pg_command_enter
, cluster
, pgstr
, cmdlen
, inbuf
, inbuflen
);
3342 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
3347 vector
<string
> cmdvec
;
3349 for (size_t i
= 0; i
< cmdlen
; i
++) {
3350 tracepoint(librados
, rados_pg_command_cmd
, cmd
[i
]);
3351 cmdvec
.push_back(cmd
[i
]);
3354 inbl
.append(inbuf
, inbuflen
);
3355 if (!pgid
.parse(pgstr
))
3358 int ret
= client
->pg_command(pgid
, cmdvec
, inbl
, &outbl
, &outstring
);
3360 do_out_buffer(outbl
, outbuf
, outbuflen
);
3361 do_out_buffer(outstring
, outs
, outslen
);
3362 tracepoint(librados
, rados_pg_command_exit
, ret
, outbuf
, outbuflen
, outs
, outslen
);
3366 extern "C" void rados_buffer_free(char *buf
)
3368 tracepoint(librados
, rados_buffer_free_enter
, buf
);
3371 tracepoint(librados
, rados_buffer_free_exit
);
3374 extern "C" int rados_monitor_log(rados_t cluster
, const char *level
, rados_log_callback_t cb
, void *arg
)
3376 tracepoint(librados
, rados_monitor_log_enter
, cluster
, level
, cb
, arg
);
3377 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
3378 int retval
= client
->monitor_log(level
, cb
, nullptr, arg
);
3379 tracepoint(librados
, rados_monitor_log_exit
, retval
);
3383 extern "C" int rados_monitor_log2(rados_t cluster
, const char *level
,
3384 rados_log_callback2_t cb
, void *arg
)
3386 tracepoint(librados
, rados_monitor_log2_enter
, cluster
, level
, cb
, arg
);
3387 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
3388 int retval
= client
->monitor_log(level
, nullptr, cb
, arg
);
3389 tracepoint(librados
, rados_monitor_log2_exit
, retval
);
3393 extern "C" int rados_ioctx_create(rados_t cluster
, const char *name
, rados_ioctx_t
*io
)
3395 tracepoint(librados
, rados_ioctx_create_enter
, cluster
, name
);
3396 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
3397 librados::IoCtxImpl
*ctx
;
3399 int r
= client
->create_ioctx(name
, &ctx
);
3401 tracepoint(librados
, rados_ioctx_create_exit
, r
, NULL
);
3407 tracepoint(librados
, rados_ioctx_create_exit
, 0, ctx
);
3411 extern "C" int rados_ioctx_create2(rados_t cluster
, int64_t pool_id
,
3414 tracepoint(librados
, rados_ioctx_create2_enter
, cluster
, pool_id
);
3415 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
3416 librados::IoCtxImpl
*ctx
;
3418 int r
= client
->create_ioctx(pool_id
, &ctx
);
3420 tracepoint(librados
, rados_ioctx_create2_exit
, r
, NULL
);
3426 tracepoint(librados
, rados_ioctx_create2_exit
, 0, ctx
);
3430 extern "C" void rados_ioctx_destroy(rados_ioctx_t io
)
3432 tracepoint(librados
, rados_ioctx_destroy_enter
, io
);
3433 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3435 tracepoint(librados
, rados_ioctx_destroy_exit
);
3438 extern "C" int rados_ioctx_pool_stat(rados_ioctx_t io
, struct rados_pool_stat_t
*stats
)
3440 tracepoint(librados
, rados_ioctx_pool_stat_enter
, io
);
3441 librados::IoCtxImpl
*io_ctx_impl
= (librados::IoCtxImpl
*)io
;
3443 std::string pool_name
;
3445 int err
= io_ctx_impl
->client
->pool_get_name(io_ctx_impl
->get_id(), &pool_name
);
3447 tracepoint(librados
, rados_ioctx_pool_stat_exit
, err
, stats
);
3450 ls
.push_back(pool_name
);
3452 map
<string
, ::pool_stat_t
> rawresult
;
3453 err
= io_ctx_impl
->client
->get_pool_stats(ls
, rawresult
);
3455 tracepoint(librados
, rados_ioctx_pool_stat_exit
, err
, stats
);
3459 ::pool_stat_t
& r
= rawresult
[pool_name
];
3460 stats
->num_kb
= SHIFT_ROUND_UP(r
.stats
.sum
.num_bytes
, 10);
3461 stats
->num_bytes
= r
.stats
.sum
.num_bytes
;
3462 stats
->num_objects
= r
.stats
.sum
.num_objects
;
3463 stats
->num_object_clones
= r
.stats
.sum
.num_object_clones
;
3464 stats
->num_object_copies
= r
.stats
.sum
.num_object_copies
;
3465 stats
->num_objects_missing_on_primary
= r
.stats
.sum
.num_objects_missing_on_primary
;
3466 stats
->num_objects_unfound
= r
.stats
.sum
.num_objects_unfound
;
3467 stats
->num_objects_degraded
=
3468 r
.stats
.sum
.num_objects_degraded
+
3469 r
.stats
.sum
.num_objects_misplaced
; // FIXME: this is imprecise
3470 stats
->num_rd
= r
.stats
.sum
.num_rd
;
3471 stats
->num_rd_kb
= r
.stats
.sum
.num_rd_kb
;
3472 stats
->num_wr
= r
.stats
.sum
.num_wr
;
3473 stats
->num_wr_kb
= r
.stats
.sum
.num_wr_kb
;
3474 tracepoint(librados
, rados_ioctx_pool_stat_exit
, 0, stats
);
3478 extern "C" rados_config_t
rados_ioctx_cct(rados_ioctx_t io
)
3480 tracepoint(librados
, rados_ioctx_cct_enter
, io
);
3481 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3482 rados_config_t retval
= (rados_config_t
)ctx
->client
->cct
;
3483 tracepoint(librados
, rados_ioctx_cct_exit
, retval
);
3487 extern "C" void rados_ioctx_snap_set_read(rados_ioctx_t io
, rados_snap_t seq
)
3489 tracepoint(librados
, rados_ioctx_snap_set_read_enter
, io
, seq
);
3490 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3491 ctx
->set_snap_read((snapid_t
)seq
);
3492 tracepoint(librados
, rados_ioctx_snap_set_read_exit
);
3495 extern "C" int rados_ioctx_selfmanaged_snap_set_write_ctx(rados_ioctx_t io
,
3496 rados_snap_t seq
, rados_snap_t
*snaps
, int num_snaps
)
3498 tracepoint(librados
, rados_ioctx_selfmanaged_snap_set_write_ctx_enter
, io
, seq
, snaps
, num_snaps
);
3499 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3500 vector
<snapid_t
> snv
;
3501 snv
.resize(num_snaps
);
3502 for (int i
=0; i
<num_snaps
; i
++) {
3503 snv
[i
] = (snapid_t
)snaps
[i
];
3505 int retval
= ctx
->set_snap_write_context((snapid_t
)seq
, snv
);
3506 tracepoint(librados
, rados_ioctx_selfmanaged_snap_set_write_ctx_exit
, retval
);
3510 extern "C" int rados_write(rados_ioctx_t io
, const char *o
, const char *buf
, size_t len
, uint64_t off
)
3512 tracepoint(librados
, rados_write_enter
, io
, o
, buf
, len
, off
);
3513 if (len
> UINT_MAX
/2)
3515 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3518 bl
.append(buf
, len
);
3519 int retval
= ctx
->write(oid
, bl
, len
, off
);
3520 tracepoint(librados
, rados_write_exit
, retval
);
3524 extern "C" int rados_append(rados_ioctx_t io
, const char *o
, const char *buf
, size_t len
)
3526 tracepoint(librados
, rados_append_enter
, io
, o
, buf
, len
);
3527 if (len
> UINT_MAX
/2)
3529 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3532 bl
.append(buf
, len
);
3533 int retval
= ctx
->append(oid
, bl
, len
);
3534 tracepoint(librados
, rados_append_exit
, retval
);
3538 extern "C" int rados_write_full(rados_ioctx_t io
, const char *o
, const char *buf
, size_t len
)
3540 tracepoint(librados
, rados_write_full_enter
, io
, o
, buf
, len
);
3541 if (len
> UINT_MAX
/2)
3543 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3546 bl
.append(buf
, len
);
3547 int retval
= ctx
->write_full(oid
, bl
);
3548 tracepoint(librados
, rados_write_full_exit
, retval
);
3552 extern "C" int rados_writesame(rados_ioctx_t io
,
3559 tracepoint(librados
, rados_writesame_enter
, io
, o
, buf
, data_len
, write_len
, off
);
3560 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3563 bl
.append(buf
, data_len
);
3564 int retval
= ctx
->writesame(oid
, bl
, write_len
, off
);
3565 tracepoint(librados
, rados_writesame_exit
, retval
);
3569 extern "C" int rados_trunc(rados_ioctx_t io
, const char *o
, uint64_t size
)
3571 tracepoint(librados
, rados_trunc_enter
, io
, o
, size
);
3572 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3574 int retval
= ctx
->trunc(oid
, size
);
3575 tracepoint(librados
, rados_trunc_exit
, retval
);
3579 extern "C" int rados_remove(rados_ioctx_t io
, const char *o
)
3581 tracepoint(librados
, rados_remove_enter
, io
, o
);
3582 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3584 int retval
= ctx
->remove(oid
);
3585 tracepoint(librados
, rados_remove_exit
, retval
);
3589 extern "C" int rados_read(rados_ioctx_t io
, const char *o
, char *buf
, size_t len
, uint64_t off
)
3591 tracepoint(librados
, rados_read_enter
, io
, o
, buf
, len
, off
);
3592 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3597 bufferptr bp
= buffer::create_static(len
, buf
);
3600 ret
= ctx
->read(oid
, bl
, len
, off
);
3602 if (bl
.length() > len
) {
3603 tracepoint(librados
, rados_read_exit
, -ERANGE
, NULL
);
3606 if (!bl
.is_provided_buffer(buf
))
3607 bl
.copy(0, bl
.length(), buf
);
3608 ret
= bl
.length(); // hrm :/
3611 tracepoint(librados
, rados_read_exit
, ret
, buf
);
3615 extern "C" int rados_checksum(rados_ioctx_t io
, const char *o
,
3616 rados_checksum_type_t type
,
3617 const char *init_value
, size_t init_value_len
,
3618 size_t len
, uint64_t off
, size_t chunk_size
,
3619 char *pchecksum
, size_t checksum_len
)
3621 tracepoint(librados
, rados_checksum_enter
, io
, o
, type
, init_value
,
3622 init_value_len
, len
, off
, chunk_size
);
3623 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3626 bufferlist init_value_bl
;
3627 init_value_bl
.append(init_value
, init_value_len
);
3629 bufferlist checksum_bl
;
3631 int retval
= ctx
->checksum(oid
, get_checksum_op_type(type
), init_value_bl
,
3632 len
, off
, chunk_size
, &checksum_bl
);
3634 if (checksum_bl
.length() > checksum_len
) {
3635 tracepoint(librados
, rados_checksum_exit
, -ERANGE
, NULL
, 0);
3639 checksum_bl
.copy(0, checksum_bl
.length(), pchecksum
);
3641 tracepoint(librados
, rados_checksum_exit
, retval
, pchecksum
, checksum_len
);
3645 extern "C" uint64_t rados_get_last_version(rados_ioctx_t io
)
3647 tracepoint(librados
, rados_get_last_version_enter
, io
);
3648 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3649 uint64_t retval
= ctx
->last_version();
3650 tracepoint(librados
, rados_get_last_version_exit
, retval
);
3654 extern "C" int rados_pool_create(rados_t cluster
, const char *name
)
3656 tracepoint(librados
, rados_pool_create_enter
, cluster
, name
);
3657 librados::RadosClient
*radosp
= (librados::RadosClient
*)cluster
;
3659 int retval
= radosp
->pool_create(sname
);
3660 tracepoint(librados
, rados_pool_create_exit
, retval
);
3664 extern "C" int rados_pool_create_with_auid(rados_t cluster
, const char *name
,
3667 tracepoint(librados
, rados_pool_create_with_auid_enter
, cluster
, name
, auid
);
3668 librados::RadosClient
*radosp
= (librados::RadosClient
*)cluster
;
3670 int retval
= radosp
->pool_create(sname
, auid
);
3671 tracepoint(librados
, rados_pool_create_with_auid_exit
, retval
);
3675 extern "C" int rados_pool_create_with_crush_rule(rados_t cluster
, const char *name
,
3676 __u8 crush_rule_num
)
3678 tracepoint(librados
, rados_pool_create_with_crush_rule_enter
, cluster
, name
, crush_rule_num
);
3679 librados::RadosClient
*radosp
= (librados::RadosClient
*)cluster
;
3681 int retval
= radosp
->pool_create(sname
, 0, crush_rule_num
);
3682 tracepoint(librados
, rados_pool_create_with_crush_rule_exit
, retval
);
3686 extern "C" int rados_pool_create_with_all(rados_t cluster
, const char *name
,
3687 uint64_t auid
, __u8 crush_rule_num
)
3689 tracepoint(librados
, rados_pool_create_with_all_enter
, cluster
, name
, auid
, crush_rule_num
);
3690 librados::RadosClient
*radosp
= (librados::RadosClient
*)cluster
;
3692 int retval
= radosp
->pool_create(sname
, auid
, crush_rule_num
);
3693 tracepoint(librados
, rados_pool_create_with_all_exit
, retval
);
3697 extern "C" int rados_pool_get_base_tier(rados_t cluster
, int64_t pool_id
, int64_t* base_tier
)
3699 tracepoint(librados
, rados_pool_get_base_tier_enter
, cluster
, pool_id
);
3700 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
3701 int retval
= client
->pool_get_base_tier(pool_id
, base_tier
);
3702 tracepoint(librados
, rados_pool_get_base_tier_exit
, retval
, *base_tier
);
3706 extern "C" int rados_pool_delete(rados_t cluster
, const char *pool_name
)
3708 tracepoint(librados
, rados_pool_delete_enter
, cluster
, pool_name
);
3709 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
3710 int retval
= client
->pool_delete(pool_name
);
3711 tracepoint(librados
, rados_pool_delete_exit
, retval
);
3715 extern "C" int rados_ioctx_pool_set_auid(rados_ioctx_t io
, uint64_t auid
)
3717 tracepoint(librados
, rados_ioctx_pool_set_auid_enter
, io
, auid
);
3718 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3719 int retval
= ctx
->pool_change_auid(auid
);
3720 tracepoint(librados
, rados_ioctx_pool_set_auid_exit
, retval
);
3724 extern "C" int rados_ioctx_pool_get_auid(rados_ioctx_t io
, uint64_t *auid
)
3726 tracepoint(librados
, rados_ioctx_pool_get_auid_enter
, io
);
3727 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3728 int retval
= ctx
->client
->pool_get_auid(ctx
->get_id(), (unsigned long long *)auid
);
3729 tracepoint(librados
, rados_ioctx_pool_get_auid_exit
, retval
, *auid
);
3733 extern "C" int rados_ioctx_pool_requires_alignment(rados_ioctx_t io
)
3735 tracepoint(librados
, rados_ioctx_pool_requires_alignment_enter
, io
);
3736 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3737 int retval
= ctx
->client
->pool_requires_alignment(ctx
->get_id());
3738 tracepoint(librados
, rados_ioctx_pool_requires_alignment_exit
, retval
);
3742 extern "C" int rados_ioctx_pool_requires_alignment2(rados_ioctx_t io
,
3745 tracepoint(librados
, rados_ioctx_pool_requires_alignment_enter2
, io
);
3746 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3747 bool requires_alignment
;
3748 int retval
= ctx
->client
->pool_requires_alignment2(ctx
->get_id(),
3749 &requires_alignment
);
3750 tracepoint(librados
, rados_ioctx_pool_requires_alignment_exit2
, retval
,
3751 requires_alignment
);
3753 *requires
= requires_alignment
;
3757 extern "C" uint64_t rados_ioctx_pool_required_alignment(rados_ioctx_t io
)
3759 tracepoint(librados
, rados_ioctx_pool_required_alignment_enter
, io
);
3760 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3761 uint64_t retval
= ctx
->client
->pool_required_alignment(ctx
->get_id());
3762 tracepoint(librados
, rados_ioctx_pool_required_alignment_exit
, retval
);
3766 extern "C" int rados_ioctx_pool_required_alignment2(rados_ioctx_t io
,
3767 uint64_t *alignment
)
3769 tracepoint(librados
, rados_ioctx_pool_required_alignment_enter2
, io
);
3770 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3771 int retval
= ctx
->client
->pool_required_alignment2(ctx
->get_id(),
3773 tracepoint(librados
, rados_ioctx_pool_required_alignment_exit2
, retval
,
3778 extern "C" void rados_ioctx_locator_set_key(rados_ioctx_t io
, const char *key
)
3780 tracepoint(librados
, rados_ioctx_locator_set_key_enter
, io
, key
);
3781 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3783 ctx
->oloc
.key
= key
;
3786 tracepoint(librados
, rados_ioctx_locator_set_key_exit
);
3789 extern "C" void rados_ioctx_set_namespace(rados_ioctx_t io
, const char *nspace
)
3791 tracepoint(librados
, rados_ioctx_set_namespace_enter
, io
, nspace
);
3792 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3794 ctx
->oloc
.nspace
= nspace
;
3796 ctx
->oloc
.nspace
= "";
3797 tracepoint(librados
, rados_ioctx_set_namespace_exit
);
3800 extern "C" rados_t
rados_ioctx_get_cluster(rados_ioctx_t io
)
3802 tracepoint(librados
, rados_ioctx_get_cluster_enter
, io
);
3803 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3804 rados_t retval
= (rados_t
)ctx
->client
;
3805 tracepoint(librados
, rados_ioctx_get_cluster_exit
, retval
);
3809 extern "C" int64_t rados_ioctx_get_id(rados_ioctx_t io
)
3811 tracepoint(librados
, rados_ioctx_get_id_enter
, io
);
3812 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3813 int64_t retval
= ctx
->get_id();
3814 tracepoint(librados
, rados_ioctx_get_id_exit
, retval
);
3818 extern "C" int rados_ioctx_get_pool_name(rados_ioctx_t io
, char *s
, unsigned maxlen
)
3820 tracepoint(librados
, rados_ioctx_get_pool_name_enter
, io
, maxlen
);
3821 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3822 std::string pool_name
;
3824 int err
= ctx
->client
->pool_get_name(ctx
->get_id(), &pool_name
);
3826 tracepoint(librados
, rados_ioctx_get_pool_name_exit
, err
, "");
3829 if (pool_name
.length() >= maxlen
) {
3830 tracepoint(librados
, rados_ioctx_get_pool_name_exit
, -ERANGE
, "");
3833 strcpy(s
, pool_name
.c_str());
3834 int retval
= pool_name
.length();
3835 tracepoint(librados
, rados_ioctx_get_pool_name_exit
, retval
, s
);
3841 extern "C" int rados_ioctx_snap_create(rados_ioctx_t io
, const char *snapname
)
3843 tracepoint(librados
, rados_ioctx_snap_create_enter
, io
, snapname
);
3844 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3845 int retval
= ctx
->snap_create(snapname
);
3846 tracepoint(librados
, rados_ioctx_snap_create_exit
, retval
);
3850 extern "C" int rados_ioctx_snap_remove(rados_ioctx_t io
, const char *snapname
)
3852 tracepoint(librados
, rados_ioctx_snap_remove_enter
, io
, snapname
);
3853 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3854 int retval
= ctx
->snap_remove(snapname
);
3855 tracepoint(librados
, rados_ioctx_snap_remove_exit
, retval
);
3859 extern "C" int rados_ioctx_snap_rollback(rados_ioctx_t io
, const char *oid
,
3860 const char *snapname
)
3862 tracepoint(librados
, rados_ioctx_snap_rollback_enter
, io
, oid
, snapname
);
3863 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3864 int retval
= ctx
->rollback(oid
, snapname
);
3865 tracepoint(librados
, rados_ioctx_snap_rollback_exit
, retval
);
3869 // Deprecated name kept for backward compatibility
3870 extern "C" int rados_rollback(rados_ioctx_t io
, const char *oid
,
3871 const char *snapname
)
3873 return rados_ioctx_snap_rollback(io
, oid
, snapname
);
3876 extern "C" int rados_ioctx_selfmanaged_snap_create(rados_ioctx_t io
,
3879 tracepoint(librados
, rados_ioctx_selfmanaged_snap_create_enter
, io
);
3880 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3881 int retval
= ctx
->selfmanaged_snap_create(snapid
);
3882 tracepoint(librados
, rados_ioctx_selfmanaged_snap_create_exit
, retval
, *snapid
);
3887 rados_aio_ioctx_selfmanaged_snap_create(rados_ioctx_t io
,
3888 rados_snap_t
*snapid
,
3889 rados_completion_t completion
)
3891 tracepoint(librados
, rados_ioctx_selfmanaged_snap_create_enter
, io
);
3892 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3893 librados::AioCompletionImpl
*c
= (librados::AioCompletionImpl
*)completion
;
3894 ctx
->aio_selfmanaged_snap_create(snapid
, c
);
3895 tracepoint(librados
, rados_ioctx_selfmanaged_snap_create_exit
, 0, 0);
3898 extern "C" int rados_ioctx_selfmanaged_snap_remove(rados_ioctx_t io
,
3901 tracepoint(librados
, rados_ioctx_selfmanaged_snap_remove_enter
, io
, snapid
);
3902 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3903 int retval
= ctx
->selfmanaged_snap_remove(snapid
);
3904 tracepoint(librados
, rados_ioctx_selfmanaged_snap_remove_exit
, retval
);
3909 rados_aio_ioctx_selfmanaged_snap_remove(rados_ioctx_t io
,
3910 rados_snap_t snapid
,
3911 rados_completion_t completion
)
3913 tracepoint(librados
, rados_ioctx_selfmanaged_snap_remove_enter
, io
, snapid
);
3914 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3915 librados::AioCompletionImpl
*c
= (librados::AioCompletionImpl
*)completion
;
3916 ctx
->aio_selfmanaged_snap_remove(snapid
, c
);
3917 tracepoint(librados
, rados_ioctx_selfmanaged_snap_remove_exit
, 0);
3920 extern "C" int rados_ioctx_selfmanaged_snap_rollback(rados_ioctx_t io
,
3924 tracepoint(librados
, rados_ioctx_selfmanaged_snap_rollback_enter
, io
, oid
, snapid
);
3925 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3926 int retval
= ctx
->selfmanaged_snap_rollback_object(oid
, ctx
->snapc
, snapid
);
3927 tracepoint(librados
, rados_ioctx_selfmanaged_snap_rollback_exit
, retval
);
3931 extern "C" int rados_ioctx_snap_list(rados_ioctx_t io
, rados_snap_t
*snaps
,
3934 tracepoint(librados
, rados_ioctx_snap_list_enter
, io
, maxlen
);
3935 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3936 vector
<uint64_t> snapvec
;
3937 int r
= ctx
->snap_list(&snapvec
);
3939 tracepoint(librados
, rados_ioctx_snap_list_exit
, r
, snaps
, 0);
3942 if ((int)snapvec
.size() <= maxlen
) {
3943 for (unsigned i
=0; i
<snapvec
.size(); i
++) {
3944 snaps
[i
] = snapvec
[i
];
3946 int retval
= snapvec
.size();
3947 tracepoint(librados
, rados_ioctx_snap_list_exit
, retval
, snaps
, retval
);
3950 int retval
= -ERANGE
;
3951 tracepoint(librados
, rados_ioctx_snap_list_exit
, retval
, snaps
, 0);
3955 extern "C" int rados_ioctx_snap_lookup(rados_ioctx_t io
, const char *name
,
3958 tracepoint(librados
, rados_ioctx_snap_lookup_enter
, io
, name
);
3959 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3960 int retval
= ctx
->snap_lookup(name
, (uint64_t *)id
);
3961 tracepoint(librados
, rados_ioctx_snap_lookup_exit
, retval
, *id
);
3965 extern "C" int rados_ioctx_snap_get_name(rados_ioctx_t io
, rados_snap_t id
,
3966 char *name
, int maxlen
)
3968 tracepoint(librados
, rados_ioctx_snap_get_name_enter
, io
, id
, maxlen
);
3969 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3971 int r
= ctx
->snap_get_name(id
, &sname
);
3973 tracepoint(librados
, rados_ioctx_snap_get_name_exit
, r
, "");
3976 if ((int)sname
.length() >= maxlen
) {
3977 int retval
= -ERANGE
;
3978 tracepoint(librados
, rados_ioctx_snap_get_name_exit
, retval
, "");
3981 strncpy(name
, sname
.c_str(), maxlen
);
3982 tracepoint(librados
, rados_ioctx_snap_get_name_exit
, 0, name
);
3986 extern "C" int rados_ioctx_snap_get_stamp(rados_ioctx_t io
, rados_snap_t id
, time_t *t
)
3988 tracepoint(librados
, rados_ioctx_snap_get_stamp_enter
, io
, id
);
3989 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
3990 int retval
= ctx
->snap_get_stamp(id
, t
);
3991 tracepoint(librados
, rados_ioctx_snap_get_stamp_exit
, retval
, *t
);
3995 extern "C" int rados_cmpext(rados_ioctx_t io
, const char *o
,
3996 const char *cmp_buf
, size_t cmp_len
, uint64_t off
)
3998 tracepoint(librados
, rados_cmpext_enter
, io
, o
, cmp_buf
, cmp_len
, off
);
3999 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4004 cmp_bl
.append(cmp_buf
, cmp_len
);
4006 ret
= ctx
->cmpext(oid
, off
, cmp_bl
);
4007 tracepoint(librados
, rados_cmpext_exit
, ret
);
4012 extern "C" int rados_getxattr(rados_ioctx_t io
, const char *o
, const char *name
,
4013 char *buf
, size_t len
)
4015 tracepoint(librados
, rados_getxattr_enter
, io
, o
, name
, len
);
4016 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4020 bl
.push_back(buffer::create_static(len
, buf
));
4021 ret
= ctx
->getxattr(oid
, name
, bl
);
4023 if (bl
.length() > len
) {
4024 tracepoint(librados
, rados_getxattr_exit
, -ERANGE
, buf
, 0);
4027 if (!bl
.is_provided_buffer(buf
))
4028 bl
.copy(0, bl
.length(), buf
);
4032 tracepoint(librados
, rados_getxattr_exit
, ret
, buf
, ret
);
4036 extern "C" int rados_getxattrs(rados_ioctx_t io
, const char *oid
,
4037 rados_xattrs_iter_t
*iter
)
4039 tracepoint(librados
, rados_getxattrs_enter
, io
, oid
);
4040 librados::RadosXattrsIter
*it
= new librados::RadosXattrsIter();
4042 tracepoint(librados
, rados_getxattrs_exit
, -ENOMEM
, NULL
);
4045 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4047 int ret
= ctx
->getxattrs(obj
, it
->attrset
);
4050 tracepoint(librados
, rados_getxattrs_exit
, ret
, NULL
);
4053 it
->i
= it
->attrset
.begin();
4055 librados::RadosXattrsIter
**iret
= (librados::RadosXattrsIter
**)iter
;
4058 tracepoint(librados
, rados_getxattrs_exit
, 0, *iter
);
4062 extern "C" int rados_getxattrs_next(rados_xattrs_iter_t iter
,
4063 const char **name
, const char **val
, size_t *len
)
4065 tracepoint(librados
, rados_getxattrs_next_enter
, iter
);
4066 librados::RadosXattrsIter
*it
= static_cast<librados::RadosXattrsIter
*>(iter
);
4067 if (it
->i
== it
->attrset
.end()) {
4071 tracepoint(librados
, rados_getxattrs_next_exit
, 0, NULL
, NULL
, 0);
4075 const std::string
&s(it
->i
->first
);
4077 bufferlist
&bl(it
->i
->second
);
4078 size_t bl_len
= bl
.length();
4080 // malloc(0) is not guaranteed to return a valid pointer
4081 *val
= (char *)NULL
;
4083 it
->val
= (char*)malloc(bl_len
);
4085 tracepoint(librados
, rados_getxattrs_next_exit
, -ENOMEM
, *name
, NULL
, 0);
4088 memcpy(it
->val
, bl
.c_str(), bl_len
);
4093 tracepoint(librados
, rados_getxattrs_next_exit
, 0, *name
, *val
, *len
);
4097 extern "C" void rados_getxattrs_end(rados_xattrs_iter_t iter
)
4099 tracepoint(librados
, rados_getxattrs_end_enter
, iter
);
4100 librados::RadosXattrsIter
*it
= static_cast<librados::RadosXattrsIter
*>(iter
);
4102 tracepoint(librados
, rados_getxattrs_end_exit
);
4105 extern "C" int rados_setxattr(rados_ioctx_t io
, const char *o
, const char *name
, const char *buf
, size_t len
)
4107 tracepoint(librados
, rados_setxattr_enter
, io
, o
, name
, buf
, len
);
4108 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4111 bl
.append(buf
, len
);
4112 int retval
= ctx
->setxattr(oid
, name
, bl
);
4113 tracepoint(librados
, rados_setxattr_exit
, retval
);
4117 extern "C" int rados_rmxattr(rados_ioctx_t io
, const char *o
, const char *name
)
4119 tracepoint(librados
, rados_rmxattr_enter
, io
, o
, name
);
4120 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4122 int retval
= ctx
->rmxattr(oid
, name
);
4123 tracepoint(librados
, rados_rmxattr_exit
, retval
);
4127 extern "C" int rados_stat(rados_ioctx_t io
, const char *o
, uint64_t *psize
, time_t *pmtime
)
4129 tracepoint(librados
, rados_stat_enter
, io
, o
);
4130 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4132 int retval
= ctx
->stat(oid
, psize
, pmtime
);
4133 tracepoint(librados
, rados_stat_exit
, retval
, psize
, pmtime
);
4137 extern "C" int rados_tmap_update(rados_ioctx_t io
, const char *o
, const char *cmdbuf
, size_t cmdbuflen
)
4139 tracepoint(librados
, rados_tmap_update_enter
, io
, o
, cmdbuf
, cmdbuflen
);
4140 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4143 cmdbl
.append(cmdbuf
, cmdbuflen
);
4144 int retval
= ctx
->tmap_update(oid
, cmdbl
);
4145 tracepoint(librados
, rados_tmap_update_exit
, retval
);
4149 extern "C" int rados_tmap_put(rados_ioctx_t io
, const char *o
, const char *buf
, size_t buflen
)
4151 tracepoint(librados
, rados_tmap_put_enter
, io
, o
, buf
, buflen
);
4152 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4155 bl
.append(buf
, buflen
);
4156 int retval
= ctx
->tmap_put(oid
, bl
);
4157 tracepoint(librados
, rados_tmap_put_exit
, retval
);
4161 extern "C" int rados_tmap_get(rados_ioctx_t io
, const char *o
, char *buf
, size_t buflen
)
4163 tracepoint(librados
, rados_tmap_get_enter
, io
, o
, buflen
);
4164 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4167 int r
= ctx
->tmap_get(oid
, bl
);
4169 tracepoint(librados
, rados_tmap_get_exit
, r
, buf
, 0);
4172 if (bl
.length() > buflen
) {
4173 tracepoint(librados
, rados_tmap_get_exit
, -ERANGE
, buf
, 0);
4176 bl
.copy(0, bl
.length(), buf
);
4177 int retval
= bl
.length();
4178 tracepoint(librados
, rados_tmap_get_exit
, retval
, buf
, retval
);
4182 extern "C" int rados_tmap_to_omap(rados_ioctx_t io
, const char *o
, bool nullok
)
4184 tracepoint(librados
, rados_tmap_to_omap_enter
, io
, o
, nullok
);
4185 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4187 int retval
= ctx
->tmap_to_omap(oid
, nullok
);
4188 tracepoint(librados
, rados_tmap_to_omap_exit
, retval
);
4192 extern "C" int rados_exec(rados_ioctx_t io
, const char *o
, const char *cls
, const char *method
,
4193 const char *inbuf
, size_t in_len
, char *buf
, size_t out_len
)
4195 tracepoint(librados
, rados_exec_enter
, io
, o
, cls
, method
, inbuf
, in_len
, out_len
);
4196 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4198 bufferlist inbl
, outbl
;
4200 inbl
.append(inbuf
, in_len
);
4201 ret
= ctx
->exec(oid
, cls
, method
, inbl
, outbl
);
4203 if (outbl
.length()) {
4204 if (outbl
.length() > out_len
) {
4205 tracepoint(librados
, rados_exec_exit
, -ERANGE
, buf
, 0);
4208 outbl
.copy(0, outbl
.length(), buf
);
4209 ret
= outbl
.length(); // hrm :/
4212 tracepoint(librados
, rados_exec_exit
, ret
, buf
, ret
);
4216 extern "C" rados_object_list_cursor
rados_object_list_begin(rados_ioctx_t io
)
4218 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4220 hobject_t
*result
= new hobject_t(ctx
->objecter
->enumerate_objects_begin());
4221 return (rados_object_list_cursor
)result
;
4224 extern "C" rados_object_list_cursor
rados_object_list_end(rados_ioctx_t io
)
4226 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4228 hobject_t
*result
= new hobject_t(ctx
->objecter
->enumerate_objects_end());
4229 return (rados_object_list_cursor
)result
;
4232 extern "C" int rados_object_list_is_end(
4233 rados_ioctx_t io
, rados_object_list_cursor cur
)
4235 hobject_t
*hobj
= (hobject_t
*)cur
;
4236 return hobj
->is_max();
4239 extern "C" void rados_object_list_cursor_free(
4240 rados_ioctx_t io
, rados_object_list_cursor cur
)
4242 hobject_t
*hobj
= (hobject_t
*)cur
;
4246 extern "C" int rados_object_list_cursor_cmp(
4248 rados_object_list_cursor lhs_cur
,
4249 rados_object_list_cursor rhs_cur
)
4251 hobject_t
*lhs
= (hobject_t
*)lhs_cur
;
4252 hobject_t
*rhs
= (hobject_t
*)rhs_cur
;
4253 return cmp(*lhs
, *rhs
);
4256 extern "C" int rados_object_list(rados_ioctx_t io
,
4257 const rados_object_list_cursor start
,
4258 const rados_object_list_cursor finish
,
4259 const size_t result_item_count
,
4260 const char *filter_buf
,
4261 const size_t filter_buf_len
,
4262 rados_object_list_item
*result_items
,
4263 rados_object_list_cursor
*next
)
4267 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4269 // Zero out items so that they will be safe to free later
4270 memset(result_items
, 0, sizeof(rados_object_list_item
) * result_item_count
);
4272 std::list
<librados::ListObjectImpl
> result
;
4273 hobject_t next_hash
;
4275 bufferlist filter_bl
;
4276 if (filter_buf
!= nullptr) {
4277 filter_bl
.append(filter_buf
, filter_buf_len
);
4281 ctx
->objecter
->enumerate_objects(
4284 *((hobject_t
*)start
),
4285 *((hobject_t
*)finish
),
4292 hobject_t
*next_hobj
= (hobject_t
*)(*next
);
4295 int r
= cond
.wait();
4297 *next_hobj
= hobject_t::get_max();
4301 assert(result
.size() <= result_item_count
); // Don't overflow!
4304 for (std::list
<librados::ListObjectImpl
>::iterator i
= result
.begin();
4305 i
!= result
.end(); ++i
) {
4306 rados_object_list_item
&item
= result_items
[k
++];
4307 do_out_buffer(i
->oid
, &item
.oid
, &item
.oid_length
);
4308 do_out_buffer(i
->nspace
, &item
.nspace
, &item
.nspace_length
);
4309 do_out_buffer(i
->locator
, &item
.locator
, &item
.locator_length
);
4312 *next_hobj
= next_hash
;
4314 return result
.size();
4317 extern "C" void rados_object_list_free(
4318 const size_t result_size
,
4319 rados_object_list_item
*results
)
4323 for (unsigned int i
= 0; i
< result_size
; ++i
) {
4324 rados_buffer_free(results
[i
].oid
);
4325 rados_buffer_free(results
[i
].locator
);
4326 rados_buffer_free(results
[i
].nspace
);
4332 extern "C" int rados_nobjects_list_open(rados_ioctx_t io
, rados_list_ctx_t
*listh
)
4334 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4336 tracepoint(librados
, rados_nobjects_list_open_enter
, io
);
4338 Objecter::NListContext
*h
= new Objecter::NListContext
;
4339 h
->pool_id
= ctx
->poolid
;
4340 h
->pool_snap_seq
= ctx
->snap_seq
;
4341 h
->nspace
= ctx
->oloc
.nspace
; // After dropping compatibility need nspace
4342 *listh
= (void *)new librados::ObjListCtx(ctx
, h
);
4343 tracepoint(librados
, rados_nobjects_list_open_exit
, 0, *listh
);
4347 extern "C" void rados_nobjects_list_close(rados_list_ctx_t h
)
4349 tracepoint(librados
, rados_nobjects_list_close_enter
, h
);
4350 librados::ObjListCtx
*lh
= (librados::ObjListCtx
*)h
;
4352 tracepoint(librados
, rados_nobjects_list_close_exit
);
4355 extern "C" uint32_t rados_nobjects_list_seek(rados_list_ctx_t listctx
,
4358 librados::ObjListCtx
*lh
= (librados::ObjListCtx
*)listctx
;
4359 tracepoint(librados
, rados_nobjects_list_seek_enter
, listctx
, pos
);
4360 uint32_t r
= lh
->ctx
->nlist_seek(lh
->nlc
, pos
);
4361 tracepoint(librados
, rados_nobjects_list_seek_exit
, r
);
4365 extern "C" uint32_t rados_nobjects_list_seek_cursor(rados_list_ctx_t listctx
,
4366 rados_object_list_cursor cursor
)
4368 librados::ObjListCtx
*lh
= (librados::ObjListCtx
*)listctx
;
4370 tracepoint(librados
, rados_nobjects_list_seek_cursor_enter
, listctx
);
4371 uint32_t r
= lh
->ctx
->nlist_seek(lh
->nlc
, cursor
);
4372 tracepoint(librados
, rados_nobjects_list_seek_cursor_exit
, r
);
4376 extern "C" int rados_nobjects_list_get_cursor(rados_list_ctx_t listctx
,
4377 rados_object_list_cursor
*cursor
)
4379 librados::ObjListCtx
*lh
= (librados::ObjListCtx
*)listctx
;
4381 tracepoint(librados
, rados_nobjects_list_get_cursor_enter
, listctx
);
4382 *cursor
= lh
->ctx
->nlist_get_cursor(lh
->nlc
);
4383 tracepoint(librados
, rados_nobjects_list_get_cursor_exit
, 0);
4387 extern "C" uint32_t rados_nobjects_list_get_pg_hash_position(
4388 rados_list_ctx_t listctx
)
4390 librados::ObjListCtx
*lh
= (librados::ObjListCtx
*)listctx
;
4391 tracepoint(librados
, rados_nobjects_list_get_pg_hash_position_enter
, listctx
);
4392 uint32_t retval
= lh
->nlc
->get_pg_hash_position();
4393 tracepoint(librados
, rados_nobjects_list_get_pg_hash_position_exit
, retval
);
4397 extern "C" int rados_nobjects_list_next(rados_list_ctx_t listctx
, const char **entry
, const char **key
, const char **nspace
)
4399 tracepoint(librados
, rados_nobjects_list_next_enter
, listctx
);
4400 librados::ObjListCtx
*lh
= (librados::ObjListCtx
*)listctx
;
4401 Objecter::NListContext
*h
= lh
->nlc
;
4403 // if the list is non-empty, this method has been called before
4404 if (!h
->list
.empty())
4405 // so let's kill the previously-returned object
4406 h
->list
.pop_front();
4408 if (h
->list
.empty()) {
4409 int ret
= lh
->ctx
->nlist(lh
->nlc
, RADOS_LIST_MAX_ENTRIES
);
4411 tracepoint(librados
, rados_nobjects_list_next_exit
, ret
, NULL
, NULL
, NULL
);
4414 if (h
->list
.empty()) {
4415 tracepoint(librados
, rados_nobjects_list_next_exit
, -ENOENT
, NULL
, NULL
, NULL
);
4420 *entry
= h
->list
.front().oid
.c_str();
4423 if (h
->list
.front().locator
.size())
4424 *key
= h
->list
.front().locator
.c_str();
4429 *nspace
= h
->list
.front().nspace
.c_str();
4430 tracepoint(librados
, rados_nobjects_list_next_exit
, 0, *entry
, key
, nspace
);
4436 * removed legacy v2 list objects stubs
4438 * thse return -ENOTSUP where possible.
4440 extern "C" int rados_objects_list_open(
4442 rados_list_ctx_t
*ctx
)
4447 extern "C" uint32_t rados_objects_list_get_pg_hash_position(
4448 rados_list_ctx_t ctx
)
4453 extern "C" uint32_t rados_objects_list_seek(
4454 rados_list_ctx_t ctx
,
4460 extern "C" int rados_objects_list_next(
4461 rados_list_ctx_t ctx
,
4468 extern "C" void rados_objects_list_close(
4469 rados_list_ctx_t ctx
)
4474 // -------------------------
4477 extern "C" int rados_aio_create_completion(void *cb_arg
,
4478 rados_callback_t cb_complete
,
4479 rados_callback_t cb_safe
,
4480 rados_completion_t
*pc
)
4482 tracepoint(librados
, rados_aio_create_completion_enter
, cb_arg
, cb_complete
, cb_safe
);
4483 librados::AioCompletionImpl
*c
= new librados::AioCompletionImpl
;
4485 c
->set_complete_callback(cb_arg
, cb_complete
);
4487 c
->set_safe_callback(cb_arg
, cb_safe
);
4489 tracepoint(librados
, rados_aio_create_completion_exit
, 0, *pc
);
4493 extern "C" int rados_aio_wait_for_complete(rados_completion_t c
)
4495 tracepoint(librados
, rados_aio_wait_for_complete_enter
, c
);
4496 int retval
= ((librados::AioCompletionImpl
*)c
)->wait_for_complete();
4497 tracepoint(librados
, rados_aio_wait_for_complete_exit
, retval
);
4501 extern "C" int rados_aio_wait_for_safe(rados_completion_t c
)
4503 tracepoint(librados
, rados_aio_wait_for_safe_enter
, c
);
4504 int retval
= ((librados::AioCompletionImpl
*)c
)->wait_for_safe();
4505 tracepoint(librados
, rados_aio_wait_for_safe_exit
, retval
);
4509 extern "C" int rados_aio_is_complete(rados_completion_t c
)
4511 tracepoint(librados
, rados_aio_is_complete_enter
, c
);
4512 int retval
= ((librados::AioCompletionImpl
*)c
)->is_complete();
4513 tracepoint(librados
, rados_aio_is_complete_exit
, retval
);
4517 extern "C" int rados_aio_is_safe(rados_completion_t c
)
4519 tracepoint(librados
, rados_aio_is_safe_enter
, c
);
4520 int retval
= ((librados::AioCompletionImpl
*)c
)->is_safe();
4521 tracepoint(librados
, rados_aio_is_safe_exit
, retval
);
4525 extern "C" int rados_aio_wait_for_complete_and_cb(rados_completion_t c
)
4527 tracepoint(librados
, rados_aio_wait_for_complete_and_cb_enter
, c
);
4528 int retval
= ((librados::AioCompletionImpl
*)c
)->wait_for_complete_and_cb();
4529 tracepoint(librados
, rados_aio_wait_for_complete_and_cb_exit
, retval
);
4533 extern "C" int rados_aio_wait_for_safe_and_cb(rados_completion_t c
)
4535 tracepoint(librados
, rados_aio_wait_for_safe_and_cb_enter
, c
);
4536 int retval
= ((librados::AioCompletionImpl
*)c
)->wait_for_safe_and_cb();
4537 tracepoint(librados
, rados_aio_wait_for_safe_and_cb_exit
, retval
);
4541 extern "C" int rados_aio_is_complete_and_cb(rados_completion_t c
)
4543 tracepoint(librados
, rados_aio_is_complete_and_cb_enter
, c
);
4544 int retval
= ((librados::AioCompletionImpl
*)c
)->is_complete_and_cb();
4545 tracepoint(librados
, rados_aio_is_complete_and_cb_exit
, retval
);
4549 extern "C" int rados_aio_is_safe_and_cb(rados_completion_t c
)
4551 tracepoint(librados
, rados_aio_is_safe_and_cb_enter
, c
);
4552 int retval
= ((librados::AioCompletionImpl
*)c
)->is_safe_and_cb();
4553 tracepoint(librados
, rados_aio_is_safe_and_cb_exit
, retval
);
4557 extern "C" int rados_aio_get_return_value(rados_completion_t c
)
4559 tracepoint(librados
, rados_aio_get_return_value_enter
, c
);
4560 int retval
= ((librados::AioCompletionImpl
*)c
)->get_return_value();
4561 tracepoint(librados
, rados_aio_get_return_value_exit
, retval
);
4565 extern "C" uint64_t rados_aio_get_version(rados_completion_t c
)
4567 tracepoint(librados
, rados_aio_get_version_enter
, c
);
4568 uint64_t retval
= ((librados::AioCompletionImpl
*)c
)->get_version();
4569 tracepoint(librados
, rados_aio_get_version_exit
, retval
);
4573 extern "C" void rados_aio_release(rados_completion_t c
)
4575 tracepoint(librados
, rados_aio_release_enter
, c
);
4576 ((librados::AioCompletionImpl
*)c
)->put();
4577 tracepoint(librados
, rados_aio_release_exit
);
4580 extern "C" int rados_aio_read(rados_ioctx_t io
, const char *o
,
4581 rados_completion_t completion
,
4582 char *buf
, size_t len
, uint64_t off
)
4584 tracepoint(librados
, rados_aio_read_enter
, io
, o
, completion
, len
, off
);
4585 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4587 int retval
= ctx
->aio_read(oid
, (librados::AioCompletionImpl
*)completion
,
4588 buf
, len
, off
, ctx
->snap_seq
);
4589 tracepoint(librados
, rados_aio_read_exit
, retval
);
4594 extern "C" int rados_aio_read_traced(rados_ioctx_t io
, const char *o
,
4595 rados_completion_t completion
,
4596 char *buf
, size_t len
, uint64_t off
,
4597 struct blkin_trace_info
*info
)
4599 tracepoint(librados
, rados_aio_read_enter
, io
, o
, completion
, len
, off
);
4600 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4602 int retval
= ctx
->aio_read(oid
, (librados::AioCompletionImpl
*)completion
,
4603 buf
, len
, off
, ctx
->snap_seq
, info
);
4604 tracepoint(librados
, rados_aio_read_exit
, retval
);
4609 extern "C" int rados_aio_write(rados_ioctx_t io
, const char *o
,
4610 rados_completion_t completion
,
4611 const char *buf
, size_t len
, uint64_t off
)
4613 tracepoint(librados
, rados_aio_write_enter
, io
, o
, completion
, buf
, len
, off
);
4614 if (len
> UINT_MAX
/2)
4616 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4619 bl
.append(buf
, len
);
4620 int retval
= ctx
->aio_write(oid
, (librados::AioCompletionImpl
*)completion
,
4622 tracepoint(librados
, rados_aio_write_exit
, retval
);
4627 extern "C" int rados_aio_write_traced(rados_ioctx_t io
, const char *o
,
4628 rados_completion_t completion
,
4629 const char *buf
, size_t len
, uint64_t off
,
4630 struct blkin_trace_info
*info
)
4632 tracepoint(librados
, rados_aio_write_enter
, io
, o
, completion
, buf
, len
, off
);
4633 if (len
> UINT_MAX
/2)
4635 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4638 bl
.append(buf
, len
);
4639 int retval
= ctx
->aio_write(oid
, (librados::AioCompletionImpl
*)completion
,
4640 bl
, len
, off
, info
);
4641 tracepoint(librados
, rados_aio_write_exit
, retval
);
4646 extern "C" int rados_aio_append(rados_ioctx_t io
, const char *o
,
4647 rados_completion_t completion
,
4648 const char *buf
, size_t len
)
4650 tracepoint(librados
, rados_aio_append_enter
, io
, o
, completion
, buf
, len
);
4651 if (len
> UINT_MAX
/2)
4653 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4656 bl
.append(buf
, len
);
4657 int retval
= ctx
->aio_append(oid
, (librados::AioCompletionImpl
*)completion
,
4659 tracepoint(librados
, rados_aio_append_exit
, retval
);
4663 extern "C" int rados_aio_write_full(rados_ioctx_t io
, const char *o
,
4664 rados_completion_t completion
,
4665 const char *buf
, size_t len
)
4667 tracepoint(librados
, rados_aio_write_full_enter
, io
, o
, completion
, buf
, len
);
4668 if (len
> UINT_MAX
/2)
4670 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4673 bl
.append(buf
, len
);
4674 int retval
= ctx
->aio_write_full(oid
, (librados::AioCompletionImpl
*)completion
, bl
);
4675 tracepoint(librados
, rados_aio_write_full_exit
, retval
);
4679 extern "C" int rados_aio_writesame(rados_ioctx_t io
, const char *o
,
4680 rados_completion_t completion
,
4681 const char *buf
, size_t data_len
,
4682 size_t write_len
, uint64_t off
)
4684 tracepoint(librados
, rados_aio_writesame_enter
, io
, o
, completion
, buf
,
4685 data_len
, write_len
, off
);
4686 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4689 bl
.append(buf
, data_len
);
4690 int retval
= ctx
->aio_writesame(o
, (librados::AioCompletionImpl
*)completion
,
4691 bl
, write_len
, off
);
4692 tracepoint(librados
, rados_aio_writesame_exit
, retval
);
4696 extern "C" int rados_aio_remove(rados_ioctx_t io
, const char *o
,
4697 rados_completion_t completion
)
4699 tracepoint(librados
, rados_aio_remove_enter
, io
, o
, completion
);
4700 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4702 int retval
= ctx
->aio_remove(oid
, (librados::AioCompletionImpl
*)completion
);
4703 tracepoint(librados
, rados_aio_remove_exit
, retval
);
4707 extern "C" int rados_aio_flush_async(rados_ioctx_t io
,
4708 rados_completion_t completion
)
4710 tracepoint(librados
, rados_aio_flush_async_enter
, io
, completion
);
4711 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4712 ctx
->flush_aio_writes_async((librados::AioCompletionImpl
*)completion
);
4713 tracepoint(librados
, rados_aio_flush_async_exit
, 0);
4717 extern "C" int rados_aio_flush(rados_ioctx_t io
)
4719 tracepoint(librados
, rados_aio_flush_enter
, io
);
4720 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4721 ctx
->flush_aio_writes();
4722 tracepoint(librados
, rados_aio_flush_exit
, 0);
4726 struct AioGetxattrData
{
4727 AioGetxattrData(char* buf
, rados_completion_t c
, size_t l
) :
4728 user_buf(buf
), len(l
), user_completion((librados::AioCompletionImpl
*)c
) {}
4732 struct librados::C_AioCompleteAndSafe user_completion
;
4735 static void rados_aio_getxattr_complete(rados_completion_t c
, void *arg
) {
4736 AioGetxattrData
*cdata
= reinterpret_cast<AioGetxattrData
*>(arg
);
4737 int rc
= rados_aio_get_return_value(c
);
4739 if (cdata
->bl
.length() > cdata
->len
) {
4742 if (!cdata
->bl
.is_provided_buffer(cdata
->user_buf
))
4743 cdata
->bl
.copy(0, cdata
->bl
.length(), cdata
->user_buf
);
4744 rc
= cdata
->bl
.length();
4747 cdata
->user_completion
.finish(rc
);
4751 extern "C" int rados_aio_getxattr(rados_ioctx_t io
, const char *o
,
4752 rados_completion_t completion
,
4753 const char *name
, char *buf
, size_t len
)
4755 tracepoint(librados
, rados_aio_getxattr_enter
, io
, o
, completion
, name
, len
);
4756 // create data object to be passed to async callback
4757 AioGetxattrData
*cdata
= new AioGetxattrData(buf
, completion
, len
);
4759 tracepoint(librados
, rados_aio_getxattr_exit
, -ENOMEM
, NULL
, 0);
4762 cdata
->bl
.push_back(buffer::create_static(len
, buf
));
4763 // create completion callback
4764 librados::AioCompletionImpl
*c
= new librados::AioCompletionImpl
;
4765 c
->set_complete_callback(cdata
, rados_aio_getxattr_complete
);
4766 // call async getxattr of IoCtx
4767 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4769 int ret
= ctx
->aio_getxattr(oid
, c
, name
, cdata
->bl
);
4770 tracepoint(librados
, rados_aio_getxattr_exit
, ret
, buf
, ret
);
4775 struct AioGetxattrsData
{
4776 AioGetxattrsData(rados_completion_t c
, rados_xattrs_iter_t
*_iter
) :
4777 iter(_iter
), user_completion((librados::AioCompletionImpl
*)c
) {
4778 it
= new librados::RadosXattrsIter();
4780 ~AioGetxattrsData() {
4783 librados::RadosXattrsIter
*it
;
4784 rados_xattrs_iter_t
*iter
;
4785 struct librados::C_AioCompleteAndSafe user_completion
;
4789 static void rados_aio_getxattrs_complete(rados_completion_t c
, void *arg
) {
4790 AioGetxattrsData
*cdata
= reinterpret_cast<AioGetxattrsData
*>(arg
);
4791 int rc
= rados_aio_get_return_value(c
);
4793 cdata
->user_completion
.finish(rc
);
4795 cdata
->it
->i
= cdata
->it
->attrset
.begin();
4796 *cdata
->iter
= cdata
->it
;
4798 cdata
->user_completion
.finish(0);
4803 extern "C" int rados_aio_getxattrs(rados_ioctx_t io
, const char *oid
,
4804 rados_completion_t completion
,
4805 rados_xattrs_iter_t
*iter
)
4807 tracepoint(librados
, rados_aio_getxattrs_enter
, io
, oid
, completion
);
4808 // create data object to be passed to async callback
4809 AioGetxattrsData
*cdata
= new AioGetxattrsData(completion
, iter
);
4811 tracepoint(librados
, rados_getxattrs_exit
, -ENOMEM
, NULL
);
4814 // create completion callback
4815 librados::AioCompletionImpl
*c
= new librados::AioCompletionImpl
;
4816 c
->set_complete_callback(cdata
, rados_aio_getxattrs_complete
);
4817 // call async getxattrs of IoCtx
4818 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4820 int ret
= ctx
->aio_getxattrs(obj
, c
, cdata
->it
->attrset
);
4821 tracepoint(librados
, rados_aio_getxattrs_exit
, ret
, cdata
->it
);
4825 extern "C" int rados_aio_setxattr(rados_ioctx_t io
, const char *o
,
4826 rados_completion_t completion
,
4827 const char *name
, const char *buf
, size_t len
)
4829 tracepoint(librados
, rados_aio_setxattr_enter
, io
, o
, completion
, name
, buf
, len
);
4830 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4833 bl
.append(buf
, len
);
4834 int retval
= ctx
->aio_setxattr(oid
, (librados::AioCompletionImpl
*)completion
, name
, bl
);
4835 tracepoint(librados
, rados_aio_setxattr_exit
, retval
);
4839 extern "C" int rados_aio_rmxattr(rados_ioctx_t io
, const char *o
,
4840 rados_completion_t completion
,
4843 tracepoint(librados
, rados_aio_rmxattr_enter
, io
, o
, completion
, name
);
4844 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4846 int retval
= ctx
->aio_rmxattr(oid
, (librados::AioCompletionImpl
*)completion
, name
);
4847 tracepoint(librados
, rados_aio_rmxattr_exit
, retval
);
4851 extern "C" int rados_aio_stat(rados_ioctx_t io
, const char *o
,
4852 rados_completion_t completion
,
4853 uint64_t *psize
, time_t *pmtime
)
4855 tracepoint(librados
, rados_aio_stat_enter
, io
, o
, completion
);
4856 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4858 int retval
= ctx
->aio_stat(oid
, (librados::AioCompletionImpl
*)completion
,
4860 tracepoint(librados
, rados_aio_stat_exit
, retval
);
4864 extern "C" int rados_aio_cmpext(rados_ioctx_t io
, const char *o
,
4865 rados_completion_t completion
, const char *cmp_buf
,
4866 size_t cmp_len
, uint64_t off
)
4868 tracepoint(librados
, rados_aio_cmpext_enter
, io
, o
, completion
, cmp_buf
,
4870 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4872 int retval
= ctx
->aio_cmpext(oid
, (librados::AioCompletionImpl
*)completion
,
4873 cmp_buf
, cmp_len
, off
);
4874 tracepoint(librados
, rados_aio_cmpext_exit
, retval
);
4878 extern "C" int rados_aio_cancel(rados_ioctx_t io
, rados_completion_t completion
)
4880 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4881 return ctx
->aio_cancel((librados::AioCompletionImpl
*)completion
);
4884 extern "C" int rados_aio_exec(rados_ioctx_t io
, const char *o
,
4885 rados_completion_t completion
,
4886 const char *cls
, const char *method
,
4887 const char *inbuf
, size_t in_len
,
4888 char *buf
, size_t out_len
)
4890 tracepoint(librados
, rados_aio_exec_enter
, io
, o
, completion
);
4891 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4894 inbl
.append(inbuf
, in_len
);
4895 int retval
= ctx
->aio_exec(oid
, (librados::AioCompletionImpl
*)completion
,
4896 cls
, method
, inbl
, buf
, out_len
);
4897 tracepoint(librados
, rados_aio_exec_exit
, retval
);
4901 struct C_WatchCB
: public librados::WatchCtx
{
4902 rados_watchcb_t wcb
;
4904 C_WatchCB(rados_watchcb_t _wcb
, void *_arg
) : wcb(_wcb
), arg(_arg
) {}
4905 void notify(uint8_t opcode
, uint64_t ver
, bufferlist
& bl
) override
{
4906 wcb(opcode
, ver
, arg
);
4910 extern "C" int rados_watch(rados_ioctx_t io
, const char *o
, uint64_t ver
,
4912 rados_watchcb_t watchcb
, void *arg
)
4914 tracepoint(librados
, rados_watch_enter
, io
, o
, ver
, watchcb
, arg
);
4915 uint64_t *cookie
= handle
;
4916 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4918 C_WatchCB
*wc
= new C_WatchCB(watchcb
, arg
);
4919 int retval
= ctx
->watch(oid
, cookie
, wc
, NULL
, true);
4920 tracepoint(librados
, rados_watch_exit
, retval
, *handle
);
4924 struct C_WatchCB2
: public librados::WatchCtx2
{
4925 rados_watchcb2_t wcb
;
4926 rados_watcherrcb_t errcb
;
4928 C_WatchCB2(rados_watchcb2_t _wcb
,
4929 rados_watcherrcb_t _errcb
,
4930 void *_arg
) : wcb(_wcb
), errcb(_errcb
), arg(_arg
) {}
4931 void handle_notify(uint64_t notify_id
,
4933 uint64_t notifier_gid
,
4934 bufferlist
& bl
) override
{
4935 wcb(arg
, notify_id
, cookie
, notifier_gid
, bl
.c_str(), bl
.length());
4937 void handle_error(uint64_t cookie
, int err
) override
{
4939 errcb(arg
, cookie
, err
);
4943 extern "C" int rados_watch2(rados_ioctx_t io
, const char *o
, uint64_t *handle
,
4944 rados_watchcb2_t watchcb
,
4945 rados_watcherrcb_t watcherrcb
,
4947 return rados_watch3(io
, o
, handle
, watchcb
, watcherrcb
, 0, arg
);
4950 extern "C" int rados_watch3(rados_ioctx_t io
, const char *o
, uint64_t *handle
,
4951 rados_watchcb2_t watchcb
,
4952 rados_watcherrcb_t watcherrcb
,
4956 tracepoint(librados
, rados_watch3_enter
, io
, o
, handle
, watchcb
, timeout
, arg
);
4958 if (!watchcb
|| !o
|| !handle
) {
4961 uint64_t *cookie
= handle
;
4962 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4964 C_WatchCB2
*wc
= new C_WatchCB2(watchcb
, watcherrcb
, arg
);
4965 ret
= ctx
->watch(oid
, cookie
, NULL
, wc
, timeout
, true);
4967 tracepoint(librados
, rados_watch3_exit
, ret
, handle
? *handle
: 0);
4971 extern "C" int rados_aio_watch(rados_ioctx_t io
, const char *o
,
4972 rados_completion_t completion
,
4974 rados_watchcb2_t watchcb
,
4975 rados_watcherrcb_t watcherrcb
, void *arg
) {
4976 return rados_aio_watch2(io
, o
, completion
, handle
, watchcb
, watcherrcb
, 0, arg
);
4979 extern "C" int rados_aio_watch2(rados_ioctx_t io
, const char *o
,
4980 rados_completion_t completion
,
4982 rados_watchcb2_t watchcb
,
4983 rados_watcherrcb_t watcherrcb
,
4984 uint32_t timeout
, void *arg
)
4986 tracepoint(librados
, rados_aio_watch2_enter
, io
, o
, completion
, handle
, watchcb
, timeout
, arg
);
4988 if (!completion
|| !watchcb
|| !o
|| !handle
) {
4991 uint64_t *cookie
= handle
;
4992 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
4994 librados::AioCompletionImpl
*c
=
4995 reinterpret_cast<librados::AioCompletionImpl
*>(completion
);
4996 C_WatchCB2
*wc
= new C_WatchCB2(watchcb
, watcherrcb
, arg
);
4997 ret
= ctx
->aio_watch(oid
, c
, cookie
, NULL
, wc
, timeout
, true);
4999 tracepoint(librados
, rados_aio_watch2_exit
, ret
, handle
? *handle
: 0);
5004 extern "C" int rados_unwatch(rados_ioctx_t io
, const char *o
, uint64_t handle
)
5006 tracepoint(librados
, rados_unwatch_enter
, io
, o
, handle
);
5007 uint64_t cookie
= handle
;
5008 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
5009 int retval
= ctx
->unwatch(cookie
);
5010 tracepoint(librados
, rados_unwatch_exit
, retval
);
5014 extern "C" int rados_unwatch2(rados_ioctx_t io
, uint64_t handle
)
5016 tracepoint(librados
, rados_unwatch2_enter
, io
, handle
);
5017 uint64_t cookie
= handle
;
5018 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
5019 int retval
= ctx
->unwatch(cookie
);
5020 tracepoint(librados
, rados_unwatch2_exit
, retval
);
5024 extern "C" int rados_aio_unwatch(rados_ioctx_t io
, uint64_t handle
,
5025 rados_completion_t completion
)
5027 tracepoint(librados
, rados_aio_unwatch_enter
, io
, handle
, completion
);
5028 uint64_t cookie
= handle
;
5029 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
5030 librados::AioCompletionImpl
*c
=
5031 reinterpret_cast<librados::AioCompletionImpl
*>(completion
);
5032 int retval
= ctx
->aio_unwatch(cookie
, c
);
5033 tracepoint(librados
, rados_aio_unwatch_exit
, retval
);
5037 extern "C" int rados_watch_check(rados_ioctx_t io
, uint64_t handle
)
5039 tracepoint(librados
, rados_watch_check_enter
, io
, handle
);
5040 uint64_t cookie
= handle
;
5041 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
5042 int retval
= ctx
->watch_check(cookie
);
5043 tracepoint(librados
, rados_watch_check_exit
, retval
);
5047 extern "C" int rados_notify(rados_ioctx_t io
, const char *o
,
5048 uint64_t ver
, const char *buf
, int buf_len
)
5050 tracepoint(librados
, rados_notify_enter
, io
, o
, ver
, buf
, buf_len
);
5051 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
5055 bufferptr p
= buffer::create(buf_len
);
5056 memcpy(p
.c_str(), buf
, buf_len
);
5059 int retval
= ctx
->notify(oid
, bl
, 0, NULL
, NULL
, NULL
);
5060 tracepoint(librados
, rados_notify_exit
, retval
);
5064 extern "C" int rados_notify2(rados_ioctx_t io
, const char *o
,
5065 const char *buf
, int buf_len
,
5066 uint64_t timeout_ms
,
5067 char **reply_buffer
,
5068 size_t *reply_buffer_len
)
5070 tracepoint(librados
, rados_notify2_enter
, io
, o
, buf
, buf_len
, timeout_ms
);
5071 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
5075 bufferptr p
= buffer::create(buf_len
);
5076 memcpy(p
.c_str(), buf
, buf_len
);
5079 int ret
= ctx
->notify(oid
, bl
, timeout_ms
, NULL
, reply_buffer
, reply_buffer_len
);
5080 tracepoint(librados
, rados_notify2_exit
, ret
);
5084 extern "C" int rados_aio_notify(rados_ioctx_t io
, const char *o
,
5085 rados_completion_t completion
,
5086 const char *buf
, int buf_len
,
5087 uint64_t timeout_ms
, char **reply_buffer
,
5088 size_t *reply_buffer_len
)
5090 tracepoint(librados
, rados_aio_notify_enter
, io
, o
, completion
, buf
, buf_len
,
5092 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
5096 bl
.push_back(buffer::copy(buf
, buf_len
));
5098 librados::AioCompletionImpl
*c
=
5099 reinterpret_cast<librados::AioCompletionImpl
*>(completion
);
5100 int ret
= ctx
->aio_notify(oid
, c
, bl
, timeout_ms
, NULL
, reply_buffer
,
5102 tracepoint(librados
, rados_aio_notify_exit
, ret
);
5106 extern "C" int rados_notify_ack(rados_ioctx_t io
, const char *o
,
5107 uint64_t notify_id
, uint64_t handle
,
5108 const char *buf
, int buf_len
)
5110 tracepoint(librados
, rados_notify_ack_enter
, io
, o
, notify_id
, handle
, buf
, buf_len
);
5111 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
5115 bufferptr p
= buffer::create(buf_len
);
5116 memcpy(p
.c_str(), buf
, buf_len
);
5119 ctx
->notify_ack(oid
, notify_id
, handle
, bl
);
5120 tracepoint(librados
, rados_notify_ack_exit
, 0);
5124 extern "C" int rados_watch_flush(rados_t cluster
)
5126 tracepoint(librados
, rados_watch_flush_enter
, cluster
);
5127 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
5128 int retval
= client
->watch_flush();
5129 tracepoint(librados
, rados_watch_flush_exit
, retval
);
5133 extern "C" int rados_aio_watch_flush(rados_t cluster
, rados_completion_t completion
)
5135 tracepoint(librados
, rados_aio_watch_flush_enter
, cluster
, completion
);
5136 librados::RadosClient
*client
= (librados::RadosClient
*)cluster
;
5137 librados::AioCompletionImpl
*c
= (librados::AioCompletionImpl
*)completion
;
5138 int retval
= client
->async_watch_flush(c
);
5139 tracepoint(librados
, rados_aio_watch_flush_exit
, retval
);
5143 extern "C" int rados_set_alloc_hint(rados_ioctx_t io
, const char *o
,
5144 uint64_t expected_object_size
,
5145 uint64_t expected_write_size
)
5147 tracepoint(librados
, rados_set_alloc_hint_enter
, io
, o
, expected_object_size
, expected_write_size
);
5148 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
5150 int retval
= ctx
->set_alloc_hint(oid
, expected_object_size
,
5151 expected_write_size
, 0);
5152 tracepoint(librados
, rados_set_alloc_hint_exit
, retval
);
5156 extern "C" int rados_set_alloc_hint2(rados_ioctx_t io
, const char *o
,
5157 uint64_t expected_object_size
,
5158 uint64_t expected_write_size
,
5161 tracepoint(librados
, rados_set_alloc_hint2_enter
, io
, o
, expected_object_size
, expected_write_size
, flags
);
5162 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
5164 int retval
= ctx
->set_alloc_hint(oid
, expected_object_size
,
5165 expected_write_size
, flags
);
5166 tracepoint(librados
, rados_set_alloc_hint2_exit
, retval
);
5170 extern "C" int rados_lock_exclusive(rados_ioctx_t io
, const char * o
,
5171 const char * name
, const char * cookie
,
5172 const char * desc
, struct timeval
* duration
,
5175 tracepoint(librados
, rados_lock_exclusive_enter
, io
, o
, name
, cookie
, desc
, duration
, flags
);
5176 librados::IoCtx ctx
;
5177 librados::IoCtx::from_rados_ioctx_t(io
, ctx
);
5179 int retval
= ctx
.lock_exclusive(o
, name
, cookie
, desc
, duration
, flags
);
5180 tracepoint(librados
, rados_lock_exclusive_exit
, retval
);
5184 extern "C" int rados_lock_shared(rados_ioctx_t io
, const char * o
,
5185 const char * name
, const char * cookie
,
5186 const char * tag
, const char * desc
,
5187 struct timeval
* duration
, uint8_t flags
)
5189 tracepoint(librados
, rados_lock_shared_enter
, io
, o
, name
, cookie
, tag
, desc
, duration
, flags
);
5190 librados::IoCtx ctx
;
5191 librados::IoCtx::from_rados_ioctx_t(io
, ctx
);
5193 int retval
= ctx
.lock_shared(o
, name
, cookie
, tag
, desc
, duration
, flags
);
5194 tracepoint(librados
, rados_lock_shared_exit
, retval
);
5197 extern "C" int rados_unlock(rados_ioctx_t io
, const char *o
, const char *name
,
5200 tracepoint(librados
, rados_unlock_enter
, io
, o
, name
, cookie
);
5201 librados::IoCtx ctx
;
5202 librados::IoCtx::from_rados_ioctx_t(io
, ctx
);
5204 int retval
= ctx
.unlock(o
, name
, cookie
);
5205 tracepoint(librados
, rados_unlock_exit
, retval
);
5209 extern "C" int rados_aio_unlock(rados_ioctx_t io
, const char *o
, const char *name
,
5210 const char *cookie
, rados_completion_t completion
)
5212 tracepoint(librados
, rados_aio_unlock_enter
, io
, o
, name
, cookie
, completion
);
5213 librados::IoCtx ctx
;
5214 librados::IoCtx::from_rados_ioctx_t(io
, ctx
);
5215 librados::AioCompletionImpl
*comp
= (librados::AioCompletionImpl
*)completion
;
5216 librados::AioCompletion
c(comp
);
5217 int retval
= ctx
.aio_unlock(o
, name
, cookie
, &c
);
5218 tracepoint(librados
, rados_aio_unlock_exit
, retval
);
5222 extern "C" ssize_t
rados_list_lockers(rados_ioctx_t io
, const char *o
,
5223 const char *name
, int *exclusive
,
5224 char *tag
, size_t *tag_len
,
5225 char *clients
, size_t *clients_len
,
5226 char *cookies
, size_t *cookies_len
,
5227 char *addrs
, size_t *addrs_len
)
5229 tracepoint(librados
, rados_list_lockers_enter
, io
, o
, name
, *tag_len
, *clients_len
, *cookies_len
, *addrs_len
);
5230 librados::IoCtx ctx
;
5231 librados::IoCtx::from_rados_ioctx_t(io
, ctx
);
5232 std::string name_str
= name
;
5233 std::string oid
= o
;
5234 std::string tag_str
;
5236 std::list
<librados::locker_t
> lockers
;
5237 int r
= ctx
.list_lockers(oid
, name_str
, &tmp_exclusive
, &tag_str
, &lockers
);
5239 tracepoint(librados
, rados_list_lockers_exit
, r
, *exclusive
, "", *tag_len
, *clients_len
, *cookies_len
, *addrs_len
);
5243 size_t clients_total
= 0;
5244 size_t cookies_total
= 0;
5245 size_t addrs_total
= 0;
5246 list
<librados::locker_t
>::const_iterator it
;
5247 for (it
= lockers
.begin(); it
!= lockers
.end(); ++it
) {
5248 clients_total
+= it
->client
.length() + 1;
5249 cookies_total
+= it
->cookie
.length() + 1;
5250 addrs_total
+= it
->address
.length() + 1;
5253 bool too_short
= ((clients_total
> *clients_len
) ||
5254 (cookies_total
> *cookies_len
) ||
5255 (addrs_total
> *addrs_len
) ||
5256 (tag_str
.length() + 1 > *tag_len
));
5257 *clients_len
= clients_total
;
5258 *cookies_len
= cookies_total
;
5259 *addrs_len
= addrs_total
;
5260 *tag_len
= tag_str
.length() + 1;
5262 tracepoint(librados
, rados_list_lockers_exit
, -ERANGE
, *exclusive
, "", *tag_len
, *clients_len
, *cookies_len
, *addrs_len
);
5266 strcpy(tag
, tag_str
.c_str());
5267 char *clients_p
= clients
;
5268 char *cookies_p
= cookies
;
5269 char *addrs_p
= addrs
;
5270 for (it
= lockers
.begin(); it
!= lockers
.end(); ++it
) {
5271 strcpy(clients_p
, it
->client
.c_str());
5272 strcpy(cookies_p
, it
->cookie
.c_str());
5273 strcpy(addrs_p
, it
->address
.c_str());
5274 tracepoint(librados
, rados_list_lockers_locker
, clients_p
, cookies_p
, addrs_p
);
5275 clients_p
+= it
->client
.length() + 1;
5276 cookies_p
+= it
->cookie
.length() + 1;
5277 addrs_p
+= it
->address
.length() + 1;
5284 int retval
= lockers
.size();
5285 tracepoint(librados
, rados_list_lockers_exit
, retval
, *exclusive
, tag
, *tag_len
, *clients_len
, *cookies_len
, *addrs_len
);
5289 extern "C" int rados_break_lock(rados_ioctx_t io
, const char *o
,
5290 const char *name
, const char *client
,
5293 tracepoint(librados
, rados_break_lock_enter
, io
, o
, name
, client
, cookie
);
5294 librados::IoCtx ctx
;
5295 librados::IoCtx::from_rados_ioctx_t(io
, ctx
);
5297 int retval
= ctx
.break_lock(o
, name
, client
, cookie
);
5298 tracepoint(librados
, rados_break_lock_exit
, retval
);
5302 extern "C" rados_write_op_t
rados_create_write_op()
5304 tracepoint(librados
, rados_create_write_op_enter
);
5305 rados_write_op_t retval
= new (std::nothrow
)::ObjectOperation
;
5306 tracepoint(librados
, rados_create_write_op_exit
, retval
);
5310 extern "C" void rados_release_write_op(rados_write_op_t write_op
)
5312 tracepoint(librados
, rados_release_write_op_enter
, write_op
);
5313 delete (::ObjectOperation
*)write_op
;
5314 tracepoint(librados
, rados_release_write_op_exit
);
5317 extern "C" void rados_write_op_set_flags(rados_write_op_t write_op
, int flags
)
5319 tracepoint(librados
, rados_write_op_set_flags_enter
, write_op
, flags
);
5320 set_op_flags((::ObjectOperation
*)write_op
, flags
);
5321 tracepoint(librados
, rados_write_op_set_flags_exit
);
5324 extern "C" void rados_write_op_assert_version(rados_write_op_t write_op
, uint64_t ver
)
5326 tracepoint(librados
, rados_write_op_assert_version_enter
, write_op
, ver
);
5327 ((::ObjectOperation
*)write_op
)->assert_version(ver
);
5328 tracepoint(librados
, rados_write_op_assert_version_exit
);
5331 extern "C" void rados_write_op_assert_exists(rados_write_op_t write_op
)
5333 tracepoint(librados
, rados_write_op_assert_exists_enter
, write_op
);
5334 ((::ObjectOperation
*)write_op
)->stat(NULL
, (ceph::real_time
*)NULL
, NULL
);
5335 tracepoint(librados
, rados_write_op_assert_exists_exit
);
5338 extern "C" void rados_write_op_cmpext(rados_write_op_t write_op
,
5339 const char *cmp_buf
,
5344 tracepoint(librados
, rados_write_op_cmpext_enter
, write_op
, cmp_buf
,
5345 cmp_len
, off
, prval
);
5346 ((::ObjectOperation
*)write_op
)->cmpext(off
, cmp_len
, cmp_buf
, prval
);
5347 tracepoint(librados
, rados_write_op_cmpext_exit
);
5350 extern "C" void rados_write_op_cmpxattr(rados_write_op_t write_op
,
5352 uint8_t comparison_operator
,
5356 tracepoint(librados
, rados_write_op_cmpxattr_enter
, write_op
, name
, comparison_operator
, value
, value_len
);
5358 bl
.append(value
, value_len
);
5359 ((::ObjectOperation
*)write_op
)->cmpxattr(name
,
5360 comparison_operator
,
5361 CEPH_OSD_CMPXATTR_MODE_STRING
,
5363 tracepoint(librados
, rados_write_op_cmpxattr_exit
);
5366 static void rados_c_omap_cmp(ObjectOperation
*op
,
5368 uint8_t comparison_operator
,
5374 bl
.append(val
, val_len
);
5375 std::map
<std::string
, pair
<bufferlist
, int> > assertions
;
5376 assertions
[key
] = std::make_pair(bl
, comparison_operator
);
5377 op
->omap_cmp(assertions
, prval
);
5380 extern "C" void rados_write_op_omap_cmp(rados_write_op_t write_op
,
5382 uint8_t comparison_operator
,
5387 tracepoint(librados
, rados_write_op_omap_cmp_enter
, write_op
, key
, comparison_operator
, val
, val_len
, prval
);
5388 rados_c_omap_cmp((::ObjectOperation
*)write_op
, key
, comparison_operator
,
5389 val
, val_len
, prval
);
5390 tracepoint(librados
, rados_write_op_omap_cmp_exit
);
5393 extern "C" void rados_write_op_setxattr(rados_write_op_t write_op
,
5398 tracepoint(librados
, rados_write_op_setxattr_enter
, write_op
, name
, value
, value_len
);
5400 bl
.append(value
, value_len
);
5401 ((::ObjectOperation
*)write_op
)->setxattr(name
, bl
);
5402 tracepoint(librados
, rados_write_op_setxattr_exit
);
5405 extern "C" void rados_write_op_rmxattr(rados_write_op_t write_op
,
5408 tracepoint(librados
, rados_write_op_rmxattr_enter
, write_op
, name
);
5409 ((::ObjectOperation
*)write_op
)->rmxattr(name
);
5410 tracepoint(librados
, rados_write_op_rmxattr_exit
);
5413 extern "C" void rados_write_op_create(rados_write_op_t write_op
,
5415 const char* category
) // unused
5417 tracepoint(librados
, rados_write_op_create_enter
, write_op
, exclusive
);
5418 ::ObjectOperation
*oo
= (::ObjectOperation
*) write_op
;
5419 oo
->create(!!exclusive
);
5420 tracepoint(librados
, rados_write_op_create_exit
);
5423 extern "C" void rados_write_op_write(rados_write_op_t write_op
,
5428 tracepoint(librados
, rados_write_op_write_enter
, write_op
, buffer
, len
, offset
);
5430 bl
.append(buffer
,len
);
5431 ((::ObjectOperation
*)write_op
)->write(offset
, bl
);
5432 tracepoint(librados
, rados_write_op_write_exit
);
5435 extern "C" void rados_write_op_write_full(rados_write_op_t write_op
,
5439 tracepoint(librados
, rados_write_op_write_full_enter
, write_op
, buffer
, len
);
5441 bl
.append(buffer
,len
);
5442 ((::ObjectOperation
*)write_op
)->write_full(bl
);
5443 tracepoint(librados
, rados_write_op_write_full_exit
);
5446 extern "C" void rados_write_op_writesame(rados_write_op_t write_op
,
5452 tracepoint(librados
, rados_write_op_writesame_enter
, write_op
, buffer
, data_len
, write_len
, offset
);
5454 bl
.append(buffer
, data_len
);
5455 ((::ObjectOperation
*)write_op
)->writesame(offset
, write_len
, bl
);
5456 tracepoint(librados
, rados_write_op_writesame_exit
);
5459 extern "C" void rados_write_op_append(rados_write_op_t write_op
,
5463 tracepoint(librados
, rados_write_op_append_enter
, write_op
, buffer
, len
);
5465 bl
.append(buffer
,len
);
5466 ((::ObjectOperation
*)write_op
)->append(bl
);
5467 tracepoint(librados
, rados_write_op_append_exit
);
5470 extern "C" void rados_write_op_remove(rados_write_op_t write_op
)
5472 tracepoint(librados
, rados_write_op_remove_enter
, write_op
);
5473 ((::ObjectOperation
*)write_op
)->remove();
5474 tracepoint(librados
, rados_write_op_remove_exit
);
5477 extern "C" void rados_write_op_truncate(rados_write_op_t write_op
,
5480 tracepoint(librados
, rados_write_op_truncate_enter
, write_op
, offset
);
5481 ((::ObjectOperation
*)write_op
)->truncate(offset
);
5482 tracepoint(librados
, rados_write_op_truncate_exit
);
5485 extern "C" void rados_write_op_zero(rados_write_op_t write_op
,
5489 tracepoint(librados
, rados_write_op_zero_enter
, write_op
, offset
, len
);
5490 ((::ObjectOperation
*)write_op
)->zero(offset
, len
);
5491 tracepoint(librados
, rados_write_op_zero_exit
);
5494 extern "C" void rados_write_op_exec(rados_write_op_t write_op
,
5501 tracepoint(librados
, rados_write_op_exec_enter
, write_op
, cls
, method
, in_buf
, in_len
, prval
);
5503 inbl
.append(in_buf
, in_len
);
5504 ((::ObjectOperation
*)write_op
)->call(cls
, method
, inbl
, NULL
, NULL
, prval
);
5505 tracepoint(librados
, rados_write_op_exec_exit
);
5508 extern "C" void rados_write_op_omap_set(rados_write_op_t write_op
,
5509 char const* const* keys
,
5510 char const* const* vals
,
5514 tracepoint(librados
, rados_write_op_omap_set_enter
, write_op
, num
);
5515 std::map
<std::string
, bufferlist
> entries
;
5516 for (size_t i
= 0; i
< num
; ++i
) {
5517 tracepoint(librados
, rados_write_op_omap_set_entry
, keys
[i
], vals
[i
], lens
[i
]);
5518 bufferlist
bl(lens
[i
]);
5519 bl
.append(vals
[i
], lens
[i
]);
5520 entries
[keys
[i
]] = bl
;
5522 ((::ObjectOperation
*)write_op
)->omap_set(entries
);
5523 tracepoint(librados
, rados_write_op_omap_set_exit
);
5526 extern "C" void rados_write_op_omap_rm_keys(rados_write_op_t write_op
,
5527 char const* const* keys
,
5530 tracepoint(librados
, rados_write_op_omap_rm_keys_enter
, write_op
, keys_len
);
5531 for(size_t i
= 0; i
< keys_len
; i
++) {
5532 tracepoint(librados
, rados_write_op_omap_rm_keys_entry
, keys
[i
]);
5534 std::set
<std::string
> to_remove(keys
, keys
+ keys_len
);
5535 ((::ObjectOperation
*)write_op
)->omap_rm_keys(to_remove
);
5536 tracepoint(librados
, rados_write_op_omap_rm_keys_exit
);
5539 extern "C" void rados_write_op_omap_clear(rados_write_op_t write_op
)
5541 tracepoint(librados
, rados_write_op_omap_clear_enter
, write_op
);
5542 ((::ObjectOperation
*)write_op
)->omap_clear();
5543 tracepoint(librados
, rados_write_op_omap_clear_exit
);
5546 extern "C" void rados_write_op_set_alloc_hint(rados_write_op_t write_op
,
5547 uint64_t expected_object_size
,
5548 uint64_t expected_write_size
)
5550 tracepoint(librados
, rados_write_op_set_alloc_hint_enter
, write_op
, expected_object_size
, expected_write_size
);
5551 ((::ObjectOperation
*)write_op
)->set_alloc_hint(expected_object_size
,
5552 expected_write_size
, 0);
5553 tracepoint(librados
, rados_write_op_set_alloc_hint_exit
);
5556 extern "C" void rados_write_op_set_alloc_hint2(rados_write_op_t write_op
,
5557 uint64_t expected_object_size
,
5558 uint64_t expected_write_size
,
5561 tracepoint(librados
, rados_write_op_set_alloc_hint2_enter
, write_op
, expected_object_size
, expected_write_size
, flags
);
5562 ((::ObjectOperation
*)write_op
)->set_alloc_hint(expected_object_size
,
5563 expected_write_size
,
5565 tracepoint(librados
, rados_write_op_set_alloc_hint2_exit
);
5568 extern "C" int rados_write_op_operate(rados_write_op_t write_op
,
5574 tracepoint(librados
, rados_write_op_operate_enter
, write_op
, io
, oid
, mtime
, flags
);
5576 ::ObjectOperation
*oo
= (::ObjectOperation
*) write_op
;
5577 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
5579 ceph::real_time
*prt
= NULL
;
5583 rt
= ceph::real_clock::from_time_t(*mtime
);
5587 int retval
= ctx
->operate(obj
, oo
, prt
, translate_flags(flags
));
5588 tracepoint(librados
, rados_write_op_operate_exit
, retval
);
5592 extern "C" int rados_write_op_operate2(rados_write_op_t write_op
,
5595 struct timespec
*ts
,
5598 tracepoint(librados
, rados_write_op_operate2_enter
, write_op
, io
, oid
, ts
, flags
);
5600 ::ObjectOperation
*oo
= (::ObjectOperation
*) write_op
;
5601 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
5603 ceph::real_time
*prt
= NULL
;
5607 rt
= ceph::real_clock::from_timespec(*ts
);
5611 int retval
= ctx
->operate(obj
, oo
, prt
, translate_flags(flags
));
5612 tracepoint(librados
, rados_write_op_operate_exit
, retval
);
5616 extern "C" int rados_aio_write_op_operate(rados_write_op_t write_op
,
5618 rados_completion_t completion
,
5623 tracepoint(librados
, rados_aio_write_op_operate_enter
, write_op
, io
, completion
, oid
, mtime
, flags
);
5625 ::ObjectOperation
*oo
= (::ObjectOperation
*) write_op
;
5626 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
5627 librados::AioCompletionImpl
*c
= (librados::AioCompletionImpl
*)completion
;
5628 int retval
= ctx
->aio_operate(obj
, oo
, c
, ctx
->snapc
, translate_flags(flags
));
5629 tracepoint(librados
, rados_aio_write_op_operate_exit
, retval
);
5633 extern "C" rados_read_op_t
rados_create_read_op()
5635 tracepoint(librados
, rados_create_read_op_enter
);
5636 rados_read_op_t retval
= new (std::nothrow
)::ObjectOperation
;
5637 tracepoint(librados
, rados_create_read_op_exit
, retval
);
5641 extern "C" void rados_release_read_op(rados_read_op_t read_op
)
5643 tracepoint(librados
, rados_release_read_op_enter
, read_op
);
5644 delete (::ObjectOperation
*)read_op
;
5645 tracepoint(librados
, rados_release_read_op_exit
);
5648 extern "C" void rados_read_op_set_flags(rados_read_op_t read_op
, int flags
)
5650 tracepoint(librados
, rados_read_op_set_flags_enter
, read_op
, flags
);
5651 set_op_flags((::ObjectOperation
*)read_op
, flags
);
5652 tracepoint(librados
, rados_read_op_set_flags_exit
);
5655 extern "C" void rados_read_op_assert_version(rados_read_op_t read_op
, uint64_t ver
)
5657 tracepoint(librados
, rados_read_op_assert_version_enter
, read_op
, ver
);
5658 ((::ObjectOperation
*)read_op
)->assert_version(ver
);
5659 tracepoint(librados
, rados_read_op_assert_version_exit
);
5662 extern "C" void rados_read_op_assert_exists(rados_read_op_t read_op
)
5664 tracepoint(librados
, rados_read_op_assert_exists_enter
, read_op
);
5665 ((::ObjectOperation
*)read_op
)->stat(NULL
, (ceph::real_time
*)NULL
, NULL
);
5666 tracepoint(librados
, rados_read_op_assert_exists_exit
);
5669 extern "C" void rados_read_op_cmpext(rados_read_op_t read_op
,
5670 const char *cmp_buf
,
5675 tracepoint(librados
, rados_read_op_cmpext_enter
, read_op
, cmp_buf
,
5676 cmp_len
, off
, prval
);
5677 ((::ObjectOperation
*)read_op
)->cmpext(off
, cmp_len
, cmp_buf
, prval
);
5678 tracepoint(librados
, rados_read_op_cmpext_exit
);
5681 extern "C" void rados_read_op_cmpxattr(rados_read_op_t read_op
,
5683 uint8_t comparison_operator
,
5687 tracepoint(librados
, rados_read_op_cmpxattr_enter
, read_op
, name
, comparison_operator
, value
, value_len
);
5689 bl
.append(value
, value_len
);
5690 ((::ObjectOperation
*)read_op
)->cmpxattr(name
,
5691 comparison_operator
,
5692 CEPH_OSD_CMPXATTR_MODE_STRING
,
5694 tracepoint(librados
, rados_read_op_cmpxattr_exit
);
5697 extern "C" void rados_read_op_omap_cmp(rados_read_op_t read_op
,
5699 uint8_t comparison_operator
,
5704 tracepoint(librados
, rados_read_op_omap_cmp_enter
, read_op
, key
, comparison_operator
, val
, val_len
, prval
);
5705 rados_c_omap_cmp((::ObjectOperation
*)read_op
, key
, comparison_operator
,
5706 val
, val_len
, prval
);
5707 tracepoint(librados
, rados_read_op_omap_cmp_exit
);
5710 extern "C" void rados_read_op_stat(rados_read_op_t read_op
,
5715 tracepoint(librados
, rados_read_op_stat_enter
, read_op
, psize
, pmtime
, prval
);
5716 ((::ObjectOperation
*)read_op
)->stat(psize
, pmtime
, prval
);
5717 tracepoint(librados
, rados_read_op_stat_exit
);
5720 class C_bl_to_buf
: public Context
{
5727 C_bl_to_buf(char *out_buf
,
5730 int *prval
) : out_buf(out_buf
), out_len(out_len
),
5731 bytes_read(bytes_read
), prval(prval
) {}
5732 void finish(int r
) override
{
5733 if (out_bl
.length() > out_len
) {
5741 *bytes_read
= out_bl
.length();
5742 if (out_buf
&& !out_bl
.is_provided_buffer(out_buf
))
5743 out_bl
.copy(0, out_bl
.length(), out_buf
);
5747 extern "C" void rados_read_op_read(rados_read_op_t read_op
,
5754 tracepoint(librados
, rados_read_op_read_enter
, read_op
, offset
, len
, buf
, bytes_read
, prval
);
5755 C_bl_to_buf
*ctx
= new C_bl_to_buf(buf
, len
, bytes_read
, prval
);
5756 ctx
->out_bl
.push_back(buffer::create_static(len
, buf
));
5757 ((::ObjectOperation
*)read_op
)->read(offset
, len
, &ctx
->out_bl
, prval
, ctx
);
5758 tracepoint(librados
, rados_read_op_read_exit
);
5761 extern "C" void rados_read_op_checksum(rados_read_op_t read_op
,
5762 rados_checksum_type_t type
,
5763 const char *init_value
,
5764 size_t init_value_len
,
5765 uint64_t offset
, size_t len
,
5766 size_t chunk_size
, char *pchecksum
,
5767 size_t checksum_len
, int *prval
)
5769 tracepoint(librados
, rados_read_op_checksum_enter
, read_op
, type
, init_value
,
5770 init_value_len
, offset
, len
, chunk_size
);
5771 bufferlist init_value_bl
;
5772 init_value_bl
.append(init_value
, init_value_len
);
5774 C_bl_to_buf
*ctx
= nullptr;
5775 if (pchecksum
!= nullptr) {
5776 ctx
= new C_bl_to_buf(pchecksum
, checksum_len
, nullptr, prval
);
5778 ((::ObjectOperation
*)read_op
)->checksum(get_checksum_op_type(type
),
5779 init_value_bl
, offset
, len
,
5781 (ctx
? &ctx
->out_bl
: nullptr),
5783 tracepoint(librados
, rados_read_op_checksum_exit
);
5786 class C_out_buffer
: public Context
{
5791 C_out_buffer(char **out_buf
, size_t *out_len
) : out_buf(out_buf
),
5793 void finish(int r
) override
{
5794 // ignore r since we don't know the meaning of return values
5795 // from custom class methods
5796 do_out_buffer(out_bl
, out_buf
, out_len
);
5800 extern "C" void rados_read_op_exec(rados_read_op_t read_op
,
5809 tracepoint(librados
, rados_read_op_exec_enter
, read_op
, cls
, method
, in_buf
, in_len
, out_buf
, out_len
, prval
);
5811 inbl
.append(in_buf
, in_len
);
5812 C_out_buffer
*ctx
= new C_out_buffer(out_buf
, out_len
);
5813 ((::ObjectOperation
*)read_op
)->call(cls
, method
, inbl
, &ctx
->out_bl
, ctx
,
5815 tracepoint(librados
, rados_read_op_exec_exit
);
5818 extern "C" void rados_read_op_exec_user_buf(rados_read_op_t read_op
,
5828 tracepoint(librados
, rados_read_op_exec_user_buf_enter
, read_op
, cls
, method
, in_buf
, in_len
, out_buf
, out_len
, used_len
, prval
);
5829 C_bl_to_buf
*ctx
= new C_bl_to_buf(out_buf
, out_len
, used_len
, prval
);
5831 inbl
.append(in_buf
, in_len
);
5832 ((::ObjectOperation
*)read_op
)->call(cls
, method
, inbl
, &ctx
->out_bl
, ctx
,
5834 tracepoint(librados
, rados_read_op_exec_user_buf_exit
);
5837 struct RadosOmapIter
{
5838 std::map
<std::string
, bufferlist
> values
;
5839 std::map
<std::string
, bufferlist
>::iterator i
;
5842 class C_OmapIter
: public Context
{
5843 RadosOmapIter
*iter
;
5845 explicit C_OmapIter(RadosOmapIter
*iter
) : iter(iter
) {}
5846 void finish(int r
) override
{
5847 iter
->i
= iter
->values
.begin();
5851 class C_XattrsIter
: public Context
{
5852 librados::RadosXattrsIter
*iter
;
5854 explicit C_XattrsIter(librados::RadosXattrsIter
*iter
) : iter(iter
) {}
5855 void finish(int r
) override
{
5856 iter
->i
= iter
->attrset
.begin();
5860 extern "C" void rados_read_op_getxattrs(rados_read_op_t read_op
,
5861 rados_xattrs_iter_t
*iter
,
5864 tracepoint(librados
, rados_read_op_getxattrs_enter
, read_op
, prval
);
5865 librados::RadosXattrsIter
*xattrs_iter
= new librados::RadosXattrsIter
;
5866 ((::ObjectOperation
*)read_op
)->getxattrs(&xattrs_iter
->attrset
, prval
);
5867 ((::ObjectOperation
*)read_op
)->add_handler(new C_XattrsIter(xattrs_iter
));
5868 *iter
= xattrs_iter
;
5869 tracepoint(librados
, rados_read_op_getxattrs_exit
, *iter
);
5872 extern "C" void rados_read_op_omap_get_vals(rados_read_op_t read_op
,
5873 const char *start_after
,
5874 const char *filter_prefix
,
5875 uint64_t max_return
,
5876 rados_omap_iter_t
*iter
,
5879 tracepoint(librados
, rados_read_op_omap_get_vals_enter
, read_op
, start_after
, filter_prefix
, max_return
, prval
);
5880 RadosOmapIter
*omap_iter
= new RadosOmapIter
;
5881 const char *start
= start_after
? start_after
: "";
5882 const char *filter
= filter_prefix
? filter_prefix
: "";
5883 ((::ObjectOperation
*)read_op
)->omap_get_vals(
5890 ((::ObjectOperation
*)read_op
)->add_handler(new C_OmapIter(omap_iter
));
5892 tracepoint(librados
, rados_read_op_omap_get_vals_exit
, *iter
);
5895 extern "C" void rados_read_op_omap_get_vals2(rados_read_op_t read_op
,
5896 const char *start_after
,
5897 const char *filter_prefix
,
5898 uint64_t max_return
,
5899 rados_omap_iter_t
*iter
,
5900 unsigned char *pmore
,
5903 tracepoint(librados
, rados_read_op_omap_get_vals_enter
, read_op
, start_after
, filter_prefix
, max_return
, prval
);
5904 RadosOmapIter
*omap_iter
= new RadosOmapIter
;
5905 const char *start
= start_after
? start_after
: "";
5906 const char *filter
= filter_prefix
? filter_prefix
: "";
5907 ((::ObjectOperation
*)read_op
)->omap_get_vals(
5914 ((::ObjectOperation
*)read_op
)->add_handler(new C_OmapIter(omap_iter
));
5916 tracepoint(librados
, rados_read_op_omap_get_vals_exit
, *iter
);
5919 struct C_OmapKeysIter
: public Context
{
5920 RadosOmapIter
*iter
;
5921 std::set
<std::string
> keys
;
5922 explicit C_OmapKeysIter(RadosOmapIter
*iter
) : iter(iter
) {}
5923 void finish(int r
) override
{
5924 // map each key to an empty bl
5925 for (std::set
<std::string
>::const_iterator i
= keys
.begin();
5926 i
!= keys
.end(); ++i
) {
5929 iter
->i
= iter
->values
.begin();
5933 extern "C" void rados_read_op_omap_get_keys(rados_read_op_t read_op
,
5934 const char *start_after
,
5935 uint64_t max_return
,
5936 rados_omap_iter_t
*iter
,
5939 tracepoint(librados
, rados_read_op_omap_get_keys_enter
, read_op
, start_after
, max_return
, prval
);
5940 RadosOmapIter
*omap_iter
= new RadosOmapIter
;
5941 C_OmapKeysIter
*ctx
= new C_OmapKeysIter(omap_iter
);
5942 ((::ObjectOperation
*)read_op
)->omap_get_keys(
5943 start_after
? start_after
: "",
5944 max_return
, &ctx
->keys
, nullptr, prval
);
5945 ((::ObjectOperation
*)read_op
)->add_handler(ctx
);
5947 tracepoint(librados
, rados_read_op_omap_get_keys_exit
, *iter
);
5950 extern "C" void rados_read_op_omap_get_keys2(rados_read_op_t read_op
,
5951 const char *start_after
,
5952 uint64_t max_return
,
5953 rados_omap_iter_t
*iter
,
5954 unsigned char *pmore
,
5957 tracepoint(librados
, rados_read_op_omap_get_keys_enter
, read_op
, start_after
, max_return
, prval
);
5958 RadosOmapIter
*omap_iter
= new RadosOmapIter
;
5959 C_OmapKeysIter
*ctx
= new C_OmapKeysIter(omap_iter
);
5960 ((::ObjectOperation
*)read_op
)->omap_get_keys(
5961 start_after
? start_after
: "",
5962 max_return
, &ctx
->keys
,
5963 (bool*)pmore
, prval
);
5964 ((::ObjectOperation
*)read_op
)->add_handler(ctx
);
5966 tracepoint(librados
, rados_read_op_omap_get_keys_exit
, *iter
);
5969 extern "C" void rados_read_op_omap_get_vals_by_keys(rados_read_op_t read_op
,
5970 char const* const* keys
,
5972 rados_omap_iter_t
*iter
,
5975 tracepoint(librados
, rados_read_op_omap_get_vals_by_keys_enter
, read_op
, keys
, keys_len
, iter
, prval
);
5976 std::set
<std::string
> to_get(keys
, keys
+ keys_len
);
5978 RadosOmapIter
*omap_iter
= new RadosOmapIter
;
5979 ((::ObjectOperation
*)read_op
)->omap_get_vals_by_keys(to_get
,
5982 ((::ObjectOperation
*)read_op
)->add_handler(new C_OmapIter(omap_iter
));
5984 tracepoint(librados
, rados_read_op_omap_get_vals_by_keys_exit
, *iter
);
5987 extern "C" int rados_omap_get_next(rados_omap_iter_t iter
,
5992 tracepoint(librados
, rados_omap_get_next_enter
, iter
);
5993 RadosOmapIter
*it
= static_cast<RadosOmapIter
*>(iter
);
5994 if (it
->i
== it
->values
.end()) {
5998 tracepoint(librados
, rados_omap_get_next_exit
, 0, key
, val
, len
);
6002 *key
= (char*)it
->i
->first
.c_str();
6004 *val
= it
->i
->second
.c_str();
6006 *len
= it
->i
->second
.length();
6008 tracepoint(librados
, rados_omap_get_next_exit
, 0, key
, val
, len
);
6012 extern "C" void rados_omap_get_end(rados_omap_iter_t iter
)
6014 tracepoint(librados
, rados_omap_get_end_enter
, iter
);
6015 RadosOmapIter
*it
= static_cast<RadosOmapIter
*>(iter
);
6017 tracepoint(librados
, rados_omap_get_end_exit
);
6020 extern "C" int rados_read_op_operate(rados_read_op_t read_op
,
6025 tracepoint(librados
, rados_read_op_operate_enter
, read_op
, io
, oid
, flags
);
6027 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
6028 int retval
= ctx
->operate_read(obj
, (::ObjectOperation
*)read_op
, NULL
,
6029 translate_flags(flags
));
6030 tracepoint(librados
, rados_read_op_operate_exit
, retval
);
6034 extern "C" int rados_aio_read_op_operate(rados_read_op_t read_op
,
6036 rados_completion_t completion
,
6040 tracepoint(librados
, rados_aio_read_op_operate_enter
, read_op
, io
, completion
, oid
, flags
);
6042 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
6043 librados::AioCompletionImpl
*c
= (librados::AioCompletionImpl
*)completion
;
6044 int retval
= ctx
->aio_operate_read(obj
, (::ObjectOperation
*)read_op
,
6045 c
, translate_flags(flags
), NULL
);
6046 tracepoint(librados
, rados_aio_read_op_operate_exit
, retval
);
6050 extern "C" int rados_cache_pin(rados_ioctx_t io
, const char *o
)
6052 tracepoint(librados
, rados_cache_pin_enter
, io
, o
);
6053 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
6055 int retval
= ctx
->cache_pin(oid
);
6056 tracepoint(librados
, rados_cache_pin_exit
, retval
);
6060 extern "C" int rados_cache_unpin(rados_ioctx_t io
, const char *o
)
6062 tracepoint(librados
, rados_cache_unpin_enter
, io
, o
);
6063 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
6065 int retval
= ctx
->cache_unpin(oid
);
6066 tracepoint(librados
, rados_cache_unpin_exit
, retval
);
6071 ///////////////////////////// ListObject //////////////////////////////
6072 librados::ListObject::ListObject() : impl(NULL
)
6076 librados::ListObject::ListObject(librados::ListObjectImpl
*i
): impl(i
)
6080 librados::ListObject::ListObject(const ListObject
& rhs
)
6082 if (rhs
.impl
== NULL
) {
6086 impl
= new ListObjectImpl();
6087 *impl
= *(rhs
.impl
);
6090 librados::ListObject
& librados::ListObject::operator=(const ListObject
& rhs
)
6092 if (rhs
.impl
== NULL
) {
6098 impl
= new ListObjectImpl();
6099 *impl
= *(rhs
.impl
);
6103 librados::ListObject::~ListObject()
6110 const std::string
& librados::ListObject::get_nspace() const
6112 return impl
->get_nspace();
6115 const std::string
& librados::ListObject::get_oid() const
6117 return impl
->get_oid();
6120 const std::string
& librados::ListObject::get_locator() const
6122 return impl
->get_locator();
6125 std::ostream
& librados::operator<<(std::ostream
& out
, const librados::ListObject
& lop
)
6131 CEPH_RADOS_API
void rados_object_list_slice(
6133 const rados_object_list_cursor start
,
6134 const rados_object_list_cursor finish
,
6137 rados_object_list_cursor
*split_start
,
6138 rados_object_list_cursor
*split_finish
)
6140 librados::IoCtxImpl
*ctx
= (librados::IoCtxImpl
*)io
;
6142 assert(split_start
);
6143 assert(split_finish
);
6144 hobject_t
*split_start_hobj
= (hobject_t
*)(*split_start
);
6145 hobject_t
*split_finish_hobj
= (hobject_t
*)(*split_finish
);
6146 assert(split_start_hobj
);
6147 assert(split_finish_hobj
);
6148 hobject_t
*start_hobj
= (hobject_t
*)(start
);
6149 hobject_t
*finish_hobj
= (hobject_t
*)(finish
);
6151 ctx
->object_list_slice(
6160 librados::ObjectCursor::ObjectCursor()
6162 c_cursor
= (rados_object_list_cursor
)new hobject_t();
6165 librados::ObjectCursor::~ObjectCursor()
6167 hobject_t
*h
= (hobject_t
*)c_cursor
;
6171 librados::ObjectCursor::ObjectCursor(rados_object_list_cursor c
)
6176 c_cursor
= (rados_object_list_cursor
)new hobject_t(*(hobject_t
*)c
);
6180 librados::ObjectCursor
& librados::ObjectCursor::operator=(const librados::ObjectCursor
& rhs
)
6182 if (rhs
.c_cursor
!= nullptr) {
6183 hobject_t
*h
= (hobject_t
*)rhs
.c_cursor
;
6184 c_cursor
= (rados_object_list_cursor
)(new hobject_t(*h
));
6191 bool librados::ObjectCursor::operator<(const librados::ObjectCursor
&rhs
) const
6193 const hobject_t lhs_hobj
= (c_cursor
== nullptr) ? hobject_t() : *((hobject_t
*)c_cursor
);
6194 const hobject_t rhs_hobj
= (rhs
.c_cursor
== nullptr) ? hobject_t() : *((hobject_t
*)(rhs
.c_cursor
));
6195 return lhs_hobj
< rhs_hobj
;
6198 bool librados::ObjectCursor::operator==(const librados::ObjectCursor
&rhs
) const
6200 const hobject_t lhs_hobj
= (c_cursor
== nullptr) ? hobject_t() : *((hobject_t
*)c_cursor
);
6201 const hobject_t rhs_hobj
= (rhs
.c_cursor
== nullptr) ? hobject_t() : *((hobject_t
*)(rhs
.c_cursor
));
6202 return cmp(lhs_hobj
, rhs_hobj
) == 0;
6204 librados::ObjectCursor::ObjectCursor(const librados::ObjectCursor
&rhs
)
6209 librados::ObjectCursor
librados::IoCtx::object_list_begin()
6211 hobject_t
*h
= new hobject_t(io_ctx_impl
->objecter
->enumerate_objects_begin());
6213 oc
.set((rados_object_list_cursor
)h
);
6218 librados::ObjectCursor
librados::IoCtx::object_list_end()
6220 hobject_t
*h
= new hobject_t(io_ctx_impl
->objecter
->enumerate_objects_end());
6221 librados::ObjectCursor oc
;
6222 oc
.set((rados_object_list_cursor
)h
);
6227 void librados::ObjectCursor::set(rados_object_list_cursor c
)
6229 delete (hobject_t
*)c_cursor
;
6233 string
librados::ObjectCursor::to_str() const
6236 ss
<< *(hobject_t
*)c_cursor
;
6240 bool librados::ObjectCursor::from_str(const string
& s
)
6243 *(hobject_t
*)c_cursor
= hobject_t();
6246 return ((hobject_t
*)c_cursor
)->parse(s
);
6249 CEPH_RADOS_API
std::ostream
& librados::operator<<(std::ostream
& os
, const librados::ObjectCursor
& oc
)
6252 os
<< *(hobject_t
*)oc
.c_cursor
;
6259 bool librados::IoCtx::object_list_is_end(const ObjectCursor
&oc
)
6261 hobject_t
*h
= (hobject_t
*)oc
.c_cursor
;
6265 int librados::IoCtx::object_list(const ObjectCursor
&start
,
6266 const ObjectCursor
&finish
,
6267 const size_t result_item_count
,
6268 const bufferlist
&filter
,
6269 std::vector
<ObjectItem
> *result
,
6272 assert(result
!= nullptr);
6273 assert(next
!= nullptr);
6277 hobject_t next_hash
;
6278 std::list
<librados::ListObjectImpl
> obj_result
;
6279 io_ctx_impl
->objecter
->enumerate_objects(
6280 io_ctx_impl
->poolid
,
6281 io_ctx_impl
->oloc
.nspace
,
6282 *((hobject_t
*)start
.c_cursor
),
6283 *((hobject_t
*)finish
.c_cursor
),
6290 int r
= cond
.wait();
6292 next
->set((rados_object_list_cursor
)(new hobject_t(hobject_t::get_max())));
6296 next
->set((rados_object_list_cursor
)(new hobject_t(next_hash
)));
6298 for (std::list
<librados::ListObjectImpl
>::iterator i
= obj_result
.begin();
6299 i
!= obj_result
.end(); ++i
) {
6302 oi
.nspace
= i
->nspace
;
6303 oi
.locator
= i
->locator
;
6304 result
->push_back(oi
);
6307 return obj_result
.size();
6310 void librados::IoCtx::object_list_slice(
6311 const ObjectCursor start
,
6312 const ObjectCursor finish
,
6315 ObjectCursor
*split_start
,
6316 ObjectCursor
*split_finish
)
6318 assert(split_start
!= nullptr);
6319 assert(split_finish
!= nullptr);
6321 io_ctx_impl
->object_list_slice(
6322 *((hobject_t
*)(start
.c_cursor
)),
6323 *((hobject_t
*)(finish
.c_cursor
)),
6326 (hobject_t
*)(split_start
->c_cursor
),
6327 (hobject_t
*)(split_finish
->c_cursor
));