1 #include "scrub_types.h"
2
3 using namespace librados;
4
5 void object_id_wrapper::encode(bufferlist& bl) const
6 {
7 ENCODE_START(1, 1, bl);
8 encode(name, bl);
9 encode(nspace, bl);
10 encode(locator, bl);
11 encode(snap, bl);
12 ENCODE_FINISH(bl);
13 }
14
15 void object_id_wrapper::decode(bufferlist::const_iterator& bp)
16 {
17 DECODE_START(1, bp);
18 decode(name, bp);
19 decode(nspace, bp);
20 decode(locator, bp);
21 decode(snap, bp);
22 DECODE_FINISH(bp);
23 }
24
25 namespace librados {
26 static void encode(const object_id_t& obj, bufferlist& bl)
27 {
28 reinterpret_cast<const object_id_wrapper&>(obj).encode(bl);
29 }
30 }
31
32 void osd_shard_wrapper::encode(bufferlist& bl) const
33 {
34 ENCODE_START(1, 1, bl);
35 encode(osd, bl);
|
(1) Event overrun-buffer-val: |
Overrunning buffer pointed to by "this->shard" of 4 bytes by passing it to a function which accesses it at byte offset 7. [details] |
36 encode(shard, bl);
37 ENCODE_FINISH(bl);
38 }
39
40 void osd_shard_wrapper::decode(bufferlist::const_iterator& bp)
41 {
42 DECODE_START(1, bp);
43 decode(osd, bp);
44 decode(shard, bp);
45 DECODE_FINISH(bp);
46 }
47
48 namespace librados {
49 static void encode(const osd_shard_t& shard, bufferlist& bl) {
50 reinterpret_cast<const osd_shard_wrapper&>(shard).encode(bl);
51 }
52 }
53
54 void shard_info_wrapper::set_object(const ScrubMap::object& object)
55 {
56 for (auto attr : object.attrs) {
57 bufferlist bl;
58 bl.push_back(attr.second);
59 attrs.insert(std::make_pair(attr.first, std::move(bl)));
60 }
61 size = object.size;
62 if (object.omap_digest_present) {
63 omap_digest_present = true;
64 omap_digest = object.omap_digest;
65 }
66 if (object.digest_present) {
67 data_digest_present = true;
68 data_digest = object.digest;
69 }
70 }
71
72 void shard_info_wrapper::encode(bufferlist& bl) const
73 {
74 ENCODE_START(3, 3, bl);
75 encode(errors, bl);
76 encode(primary, bl);
77 if (!has_shard_missing()) {
78 encode(attrs, bl);
79 encode(size, bl);
80 encode(omap_digest_present, bl);
81 encode(omap_digest, bl);
82 encode(data_digest_present, bl);
83 encode(data_digest, bl);
84 encode(selected_oi, bl);
85 }
86 ENCODE_FINISH(bl);
87 }
88
89 void shard_info_wrapper::decode(bufferlist::const_iterator& bp)
90 {
91 DECODE_START(3, bp);
92 decode(errors, bp);
93 decode(primary, bp);
94 if (!has_shard_missing()) {
95 decode(attrs, bp);
96 decode(size, bp);
97 decode(omap_digest_present, bp);
98 decode(omap_digest, bp);
99 decode(data_digest_present, bp);
100 decode(data_digest, bp);
101 decode(selected_oi, bp);
102 }
103 DECODE_FINISH(bp);
104 }
105
106 inconsistent_obj_wrapper::inconsistent_obj_wrapper(const hobject_t& hoid)
107 : inconsistent_obj_t{librados::object_id_t{hoid.oid.name,
108 hoid.nspace,
109 hoid.get_key(), hoid.snap}}
110 {}
111
112 void inconsistent_obj_wrapper::add_shard(const pg_shard_t& pgs,
113 const shard_info_wrapper& shard)
114 {
115 union_shards.errors |= shard.errors;
116 shards.emplace(osd_shard_t{pgs.osd, int8_t(pgs.shard)}, shard);
117 }
118
119 void
120 inconsistent_obj_wrapper::set_auth_missing(const hobject_t& hoid,
121 const map<pg_shard_t, ScrubMap*>& maps,
122 map<pg_shard_t, shard_info_wrapper> &shard_map,
123 int &shallow_errors, int &deep_errors,
124 const pg_shard_t &primary)
125 {
126 for (auto pg_map : maps) {
127 auto oid_object = pg_map.second->objects.find(hoid);
128 shard_map[pg_map.first].primary = (pg_map.first == primary);
129 if (oid_object == pg_map.second->objects.end())
130 shard_map[pg_map.first].set_missing();
131 else
132 shard_map[pg_map.first].set_object(oid_object->second);
133 if (shard_map[pg_map.first].has_deep_errors())
134 ++deep_errors;
135 else if (shard_map[pg_map.first].has_shallow_errors())
136 ++shallow_errors;
137 union_shards.errors |= shard_map[pg_map.first].errors;
138 shards.emplace(osd_shard_t{pg_map.first.osd, pg_map.first.shard}, shard_map[pg_map.first]);
139 }
140 }
141
142 namespace librados {
143 static void encode(const shard_info_t& shard, bufferlist& bl)
144 {
145 reinterpret_cast<const shard_info_wrapper&>(shard).encode(bl);
146 }
147 }
148
149 void inconsistent_obj_wrapper::encode(bufferlist& bl) const
150 {
151 ENCODE_START(2, 2, bl);
152 encode(errors, bl);
153 encode(object, bl);
154 encode(version, bl);
155 encode(shards, bl);
156 encode(union_shards.errors, bl);
157 ENCODE_FINISH(bl);
158 }
159
160 void inconsistent_obj_wrapper::decode(bufferlist::const_iterator& bp)
161 {
162 DECODE_START(2, bp);
163 DECODE_OLDEST(2);
164 decode(errors, bp);
165 decode(object, bp);
166 decode(version, bp);
167 decode(shards, bp);
168 decode(union_shards.errors, bp);
169 DECODE_FINISH(bp);
170 }
171
172 inconsistent_snapset_wrapper::inconsistent_snapset_wrapper(const hobject_t& hoid)
173 : inconsistent_snapset_t{object_id_t{hoid.oid.name,
174 hoid.nspace,
175 hoid.get_key(),
176 hoid.snap}}
177 {}
178
179 using inc_snapset_t = inconsistent_snapset_t;
180
181 void inconsistent_snapset_wrapper::set_headless()
182 {
183 errors |= inc_snapset_t::HEADLESS_CLONE;
184 }
185
186 void inconsistent_snapset_wrapper::set_snapset_missing()
187 {
188 errors |= inc_snapset_t::SNAPSET_MISSING;
189 }
190
191 void inconsistent_snapset_wrapper::set_info_missing()
192 {
193 errors |= inc_snapset_t::INFO_MISSING;
194 }
195
196 void inconsistent_snapset_wrapper::set_snapset_corrupted()
197 {
198 errors |= inc_snapset_t::SNAPSET_CORRUPTED;
199 }
200
201 void inconsistent_snapset_wrapper::set_info_corrupted()
202 {
203 errors |= inc_snapset_t::INFO_CORRUPTED;
204 }
205
206 void inconsistent_snapset_wrapper::set_clone_missing(snapid_t snap)
207 {
208 errors |= inc_snapset_t::CLONE_MISSING;
209 missing.push_back(snap);
210 }
211
212 void inconsistent_snapset_wrapper::set_clone(snapid_t snap)
213 {
214 errors |= inc_snapset_t::EXTRA_CLONES;
215 clones.push_back(snap);
216 }
217
218 void inconsistent_snapset_wrapper::set_snapset_error()
219 {
220 errors |= inc_snapset_t::SNAP_ERROR;
221 }
222
223 void inconsistent_snapset_wrapper::set_size_mismatch()
224 {
225 errors |= inc_snapset_t::SIZE_MISMATCH;
226 }
227
228 void inconsistent_snapset_wrapper::encode(bufferlist& bl) const
229 {
230 ENCODE_START(2, 1, bl);
231 encode(errors, bl);
232 encode(object, bl);
233 encode(clones, bl);
234 encode(missing, bl);
235 encode(ss_bl, bl);
236 ENCODE_FINISH(bl);
237 }
238
239 void inconsistent_snapset_wrapper::decode(bufferlist::const_iterator& bp)
240 {
241 DECODE_START(2, bp);
242 decode(errors, bp);
243 decode(object, bp);
244 decode(clones, bp);
245 decode(missing, bp);
246 if (struct_v >= 2) {
247 decode(ss_bl, bp);
248 }
249 DECODE_FINISH(bp);
250 }
251
252 void scrub_ls_arg_t::encode(bufferlist& bl) const
253 {
254 ENCODE_START(1, 1, bl);
255 encode(interval, bl);
256 encode(get_snapsets, bl);
257 encode(start_after.name, bl);
258 encode(start_after.nspace, bl);
259 encode(start_after.snap, bl);
260 encode(max_return, bl);
261 ENCODE_FINISH(bl);
262 }
263
264 void scrub_ls_arg_t::decode(bufferlist::const_iterator& bp)
265 {
266 DECODE_START(1, bp);
267 decode(interval, bp);
268 decode(get_snapsets, bp);
269 decode(start_after.name, bp);
270 decode(start_after.nspace, bp);
271 decode(start_after.snap, bp);
272 decode(max_return, bp);
273 DECODE_FINISH(bp);
274 }
275
276 void scrub_ls_result_t::encode(bufferlist& bl) const
277 {
278 ENCODE_START(1, 1, bl);
279 encode(interval, bl);
280 encode(vals, bl);
281 ENCODE_FINISH(bl);
282 }
283
284 void scrub_ls_result_t::decode(bufferlist::const_iterator& bp)
285 {
286 DECODE_START(1, bp);
287 decode(interval, bp);
288 decode(vals, bp);
289 DECODE_FINISH(bp);
290 }
291