1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2 // vim: ts=8 sw=2 smarttab
4 #include "cls/rbd/cls_rbd_client.h"
5 #include "cls/lock/cls_lock_client.h"
6 #include "include/buffer.h"
7 #include "include/encoding.h"
8 #include "include/rbd_types.h"
9 #include "include/rados/librados.hpp"
14 namespace cls_client
{
16 void get_immutable_metadata_start(librados::ObjectReadOperation
*op
) {
17 bufferlist bl
, empty_bl
;
18 snapid_t snap
= CEPH_NOSNAP
;
20 op
->exec("rbd", "get_size", bl
);
21 op
->exec("rbd", "get_object_prefix", empty_bl
);
24 int get_immutable_metadata_finish(bufferlist::iterator
*it
,
25 std::string
*object_prefix
,
30 ::decode(*order
, *it
);
33 ::decode(*object_prefix
, *it
);
34 } catch (const buffer::error
&err
) {
41 int get_immutable_metadata(librados::IoCtx
*ioctx
, const std::string
&oid
,
42 std::string
*object_prefix
, uint8_t *order
)
44 librados::ObjectReadOperation op
;
45 get_immutable_metadata_start(&op
);
48 int r
= ioctx
->operate(oid
, &op
, &out_bl
);
53 bufferlist::iterator it
= out_bl
.begin();
54 return get_immutable_metadata_finish(&it
, object_prefix
, order
);
57 void get_mutable_metadata_start(librados::ObjectReadOperation
*op
,
59 snapid_t snap
= CEPH_NOSNAP
;
61 ::encode(snap
, size_bl
);
62 op
->exec("rbd", "get_size", size_bl
);
64 bufferlist features_bl
;
65 ::encode(snap
, features_bl
);
66 ::encode(read_only
, features_bl
);
67 op
->exec("rbd", "get_features", features_bl
);
70 op
->exec("rbd", "get_snapcontext", empty_bl
);
73 ::encode(snap
, parent_bl
);
74 op
->exec("rbd", "get_parent", parent_bl
);
76 rados::cls::lock::get_lock_info_start(op
, RBD_LOCK_NAME
);
79 int get_mutable_metadata_finish(bufferlist::iterator
*it
,
80 uint64_t *size
, uint64_t *features
,
81 uint64_t *incompatible_features
,
82 std::map
<rados::cls::lock::locker_id_t
,
83 rados::cls::lock::locker_info_t
> *lockers
,
84 bool *exclusive_lock
, std::string
*lock_tag
,
85 ::SnapContext
*snapc
, ParentInfo
*parent
) {
88 assert(incompatible_features
);
90 assert(exclusive_lock
);
100 ::decode(*features
, *it
);
101 ::decode(*incompatible_features
, *it
);
103 ::decode(*snapc
, *it
);
105 ::decode(parent
->spec
.pool_id
, *it
);
106 ::decode(parent
->spec
.image_id
, *it
);
107 ::decode(parent
->spec
.snap_id
, *it
);
108 ::decode(parent
->overlap
, *it
);
111 ClsLockType lock_type
= LOCK_NONE
;
112 int r
= rados::cls::lock::get_lock_info_finish(it
, lockers
, &lock_type
,
114 if (r
== -EOPNOTSUPP
) {
118 *exclusive_lock
= (lock_type
== LOCK_EXCLUSIVE
);
120 } catch (const buffer::error
&err
) {
126 int get_mutable_metadata(librados::IoCtx
*ioctx
, const std::string
&oid
,
127 bool read_only
, uint64_t *size
, uint64_t *features
,
128 uint64_t *incompatible_features
,
129 map
<rados::cls::lock::locker_id_t
,
130 rados::cls::lock::locker_info_t
> *lockers
,
131 bool *exclusive_lock
,
133 ::SnapContext
*snapc
,
136 librados::ObjectReadOperation op
;
137 get_mutable_metadata_start(&op
, read_only
);
140 int r
= ioctx
->operate(oid
, &op
, &out_bl
);
145 bufferlist::iterator it
= out_bl
.begin();
146 return get_mutable_metadata_finish(&it
, size
, features
,
147 incompatible_features
, lockers
,
148 exclusive_lock
, lock_tag
, snapc
,
152 void create_image(librados::ObjectWriteOperation
*op
, uint64_t size
,
153 uint8_t order
, uint64_t features
,
154 const std::string
&object_prefix
, int64_t data_pool_id
)
159 ::encode(features
, bl
);
160 ::encode(object_prefix
, bl
);
161 ::encode(data_pool_id
, bl
);
163 op
->exec("rbd", "create", bl
);
166 int create_image(librados::IoCtx
*ioctx
, const std::string
&oid
,
167 uint64_t size
, uint8_t order
, uint64_t features
,
168 const std::string
&object_prefix
, int64_t data_pool_id
)
170 librados::ObjectWriteOperation op
;
171 create_image(&op
, size
, order
, features
, object_prefix
, data_pool_id
);
173 return ioctx
->operate(oid
, &op
);
176 int get_features(librados::IoCtx
*ioctx
, const std::string
&oid
,
177 snapid_t snap_id
, uint64_t *features
)
179 bufferlist inbl
, outbl
;
180 ::encode(snap_id
, inbl
);
182 int r
= ioctx
->exec(oid
, "rbd", "get_features", inbl
, outbl
);
187 bufferlist::iterator iter
= outbl
.begin();
188 ::decode(*features
, iter
);
189 } catch (const buffer::error
&err
) {
196 void set_features(librados::ObjectWriteOperation
*op
, uint64_t features
,
200 ::encode(features
, bl
);
203 op
->exec("rbd", "set_features", bl
);
206 int set_features(librados::IoCtx
*ioctx
, const std::string
&oid
,
207 uint64_t features
, uint64_t mask
)
209 librados::ObjectWriteOperation op
;
210 set_features(&op
, features
, mask
);
212 return ioctx
->operate(oid
, &op
);
215 int get_object_prefix(librados::IoCtx
*ioctx
, const std::string
&oid
,
216 std::string
*object_prefix
)
218 bufferlist inbl
, outbl
;
219 int r
= ioctx
->exec(oid
, "rbd", "get_object_prefix", inbl
, outbl
);
224 bufferlist::iterator iter
= outbl
.begin();
225 ::decode(*object_prefix
, iter
);
226 } catch (const buffer::error
&err
) {
233 void get_data_pool_start(librados::ObjectReadOperation
*op
) {
235 op
->exec("rbd", "get_data_pool", bl
);
238 int get_data_pool_finish(bufferlist::iterator
*it
, int64_t *data_pool_id
) {
240 ::decode(*data_pool_id
, *it
);
241 } catch (const buffer::error
&err
) {
247 int get_data_pool(librados::IoCtx
*ioctx
, const std::string
&oid
,
248 int64_t *data_pool_id
) {
249 librados::ObjectReadOperation op
;
250 get_data_pool_start(&op
);
253 int r
= ioctx
->operate(oid
, &op
, &out_bl
);
258 bufferlist::iterator it
= out_bl
.begin();
259 return get_data_pool_finish(&it
, data_pool_id
);
262 int get_size(librados::IoCtx
*ioctx
, const std::string
&oid
,
263 snapid_t snap_id
, uint64_t *size
, uint8_t *order
)
265 bufferlist inbl
, outbl
;
266 ::encode(snap_id
, inbl
);
268 int r
= ioctx
->exec(oid
, "rbd", "get_size", inbl
, outbl
);
273 bufferlist::iterator iter
= outbl
.begin();
274 ::decode(*order
, iter
);
275 ::decode(*size
, iter
);
276 } catch (const buffer::error
&err
) {
283 int set_size(librados::IoCtx
*ioctx
, const std::string
&oid
,
286 librados::ObjectWriteOperation op
;
288 return ioctx
->operate(oid
, &op
);
291 void set_size(librados::ObjectWriteOperation
*op
, uint64_t size
)
295 op
->exec("rbd", "set_size", bl
);
298 int get_parent(librados::IoCtx
*ioctx
, const std::string
&oid
,
299 snapid_t snap_id
, ParentSpec
*pspec
,
300 uint64_t *parent_overlap
)
302 bufferlist inbl
, outbl
;
303 ::encode(snap_id
, inbl
);
305 int r
= ioctx
->exec(oid
, "rbd", "get_parent", inbl
, outbl
);
310 bufferlist::iterator iter
= outbl
.begin();
311 ::decode(pspec
->pool_id
, iter
);
312 ::decode(pspec
->image_id
, iter
);
313 ::decode(pspec
->snap_id
, iter
);
314 ::decode(*parent_overlap
, iter
);
315 } catch (const buffer::error
&err
) {
322 int set_parent(librados::IoCtx
*ioctx
, const std::string
&oid
,
323 const ParentSpec
&pspec
, uint64_t parent_overlap
)
325 librados::ObjectWriteOperation op
;
326 set_parent(&op
, pspec
, parent_overlap
);
327 return ioctx
->operate(oid
, &op
);
330 void set_parent(librados::ObjectWriteOperation
*op
,
331 const ParentSpec
&pspec
, uint64_t parent_overlap
) {
333 ::encode(pspec
.pool_id
, in_bl
);
334 ::encode(pspec
.image_id
, in_bl
);
335 ::encode(pspec
.snap_id
, in_bl
);
336 ::encode(parent_overlap
, in_bl
);
338 op
->exec("rbd", "set_parent", in_bl
);
341 void get_flags_start(librados::ObjectReadOperation
*op
,
342 const std::vector
<snapid_t
> &snap_ids
) {
344 ::encode(static_cast<snapid_t
>(CEPH_NOSNAP
), in_bl
);
346 op
->exec("rbd", "get_flags", in_bl
);
347 for (size_t i
= 0; i
< snap_ids
.size(); ++i
) {
349 ::encode(snap_ids
[i
], snap_bl
);
350 op
->exec("rbd", "get_flags", snap_bl
);
355 int get_flags_finish(bufferlist::iterator
*it
, uint64_t *flags
,
356 const std::vector
<snapid_t
> &snap_ids
,
357 std::vector
<uint64_t> *snap_flags
) {
358 snap_flags
->resize(snap_ids
.size());
360 ::decode(*flags
, *it
);
361 for (size_t i
= 0; i
< snap_flags
->size(); ++i
) {
362 ::decode((*snap_flags
)[i
], *it
);
364 } catch (const buffer::error
&err
) {
370 int get_flags(librados::IoCtx
*ioctx
, const std::string
&oid
,
371 uint64_t *flags
, const std::vector
<snapid_t
> &snap_ids
,
372 vector
<uint64_t> *snap_flags
)
374 librados::ObjectReadOperation op
;
375 get_flags_start(&op
, snap_ids
);
378 int r
= ioctx
->operate(oid
, &op
, &out_bl
);
383 bufferlist::iterator it
= out_bl
.begin();
384 return get_flags_finish(&it
, flags
, snap_ids
, snap_flags
);
387 void set_flags(librados::ObjectWriteOperation
*op
, snapid_t snap_id
,
388 uint64_t flags
, uint64_t mask
)
391 ::encode(flags
, inbl
);
392 ::encode(mask
, inbl
);
393 ::encode(snap_id
, inbl
);
394 op
->exec("rbd", "set_flags", inbl
);
397 int remove_parent(librados::IoCtx
*ioctx
, const std::string
&oid
)
399 librados::ObjectWriteOperation op
;
401 return ioctx
->operate(oid
, &op
);
404 void remove_parent(librados::ObjectWriteOperation
*op
)
407 op
->exec("rbd", "remove_parent", inbl
);
410 int add_child(librados::IoCtx
*ioctx
, const std::string
&oid
,
411 const ParentSpec
&pspec
, const std::string
&c_imageid
)
413 librados::ObjectWriteOperation op
;
414 add_child(&op
, pspec
, c_imageid
);
415 return ioctx
->operate(oid
, &op
);
418 void add_child(librados::ObjectWriteOperation
*op
,
419 const ParentSpec pspec
, const std::string
&c_imageid
)
422 ::encode(pspec
.pool_id
, in
);
423 ::encode(pspec
.image_id
, in
);
424 ::encode(pspec
.snap_id
, in
);
425 ::encode(c_imageid
, in
);
427 op
->exec("rbd", "add_child", in
);
430 void remove_child(librados::ObjectWriteOperation
*op
,
431 const ParentSpec
&pspec
, const std::string
&c_imageid
)
434 ::encode(pspec
.pool_id
, in
);
435 ::encode(pspec
.image_id
, in
);
436 ::encode(pspec
.snap_id
, in
);
437 ::encode(c_imageid
, in
);
438 op
->exec("rbd", "remove_child", in
);
441 int remove_child(librados::IoCtx
*ioctx
, const std::string
&oid
,
442 const ParentSpec
&pspec
, const std::string
&c_imageid
)
444 librados::ObjectWriteOperation op
;
445 remove_child(&op
, pspec
, c_imageid
);
446 return ioctx
->operate(oid
, &op
);
449 void get_children_start(librados::ObjectReadOperation
*op
,
450 const ParentSpec
&pspec
) {
452 ::encode(pspec
.pool_id
, in_bl
);
453 ::encode(pspec
.image_id
, in_bl
);
454 ::encode(pspec
.snap_id
, in_bl
);
455 op
->exec("rbd", "get_children", in_bl
);
458 int get_children_finish(bufferlist::iterator
*it
,
459 std::set
<std::string
>* children
) {
461 ::decode(*children
, *it
);
462 } catch (const buffer::error
&err
) {
468 int get_children(librados::IoCtx
*ioctx
, const std::string
&oid
,
469 const ParentSpec
&pspec
, set
<string
>& children
)
471 librados::ObjectReadOperation op
;
472 get_children_start(&op
, pspec
);
475 int r
= ioctx
->operate(oid
, &op
, &out_bl
);
480 bufferlist::iterator it
= out_bl
.begin();
481 return get_children_finish(&it
, &children
);
484 void snapshot_add(librados::ObjectWriteOperation
*op
, snapid_t snap_id
,
485 const std::string
&snap_name
, const cls::rbd::SnapshotNamespace
&snap_namespace
)
488 ::encode(snap_name
, bl
);
489 ::encode(snap_id
, bl
);
490 ::encode(cls::rbd::SnapshotNamespaceOnDisk(snap_namespace
), bl
);
491 op
->exec("rbd", "snapshot_add", bl
);
494 void snapshot_remove(librados::ObjectWriteOperation
*op
, snapid_t snap_id
)
497 ::encode(snap_id
, bl
);
498 op
->exec("rbd", "snapshot_remove", bl
);
501 void snapshot_rename(librados::ObjectWriteOperation
*op
,
502 snapid_t src_snap_id
,
503 const std::string
&dst_name
)
506 ::encode(src_snap_id
, bl
);
507 ::encode(dst_name
, bl
);
508 op
->exec("rbd", "snapshot_rename", bl
);
511 int get_snapcontext(librados::IoCtx
*ioctx
, const std::string
&oid
,
512 ::SnapContext
*snapc
)
514 bufferlist inbl
, outbl
;
516 int r
= ioctx
->exec(oid
, "rbd", "get_snapcontext", inbl
, outbl
);
521 bufferlist::iterator iter
= outbl
.begin();
522 ::decode(*snapc
, iter
);
523 } catch (const buffer::error
&err
) {
527 if (!snapc
->is_valid())
533 void snapshot_list_start(librados::ObjectReadOperation
*op
,
534 const std::vector
<snapid_t
> &ids
) {
535 for (auto snap_id
: ids
) {
536 bufferlist bl1
, bl2
, bl3
, bl4
;
537 ::encode(snap_id
, bl1
);
538 op
->exec("rbd", "get_snapshot_name", bl1
);
539 ::encode(snap_id
, bl2
);
540 op
->exec("rbd", "get_size", bl2
);
541 ::encode(snap_id
, bl3
);
542 op
->exec("rbd", "get_parent", bl3
);
543 ::encode(snap_id
, bl4
);
544 op
->exec("rbd", "get_protection_status", bl4
);
548 int snapshot_list_finish(bufferlist::iterator
*it
,
549 const std::vector
<snapid_t
> &ids
,
550 std::vector
<string
> *names
,
551 std::vector
<uint64_t> *sizes
,
552 std::vector
<ParentInfo
> *parents
,
553 std::vector
<uint8_t> *protection_statuses
)
555 names
->resize(ids
.size());
556 sizes
->resize(ids
.size());
557 parents
->resize(ids
.size());
558 protection_statuses
->resize(ids
.size());
560 for (size_t i
= 0; i
< names
->size(); ++i
) {
563 ::decode((*names
)[i
], *it
);
565 ::decode(order
, *it
);
566 ::decode((*sizes
)[i
], *it
);
568 ::decode((*parents
)[i
].spec
.pool_id
, *it
);
569 ::decode((*parents
)[i
].spec
.image_id
, *it
);
570 ::decode((*parents
)[i
].spec
.snap_id
, *it
);
571 ::decode((*parents
)[i
].overlap
, *it
);
572 // get_protection_status
573 ::decode((*protection_statuses
)[i
], *it
);
575 } catch (const buffer::error
&err
) {
581 int snapshot_list(librados::IoCtx
*ioctx
, const std::string
&oid
,
582 const std::vector
<snapid_t
> &ids
,
583 std::vector
<string
> *names
,
584 std::vector
<uint64_t> *sizes
,
585 std::vector
<ParentInfo
> *parents
,
586 std::vector
<uint8_t> *protection_statuses
)
588 librados::ObjectReadOperation op
;
589 snapshot_list_start(&op
, ids
);
592 int r
= ioctx
->operate(oid
, &op
, &out_bl
);
597 bufferlist::iterator it
= out_bl
.begin();
598 return snapshot_list_finish(&it
, ids
, names
, sizes
, parents
,
599 protection_statuses
);
602 void snapshot_timestamp_list_start(librados::ObjectReadOperation
*op
,
603 const std::vector
<snapid_t
> &ids
)
605 for (auto snap_id
: ids
) {
607 ::encode(snap_id
, bl
);
608 op
->exec("rbd", "get_snapshot_timestamp", bl
);
612 int snapshot_timestamp_list_finish(bufferlist::iterator
*it
,
613 const std::vector
<snapid_t
> &ids
,
614 std::vector
<utime_t
> *timestamps
)
616 timestamps
->resize(ids
.size());
618 for (size_t i
= 0; i
< timestamps
->size(); ++i
) {
621 (*timestamps
)[i
] = t
;
623 } catch (const buffer::error
&err
) {
629 int snapshot_timestamp_list(librados::IoCtx
*ioctx
, const std::string
&oid
,
630 const std::vector
<snapid_t
> &ids
,
631 std::vector
<utime_t
> *timestamps
)
633 librados::ObjectReadOperation op
;
634 snapshot_timestamp_list_start(&op
, ids
);
637 int r
= ioctx
->operate(oid
, &op
, &out_bl
);
642 bufferlist::iterator it
= out_bl
.begin();
643 return snapshot_timestamp_list_finish(&it
, ids
, timestamps
);
646 void snapshot_namespace_list_start(librados::ObjectReadOperation
*op
,
647 const std::vector
<snapid_t
> &ids
)
649 for (auto snap_id
: ids
) {
651 ::encode(snap_id
, bl
);
652 op
->exec("rbd", "get_snapshot_namespace", bl
);
656 int snapshot_namespace_list_finish(bufferlist::iterator
*it
,
657 const std::vector
<snapid_t
> &ids
,
658 std::vector
<cls::rbd::SnapshotNamespace
> *namespaces
)
660 namespaces
->resize(ids
.size());
662 for (size_t i
= 0; i
< namespaces
->size(); ++i
) {
663 cls::rbd::SnapshotNamespaceOnDisk e
;
665 (*namespaces
)[i
] = e
.snapshot_namespace
;
667 } catch (const buffer::error
&err
) {
673 int snapshot_namespace_list(librados::IoCtx
*ioctx
, const std::string
&oid
,
674 const std::vector
<snapid_t
> &ids
,
675 std::vector
<cls::rbd::SnapshotNamespace
> *namespaces
)
677 librados::ObjectReadOperation op
;
678 snapshot_namespace_list_start(&op
, ids
);
681 int r
= ioctx
->operate(oid
, &op
, &out_bl
);
686 bufferlist::iterator it
= out_bl
.begin();
687 return snapshot_namespace_list_finish(&it
, ids
, namespaces
);
690 void old_snapshot_add(librados::ObjectWriteOperation
*op
,
691 snapid_t snap_id
, const std::string
&snap_name
)
694 ::encode(snap_name
, bl
);
695 ::encode(snap_id
, bl
);
696 op
->exec("rbd", "snap_add", bl
);
699 void old_snapshot_remove(librados::ObjectWriteOperation
*op
,
700 const std::string
&snap_name
)
703 ::encode(snap_name
, bl
);
704 op
->exec("rbd", "snap_remove", bl
);
707 void old_snapshot_rename(librados::ObjectWriteOperation
*op
,
708 snapid_t src_snap_id
, const std::string
&dst_name
)
711 ::encode(src_snap_id
, bl
);
712 ::encode(dst_name
, bl
);
713 op
->exec("rbd", "snap_rename", bl
);
716 void old_snapshot_list_start(librados::ObjectReadOperation
*op
) {
718 op
->exec("rbd", "snap_list", in_bl
);
721 int old_snapshot_list_finish(bufferlist::iterator
*it
,
722 std::vector
<string
> *names
,
723 std::vector
<uint64_t> *sizes
,
724 ::SnapContext
*snapc
) {
727 ::decode(snapc
->seq
, *it
);
728 ::decode(num_snaps
, *it
);
730 names
->resize(num_snaps
);
731 sizes
->resize(num_snaps
);
732 snapc
->snaps
.resize(num_snaps
);
733 for (uint32_t i
= 0; i
< num_snaps
; ++i
) {
734 ::decode(snapc
->snaps
[i
], *it
);
735 ::decode((*sizes
)[i
], *it
);
736 ::decode((*names
)[i
], *it
);
738 } catch (const buffer::error
&err
) {
744 int old_snapshot_list(librados::IoCtx
*ioctx
, const std::string
&oid
,
745 std::vector
<string
> *names
,
746 std::vector
<uint64_t> *sizes
,
747 ::SnapContext
*snapc
)
749 librados::ObjectReadOperation op
;
750 old_snapshot_list_start(&op
);
753 int r
= ioctx
->operate(oid
, &op
, &out_bl
);
758 bufferlist::iterator it
= out_bl
.begin();
759 return old_snapshot_list_finish(&it
, names
, sizes
, snapc
);
762 void get_all_features_start(librados::ObjectReadOperation
*op
) {
764 op
->exec("rbd", "get_all_features", in
);
767 int get_all_features_finish(bufferlist::iterator
*it
,
768 uint64_t *all_features
) {
770 ::decode(*all_features
, *it
);
771 } catch (const buffer::error
&err
) {
777 int get_all_features(librados::IoCtx
*ioctx
, const std::string
&oid
,
778 uint64_t *all_features
) {
779 librados::ObjectReadOperation op
;
780 get_all_features_start(&op
);
783 int r
= ioctx
->operate(oid
, &op
, &out_bl
);
788 bufferlist::iterator it
= out_bl
.begin();
789 return get_all_features_finish(&it
, all_features
);
792 int copyup(librados::IoCtx
*ioctx
, const std::string
&oid
,
795 return ioctx
->exec(oid
, "rbd", "copyup", data
, out
);
798 int get_protection_status(librados::IoCtx
*ioctx
, const std::string
&oid
,
799 snapid_t snap_id
, uint8_t *protection_status
)
802 ::encode(snap_id
.val
, in
);
804 int r
= ioctx
->exec(oid
, "rbd", "get_protection_status", in
, out
);
809 bufferlist::iterator iter
= out
.begin();
810 ::decode(*protection_status
, iter
);
811 } catch (const buffer::error
&err
) {
818 int set_protection_status(librados::IoCtx
*ioctx
, const std::string
&oid
,
819 snapid_t snap_id
, uint8_t protection_status
)
822 librados::ObjectWriteOperation op
;
823 set_protection_status(&op
, snap_id
, protection_status
);
824 return ioctx
->operate(oid
, &op
);
827 void set_protection_status(librados::ObjectWriteOperation
*op
,
828 snapid_t snap_id
, uint8_t protection_status
)
831 ::encode(snap_id
, in
);
832 ::encode(protection_status
, in
);
833 op
->exec("rbd", "set_protection_status", in
);
836 int snapshot_get_limit(librados::IoCtx
*ioctx
, const std::string
&oid
,
840 int r
= ioctx
->exec(oid
, "rbd", "snapshot_get_limit", in
, out
);
847 bufferlist::iterator iter
= out
.begin();
848 ::decode(*limit
, iter
);
849 } catch (const buffer::error
&err
) {
856 void snapshot_set_limit(librados::ObjectWriteOperation
*op
, uint64_t limit
)
860 op
->exec("rbd", "snapshot_set_limit", in
);
863 void get_stripe_unit_count_start(librados::ObjectReadOperation
*op
) {
865 op
->exec("rbd", "get_stripe_unit_count", empty_bl
);
868 int get_stripe_unit_count_finish(bufferlist::iterator
*it
,
869 uint64_t *stripe_unit
,
870 uint64_t *stripe_count
) {
872 assert(stripe_count
);
875 ::decode(*stripe_unit
, *it
);
876 ::decode(*stripe_count
, *it
);
877 } catch (const buffer::error
&err
) {
883 int get_stripe_unit_count(librados::IoCtx
*ioctx
, const std::string
&oid
,
884 uint64_t *stripe_unit
, uint64_t *stripe_count
)
886 librados::ObjectReadOperation op
;
887 get_stripe_unit_count_start(&op
);
890 int r
= ioctx
->operate(oid
, &op
, &out_bl
);
895 bufferlist::iterator it
= out_bl
.begin();
896 return get_stripe_unit_count_finish(&it
, stripe_unit
, stripe_count
);
899 void set_stripe_unit_count(librados::ObjectWriteOperation
*op
,
900 uint64_t stripe_unit
, uint64_t stripe_count
)
903 ::encode(stripe_unit
, bl
);
904 ::encode(stripe_count
, bl
);
906 op
->exec("rbd", "set_stripe_unit_count", bl
);
909 int set_stripe_unit_count(librados::IoCtx
*ioctx
, const std::string
&oid
,
910 uint64_t stripe_unit
, uint64_t stripe_count
)
912 librados::ObjectWriteOperation op
;
913 set_stripe_unit_count(&op
, stripe_unit
, stripe_count
);
915 return ioctx
->operate(oid
, &op
);
918 void get_create_timestamp_start(librados::ObjectReadOperation
*op
) {
920 op
->exec("rbd", "get_create_timestamp", empty_bl
);
923 int get_create_timestamp_finish(bufferlist::iterator
*it
,
924 utime_t
*timestamp
) {
928 ::decode(*timestamp
, *it
);
929 } catch (const buffer::error
&err
) {
935 int get_create_timestamp(librados::IoCtx
*ioctx
, const std::string
&oid
,
938 librados::ObjectReadOperation op
;
939 get_create_timestamp_start(&op
);
942 int r
= ioctx
->operate(oid
, &op
, &out_bl
);
947 bufferlist::iterator it
= out_bl
.begin();
948 return get_create_timestamp_finish(&it
, timestamp
);
951 /************************ rbd_id object methods ************************/
953 void get_id_start(librados::ObjectReadOperation
*op
) {
955 op
->exec("rbd", "get_id", empty_bl
);
958 int get_id_finish(bufferlist::iterator
*it
, std::string
*id
) {
961 } catch (const buffer::error
&err
) {
967 int get_id(librados::IoCtx
*ioctx
, const std::string
&oid
, std::string
*id
)
969 librados::ObjectReadOperation op
;
973 int r
= ioctx
->operate(oid
, &op
, &out_bl
);
978 bufferlist::iterator it
= out_bl
.begin();
979 return get_id_finish(&it
, id
);
982 void set_id(librados::ObjectWriteOperation
*op
, const std::string id
)
986 op
->exec("rbd", "set_id", bl
);
989 int set_id(librados::IoCtx
*ioctx
, const std::string
&oid
, std::string id
)
991 librados::ObjectWriteOperation op
;
994 return ioctx
->operate(oid
, &op
);
997 /******************** rbd_directory object methods ********************/
999 void dir_get_id_start(librados::ObjectReadOperation
*op
,
1000 const std::string
&image_name
) {
1002 ::encode(image_name
, bl
);
1004 op
->exec("rbd", "dir_get_id", bl
);
1007 int dir_get_id_finish(bufferlist::iterator
*iter
, std::string
*image_id
) {
1009 ::decode(*image_id
, *iter
);
1010 } catch (const buffer::error
&err
) {
1017 int dir_get_id(librados::IoCtx
*ioctx
, const std::string
&oid
,
1018 const std::string
&name
, std::string
*id
) {
1019 librados::ObjectReadOperation op
;
1020 dir_get_id_start(&op
, name
);
1023 int r
= ioctx
->operate(oid
, &op
, &out_bl
);
1028 bufferlist::iterator iter
= out_bl
.begin();
1029 return dir_get_id_finish(&iter
, id
);
1032 void dir_get_name_start(librados::ObjectReadOperation
*op
,
1033 const std::string
&id
) {
1035 ::encode(id
, in_bl
);
1036 op
->exec("rbd", "dir_get_name", in_bl
);
1039 int dir_get_name_finish(bufferlist::iterator
*it
, std::string
*name
) {
1041 ::decode(*name
, *it
);
1042 } catch (const buffer::error
&err
) {
1048 int dir_get_name(librados::IoCtx
*ioctx
, const std::string
&oid
,
1049 const std::string
&id
, std::string
*name
) {
1050 librados::ObjectReadOperation op
;
1051 dir_get_name_start(&op
, id
);
1054 int r
= ioctx
->operate(oid
, &op
, &out_bl
);
1059 bufferlist::iterator it
= out_bl
.begin();
1060 return dir_get_name_finish(&it
, name
);
1063 void dir_list_start(librados::ObjectReadOperation
*op
,
1064 const std::string
&start
, uint64_t max_return
)
1067 ::encode(start
, in_bl
);
1068 ::encode(max_return
, in_bl
);
1070 op
->exec("rbd", "dir_list", in_bl
);
1073 int dir_list_finish(bufferlist::iterator
*it
, map
<string
, string
> *images
)
1076 ::decode(*images
, *it
);
1077 } catch (const buffer::error
&err
) {
1083 int dir_list(librados::IoCtx
*ioctx
, const std::string
&oid
,
1084 const std::string
&start
, uint64_t max_return
,
1085 map
<string
, string
> *images
)
1087 librados::ObjectReadOperation op
;
1088 dir_list_start(&op
, start
, max_return
);
1091 int r
= ioctx
->operate(oid
, &op
, &out_bl
);
1096 bufferlist::iterator iter
= out_bl
.begin();
1097 return dir_list_finish(&iter
, images
);
1100 void dir_add_image(librados::ObjectWriteOperation
*op
,
1101 const std::string
&name
, const std::string
&id
)
1106 op
->exec("rbd", "dir_add_image", bl
);
1109 int dir_add_image(librados::IoCtx
*ioctx
, const std::string
&oid
,
1110 const std::string
&name
, const std::string
&id
)
1112 librados::ObjectWriteOperation op
;
1113 dir_add_image(&op
, name
, id
);
1115 return ioctx
->operate(oid
, &op
);
1118 int dir_remove_image(librados::IoCtx
*ioctx
, const std::string
&oid
,
1119 const std::string
&name
, const std::string
&id
)
1121 librados::ObjectWriteOperation op
;
1122 dir_remove_image(&op
, name
, id
);
1124 return ioctx
->operate(oid
, &op
);
1127 void dir_remove_image(librados::ObjectWriteOperation
*op
,
1128 const std::string
&name
, const std::string
&id
)
1134 op
->exec("rbd", "dir_remove_image", bl
);
1137 void dir_rename_image(librados::ObjectWriteOperation
*op
,
1138 const std::string
&src
, const std::string
&dest
,
1139 const std::string
&id
)
1145 op
->exec("rbd", "dir_rename_image", in
);
1148 void object_map_load_start(librados::ObjectReadOperation
*op
) {
1150 op
->exec("rbd", "object_map_load", in_bl
);
1153 int object_map_load_finish(bufferlist::iterator
*it
,
1154 ceph::BitVector
<2> *object_map
) {
1156 ::decode(*object_map
, *it
);
1157 } catch (const buffer::error
&err
) {
1163 int object_map_load(librados::IoCtx
*ioctx
, const std::string
&oid
,
1164 ceph::BitVector
<2> *object_map
)
1166 librados::ObjectReadOperation op
;
1167 object_map_load_start(&op
);
1170 int r
= ioctx
->operate(oid
, &op
, &out_bl
);
1175 bufferlist::iterator it
= out_bl
.begin();
1176 return object_map_load_finish(&it
, object_map
);
1179 void object_map_save(librados::ObjectWriteOperation
*rados_op
,
1180 const ceph::BitVector
<2> &object_map
)
1182 ceph::BitVector
<2> object_map_copy(object_map
);
1183 object_map_copy
.set_crc_enabled(false);
1186 ::encode(object_map_copy
, in
);
1187 rados_op
->exec("rbd", "object_map_save", in
);
1190 void object_map_resize(librados::ObjectWriteOperation
*rados_op
,
1191 uint64_t object_count
, uint8_t default_state
)
1194 ::encode(object_count
, in
);
1195 ::encode(default_state
, in
);
1196 rados_op
->exec("rbd", "object_map_resize", in
);
1199 void object_map_update(librados::ObjectWriteOperation
*rados_op
,
1200 uint64_t start_object_no
, uint64_t end_object_no
,
1201 uint8_t new_object_state
,
1202 const boost::optional
<uint8_t> ¤t_object_state
)
1205 ::encode(start_object_no
, in
);
1206 ::encode(end_object_no
, in
);
1207 ::encode(new_object_state
, in
);
1208 ::encode(current_object_state
, in
);
1209 rados_op
->exec("rbd", "object_map_update", in
);
1212 void object_map_snap_add(librados::ObjectWriteOperation
*rados_op
)
1215 rados_op
->exec("rbd", "object_map_snap_add", in
);
1218 void object_map_snap_remove(librados::ObjectWriteOperation
*rados_op
,
1219 const ceph::BitVector
<2> &object_map
)
1221 ceph::BitVector
<2> object_map_copy(object_map
);
1222 object_map_copy
.set_crc_enabled(false);
1225 ::encode(object_map_copy
, in
);
1226 rados_op
->exec("rbd", "object_map_snap_remove", in
);
1229 void metadata_set(librados::ObjectWriteOperation
*op
,
1230 const map
<string
, bufferlist
> &data
)
1235 op
->exec("rbd", "metadata_set", bl
);
1238 int metadata_set(librados::IoCtx
*ioctx
, const std::string
&oid
,
1239 const map
<string
, bufferlist
> &data
)
1241 librados::ObjectWriteOperation op
;
1242 metadata_set(&op
, data
);
1244 return ioctx
->operate(oid
, &op
);
1247 void metadata_remove(librados::ObjectWriteOperation
*op
,
1248 const std::string
&key
)
1253 op
->exec("rbd", "metadata_remove", bl
);
1256 int metadata_remove(librados::IoCtx
*ioctx
, const std::string
&oid
,
1257 const std::string
&key
)
1259 librados::ObjectWriteOperation op
;
1260 metadata_remove(&op
, key
);
1262 return ioctx
->operate(oid
, &op
);
1265 int metadata_list(librados::IoCtx
*ioctx
, const std::string
&oid
,
1266 const std::string
&start
, uint64_t max_return
,
1267 map
<string
, bufferlist
> *pairs
)
1269 librados::ObjectReadOperation op
;
1270 metadata_list_start(&op
, start
, max_return
);
1273 int r
= ioctx
->operate(oid
, &op
, &out_bl
);
1278 bufferlist::iterator it
= out_bl
.begin();
1279 return metadata_list_finish(&it
, pairs
);
1282 void metadata_list_start(librados::ObjectReadOperation
*op
,
1283 const std::string
&start
, uint64_t max_return
)
1286 ::encode(start
, in_bl
);
1287 ::encode(max_return
, in_bl
);
1288 op
->exec("rbd", "metadata_list", in_bl
);
1291 int metadata_list_finish(bufferlist::iterator
*it
,
1292 std::map
<std::string
, bufferlist
> *pairs
)
1296 ::decode(*pairs
, *it
);
1297 } catch (const buffer::error
&err
) {
1303 int metadata_get(librados::IoCtx
*ioctx
, const std::string
&oid
,
1304 const std::string
&key
, string
*s
)
1309 int r
= ioctx
->exec(oid
, "rbd", "metadata_get", in
, out
);
1313 bufferlist::iterator iter
= out
.begin();
1316 } catch (const buffer::error
&err
) {
1323 void mirror_uuid_get_start(librados::ObjectReadOperation
*op
) {
1325 op
->exec("rbd", "mirror_uuid_get", bl
);
1328 int mirror_uuid_get_finish(bufferlist::iterator
*it
,
1329 std::string
*uuid
) {
1331 ::decode(*uuid
, *it
);
1332 } catch (const buffer::error
&err
) {
1338 int mirror_uuid_get(librados::IoCtx
*ioctx
, std::string
*uuid
) {
1339 librados::ObjectReadOperation op
;
1340 mirror_uuid_get_start(&op
);
1343 int r
= ioctx
->operate(RBD_MIRRORING
, &op
, &out_bl
);
1348 bufferlist::iterator it
= out_bl
.begin();
1349 r
= mirror_uuid_get_finish(&it
, uuid
);
1356 int mirror_uuid_set(librados::IoCtx
*ioctx
, const std::string
&uuid
) {
1358 ::encode(uuid
, in_bl
);
1361 int r
= ioctx
->exec(RBD_MIRRORING
, "rbd", "mirror_uuid_set", in_bl
,
1369 void mirror_mode_get_start(librados::ObjectReadOperation
*op
) {
1371 op
->exec("rbd", "mirror_mode_get", bl
);
1374 int mirror_mode_get_finish(bufferlist::iterator
*it
,
1375 cls::rbd::MirrorMode
*mirror_mode
) {
1377 uint32_t mirror_mode_decode
;
1378 ::decode(mirror_mode_decode
, *it
);
1379 *mirror_mode
= static_cast<cls::rbd::MirrorMode
>(mirror_mode_decode
);
1380 } catch (const buffer::error
&err
) {
1387 int mirror_mode_get(librados::IoCtx
*ioctx
,
1388 cls::rbd::MirrorMode
*mirror_mode
) {
1389 librados::ObjectReadOperation op
;
1390 mirror_mode_get_start(&op
);
1393 int r
= ioctx
->operate(RBD_MIRRORING
, &op
, &out_bl
);
1395 *mirror_mode
= cls::rbd::MIRROR_MODE_DISABLED
;
1401 bufferlist::iterator it
= out_bl
.begin();
1402 r
= mirror_mode_get_finish(&it
, mirror_mode
);
1409 int mirror_mode_set(librados::IoCtx
*ioctx
,
1410 cls::rbd::MirrorMode mirror_mode
) {
1412 ::encode(static_cast<uint32_t>(mirror_mode
), in_bl
);
1415 int r
= ioctx
->exec(RBD_MIRRORING
, "rbd", "mirror_mode_set", in_bl
,
1423 int mirror_peer_list(librados::IoCtx
*ioctx
,
1424 std::vector
<cls::rbd::MirrorPeer
> *peers
) {
1427 int r
= ioctx
->exec(RBD_MIRRORING
, "rbd", "mirror_peer_list", in_bl
,
1435 bufferlist::iterator bl_it
= out_bl
.begin();
1436 ::decode(*peers
, bl_it
);
1437 } catch (const buffer::error
&err
) {
1443 int mirror_peer_add(librados::IoCtx
*ioctx
, const std::string
&uuid
,
1444 const std::string
&cluster_name
,
1445 const std::string
&client_name
, int64_t pool_id
) {
1446 cls::rbd::MirrorPeer
peer(uuid
, cluster_name
, client_name
, pool_id
);
1448 ::encode(peer
, in_bl
);
1451 int r
= ioctx
->exec(RBD_MIRRORING
, "rbd", "mirror_peer_add", in_bl
,
1459 int mirror_peer_remove(librados::IoCtx
*ioctx
,
1460 const std::string
&uuid
) {
1462 ::encode(uuid
, in_bl
);
1465 int r
= ioctx
->exec(RBD_MIRRORING
, "rbd", "mirror_peer_remove", in_bl
,
1473 int mirror_peer_set_client(librados::IoCtx
*ioctx
,
1474 const std::string
&uuid
,
1475 const std::string
&client_name
) {
1477 ::encode(uuid
, in_bl
);
1478 ::encode(client_name
, in_bl
);
1481 int r
= ioctx
->exec(RBD_MIRRORING
, "rbd", "mirror_peer_set_client",
1489 int mirror_peer_set_cluster(librados::IoCtx
*ioctx
,
1490 const std::string
&uuid
,
1491 const std::string
&cluster_name
) {
1493 ::encode(uuid
, in_bl
);
1494 ::encode(cluster_name
, in_bl
);
1497 int r
= ioctx
->exec(RBD_MIRRORING
, "rbd", "mirror_peer_set_cluster",
1505 void mirror_image_list_start(librados::ObjectReadOperation
*op
,
1506 const std::string
&start
, uint64_t max_return
)
1509 ::encode(start
, in_bl
);
1510 ::encode(max_return
, in_bl
);
1511 op
->exec("rbd", "mirror_image_list", in_bl
);
1514 int mirror_image_list_finish(bufferlist::iterator
*it
,
1515 std::map
<string
, string
> *mirror_image_ids
)
1518 ::decode(*mirror_image_ids
, *it
);
1519 } catch (const buffer::error
&err
) {
1525 int mirror_image_list(librados::IoCtx
*ioctx
,
1526 const std::string
&start
, uint64_t max_return
,
1527 std::map
<std::string
, std::string
> *mirror_image_ids
) {
1528 librados::ObjectReadOperation op
;
1529 mirror_image_list_start(&op
, start
, max_return
);
1532 int r
= ioctx
->operate(RBD_MIRRORING
, &op
, &out_bl
);
1537 bufferlist::iterator bl_it
= out_bl
.begin();
1538 return mirror_image_list_finish(&bl_it
, mirror_image_ids
);
1541 void mirror_image_get_image_id_start(librados::ObjectReadOperation
*op
,
1542 const std::string
&global_image_id
) {
1544 ::encode(global_image_id
, in_bl
);
1545 op
->exec( "rbd", "mirror_image_get_image_id", in_bl
);
1548 int mirror_image_get_image_id_finish(bufferlist::iterator
*it
,
1549 std::string
*image_id
) {
1551 ::decode(*image_id
, *it
);
1552 } catch (const buffer::error
&err
) {
1558 int mirror_image_get_image_id(librados::IoCtx
*ioctx
,
1559 const std::string
&global_image_id
,
1560 std::string
*image_id
) {
1561 librados::ObjectReadOperation op
;
1562 mirror_image_get_image_id_start(&op
, global_image_id
);
1565 int r
= ioctx
->operate(RBD_MIRRORING
, &op
, &out_bl
);
1570 bufferlist::iterator it
= out_bl
.begin();
1571 return mirror_image_get_image_id_finish(&it
, image_id
);
1574 int mirror_image_get(librados::IoCtx
*ioctx
, const std::string
&image_id
,
1575 cls::rbd::MirrorImage
*mirror_image
) {
1576 librados::ObjectReadOperation op
;
1577 mirror_image_get_start(&op
, image_id
);
1580 int r
= ioctx
->operate(RBD_MIRRORING
, &op
, &out_bl
);
1585 bufferlist::iterator iter
= out_bl
.begin();
1586 r
= mirror_image_get_finish(&iter
, mirror_image
);
1593 void mirror_image_get_start(librados::ObjectReadOperation
*op
,
1594 const std::string
&image_id
) {
1596 ::encode(image_id
, in_bl
);
1598 op
->exec("rbd", "mirror_image_get", in_bl
);
1601 int mirror_image_get_finish(bufferlist::iterator
*iter
,
1602 cls::rbd::MirrorImage
*mirror_image
) {
1604 ::decode(*mirror_image
, *iter
);
1605 } catch (const buffer::error
&err
) {
1611 void mirror_image_set(librados::ObjectWriteOperation
*op
,
1612 const std::string
&image_id
,
1613 const cls::rbd::MirrorImage
&mirror_image
) {
1615 ::encode(image_id
, bl
);
1616 ::encode(mirror_image
, bl
);
1618 op
->exec("rbd", "mirror_image_set", bl
);
1621 int mirror_image_set(librados::IoCtx
*ioctx
, const std::string
&image_id
,
1622 const cls::rbd::MirrorImage
&mirror_image
) {
1623 librados::ObjectWriteOperation op
;
1624 mirror_image_set(&op
, image_id
, mirror_image
);
1626 int r
= ioctx
->operate(RBD_MIRRORING
, &op
);
1633 void mirror_image_remove(librados::ObjectWriteOperation
*op
,
1634 const std::string
&image_id
) {
1636 ::encode(image_id
, bl
);
1638 op
->exec("rbd", "mirror_image_remove", bl
);
1641 int mirror_image_remove(librados::IoCtx
*ioctx
, const std::string
&image_id
) {
1642 librados::ObjectWriteOperation op
;
1643 mirror_image_remove(&op
, image_id
);
1645 int r
= ioctx
->operate(RBD_MIRRORING
, &op
);
1652 int mirror_image_status_set(librados::IoCtx
*ioctx
,
1653 const std::string
&global_image_id
,
1654 const cls::rbd::MirrorImageStatus
&status
) {
1655 librados::ObjectWriteOperation op
;
1656 mirror_image_status_set(&op
, global_image_id
, status
);
1657 return ioctx
->operate(RBD_MIRRORING
, &op
);
1660 void mirror_image_status_set(librados::ObjectWriteOperation
*op
,
1661 const std::string
&global_image_id
,
1662 const cls::rbd::MirrorImageStatus
&status
) {
1664 ::encode(global_image_id
, bl
);
1665 ::encode(status
, bl
);
1666 op
->exec("rbd", "mirror_image_status_set", bl
);
1669 int mirror_image_status_remove(librados::IoCtx
*ioctx
,
1670 const std::string
&global_image_id
) {
1671 librados::ObjectWriteOperation op
;
1672 mirror_image_status_remove(&op
, global_image_id
);
1673 return ioctx
->operate(RBD_MIRRORING
, &op
);
1676 void mirror_image_status_remove(librados::ObjectWriteOperation
*op
,
1677 const std::string
&global_image_id
) {
1679 ::encode(global_image_id
, bl
);
1680 op
->exec("rbd", "mirror_image_status_remove", bl
);
1683 int mirror_image_status_get(librados::IoCtx
*ioctx
,
1684 const std::string
&global_image_id
,
1685 cls::rbd::MirrorImageStatus
*status
) {
1686 librados::ObjectReadOperation op
;
1687 mirror_image_status_get_start(&op
, global_image_id
);
1690 int r
= ioctx
->operate(RBD_MIRRORING
, &op
, &out_bl
);
1695 bufferlist::iterator iter
= out_bl
.begin();
1696 r
= mirror_image_status_get_finish(&iter
, status
);
1703 void mirror_image_status_get_start(librados::ObjectReadOperation
*op
,
1704 const std::string
&global_image_id
) {
1706 ::encode(global_image_id
, bl
);
1707 op
->exec("rbd", "mirror_image_status_get", bl
);
1710 int mirror_image_status_get_finish(bufferlist::iterator
*iter
,
1711 cls::rbd::MirrorImageStatus
*status
) {
1713 ::decode(*status
, *iter
);
1714 } catch (const buffer::error
&err
) {
1720 int mirror_image_status_list(librados::IoCtx
*ioctx
,
1721 const std::string
&start
, uint64_t max_return
,
1722 std::map
<std::string
, cls::rbd::MirrorImage
> *images
,
1723 std::map
<std::string
, cls::rbd::MirrorImageStatus
> *statuses
) {
1724 librados::ObjectReadOperation op
;
1725 mirror_image_status_list_start(&op
, start
, max_return
);
1728 int r
= ioctx
->operate(RBD_MIRRORING
, &op
, &out_bl
);
1733 bufferlist::iterator iter
= out_bl
.begin();
1734 r
= mirror_image_status_list_finish(&iter
, images
, statuses
);
1741 void mirror_image_status_list_start(librados::ObjectReadOperation
*op
,
1742 const std::string
&start
,
1743 uint64_t max_return
) {
1745 ::encode(start
, bl
);
1746 ::encode(max_return
, bl
);
1747 op
->exec("rbd", "mirror_image_status_list", bl
);
1750 int mirror_image_status_list_finish(bufferlist::iterator
*iter
,
1751 std::map
<std::string
, cls::rbd::MirrorImage
> *images
,
1752 std::map
<std::string
, cls::rbd::MirrorImageStatus
> *statuses
) {
1756 ::decode(*images
, *iter
);
1757 ::decode(*statuses
, *iter
);
1758 } catch (const buffer::error
&err
) {
1764 int mirror_image_status_get_summary(librados::IoCtx
*ioctx
,
1765 std::map
<cls::rbd::MirrorImageStatusState
, int> *states
) {
1766 librados::ObjectReadOperation op
;
1767 mirror_image_status_get_summary_start(&op
);
1770 int r
= ioctx
->operate(RBD_MIRRORING
, &op
, &out_bl
);
1775 bufferlist::iterator iter
= out_bl
.begin();
1776 r
= mirror_image_status_get_summary_finish(&iter
, states
);
1783 void mirror_image_status_get_summary_start(
1784 librados::ObjectReadOperation
*op
) {
1786 op
->exec("rbd", "mirror_image_status_get_summary", bl
);
1789 int mirror_image_status_get_summary_finish(bufferlist::iterator
*iter
,
1790 std::map
<cls::rbd::MirrorImageStatusState
, int> *states
) {
1792 ::decode(*states
, *iter
);
1793 } catch (const buffer::error
&err
) {
1799 int mirror_image_status_remove_down(librados::IoCtx
*ioctx
) {
1800 librados::ObjectWriteOperation op
;
1801 mirror_image_status_remove_down(&op
);
1802 return ioctx
->operate(RBD_MIRRORING
, &op
);
1805 void mirror_image_status_remove_down(librados::ObjectWriteOperation
*op
) {
1807 op
->exec("rbd", "mirror_image_status_remove_down", bl
);
1810 void mirror_instances_list_start(librados::ObjectReadOperation
*op
) {
1812 op
->exec("rbd", "mirror_instances_list", bl
);
1815 int mirror_instances_list_finish(bufferlist::iterator
*iter
,
1816 std::vector
<std::string
> *instance_ids
) {
1817 instance_ids
->clear();
1819 ::decode(*instance_ids
, *iter
);
1820 } catch (const buffer::error
&err
) {
1826 int mirror_instances_list(librados::IoCtx
*ioctx
,
1827 std::vector
<std::string
> *instance_ids
) {
1828 librados::ObjectReadOperation op
;
1829 mirror_instances_list_start(&op
);
1832 int r
= ioctx
->operate(RBD_MIRROR_LEADER
, &op
, &out_bl
);
1837 bufferlist::iterator iter
= out_bl
.begin();
1838 r
= mirror_instances_list_finish(&iter
, instance_ids
);
1845 void mirror_instances_add(librados::ObjectWriteOperation
*op
,
1846 const std::string
&instance_id
) {
1848 ::encode(instance_id
, bl
);
1849 op
->exec("rbd", "mirror_instances_add", bl
);
1852 int mirror_instances_add(librados::IoCtx
*ioctx
,
1853 const std::string
&instance_id
) {
1854 librados::ObjectWriteOperation op
;
1855 mirror_instances_add(&op
, instance_id
);
1856 return ioctx
->operate(RBD_MIRROR_LEADER
, &op
);
1859 void mirror_instances_remove(librados::ObjectWriteOperation
*op
,
1860 const std::string
&instance_id
) {
1862 ::encode(instance_id
, bl
);
1863 op
->exec("rbd", "mirror_instances_remove", bl
);
1866 int mirror_instances_remove(librados::IoCtx
*ioctx
,
1867 const std::string
&instance_id
) {
1868 librados::ObjectWriteOperation op
;
1869 mirror_instances_remove(&op
, instance_id
);
1870 return ioctx
->operate(RBD_MIRROR_LEADER
, &op
);
1873 // Consistency groups functions
1874 int group_create(librados::IoCtx
*ioctx
, const std::string
&oid
)
1878 return ioctx
->exec(oid
, "rbd", "group_create", bl
, bl2
);
1881 int group_dir_list(librados::IoCtx
*ioctx
, const std::string
&oid
,
1882 const std::string
&start
, uint64_t max_return
,
1883 map
<string
, string
> *cgs
)
1886 ::encode(start
, in
);
1887 ::encode(max_return
, in
);
1888 int r
= ioctx
->exec(oid
, "rbd", "group_dir_list", in
, out
);
1892 bufferlist::iterator iter
= out
.begin();
1894 ::decode(*cgs
, iter
);
1895 } catch (const buffer::error
&err
) {
1902 int group_dir_add(librados::IoCtx
*ioctx
, const std::string
&oid
,
1903 const std::string
&name
, const std::string
&id
)
1908 return ioctx
->exec(oid
, "rbd", "group_dir_add", in
, out
);
1911 int group_dir_remove(librados::IoCtx
*ioctx
, const std::string
&oid
,
1912 const std::string
&name
, const std::string
&id
)
1917 return ioctx
->exec(oid
, "rbd", "group_dir_remove", in
, out
);
1920 int group_image_remove(librados::IoCtx
*ioctx
, const std::string
&oid
,
1921 const cls::rbd::GroupImageSpec
&spec
)
1926 return ioctx
->exec(oid
, "rbd", "group_image_remove", bl
, bl2
);
1929 int group_image_list(librados::IoCtx
*ioctx
,
1930 const std::string
&oid
,
1931 const cls::rbd::GroupImageSpec
&start
,
1932 uint64_t max_return
,
1933 std::vector
<cls::rbd::GroupImageStatus
> *images
)
1936 ::encode(start
, bl
);
1937 ::encode(max_return
, bl
);
1939 int r
= ioctx
->exec(oid
, "rbd", "group_image_list", bl
, bl2
);
1943 bufferlist::iterator iter
= bl2
.begin();
1945 ::decode(*images
, iter
);
1946 } catch (const buffer::error
&err
) {
1953 int group_image_set(librados::IoCtx
*ioctx
, const std::string
&oid
,
1954 const cls::rbd::GroupImageStatus
&st
)
1959 return ioctx
->exec(oid
, "rbd", "group_image_set", bl
, bl2
);
1962 int image_add_group(librados::IoCtx
*ioctx
, const std::string
&oid
,
1963 const cls::rbd::GroupSpec
&group_spec
)
1966 ::encode(group_spec
, bl
);
1968 return ioctx
->exec(oid
, "rbd", "image_add_group", bl
, bl2
);
1971 int image_remove_group(librados::IoCtx
*ioctx
, const std::string
&oid
,
1972 const cls::rbd::GroupSpec
&group_spec
)
1975 ::encode(group_spec
, bl
);
1977 return ioctx
->exec(oid
, "rbd", "image_remove_group", bl
, bl2
);
1980 void image_get_group_start(librados::ObjectReadOperation
*op
)
1983 op
->exec("rbd", "image_get_group", in_bl
);
1986 int image_get_group_finish(bufferlist::iterator
*iter
,
1987 cls::rbd::GroupSpec
*group_spec
)
1990 ::decode(*group_spec
, *iter
);
1991 } catch (const buffer::error
&err
) {
1997 int image_get_group(librados::IoCtx
*ioctx
, const std::string
&oid
,
1998 cls::rbd::GroupSpec
*group_spec
)
2000 librados::ObjectReadOperation op
;
2001 image_get_group_start(&op
);
2004 int r
= ioctx
->operate(oid
, &op
, &out_bl
);
2009 bufferlist::iterator iter
= out_bl
.begin();
2010 return image_get_group_finish(&iter
, group_spec
);
2013 // rbd_trash functions
2014 void trash_add(librados::ObjectWriteOperation
*op
,
2015 const std::string
&id
,
2016 const cls::rbd::TrashImageSpec
&trash_spec
)
2020 ::encode(trash_spec
, bl
);
2021 op
->exec("rbd", "trash_add", bl
);
2024 int trash_add(librados::IoCtx
*ioctx
, const std::string
&id
,
2025 const cls::rbd::TrashImageSpec
&trash_spec
)
2027 librados::ObjectWriteOperation op
;
2028 trash_add(&op
, id
, trash_spec
);
2030 return ioctx
->operate(RBD_TRASH
, &op
);
2033 void trash_remove(librados::ObjectWriteOperation
*op
,
2034 const std::string
&id
)
2038 op
->exec("rbd", "trash_remove", bl
);
2041 int trash_remove(librados::IoCtx
*ioctx
, const std::string
&id
)
2043 librados::ObjectWriteOperation op
;
2044 trash_remove(&op
, id
);
2046 return ioctx
->operate(RBD_TRASH
, &op
);
2049 void trash_list_start(librados::ObjectReadOperation
*op
,
2050 const std::string
&start
, uint64_t max_return
)
2053 ::encode(start
, bl
);
2054 ::encode(max_return
, bl
);
2055 op
->exec("rbd", "trash_list", bl
);
2058 int trash_list_finish(bufferlist::iterator
*it
,
2059 map
<string
, cls::rbd::TrashImageSpec
> *entries
)
2064 ::decode(*entries
, *it
);
2065 } catch (const buffer::error
&err
) {
2072 int trash_list(librados::IoCtx
*ioctx
,
2073 const std::string
&start
, uint64_t max_return
,
2074 map
<string
, cls::rbd::TrashImageSpec
> *entries
)
2076 librados::ObjectReadOperation op
;
2077 trash_list_start(&op
, start
, max_return
);
2080 int r
= ioctx
->operate(RBD_TRASH
, &op
, &out_bl
);
2085 bufferlist::iterator iter
= out_bl
.begin();
2086 return trash_list_finish(&iter
, entries
);
2089 void trash_get_start(librados::ObjectReadOperation
*op
,
2090 const std::string
&id
)
2094 op
->exec("rbd", "trash_get", bl
);
2097 int trash_get_finish(bufferlist::iterator
*it
,
2098 cls::rbd::TrashImageSpec
*trash_spec
) {
2101 ::decode(*trash_spec
, *it
);
2102 } catch (const buffer::error
&err
) {
2110 int trash_get(librados::IoCtx
*ioctx
, const std::string
&id
,
2111 cls::rbd::TrashImageSpec
*trash_spec
)
2113 librados::ObjectReadOperation op
;
2114 trash_get_start(&op
, id
);
2117 int r
= ioctx
->operate(RBD_TRASH
, &op
, &out_bl
);
2122 bufferlist::iterator it
= out_bl
.begin();
2123 return trash_get_finish(&it
, trash_spec
);
2126 } // namespace cls_client
2127 } // namespace librbd