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