]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- |
2 | // vim: ts=8 sw=2 smarttab | |
3 | #ifndef __CEPH_CLS_RBD_H | |
4 | #define __CEPH_CLS_RBD_H | |
5 | ||
6 | #include "include/types.h" | |
7 | #include "include/buffer_fwd.h" | |
8 | #include "include/rbd_types.h" | |
9 | #include "common/Formatter.h" | |
10 | #include "cls/rbd/cls_rbd_types.h" | |
11 | ||
12 | /// information about our parent image, if any | |
13 | struct cls_rbd_parent { | |
14 | int64_t pool; ///< parent pool id | |
15 | string id; ///< parent image id | |
16 | snapid_t snapid; ///< parent snapid we refer to | |
17 | uint64_t overlap; ///< portion of this image mapped onto parent (bytes) | |
18 | ||
19 | /// true if our parent pointer information is defined | |
20 | bool exists() const { | |
21 | return snapid != CEPH_NOSNAP && pool >= 0 && id.length() > 0 && overlap > 0; | |
22 | } | |
23 | ||
24 | cls_rbd_parent() : pool(-1), snapid(CEPH_NOSNAP), overlap(0) {} | |
25 | ||
26 | void encode(bufferlist& bl) const { | |
27 | ENCODE_START(1, 1, bl); | |
28 | ::encode(pool, bl); | |
29 | ::encode(id, bl); | |
30 | ::encode(snapid, bl); | |
31 | ::encode(overlap, bl); | |
32 | ENCODE_FINISH(bl); | |
33 | } | |
34 | void decode(bufferlist::iterator& bl) { | |
35 | DECODE_START(1, bl); | |
36 | ::decode(pool, bl); | |
37 | ::decode(id, bl); | |
38 | ::decode(snapid, bl); | |
39 | ::decode(overlap, bl); | |
40 | DECODE_FINISH(bl); | |
41 | } | |
42 | void dump(Formatter *f) const { | |
43 | f->dump_int("pool", pool); | |
44 | f->dump_string("id", id); | |
45 | f->dump_unsigned("snapid", snapid); | |
46 | f->dump_unsigned("overlap", overlap); | |
47 | } | |
48 | static void generate_test_instances(list<cls_rbd_parent*>& o) { | |
49 | o.push_back(new cls_rbd_parent); | |
50 | cls_rbd_parent *t = new cls_rbd_parent; | |
51 | t->pool = 1; | |
52 | t->id = "foo"; | |
53 | t->snapid = 3; | |
54 | t->overlap = 500; | |
55 | o.push_back(t); | |
56 | } | |
57 | }; | |
58 | WRITE_CLASS_ENCODER(cls_rbd_parent) | |
59 | ||
60 | struct cls_rbd_snap { | |
61 | snapid_t id; | |
62 | string name; | |
63 | uint64_t image_size; | |
64 | uint64_t features; | |
65 | uint8_t protection_status; | |
66 | cls_rbd_parent parent; | |
67 | uint64_t flags; | |
68 | utime_t timestamp; | |
69 | cls::rbd::SnapshotNamespaceOnDisk snapshot_namespace = { | |
70 | cls::rbd::UserSnapshotNamespace{}}; | |
71 | ||
72 | /// true if we have a parent | |
73 | bool has_parent() const { | |
74 | return parent.exists(); | |
75 | } | |
76 | ||
77 | cls_rbd_snap() : id(CEPH_NOSNAP), image_size(0), features(0), | |
78 | protection_status(RBD_PROTECTION_STATUS_UNPROTECTED), | |
79 | flags(0), timestamp(utime_t()) | |
80 | {} | |
81 | void encode(bufferlist& bl) const { | |
82 | ENCODE_START(6, 1, bl); | |
83 | ::encode(id, bl); | |
84 | ::encode(name, bl); | |
85 | ::encode(image_size, bl); | |
86 | ::encode(features, bl); | |
87 | ::encode(parent, bl); | |
88 | ::encode(protection_status, bl); | |
89 | ::encode(flags, bl); | |
90 | ::encode(snapshot_namespace, bl); | |
91 | ::encode(timestamp, bl); | |
92 | ENCODE_FINISH(bl); | |
93 | } | |
94 | void decode(bufferlist::iterator& p) { | |
95 | DECODE_START(6, p); | |
96 | ::decode(id, p); | |
97 | ::decode(name, p); | |
98 | ::decode(image_size, p); | |
99 | ::decode(features, p); | |
100 | if (struct_v >= 2) { | |
101 | ::decode(parent, p); | |
102 | } | |
103 | if (struct_v >= 3) { | |
104 | ::decode(protection_status, p); | |
105 | } | |
106 | if (struct_v >= 4) { | |
107 | ::decode(flags, p); | |
108 | } | |
109 | if (struct_v >= 5) { | |
110 | ::decode(snapshot_namespace, p); | |
111 | } | |
112 | if (struct_v >= 6) { | |
113 | ::decode(timestamp, p); | |
114 | } | |
115 | DECODE_FINISH(p); | |
116 | } | |
117 | void dump(Formatter *f) const { | |
118 | f->dump_unsigned("id", id); | |
119 | f->dump_string("name", name); | |
120 | f->dump_unsigned("image_size", image_size); | |
121 | f->dump_unsigned("features", features); | |
122 | if (has_parent()) { | |
123 | f->open_object_section("parent"); | |
124 | parent.dump(f); | |
125 | f->close_section(); | |
126 | } | |
127 | switch (protection_status) { | |
128 | case RBD_PROTECTION_STATUS_UNPROTECTED: | |
129 | f->dump_string("protection_status", "unprotected"); | |
130 | break; | |
131 | case RBD_PROTECTION_STATUS_UNPROTECTING: | |
132 | f->dump_string("protection_status", "unprotecting"); | |
133 | break; | |
134 | case RBD_PROTECTION_STATUS_PROTECTED: | |
135 | f->dump_string("protection_status", "protected"); | |
136 | break; | |
137 | default: | |
138 | ceph_abort(); | |
139 | } | |
140 | } | |
141 | static void generate_test_instances(list<cls_rbd_snap*>& o) { | |
142 | o.push_back(new cls_rbd_snap); | |
143 | cls_rbd_snap *t = new cls_rbd_snap; | |
144 | t->id = 1; | |
145 | t->name = "snap"; | |
146 | t->image_size = 123456; | |
147 | t->features = 123; | |
148 | t->flags = 31; | |
149 | o.push_back(t); | |
150 | t = new cls_rbd_snap; | |
151 | t->id = 2; | |
152 | t->name = "snap2"; | |
153 | t->image_size = 12345678; | |
154 | t->features = 1234; | |
155 | t->parent.pool = 1; | |
156 | t->parent.id = "parent"; | |
157 | t->parent.snapid = 456; | |
158 | t->parent.overlap = 12345; | |
159 | t->protection_status = RBD_PROTECTION_STATUS_PROTECTED; | |
160 | t->flags = 14; | |
161 | t->timestamp = utime_t(); | |
162 | o.push_back(t); | |
163 | } | |
164 | }; | |
165 | WRITE_CLASS_ENCODER(cls_rbd_snap) | |
166 | ||
167 | #endif |