+++ /dev/null
-// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
-// vim: ts=8 sw=2 smarttab
-/*
- * Ceph - scalable distributed file system
- *
- * Copyright (C) 2004-2006 Sage Weil <sage@newdream.net>
- * Copyright (C) 2013,2014 Cloudwatt <libre.licensing@cloudwatt.com>
- *
- * Author: Loic Dachary <loic@dachary.org>
- *
- * This is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License version 2.1, as published by the Free Software
- * Foundation. See file COPYING.
- *
- */
-
-#ifndef CEPH_OSD_TYPES_H
-#define CEPH_OSD_TYPES_H
-
-#include <sstream>
-#include <stdio.h>
-#include <memory>
-#include <boost/scoped_ptr.hpp>
-#include <boost/optional/optional_io.hpp>
-#include <boost/variant.hpp>
-
-#include "include/rados/rados_types.hpp"
-#include "include/mempool.h"
-
-#include "msg/msg_types.h"
-#include "include/types.h"
-#include "include/utime.h"
-#include "include/CompatSet.h"
-#include "common/histogram.h"
-#include "include/interval_set.h"
-#include "include/inline_memory.h"
-#include "common/Formatter.h"
-#include "common/bloom_filter.hpp"
-#include "common/hobject.h"
-#include "common/snap_types.h"
-#include "HitSet.h"
-#include "Watch.h"
-#include "include/cmp.h"
-#include "librados/ListObjectImpl.h"
-#include "compressor/Compressor.h"
-#include <atomic>
-
-#define CEPH_OSD_ONDISK_MAGIC "ceph osd volume v026"
-
-#define CEPH_OSD_FEATURE_INCOMPAT_BASE CompatSet::Feature(1, "initial feature set(~v.18)")
-#define CEPH_OSD_FEATURE_INCOMPAT_PGINFO CompatSet::Feature(2, "pginfo object")
-#define CEPH_OSD_FEATURE_INCOMPAT_OLOC CompatSet::Feature(3, "object locator")
-#define CEPH_OSD_FEATURE_INCOMPAT_LEC CompatSet::Feature(4, "last_epoch_clean")
-#define CEPH_OSD_FEATURE_INCOMPAT_CATEGORIES CompatSet::Feature(5, "categories")
-#define CEPH_OSD_FEATURE_INCOMPAT_HOBJECTPOOL CompatSet::Feature(6, "hobjectpool")
-#define CEPH_OSD_FEATURE_INCOMPAT_BIGINFO CompatSet::Feature(7, "biginfo")
-#define CEPH_OSD_FEATURE_INCOMPAT_LEVELDBINFO CompatSet::Feature(8, "leveldbinfo")
-#define CEPH_OSD_FEATURE_INCOMPAT_LEVELDBLOG CompatSet::Feature(9, "leveldblog")
-#define CEPH_OSD_FEATURE_INCOMPAT_SNAPMAPPER CompatSet::Feature(10, "snapmapper")
-#define CEPH_OSD_FEATURE_INCOMPAT_SHARDS CompatSet::Feature(11, "sharded objects")
-#define CEPH_OSD_FEATURE_INCOMPAT_HINTS CompatSet::Feature(12, "transaction hints")
-#define CEPH_OSD_FEATURE_INCOMPAT_PGMETA CompatSet::Feature(13, "pg meta object")
-#define CEPH_OSD_FEATURE_INCOMPAT_MISSING CompatSet::Feature(14, "explicit missing set")
-#define CEPH_OSD_FEATURE_INCOMPAT_FASTINFO CompatSet::Feature(15, "fastinfo pg attr")
-#define CEPH_OSD_FEATURE_INCOMPAT_RECOVERY_DELETES CompatSet::Feature(16, "deletes in missing set")
-
-
-/// min recovery priority for MBackfillReserve
-#define OSD_RECOVERY_PRIORITY_MIN 0
-
-/// base backfill priority for MBackfillReserve
-#define OSD_BACKFILL_PRIORITY_BASE 100
-
-/// base backfill priority for MBackfillReserve (degraded PG)
-#define OSD_BACKFILL_DEGRADED_PRIORITY_BASE 140
-
-/// base recovery priority for MBackfillReserve
-#define OSD_RECOVERY_PRIORITY_BASE 180
-
-/// base backfill priority for MBackfillReserve (inactive PG)
-#define OSD_BACKFILL_INACTIVE_PRIORITY_BASE 220
-
-/// max manually/automatically set recovery priority for MBackfillReserve
-#define OSD_RECOVERY_PRIORITY_MAX 254
-
-/// max recovery priority for MBackfillReserve, only when forced manually
-#define OSD_RECOVERY_PRIORITY_FORCED 255
-
-
-typedef hobject_t collection_list_handle_t;
-
-/// convert a single CPEH_OSD_FLAG_* to a string
-const char *ceph_osd_flag_name(unsigned flag);
-/// convert a single CEPH_OSD_OF_FLAG_* to a string
-const char *ceph_osd_op_flag_name(unsigned flag);
-
-/// convert CEPH_OSD_FLAG_* op flags to a string
-string ceph_osd_flag_string(unsigned flags);
-/// conver CEPH_OSD_OP_FLAG_* op flags to a string
-string ceph_osd_op_flag_string(unsigned flags);
-/// conver CEPH_OSD_ALLOC_HINT_FLAG_* op flags to a string
-string ceph_osd_alloc_hint_flag_string(unsigned flags);
-
-
-/**
- * osd request identifier
- *
- * caller name + incarnation# + tid to unique identify this request.
- */
-struct osd_reqid_t {
- entity_name_t name; // who
- ceph_tid_t tid;
- int32_t inc; // incarnation
-
- osd_reqid_t()
- : tid(0), inc(0)
- {}
- osd_reqid_t(const osd_reqid_t& other)
- : name(other.name), tid(other.tid), inc(other.inc)
- {}
- osd_reqid_t(const entity_name_t& a, int i, ceph_tid_t t)
- : name(a), tid(t), inc(i)
- {}
-
- DENC(osd_reqid_t, v, p) {
- DENC_START(2, 2, p);
- denc(v.name, p);
- denc(v.tid, p);
- denc(v.inc, p);
- DENC_FINISH(p);
- }
- void dump(Formatter *f) const;
- static void generate_test_instances(list<osd_reqid_t*>& o);
-};
-WRITE_CLASS_DENC(osd_reqid_t)
-
-
-
-struct pg_shard_t {
- int32_t osd;
- shard_id_t shard;
- pg_shard_t() : osd(-1), shard(shard_id_t::NO_SHARD) {}
- explicit pg_shard_t(int osd) : osd(osd), shard(shard_id_t::NO_SHARD) {}
- pg_shard_t(int osd, shard_id_t shard) : osd(osd), shard(shard) {}
- bool is_undefined() const {
- return osd == -1;
- }
- void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
- void dump(Formatter *f) const {
- f->dump_unsigned("osd", osd);
- if (shard != shard_id_t::NO_SHARD) {
- f->dump_unsigned("shard", shard);
- }
- }
-};
-WRITE_CLASS_ENCODER(pg_shard_t)
-WRITE_EQ_OPERATORS_2(pg_shard_t, osd, shard)
-WRITE_CMP_OPERATORS_2(pg_shard_t, osd, shard)
-ostream &operator<<(ostream &lhs, const pg_shard_t &rhs);
-
-class IsPGRecoverablePredicate {
-public:
- /**
- * have encodes the shards available
- */
- virtual bool operator()(const set<pg_shard_t> &have) const = 0;
- virtual ~IsPGRecoverablePredicate() {}
-};
-
-class IsPGReadablePredicate {
-public:
- /**
- * have encodes the shards available
- */
- virtual bool operator()(const set<pg_shard_t> &have) const = 0;
- virtual ~IsPGReadablePredicate() {}
-};
-
-inline ostream& operator<<(ostream& out, const osd_reqid_t& r) {
- return out << r.name << "." << r.inc << ":" << r.tid;
-}
-
-inline bool operator==(const osd_reqid_t& l, const osd_reqid_t& r) {
- return (l.name == r.name) && (l.inc == r.inc) && (l.tid == r.tid);
-}
-inline bool operator!=(const osd_reqid_t& l, const osd_reqid_t& r) {
- return (l.name != r.name) || (l.inc != r.inc) || (l.tid != r.tid);
-}
-inline bool operator<(const osd_reqid_t& l, const osd_reqid_t& r) {
- return (l.name < r.name) || (l.inc < r.inc) ||
- (l.name == r.name && l.inc == r.inc && l.tid < r.tid);
-}
-inline bool operator<=(const osd_reqid_t& l, const osd_reqid_t& r) {
- return (l.name < r.name) || (l.inc < r.inc) ||
- (l.name == r.name && l.inc == r.inc && l.tid <= r.tid);
-}
-inline bool operator>(const osd_reqid_t& l, const osd_reqid_t& r) { return !(l <= r); }
-inline bool operator>=(const osd_reqid_t& l, const osd_reqid_t& r) { return !(l < r); }
-
-namespace std {
- template<> struct hash<osd_reqid_t> {
- size_t operator()(const osd_reqid_t &r) const {
- static hash<uint64_t> H;
- return H(r.name.num() ^ r.tid ^ r.inc);
- }
- };
-} // namespace std
-
-
-// -----
-
-// a locator constrains the placement of an object. mainly, which pool
-// does it go in.
-struct object_locator_t {
- // You specify either the hash or the key -- not both
- int64_t pool; ///< pool id
- string key; ///< key string (if non-empty)
- string nspace; ///< namespace
- int64_t hash; ///< hash position (if >= 0)
-
- explicit object_locator_t()
- : pool(-1), hash(-1) {}
- explicit object_locator_t(int64_t po)
- : pool(po), hash(-1) {}
- explicit object_locator_t(int64_t po, int64_t ps)
- : pool(po), hash(ps) {}
- explicit object_locator_t(int64_t po, string ns)
- : pool(po), nspace(ns), hash(-1) {}
- explicit object_locator_t(int64_t po, string ns, int64_t ps)
- : pool(po), nspace(ns), hash(ps) {}
- explicit object_locator_t(int64_t po, string ns, string s)
- : pool(po), key(s), nspace(ns), hash(-1) {}
- explicit object_locator_t(const hobject_t& soid)
- : pool(soid.pool), key(soid.get_key()), nspace(soid.nspace), hash(-1) {}
-
- int64_t get_pool() const {
- return pool;
- }
-
- void clear() {
- pool = -1;
- key = "";
- nspace = "";
- hash = -1;
- }
-
- bool empty() const {
- return pool == -1;
- }
-
- void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& p);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<object_locator_t*>& o);
-};
-WRITE_CLASS_ENCODER(object_locator_t)
-
-inline bool operator==(const object_locator_t& l, const object_locator_t& r) {
- return l.pool == r.pool && l.key == r.key && l.nspace == r.nspace && l.hash == r.hash;
-}
-inline bool operator!=(const object_locator_t& l, const object_locator_t& r) {
- return !(l == r);
-}
-
-inline ostream& operator<<(ostream& out, const object_locator_t& loc)
-{
- out << "@" << loc.pool;
- if (loc.nspace.length())
- out << ";" << loc.nspace;
- if (loc.key.length())
- out << ":" << loc.key;
- return out;
-}
-
-struct request_redirect_t {
-private:
- object_locator_t redirect_locator; ///< this is authoritative
- string redirect_object; ///< If non-empty, the request goes to this object name
- bufferlist osd_instructions; ///< a bufferlist for the OSDs, passed but not interpreted by clients
-
- friend ostream& operator<<(ostream& out, const request_redirect_t& redir);
-public:
-
- request_redirect_t() {}
- explicit request_redirect_t(const object_locator_t& orig, int64_t rpool) :
- redirect_locator(orig) { redirect_locator.pool = rpool; }
- explicit request_redirect_t(const object_locator_t& rloc) :
- redirect_locator(rloc) {}
- explicit request_redirect_t(const object_locator_t& orig,
- const string& robj) :
- redirect_locator(orig), redirect_object(robj) {}
-
- void set_instructions(const bufferlist& bl) { osd_instructions = bl; }
- const bufferlist& get_instructions() { return osd_instructions; }
-
- bool empty() const { return redirect_locator.empty() &&
- redirect_object.empty(); }
-
- void combine_with_locator(object_locator_t& orig, string& obj) const {
- orig = redirect_locator;
- if (!redirect_object.empty())
- obj = redirect_object;
- }
-
- void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<request_redirect_t*>& o);
-};
-WRITE_CLASS_ENCODER(request_redirect_t)
-
-inline ostream& operator<<(ostream& out, const request_redirect_t& redir) {
- out << "object " << redir.redirect_object << ", locator{" << redir.redirect_locator << "}";
- return out;
-}
-
-// Internal OSD op flags - set by the OSD based on the op types
-enum {
- CEPH_OSD_RMW_FLAG_READ = (1 << 1),
- CEPH_OSD_RMW_FLAG_WRITE = (1 << 2),
- CEPH_OSD_RMW_FLAG_CLASS_READ = (1 << 3),
- CEPH_OSD_RMW_FLAG_CLASS_WRITE = (1 << 4),
- CEPH_OSD_RMW_FLAG_PGOP = (1 << 5),
- CEPH_OSD_RMW_FLAG_CACHE = (1 << 6),
- CEPH_OSD_RMW_FLAG_FORCE_PROMOTE = (1 << 7),
- CEPH_OSD_RMW_FLAG_SKIP_HANDLE_CACHE = (1 << 8),
- CEPH_OSD_RMW_FLAG_SKIP_PROMOTE = (1 << 9),
- CEPH_OSD_RMW_FLAG_RWORDERED = (1 << 10),
-};
-
-
-// pg stuff
-
-#define OSD_SUPERBLOCK_GOBJECT ghobject_t(hobject_t(sobject_t(object_t("osd_superblock"), 0)))
-
-// placement seed (a hash value)
-typedef uint32_t ps_t;
-
-// old (v1) pg_t encoding (wrap old struct ceph_pg)
-struct old_pg_t {
- ceph_pg v;
- void encode(bufferlist& bl) const {
- ::encode_raw(v, bl);
- }
- void decode(bufferlist::iterator& bl) {
- ::decode_raw(v, bl);
- }
-};
-WRITE_CLASS_ENCODER(old_pg_t)
-
-// placement group id
-struct pg_t {
- uint64_t m_pool;
- uint32_t m_seed;
- int32_t m_preferred;
-
- pg_t() : m_pool(0), m_seed(0), m_preferred(-1) {}
- pg_t(ps_t seed, uint64_t pool, int pref=-1) :
- m_pool(pool), m_seed(seed), m_preferred(pref) {}
- // cppcheck-suppress noExplicitConstructor
- pg_t(const ceph_pg& cpg) :
- m_pool(cpg.pool), m_seed(cpg.ps), m_preferred((__s16)cpg.preferred) {}
-
- // cppcheck-suppress noExplicitConstructor
- pg_t(const old_pg_t& opg) {
- *this = opg.v;
- }
-
- old_pg_t get_old_pg() const {
- old_pg_t o;
- assert(m_pool < 0xffffffffull);
- o.v.pool = m_pool;
- o.v.ps = m_seed;
- o.v.preferred = (__s16)m_preferred;
- return o;
- }
-
- ps_t ps() const {
- return m_seed;
- }
- uint64_t pool() const {
- return m_pool;
- }
- int32_t preferred() const {
- return m_preferred;
- }
-
- static const uint8_t calc_name_buf_size = 36; // max length for max values len("18446744073709551615.ffffffff") + future suffix len("_head") + '\0'
- char *calc_name(char *buf, const char *suffix_backwords) const;
-
- void set_ps(ps_t p) {
- m_seed = p;
- }
- void set_pool(uint64_t p) {
- m_pool = p;
- }
- void set_preferred(int32_t osd) {
- m_preferred = osd;
- }
-
- pg_t get_parent() const;
- pg_t get_ancestor(unsigned old_pg_num) const;
-
- int print(char *o, int maxlen) const;
- bool parse(const char *s);
-
- bool is_split(unsigned old_pg_num, unsigned new_pg_num, set<pg_t> *pchildren) const;
-
- /**
- * Returns b such that for all object o:
- * ~((~0)<<b) & o.hash) == 0 iff o is in the pg for *this
- */
- unsigned get_split_bits(unsigned pg_num) const;
-
- bool contains(int bits, const ghobject_t& oid) {
- return oid.match(bits, ps());
- }
- bool contains(int bits, const hobject_t& oid) {
- return oid.match(bits, ps());
- }
-
- hobject_t get_hobj_start() const;
- hobject_t get_hobj_end(unsigned pg_num) const;
-
- void encode(bufferlist& bl) const {
- __u8 v = 1;
- ::encode(v, bl);
- ::encode(m_pool, bl);
- ::encode(m_seed, bl);
- ::encode(m_preferred, bl);
- }
- void decode(bufferlist::iterator& bl) {
- __u8 v;
- ::decode(v, bl);
- ::decode(m_pool, bl);
- ::decode(m_seed, bl);
- ::decode(m_preferred, bl);
- }
- void decode_old(bufferlist::iterator& bl) {
- old_pg_t opg;
- ::decode(opg, bl);
- *this = opg;
- }
- void dump(Formatter *f) const;
- static void generate_test_instances(list<pg_t*>& o);
-};
-WRITE_CLASS_ENCODER(pg_t)
-
-inline bool operator<(const pg_t& l, const pg_t& r) {
- return l.pool() < r.pool() ||
- (l.pool() == r.pool() && (l.preferred() < r.preferred() ||
- (l.preferred() == r.preferred() && (l.ps() < r.ps()))));
-}
-inline bool operator<=(const pg_t& l, const pg_t& r) {
- return l.pool() < r.pool() ||
- (l.pool() == r.pool() && (l.preferred() < r.preferred() ||
- (l.preferred() == r.preferred() && (l.ps() <= r.ps()))));
-}
-inline bool operator==(const pg_t& l, const pg_t& r) {
- return l.pool() == r.pool() &&
- l.preferred() == r.preferred() &&
- l.ps() == r.ps();
-}
-inline bool operator!=(const pg_t& l, const pg_t& r) {
- return l.pool() != r.pool() ||
- l.preferred() != r.preferred() ||
- l.ps() != r.ps();
-}
-inline bool operator>(const pg_t& l, const pg_t& r) {
- return l.pool() > r.pool() ||
- (l.pool() == r.pool() && (l.preferred() > r.preferred() ||
- (l.preferred() == r.preferred() && (l.ps() > r.ps()))));
-}
-inline bool operator>=(const pg_t& l, const pg_t& r) {
- return l.pool() > r.pool() ||
- (l.pool() == r.pool() && (l.preferred() > r.preferred() ||
- (l.preferred() == r.preferred() && (l.ps() >= r.ps()))));
-}
-
-ostream& operator<<(ostream& out, const pg_t &pg);
-
-namespace std {
- template<> struct hash< pg_t >
- {
- size_t operator()( const pg_t& x ) const
- {
- static hash<uint32_t> H;
- return H((x.pool() & 0xffffffff) ^ (x.pool() >> 32) ^ x.ps() ^ x.preferred());
- }
- };
-} // namespace std
-
-struct spg_t {
- pg_t pgid;
- shard_id_t shard;
- spg_t() : shard(shard_id_t::NO_SHARD) {}
- spg_t(pg_t pgid, shard_id_t shard) : pgid(pgid), shard(shard) {}
- explicit spg_t(pg_t pgid) : pgid(pgid), shard(shard_id_t::NO_SHARD) {}
- unsigned get_split_bits(unsigned pg_num) const {
- return pgid.get_split_bits(pg_num);
- }
- spg_t get_parent() const {
- return spg_t(pgid.get_parent(), shard);
- }
- ps_t ps() const {
- return pgid.ps();
- }
- uint64_t pool() const {
- return pgid.pool();
- }
- int32_t preferred() const {
- return pgid.preferred();
- }
-
- static const uint8_t calc_name_buf_size = pg_t::calc_name_buf_size + 4; // 36 + len('s') + len("255");
- char *calc_name(char *buf, const char *suffix_backwords) const;
-
- bool parse(const char *s);
- bool parse(const std::string& s) {
- return parse(s.c_str());
- }
- bool is_split(unsigned old_pg_num, unsigned new_pg_num,
- set<spg_t> *pchildren) const {
- set<pg_t> _children;
- set<pg_t> *children = pchildren ? &_children : NULL;
- bool is_split = pgid.is_split(old_pg_num, new_pg_num, children);
- if (pchildren && is_split) {
- for (set<pg_t>::iterator i = _children.begin();
- i != _children.end();
- ++i) {
- pchildren->insert(spg_t(*i, shard));
- }
- }
- return is_split;
- }
- bool is_no_shard() const {
- return shard == shard_id_t::NO_SHARD;
- }
-
- ghobject_t make_pgmeta_oid() const {
- return ghobject_t::make_pgmeta(pgid.pool(), pgid.ps(), shard);
- }
-
- void encode(bufferlist &bl) const {
- ENCODE_START(1, 1, bl);
- ::encode(pgid, bl);
- ::encode(shard, bl);
- ENCODE_FINISH(bl);
- }
- void decode(bufferlist::iterator &bl) {
- DECODE_START(1, bl);
- ::decode(pgid, bl);
- ::decode(shard, bl);
- DECODE_FINISH(bl);
- }
-
- ghobject_t make_temp_ghobject(const string& name) const {
- return ghobject_t(
- hobject_t(object_t(name), "", CEPH_NOSNAP,
- pgid.ps(),
- hobject_t::POOL_TEMP_START - pgid.pool(), ""),
- ghobject_t::NO_GEN,
- shard);
- }
-
- unsigned hash_to_shard(unsigned num_shards) const {
- return ps() % num_shards;
- }
-};
-WRITE_CLASS_ENCODER(spg_t)
-WRITE_EQ_OPERATORS_2(spg_t, pgid, shard)
-WRITE_CMP_OPERATORS_2(spg_t, pgid, shard)
-
-namespace std {
- template<> struct hash< spg_t >
- {
- size_t operator()( const spg_t& x ) const
- {
- static hash<uint32_t> H;
- return H(hash<pg_t>()(x.pgid) ^ x.shard);
- }
- };
-} // namespace std
-
-ostream& operator<<(ostream& out, const spg_t &pg);
-
-// ----------------------
-
-class coll_t {
- enum type_t {
- TYPE_META = 0,
- TYPE_LEGACY_TEMP = 1, /* no longer used */
- TYPE_PG = 2,
- TYPE_PG_TEMP = 3,
- };
- type_t type;
- spg_t pgid;
- uint64_t removal_seq; // note: deprecated, not encoded
-
- char _str_buff[spg_t::calc_name_buf_size];
- char *_str;
-
- void calc_str();
-
- coll_t(type_t t, spg_t p, uint64_t r)
- : type(t), pgid(p), removal_seq(r) {
- calc_str();
- }
-
-public:
- coll_t() : type(TYPE_META), removal_seq(0)
- {
- calc_str();
- }
-
- coll_t(const coll_t& other)
- : type(other.type), pgid(other.pgid), removal_seq(other.removal_seq) {
- calc_str();
- }
-
- explicit coll_t(spg_t pgid)
- : type(TYPE_PG), pgid(pgid), removal_seq(0)
- {
- calc_str();
- }
-
- coll_t& operator=(const coll_t& rhs)
- {
- this->type = rhs.type;
- this->pgid = rhs.pgid;
- this->removal_seq = rhs.removal_seq;
- this->calc_str();
- return *this;
- }
-
- // named constructors
- static coll_t meta() {
- return coll_t();
- }
- static coll_t pg(spg_t p) {
- return coll_t(p);
- }
-
- const std::string to_str() const {
- return string(_str);
- }
- const char *c_str() const {
- return _str;
- }
-
- bool parse(const std::string& s);
-
- int operator<(const coll_t &rhs) const {
- return type < rhs.type ||
- (type == rhs.type && pgid < rhs.pgid);
- }
-
- bool is_meta() const {
- return type == TYPE_META;
- }
- bool is_pg_prefix(spg_t *pgid_) const {
- if (type == TYPE_PG || type == TYPE_PG_TEMP) {
- *pgid_ = pgid;
- return true;
- }
- return false;
- }
- bool is_pg() const {
- return type == TYPE_PG;
- }
- bool is_pg(spg_t *pgid_) const {
- if (type == TYPE_PG) {
- *pgid_ = pgid;
- return true;
- }
- return false;
- }
- bool is_temp() const {
- return type == TYPE_PG_TEMP;
- }
- bool is_temp(spg_t *pgid_) const {
- if (type == TYPE_PG_TEMP) {
- *pgid_ = pgid;
- return true;
- }
- return false;
- }
-
- void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
- size_t encoded_size() const;
-
- inline bool operator==(const coll_t& rhs) const {
- // only compare type if meta
- if (type != rhs.type)
- return false;
- if (type == TYPE_META)
- return true;
- return type == rhs.type && pgid == rhs.pgid;
- }
- inline bool operator!=(const coll_t& rhs) const {
- return !(*this == rhs);
- }
-
- // get a TEMP collection that corresponds to the current collection,
- // which we presume is a pg collection.
- coll_t get_temp() const {
- assert(type == TYPE_PG);
- return coll_t(TYPE_PG_TEMP, pgid, 0);
- }
-
- ghobject_t get_min_hobj() const {
- ghobject_t o;
- switch (type) {
- case TYPE_PG:
- o.hobj.pool = pgid.pool();
- o.set_shard(pgid.shard);
- break;
- case TYPE_META:
- o.hobj.pool = -1;
- break;
- default:
- break;
- }
- return o;
- }
-
- unsigned hash_to_shard(unsigned num_shards) const {
- if (type == TYPE_PG)
- return pgid.hash_to_shard(num_shards);
- return 0; // whatever.
- }
-
- void dump(Formatter *f) const;
- static void generate_test_instances(list<coll_t*>& o);
-};
-
-WRITE_CLASS_ENCODER(coll_t)
-
-inline ostream& operator<<(ostream& out, const coll_t& c) {
- out << c.to_str();
- return out;
-}
-
-namespace std {
- template<> struct hash<coll_t> {
- size_t operator()(const coll_t &c) const {
- size_t h = 0;
- string str(c.to_str());
- std::string::const_iterator end(str.end());
- for (std::string::const_iterator s = str.begin(); s != end; ++s) {
- h += *s;
- h += (h << 10);
- h ^= (h >> 6);
- }
- h += (h << 3);
- h ^= (h >> 11);
- h += (h << 15);
- return h;
- }
- };
-} // namespace std
-
-inline ostream& operator<<(ostream& out, const ceph_object_layout &ol)
-{
- out << pg_t(ol.ol_pgid);
- int su = ol.ol_stripe_unit;
- if (su)
- out << ".su=" << su;
- return out;
-}
-
-
-
-// compound rados version type
-/* WARNING: If add member in eversion_t, please make sure the encode/decode function
- * work well. For little-endian machine, we should make sure there is no padding
- * in 32-bit machine and 64-bit machine.
- */
-class eversion_t {
-public:
- version_t version;
- epoch_t epoch;
- __u32 __pad;
- eversion_t() : version(0), epoch(0), __pad(0) {}
- eversion_t(epoch_t e, version_t v) : version(v), epoch(e), __pad(0) {}
-
- // cppcheck-suppress noExplicitConstructor
- eversion_t(const ceph_eversion& ce) :
- version(ce.version),
- epoch(ce.epoch),
- __pad(0) { }
-
- explicit eversion_t(bufferlist& bl) : __pad(0) { decode(bl); }
-
- static eversion_t max() {
- eversion_t max;
- max.version -= 1;
- max.epoch -= 1;
- return max;
- }
-
- operator ceph_eversion() {
- ceph_eversion c;
- c.epoch = epoch;
- c.version = version;
- return c;
- }
-
- string get_key_name() const;
-
- void encode(bufferlist &bl) const {
-#if defined(CEPH_LITTLE_ENDIAN)
- bl.append((char *)this, sizeof(version_t) + sizeof(epoch_t));
-#else
- ::encode(version, bl);
- ::encode(epoch, bl);
-#endif
- }
- void decode(bufferlist::iterator &bl) {
-#if defined(CEPH_LITTLE_ENDIAN)
- bl.copy(sizeof(version_t) + sizeof(epoch_t), (char *)this);
-#else
- ::decode(version, bl);
- ::decode(epoch, bl);
-#endif
- }
- void decode(bufferlist& bl) {
- bufferlist::iterator p = bl.begin();
- decode(p);
- }
-};
-WRITE_CLASS_ENCODER(eversion_t)
-
-inline bool operator==(const eversion_t& l, const eversion_t& r) {
- return (l.epoch == r.epoch) && (l.version == r.version);
-}
-inline bool operator!=(const eversion_t& l, const eversion_t& r) {
- return (l.epoch != r.epoch) || (l.version != r.version);
-}
-inline bool operator<(const eversion_t& l, const eversion_t& r) {
- return (l.epoch == r.epoch) ? (l.version < r.version):(l.epoch < r.epoch);
-}
-inline bool operator<=(const eversion_t& l, const eversion_t& r) {
- return (l.epoch == r.epoch) ? (l.version <= r.version):(l.epoch <= r.epoch);
-}
-inline bool operator>(const eversion_t& l, const eversion_t& r) {
- return (l.epoch == r.epoch) ? (l.version > r.version):(l.epoch > r.epoch);
-}
-inline bool operator>=(const eversion_t& l, const eversion_t& r) {
- return (l.epoch == r.epoch) ? (l.version >= r.version):(l.epoch >= r.epoch);
-}
-inline ostream& operator<<(ostream& out, const eversion_t& e) {
- return out << e.epoch << "'" << e.version;
-}
-
-/**
- * objectstore_perf_stat_t
- *
- * current perf information about the osd
- */
-struct objectstore_perf_stat_t {
- // cur_op_latency is in ms since double add/sub are not associative
- uint32_t os_commit_latency;
- uint32_t os_apply_latency;
-
- objectstore_perf_stat_t() :
- os_commit_latency(0), os_apply_latency(0) {}
-
- bool operator==(const objectstore_perf_stat_t &r) const {
- return os_commit_latency == r.os_commit_latency &&
- os_apply_latency == r.os_apply_latency;
- }
-
- void add(const objectstore_perf_stat_t &o) {
- os_commit_latency += o.os_commit_latency;
- os_apply_latency += o.os_apply_latency;
- }
- void sub(const objectstore_perf_stat_t &o) {
- os_commit_latency -= o.os_commit_latency;
- os_apply_latency -= o.os_apply_latency;
- }
- void dump(Formatter *f) const;
- void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
- static void generate_test_instances(std::list<objectstore_perf_stat_t*>& o);
-};
-WRITE_CLASS_ENCODER(objectstore_perf_stat_t)
-
-/** osd_stat
- * aggregate stats for an osd
- */
-struct osd_stat_t {
- int64_t kb, kb_used, kb_avail;
- vector<int> hb_peers;
- int32_t snap_trim_queue_len, num_snap_trimming;
-
- pow2_hist_t op_queue_age_hist;
-
- objectstore_perf_stat_t os_perf_stat;
-
- epoch_t up_from = 0;
- uint64_t seq = 0;
-
- uint32_t num_pgs = 0;
-
- osd_stat_t() : kb(0), kb_used(0), kb_avail(0),
- snap_trim_queue_len(0), num_snap_trimming(0) {}
-
- void add(const osd_stat_t& o) {
- kb += o.kb;
- kb_used += o.kb_used;
- kb_avail += o.kb_avail;
- snap_trim_queue_len += o.snap_trim_queue_len;
- num_snap_trimming += o.num_snap_trimming;
- op_queue_age_hist.add(o.op_queue_age_hist);
- os_perf_stat.add(o.os_perf_stat);
- num_pgs += o.num_pgs;
- }
- void sub(const osd_stat_t& o) {
- kb -= o.kb;
- kb_used -= o.kb_used;
- kb_avail -= o.kb_avail;
- snap_trim_queue_len -= o.snap_trim_queue_len;
- num_snap_trimming -= o.num_snap_trimming;
- op_queue_age_hist.sub(o.op_queue_age_hist);
- os_perf_stat.sub(o.os_perf_stat);
- num_pgs -= o.num_pgs;
- }
-
- void dump(Formatter *f) const;
- void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
- static void generate_test_instances(std::list<osd_stat_t*>& o);
-};
-WRITE_CLASS_ENCODER(osd_stat_t)
-
-inline bool operator==(const osd_stat_t& l, const osd_stat_t& r) {
- return l.kb == r.kb &&
- l.kb_used == r.kb_used &&
- l.kb_avail == r.kb_avail &&
- l.snap_trim_queue_len == r.snap_trim_queue_len &&
- l.num_snap_trimming == r.num_snap_trimming &&
- l.hb_peers == r.hb_peers &&
- l.op_queue_age_hist == r.op_queue_age_hist &&
- l.os_perf_stat == r.os_perf_stat &&
- l.num_pgs == r.num_pgs;
-}
-inline bool operator!=(const osd_stat_t& l, const osd_stat_t& r) {
- return !(l == r);
-}
-
-
-
-inline ostream& operator<<(ostream& out, const osd_stat_t& s) {
- return out << "osd_stat(" << kb_t(s.kb_used) << " used, "
- << kb_t(s.kb_avail) << " avail, "
- << kb_t(s.kb) << " total, "
- << "peers " << s.hb_peers
- << " op hist " << s.op_queue_age_hist.h
- << ")";
-}
-
-
-/*
- * pg states
- */
-#define PG_STATE_CREATING (1<<0) // creating
-#define PG_STATE_ACTIVE (1<<1) // i am active. (primary: replicas too)
-#define PG_STATE_CLEAN (1<<2) // peers are complete, clean of stray replicas.
-#define PG_STATE_DOWN (1<<4) // a needed replica is down, PG offline
-//#define PG_STATE_REPLAY (1<<5) // crashed, waiting for replay
-//#define PG_STATE_STRAY (1<<6) // i must notify the primary i exist.
-//#define PG_STATE_SPLITTING (1<<7) // i am splitting
-#define PG_STATE_SCRUBBING (1<<8) // scrubbing
-//#define PG_STATE_SCRUBQ (1<<9) // queued for scrub
-#define PG_STATE_DEGRADED (1<<10) // pg contains objects with reduced redundancy
-#define PG_STATE_INCONSISTENT (1<<11) // pg replicas are inconsistent (but shouldn't be)
-#define PG_STATE_PEERING (1<<12) // pg is (re)peering
-#define PG_STATE_REPAIR (1<<13) // pg should repair on next scrub
-#define PG_STATE_RECOVERING (1<<14) // pg is recovering/migrating objects
-#define PG_STATE_BACKFILL_WAIT (1<<15) // [active] reserving backfill
-#define PG_STATE_INCOMPLETE (1<<16) // incomplete content, peering failed.
-#define PG_STATE_STALE (1<<17) // our state for this pg is stale, unknown.
-#define PG_STATE_REMAPPED (1<<18) // pg is explicitly remapped to different OSDs than CRUSH
-#define PG_STATE_DEEP_SCRUB (1<<19) // deep scrub: check CRC32 on files
-#define PG_STATE_BACKFILLING (1<<20) // [active] backfilling pg content
-#define PG_STATE_BACKFILL_TOOFULL (1<<21) // backfill can't proceed: too full
-#define PG_STATE_RECOVERY_WAIT (1<<22) // waiting for recovery reservations
-#define PG_STATE_UNDERSIZED (1<<23) // pg acting < pool size
-#define PG_STATE_ACTIVATING (1<<24) // pg is peered but not yet active
-#define PG_STATE_PEERED (1<<25) // peered, cannot go active, can recover
-#define PG_STATE_SNAPTRIM (1<<26) // trimming snaps
-#define PG_STATE_SNAPTRIM_WAIT (1<<27) // queued to trim snaps
-#define PG_STATE_RECOVERY_TOOFULL (1<<28) // recovery can't proceed: too full
-#define PG_STATE_SNAPTRIM_ERROR (1<<29) // error stopped trimming snaps
-#define PG_STATE_FORCED_RECOVERY (1<<30) // force recovery of this pg before any other
-#define PG_STATE_FORCED_BACKFILL (1<<31) // force backfill of this pg before any other
-
-std::string pg_state_string(int state);
-std::string pg_vector_string(const vector<int32_t> &a);
-boost::optional<uint64_t> pg_string_state(const std::string& state);
-
-
-/*
- * pool_snap_info_t
- *
- * attributes for a single pool snapshot.
- */
-struct pool_snap_info_t {
- snapid_t snapid;
- utime_t stamp;
- string name;
-
- void dump(Formatter *f) const;
- void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& bl);
- static void generate_test_instances(list<pool_snap_info_t*>& o);
-};
-WRITE_CLASS_ENCODER_FEATURES(pool_snap_info_t)
-
-inline ostream& operator<<(ostream& out, const pool_snap_info_t& si) {
- return out << si.snapid << '(' << si.name << ' ' << si.stamp << ')';
-}
-
-
-/*
- * pool_opts_t
- *
- * pool options.
- */
-
-class pool_opts_t {
-public:
- enum key_t {
- SCRUB_MIN_INTERVAL,
- SCRUB_MAX_INTERVAL,
- DEEP_SCRUB_INTERVAL,
- RECOVERY_PRIORITY,
- RECOVERY_OP_PRIORITY,
- SCRUB_PRIORITY,
- COMPRESSION_MODE,
- COMPRESSION_ALGORITHM,
- COMPRESSION_REQUIRED_RATIO,
- COMPRESSION_MAX_BLOB_SIZE,
- COMPRESSION_MIN_BLOB_SIZE,
- CSUM_TYPE,
- CSUM_MAX_BLOCK,
- CSUM_MIN_BLOCK,
- };
-
- enum type_t {
- STR,
- INT,
- DOUBLE,
- };
-
- struct opt_desc_t {
- key_t key;
- type_t type;
-
- opt_desc_t(key_t k, type_t t) : key(k), type(t) {}
-
- bool operator==(const opt_desc_t& rhs) const {
- return key == rhs.key && type == rhs.type;
- }
- };
-
- typedef boost::variant<std::string,int,double> value_t;
-
- static bool is_opt_name(const std::string& name);
- static opt_desc_t get_opt_desc(const std::string& name);
-
- pool_opts_t() : opts() {}
-
- bool is_set(key_t key) const;
-
- template<typename T>
- void set(key_t key, const T &val) {
- value_t value = val;
- opts[key] = value;
- }
-
- template<typename T>
- bool get(key_t key, T *val) const {
- opts_t::const_iterator i = opts.find(key);
- if (i == opts.end()) {
- return false;
- }
- *val = boost::get<T>(i->second);
- return true;
- }
-
- const value_t& get(key_t key) const;
-
- bool unset(key_t key);
-
- void dump(const std::string& name, Formatter *f) const;
-
- void dump(Formatter *f) const;
- void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
-
-private:
- typedef std::map<key_t, value_t> opts_t;
- opts_t opts;
-
- friend ostream& operator<<(ostream& out, const pool_opts_t& opts);
-};
-WRITE_CLASS_ENCODER(pool_opts_t)
-
-/*
- * pg_pool
- */
-struct pg_pool_t {
- static const char *APPLICATION_NAME_CEPHFS;
- static const char *APPLICATION_NAME_RBD;
- static const char *APPLICATION_NAME_RGW;
-
- enum {
- TYPE_REPLICATED = 1, // replication
- //TYPE_RAID4 = 2, // raid4 (never implemented)
- TYPE_ERASURE = 3, // erasure-coded
- };
- static const char *get_type_name(int t) {
- switch (t) {
- case TYPE_REPLICATED: return "replicated";
- //case TYPE_RAID4: return "raid4";
- case TYPE_ERASURE: return "erasure";
- default: return "???";
- }
- }
- const char *get_type_name() const {
- return get_type_name(type);
- }
-
- enum {
- FLAG_HASHPSPOOL = 1<<0, // hash pg seed and pool together (instead of adding)
- FLAG_FULL = 1<<1, // pool is full
- FLAG_EC_OVERWRITES = 1<<2, // enables overwrites, once enabled, cannot be disabled
- FLAG_INCOMPLETE_CLONES = 1<<3, // may have incomplete clones (bc we are/were an overlay)
- FLAG_NODELETE = 1<<4, // pool can't be deleted
- FLAG_NOPGCHANGE = 1<<5, // pool's pg and pgp num can't be changed
- FLAG_NOSIZECHANGE = 1<<6, // pool's size and min size can't be changed
- FLAG_WRITE_FADVISE_DONTNEED = 1<<7, // write mode with LIBRADOS_OP_FLAG_FADVISE_DONTNEED
- FLAG_NOSCRUB = 1<<8, // block periodic scrub
- FLAG_NODEEP_SCRUB = 1<<9, // block periodic deep-scrub
- FLAG_FULL_NO_QUOTA = 1<<10, // pool is currently running out of quota, will set FLAG_FULL too
- FLAG_NEARFULL = 1<<11, // pool is nearfull
- FLAG_BACKFILLFULL = 1<<12, // pool is backfillfull
- };
-
- static const char *get_flag_name(int f) {
- switch (f) {
- case FLAG_HASHPSPOOL: return "hashpspool";
- case FLAG_FULL: return "full";
- case FLAG_EC_OVERWRITES: return "ec_overwrites";
- case FLAG_INCOMPLETE_CLONES: return "incomplete_clones";
- case FLAG_NODELETE: return "nodelete";
- case FLAG_NOPGCHANGE: return "nopgchange";
- case FLAG_NOSIZECHANGE: return "nosizechange";
- case FLAG_WRITE_FADVISE_DONTNEED: return "write_fadvise_dontneed";
- case FLAG_NOSCRUB: return "noscrub";
- case FLAG_NODEEP_SCRUB: return "nodeep-scrub";
- case FLAG_FULL_NO_QUOTA: return "full_no_quota";
- case FLAG_NEARFULL: return "nearfull";
- case FLAG_BACKFILLFULL: return "backfillfull";
- default: return "???";
- }
- }
- static string get_flags_string(uint64_t f) {
- string s;
- for (unsigned n=0; f && n<64; ++n) {
- if (f & (1ull << n)) {
- if (s.length())
- s += ",";
- s += get_flag_name(1ull << n);
- }
- }
- return s;
- }
- string get_flags_string() const {
- return get_flags_string(flags);
- }
- static uint64_t get_flag_by_name(const string& name) {
- if (name == "hashpspool")
- return FLAG_HASHPSPOOL;
- if (name == "full")
- return FLAG_FULL;
- if (name == "ec_overwrites")
- return FLAG_EC_OVERWRITES;
- if (name == "incomplete_clones")
- return FLAG_INCOMPLETE_CLONES;
- if (name == "nodelete")
- return FLAG_NODELETE;
- if (name == "nopgchange")
- return FLAG_NOPGCHANGE;
- if (name == "nosizechange")
- return FLAG_NOSIZECHANGE;
- if (name == "write_fadvise_dontneed")
- return FLAG_WRITE_FADVISE_DONTNEED;
- if (name == "noscrub")
- return FLAG_NOSCRUB;
- if (name == "nodeep-scrub")
- return FLAG_NODEEP_SCRUB;
- if (name == "full_no_quota")
- return FLAG_FULL_NO_QUOTA;
- if (name == "nearfull")
- return FLAG_NEARFULL;
- if (name == "backfillfull")
- return FLAG_BACKFILLFULL;
- return 0;
- }
-
- /// converts the acting/up vector to a set of pg shards
- void convert_to_pg_shards(const vector<int> &from, set<pg_shard_t>* to) const;
-
- typedef enum {
- CACHEMODE_NONE = 0, ///< no caching
- CACHEMODE_WRITEBACK = 1, ///< write to cache, flush later
- CACHEMODE_FORWARD = 2, ///< forward if not in cache
- CACHEMODE_READONLY = 3, ///< handle reads, forward writes [not strongly consistent]
- CACHEMODE_READFORWARD = 4, ///< forward reads, write to cache flush later
- CACHEMODE_READPROXY = 5, ///< proxy reads, write to cache flush later
- CACHEMODE_PROXY = 6, ///< proxy if not in cache
- } cache_mode_t;
- static const char *get_cache_mode_name(cache_mode_t m) {
- switch (m) {
- case CACHEMODE_NONE: return "none";
- case CACHEMODE_WRITEBACK: return "writeback";
- case CACHEMODE_FORWARD: return "forward";
- case CACHEMODE_READONLY: return "readonly";
- case CACHEMODE_READFORWARD: return "readforward";
- case CACHEMODE_READPROXY: return "readproxy";
- case CACHEMODE_PROXY: return "proxy";
- default: return "unknown";
- }
- }
- static cache_mode_t get_cache_mode_from_str(const string& s) {
- if (s == "none")
- return CACHEMODE_NONE;
- if (s == "writeback")
- return CACHEMODE_WRITEBACK;
- if (s == "forward")
- return CACHEMODE_FORWARD;
- if (s == "readonly")
- return CACHEMODE_READONLY;
- if (s == "readforward")
- return CACHEMODE_READFORWARD;
- if (s == "readproxy")
- return CACHEMODE_READPROXY;
- if (s == "proxy")
- return CACHEMODE_PROXY;
- return (cache_mode_t)-1;
- }
- const char *get_cache_mode_name() const {
- return get_cache_mode_name(cache_mode);
- }
- bool cache_mode_requires_hit_set() const {
- switch (cache_mode) {
- case CACHEMODE_NONE:
- case CACHEMODE_FORWARD:
- case CACHEMODE_READONLY:
- case CACHEMODE_PROXY:
- return false;
- case CACHEMODE_WRITEBACK:
- case CACHEMODE_READFORWARD:
- case CACHEMODE_READPROXY:
- return true;
- default:
- assert(0 == "implement me");
- }
- }
-
- uint64_t flags; ///< FLAG_*
- __u8 type; ///< TYPE_*
- __u8 size, min_size; ///< number of osds in each pg
- __u8 crush_rule; ///< crush placement rule
- __u8 object_hash; ///< hash mapping object name to ps
-private:
- __u32 pg_num, pgp_num; ///< number of pgs
-
-
-public:
- map<string,string> properties; ///< OBSOLETE
- string erasure_code_profile; ///< name of the erasure code profile in OSDMap
- epoch_t last_change; ///< most recent epoch changed, exclusing snapshot changes
- epoch_t last_force_op_resend; ///< last epoch that forced clients to resend
- /// last epoch that forced clients to resend (pre-luminous clients only)
- epoch_t last_force_op_resend_preluminous;
- snapid_t snap_seq; ///< seq for per-pool snapshot
- epoch_t snap_epoch; ///< osdmap epoch of last snap
- uint64_t auid; ///< who owns the pg
- __u32 crash_replay_interval; ///< seconds to allow clients to replay ACKed but unCOMMITted requests
-
- uint64_t quota_max_bytes; ///< maximum number of bytes for this pool
- uint64_t quota_max_objects; ///< maximum number of objects for this pool
-
- /*
- * Pool snaps (global to this pool). These define a SnapContext for
- * the pool, unless the client manually specifies an alternate
- * context.
- */
- map<snapid_t, pool_snap_info_t> snaps;
- /*
- * Alternatively, if we are defining non-pool snaps (e.g. via the
- * Ceph MDS), we must track @removed_snaps (since @snaps is not
- * used). Snaps and removed_snaps are to be used exclusive of each
- * other!
- */
- interval_set<snapid_t> removed_snaps;
-
- unsigned pg_num_mask, pgp_num_mask;
-
- set<uint64_t> tiers; ///< pools that are tiers of us
- int64_t tier_of; ///< pool for which we are a tier
- // Note that write wins for read+write ops
- int64_t read_tier; ///< pool/tier for objecter to direct reads to
- int64_t write_tier; ///< pool/tier for objecter to direct writes to
- cache_mode_t cache_mode; ///< cache pool mode
-
- bool is_tier() const { return tier_of >= 0; }
- bool has_tiers() const { return !tiers.empty(); }
- void clear_tier() {
- tier_of = -1;
- clear_read_tier();
- clear_write_tier();
- clear_tier_tunables();
- }
- bool has_read_tier() const { return read_tier >= 0; }
- void clear_read_tier() { read_tier = -1; }
- bool has_write_tier() const { return write_tier >= 0; }
- void clear_write_tier() { write_tier = -1; }
- void clear_tier_tunables() {
- if (cache_mode != CACHEMODE_NONE)
- flags |= FLAG_INCOMPLETE_CLONES;
- cache_mode = CACHEMODE_NONE;
-
- target_max_bytes = 0;
- target_max_objects = 0;
- cache_target_dirty_ratio_micro = 0;
- cache_target_dirty_high_ratio_micro = 0;
- cache_target_full_ratio_micro = 0;
- hit_set_params = HitSet::Params();
- hit_set_period = 0;
- hit_set_count = 0;
- hit_set_grade_decay_rate = 0;
- hit_set_search_last_n = 0;
- grade_table.resize(0);
- }
-
- uint64_t target_max_bytes; ///< tiering: target max pool size
- uint64_t target_max_objects; ///< tiering: target max pool size
-
- uint32_t cache_target_dirty_ratio_micro; ///< cache: fraction of target to leave dirty
- uint32_t cache_target_dirty_high_ratio_micro; ///<cache: fraction of target to flush with high speed
- uint32_t cache_target_full_ratio_micro; ///< cache: fraction of target to fill before we evict in earnest
-
- uint32_t cache_min_flush_age; ///< minimum age (seconds) before we can flush
- uint32_t cache_min_evict_age; ///< minimum age (seconds) before we can evict
-
- HitSet::Params hit_set_params; ///< The HitSet params to use on this pool
- uint32_t hit_set_period; ///< periodicity of HitSet segments (seconds)
- uint32_t hit_set_count; ///< number of periods to retain
- bool use_gmt_hitset; ///< use gmt to name the hitset archive object
- uint32_t min_read_recency_for_promote; ///< minimum number of HitSet to check before promote on read
- uint32_t min_write_recency_for_promote; ///< minimum number of HitSet to check before promote on write
- uint32_t hit_set_grade_decay_rate; ///< current hit_set has highest priority on objects
- ///temperature count,the follow hit_set's priority decay
- ///by this params than pre hit_set
- uint32_t hit_set_search_last_n; ///<accumulate atmost N hit_sets for temperature
-
- uint32_t stripe_width; ///< erasure coded stripe size in bytes
-
- uint64_t expected_num_objects; ///< expected number of objects on this pool, a value of 0 indicates
- ///< user does not specify any expected value
- bool fast_read; ///< whether turn on fast read on the pool or not
-
- pool_opts_t opts; ///< options
-
- /// application -> key/value metadata
- map<string, std::map<string, string>> application_metadata;
-
-private:
- vector<uint32_t> grade_table;
-
-public:
- uint32_t get_grade(unsigned i) const {
- if (grade_table.size() <= i)
- return 0;
- return grade_table[i];
- }
- void calc_grade_table() {
- unsigned v = 1000000;
- grade_table.resize(hit_set_count);
- for (unsigned i = 0; i < hit_set_count; i++) {
- v = v * (1 - (hit_set_grade_decay_rate / 100.0));
- grade_table[i] = v;
- }
- }
-
- pg_pool_t()
- : flags(0), type(0), size(0), min_size(0),
- crush_rule(0), object_hash(0),
- pg_num(0), pgp_num(0),
- last_change(0),
- last_force_op_resend(0),
- last_force_op_resend_preluminous(0),
- snap_seq(0), snap_epoch(0),
- auid(0),
- crash_replay_interval(0),
- quota_max_bytes(0), quota_max_objects(0),
- pg_num_mask(0), pgp_num_mask(0),
- tier_of(-1), read_tier(-1), write_tier(-1),
- cache_mode(CACHEMODE_NONE),
- target_max_bytes(0), target_max_objects(0),
- cache_target_dirty_ratio_micro(0),
- cache_target_dirty_high_ratio_micro(0),
- cache_target_full_ratio_micro(0),
- cache_min_flush_age(0),
- cache_min_evict_age(0),
- hit_set_params(),
- hit_set_period(0),
- hit_set_count(0),
- use_gmt_hitset(true),
- min_read_recency_for_promote(0),
- min_write_recency_for_promote(0),
- hit_set_grade_decay_rate(0),
- hit_set_search_last_n(0),
- stripe_width(0),
- expected_num_objects(0),
- fast_read(false),
- opts()
- { }
-
- void dump(Formatter *f) const;
-
- uint64_t get_flags() const { return flags; }
- bool has_flag(uint64_t f) const { return flags & f; }
- void set_flag(uint64_t f) { flags |= f; }
- void unset_flag(uint64_t f) { flags &= ~f; }
-
- bool ec_pool() const {
- return type == TYPE_ERASURE;
- }
- bool require_rollback() const {
- return ec_pool();
- }
-
- /// true if incomplete clones may be present
- bool allow_incomplete_clones() const {
- return cache_mode != CACHEMODE_NONE || has_flag(FLAG_INCOMPLETE_CLONES);
- }
-
- unsigned get_type() const { return type; }
- unsigned get_size() const { return size; }
- unsigned get_min_size() const { return min_size; }
- int get_crush_rule() const { return crush_rule; }
- int get_object_hash() const { return object_hash; }
- const char *get_object_hash_name() const {
- return ceph_str_hash_name(get_object_hash());
- }
- epoch_t get_last_change() const { return last_change; }
- epoch_t get_last_force_op_resend() const { return last_force_op_resend; }
- epoch_t get_last_force_op_resend_preluminous() const {
- return last_force_op_resend_preluminous;
- }
- epoch_t get_snap_epoch() const { return snap_epoch; }
- snapid_t get_snap_seq() const { return snap_seq; }
- uint64_t get_auid() const { return auid; }
- unsigned get_crash_replay_interval() const { return crash_replay_interval; }
-
- void set_snap_seq(snapid_t s) { snap_seq = s; }
- void set_snap_epoch(epoch_t e) { snap_epoch = e; }
-
- void set_stripe_width(uint32_t s) { stripe_width = s; }
- uint32_t get_stripe_width() const { return stripe_width; }
-
- bool is_replicated() const { return get_type() == TYPE_REPLICATED; }
- bool is_erasure() const { return get_type() == TYPE_ERASURE; }
-
- bool supports_omap() const {
- return !(get_type() == TYPE_ERASURE);
- }
-
- bool requires_aligned_append() const {
- return is_erasure() && !has_flag(FLAG_EC_OVERWRITES);
- }
- uint64_t required_alignment() const { return stripe_width; }
-
- bool allows_ecoverwrites() const {
- return has_flag(FLAG_EC_OVERWRITES);
- }
-
- bool can_shift_osds() const {
- switch (get_type()) {
- case TYPE_REPLICATED:
- return true;
- case TYPE_ERASURE:
- return false;
- default:
- assert(0 == "unhandled pool type");
- }
- }
-
- unsigned get_pg_num() const { return pg_num; }
- unsigned get_pgp_num() const { return pgp_num; }
-
- unsigned get_pg_num_mask() const { return pg_num_mask; }
- unsigned get_pgp_num_mask() const { return pgp_num_mask; }
-
- // if pg_num is not a multiple of two, pgs are not equally sized.
- // return, for a given pg, the fraction (denominator) of the total
- // pool size that it represents.
- unsigned get_pg_num_divisor(pg_t pgid) const;
-
- void set_pg_num(int p) {
- pg_num = p;
- calc_pg_masks();
- }
- void set_pgp_num(int p) {
- pgp_num = p;
- calc_pg_masks();
- }
-
- void set_quota_max_bytes(uint64_t m) {
- quota_max_bytes = m;
- }
- uint64_t get_quota_max_bytes() {
- return quota_max_bytes;
- }
-
- void set_quota_max_objects(uint64_t m) {
- quota_max_objects = m;
- }
- uint64_t get_quota_max_objects() {
- return quota_max_objects;
- }
-
- void set_last_force_op_resend(uint64_t t) {
- last_force_op_resend = t;
- last_force_op_resend_preluminous = t;
- }
-
- void calc_pg_masks();
-
- /*
- * we have two snap modes:
- * - pool global snaps
- * - snap existence/non-existence defined by snaps[] and snap_seq
- * - user managed snaps
- * - removal governed by removed_snaps
- *
- * we know which mode we're using based on whether removed_snaps is empty.
- * If nothing has been created, both functions report false.
- */
- bool is_pool_snaps_mode() const;
- bool is_unmanaged_snaps_mode() const;
- bool is_removed_snap(snapid_t s) const;
-
- /*
- * build set of known-removed sets from either pool snaps or
- * explicit removed_snaps set.
- */
- void build_removed_snaps(interval_set<snapid_t>& rs) const;
- snapid_t snap_exists(const char *s) const;
- void add_snap(const char *n, utime_t stamp);
- void add_unmanaged_snap(uint64_t& snapid);
- void remove_snap(snapid_t s);
- void remove_unmanaged_snap(snapid_t s);
-
- SnapContext get_snap_context() const;
-
- /// hash a object name+namespace key to a hash position
- uint32_t hash_key(const string& key, const string& ns) const;
-
- /// round a hash position down to a pg num
- uint32_t raw_hash_to_pg(uint32_t v) const;
-
- /*
- * map a raw pg (with full precision ps) into an actual pg, for storage
- */
- pg_t raw_pg_to_pg(pg_t pg) const;
-
- /*
- * map raw pg (full precision ps) into a placement seed. include
- * pool id in that value so that different pools don't use the same
- * seeds.
- */
- ps_t raw_pg_to_pps(pg_t pg) const;
-
- /// choose a random hash position within a pg
- uint32_t get_random_pg_position(pg_t pgid, uint32_t seed) const;
-
- void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& bl);
-
- static void generate_test_instances(list<pg_pool_t*>& o);
-};
-WRITE_CLASS_ENCODER_FEATURES(pg_pool_t)
-
-ostream& operator<<(ostream& out, const pg_pool_t& p);
-
-
-/**
- * a summation of object stats
- *
- * This is just a container for object stats; we don't know what for.
- *
- * If you add members in object_stat_sum_t, you should make sure there are
- * not padding among these members.
- * You should also modify the padding_check function.
-
- */
-struct object_stat_sum_t {
- /**************************************************************************
- * WARNING: be sure to update operator==, floor, and split when
- * adding/removing fields!
- **************************************************************************/
- int64_t num_bytes; // in bytes
- int64_t num_objects;
- int64_t num_object_clones;
- int64_t num_object_copies; // num_objects * num_replicas
- int64_t num_objects_missing_on_primary;
- int64_t num_objects_degraded;
- int64_t num_objects_unfound;
- int64_t num_rd;
- int64_t num_rd_kb;
- int64_t num_wr;
- int64_t num_wr_kb;
- int64_t num_scrub_errors; // total deep and shallow scrub errors
- int64_t num_objects_recovered;
- int64_t num_bytes_recovered;
- int64_t num_keys_recovered;
- int64_t num_shallow_scrub_errors;
- int64_t num_deep_scrub_errors;
- int64_t num_objects_dirty;
- int64_t num_whiteouts;
- int64_t num_objects_omap;
- int64_t num_objects_hit_set_archive;
- int64_t num_objects_misplaced;
- int64_t num_bytes_hit_set_archive;
- int64_t num_flush;
- int64_t num_flush_kb;
- int64_t num_evict;
- int64_t num_evict_kb;
- int64_t num_promote;
- int32_t num_flush_mode_high; // 1 when in high flush mode, otherwise 0
- int32_t num_flush_mode_low; // 1 when in low flush mode, otherwise 0
- int32_t num_evict_mode_some; // 1 when in evict some mode, otherwise 0
- int32_t num_evict_mode_full; // 1 when in evict full mode, otherwise 0
- int64_t num_objects_pinned;
- int64_t num_objects_missing;
- int64_t num_legacy_snapsets; ///< upper bound on pre-luminous-style SnapSets
-
- object_stat_sum_t()
- : num_bytes(0),
- num_objects(0), num_object_clones(0), num_object_copies(0),
- num_objects_missing_on_primary(0), num_objects_degraded(0),
- num_objects_unfound(0),
- num_rd(0), num_rd_kb(0), num_wr(0), num_wr_kb(0),
- num_scrub_errors(0),
- num_objects_recovered(0),
- num_bytes_recovered(0),
- num_keys_recovered(0),
- num_shallow_scrub_errors(0),
- num_deep_scrub_errors(0),
- num_objects_dirty(0),
- num_whiteouts(0),
- num_objects_omap(0),
- num_objects_hit_set_archive(0),
- num_objects_misplaced(0),
- num_bytes_hit_set_archive(0),
- num_flush(0),
- num_flush_kb(0),
- num_evict(0),
- num_evict_kb(0),
- num_promote(0),
- num_flush_mode_high(0), num_flush_mode_low(0),
- num_evict_mode_some(0), num_evict_mode_full(0),
- num_objects_pinned(0),
- num_objects_missing(0),
- num_legacy_snapsets(0)
- {}
-
- void floor(int64_t f) {
-#define FLOOR(x) if (x < f) x = f
- FLOOR(num_bytes);
- FLOOR(num_objects);
- FLOOR(num_object_clones);
- FLOOR(num_object_copies);
- FLOOR(num_objects_missing_on_primary);
- FLOOR(num_objects_missing);
- FLOOR(num_objects_degraded);
- FLOOR(num_objects_misplaced);
- FLOOR(num_objects_unfound);
- FLOOR(num_rd);
- FLOOR(num_rd_kb);
- FLOOR(num_wr);
- FLOOR(num_wr_kb);
- FLOOR(num_scrub_errors);
- FLOOR(num_shallow_scrub_errors);
- FLOOR(num_deep_scrub_errors);
- FLOOR(num_objects_recovered);
- FLOOR(num_bytes_recovered);
- FLOOR(num_keys_recovered);
- FLOOR(num_objects_dirty);
- FLOOR(num_whiteouts);
- FLOOR(num_objects_omap);
- FLOOR(num_objects_hit_set_archive);
- FLOOR(num_bytes_hit_set_archive);
- FLOOR(num_flush);
- FLOOR(num_flush_kb);
- FLOOR(num_evict);
- FLOOR(num_evict_kb);
- FLOOR(num_promote);
- FLOOR(num_flush_mode_high);
- FLOOR(num_flush_mode_low);
- FLOOR(num_evict_mode_some);
- FLOOR(num_evict_mode_full);
- FLOOR(num_objects_pinned);
- FLOOR(num_legacy_snapsets);
-#undef FLOOR
- }
-
- void split(vector<object_stat_sum_t> &out) const {
-#define SPLIT(PARAM) \
- for (unsigned i = 0; i < out.size(); ++i) { \
- out[i].PARAM = PARAM / out.size(); \
- if (i < (PARAM % out.size())) { \
- out[i].PARAM++; \
- } \
- }
-#define SPLIT_PRESERVE_NONZERO(PARAM) \
- for (unsigned i = 0; i < out.size(); ++i) { \
- if (PARAM) \
- out[i].PARAM = 1 + PARAM / out.size(); \
- else \
- out[i].PARAM = 0; \
- }
-
- SPLIT(num_bytes);
- SPLIT(num_objects);
- SPLIT(num_object_clones);
- SPLIT(num_object_copies);
- SPLIT(num_objects_missing_on_primary);
- SPLIT(num_objects_missing);
- SPLIT(num_objects_degraded);
- SPLIT(num_objects_misplaced);
- SPLIT(num_objects_unfound);
- SPLIT(num_rd);
- SPLIT(num_rd_kb);
- SPLIT(num_wr);
- SPLIT(num_wr_kb);
- SPLIT(num_scrub_errors);
- SPLIT(num_shallow_scrub_errors);
- SPLIT(num_deep_scrub_errors);
- SPLIT(num_objects_recovered);
- SPLIT(num_bytes_recovered);
- SPLIT(num_keys_recovered);
- SPLIT(num_objects_dirty);
- SPLIT(num_whiteouts);
- SPLIT(num_objects_omap);
- SPLIT(num_objects_hit_set_archive);
- SPLIT(num_bytes_hit_set_archive);
- SPLIT(num_flush);
- SPLIT(num_flush_kb);
- SPLIT(num_evict);
- SPLIT(num_evict_kb);
- SPLIT(num_promote);
- SPLIT(num_flush_mode_high);
- SPLIT(num_flush_mode_low);
- SPLIT(num_evict_mode_some);
- SPLIT(num_evict_mode_full);
- SPLIT(num_objects_pinned);
- SPLIT_PRESERVE_NONZERO(num_legacy_snapsets);
-#undef SPLIT
-#undef SPLIT_PRESERVE_NONZERO
- }
-
- void clear() {
- memset(this, 0, sizeof(*this));
- }
-
- void calc_copies(int nrep) {
- num_object_copies = nrep * num_objects;
- }
-
- bool is_zero() const {
- return mem_is_zero((char*)this, sizeof(*this));
- }
-
- void add(const object_stat_sum_t& o);
- void sub(const object_stat_sum_t& o);
-
- void dump(Formatter *f) const;
- void padding_check() {
- static_assert(
- sizeof(object_stat_sum_t) ==
- sizeof(num_bytes) +
- sizeof(num_objects) +
- sizeof(num_object_clones) +
- sizeof(num_object_copies) +
- sizeof(num_objects_missing_on_primary) +
- sizeof(num_objects_degraded) +
- sizeof(num_objects_unfound) +
- sizeof(num_rd) +
- sizeof(num_rd_kb) +
- sizeof(num_wr) +
- sizeof(num_wr_kb) +
- sizeof(num_scrub_errors) +
- sizeof(num_objects_recovered) +
- sizeof(num_bytes_recovered) +
- sizeof(num_keys_recovered) +
- sizeof(num_shallow_scrub_errors) +
- sizeof(num_deep_scrub_errors) +
- sizeof(num_objects_dirty) +
- sizeof(num_whiteouts) +
- sizeof(num_objects_omap) +
- sizeof(num_objects_hit_set_archive) +
- sizeof(num_objects_misplaced) +
- sizeof(num_bytes_hit_set_archive) +
- sizeof(num_flush) +
- sizeof(num_flush_kb) +
- sizeof(num_evict) +
- sizeof(num_evict_kb) +
- sizeof(num_promote) +
- sizeof(num_flush_mode_high) +
- sizeof(num_flush_mode_low) +
- sizeof(num_evict_mode_some) +
- sizeof(num_evict_mode_full) +
- sizeof(num_objects_pinned) +
- sizeof(num_objects_missing) +
- sizeof(num_legacy_snapsets)
- ,
- "object_stat_sum_t have padding");
- }
- void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
- static void generate_test_instances(list<object_stat_sum_t*>& o);
-};
-WRITE_CLASS_ENCODER(object_stat_sum_t)
-
-bool operator==(const object_stat_sum_t& l, const object_stat_sum_t& r);
-
-/**
- * a collection of object stat sums
- *
- * This is a collection of stat sums over different categories.
- */
-struct object_stat_collection_t {
- /**************************************************************************
- * WARNING: be sure to update the operator== when adding/removing fields! *
- **************************************************************************/
- object_stat_sum_t sum;
-
- void calc_copies(int nrep) {
- sum.calc_copies(nrep);
- }
-
- void dump(Formatter *f) const;
- void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
- static void generate_test_instances(list<object_stat_collection_t*>& o);
-
- bool is_zero() const {
- return sum.is_zero();
- }
-
- void clear() {
- sum.clear();
- }
-
- void floor(int64_t f) {
- sum.floor(f);
- }
-
- void add(const object_stat_sum_t& o) {
- sum.add(o);
- }
-
- void add(const object_stat_collection_t& o) {
- sum.add(o.sum);
- }
- void sub(const object_stat_collection_t& o) {
- sum.sub(o.sum);
- }
-};
-WRITE_CLASS_ENCODER(object_stat_collection_t)
-
-inline bool operator==(const object_stat_collection_t& l,
- const object_stat_collection_t& r) {
- return l.sum == r.sum;
-}
-
-
-/** pg_stat
- * aggregate stats for a single PG.
- */
-struct pg_stat_t {
- /**************************************************************************
- * WARNING: be sure to update the operator== when adding/removing fields! *
- **************************************************************************/
- eversion_t version;
- version_t reported_seq; // sequence number
- epoch_t reported_epoch; // epoch of this report
- __u32 state;
- utime_t last_fresh; // last reported
- utime_t last_change; // new state != previous state
- utime_t last_active; // state & PG_STATE_ACTIVE
- utime_t last_peered; // state & PG_STATE_ACTIVE || state & PG_STATE_PEERED
- utime_t last_clean; // state & PG_STATE_CLEAN
- utime_t last_unstale; // (state & PG_STATE_STALE) == 0
- utime_t last_undegraded; // (state & PG_STATE_DEGRADED) == 0
- utime_t last_fullsized; // (state & PG_STATE_UNDERSIZED) == 0
-
- eversion_t log_start; // (log_start,version]
- eversion_t ondisk_log_start; // there may be more on disk
-
- epoch_t created;
- epoch_t last_epoch_clean;
- pg_t parent;
- __u32 parent_split_bits;
-
- eversion_t last_scrub;
- eversion_t last_deep_scrub;
- utime_t last_scrub_stamp;
- utime_t last_deep_scrub_stamp;
- utime_t last_clean_scrub_stamp;
-
- object_stat_collection_t stats;
-
- int64_t log_size;
- int64_t ondisk_log_size; // >= active_log_size
-
- vector<int32_t> up, acting;
- epoch_t mapping_epoch;
-
- vector<int32_t> blocked_by; ///< osds on which the pg is blocked
-
- utime_t last_became_active;
- utime_t last_became_peered;
-
- /// up, acting primaries
- int32_t up_primary;
- int32_t acting_primary;
-
- bool stats_invalid:1;
- /// true if num_objects_dirty is not accurate (because it was not
- /// maintained starting from pool creation)
- bool dirty_stats_invalid:1;
- bool omap_stats_invalid:1;
- bool hitset_stats_invalid:1;
- bool hitset_bytes_stats_invalid:1;
- bool pin_stats_invalid:1;
-
- pg_stat_t()
- : reported_seq(0),
- reported_epoch(0),
- state(0),
- created(0), last_epoch_clean(0),
- parent_split_bits(0),
- log_size(0), ondisk_log_size(0),
- mapping_epoch(0),
- up_primary(-1),
- acting_primary(-1),
- stats_invalid(false),
- dirty_stats_invalid(false),
- omap_stats_invalid(false),
- hitset_stats_invalid(false),
- hitset_bytes_stats_invalid(false),
- pin_stats_invalid(false)
- { }
-
- epoch_t get_effective_last_epoch_clean() const {
- if (state & PG_STATE_CLEAN) {
- // we are clean as of this report, and should thus take the
- // reported epoch
- return reported_epoch;
- } else {
- return last_epoch_clean;
- }
- }
-
- pair<epoch_t, version_t> get_version_pair() const {
- return make_pair(reported_epoch, reported_seq);
- }
-
- void floor(int64_t f) {
- stats.floor(f);
- if (log_size < f)
- log_size = f;
- if (ondisk_log_size < f)
- ondisk_log_size = f;
- }
-
- void add(const pg_stat_t& o) {
- stats.add(o.stats);
- log_size += o.log_size;
- ondisk_log_size += o.ondisk_log_size;
- }
- void sub(const pg_stat_t& o) {
- stats.sub(o.stats);
- log_size -= o.log_size;
- ondisk_log_size -= o.ondisk_log_size;
- }
-
- bool is_acting_osd(int32_t osd, bool primary) const;
- void dump(Formatter *f) const;
- void dump_brief(Formatter *f) const;
- void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
- static void generate_test_instances(list<pg_stat_t*>& o);
-};
-WRITE_CLASS_ENCODER(pg_stat_t)
-
-bool operator==(const pg_stat_t& l, const pg_stat_t& r);
-
-/*
- * summation over an entire pool
- */
-struct pool_stat_t {
- object_stat_collection_t stats;
- int64_t log_size;
- int64_t ondisk_log_size; // >= active_log_size
- int32_t up; ///< number of up replicas or shards
- int32_t acting; ///< number of acting replicas or shards
-
- pool_stat_t() : log_size(0), ondisk_log_size(0), up(0), acting(0)
- { }
-
- void floor(int64_t f) {
- stats.floor(f);
- if (log_size < f)
- log_size = f;
- if (ondisk_log_size < f)
- ondisk_log_size = f;
- if (up < f)
- up = f;
- if (acting < f)
- acting = f;
- }
-
- void add(const pg_stat_t& o) {
- stats.add(o.stats);
- log_size += o.log_size;
- ondisk_log_size += o.ondisk_log_size;
- up += o.up.size();
- acting += o.acting.size();
- }
- void sub(const pg_stat_t& o) {
- stats.sub(o.stats);
- log_size -= o.log_size;
- ondisk_log_size -= o.ondisk_log_size;
- up -= o.up.size();
- acting -= o.acting.size();
- }
-
- bool is_zero() const {
- return (stats.is_zero() &&
- log_size == 0 &&
- ondisk_log_size == 0 &&
- up == 0 &&
- acting == 0);
- }
-
- void dump(Formatter *f) const;
- void encode(bufferlist &bl, uint64_t features) const;
- void decode(bufferlist::iterator &bl);
- static void generate_test_instances(list<pool_stat_t*>& o);
-};
-WRITE_CLASS_ENCODER_FEATURES(pool_stat_t)
-
-
-// -----------------------------------------
-
-/**
- * pg_hit_set_info_t - information about a single recorded HitSet
- *
- * Track basic metadata about a HitSet, like the nubmer of insertions
- * and the time range it covers.
- */
-struct pg_hit_set_info_t {
- utime_t begin, end; ///< time interval
- eversion_t version; ///< version this HitSet object was written
- bool using_gmt; ///< use gmt for creating the hit_set archive object name
-
- friend bool operator==(const pg_hit_set_info_t& l,
- const pg_hit_set_info_t& r) {
- return
- l.begin == r.begin &&
- l.end == r.end &&
- l.version == r.version &&
- l.using_gmt == r.using_gmt;
- }
-
- explicit pg_hit_set_info_t(bool using_gmt = true)
- : using_gmt(using_gmt) {}
-
- void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<pg_hit_set_info_t*>& o);
-};
-WRITE_CLASS_ENCODER(pg_hit_set_info_t)
-
-/**
- * pg_hit_set_history_t - information about a history of hitsets
- *
- * Include information about the currently accumulating hit set as well
- * as archived/historical ones.
- */
-struct pg_hit_set_history_t {
- eversion_t current_last_update; ///< last version inserted into current set
- list<pg_hit_set_info_t> history; ///< archived sets, sorted oldest -> newest
-
- friend bool operator==(const pg_hit_set_history_t& l,
- const pg_hit_set_history_t& r) {
- return
- l.current_last_update == r.current_last_update &&
- l.history == r.history;
- }
-
- void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<pg_hit_set_history_t*>& o);
-};
-WRITE_CLASS_ENCODER(pg_hit_set_history_t)
-
-
-// -----------------------------------------
-
-/**
- * pg_history_t - information about recent pg peering/mapping history
- *
- * This is aggressively shared between OSDs to bound the amount of past
- * history they need to worry about.
- */
-struct pg_history_t {
- epoch_t epoch_created; // epoch in which *pg* was created (pool or pg)
- epoch_t epoch_pool_created; // epoch in which *pool* was created
- // (note: may be pg creation epoch for
- // pre-luminous clusters)
- epoch_t last_epoch_started; // lower bound on last epoch started (anywhere, not necessarily locally)
- epoch_t last_interval_started; // first epoch of last_epoch_started interval
- epoch_t last_epoch_clean; // lower bound on last epoch the PG was completely clean.
- epoch_t last_interval_clean; // first epoch of last_epoch_clean interval
- epoch_t last_epoch_split; // as parent or child
- epoch_t last_epoch_marked_full; // pool or cluster
-
- /**
- * In the event of a map discontinuity, same_*_since may reflect the first
- * map the osd has seen in the new map sequence rather than the actual start
- * of the interval. This is ok since a discontinuity at epoch e means there
- * must have been a clean interval between e and now and that we cannot be
- * in the active set during the interval containing e.
- */
- epoch_t same_up_since; // same acting set since
- epoch_t same_interval_since; // same acting AND up set since
- epoch_t same_primary_since; // same primary at least back through this epoch.
-
- eversion_t last_scrub;
- eversion_t last_deep_scrub;
- utime_t last_scrub_stamp;
- utime_t last_deep_scrub_stamp;
- utime_t last_clean_scrub_stamp;
-
- friend bool operator==(const pg_history_t& l, const pg_history_t& r) {
- return
- l.epoch_created == r.epoch_created &&
- l.epoch_pool_created == r.epoch_pool_created &&
- l.last_epoch_started == r.last_epoch_started &&
- l.last_interval_started == r.last_interval_started &&
- l.last_epoch_clean == r.last_epoch_clean &&
- l.last_interval_clean == r.last_interval_clean &&
- l.last_epoch_split == r.last_epoch_split &&
- l.last_epoch_marked_full == r.last_epoch_marked_full &&
- l.same_up_since == r.same_up_since &&
- l.same_interval_since == r.same_interval_since &&
- l.same_primary_since == r.same_primary_since &&
- l.last_scrub == r.last_scrub &&
- l.last_deep_scrub == r.last_deep_scrub &&
- l.last_scrub_stamp == r.last_scrub_stamp &&
- l.last_deep_scrub_stamp == r.last_deep_scrub_stamp &&
- l.last_clean_scrub_stamp == r.last_clean_scrub_stamp;
- }
-
- pg_history_t()
- : epoch_created(0),
- epoch_pool_created(0),
- last_epoch_started(0),
- last_interval_started(0),
- last_epoch_clean(0),
- last_interval_clean(0),
- last_epoch_split(0),
- last_epoch_marked_full(0),
- same_up_since(0), same_interval_since(0), same_primary_since(0) {}
-
- bool merge(const pg_history_t &other) {
- // Here, we only update the fields which cannot be calculated from the OSDmap.
- bool modified = false;
- if (epoch_created < other.epoch_created) {
- epoch_created = other.epoch_created;
- modified = true;
- }
- if (epoch_pool_created < other.epoch_pool_created) {
- // FIXME: for jewel compat only; this should either be 0 or always the
- // same value across all pg instances.
- epoch_pool_created = other.epoch_pool_created;
- modified = true;
- }
- if (last_epoch_started < other.last_epoch_started) {
- last_epoch_started = other.last_epoch_started;
- modified = true;
- }
- if (last_interval_started < other.last_interval_started) {
- last_interval_started = other.last_interval_started;
- modified = true;
- }
- if (last_epoch_clean < other.last_epoch_clean) {
- last_epoch_clean = other.last_epoch_clean;
- modified = true;
- }
- if (last_interval_clean < other.last_interval_clean) {
- last_interval_clean = other.last_interval_clean;
- modified = true;
- }
- if (last_epoch_split < other.last_epoch_split) {
- last_epoch_split = other.last_epoch_split;
- modified = true;
- }
- if (last_epoch_marked_full < other.last_epoch_marked_full) {
- last_epoch_marked_full = other.last_epoch_marked_full;
- modified = true;
- }
- if (other.last_scrub > last_scrub) {
- last_scrub = other.last_scrub;
- modified = true;
- }
- if (other.last_scrub_stamp > last_scrub_stamp) {
- last_scrub_stamp = other.last_scrub_stamp;
- modified = true;
- }
- if (other.last_deep_scrub > last_deep_scrub) {
- last_deep_scrub = other.last_deep_scrub;
- modified = true;
- }
- if (other.last_deep_scrub_stamp > last_deep_scrub_stamp) {
- last_deep_scrub_stamp = other.last_deep_scrub_stamp;
- modified = true;
- }
- if (other.last_clean_scrub_stamp > last_clean_scrub_stamp) {
- last_clean_scrub_stamp = other.last_clean_scrub_stamp;
- modified = true;
- }
- return modified;
- }
-
- void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& p);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<pg_history_t*>& o);
-};
-WRITE_CLASS_ENCODER(pg_history_t)
-
-inline ostream& operator<<(ostream& out, const pg_history_t& h) {
- return out << "ec=" << h.epoch_created << "/" << h.epoch_pool_created
- << " lis/c " << h.last_interval_started
- << "/" << h.last_interval_clean
- << " les/c/f " << h.last_epoch_started << "/" << h.last_epoch_clean
- << "/" << h.last_epoch_marked_full
- << " " << h.same_up_since
- << "/" << h.same_interval_since
- << "/" << h.same_primary_since;
-}
-
-
-/**
- * pg_info_t - summary of PG statistics.
- *
- * some notes:
- * - last_complete implies we have all objects that existed as of that
- * stamp, OR a newer object, OR have already applied a later delete.
- * - if last_complete >= log.bottom, then we know pg contents thru log.head.
- * otherwise, we have no idea what the pg is supposed to contain.
- */
-struct pg_info_t {
- spg_t pgid;
- eversion_t last_update; ///< last object version applied to store.
- eversion_t last_complete; ///< last version pg was complete through.
- epoch_t last_epoch_started; ///< last epoch at which this pg started on this osd
- epoch_t last_interval_started; ///< first epoch of last_epoch_started interval
-
- version_t last_user_version; ///< last user object version applied to store
-
- eversion_t log_tail; ///< oldest log entry.
-
- hobject_t last_backfill; ///< objects >= this and < last_complete may be missing
- bool last_backfill_bitwise; ///< true if last_backfill reflects a bitwise (vs nibblewise) sort
-
- interval_set<snapid_t> purged_snaps;
-
- pg_stat_t stats;
-
- pg_history_t history;
- pg_hit_set_history_t hit_set;
-
- friend bool operator==(const pg_info_t& l, const pg_info_t& r) {
- return
- l.pgid == r.pgid &&
- l.last_update == r.last_update &&
- l.last_complete == r.last_complete &&
- l.last_epoch_started == r.last_epoch_started &&
- l.last_interval_started == r.last_interval_started &&
- l.last_user_version == r.last_user_version &&
- l.log_tail == r.log_tail &&
- l.last_backfill == r.last_backfill &&
- l.last_backfill_bitwise == r.last_backfill_bitwise &&
- l.purged_snaps == r.purged_snaps &&
- l.stats == r.stats &&
- l.history == r.history &&
- l.hit_set == r.hit_set;
- }
-
- pg_info_t()
- : last_epoch_started(0),
- last_interval_started(0),
- last_user_version(0),
- last_backfill(hobject_t::get_max()),
- last_backfill_bitwise(false)
- { }
- // cppcheck-suppress noExplicitConstructor
- pg_info_t(spg_t p)
- : pgid(p),
- last_epoch_started(0),
- last_interval_started(0),
- last_user_version(0),
- last_backfill(hobject_t::get_max()),
- last_backfill_bitwise(false)
- { }
-
- void set_last_backfill(hobject_t pos) {
- last_backfill = pos;
- last_backfill_bitwise = true;
- }
-
- bool is_empty() const { return last_update.version == 0; }
- bool dne() const { return history.epoch_created == 0; }
-
- bool is_incomplete() const { return !last_backfill.is_max(); }
-
- void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& p);
- void dump(Formatter *f) const;
- bool overlaps_with(const pg_info_t &oinfo) const {
- return last_update > oinfo.log_tail ?
- oinfo.last_update >= log_tail :
- last_update >= oinfo.log_tail;
- }
- static void generate_test_instances(list<pg_info_t*>& o);
-};
-WRITE_CLASS_ENCODER(pg_info_t)
-
-inline ostream& operator<<(ostream& out, const pg_info_t& pgi)
-{
- out << pgi.pgid << "(";
- if (pgi.dne())
- out << " DNE";
- if (pgi.is_empty())
- out << " empty";
- else {
- out << " v " << pgi.last_update;
- if (pgi.last_complete != pgi.last_update)
- out << " lc " << pgi.last_complete;
- out << " (" << pgi.log_tail << "," << pgi.last_update << "]";
- }
- if (pgi.is_incomplete())
- out << " lb " << pgi.last_backfill
- << (pgi.last_backfill_bitwise ? " (bitwise)" : " (NIBBLEWISE)");
- //out << " c " << pgi.epoch_created;
- out << " local-lis/les=" << pgi.last_interval_started
- << "/" << pgi.last_epoch_started;
- out << " n=" << pgi.stats.stats.sum.num_objects;
- out << " " << pgi.history
- << ")";
- return out;
-}
-
-/**
- * pg_fast_info_t - common pg_info_t fields
- *
- * These are the fields of pg_info_t (and children) that are updated for
- * most IO operations.
- *
- * ** WARNING **
- * Because we rely on these fields to be applied to the normal
- * info struct, adding a new field here that is not also new in info
- * means that we must set an incompat OSD feature bit!
- */
-struct pg_fast_info_t {
- eversion_t last_update;
- eversion_t last_complete;
- version_t last_user_version;
- struct { // pg_stat_t stats
- eversion_t version;
- version_t reported_seq;
- utime_t last_fresh;
- utime_t last_active;
- utime_t last_peered;
- utime_t last_clean;
- utime_t last_unstale;
- utime_t last_undegraded;
- utime_t last_fullsized;
- int64_t log_size; // (also ondisk_log_size, which has the same value)
- struct { // object_stat_collection_t stats;
- struct { // objct_stat_sum_t sum
- int64_t num_bytes; // in bytes
- int64_t num_objects;
- int64_t num_object_copies;
- int64_t num_rd;
- int64_t num_rd_kb;
- int64_t num_wr;
- int64_t num_wr_kb;
- int64_t num_objects_dirty;
- } sum;
- } stats;
- } stats;
-
- void populate_from(const pg_info_t& info) {
- last_update = info.last_update;
- last_complete = info.last_complete;
- last_user_version = info.last_user_version;
- stats.version = info.stats.version;
- stats.reported_seq = info.stats.reported_seq;
- stats.last_fresh = info.stats.last_fresh;
- stats.last_active = info.stats.last_active;
- stats.last_peered = info.stats.last_peered;
- stats.last_clean = info.stats.last_clean;
- stats.last_unstale = info.stats.last_unstale;
- stats.last_undegraded = info.stats.last_undegraded;
- stats.last_fullsized = info.stats.last_fullsized;
- stats.log_size = info.stats.log_size;
- stats.stats.sum.num_bytes = info.stats.stats.sum.num_bytes;
- stats.stats.sum.num_objects = info.stats.stats.sum.num_objects;
- stats.stats.sum.num_object_copies = info.stats.stats.sum.num_object_copies;
- stats.stats.sum.num_rd = info.stats.stats.sum.num_rd;
- stats.stats.sum.num_rd_kb = info.stats.stats.sum.num_rd_kb;
- stats.stats.sum.num_wr = info.stats.stats.sum.num_wr;
- stats.stats.sum.num_wr_kb = info.stats.stats.sum.num_wr_kb;
- stats.stats.sum.num_objects_dirty = info.stats.stats.sum.num_objects_dirty;
- }
-
- bool try_apply_to(pg_info_t* info) {
- if (last_update <= info->last_update)
- return false;
- info->last_update = last_update;
- info->last_complete = last_complete;
- info->last_user_version = last_user_version;
- info->stats.version = stats.version;
- info->stats.reported_seq = stats.reported_seq;
- info->stats.last_fresh = stats.last_fresh;
- info->stats.last_active = stats.last_active;
- info->stats.last_peered = stats.last_peered;
- info->stats.last_clean = stats.last_clean;
- info->stats.last_unstale = stats.last_unstale;
- info->stats.last_undegraded = stats.last_undegraded;
- info->stats.last_fullsized = stats.last_fullsized;
- info->stats.log_size = stats.log_size;
- info->stats.ondisk_log_size = stats.log_size;
- info->stats.stats.sum.num_bytes = stats.stats.sum.num_bytes;
- info->stats.stats.sum.num_objects = stats.stats.sum.num_objects;
- info->stats.stats.sum.num_object_copies = stats.stats.sum.num_object_copies;
- info->stats.stats.sum.num_rd = stats.stats.sum.num_rd;
- info->stats.stats.sum.num_rd_kb = stats.stats.sum.num_rd_kb;
- info->stats.stats.sum.num_wr = stats.stats.sum.num_wr;
- info->stats.stats.sum.num_wr_kb = stats.stats.sum.num_wr_kb;
- info->stats.stats.sum.num_objects_dirty = stats.stats.sum.num_objects_dirty;
- return true;
- }
-
- void encode(bufferlist& bl) const {
- ENCODE_START(1, 1, bl);
- ::encode(last_update, bl);
- ::encode(last_complete, bl);
- ::encode(last_user_version, bl);
- ::encode(stats.version, bl);
- ::encode(stats.reported_seq, bl);
- ::encode(stats.last_fresh, bl);
- ::encode(stats.last_active, bl);
- ::encode(stats.last_peered, bl);
- ::encode(stats.last_clean, bl);
- ::encode(stats.last_unstale, bl);
- ::encode(stats.last_undegraded, bl);
- ::encode(stats.last_fullsized, bl);
- ::encode(stats.log_size, bl);
- ::encode(stats.stats.sum.num_bytes, bl);
- ::encode(stats.stats.sum.num_objects, bl);
- ::encode(stats.stats.sum.num_object_copies, bl);
- ::encode(stats.stats.sum.num_rd, bl);
- ::encode(stats.stats.sum.num_rd_kb, bl);
- ::encode(stats.stats.sum.num_wr, bl);
- ::encode(stats.stats.sum.num_wr_kb, bl);
- ::encode(stats.stats.sum.num_objects_dirty, bl);
- ENCODE_FINISH(bl);
- }
- void decode(bufferlist::iterator& p) {
- DECODE_START(1, p);
- ::decode(last_update, p);
- ::decode(last_complete, p);
- ::decode(last_user_version, p);
- ::decode(stats.version, p);
- ::decode(stats.reported_seq, p);
- ::decode(stats.last_fresh, p);
- ::decode(stats.last_active, p);
- ::decode(stats.last_peered, p);
- ::decode(stats.last_clean, p);
- ::decode(stats.last_unstale, p);
- ::decode(stats.last_undegraded, p);
- ::decode(stats.last_fullsized, p);
- ::decode(stats.log_size, p);
- ::decode(stats.stats.sum.num_bytes, p);
- ::decode(stats.stats.sum.num_objects, p);
- ::decode(stats.stats.sum.num_object_copies, p);
- ::decode(stats.stats.sum.num_rd, p);
- ::decode(stats.stats.sum.num_rd_kb, p);
- ::decode(stats.stats.sum.num_wr, p);
- ::decode(stats.stats.sum.num_wr_kb, p);
- ::decode(stats.stats.sum.num_objects_dirty, p);
- DECODE_FINISH(p);
- }
-};
-WRITE_CLASS_ENCODER(pg_fast_info_t)
-
-
-struct pg_notify_t {
- epoch_t query_epoch;
- epoch_t epoch_sent;
- pg_info_t info;
- shard_id_t to;
- shard_id_t from;
- pg_notify_t() :
- query_epoch(0), epoch_sent(0), to(shard_id_t::NO_SHARD),
- from(shard_id_t::NO_SHARD) {}
- pg_notify_t(
- shard_id_t to,
- shard_id_t from,
- epoch_t query_epoch,
- epoch_t epoch_sent,
- const pg_info_t &info)
- : query_epoch(query_epoch),
- epoch_sent(epoch_sent),
- info(info), to(to), from(from) {
- assert(from == info.pgid.shard);
- }
- void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &p);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<pg_notify_t*> &o);
-};
-WRITE_CLASS_ENCODER(pg_notify_t)
-ostream &operator<<(ostream &lhs, const pg_notify_t ¬ify);
-
-
-class OSDMap;
-/**
- * PastIntervals -- information needed to determine the PriorSet and
- * the might_have_unfound set
- */
-class PastIntervals {
-public:
- struct pg_interval_t {
- vector<int32_t> up, acting;
- epoch_t first, last;
- bool maybe_went_rw;
- int32_t primary;
- int32_t up_primary;
-
- pg_interval_t()
- : first(0), last(0),
- maybe_went_rw(false),
- primary(-1),
- up_primary(-1)
- {}
-
- pg_interval_t(
- vector<int32_t> &&up,
- vector<int32_t> &&acting,
- epoch_t first,
- epoch_t last,
- bool maybe_went_rw,
- int32_t primary,
- int32_t up_primary)
- : up(up), acting(acting), first(first), last(last),
- maybe_went_rw(maybe_went_rw), primary(primary), up_primary(up_primary)
- {}
-
- void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<pg_interval_t*>& o);
- };
-
- PastIntervals() = default;
- PastIntervals(bool ec_pool, const OSDMap &osdmap) : PastIntervals() {
- update_type_from_map(ec_pool, osdmap);
- }
- PastIntervals(bool ec_pool, bool compact) : PastIntervals() {
- update_type(ec_pool, compact);
- }
- PastIntervals(PastIntervals &&rhs) = default;
- PastIntervals &operator=(PastIntervals &&rhs) = default;
-
- PastIntervals(const PastIntervals &rhs);
- PastIntervals &operator=(const PastIntervals &rhs);
-
- class interval_rep {
- public:
- virtual size_t size() const = 0;
- virtual bool empty() const = 0;
- virtual void clear() = 0;
- virtual pair<epoch_t, epoch_t> get_bounds() const = 0;
- virtual set<pg_shard_t> get_all_participants(
- bool ec_pool) const = 0;
- virtual void add_interval(bool ec_pool, const pg_interval_t &interval) = 0;
- virtual unique_ptr<interval_rep> clone() const = 0;
- virtual ostream &print(ostream &out) const = 0;
- virtual void encode(bufferlist &bl) const = 0;
- virtual void decode(bufferlist::iterator &bl) = 0;
- virtual void dump(Formatter *f) const = 0;
- virtual bool is_classic() const = 0;
- virtual void iterate_mayberw_back_to(
- bool ec_pool,
- epoch_t les,
- std::function<void(epoch_t, const set<pg_shard_t> &)> &&f) const = 0;
-
- virtual bool has_full_intervals() const { return false; }
- virtual void iterate_all_intervals(
- std::function<void(const pg_interval_t &)> &&f) const {
- assert(!has_full_intervals());
- assert(0 == "not valid for this implementation");
- }
-
- virtual ~interval_rep() {}
- };
- friend class pi_simple_rep;
- friend class pi_compact_rep;
-private:
-
- unique_ptr<interval_rep> past_intervals;
-
- PastIntervals(interval_rep *rep) : past_intervals(rep) {}
-
-public:
- void add_interval(bool ec_pool, const pg_interval_t &interval) {
- assert(past_intervals);
- return past_intervals->add_interval(ec_pool, interval);
- }
-
- bool is_classic() const {
- assert(past_intervals);
- return past_intervals->is_classic();
- }
-
- void encode(bufferlist &bl) const {
- ENCODE_START(1, 1, bl);
- if (past_intervals) {
- __u8 type = is_classic() ? 1 : 2;
- ::encode(type, bl);
- past_intervals->encode(bl);
- } else {
- ::encode((__u8)0, bl);
- }
- ENCODE_FINISH(bl);
- }
- void encode_classic(bufferlist &bl) const {
- if (past_intervals) {
- assert(past_intervals->is_classic());
- past_intervals->encode(bl);
- } else {
- // it's a map<>
- ::encode((uint32_t)0, bl);
- }
- }
-
- void decode(bufferlist::iterator &bl);
- void decode_classic(bufferlist::iterator &bl);
-
- void dump(Formatter *f) const {
- assert(past_intervals);
- past_intervals->dump(f);
- }
- static void generate_test_instances(list<PastIntervals *> & o);
-
- /**
- * Determines whether there is an interval change
- */
- static bool is_new_interval(
- int old_acting_primary,
- int new_acting_primary,
- const vector<int> &old_acting,
- const vector<int> &new_acting,
- int old_up_primary,
- int new_up_primary,
- const vector<int> &old_up,
- const vector<int> &new_up,
- int old_size,
- int new_size,
- int old_min_size,
- int new_min_size,
- unsigned old_pg_num,
- unsigned new_pg_num,
- bool old_sort_bitwise,
- bool new_sort_bitwise,
- bool old_recovery_deletes,
- bool new_recovery_deletes,
- pg_t pgid
- );
-
- /**
- * Determines whether there is an interval change
- */
- static bool is_new_interval(
- int old_acting_primary, ///< [in] primary as of lastmap
- int new_acting_primary, ///< [in] primary as of lastmap
- const vector<int> &old_acting, ///< [in] acting as of lastmap
- const vector<int> &new_acting, ///< [in] acting as of osdmap
- int old_up_primary, ///< [in] up primary of lastmap
- int new_up_primary, ///< [in] up primary of osdmap
- const vector<int> &old_up, ///< [in] up as of lastmap
- const vector<int> &new_up, ///< [in] up as of osdmap
- ceph::shared_ptr<const OSDMap> osdmap, ///< [in] current map
- ceph::shared_ptr<const OSDMap> lastmap, ///< [in] last map
- pg_t pgid ///< [in] pgid for pg
- );
-
- /**
- * Integrates a new map into *past_intervals, returns true
- * if an interval was closed out.
- */
- static bool check_new_interval(
- int old_acting_primary, ///< [in] primary as of lastmap
- int new_acting_primary, ///< [in] primary as of osdmap
- const vector<int> &old_acting, ///< [in] acting as of lastmap
- const vector<int> &new_acting, ///< [in] acting as of osdmap
- int old_up_primary, ///< [in] up primary of lastmap
- int new_up_primary, ///< [in] up primary of osdmap
- const vector<int> &old_up, ///< [in] up as of lastmap
- const vector<int> &new_up, ///< [in] up as of osdmap
- epoch_t same_interval_since, ///< [in] as of osdmap
- epoch_t last_epoch_clean, ///< [in] current
- ceph::shared_ptr<const OSDMap> osdmap, ///< [in] current map
- ceph::shared_ptr<const OSDMap> lastmap, ///< [in] last map
- pg_t pgid, ///< [in] pgid for pg
- IsPGRecoverablePredicate *could_have_gone_active, /// [in] predicate whether the pg can be active
- PastIntervals *past_intervals, ///< [out] intervals
- ostream *out = 0 ///< [out] debug ostream
- );
-
- friend ostream& operator<<(ostream& out, const PastIntervals &i);
-
- template <typename F>
- void iterate_mayberw_back_to(
- bool ec_pool,
- epoch_t les,
- F &&f) const {
- assert(past_intervals);
- past_intervals->iterate_mayberw_back_to(ec_pool, les, std::forward<F>(f));
- }
- void clear() {
- assert(past_intervals);
- past_intervals->clear();
- }
-
- /**
- * Should return a value which gives an indication of the amount
- * of state contained
- */
- size_t size() const {
- assert(past_intervals);
- return past_intervals->size();
- }
-
- bool empty() const {
- assert(past_intervals);
- return past_intervals->empty();
- }
-
- void swap(PastIntervals &other) {
- using std::swap;
- swap(other.past_intervals, past_intervals);
- }
-
- /**
- * Return all shards which have been in the acting set back to the
- * latest epoch to which we have trimmed except for pg_whoami
- */
- set<pg_shard_t> get_might_have_unfound(
- pg_shard_t pg_whoami,
- bool ec_pool) const {
- assert(past_intervals);
- auto ret = past_intervals->get_all_participants(ec_pool);
- ret.erase(pg_whoami);
- return ret;
- }
-
- /**
- * Return all shards which we might want to talk to for peering
- */
- set<pg_shard_t> get_all_probe(
- bool ec_pool) const {
- assert(past_intervals);
- return past_intervals->get_all_participants(ec_pool);
- }
-
- /* Return the set of epochs [start, end) represented by the
- * past_interval set.
- */
- pair<epoch_t, epoch_t> get_bounds() const {
- assert(past_intervals);
- return past_intervals->get_bounds();
- }
-
- enum osd_state_t {
- UP,
- DOWN,
- DNE,
- LOST
- };
- struct PriorSet {
- bool ec_pool = false;
- set<pg_shard_t> probe; /// current+prior OSDs we need to probe.
- set<int> down; /// down osds that would normally be in @a probe and might be interesting.
- map<int, epoch_t> blocked_by; /// current lost_at values for any OSDs in cur set for which (re)marking them lost would affect cur set
-
- bool pg_down = false; /// some down osds are included in @a cur; the DOWN pg state bit should be set.
- unique_ptr<IsPGRecoverablePredicate> pcontdec;
-
- PriorSet() = default;
- PriorSet(PriorSet &&) = default;
- PriorSet &operator=(PriorSet &&) = default;
-
- PriorSet &operator=(const PriorSet &) = delete;
- PriorSet(const PriorSet &) = delete;
-
- bool operator==(const PriorSet &rhs) const {
- return (ec_pool == rhs.ec_pool) &&
- (probe == rhs.probe) &&
- (down == rhs.down) &&
- (blocked_by == rhs.blocked_by) &&
- (pg_down == rhs.pg_down);
- }
-
- bool affected_by_map(
- const OSDMap &osdmap,
- const DoutPrefixProvider *dpp) const;
-
- // For verifying tests
- PriorSet(
- bool ec_pool,
- set<pg_shard_t> probe,
- set<int> down,
- map<int, epoch_t> blocked_by,
- bool pg_down,
- IsPGRecoverablePredicate *pcontdec)
- : ec_pool(ec_pool), probe(probe), down(down), blocked_by(blocked_by),
- pg_down(pg_down), pcontdec(pcontdec) {}
-
- private:
- template <typename F>
- PriorSet(
- const PastIntervals &past_intervals,
- bool ec_pool,
- epoch_t last_epoch_started,
- IsPGRecoverablePredicate *c,
- F f,
- const vector<int> &up,
- const vector<int> &acting,
- const DoutPrefixProvider *dpp);
-
- friend class PastIntervals;
- };
-
- void update_type(bool ec_pool, bool compact);
- void update_type_from_map(bool ec_pool, const OSDMap &osdmap);
-
- template <typename... Args>
- PriorSet get_prior_set(Args&&... args) const {
- return PriorSet(*this, std::forward<Args>(args)...);
- }
-};
-WRITE_CLASS_ENCODER(PastIntervals)
-
-ostream& operator<<(ostream& out, const PastIntervals::pg_interval_t& i);
-ostream& operator<<(ostream& out, const PastIntervals &i);
-ostream& operator<<(ostream& out, const PastIntervals::PriorSet &i);
-
-template <typename F>
-PastIntervals::PriorSet::PriorSet(
- const PastIntervals &past_intervals,
- bool ec_pool,
- epoch_t last_epoch_started,
- IsPGRecoverablePredicate *c,
- F f,
- const vector<int> &up,
- const vector<int> &acting,
- const DoutPrefixProvider *dpp)
- : ec_pool(ec_pool), pg_down(false), pcontdec(c)
-{
- /*
- * We have to be careful to gracefully deal with situations like
- * so. Say we have a power outage or something that takes out both
- * OSDs, but the monitor doesn't mark them down in the same epoch.
- * The history may look like
- *
- * 1: A B
- * 2: B
- * 3: let's say B dies for good, too (say, from the power spike)
- * 4: A
- *
- * which makes it look like B may have applied updates to the PG
- * that we need in order to proceed. This sucks...
- *
- * To minimize the risk of this happening, we CANNOT go active if
- * _any_ OSDs in the prior set are down until we send an MOSDAlive
- * to the monitor such that the OSDMap sets osd_up_thru to an epoch.
- * Then, we have something like
- *
- * 1: A B
- * 2: B up_thru[B]=0
- * 3:
- * 4: A
- *
- * -> we can ignore B, bc it couldn't have gone active (alive_thru
- * still 0).
- *
- * or,
- *
- * 1: A B
- * 2: B up_thru[B]=0
- * 3: B up_thru[B]=2
- * 4:
- * 5: A
- *
- * -> we must wait for B, bc it was alive through 2, and could have
- * written to the pg.
- *
- * If B is really dead, then an administrator will need to manually
- * intervene by marking the OSD as "lost."
- */
-
- // Include current acting and up nodes... not because they may
- // contain old data (this interval hasn't gone active, obviously),
- // but because we want their pg_info to inform choose_acting(), and
- // so that we know what they do/do not have explicitly before
- // sending them any new info/logs/whatever.
- for (unsigned i = 0; i < acting.size(); i++) {
- if (acting[i] != 0x7fffffff /* CRUSH_ITEM_NONE, can't import crush.h here */)
- probe.insert(pg_shard_t(acting[i], ec_pool ? shard_id_t(i) : shard_id_t::NO_SHARD));
- }
- // It may be possible to exclude the up nodes, but let's keep them in
- // there for now.
- for (unsigned i = 0; i < up.size(); i++) {
- if (up[i] != 0x7fffffff /* CRUSH_ITEM_NONE, can't import crush.h here */)
- probe.insert(pg_shard_t(up[i], ec_pool ? shard_id_t(i) : shard_id_t::NO_SHARD));
- }
-
- set<pg_shard_t> all_probe = past_intervals.get_all_probe(ec_pool);
- ldpp_dout(dpp, 10) << "build_prior all_probe " << all_probe << dendl;
- for (auto &&i: all_probe) {
- switch (f(0, i.osd, nullptr)) {
- case UP: {
- probe.insert(i);
- break;
- }
- case DNE:
- case LOST:
- case DOWN: {
- down.insert(i.osd);
- break;
- }
- }
- }
-
- past_intervals.iterate_mayberw_back_to(
- ec_pool,
- last_epoch_started,
- [&](epoch_t start, const set<pg_shard_t> &acting) {
- ldpp_dout(dpp, 10) << "build_prior maybe_rw interval:" << start
- << ", acting: " << acting << dendl;
-
- // look at candidate osds during this interval. each falls into
- // one of three categories: up, down (but potentially
- // interesting), or lost (down, but we won't wait for it).
- set<pg_shard_t> up_now;
- map<int, epoch_t> candidate_blocked_by;
- // any candidates down now (that might have useful data)
- bool any_down_now = false;
-
- // consider ACTING osds
- for (auto &&so: acting) {
- epoch_t lost_at = 0;
- switch (f(start, so.osd, &lost_at)) {
- case UP: {
- // include past acting osds if they are up.
- up_now.insert(so);
- break;
- }
- case DNE: {
- ldpp_dout(dpp, 10) << "build_prior prior osd." << so.osd
- << " no longer exists" << dendl;
- break;
- }
- case LOST: {
- ldpp_dout(dpp, 10) << "build_prior prior osd." << so.osd
- << " is down, but lost_at " << lost_at << dendl;
- up_now.insert(so);
- break;
- }
- case DOWN: {
- ldpp_dout(dpp, 10) << "build_prior prior osd." << so.osd
- << " is down" << dendl;
- candidate_blocked_by[so.osd] = lost_at;
- any_down_now = true;
- break;
- }
- }
- }
-
- // if not enough osds survived this interval, and we may have gone rw,
- // then we need to wait for one of those osds to recover to
- // ensure that we haven't lost any information.
- if (!(*pcontdec)(up_now) && any_down_now) {
- // fixme: how do we identify a "clean" shutdown anyway?
- ldpp_dout(dpp, 10) << "build_prior possibly went active+rw,"
- << " insufficient up; including down osds" << dendl;
- assert(!candidate_blocked_by.empty());
- pg_down = true;
- blocked_by.insert(
- candidate_blocked_by.begin(),
- candidate_blocked_by.end());
- }
- });
-
- ldpp_dout(dpp, 10) << "build_prior final: probe " << probe
- << " down " << down
- << " blocked_by " << blocked_by
- << (pg_down ? " pg_down":"")
- << dendl;
-}
-
-/**
- * pg_query_t - used to ask a peer for information about a pg.
- *
- * note: if version=0, type=LOG, then we just provide our full log.
- */
-struct pg_query_t {
- enum {
- INFO = 0,
- LOG = 1,
- MISSING = 4,
- FULLLOG = 5,
- };
- const char *get_type_name() const {
- switch (type) {
- case INFO: return "info";
- case LOG: return "log";
- case MISSING: return "missing";
- case FULLLOG: return "fulllog";
- default: return "???";
- }
- }
-
- __s32 type;
- eversion_t since;
- pg_history_t history;
- epoch_t epoch_sent;
- shard_id_t to;
- shard_id_t from;
-
- pg_query_t() : type(-1), epoch_sent(0), to(shard_id_t::NO_SHARD),
- from(shard_id_t::NO_SHARD) {}
- pg_query_t(
- int t,
- shard_id_t to,
- shard_id_t from,
- const pg_history_t& h,
- epoch_t epoch_sent)
- : type(t),
- history(h),
- epoch_sent(epoch_sent),
- to(to), from(from) {
- assert(t != LOG);
- }
- pg_query_t(
- int t,
- shard_id_t to,
- shard_id_t from,
- eversion_t s,
- const pg_history_t& h,
- epoch_t epoch_sent)
- : type(t), since(s), history(h),
- epoch_sent(epoch_sent), to(to), from(from) {
- assert(t == LOG);
- }
-
- void encode(bufferlist &bl, uint64_t features) const;
- void decode(bufferlist::iterator &bl);
-
- void dump(Formatter *f) const;
- static void generate_test_instances(list<pg_query_t*>& o);
-};
-WRITE_CLASS_ENCODER_FEATURES(pg_query_t)
-
-inline ostream& operator<<(ostream& out, const pg_query_t& q) {
- out << "query(" << q.get_type_name() << " " << q.since;
- if (q.type == pg_query_t::LOG)
- out << " " << q.history;
- out << ")";
- return out;
-}
-
-class PGBackend;
-class ObjectModDesc {
- bool can_local_rollback;
- bool rollback_info_completed;
-
- // version required to decode, reflected in encode/decode version
- __u8 max_required_version = 1;
-public:
- class Visitor {
- public:
- virtual void append(uint64_t old_offset) {}
- virtual void setattrs(map<string, boost::optional<bufferlist> > &attrs) {}
- virtual void rmobject(version_t old_version) {}
- /**
- * Used to support the unfound_lost_delete log event: if the stashed
- * version exists, we unstash it, otherwise, we do nothing. This way
- * each replica rolls back to whatever state it had prior to the attempt
- * at mark unfound lost delete
- */
- virtual void try_rmobject(version_t old_version) {
- rmobject(old_version);
- }
- virtual void create() {}
- virtual void update_snaps(const set<snapid_t> &old_snaps) {}
- virtual void rollback_extents(
- version_t gen,
- const vector<pair<uint64_t, uint64_t> > &extents) {}
- virtual ~Visitor() {}
- };
- void visit(Visitor *visitor) const;
- mutable bufferlist bl;
- enum ModID {
- APPEND = 1,
- SETATTRS = 2,
- DELETE = 3,
- CREATE = 4,
- UPDATE_SNAPS = 5,
- TRY_DELETE = 6,
- ROLLBACK_EXTENTS = 7
- };
- ObjectModDesc() : can_local_rollback(true), rollback_info_completed(false) {
- bl.reassign_to_mempool(mempool::mempool_osd_pglog);
- }
- void claim(ObjectModDesc &other) {
- bl.clear();
- bl.claim(other.bl);
- can_local_rollback = other.can_local_rollback;
- rollback_info_completed = other.rollback_info_completed;
- }
- void claim_append(ObjectModDesc &other) {
- if (!can_local_rollback || rollback_info_completed)
- return;
- if (!other.can_local_rollback) {
- mark_unrollbackable();
- return;
- }
- bl.claim_append(other.bl);
- rollback_info_completed = other.rollback_info_completed;
- }
- void swap(ObjectModDesc &other) {
- bl.swap(other.bl);
-
- using std::swap;
- swap(other.can_local_rollback, can_local_rollback);
- swap(other.rollback_info_completed, rollback_info_completed);
- swap(other.max_required_version, max_required_version);
- }
- void append_id(ModID id) {
- uint8_t _id(id);
- ::encode(_id, bl);
- }
- void append(uint64_t old_size) {
- if (!can_local_rollback || rollback_info_completed)
- return;
- ENCODE_START(1, 1, bl);
- append_id(APPEND);
- ::encode(old_size, bl);
- ENCODE_FINISH(bl);
- }
- void setattrs(map<string, boost::optional<bufferlist> > &old_attrs) {
- if (!can_local_rollback || rollback_info_completed)
- return;
- ENCODE_START(1, 1, bl);
- append_id(SETATTRS);
- ::encode(old_attrs, bl);
- ENCODE_FINISH(bl);
- }
- bool rmobject(version_t deletion_version) {
- if (!can_local_rollback || rollback_info_completed)
- return false;
- ENCODE_START(1, 1, bl);
- append_id(DELETE);
- ::encode(deletion_version, bl);
- ENCODE_FINISH(bl);
- rollback_info_completed = true;
- return true;
- }
- bool try_rmobject(version_t deletion_version) {
- if (!can_local_rollback || rollback_info_completed)
- return false;
- ENCODE_START(1, 1, bl);
- append_id(TRY_DELETE);
- ::encode(deletion_version, bl);
- ENCODE_FINISH(bl);
- rollback_info_completed = true;
- return true;
- }
- void create() {
- if (!can_local_rollback || rollback_info_completed)
- return;
- rollback_info_completed = true;
- ENCODE_START(1, 1, bl);
- append_id(CREATE);
- ENCODE_FINISH(bl);
- }
- void update_snaps(const set<snapid_t> &old_snaps) {
- if (!can_local_rollback || rollback_info_completed)
- return;
- ENCODE_START(1, 1, bl);
- append_id(UPDATE_SNAPS);
- ::encode(old_snaps, bl);
- ENCODE_FINISH(bl);
- }
- void rollback_extents(
- version_t gen, const vector<pair<uint64_t, uint64_t> > &extents) {
- assert(can_local_rollback);
- assert(!rollback_info_completed);
- if (max_required_version < 2)
- max_required_version = 2;
- ENCODE_START(2, 2, bl);
- append_id(ROLLBACK_EXTENTS);
- ::encode(gen, bl);
- ::encode(extents, bl);
- ENCODE_FINISH(bl);
- }
-
- // cannot be rolled back
- void mark_unrollbackable() {
- can_local_rollback = false;
- bl.clear();
- }
- bool can_rollback() const {
- return can_local_rollback;
- }
- bool empty() const {
- return can_local_rollback && (bl.length() == 0);
- }
-
- bool requires_kraken() const {
- return max_required_version >= 2;
- }
-
- /**
- * Create fresh copy of bl bytes to avoid keeping large buffers around
- * in the case that bl contains ptrs which point into a much larger
- * message buffer
- */
- void trim_bl() const {
- if (bl.length() > 0)
- bl.rebuild();
- }
- void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<ObjectModDesc*>& o);
-};
-WRITE_CLASS_ENCODER(ObjectModDesc)
-
-
-/**
- * pg_log_entry_t - single entry/event in pg log
- *
- */
-struct pg_log_entry_t {
- enum {
- MODIFY = 1, // some unspecified modification (but not *all* modifications)
- CLONE = 2, // cloned object from head
- DELETE = 3, // deleted object
- BACKLOG = 4, // event invented by generate_backlog [deprecated]
- LOST_REVERT = 5, // lost new version, revert to an older version.
- LOST_DELETE = 6, // lost new version, revert to no object (deleted).
- LOST_MARK = 7, // lost new version, now EIO
- PROMOTE = 8, // promoted object from another tier
- CLEAN = 9, // mark an object clean
- ERROR = 10, // write that returned an error
- };
- static const char *get_op_name(int op) {
- switch (op) {
- case MODIFY:
- return "modify";
- case PROMOTE:
- return "promote";
- case CLONE:
- return "clone";
- case DELETE:
- return "delete";
- case BACKLOG:
- return "backlog";
- case LOST_REVERT:
- return "l_revert";
- case LOST_DELETE:
- return "l_delete";
- case LOST_MARK:
- return "l_mark";
- case CLEAN:
- return "clean";
- case ERROR:
- return "error";
- default:
- return "unknown";
- }
- }
- const char *get_op_name() const {
- return get_op_name(op);
- }
-
- // describes state for a locally-rollbackable entry
- ObjectModDesc mod_desc;
- bufferlist snaps; // only for clone entries
- hobject_t soid;
- osd_reqid_t reqid; // caller+tid to uniquely identify request
- mempool::osd_pglog::vector<pair<osd_reqid_t, version_t> > extra_reqids;
- eversion_t version, prior_version, reverting_to;
- version_t user_version; // the user version for this entry
- utime_t mtime; // this is the _user_ mtime, mind you
- int32_t return_code; // only stored for ERRORs for dup detection
-
- __s32 op;
- bool invalid_hash; // only when decoding sobject_t based entries
- bool invalid_pool; // only when decoding pool-less hobject based entries
-
- pg_log_entry_t()
- : user_version(0), return_code(0), op(0),
- invalid_hash(false), invalid_pool(false) {
- snaps.reassign_to_mempool(mempool::mempool_osd_pglog);
- }
- pg_log_entry_t(int _op, const hobject_t& _soid,
- const eversion_t& v, const eversion_t& pv,
- version_t uv,
- const osd_reqid_t& rid, const utime_t& mt,
- int return_code)
- : soid(_soid), reqid(rid), version(v), prior_version(pv), user_version(uv),
- mtime(mt), return_code(return_code), op(_op),
- invalid_hash(false), invalid_pool(false) {
- snaps.reassign_to_mempool(mempool::mempool_osd_pglog);
- }
-
- bool is_clone() const { return op == CLONE; }
- bool is_modify() const { return op == MODIFY; }
- bool is_promote() const { return op == PROMOTE; }
- bool is_clean() const { return op == CLEAN; }
- bool is_backlog() const { return op == BACKLOG; }
- bool is_lost_revert() const { return op == LOST_REVERT; }
- bool is_lost_delete() const { return op == LOST_DELETE; }
- bool is_lost_mark() const { return op == LOST_MARK; }
- bool is_error() const { return op == ERROR; }
-
- bool is_update() const {
- return
- is_clone() || is_modify() || is_promote() || is_clean() ||
- is_backlog() || is_lost_revert() || is_lost_mark();
- }
- bool is_delete() const {
- return op == DELETE || op == LOST_DELETE;
- }
-
- bool can_rollback() const {
- return mod_desc.can_rollback();
- }
-
- void mark_unrollbackable() {
- mod_desc.mark_unrollbackable();
- }
-
- bool requires_kraken() const {
- return mod_desc.requires_kraken();
- }
-
- // Errors are only used for dup detection, whereas
- // the index by objects is used by recovery, copy_get,
- // and other facilities that don't expect or need to
- // be aware of error entries.
- bool object_is_indexed() const {
- return !is_error();
- }
-
- bool reqid_is_indexed() const {
- return reqid != osd_reqid_t() &&
- (op == MODIFY || op == DELETE || op == ERROR);
- }
-
- string get_key_name() const;
- void encode_with_checksum(bufferlist& bl) const;
- void decode_with_checksum(bufferlist::iterator& p);
-
- void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<pg_log_entry_t*>& o);
-
-};
-WRITE_CLASS_ENCODER(pg_log_entry_t)
-
-ostream& operator<<(ostream& out, const pg_log_entry_t& e);
-
-struct pg_log_dup_t {
- osd_reqid_t reqid; // caller+tid to uniquely identify request
- eversion_t version;
- version_t user_version; // the user version for this entry
- int32_t return_code; // only stored for ERRORs for dup detection
-
- pg_log_dup_t()
- : user_version(0), return_code(0)
- {}
- explicit pg_log_dup_t(const pg_log_entry_t& entry)
- : reqid(entry.reqid), version(entry.version),
- user_version(entry.user_version), return_code(entry.return_code)
- {}
- pg_log_dup_t(const eversion_t& v, version_t uv,
- const osd_reqid_t& rid, int return_code)
- : reqid(rid), version(v), user_version(uv),
- return_code(return_code)
- {}
-
- string get_key_name() const;
- void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<pg_log_dup_t*>& o);
-
- bool operator==(const pg_log_dup_t &rhs) const {
- return reqid == rhs.reqid &&
- version == rhs.version &&
- user_version == rhs.user_version &&
- return_code == rhs.return_code;
- }
- bool operator!=(const pg_log_dup_t &rhs) const {
- return !(*this == rhs);
- }
-
- friend std::ostream& operator<<(std::ostream& out, const pg_log_dup_t& e);
-};
-WRITE_CLASS_ENCODER(pg_log_dup_t)
-
-std::ostream& operator<<(std::ostream& out, const pg_log_dup_t& e);
-
-/**
- * pg_log_t - incremental log of recent pg changes.
- *
- * serves as a recovery queue for recent changes.
- */
-struct pg_log_t {
- /*
- * head - newest entry (update|delete)
- * tail - entry previous to oldest (update|delete) for which we have
- * complete negative information.
- * i.e. we can infer pg contents for any store whose last_update >= tail.
- */
- eversion_t head; // newest entry
- eversion_t tail; // version prior to oldest
-
-protected:
- // We can rollback rollback-able entries > can_rollback_to
- eversion_t can_rollback_to;
-
- // always <= can_rollback_to, indicates how far stashed rollback
- // data can be found
- eversion_t rollback_info_trimmed_to;
-
-public:
- // the actual log
- mempool::osd_pglog::list<pg_log_entry_t> log;
-
- // entries just for dup op detection ordered oldest to newest
- mempool::osd_pglog::list<pg_log_dup_t> dups;
-
- pg_log_t() = default;
- pg_log_t(const eversion_t &last_update,
- const eversion_t &log_tail,
- const eversion_t &can_rollback_to,
- const eversion_t &rollback_info_trimmed_to,
- mempool::osd_pglog::list<pg_log_entry_t> &&entries,
- mempool::osd_pglog::list<pg_log_dup_t> &&dup_entries)
- : head(last_update), tail(log_tail), can_rollback_to(can_rollback_to),
- rollback_info_trimmed_to(rollback_info_trimmed_to),
- log(std::move(entries)), dups(std::move(dup_entries)) {}
- pg_log_t(const eversion_t &last_update,
- const eversion_t &log_tail,
- const eversion_t &can_rollback_to,
- const eversion_t &rollback_info_trimmed_to,
- const std::list<pg_log_entry_t> &entries,
- const std::list<pg_log_dup_t> &dup_entries)
- : head(last_update), tail(log_tail), can_rollback_to(can_rollback_to),
- rollback_info_trimmed_to(rollback_info_trimmed_to) {
- for (auto &&entry: entries) {
- log.push_back(entry);
- }
- for (auto &&entry: dup_entries) {
- dups.push_back(entry);
- }
- }
-
- void clear() {
- eversion_t z;
- rollback_info_trimmed_to = can_rollback_to = head = tail = z;
- log.clear();
- dups.clear();
- }
-
- eversion_t get_rollback_info_trimmed_to() const {
- return rollback_info_trimmed_to;
- }
- eversion_t get_can_rollback_to() const {
- return can_rollback_to;
- }
-
-
- pg_log_t split_out_child(pg_t child_pgid, unsigned split_bits) {
- mempool::osd_pglog::list<pg_log_entry_t> oldlog, childlog;
- oldlog.swap(log);
-
- eversion_t old_tail;
- unsigned mask = ~((~0)<<split_bits);
- for (auto i = oldlog.begin();
- i != oldlog.end();
- ) {
- if ((i->soid.get_hash() & mask) == child_pgid.m_seed) {
- childlog.push_back(*i);
- } else {
- log.push_back(*i);
- }
- oldlog.erase(i++);
- }
-
- // osd_reqid is unique, so it doesn't matter if there are extra
- // dup entries in each pg. To avoid storing oid with the dup
- // entries, just copy the whole list.
- auto childdups(dups);
-
- return pg_log_t(
- head,
- tail,
- can_rollback_to,
- rollback_info_trimmed_to,
- std::move(childlog),
- std::move(childdups));
- }
-
- mempool::osd_pglog::list<pg_log_entry_t> rewind_from_head(eversion_t newhead) {
- assert(newhead >= tail);
-
- mempool::osd_pglog::list<pg_log_entry_t>::iterator p = log.end();
- mempool::osd_pglog::list<pg_log_entry_t> divergent;
- while (true) {
- if (p == log.begin()) {
- // yikes, the whole thing is divergent!
- using std::swap;
- swap(divergent, log);
- break;
- }
- --p;
- if (p->version.version <= newhead.version) {
- /*
- * look at eversion.version here. we want to avoid a situation like:
- * our log: 100'10 (0'0) m 10000004d3a.00000000/head by client4225.1:18529
- * new log: 122'10 (0'0) m 10000004d3a.00000000/head by client4225.1:18529
- * lower_bound = 100'9
- * i.e, same request, different version. If the eversion.version is > the
- * lower_bound, we it is divergent.
- */
- ++p;
- divergent.splice(divergent.begin(), log, p, log.end());
- break;
- }
- assert(p->version > newhead);
- }
- head = newhead;
-
- if (can_rollback_to > newhead)
- can_rollback_to = newhead;
-
- if (rollback_info_trimmed_to > newhead)
- rollback_info_trimmed_to = newhead;
-
- return divergent;
- }
-
- bool empty() const {
- return log.empty();
- }
-
- bool null() const {
- return head.version == 0 && head.epoch == 0;
- }
-
- size_t approx_size() const {
- return head.version - tail.version;
- }
-
- static void filter_log(spg_t import_pgid, const OSDMap &curmap,
- const string &hit_set_namespace, const pg_log_t &in,
- pg_log_t &out, pg_log_t &reject);
-
- /**
- * copy entries from the tail of another pg_log_t
- *
- * @param other pg_log_t to copy from
- * @param from copy entries after this version
- */
- void copy_after(const pg_log_t &other, eversion_t from);
-
- /**
- * copy a range of entries from another pg_log_t
- *
- * @param other pg_log_t to copy from
- * @param from copy entries after this version
- * @param to up to and including this version
- */
- void copy_range(const pg_log_t &other, eversion_t from, eversion_t to);
-
- /**
- * copy up to N entries
- *
- * @param other source log
- * @param max max number of entries to copy
- */
- void copy_up_to(const pg_log_t &other, int max);
-
- ostream& print(ostream& out) const;
-
- void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl, int64_t pool = -1);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<pg_log_t*>& o);
-};
-WRITE_CLASS_ENCODER(pg_log_t)
-
-inline ostream& operator<<(ostream& out, const pg_log_t& log)
-{
- out << "log((" << log.tail << "," << log.head << "], crt="
- << log.get_can_rollback_to() << ")";
- return out;
-}
-
-
-/**
- * pg_missing_t - summary of missing objects.
- *
- * kept in memory, as a supplement to pg_log_t
- * also used to pass missing info in messages.
- */
-struct pg_missing_item {
- eversion_t need, have;
- enum missing_flags_t {
- FLAG_NONE = 0,
- FLAG_DELETE = 1,
- } flags;
- pg_missing_item() : flags(FLAG_NONE) {}
- explicit pg_missing_item(eversion_t n) : need(n), flags(FLAG_NONE) {} // have no old version
- pg_missing_item(eversion_t n, eversion_t h, bool is_delete=false) : need(n), have(h) {
- set_delete(is_delete);
- }
-
- void encode(bufferlist& bl, uint64_t features) const {
- if (HAVE_FEATURE(features, OSD_RECOVERY_DELETES)) {
- // encoding a zeroed eversion_t to differentiate between this and
- // legacy unversioned encoding - a need value of 0'0 is not
- // possible. This can be replaced with the legacy encoding
- // macros post-luminous.
- eversion_t e;
- ::encode(e, bl);
- ::encode(need, bl);
- ::encode(have, bl);
- ::encode(static_cast<uint8_t>(flags), bl);
- } else {
- // legacy unversioned encoding
- ::encode(need, bl);
- ::encode(have, bl);
- }
- }
- void decode(bufferlist::iterator& bl) {
- eversion_t e;
- ::decode(e, bl);
- if (e != eversion_t()) {
- // legacy encoding, this is the need value
- need = e;
- ::decode(have, bl);
- } else {
- ::decode(need, bl);
- ::decode(have, bl);
- uint8_t f;
- ::decode(f, bl);
- flags = static_cast<missing_flags_t>(f);
- }
- }
-
- void set_delete(bool is_delete) {
- flags = is_delete ? FLAG_DELETE : FLAG_NONE;
- }
-
- bool is_delete() const {
- return (flags & FLAG_DELETE) == FLAG_DELETE;
- }
-
- string flag_str() const {
- if (flags == FLAG_NONE) {
- return "none";
- } else {
- return "delete";
- }
- }
-
- void dump(Formatter *f) const {
- f->dump_stream("need") << need;
- f->dump_stream("have") << have;
- f->dump_stream("flags") << flag_str();
- }
- static void generate_test_instances(list<pg_missing_item*>& o) {
- o.push_back(new pg_missing_item);
- o.push_back(new pg_missing_item);
- o.back()->need = eversion_t(1, 2);
- o.back()->have = eversion_t(1, 1);
- o.push_back(new pg_missing_item);
- o.back()->need = eversion_t(3, 5);
- o.back()->have = eversion_t(3, 4);
- o.back()->flags = FLAG_DELETE;
- }
- bool operator==(const pg_missing_item &rhs) const {
- return need == rhs.need && have == rhs.have && flags == rhs.flags;
- }
- bool operator!=(const pg_missing_item &rhs) const {
- return !(*this == rhs);
- }
-};
-WRITE_CLASS_ENCODER_FEATURES(pg_missing_item)
-ostream& operator<<(ostream& out, const pg_missing_item &item);
-
-class pg_missing_const_i {
-public:
- virtual const map<hobject_t, pg_missing_item> &
- get_items() const = 0;
- virtual const map<version_t, hobject_t> &get_rmissing() const = 0;
- virtual bool get_may_include_deletes() const = 0;
- virtual unsigned int num_missing() const = 0;
- virtual bool have_missing() const = 0;
- virtual bool is_missing(const hobject_t& oid, pg_missing_item *out = nullptr) const = 0;
- virtual bool is_missing(const hobject_t& oid, eversion_t v) const = 0;
- virtual eversion_t have_old(const hobject_t& oid) const = 0;
- virtual ~pg_missing_const_i() {}
-};
-
-
-template <bool Track>
-class ChangeTracker {
-public:
- void changed(const hobject_t &obj) {}
- template <typename F>
- void get_changed(F &&f) const {}
- void flush() {}
- bool is_clean() const {
- return true;
- }
-};
-template <>
-class ChangeTracker<true> {
- set<hobject_t> _changed;
-public:
- void changed(const hobject_t &obj) {
- _changed.insert(obj);
- }
- template <typename F>
- void get_changed(F &&f) const {
- for (auto const &i: _changed) {
- f(i);
- }
- }
- void flush() {
- _changed.clear();
- }
- bool is_clean() const {
- return _changed.empty();
- }
-};
-
-template <bool TrackChanges>
-class pg_missing_set : public pg_missing_const_i {
- using item = pg_missing_item;
- map<hobject_t, item> missing; // oid -> (need v, have v)
- map<version_t, hobject_t> rmissing; // v -> oid
- ChangeTracker<TrackChanges> tracker;
-
-public:
- pg_missing_set() = default;
-
- template <typename missing_type>
- pg_missing_set(const missing_type &m) {
- missing = m.get_items();
- rmissing = m.get_rmissing();
- may_include_deletes = m.get_may_include_deletes();
- for (auto &&i: missing)
- tracker.changed(i.first);
- }
-
- bool may_include_deletes = false;
-
- const map<hobject_t, item> &get_items() const override {
- return missing;
- }
- const map<version_t, hobject_t> &get_rmissing() const override {
- return rmissing;
- }
- bool get_may_include_deletes() const override {
- return may_include_deletes;
- }
- unsigned int num_missing() const override {
- return missing.size();
- }
- bool have_missing() const override {
- return !missing.empty();
- }
- bool is_missing(const hobject_t& oid, pg_missing_item *out = nullptr) const override {
- auto iter = missing.find(oid);
- if (iter == missing.end())
- return false;
- if (out)
- *out = iter->second;
- return true;
- }
- bool is_missing(const hobject_t& oid, eversion_t v) const override {
- map<hobject_t, item>::const_iterator m =
- missing.find(oid);
- if (m == missing.end())
- return false;
- const item &item(m->second);
- if (item.need > v)
- return false;
- return true;
- }
- eversion_t have_old(const hobject_t& oid) const override {
- map<hobject_t, item>::const_iterator m =
- missing.find(oid);
- if (m == missing.end())
- return eversion_t();
- const item &item(m->second);
- return item.have;
- }
-
- void claim(pg_missing_set& o) {
- static_assert(!TrackChanges, "Can't use claim with TrackChanges");
- missing.swap(o.missing);
- rmissing.swap(o.rmissing);
- }
-
- /*
- * this needs to be called in log order as we extend the log. it
- * assumes missing is accurate up through the previous log entry.
- */
- void add_next_event(const pg_log_entry_t& e) {
- map<hobject_t, item>::iterator missing_it;
- missing_it = missing.find(e.soid);
- bool is_missing_divergent_item = missing_it != missing.end();
- if (e.prior_version == eversion_t() || e.is_clone()) {
- // new object.
- if (is_missing_divergent_item) { // use iterator
- rmissing.erase((missing_it->second).need.version);
- missing_it->second = item(e.version, eversion_t(), e.is_delete()); // .have = nil
- } else // create new element in missing map
- missing[e.soid] = item(e.version, eversion_t(), e.is_delete()); // .have = nil
- } else if (is_missing_divergent_item) {
- // already missing (prior).
- rmissing.erase((missing_it->second).need.version);
- (missing_it->second).need = e.version; // leave .have unchanged.
- missing_it->second.set_delete(e.is_delete());
- } else if (e.is_backlog()) {
- // May not have prior version
- assert(0 == "these don't exist anymore");
- } else {
- // not missing, we must have prior_version (if any)
- assert(!is_missing_divergent_item);
- missing[e.soid] = item(e.version, e.prior_version, e.is_delete());
- }
- rmissing[e.version.version] = e.soid;
- tracker.changed(e.soid);
- }
-
- void revise_need(hobject_t oid, eversion_t need, bool is_delete) {
- if (missing.count(oid)) {
- rmissing.erase(missing[oid].need.version);
- missing[oid].need = need; // no not adjust .have
- missing[oid].set_delete(is_delete);
- } else {
- missing[oid] = item(need, eversion_t(), is_delete);
- }
- rmissing[need.version] = oid;
-
- tracker.changed(oid);
- }
-
- void revise_have(hobject_t oid, eversion_t have) {
- if (missing.count(oid)) {
- tracker.changed(oid);
- missing[oid].have = have;
- }
- }
-
- void add(const hobject_t& oid, eversion_t need, eversion_t have,
- bool is_delete) {
- missing[oid] = item(need, have, is_delete);
- rmissing[need.version] = oid;
- tracker.changed(oid);
- }
-
- void rm(const hobject_t& oid, eversion_t v) {
- std::map<hobject_t, item>::iterator p = missing.find(oid);
- if (p != missing.end() && p->second.need <= v)
- rm(p);
- }
-
- void rm(std::map<hobject_t, item>::const_iterator m) {
- tracker.changed(m->first);
- rmissing.erase(m->second.need.version);
- missing.erase(m);
- }
-
- void got(const hobject_t& oid, eversion_t v) {
- std::map<hobject_t, item>::iterator p = missing.find(oid);
- assert(p != missing.end());
- assert(p->second.need <= v || p->second.is_delete());
- got(p);
- }
-
- void got(std::map<hobject_t, item>::const_iterator m) {
- tracker.changed(m->first);
- rmissing.erase(m->second.need.version);
- missing.erase(m);
- }
-
- void split_into(
- pg_t child_pgid,
- unsigned split_bits,
- pg_missing_set *omissing) {
- omissing->may_include_deletes = may_include_deletes;
- unsigned mask = ~((~0)<<split_bits);
- for (map<hobject_t, item>::iterator i = missing.begin();
- i != missing.end();
- ) {
- if ((i->first.get_hash() & mask) == child_pgid.m_seed) {
- omissing->add(i->first, i->second.need, i->second.have,
- i->second.is_delete());
- rm(i++);
- } else {
- ++i;
- }
- }
- }
-
- void clear() {
- for (auto const &i: missing)
- tracker.changed(i.first);
- missing.clear();
- rmissing.clear();
- }
-
- void encode(bufferlist &bl) const {
- ENCODE_START(4, 2, bl);
- ::encode(missing, bl, may_include_deletes ? CEPH_FEATURE_OSD_RECOVERY_DELETES : 0);
- ::encode(may_include_deletes, bl);
- ENCODE_FINISH(bl);
- }
- void decode(bufferlist::iterator &bl, int64_t pool = -1) {
- for (auto const &i: missing)
- tracker.changed(i.first);
- DECODE_START_LEGACY_COMPAT_LEN(4, 2, 2, bl);
- ::decode(missing, bl);
- if (struct_v >= 4) {
- ::decode(may_include_deletes, bl);
- }
- DECODE_FINISH(bl);
-
- if (struct_v < 3) {
- // Handle hobject_t upgrade
- map<hobject_t, item> tmp;
- for (map<hobject_t, item>::iterator i =
- missing.begin();
- i != missing.end();
- ) {
- if (!i->first.is_max() && i->first.pool == -1) {
- hobject_t to_insert(i->first);
- to_insert.pool = pool;
- tmp[to_insert] = i->second;
- missing.erase(i++);
- } else {
- ++i;
- }
- }
- missing.insert(tmp.begin(), tmp.end());
- }
-
- for (map<hobject_t,item>::iterator it =
- missing.begin();
- it != missing.end();
- ++it)
- rmissing[it->second.need.version] = it->first;
- for (auto const &i: missing)
- tracker.changed(i.first);
- }
- void dump(Formatter *f) const {
- f->open_array_section("missing");
- for (map<hobject_t,item>::const_iterator p =
- missing.begin(); p != missing.end(); ++p) {
- f->open_object_section("item");
- f->dump_stream("object") << p->first;
- p->second.dump(f);
- f->close_section();
- }
- f->close_section();
- f->dump_bool("may_include_deletes", may_include_deletes);
- }
- template <typename F>
- void filter_objects(F &&f) {
- for (auto i = missing.begin(); i != missing.end();) {
- if (f(i->first)) {
- rm(i++);
- } else {
- ++i;
- }
- }
- }
- static void generate_test_instances(list<pg_missing_set*>& o) {
- o.push_back(new pg_missing_set);
- o.push_back(new pg_missing_set);
- o.back()->add(
- hobject_t(object_t("foo"), "foo", 123, 456, 0, ""),
- eversion_t(5, 6), eversion_t(5, 1), false);
- o.push_back(new pg_missing_set);
- o.back()->add(
- hobject_t(object_t("foo"), "foo", 123, 456, 0, ""),
- eversion_t(5, 6), eversion_t(5, 1), true);
- o.back()->may_include_deletes = true;
- }
- template <typename F>
- void get_changed(F &&f) const {
- tracker.get_changed(f);
- }
- void flush() {
- tracker.flush();
- }
- bool is_clean() const {
- return tracker.is_clean();
- }
- template <typename missing_t>
- bool debug_verify_from_init(
- const missing_t &init_missing,
- ostream *oss) const {
- if (!TrackChanges)
- return true;
- auto check_missing(init_missing.get_items());
- tracker.get_changed([&](const hobject_t &hoid) {
- check_missing.erase(hoid);
- if (missing.count(hoid)) {
- check_missing.insert(*(missing.find(hoid)));
- }
- });
- bool ok = true;
- if (check_missing.size() != missing.size()) {
- if (oss) {
- *oss << "Size mismatch, check: " << check_missing.size()
- << ", actual: " << missing.size() << "\n";
- }
- ok = false;
- }
- for (auto &i: missing) {
- if (!check_missing.count(i.first)) {
- if (oss)
- *oss << "check_missing missing " << i.first << "\n";
- ok = false;
- } else if (check_missing[i.first] != i.second) {
- if (oss)
- *oss << "check_missing missing item mismatch on " << i.first
- << ", check: " << check_missing[i.first]
- << ", actual: " << i.second << "\n";
- ok = false;
- }
- }
- if (oss && !ok) {
- *oss << "check_missing: " << check_missing << "\n";
- set<hobject_t> changed;
- tracker.get_changed([&](const hobject_t &hoid) { changed.insert(hoid); });
- *oss << "changed: " << changed << "\n";
- }
- return ok;
- }
-};
-template <bool TrackChanges>
-void encode(
- const pg_missing_set<TrackChanges> &c, bufferlist &bl, uint64_t features=0) {
- ENCODE_DUMP_PRE();
- c.encode(bl);
- ENCODE_DUMP_POST(cl);
-}
-template <bool TrackChanges>
-void decode(pg_missing_set<TrackChanges> &c, bufferlist::iterator &p) {
- c.decode(p);
-}
-template <bool TrackChanges>
-ostream& operator<<(ostream& out, const pg_missing_set<TrackChanges> &missing)
-{
- out << "missing(" << missing.num_missing()
- << " may_include_deletes = " << missing.may_include_deletes;
- //if (missing.num_lost()) out << ", " << missing.num_lost() << " lost";
- out << ")";
- return out;
-}
-
-using pg_missing_t = pg_missing_set<false>;
-using pg_missing_tracker_t = pg_missing_set<true>;
-
-
-/**
- * pg list objects response format
- *
- */
-struct pg_nls_response_t {
- collection_list_handle_t handle;
- list<librados::ListObjectImpl> entries;
-
- void encode(bufferlist& bl) const {
- ENCODE_START(1, 1, bl);
- ::encode(handle, bl);
- __u32 n = (__u32)entries.size();
- ::encode(n, bl);
- for (list<librados::ListObjectImpl>::const_iterator i = entries.begin(); i != entries.end(); ++i) {
- ::encode(i->nspace, bl);
- ::encode(i->oid, bl);
- ::encode(i->locator, bl);
- }
- ENCODE_FINISH(bl);
- }
- void decode(bufferlist::iterator& bl) {
- DECODE_START(1, bl);
- ::decode(handle, bl);
- __u32 n;
- ::decode(n, bl);
- entries.clear();
- while (n--) {
- librados::ListObjectImpl i;
- ::decode(i.nspace, bl);
- ::decode(i.oid, bl);
- ::decode(i.locator, bl);
- entries.push_back(i);
- }
- DECODE_FINISH(bl);
- }
- void dump(Formatter *f) const {
- f->dump_stream("handle") << handle;
- f->open_array_section("entries");
- for (list<librados::ListObjectImpl>::const_iterator p = entries.begin(); p != entries.end(); ++p) {
- f->open_object_section("object");
- f->dump_string("namespace", p->nspace);
- f->dump_string("object", p->oid);
- f->dump_string("key", p->locator);
- f->close_section();
- }
- f->close_section();
- }
- static void generate_test_instances(list<pg_nls_response_t*>& o) {
- o.push_back(new pg_nls_response_t);
- o.push_back(new pg_nls_response_t);
- o.back()->handle = hobject_t(object_t("hi"), "key", 1, 2, -1, "");
- o.back()->entries.push_back(librados::ListObjectImpl("", "one", ""));
- o.back()->entries.push_back(librados::ListObjectImpl("", "two", "twokey"));
- o.back()->entries.push_back(librados::ListObjectImpl("", "three", ""));
- o.push_back(new pg_nls_response_t);
- o.back()->handle = hobject_t(object_t("hi"), "key", 3, 4, -1, "");
- o.back()->entries.push_back(librados::ListObjectImpl("n1", "n1one", ""));
- o.back()->entries.push_back(librados::ListObjectImpl("n1", "n1two", "n1twokey"));
- o.back()->entries.push_back(librados::ListObjectImpl("n1", "n1three", ""));
- o.push_back(new pg_nls_response_t);
- o.back()->handle = hobject_t(object_t("hi"), "key", 5, 6, -1, "");
- o.back()->entries.push_back(librados::ListObjectImpl("", "one", ""));
- o.back()->entries.push_back(librados::ListObjectImpl("", "two", "twokey"));
- o.back()->entries.push_back(librados::ListObjectImpl("", "three", ""));
- o.back()->entries.push_back(librados::ListObjectImpl("n1", "n1one", ""));
- o.back()->entries.push_back(librados::ListObjectImpl("n1", "n1two", "n1twokey"));
- o.back()->entries.push_back(librados::ListObjectImpl("n1", "n1three", ""));
- }
-};
-
-WRITE_CLASS_ENCODER(pg_nls_response_t)
-
-// For backwards compatibility with older OSD requests
-struct pg_ls_response_t {
- collection_list_handle_t handle;
- list<pair<object_t, string> > entries;
-
- void encode(bufferlist& bl) const {
- __u8 v = 1;
- ::encode(v, bl);
- ::encode(handle, bl);
- ::encode(entries, bl);
- }
- void decode(bufferlist::iterator& bl) {
- __u8 v;
- ::decode(v, bl);
- assert(v == 1);
- ::decode(handle, bl);
- ::decode(entries, bl);
- }
- void dump(Formatter *f) const {
- f->dump_stream("handle") << handle;
- f->open_array_section("entries");
- for (list<pair<object_t, string> >::const_iterator p = entries.begin(); p != entries.end(); ++p) {
- f->open_object_section("object");
- f->dump_stream("object") << p->first;
- f->dump_string("key", p->second);
- f->close_section();
- }
- f->close_section();
- }
- static void generate_test_instances(list<pg_ls_response_t*>& o) {
- o.push_back(new pg_ls_response_t);
- o.push_back(new pg_ls_response_t);
- o.back()->handle = hobject_t(object_t("hi"), "key", 1, 2, -1, "");
- o.back()->entries.push_back(make_pair(object_t("one"), string()));
- o.back()->entries.push_back(make_pair(object_t("two"), string("twokey")));
- }
-};
-
-WRITE_CLASS_ENCODER(pg_ls_response_t)
-
-/**
- * object_copy_cursor_t
- */
-struct object_copy_cursor_t {
- uint64_t data_offset;
- string omap_offset;
- bool attr_complete;
- bool data_complete;
- bool omap_complete;
-
- object_copy_cursor_t()
- : data_offset(0),
- attr_complete(false),
- data_complete(false),
- omap_complete(false)
- {}
-
- bool is_initial() const {
- return !attr_complete && data_offset == 0 && omap_offset.empty();
- }
- bool is_complete() const {
- return attr_complete && data_complete && omap_complete;
- }
-
- static void generate_test_instances(list<object_copy_cursor_t*>& o);
- void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator &bl);
- void dump(Formatter *f) const;
-};
-WRITE_CLASS_ENCODER(object_copy_cursor_t)
-
-/**
- * object_copy_data_t
- *
- * Return data from a copy request. The semantics are a little strange
- * as a result of the encoding's heritage.
- *
- * In particular, the sender unconditionally fills in the cursor (from what
- * it receives and sends), the size, and the mtime, but is responsible for
- * figuring out whether it should put any data in the attrs, data, or
- * omap members (corresponding to xattrs, object data, and the omap entries)
- * based on external data (the client includes a max amount to return with
- * the copy request). The client then looks into the attrs, data, and/or omap
- * based on the contents of the cursor.
- */
-struct object_copy_data_t {
- enum {
- FLAG_DATA_DIGEST = 1<<0,
- FLAG_OMAP_DIGEST = 1<<1,
- };
- object_copy_cursor_t cursor;
- uint64_t size;
- utime_t mtime;
- uint32_t data_digest, omap_digest;
- uint32_t flags;
- map<string, bufferlist> attrs;
- bufferlist data;
- bufferlist omap_header;
- bufferlist omap_data;
-
- /// which snaps we are defined for (if a snap and not the head)
- vector<snapid_t> snaps;
- ///< latest snap seq for the object (if head)
- snapid_t snap_seq;
-
- ///< recent reqids on this object
- mempool::osd_pglog::vector<pair<osd_reqid_t, version_t> > reqids;
-
- uint64_t truncate_seq;
- uint64_t truncate_size;
-
-public:
- object_copy_data_t() :
- size((uint64_t)-1), data_digest(-1),
- omap_digest(-1), flags(0),
- truncate_seq(0),
- truncate_size(0) {}
-
- static void generate_test_instances(list<object_copy_data_t*>& o);
- void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& bl);
- void dump(Formatter *f) const;
-};
-WRITE_CLASS_ENCODER_FEATURES(object_copy_data_t)
-
-/**
- * pg creation info
- */
-struct pg_create_t {
- epoch_t created; // epoch pg created
- pg_t parent; // split from parent (if != pg_t())
- __s32 split_bits;
-
- pg_create_t()
- : created(0), split_bits(0) {}
- pg_create_t(unsigned c, pg_t p, int s)
- : created(c), parent(p), split_bits(s) {}
-
- void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<pg_create_t*>& o);
-};
-WRITE_CLASS_ENCODER(pg_create_t)
-
-// -----------------------------------------
-
-struct osd_peer_stat_t {
- utime_t stamp;
-
- osd_peer_stat_t() { }
-
- void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<osd_peer_stat_t*>& o);
-};
-WRITE_CLASS_ENCODER(osd_peer_stat_t)
-
-ostream& operator<<(ostream& out, const osd_peer_stat_t &stat);
-
-
-// -----------------------------------------
-
-class ObjectExtent {
- /**
- * ObjectExtents are used for specifying IO behavior against RADOS
- * objects when one is using the ObjectCacher.
- *
- * To use this in a real system, *every member* must be filled
- * out correctly. In particular, make sure to initialize the
- * oloc correctly, as its default values are deliberate poison
- * and will cause internal ObjectCacher asserts.
- *
- * Similarly, your buffer_extents vector *must* specify a total
- * size equal to your length. If the buffer_extents inadvertently
- * contain less space than the length member specifies, you
- * will get unintelligible asserts deep in the ObjectCacher.
- *
- * If you are trying to do testing and don't care about actual
- * RADOS function, the simplest thing to do is to initialize
- * the ObjectExtent (truncate_size can be 0), create a single entry
- * in buffer_extents matching the length, and set oloc.pool to 0.
- */
- public:
- object_t oid; // object id
- uint64_t objectno;
- uint64_t offset; // in object
- uint64_t length; // in object
- uint64_t truncate_size; // in object
-
- object_locator_t oloc; // object locator (pool etc)
-
- vector<pair<uint64_t,uint64_t> > buffer_extents; // off -> len. extents in buffer being mapped (may be fragmented bc of striping!)
-
- ObjectExtent() : objectno(0), offset(0), length(0), truncate_size(0) {}
- ObjectExtent(object_t o, uint64_t ono, uint64_t off, uint64_t l, uint64_t ts) :
- oid(o), objectno(ono), offset(off), length(l), truncate_size(ts) { }
-};
-
-inline ostream& operator<<(ostream& out, const ObjectExtent &ex)
-{
- return out << "extent("
- << ex.oid << " (" << ex.objectno << ") in " << ex.oloc
- << " " << ex.offset << "~" << ex.length
- << " -> " << ex.buffer_extents
- << ")";
-}
-
-
-// ---------------------------------------
-
-class OSDSuperblock {
-public:
- uuid_d cluster_fsid, osd_fsid;
- int32_t whoami; // my role in this fs.
- epoch_t current_epoch; // most recent epoch
- epoch_t oldest_map, newest_map; // oldest/newest maps we have.
- double weight;
-
- CompatSet compat_features;
-
- // last interval over which i mounted and was then active
- epoch_t mounted; // last epoch i mounted
- epoch_t clean_thru; // epoch i was active and clean thru
-
- OSDSuperblock() :
- whoami(-1),
- current_epoch(0), oldest_map(0), newest_map(0), weight(0),
- mounted(0), clean_thru(0) {
- }
-
- void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<OSDSuperblock*>& o);
-};
-WRITE_CLASS_ENCODER(OSDSuperblock)
-
-inline ostream& operator<<(ostream& out, const OSDSuperblock& sb)
-{
- return out << "sb(" << sb.cluster_fsid
- << " osd." << sb.whoami
- << " " << sb.osd_fsid
- << " e" << sb.current_epoch
- << " [" << sb.oldest_map << "," << sb.newest_map << "]"
- << " lci=[" << sb.mounted << "," << sb.clean_thru << "]"
- << ")";
-}
-
-
-// -------
-
-
-
-
-
-
-/*
- * attached to object head. describes most recent snap context, and
- * set of existing clones.
- */
-struct SnapSet {
- snapid_t seq;
- bool head_exists;
- vector<snapid_t> snaps; // descending
- vector<snapid_t> clones; // ascending
- map<snapid_t, interval_set<uint64_t> > clone_overlap; // overlap w/ next newest
- map<snapid_t, uint64_t> clone_size;
- map<snapid_t, vector<snapid_t>> clone_snaps; // descending
-
- SnapSet() : seq(0), head_exists(false) {}
- explicit SnapSet(bufferlist& bl) {
- bufferlist::iterator p = bl.begin();
- decode(p);
- }
-
- bool is_legacy() const {
- return clone_snaps.size() < clones.size() || !head_exists;
- }
-
- /// populate SnapSet from a librados::snap_set_t
- void from_snap_set(const librados::snap_set_t& ss, bool legacy);
-
- /// get space accounted to clone
- uint64_t get_clone_bytes(snapid_t clone) const;
-
- void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<SnapSet*>& o);
-
- SnapContext get_ssc_as_of(snapid_t as_of) const {
- SnapContext out;
- out.seq = as_of;
- for (vector<snapid_t>::const_iterator i = snaps.begin();
- i != snaps.end();
- ++i) {
- if (*i <= as_of)
- out.snaps.push_back(*i);
- }
- return out;
- }
-
- // return min element of snaps > after, return max if no such element
- snapid_t get_first_snap_after(snapid_t after, snapid_t max) const {
- for (vector<snapid_t>::const_reverse_iterator i = snaps.rbegin();
- i != snaps.rend();
- ++i) {
- if (*i > after)
- return *i;
- }
- return max;
- }
-
- SnapSet get_filtered(const pg_pool_t &pinfo) const;
- void filter(const pg_pool_t &pinfo);
-};
-WRITE_CLASS_ENCODER(SnapSet)
-
-ostream& operator<<(ostream& out, const SnapSet& cs);
-
-
-
-#define OI_ATTR "_"
-#define SS_ATTR "snapset"
-
-struct watch_info_t {
- uint64_t cookie;
- uint32_t timeout_seconds;
- entity_addr_t addr;
-
- watch_info_t() : cookie(0), timeout_seconds(0) { }
- watch_info_t(uint64_t c, uint32_t t, const entity_addr_t& a) : cookie(c), timeout_seconds(t), addr(a) {}
-
- void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& bl);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<watch_info_t*>& o);
-};
-WRITE_CLASS_ENCODER_FEATURES(watch_info_t)
-
-static inline bool operator==(const watch_info_t& l, const watch_info_t& r) {
- return l.cookie == r.cookie && l.timeout_seconds == r.timeout_seconds
- && l.addr == r.addr;
-}
-
-static inline ostream& operator<<(ostream& out, const watch_info_t& w) {
- return out << "watch(cookie " << w.cookie << " " << w.timeout_seconds << "s"
- << " " << w.addr << ")";
-}
-
-struct notify_info_t {
- uint64_t cookie;
- uint64_t notify_id;
- uint32_t timeout;
- bufferlist bl;
-};
-
-static inline ostream& operator<<(ostream& out, const notify_info_t& n) {
- return out << "notify(cookie " << n.cookie
- << " notify" << n.notify_id
- << " " << n.timeout << "s)";
-}
-
-struct object_info_t;
-struct object_manifest_t {
- enum {
- TYPE_NONE = 0,
- TYPE_REDIRECT = 1, // start with this
- TYPE_CHUNKED = 2, // do this later
- };
- uint8_t type; // redirect, chunked, ...
- hobject_t redirect_target;
-
- object_manifest_t() : type(0) { }
- object_manifest_t(uint8_t type, const hobject_t& redirect_target)
- : type(type), redirect_target(redirect_target) { }
-
- bool is_empty() const {
- return type == TYPE_NONE;
- }
- bool is_redirect() const {
- return type == TYPE_REDIRECT;
- }
- bool is_chunked() const {
- return type == TYPE_CHUNKED;
- }
- static const char *get_type_name(uint8_t m) {
- switch (m) {
- case TYPE_NONE: return "none";
- case TYPE_REDIRECT: return "redirect";
- case TYPE_CHUNKED: return "chunked";
- default: return "unknown";
- }
- }
- const char *get_type_name() const {
- return get_type_name(type);
- }
- static void generate_test_instances(list<object_manifest_t*>& o);
- void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
- void dump(Formatter *f) const;
- friend ostream& operator<<(ostream& out, const object_info_t& oi);
-};
-WRITE_CLASS_ENCODER(object_manifest_t)
-ostream& operator<<(ostream& out, const object_manifest_t& oi);
-
-struct object_info_t {
- hobject_t soid;
- eversion_t version, prior_version;
- version_t user_version;
- osd_reqid_t last_reqid;
-
- uint64_t size;
- utime_t mtime;
- utime_t local_mtime; // local mtime
-
- // note: these are currently encoded into a total 16 bits; see
- // encode()/decode() for the weirdness.
- typedef enum {
- FLAG_LOST = 1<<0,
- FLAG_WHITEOUT = 1<<1, // object logically does not exist
- FLAG_DIRTY = 1<<2, // object has been modified since last flushed or undirtied
- FLAG_OMAP = 1 << 3, // has (or may have) some/any omap data
- FLAG_DATA_DIGEST = 1 << 4, // has data crc
- FLAG_OMAP_DIGEST = 1 << 5, // has omap crc
- FLAG_CACHE_PIN = 1 << 6, // pin the object in cache tier
- FLAG_MANIFEST = 1 << 7, // has manifest
- // ...
- FLAG_USES_TMAP = 1<<8, // deprecated; no longer used.
- } flag_t;
-
- flag_t flags;
-
- static string get_flag_string(flag_t flags) {
- string s;
- if (flags & FLAG_LOST)
- s += "|lost";
- if (flags & FLAG_WHITEOUT)
- s += "|whiteout";
- if (flags & FLAG_DIRTY)
- s += "|dirty";
- if (flags & FLAG_USES_TMAP)
- s += "|uses_tmap";
- if (flags & FLAG_OMAP)
- s += "|omap";
- if (flags & FLAG_DATA_DIGEST)
- s += "|data_digest";
- if (flags & FLAG_OMAP_DIGEST)
- s += "|omap_digest";
- if (flags & FLAG_CACHE_PIN)
- s += "|cache_pin";
- if (flags & FLAG_MANIFEST)
- s += "|manifest";
- if (s.length())
- return s.substr(1);
- return s;
- }
- string get_flag_string() const {
- return get_flag_string(flags);
- }
-
- /// [clone] descending. pre-luminous; moved to SnapSet
- vector<snapid_t> legacy_snaps;
-
- uint64_t truncate_seq, truncate_size;
-
- map<pair<uint64_t, entity_name_t>, watch_info_t> watchers;
-
- // opportunistic checksums; may or may not be present
- __u32 data_digest; ///< data crc32c
- __u32 omap_digest; ///< omap crc32c
-
- // alloc hint attribute
- uint64_t expected_object_size, expected_write_size;
- uint32_t alloc_hint_flags;
-
- struct object_manifest_t manifest;
-
- void copy_user_bits(const object_info_t& other);
-
- static ps_t legacy_object_locator_to_ps(const object_t &oid,
- const object_locator_t &loc);
-
- bool test_flag(flag_t f) const {
- return (flags & f) == f;
- }
- void set_flag(flag_t f) {
- flags = (flag_t)(flags | f);
- }
- void clear_flag(flag_t f) {
- flags = (flag_t)(flags & ~f);
- }
- bool is_lost() const {
- return test_flag(FLAG_LOST);
- }
- bool is_whiteout() const {
- return test_flag(FLAG_WHITEOUT);
- }
- bool is_dirty() const {
- return test_flag(FLAG_DIRTY);
- }
- bool is_omap() const {
- return test_flag(FLAG_OMAP);
- }
- bool is_data_digest() const {
- return test_flag(FLAG_DATA_DIGEST);
- }
- bool is_omap_digest() const {
- return test_flag(FLAG_OMAP_DIGEST);
- }
- bool is_cache_pinned() const {
- return test_flag(FLAG_CACHE_PIN);
- }
- bool has_manifest() const {
- return test_flag(FLAG_MANIFEST);
- }
-
- void set_data_digest(__u32 d) {
- set_flag(FLAG_DATA_DIGEST);
- data_digest = d;
- }
- void set_omap_digest(__u32 d) {
- set_flag(FLAG_OMAP_DIGEST);
- omap_digest = d;
- }
- void clear_data_digest() {
- clear_flag(FLAG_DATA_DIGEST);
- data_digest = -1;
- }
- void clear_omap_digest() {
- clear_flag(FLAG_OMAP_DIGEST);
- omap_digest = -1;
- }
- void new_object() {
- set_data_digest(-1);
- set_omap_digest(-1);
- }
-
- void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& bl);
- void decode(bufferlist& bl) {
- bufferlist::iterator p = bl.begin();
- decode(p);
- }
- void dump(Formatter *f) const;
- static void generate_test_instances(list<object_info_t*>& o);
-
- explicit object_info_t()
- : user_version(0), size(0), flags((flag_t)0),
- truncate_seq(0), truncate_size(0),
- data_digest(-1), omap_digest(-1),
- expected_object_size(0), expected_write_size(0),
- alloc_hint_flags(0)
- {}
-
- explicit object_info_t(const hobject_t& s)
- : soid(s),
- user_version(0), size(0), flags((flag_t)0),
- truncate_seq(0), truncate_size(0),
- data_digest(-1), omap_digest(-1),
- expected_object_size(0), expected_write_size(0),
- alloc_hint_flags(0)
- {}
-
- explicit object_info_t(bufferlist& bl) {
- decode(bl);
- }
-};
-WRITE_CLASS_ENCODER_FEATURES(object_info_t)
-
-ostream& operator<<(ostream& out, const object_info_t& oi);
-
-
-
-// Object recovery
-struct ObjectRecoveryInfo {
- hobject_t soid;
- eversion_t version;
- uint64_t size;
- object_info_t oi;
- SnapSet ss; // only populated if soid is_snap()
- interval_set<uint64_t> copy_subset;
- map<hobject_t, interval_set<uint64_t>> clone_subset;
-
- ObjectRecoveryInfo() : size(0) { }
-
- static void generate_test_instances(list<ObjectRecoveryInfo*>& o);
- void encode(bufferlist &bl, uint64_t features) const;
- void decode(bufferlist::iterator &bl, int64_t pool = -1);
- ostream &print(ostream &out) const;
- void dump(Formatter *f) const;
-};
-WRITE_CLASS_ENCODER_FEATURES(ObjectRecoveryInfo)
-ostream& operator<<(ostream& out, const ObjectRecoveryInfo &inf);
-
-struct ObjectRecoveryProgress {
- uint64_t data_recovered_to;
- string omap_recovered_to;
- bool first;
- bool data_complete;
- bool omap_complete;
- bool error = false;
-
- ObjectRecoveryProgress()
- : data_recovered_to(0),
- first(true),
- data_complete(false), omap_complete(false) { }
-
- bool is_complete(const ObjectRecoveryInfo& info) const {
- return (data_recovered_to >= (
- info.copy_subset.empty() ?
- 0 : info.copy_subset.range_end())) &&
- omap_complete;
- }
-
- static void generate_test_instances(list<ObjectRecoveryProgress*>& o);
- void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
- ostream &print(ostream &out) const;
- void dump(Formatter *f) const;
-};
-WRITE_CLASS_ENCODER(ObjectRecoveryProgress)
-ostream& operator<<(ostream& out, const ObjectRecoveryProgress &prog);
-
-struct PushReplyOp {
- hobject_t soid;
-
- static void generate_test_instances(list<PushReplyOp*>& o);
- void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
- ostream &print(ostream &out) const;
- void dump(Formatter *f) const;
-
- uint64_t cost(CephContext *cct) const;
-};
-WRITE_CLASS_ENCODER(PushReplyOp)
-ostream& operator<<(ostream& out, const PushReplyOp &op);
-
-struct PullOp {
- hobject_t soid;
-
- ObjectRecoveryInfo recovery_info;
- ObjectRecoveryProgress recovery_progress;
-
- static void generate_test_instances(list<PullOp*>& o);
- void encode(bufferlist &bl, uint64_t features) const;
- void decode(bufferlist::iterator &bl);
- ostream &print(ostream &out) const;
- void dump(Formatter *f) const;
-
- uint64_t cost(CephContext *cct) const;
-};
-WRITE_CLASS_ENCODER_FEATURES(PullOp)
-ostream& operator<<(ostream& out, const PullOp &op);
-
-struct PushOp {
- hobject_t soid;
- eversion_t version;
- bufferlist data;
- interval_set<uint64_t> data_included;
- bufferlist omap_header;
- map<string, bufferlist> omap_entries;
- map<string, bufferlist> attrset;
-
- ObjectRecoveryInfo recovery_info;
- ObjectRecoveryProgress before_progress;
- ObjectRecoveryProgress after_progress;
-
- static void generate_test_instances(list<PushOp*>& o);
- void encode(bufferlist &bl, uint64_t features) const;
- void decode(bufferlist::iterator &bl);
- ostream &print(ostream &out) const;
- void dump(Formatter *f) const;
-
- uint64_t cost(CephContext *cct) const;
-};
-WRITE_CLASS_ENCODER_FEATURES(PushOp)
-ostream& operator<<(ostream& out, const PushOp &op);
-
-
-/*
- * summarize pg contents for purposes of a scrub
- */
-struct ScrubMap {
- struct object {
- map<string,bufferptr> attrs;
- uint64_t size;
- __u32 omap_digest; ///< omap crc32c
- __u32 digest; ///< data crc32c
- bool negative:1;
- bool digest_present:1;
- bool omap_digest_present:1;
- bool read_error:1;
- bool stat_error:1;
- bool ec_hash_mismatch:1;
- bool ec_size_mismatch:1;
-
- object() :
- // Init invalid size so it won't match if we get a stat EIO error
- size(-1), omap_digest(0), digest(0),
- negative(false), digest_present(false), omap_digest_present(false),
- read_error(false), stat_error(false), ec_hash_mismatch(false), ec_size_mismatch(false) {}
-
- void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<object*>& o);
- };
- WRITE_CLASS_ENCODER(object)
-
- map<hobject_t,object> objects;
- eversion_t valid_through;
- eversion_t incr_since;
-
- void merge_incr(const ScrubMap &l);
- void insert(const ScrubMap &r) {
- objects.insert(r.objects.begin(), r.objects.end());
- }
- void swap(ScrubMap &r) {
- using std::swap;
- swap(objects, r.objects);
- swap(valid_through, r.valid_through);
- swap(incr_since, r.incr_since);
- }
-
- void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl, int64_t pool=-1);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<ScrubMap*>& o);
-};
-WRITE_CLASS_ENCODER(ScrubMap::object)
-WRITE_CLASS_ENCODER(ScrubMap)
-
-struct OSDOp {
- ceph_osd_op op;
- sobject_t soid;
-
- bufferlist indata, outdata;
- errorcode32_t rval;
-
- OSDOp() : rval(0) {
- memset(&op, 0, sizeof(ceph_osd_op));
- }
-
- /**
- * split a bufferlist into constituent indata members of a vector of OSDOps
- *
- * @param ops [out] vector of OSDOps
- * @param in [in] combined data buffer
- */
- static void split_osd_op_vector_in_data(vector<OSDOp>& ops, bufferlist& in);
-
- /**
- * merge indata members of a vector of OSDOp into a single bufferlist
- *
- * Notably this also encodes certain other OSDOp data into the data
- * buffer, including the sobject_t soid.
- *
- * @param ops [in] vector of OSDOps
- * @param out [out] combined data buffer
- */
- static void merge_osd_op_vector_in_data(vector<OSDOp>& ops, bufferlist& out);
-
- /**
- * split a bufferlist into constituent outdata members of a vector of OSDOps
- *
- * @param ops [out] vector of OSDOps
- * @param in [in] combined data buffer
- */
- static void split_osd_op_vector_out_data(vector<OSDOp>& ops, bufferlist& in);
-
- /**
- * merge outdata members of a vector of OSDOps into a single bufferlist
- *
- * @param ops [in] vector of OSDOps
- * @param out [out] combined data buffer
- */
- static void merge_osd_op_vector_out_data(vector<OSDOp>& ops, bufferlist& out);
-
- /**
- * Clear data as much as possible, leave minimal data for historical op dump
- *
- * @param ops [in] vector of OSDOps
- */
- static void clear_data(vector<OSDOp>& ops);
-};
-
-ostream& operator<<(ostream& out, const OSDOp& op);
-
-struct watch_item_t {
- entity_name_t name;
- uint64_t cookie;
- uint32_t timeout_seconds;
- entity_addr_t addr;
-
- watch_item_t() : cookie(0), timeout_seconds(0) { }
- watch_item_t(entity_name_t name, uint64_t cookie, uint32_t timeout,
- const entity_addr_t& addr)
- : name(name), cookie(cookie), timeout_seconds(timeout),
- addr(addr) { }
-
- void encode(bufferlist &bl, uint64_t features) const {
- ENCODE_START(2, 1, bl);
- ::encode(name, bl);
- ::encode(cookie, bl);
- ::encode(timeout_seconds, bl);
- ::encode(addr, bl, features);
- ENCODE_FINISH(bl);
- }
- void decode(bufferlist::iterator &bl) {
- DECODE_START(2, bl);
- ::decode(name, bl);
- ::decode(cookie, bl);
- ::decode(timeout_seconds, bl);
- if (struct_v >= 2) {
- ::decode(addr, bl);
- }
- DECODE_FINISH(bl);
- }
-};
-WRITE_CLASS_ENCODER_FEATURES(watch_item_t)
-
-struct obj_watch_item_t {
- hobject_t obj;
- watch_item_t wi;
-};
-
-/**
- * obj list watch response format
- *
- */
-struct obj_list_watch_response_t {
- list<watch_item_t> entries;
-
- void encode(bufferlist& bl, uint64_t features) const {
- ENCODE_START(1, 1, bl);
- ::encode(entries, bl, features);
- ENCODE_FINISH(bl);
- }
- void decode(bufferlist::iterator& bl) {
- DECODE_START(1, bl);
- ::decode(entries, bl);
- DECODE_FINISH(bl);
- }
- void dump(Formatter *f) const {
- f->open_array_section("entries");
- for (list<watch_item_t>::const_iterator p = entries.begin(); p != entries.end(); ++p) {
- f->open_object_section("watch");
- f->dump_stream("watcher") << p->name;
- f->dump_int("cookie", p->cookie);
- f->dump_int("timeout", p->timeout_seconds);
- f->open_object_section("addr");
- p->addr.dump(f);
- f->close_section();
- f->close_section();
- }
- f->close_section();
- }
- static void generate_test_instances(list<obj_list_watch_response_t*>& o) {
- entity_addr_t ea;
- o.push_back(new obj_list_watch_response_t);
- o.push_back(new obj_list_watch_response_t);
- ea.set_type(entity_addr_t::TYPE_LEGACY);
- ea.set_nonce(1000);
- ea.set_family(AF_INET);
- ea.set_in4_quad(0, 127);
- ea.set_in4_quad(1, 0);
- ea.set_in4_quad(2, 0);
- ea.set_in4_quad(3, 1);
- ea.set_port(1024);
- o.back()->entries.push_back(watch_item_t(entity_name_t(entity_name_t::TYPE_CLIENT, 1), 10, 30, ea));
- ea.set_nonce(1001);
- ea.set_in4_quad(3, 2);
- ea.set_port(1025);
- o.back()->entries.push_back(watch_item_t(entity_name_t(entity_name_t::TYPE_CLIENT, 2), 20, 60, ea));
- }
-};
-WRITE_CLASS_ENCODER_FEATURES(obj_list_watch_response_t)
-
-struct clone_info {
- snapid_t cloneid;
- vector<snapid_t> snaps; // ascending
- vector< pair<uint64_t,uint64_t> > overlap;
- uint64_t size;
-
- clone_info() : cloneid(CEPH_NOSNAP), size(0) {}
-
- void encode(bufferlist& bl) const {
- ENCODE_START(1, 1, bl);
- ::encode(cloneid, bl);
- ::encode(snaps, bl);
- ::encode(overlap, bl);
- ::encode(size, bl);
- ENCODE_FINISH(bl);
- }
- void decode(bufferlist::iterator& bl) {
- DECODE_START(1, bl);
- ::decode(cloneid, bl);
- ::decode(snaps, bl);
- ::decode(overlap, bl);
- ::decode(size, bl);
- DECODE_FINISH(bl);
- }
- void dump(Formatter *f) const {
- if (cloneid == CEPH_NOSNAP)
- f->dump_string("cloneid", "HEAD");
- else
- f->dump_unsigned("cloneid", cloneid.val);
- f->open_array_section("snapshots");
- for (vector<snapid_t>::const_iterator p = snaps.begin(); p != snaps.end(); ++p) {
- f->open_object_section("snap");
- f->dump_unsigned("id", p->val);
- f->close_section();
- }
- f->close_section();
- f->open_array_section("overlaps");
- for (vector< pair<uint64_t,uint64_t> >::const_iterator q = overlap.begin();
- q != overlap.end(); ++q) {
- f->open_object_section("overlap");
- f->dump_unsigned("offset", q->first);
- f->dump_unsigned("length", q->second);
- f->close_section();
- }
- f->close_section();
- f->dump_unsigned("size", size);
- }
- static void generate_test_instances(list<clone_info*>& o) {
- o.push_back(new clone_info);
- o.push_back(new clone_info);
- o.back()->cloneid = 1;
- o.back()->snaps.push_back(1);
- o.back()->overlap.push_back(pair<uint64_t,uint64_t>(0,4096));
- o.back()->overlap.push_back(pair<uint64_t,uint64_t>(8192,4096));
- o.back()->size = 16384;
- o.push_back(new clone_info);
- o.back()->cloneid = CEPH_NOSNAP;
- o.back()->size = 32768;
- }
-};
-WRITE_CLASS_ENCODER(clone_info)
-
-/**
- * obj list snaps response format
- *
- */
-struct obj_list_snap_response_t {
- vector<clone_info> clones; // ascending
- snapid_t seq;
-
- void encode(bufferlist& bl) const {
- ENCODE_START(2, 1, bl);
- ::encode(clones, bl);
- ::encode(seq, bl);
- ENCODE_FINISH(bl);
- }
- void decode(bufferlist::iterator& bl) {
- DECODE_START(2, bl);
- ::decode(clones, bl);
- if (struct_v >= 2)
- ::decode(seq, bl);
- else
- seq = CEPH_NOSNAP;
- DECODE_FINISH(bl);
- }
- void dump(Formatter *f) const {
- f->open_array_section("clones");
- for (vector<clone_info>::const_iterator p = clones.begin(); p != clones.end(); ++p) {
- f->open_object_section("clone");
- p->dump(f);
- f->close_section();
- }
- f->dump_unsigned("seq", seq);
- f->close_section();
- }
- static void generate_test_instances(list<obj_list_snap_response_t*>& o) {
- o.push_back(new obj_list_snap_response_t);
- o.push_back(new obj_list_snap_response_t);
- clone_info cl;
- cl.cloneid = 1;
- cl.snaps.push_back(1);
- cl.overlap.push_back(pair<uint64_t,uint64_t>(0,4096));
- cl.overlap.push_back(pair<uint64_t,uint64_t>(8192,4096));
- cl.size = 16384;
- o.back()->clones.push_back(cl);
- cl.cloneid = CEPH_NOSNAP;
- cl.snaps.clear();
- cl.overlap.clear();
- cl.size = 32768;
- o.back()->clones.push_back(cl);
- o.back()->seq = 123;
- }
-};
-
-WRITE_CLASS_ENCODER(obj_list_snap_response_t)
-
-// PromoteCounter
-
-struct PromoteCounter {
- std::atomic_ullong attempts{0};
- std::atomic_ullong objects{0};
- std::atomic_ullong bytes{0};
-
- void attempt() {
- attempts++;
- }
-
- void finish(uint64_t size) {
- objects++;
- bytes += size;
- }
-
- void sample_and_attenuate(uint64_t *a, uint64_t *o, uint64_t *b) {
- *a = attempts;
- *o = objects;
- *b = bytes;
- attempts = *a / 2;
- objects = *o / 2;
- bytes = *b / 2;
- }
-};
-
-/** store_statfs_t
- * ObjectStore full statfs information
- */
-struct store_statfs_t
-{
- uint64_t total = 0; // Total bytes
- uint64_t available = 0; // Free bytes available
-
- int64_t allocated = 0; // Bytes allocated by the store
- int64_t stored = 0; // Bytes actually stored by the user
- int64_t compressed = 0; // Bytes stored after compression
- int64_t compressed_allocated = 0; // Bytes allocated for compressed data
- int64_t compressed_original = 0; // Bytes that were successfully compressed
-
- void reset() {
- *this = store_statfs_t();
- }
- bool operator ==(const store_statfs_t& other) const;
- void dump(Formatter *f) const;
-};
-ostream &operator<<(ostream &lhs, const store_statfs_t &rhs);
-
-#endif
Code Review / stor4nfv.git / blobdiff