ceph/src/common/scrub_types.h

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #ifndef CEPH_SCRUB_TYPES_H
   5 #define CEPH_SCRUB_TYPES_H
   6
   7 #include "include/rados/rados_types.hpp"
   8 #include "common/hobject.h"
   9 #include "osd/osd_types.h"
  10
  11
  12 // wrappers around scrub types to offer the necessary bits other than
  13 // the minimal set that the lirados requires
  14 struct object_id_wrapper : public librados::object_id_t {
  15   object_id_wrapper(const hobject_t& hoid)
  16     : object_id_t{hoid.oid.name, hoid.nspace, hoid.get_key(), hoid.snap}
  17   {}
  18   void encode(bufferlist& bl) const;
  19   void decode(bufferlist::iterator& bl);
  20 };
  21
  22 WRITE_CLASS_ENCODER(object_id_wrapper)
  23
  24 inline void decode(librados::object_id_t& obj, bufferlist::iterator& bp) {
  25   reinterpret_cast<object_id_wrapper&>(obj).decode(bp);
  26 }
  27
  28 struct osd_shard_wrapper : public librados::osd_shard_t {
  29   void encode(bufferlist& bl) const;
  30   void decode(bufferlist::iterator& bp);
  31 };
  32
  33 WRITE_CLASS_ENCODER(osd_shard_wrapper)
  34
  35 namespace librados {
  36   inline void decode(librados::osd_shard_t& shard, bufferlist::iterator& bp) {
  37     reinterpret_cast<osd_shard_wrapper&>(shard).decode(bp);
  38   }
  39 }
  40
  41 struct shard_info_wrapper : public librados::shard_info_t {
  42 public:
  43   shard_info_wrapper() = default;
  44   shard_info_wrapper(const ScrubMap::object& object) {
  45     set_object(object);
  46   }
  47   void set_object(const ScrubMap::object& object);
  48   void set_missing() {
  49     errors |= err_t::SHARD_MISSING;
  50   }
  51   void set_omap_digest_mismatch_oi() {
  52     errors |= err_t::OMAP_DIGEST_MISMATCH_OI;
  53   }
  54   void set_size_mismatch_oi() {
  55     errors |= err_t::SIZE_MISMATCH_OI;
  56   }
  57   void set_data_digest_mismatch_oi() {
  58     errors |= err_t::DATA_DIGEST_MISMATCH_OI;
  59   }
  60   void set_read_error() {
  61     errors |= err_t::SHARD_READ_ERR;
  62   }
  63   void set_stat_error() {
  64     errors |= err_t::SHARD_STAT_ERR;
  65   }
  66   void set_ec_hash_mismatch() {
  67     errors |= err_t::SHARD_EC_HASH_MISMATCH;
  68   }
  69   void set_ec_size_mismatch() {
  70     errors |= err_t::SHARD_EC_SIZE_MISMATCH;
  71   }
  72   void set_oi_attr_missing() {
  73     errors |= err_t::OI_ATTR_MISSING;
  74   }
  75   void set_oi_attr_corrupted() {
  76     errors |= err_t::OI_ATTR_CORRUPTED;
  77   }
  78   void set_ss_attr_missing() {
  79     errors |= err_t::SS_ATTR_MISSING;
  80   }
  81   void set_ss_attr_corrupted() {
  82     errors |= err_t::SS_ATTR_CORRUPTED;
  83   }
  84   void encode(bufferlist& bl) const;
  85   void decode(bufferlist::iterator& bp);
  86 };
  87
  88 WRITE_CLASS_ENCODER(shard_info_wrapper)
  89
  90 namespace librados {
  91   inline void decode(librados::shard_info_t& shard,
  92                      bufferlist::iterator& bp) {
  93     reinterpret_cast<shard_info_wrapper&>(shard).decode(bp);
  94   }
  95 }
  96
  97 struct inconsistent_obj_wrapper : librados::inconsistent_obj_t {
  98   inconsistent_obj_wrapper(const hobject_t& hoid);
  99
 100   void set_object_info_inconsistency() {
 101     errors |= obj_err_t::OBJECT_INFO_INCONSISTENCY;
 102   }
 103   void set_omap_digest_mismatch() {
 104     errors |= obj_err_t::OMAP_DIGEST_MISMATCH;
 105   }
 106   void set_data_digest_mismatch() {
 107     errors |= obj_err_t::DATA_DIGEST_MISMATCH;
 108   }
 109   void set_size_mismatch() {
 110     errors |= obj_err_t::SIZE_MISMATCH;
 111   }
 112   void set_attr_value_mismatch() {
 113     errors |= obj_err_t::ATTR_VALUE_MISMATCH;
 114   }
 115   void set_attr_name_mismatch() {
 116     errors |= obj_err_t::ATTR_NAME_MISMATCH;
 117   }
 118   void add_shard(const pg_shard_t& pgs, const shard_info_wrapper& shard);
 119   void set_auth_missing(const hobject_t& hoid,
 120                         const map<pg_shard_t, ScrubMap*>&,
 121                         map<pg_shard_t, shard_info_wrapper>&,
 122                         int &shallow_errors, int &deep_errors);
 123   void set_version(uint64_t ver) { version = ver; }
 124   void encode(bufferlist& bl) const;
 125   void decode(bufferlist::iterator& bp);
 126 };
 127
 128 WRITE_CLASS_ENCODER(inconsistent_obj_wrapper)
 129
 130 inline void decode(librados::inconsistent_obj_t& obj,
 131                    bufferlist::iterator& bp) {
 132   reinterpret_cast<inconsistent_obj_wrapper&>(obj).decode(bp);
 133 }
 134
 135 struct inconsistent_snapset_wrapper : public librados::inconsistent_snapset_t {
 136   inconsistent_snapset_wrapper() = default;
 137   inconsistent_snapset_wrapper(const hobject_t& head);
 138   void set_headless();
 139   // soid claims that it is a head or a snapdir, but its SS_ATTR
 140   // is missing.
 141   void set_ss_attr_missing();
 142   void set_oi_attr_missing();
 143   void set_ss_attr_corrupted();
 144   void set_oi_attr_corrupted();
 145   // snapset with missing clone
 146   void set_clone_missing(snapid_t);
 147   // Clones that are there
 148   void set_clone(snapid_t);
 149   // the snapset is not consistent with itself
 150   void set_snapset_mismatch();
 151   // soid.snap inconsistent with snapset
 152   void set_head_mismatch();
 153   void set_size_mismatch();
 154
 155   void encode(bufferlist& bl) const;
 156   void decode(bufferlist::iterator& bp);
 157 };
 158
 159 WRITE_CLASS_ENCODER(inconsistent_snapset_wrapper)
 160
 161 namespace librados {
 162   inline void decode(librados::inconsistent_snapset_t& snapset,
 163                      bufferlist::iterator& bp) {
 164     reinterpret_cast<inconsistent_snapset_wrapper&>(snapset).decode(bp);
 165   }
 166 }
 167
 168 struct scrub_ls_arg_t {
 169   uint32_t interval;
 170   uint32_t get_snapsets;
 171   librados::object_id_t start_after;
 172   uint64_t max_return;
 173   void encode(bufferlist& bl) const;
 174   void decode(bufferlist::iterator& bl);
 175 };
 176
 177 WRITE_CLASS_ENCODER(scrub_ls_arg_t);
 178
 179 struct scrub_ls_result_t {
 180   epoch_t interval;
 181   std::vector<bufferlist> vals;
 182   void encode(bufferlist& bl) const;
 183   void decode(bufferlist::iterator& bl);
 184 };
 185
 186 WRITE_CLASS_ENCODER(scrub_ls_result_t);
 187
 188 #endif