ceph/src/common/scrub_types.cc

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