X-Git-Url: https://gerrit.opnfv.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fceph%2Fsrc%2Fmessages%2FMMDSCacheRejoin.h;fp=src%2Fceph%2Fsrc%2Fmessages%2FMMDSCacheRejoin.h;h=0000000000000000000000000000000000000000;hb=7da45d65be36d36b880cc55c5036e96c24b53f00;hp=bc4d48d24f901f47a33851d161c03c7586a4ceef;hpb=691462d09d0987b47e112d6ee8740375df3c51b2;p=stor4nfv.git diff --git a/src/ceph/src/messages/MMDSCacheRejoin.h b/src/ceph/src/messages/MMDSCacheRejoin.h deleted file mode 100644 index bc4d48d..0000000 --- a/src/ceph/src/messages/MMDSCacheRejoin.h +++ /dev/null @@ -1,347 +0,0 @@ -// -*- 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 - * - * 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_MMDSCACHEREJOIN_H -#define CEPH_MMDSCACHEREJOIN_H - -#include "msg/Message.h" - -#include "include/types.h" - -#include "mds/CInode.h" -#include "mds/CDir.h" -#include "mds/mdstypes.h" - -// sent from replica to auth - -class MMDSCacheRejoin : public Message { - - static const int HEAD_VERSION = 1; - static const int COMPAT_VERSION = 1; - - public: - static const int OP_WEAK = 1; // replica -> auth, i exist, + maybe open files. - static const int OP_STRONG = 2; // replica -> auth, i exist, + open files and lock state. - static const int OP_ACK = 3; // auth -> replica, here is your lock state. - static const char *get_opname(int op) { - switch (op) { - case OP_WEAK: return "weak"; - case OP_STRONG: return "strong"; - case OP_ACK: return "ack"; - default: ceph_abort(); return 0; - } - } - - // -- types -- - struct inode_strong { - uint32_t nonce; - int32_t caps_wanted; - int32_t filelock, nestlock, dftlock; - inode_strong() {} - inode_strong(int n, int cw, int dl, int nl, int dftl) : - nonce(n), caps_wanted(cw), - filelock(dl), nestlock(nl), dftlock(dftl) { } - void encode(bufferlist &bl) const { - ::encode(nonce, bl); - ::encode(caps_wanted, bl); - ::encode(filelock, bl); - ::encode(nestlock, bl); - ::encode(dftlock, bl); - } - void decode(bufferlist::iterator &bl) { - ::decode(nonce, bl); - ::decode(caps_wanted, bl); - ::decode(filelock, bl); - ::decode(nestlock, bl); - ::decode(dftlock, bl); - } - }; - WRITE_CLASS_ENCODER(inode_strong) - - struct dirfrag_strong { - uint32_t nonce; - int8_t dir_rep; - dirfrag_strong() {} - dirfrag_strong(int n, int dr) : nonce(n), dir_rep(dr) {} - void encode(bufferlist &bl) const { - ::encode(nonce, bl); - ::encode(dir_rep, bl); - } - void decode(bufferlist::iterator &bl) { - ::decode(nonce, bl); - ::decode(dir_rep, bl); - } - }; - WRITE_CLASS_ENCODER(dirfrag_strong) - - struct dn_strong { - snapid_t first; - inodeno_t ino; - inodeno_t remote_ino; - unsigned char remote_d_type; - uint32_t nonce; - int32_t lock; - dn_strong() : - ino(0), remote_ino(0), remote_d_type(0), nonce(0), lock(0) {} - dn_strong(snapid_t f, inodeno_t pi, inodeno_t ri, unsigned char rdt, int n, int l) : - first(f), ino(pi), remote_ino(ri), remote_d_type(rdt), nonce(n), lock(l) {} - bool is_primary() { return ino > 0; } - bool is_remote() { return remote_ino > 0; } - bool is_null() { return ino == 0 && remote_ino == 0; } - void encode(bufferlist &bl) const { - ::encode(first, bl); - ::encode(ino, bl); - ::encode(remote_ino, bl); - ::encode(remote_d_type, bl); - ::encode(nonce, bl); - ::encode(lock, bl); - } - void decode(bufferlist::iterator &bl) { - ::decode(first, bl); - ::decode(ino, bl); - ::decode(remote_ino, bl); - ::decode(remote_d_type, bl); - ::decode(nonce, bl); - ::decode(lock, bl); - } - }; - WRITE_CLASS_ENCODER(dn_strong) - - struct dn_weak { - snapid_t first; - inodeno_t ino; - dn_weak() : ino(0) {} - dn_weak(snapid_t f, inodeno_t pi) : first(f), ino(pi) {} - void encode(bufferlist &bl) const { - ::encode(first, bl); - ::encode(ino, bl); - } - void decode(bufferlist::iterator &bl) { - ::decode(first, bl); - ::decode(ino, bl); - } - }; - WRITE_CLASS_ENCODER(dn_weak) - - // -- data -- - int32_t op; - - struct lock_bls { - bufferlist file, nest, dft; - void encode(bufferlist& bl) const { - ::encode(file, bl); - ::encode(nest, bl); - ::encode(dft, bl); - } - void decode(bufferlist::iterator& bl) { - ::decode(file, bl); - ::decode(nest, bl); - ::decode(dft, bl); - } - }; - WRITE_CLASS_ENCODER(lock_bls) - - // weak - map > weak; - set weak_dirfrags; - set weak_inodes; - map inode_scatterlocks; - - // strong - map strong_dirfrags; - map > strong_dentries; - map strong_inodes; - - // open - map > cap_exports; - map client_map; - bufferlist imported_caps; - - // full - bufferlist inode_base; - bufferlist inode_locks; - map dirfrag_bases; - - // authpins, xlocks - struct slave_reqid { - metareqid_t reqid; - __u32 attempt; - slave_reqid() : attempt(0) {} - slave_reqid(const metareqid_t& r, __u32 a) - : reqid(r), attempt(a) {} - void encode(bufferlist& bl) const { - ::encode(reqid, bl); - ::encode(attempt, bl); - } - void decode(bufferlist::iterator& bl) { - ::decode(reqid, bl); - ::decode(attempt, bl); - } - }; - map > authpinned_inodes; - map frozen_authpin_inodes; - map > xlocked_inodes; - map > > wrlocked_inodes; - map > > authpinned_dentries; - map > xlocked_dentries; - - MMDSCacheRejoin() : - Message(MSG_MDS_CACHEREJOIN, HEAD_VERSION, COMPAT_VERSION), - op(0) {} - MMDSCacheRejoin(int o) : - Message(MSG_MDS_CACHEREJOIN, HEAD_VERSION, COMPAT_VERSION), - op(o) {} -private: - ~MMDSCacheRejoin() override {} - -public: - const char *get_type_name() const override { return "cache_rejoin"; } - void print(ostream& out) const override { - out << "cache_rejoin " << get_opname(op); - } - - // -- builders -- - // inodes - void add_weak_inode(vinodeno_t i) { - weak_inodes.insert(i); - } - void add_strong_inode(vinodeno_t i, int n, int cw, int dl, int nl, int dftl) { - strong_inodes[i] = inode_strong(n, cw, dl, nl, dftl); - } - void add_inode_locks(CInode *in, __u32 nonce, bufferlist& bl) { - ::encode(in->inode.ino, inode_locks); - ::encode(in->last, inode_locks); - ::encode(nonce, inode_locks); - ::encode(bl, inode_locks); - } - void add_inode_base(CInode *in, uint64_t features) { - ::encode(in->inode.ino, inode_base); - ::encode(in->last, inode_base); - bufferlist bl; - in->_encode_base(bl, features); - ::encode(bl, inode_base); - } - void add_inode_authpin(vinodeno_t ino, const metareqid_t& ri, __u32 attempt) { - authpinned_inodes[ino].push_back(slave_reqid(ri, attempt)); - } - void add_inode_frozen_authpin(vinodeno_t ino, const metareqid_t& ri, __u32 attempt) { - frozen_authpin_inodes[ino] = slave_reqid(ri, attempt); - } - void add_inode_xlock(vinodeno_t ino, int lt, const metareqid_t& ri, __u32 attempt) { - xlocked_inodes[ino][lt] = slave_reqid(ri, attempt); - } - void add_inode_wrlock(vinodeno_t ino, int lt, const metareqid_t& ri, __u32 attempt) { - wrlocked_inodes[ino][lt].push_back(slave_reqid(ri, attempt)); - } - - void add_scatterlock_state(CInode *in) { - if (inode_scatterlocks.count(in->ino())) - return; // already added this one - in->encode_lock_state(CEPH_LOCK_IFILE, inode_scatterlocks[in->ino()].file); - in->encode_lock_state(CEPH_LOCK_INEST, inode_scatterlocks[in->ino()].nest); - in->encode_lock_state(CEPH_LOCK_IDFT, inode_scatterlocks[in->ino()].dft); - } - - // dirfrags - void add_strong_dirfrag(dirfrag_t df, int n, int dr) { - strong_dirfrags[df] = dirfrag_strong(n, dr); - } - void add_dirfrag_base(CDir *dir) { - bufferlist& bl = dirfrag_bases[dir->dirfrag()]; - dir->_encode_base(bl); - } - - // dentries - void add_weak_dirfrag(dirfrag_t df) { - weak_dirfrags.insert(df); - } - void add_weak_dentry(inodeno_t dirino, const string& dname, snapid_t last, dn_weak& dnw) { - weak[dirino][string_snap_t(dname, last)] = dnw; - } - void add_weak_primary_dentry(inodeno_t dirino, const string& dname, snapid_t first, snapid_t last, inodeno_t ino) { - weak[dirino][string_snap_t(dname, last)] = dn_weak(first, ino); - } - void add_strong_dentry(dirfrag_t df, const string& dname, snapid_t first, snapid_t last, inodeno_t pi, inodeno_t ri, unsigned char rdt, int n, int ls) { - strong_dentries[df][string_snap_t(dname, last)] = dn_strong(first, pi, ri, rdt, n, ls); - } - void add_dentry_authpin(dirfrag_t df, const string& dname, snapid_t last, - const metareqid_t& ri, __u32 attempt) { - authpinned_dentries[df][string_snap_t(dname, last)].push_back(slave_reqid(ri, attempt)); - } - void add_dentry_xlock(dirfrag_t df, const string& dname, snapid_t last, - const metareqid_t& ri, __u32 attempt) { - xlocked_dentries[df][string_snap_t(dname, last)] = slave_reqid(ri, attempt); - } - - // -- encoding -- - void encode_payload(uint64_t features) override { - ::encode(op, payload); - ::encode(strong_inodes, payload); - ::encode(inode_base, payload); - ::encode(inode_locks, payload); - ::encode(inode_scatterlocks, payload); - ::encode(authpinned_inodes, payload); - ::encode(frozen_authpin_inodes, payload); - ::encode(xlocked_inodes, payload); - ::encode(wrlocked_inodes, payload); - ::encode(cap_exports, payload); - ::encode(client_map, payload, features); - ::encode(imported_caps, payload); - ::encode(strong_dirfrags, payload); - ::encode(dirfrag_bases, payload); - ::encode(weak, payload); - ::encode(weak_dirfrags, payload); - ::encode(weak_inodes, payload); - ::encode(strong_dentries, payload); - ::encode(authpinned_dentries, payload); - ::encode(xlocked_dentries, payload); - } - void decode_payload() override { - bufferlist::iterator p = payload.begin(); - ::decode(op, p); - ::decode(strong_inodes, p); - ::decode(inode_base, p); - ::decode(inode_locks, p); - ::decode(inode_scatterlocks, p); - ::decode(authpinned_inodes, p); - ::decode(frozen_authpin_inodes, p); - ::decode(xlocked_inodes, p); - ::decode(wrlocked_inodes, p); - ::decode(cap_exports, p); - ::decode(client_map, p); - ::decode(imported_caps, p); - ::decode(strong_dirfrags, p); - ::decode(dirfrag_bases, p); - ::decode(weak, p); - ::decode(weak_dirfrags, p); - ::decode(weak_inodes, p); - ::decode(strong_dentries, p); - ::decode(authpinned_dentries, p); - ::decode(xlocked_dentries, p); - } - -}; - -WRITE_CLASS_ENCODER(MMDSCacheRejoin::inode_strong) -WRITE_CLASS_ENCODER(MMDSCacheRejoin::dirfrag_strong) -WRITE_CLASS_ENCODER(MMDSCacheRejoin::dn_strong) -WRITE_CLASS_ENCODER(MMDSCacheRejoin::dn_weak) -WRITE_CLASS_ENCODER(MMDSCacheRejoin::lock_bls) -WRITE_CLASS_ENCODER(MMDSCacheRejoin::slave_reqid) - -inline ostream& operator<<(ostream& out, const MMDSCacheRejoin::slave_reqid& r) { - return out << r.reqid << '.' << r.attempt; -} - -#endif