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=bc4d48d24f901f47a33851d161c03c7586a4ceef;hb=812ff6ca9fcd3e629e49d4328905f33eee8ca3f5;hp=0000000000000000000000000000000000000000;hpb=15280273faafb77777eab341909a3f495cf248d9;p=stor4nfv.git diff --git a/src/ceph/src/messages/MMDSCacheRejoin.h b/src/ceph/src/messages/MMDSCacheRejoin.h new file mode 100644 index 0000000..bc4d48d --- /dev/null +++ b/src/ceph/src/messages/MMDSCacheRejoin.h @@ -0,0 +1,347 @@ +// -*- 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