ceph/src/messages/MMDSResolve.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_MMDSRESOLVE_H
  16 #define CEPH_MMDSRESOLVE_H
  17
  18 #include "msg/Message.h"
  19
  20 #include "include/types.h"
  21
  22 #include "mds/Capability.h"
  23
  24 class MMDSResolve : public SafeMessage {
  25   static const int HEAD_VERSION = 1;
  26   static const int COMPAT_VERSION = 1;
  27
  28 public:
  29   map<dirfrag_t, vector<dirfrag_t> > subtrees;
  30   map<dirfrag_t, vector<dirfrag_t> > ambiguous_imports;
  31
  32   class slave_inode_cap {
  33   public:
  34     inodeno_t ino;
  35     map<client_t,Capability::Export> cap_exports;
  36     slave_inode_cap() {}
  37     slave_inode_cap(inodeno_t a, map<client_t, Capability::Export> b) : ino(a), cap_exports(b) {}
  38     void encode(bufferlist &bl) const
  39     {
  40       ENCODE_START(1, 1, bl);
  41       encode(ino, bl);
  42       encode(cap_exports, bl);
  43       ENCODE_FINISH(bl);
  44     }
  45     void decode(bufferlist::const_iterator &blp)
  46     {
  47       DECODE_START(1, blp);
  48       decode(ino, blp);
  49       decode(cap_exports, blp);
  50       DECODE_FINISH(blp);
  51     }
  52   };
  53   WRITE_CLASS_ENCODER(slave_inode_cap)
  54
  55   struct slave_request {
  56     bufferlist inode_caps;
  57     bool committing;
  58     slave_request() : committing(false) {}
  59     void encode(bufferlist &bl) const {
  60       ENCODE_START(1, 1, bl);
  61       encode(inode_caps, bl);
  62       encode(committing, bl);
  63       ENCODE_FINISH(bl);
  64     }
  65     void decode(bufferlist::const_iterator &blp) {
  66       DECODE_START(1, blp);
  67       decode(inode_caps, blp);
  68       decode(committing, blp);
  69       DECODE_FINISH(blp);
  70     }
  71   };
  72
  73   map<metareqid_t, slave_request> slave_requests;
  74
  75   // table client information
  76   struct table_client {
  77     __u8 type;
  78     set<version_t> pending_commits;
  79
  80     table_client() : type(0) {}
  81     table_client(int _type, const set<version_t>& commits)
  82       : type(_type), pending_commits(commits) {}
  83
  84     void encode(bufferlist& bl) const {
  85       using ceph::encode;
  86       encode(type, bl);
  87       encode(pending_commits, bl);
  88     }
  89     void decode(bufferlist::const_iterator& bl) {
  90       using ceph::decode;
  91       decode(type, bl);
  92       decode(pending_commits, bl);
  93     }
  94   };
  95
  96   list<table_client> table_clients;
  97
  98 protected:
  99   MMDSResolve() : SafeMessage{MSG_MDS_RESOLVE, HEAD_VERSION, COMPAT_VERSION}
 100  {}
 101   ~MMDSResolve() override {}
 102
 103 public:
 104   std::string_view get_type_name() const override { return "mds_resolve"; }
 105
 106   void print(ostream& out) const override {
 107     out << "mds_resolve(" << subtrees.size()
 108         << "+" << ambiguous_imports.size()
 109         << " subtrees +" << slave_requests.size() << " slave requests)";
 110   }
 111
 112   void add_subtree(dirfrag_t im) {
 113     subtrees[im].clear();
 114   }
 115   void add_subtree_bound(dirfrag_t im, dirfrag_t ex) {
 116     subtrees[im].push_back(ex);
 117   }
 118
 119   void add_ambiguous_import(dirfrag_t im, const vector<dirfrag_t>& m) {
 120     ambiguous_imports[im] = m;
 121   }
 122
 123   void add_slave_request(metareqid_t reqid, bool committing) {
 124     slave_requests[reqid].committing = committing;
 125   }
 126
 127   void add_slave_request(metareqid_t reqid, bufferlist& bl) {
 128     slave_requests[reqid].inode_caps.claim(bl);
 129   }
 130
 131   void add_table_commits(int table, const set<version_t>& pending_commits) {
 132     table_clients.push_back(table_client(table, pending_commits));
 133   }
 134
 135   void encode_payload(uint64_t features) override {
 136     using ceph::encode;
 137     encode(subtrees, payload);
 138     encode(ambiguous_imports, payload);
 139     encode(slave_requests, payload);
 140     encode(table_clients, payload);
 141   }
 142   void decode_payload() override {
 143     using ceph::decode;
 144     auto p = payload.cbegin();
 145     decode(subtrees, p);
 146     decode(ambiguous_imports, p);
 147     decode(slave_requests, p);
 148     decode(table_clients, p);
 149   }
 150 private:
 151   template<class T, typename... Args>
 152   friend boost::intrusive_ptr<T> ceph::make_message(Args&&... args);
 153 };
 154
 155 inline ostream& operator<<(ostream& out, const MMDSResolve::slave_request&) {
 156     return out;
 157 }
 158
 159 WRITE_CLASS_ENCODER(MMDSResolve::slave_request)
 160 WRITE_CLASS_ENCODER(MMDSResolve::table_client)
 161 WRITE_CLASS_ENCODER(MMDSResolve::slave_inode_cap)
 162 #endif