ceph/src/messages/MRecoveryReserve.h

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3 /*
   4  * Ceph - scalable distributed file system
   5  *
   6  * Copyright (C) 2004-2006 Sage Weil <sage@newdream.net>
   7  *
   8  * This is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License version 2.1, as published by the Free Software
  11  * Foundation.  See file COPYING.
  12  *
  13  */
  14
  15 #ifndef CEPH_MRECOVERY_H
  16 #define CEPH_MRECOVERY_H
  17
  18 #include "msg/Message.h"
  19 #include "messages/MOSDPeeringOp.h"
  20 #include "osd/PGPeeringEvent.h"
  21
  22 class MRecoveryReserve : public MOSDPeeringOp {
  23 private:
  24   static constexpr int HEAD_VERSION = 3;
  25   static constexpr int COMPAT_VERSION = 2;
  26 public:
  27   spg_t pgid;
  28   epoch_t query_epoch;
  29   enum {
  30     REQUEST = 0,   // primary->replica: please reserve slot
  31     GRANT = 1,     // replica->primary: ok, i reserved it
  32     RELEASE = 2,   // primary->replica: release the slot i reserved before
  33     REVOKE = 3,    // replica->primary: i'm taking back the slot i gave you
  34   };
  35   uint32_t type;
  36   uint32_t priority = 0;
  37
  38   spg_t get_spg() const {
  39     return pgid;
  40   }
  41   epoch_t get_map_epoch() const {
  42     return query_epoch;
  43   }
  44   epoch_t get_min_epoch() const {
  45     return query_epoch;
  46   }
  47
  48   PGPeeringEvent *get_event() override {
  49     switch (type) {
  50     case REQUEST:
  51       return new PGPeeringEvent(
  52         query_epoch,
  53         query_epoch,
  54         RequestRecoveryPrio(priority));
  55     case GRANT:
  56       return new PGPeeringEvent(
  57         query_epoch,
  58         query_epoch,
  59         RemoteRecoveryReserved());
  60     case RELEASE:
  61       return new PGPeeringEvent(
  62         query_epoch,
  63         query_epoch,
  64         RecoveryDone());
  65     case REVOKE:
  66       return new PGPeeringEvent(
  67         query_epoch,
  68         query_epoch,
  69         DeferRecovery(0.0));
  70     default:
  71       ceph_abort();
  72     }
  73   }
  74
  75   MRecoveryReserve()
  76     : MOSDPeeringOp{MSG_OSD_RECOVERY_RESERVE, HEAD_VERSION, COMPAT_VERSION},
  77       query_epoch(0), type(-1) {}
  78   MRecoveryReserve(int type,
  79                    spg_t pgid,
  80                    epoch_t query_epoch,
  81                    unsigned prio = 0)
  82     : MOSDPeeringOp{MSG_OSD_RECOVERY_RESERVE, HEAD_VERSION, COMPAT_VERSION},
  83       pgid(pgid), query_epoch(query_epoch),
  84       type(type), priority(prio) {}
  85
  86   std::string_view get_type_name() const override {
  87     return "MRecoveryReserve";
  88   }
  89
  90   void inner_print(ostream& out) const override {
  91     switch (type) {
  92     case REQUEST:
  93       out << "REQUEST";
  94       break;
  95     case GRANT:
  96       out << "GRANT";
  97       break;
  98     case RELEASE:
  99       out << "RELEASE";
 100       break;
 101     case REVOKE:
 102       out << "REVOKE";
 103       break;
 104     }
 105     if (type == REQUEST) out << " prio: " << priority;
 106   }
 107
 108   void decode_payload() override {
 109     auto p = payload.cbegin();
 110     decode(pgid.pgid, p);
 111     decode(query_epoch, p);
 112     decode(type, p);
 113     decode(pgid.shard, p);
 114     if (header.version >= 3) {
 115       decode(priority, p);
 116     }
 117   }
 118
 119   void encode_payload(uint64_t features) override {
 120     using ceph::encode;
 121     encode(pgid.pgid, payload);
 122     encode(query_epoch, payload);
 123     encode(type, payload);
 124     encode(pgid.shard, payload);
 125     encode(priority, payload);
 126   }
 127 private:
 128   template<class T, typename... Args>
 129   friend boost::intrusive_ptr<T> ceph::make_message(Args&&... args);
 130 };
 131
 132 #endif