ceph/src/common/scrub_types.cc

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