From 4ae3dfb307c2d7b5da002b2a3f74f55908a25e70 Mon Sep 17 00:00:00 2001 From: Sage Weil Date: Thu, 8 May 2008 13:11:28 -0700 Subject: [PATCH] fully removed encodable.h --- src/Makefile.am | 1 - src/client/Client.cc | 22 +- src/include/encodable.h | 426 -------------------------------- src/include/types.h | 2 + src/mds/Locker.cc | 2 +- src/mds/Server.cc | 8 +- src/mds/mdstypes.h | 22 +- src/messages/MClientReply.h | 66 ++--- src/messages/MLock.h | 26 +- src/messages/MMDSCacheRejoin.h | 126 +++++++--- src/messages/MMDSGetMap.h | 9 +- src/messages/MMDSSlaveRequest.h | 45 ++-- 12 files changed, 202 insertions(+), 553 deletions(-) delete mode 100644 src/include/encodable.h diff --git a/src/Makefile.am b/src/Makefile.am index 203831f68a30b..73db5362bccaf 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -293,7 +293,6 @@ noinst_HEADERS = \ include/statlite.h\ include/triple.h\ include/uofs.h\ - include/encodable.h\ include/byteorder.h\ include/inttypes.h\ include/utime.h\ diff --git a/src/client/Client.cc b/src/client/Client.cc index 7f86168b7afa4..c96b5d29e5579 100644 --- a/src/client/Client.cc +++ b/src/client/Client.cc @@ -500,8 +500,8 @@ Inode* Client::insert_trace(MClientReply *reply, utime_t from) } __u16 numi, numd; - ::_decode_simple(numi, p); - ::_decode_simple(numd, p); + ::decode(numi, p); + ::decode(numd, p); dout(10) << "insert_trace got " << numi << " inodes, " << numd << " dentries" << dendl; // decode @@ -522,15 +522,15 @@ Inode* Client::insert_trace(MClientReply *reply, utime_t from) inode: if (!ileft) goto done; ileft--; - ist[ileft]._decode(p); - ::_decode_simple(ilease[ileft], p); + ist[ileft].decode(p); + ::decode(ilease[ileft], p); dentry: if (!dleft) goto done; dleft--; - ::_decode_simple(dname[dleft], p); - ::_decode_simple(dlease[dleft], p); - dst[dleft]._decode(p); + ::decode(dname[dleft], p); + ::decode(dlease[dleft], p); + dst[dleft].decode(p); goto inode; done: @@ -2529,15 +2529,15 @@ int Client::_readdir_get_frag(DirResult *dirp) // dirstat DirStat dst(p); __u32 numdn; - ::_decode_simple(numdn, p); + ::decode(numdn, p); string dname; LeaseStat dlease, ilease; while (numdn) { - ::_decode_simple(dname, p); - ::_decode_simple(dlease, p); + ::decode(dname, p); + ::decode(dlease, p); InodeStat ist(p); - ::_decode_simple(ilease, p); + ::decode(ilease, p); // cache Inode *in = this->insert_dentry_inode(dir, dname, &dlease, &ist, &ilease, from); diff --git a/src/include/encodable.h b/src/include/encodable.h deleted file mode 100644 index ca19fcd538aa7..0000000000000 --- a/src/include/encodable.h +++ /dev/null @@ -1,426 +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 __ENCODABLE_H -#define __ENCODABLE_H - -//#warning "deprecated" - -#include "buffer.h" - -#include -#include -#include -#include -#include -#include - - -// ================================================================== -// simple - - -// raw -template -inline void _encode_raw(const T& t, bufferlist& bl) -{ - bl.append((char*)&t, sizeof(t)); -} -template -inline void _decode_raw(T& t, bufferlist::iterator &p) -{ - p.copy(sizeof(t), (char*)&t); -} - -#include -#include -#include -#include -#include -#include - -// list -template -inline void _encode_simple(const std::list& ls, bufferlist& bl) -{ - // should i pre- or post- count? - if (!ls.empty()) { - unsigned pos = bl.length(); - uint32_t n = 0; - _encode_raw(n, bl); - for (typename std::list::const_iterator p = ls.begin(); p != ls.end(); ++p) { - n++; - _encode_simple(*p, bl); - } - bl.copy_in(pos, sizeof(n), (char*)&n); - } else { - uint32_t n = ls.size(); // FIXME: this is slow on a list. - _encode_raw(n, bl); - for (typename std::list::const_iterator p = ls.begin(); p != ls.end(); ++p) - _encode_simple(*p, bl); - } -} -template -inline void _decode_simple(std::list& ls, bufferlist::iterator& p) -{ - uint32_t n; - _decode_raw(n, p); - ls.clear(); - while (n--) { - T v; - _decode_simple(v, p); - ls.push_back(v); - } -} - -// deque -template -inline void _encode_simple(const std::deque& ls, bufferlist& bl) -{ - uint32_t n = ls.size(); - _encode_raw(n, bl); - for (typename std::deque::const_iterator p = ls.begin(); p != ls.end(); ++p) - _encode_simple(*p, bl); -} -template -inline void _decode_simple(std::deque& ls, bufferlist::iterator& p) -{ - uint32_t n; - _decode_raw(n, p); - ls.clear(); - while (n--) { - T v; - _decode_simple(v, p); - ls.push_back(v); - } -} - -// set -template -inline void _encode_simple(const std::set& s, bufferlist& bl) -{ - uint32_t n = s.size(); - _encode_raw(n, bl); - for (typename std::set::const_iterator p = s.begin(); p != s.end(); ++p) - _encode_simple(*p, bl); -} -template -inline void _decode_simple(std::set& s, bufferlist::iterator& p) -{ - uint32_t n; - _decode_raw(n, p); - s.clear(); - while (n--) { - T v; - _decode_simple(v, p); - s.insert(v); - } -} - -// vector -template -inline void _encode_simple(const std::vector& v, bufferlist& bl) -{ - uint32_t n = v.size(); - _encode_raw(n, bl); - for (typename std::vector::const_iterator p = v.begin(); p != v.end(); ++p) - _encode_simple(*p, bl); -} -template -inline void _decode_simple(std::vector& v, bufferlist::iterator& p) -{ - uint32_t n; - _decode_raw(n, p); - v.resize(n); - for (uint32_t i=0; i -inline void _encode_simple(const std::map& m, bufferlist& bl) -{ - uint32_t n = m.size(); - _encode_raw(n, bl); - for (typename std::map::const_iterator p = m.begin(); p != m.end(); ++p) { - _encode_simple(p->first, bl); - _encode_simple(p->second, bl); - } -} -template -inline void _decode_simple(std::map& m, bufferlist::iterator& p) -{ - uint32_t n; - _decode_raw(n, p); - m.clear(); - while (n--) { - T k; - _decode_simple(k, p); - _decode_simple(m[k], p); - } -} - -// hash_map -template -inline void _encode_simple(const __gnu_cxx::hash_map& m, bufferlist& bl) -{ - uint32_t n = m.size(); - _encode_raw(n, bl); - for (typename __gnu_cxx::hash_map::const_iterator p = m.begin(); p != m.end(); ++p) { - _encode_simple(p->first, bl); - _encode_simple(p->second, bl); - } -} -template -inline void _decode_simple(__gnu_cxx::hash_map& m, bufferlist::iterator& p) -{ - uint32_t n; - _decode_raw(n, p); - m.clear(); - while (n--) { - T k; - _decode_simple(k, p); - _decode_simple(m[k], p); - } -} - -// string -inline void _encode_simple(const std::string& s, bufferlist& bl) -{ - uint32_t len = s.length(); - _encode_raw(len, bl); - bl.append(s.data(), len); -} -inline void _decode_simple(std::string& s, bufferlist::iterator& p) -{ - uint32_t len; - _decode_raw(len, p); - s.clear(); - p.copy(len, s); -} - -// const char* (encode only, string compatible) -inline void _encode_simple(const char *s, bufferlist& bl) -{ - uint32_t len = strlen(s); - _encode_raw(len, bl); - bl.append(s, len); -} - -// bufferptr (encapsulated) -inline void _encode_simple(const buffer::ptr& bp, bufferlist& bl) -{ - uint32_t len = bp.length(); - _encode_raw(len, bl); - bl.append(bp); -} -inline void _decode_simple(buffer::ptr& bp, bufferlist::iterator& p) -{ - uint32_t len; - _decode_raw(len, p); - - bufferlist s; - p.copy(len, s); - - if (s.buffers().size() == 1) - bp = s.buffers().front(); - else - bp = buffer::copy(s.c_str(), s.length()); -} - -// bufferlist (encapsulated) -inline void _encode_simple(const bufferlist& s, bufferlist& bl) -{ - uint32_t len = s.length(); - _encode_raw(len, bl); - bl.append(s); -} -inline void _encode_simple_destructively(bufferlist& s, bufferlist& bl) -{ - uint32_t len = s.length(); - _encode_raw(len, bl); - bl.claim_append(s); -} -inline void _decode_simple(bufferlist& s, bufferlist::iterator& p) -{ - uint32_t len; - _decode_raw(len, p); - s.clear(); - p.copy(len, s); -} - -// base -template -inline void _encode_simple(const T& t, bufferlist& bl) -{ - _encode_raw(t, bl); -} -template -inline void _decode_simple(T& t, bufferlist::iterator& p) -{ - _decode_raw(t, p); -} - - - - -// ================================================================== -// complex - -// list -template -inline void _encode_complex(const std::list& ls, bufferlist& bl) -{ - uint32_t n = ls.size(); - _encode_raw(n, bl); - for (typename std::list::const_iterator p = ls.begin(); p != ls.end(); ++p) - _encode_complex(*p, bl); -} -template -inline void _decode_complex(std::list& ls, bufferlist::iterator& p) -{ - uint32_t n; - _decode_raw(n, p); - ls.clear(); - while (n--) { - T v; - _decode_complex(v, p); - ls.push_back(v); - } -} - -// deque -template -inline void _encode_complex(const std::deque& ls, bufferlist& bl) -{ - uint32_t n = ls.size(); - _encode_raw(n, bl); - for (typename std::deque::const_iterator p = ls.begin(); p != ls.end(); ++p) - _encode_complex(*p, bl); -} -template -inline void _decode_complex(std::deque& ls, bufferlist::iterator& p) -{ - uint32_t n; - _decode_raw(n, p); - ls.clear(); - while (n--) { - T v; - _decode_complex(v, p); - ls.push_back(v); - } -} - -// set -template -inline void _encode_complex(const std::set& s, bufferlist& bl) -{ - uint32_t n = s.size(); - _encode_raw(n, bl); - for (typename std::set::const_iterator p = s.begin(); p != s.end(); ++p) - _encode_complex(*p, bl); -} -template -inline void _decode_complex(std::set& s, bufferlist::iterator& p) -{ - uint32_t n; - _decode_raw(n, p); - s.clear(); - while (n--) { - T v; - _decode_complex(v, p); - s.insert(v); - } -} - -// vector -template -inline void _encode_complex(const std::vector& v, bufferlist& bl) -{ - uint32_t n = v.size(); - _encode_raw(n, bl); - for (typename std::vector::const_iterator p = v.begin(); p != v.end(); ++p) - _encode_complex(*p, bl); -} -template -inline void _decode_complex(std::vector& v, bufferlist::iterator& p) -{ - uint32_t n; - _decode_raw(n, p); - v.resize(n); - for (uint32_t i=0; i -inline void _encode_complex(const std::map& m, bufferlist& bl) -{ - uint32_t n = m.size(); - _encode_raw(n, bl); - for (typename std::map::const_iterator p = m.begin(); p != m.end(); ++p) { - _encode_simple(p->first, bl); - _encode_complex(p->second, bl); - } -} -template -inline void _decode_complex(std::map& m, bufferlist::iterator& p) -{ - uint32_t n; - _decode_raw(n, p); - m.clear(); - while (n--) { - T k; - _decode_simple(k, p); - _decode_complex(m[k], p); - } -} - -// hash_map -template -inline void _encode_complex(const __gnu_cxx::hash_map& m, bufferlist& bl) -{ - uint32_t n = m.size(); - _encode_raw(n, bl); - for (typename __gnu_cxx::hash_map::const_iterator p = m.begin(); p != m.end(); ++p) { - _encode_simple(p->first, bl); - _encode_complex(p->second, bl); - } -} -template -inline void _decode_complex(__gnu_cxx::hash_map& m, bufferlist::iterator& p) -{ - uint32_t n; - _decode_raw(n, p); - m.clear(); - while (n--) { - T k; - _decode_simple(k, p); - _decode_complex(m[k], p); - } -} - -// base case -template -inline void _encode_complex(const T& t, bufferlist& bl) -{ - t._encode(bl); -} -template -inline void _decode_complex(T& t, bufferlist::iterator& p) -{ - t._decode(p); -} - -#endif diff --git a/src/include/types.h b/src/include/types.h index 88da7500cb204..f83b78b69840c 100644 --- a/src/include/types.h +++ b/src/include/types.h @@ -115,6 +115,8 @@ WRITE_RAW_ENCODER(ceph_file_layout); WRITE_RAW_ENCODER(ceph_mds_request_head); WRITE_RAW_ENCODER(ceph_mds_file_caps); WRITE_RAW_ENCODER(ceph_mds_lease); +WRITE_RAW_ENCODER(ceph_mds_reply_head); +WRITE_RAW_ENCODER(ceph_mds_reply_inode); WRITE_RAW_ENCODER(ceph_osd_request_head); // ---------------------- diff --git a/src/mds/Locker.cc b/src/mds/Locker.cc index cf2aed8163264..c4ffffff88a94 100644 --- a/src/mds/Locker.cc +++ b/src/mds/Locker.cc @@ -1116,7 +1116,7 @@ void Locker::_issue_client_lease(MDSCacheObject *p, int mask, int pool, int clie LeaseStat e; e.mask = mask; e.duration_ms = (int)(1000 * mdcache->client_lease_durations[pool]); - ::_encode_simple(e, bl); + ::encode(e, bl); } diff --git a/src/mds/Server.cc b/src/mds/Server.cc index 48c1c9a5340ca..577287ffcf1ac 100644 --- a/src/mds/Server.cc +++ b/src/mds/Server.cc @@ -600,7 +600,7 @@ void Server::set_trace_dist(Session *session, MClientReply *reply, CInode *in, C goto done; dentry: - ::_encode_simple(dn->get_name(), bl); + ::encode(dn->get_name(), bl); lmask = mds->locker->issue_client_lease(dn, client, bl, now, session); numdn++; dout(20) << " trace added " << lmask << " " << *dn << dendl; @@ -1812,7 +1812,7 @@ void Server::handle_client_readdir(MDRequest *mdr) // touch dn mdcache->lru.lru_touch(dn); } - ::_encode_simple(numfiles, dirbl); + ::encode(numfiles, dirbl); dirbl.claim_append(dnbl); // yay, reply @@ -3295,8 +3295,8 @@ void Server::_rename_prepare(MDRequest *mdr, bufferlist::iterator blp = mdr->more()->inode_import.begin(); // imported caps - ::_decode_simple(mdr->more()->imported_client_map, blp); - ::_encode_simple(mdr->more()->imported_client_map, *client_map_bl); + ::decode(mdr->more()->imported_client_map, blp); + ::encode(mdr->more()->imported_client_map, *client_map_bl); prepare_force_open_sessions(mdr->more()->imported_client_map); list updated_scatterlocks; // we clear_updated explicitly below diff --git a/src/mds/mdstypes.h b/src/mds/mdstypes.h index 0a2b8c2d73368..8a924d12c0d86 100644 --- a/src/mds/mdstypes.h +++ b/src/mds/mdstypes.h @@ -56,6 +56,17 @@ struct metareqid_t { metareqid_t(entity_name_t n, tid_t t) : name(n), tid(t) {} }; +static inline void encode(const metareqid_t &r, bufferlist &bl) +{ + ::encode(r.name, bl); + ::encode(r.tid, bl); +} +static inline void decode( metareqid_t &r, bufferlist::iterator &p) +{ + ::decode(r.name, p); + ::decode(r.tid, p); +} + inline ostream& operator<<(ostream& out, const metareqid_t& r) { return out << r.name << ":" << r.tid; } @@ -426,23 +437,20 @@ public: MDSCacheObjectInfo() : ino(0) {} - void _encode(bufferlist& bl) const { + void encode(bufferlist& bl) const { ::encode(ino, bl); ::encode(dirfrag, bl); ::encode(dname, bl); } - void _decode(bufferlist& bl, int& off) { - ::_decode(ino, bl, off); - ::_decode(dirfrag, bl, off); - ::_decode(dname, bl, off); - } - void _decode(bufferlist::iterator& p) { + void decode(bufferlist::iterator& p) { ::decode(ino, p); ::decode(dirfrag, p); ::decode(dname, p); } }; +WRITE_CLASS_ENCODERS(MDSCacheObjectInfo) + class MDSCacheObject { public: diff --git a/src/messages/MClientReply.h b/src/messages/MClientReply.h index 1306bffdf4267..4936745a4d167 100644 --- a/src/messages/MClientReply.h +++ b/src/messages/MClientReply.h @@ -17,7 +17,6 @@ #define __MCLIENTREPLY_H #include "include/types.h" -#include "include/encodable.h" #include "MClientRequest.h" #include "msg/Message.h" @@ -55,7 +54,18 @@ struct LeaseStat { // this matches ceph_mds_reply_lease __u16 mask; __u32 duration_ms; -} __attribute__ ((packed)); + void encode(bufferlist &bl) const { + ::encode(mask, bl); + ::encode(duration_ms, bl); + } + void decode(bufferlist::iterator &bl) { + ::decode(mask, bl); + ::decode(duration_ms, bl); + } +}; +WRITE_CLASS_ENCODERS(LeaseStat) + + struct DirStat { // mds distribution hints @@ -66,14 +76,14 @@ struct DirStat { DirStat() {} DirStat(bufferlist::iterator& p) { - _decode(p); + decode(p); } - void _decode(bufferlist::iterator& p) { - ::_decode_simple(frag, p); - ::_decode_simple(auth, p); - ::_decode_simple(is_rep, p); - ::_decode_simple(dist, p); + void decode(bufferlist::iterator& p) { + ::decode(frag, p); + ::decode(auth, p); + ::decode(is_rep, p); + ::decode(dist, p); } static void _encode(bufferlist& bl, CDir *dir, int whoami) { @@ -90,10 +100,10 @@ struct DirStat { dir->get_dist_spec(dist, whoami); is_rep = dir->is_rep(); - ::_encode_simple(frag, bl); - ::_encode_simple(auth, bl); - ::_encode_simple(is_rep, bl); - ::_encode_simple(dist, bl); + ::encode(frag, bl); + ::encode(auth, bl); + ::encode(is_rep, bl); + ::encode(dist, bl); } }; @@ -113,12 +123,12 @@ struct InodeStat { public: InodeStat() {} InodeStat(bufferlist::iterator& p) { - _decode(p); + decode(p); } - void _decode(bufferlist::iterator &p) { + void decode(bufferlist::iterator &p) { struct ceph_mds_reply_inode e; - ::_decode_simple(e, p); + ::decode(e, p); ino = inodeno_t(e.ino); version = e.version; layout = e.layout; @@ -137,12 +147,12 @@ struct InodeStat { int n = e.fragtree.nsplits; while (n) { __u32 s, by; - ::_decode_simple(s, p); - ::_decode_simple(by, p); + ::decode(s, p); + ::decode(by, p); dirfragtree._splits[s] = by; n--; } - ::_decode_simple(symlink, p); + ::decode(symlink, p); } static void _encode(bufferlist &bl, CInode *in) { @@ -166,14 +176,14 @@ struct InodeStat { e.max_size = in->inode.max_size; e.rdev = in->inode.rdev; e.fragtree.nsplits = in->dirfragtree._splits.size(); - ::_encode_simple(e, bl); + ::encode(e, bl); for (map::iterator p = in->dirfragtree._splits.begin(); p != in->dirfragtree._splits.end(); p++) { - ::_encode_simple(p->first, bl); - ::_encode_simple(p->second, bl); + ::encode(p->first, bl); + ::encode(p->second, bl); } - ::_encode_simple(in->symlink, bl); + ::encode(in->symlink, bl); } }; @@ -223,15 +233,15 @@ class MClientReply : public Message { // serialization virtual void decode_payload() { bufferlist::iterator p = payload.begin(); - ::_decode_simple(st, p); - ::_decode_simple(trace_bl, p); - ::_decode_simple(dir_bl, p); + ::decode(st, p); + ::decode(trace_bl, p); + ::decode(dir_bl, p); assert(p.end()); } virtual void encode_payload() { - ::_encode_simple(st, payload); - ::_encode_simple(trace_bl, payload); - ::_encode_simple(dir_bl, payload); + ::encode(st, payload); + ::encode(trace_bl, payload); + ::encode(dir_bl, payload); } diff --git a/src/messages/MLock.h b/src/messages/MLock.h index 7cf13fc523689..0ae5e6bfdafa3 100644 --- a/src/messages/MLock.h +++ b/src/messages/MLock.h @@ -104,21 +104,21 @@ class MLock : public Message { } void decode_payload() { - int off = 0; - ::_decode(asker, payload, off); - ::_decode(action, payload, off); - ::_decode(reqid, payload, off); - ::_decode(lock_type, payload, off); - object_info._decode(payload, off); - ::_decode(lockdata, payload, off); + bufferlist::iterator p = payload.begin(); + ::decode(asker, p); + ::decode(action, p); + ::decode(reqid, p); + ::decode(lock_type, p); + ::decode(object_info, p); + ::decode(lockdata, p); } virtual void encode_payload() { - ::_encode(asker, payload); - ::_encode(action, payload); - ::_encode(reqid, payload); - ::_encode(lock_type, payload); - object_info._encode(payload); - ::_encode(lockdata, payload); + ::encode(asker, payload); + ::encode(action, payload); + ::encode(reqid, payload); + ::encode(lock_type, payload); + ::encode(object_info, payload); + ::encode(lockdata, payload); } }; diff --git a/src/messages/MMDSCacheRejoin.h b/src/messages/MMDSCacheRejoin.h index 2e453f339b759..03a230f9fea8a 100644 --- a/src/messages/MMDSCacheRejoin.h +++ b/src/messages/MMDSCacheRejoin.h @@ -18,7 +18,6 @@ #include "msg/Message.h" #include "include/types.h" -#include "include/encodable.h" // sent from replica to auth @@ -49,13 +48,33 @@ class MMDSCacheRejoin : public Message { int32_t linklock; int32_t dirfragtreelock; int32_t filelock; - __int32_t dirlock; + int32_t dirlock; inode_strong() {} inode_strong(int n, int cw=0, int a=0, int l=0, int dft=0, int f=0, int dl=0) : caps_wanted(cw), nonce(n), authlock(a), linklock(l), dirfragtreelock(dft), filelock(f), dirlock(dl) { } + void encode(bufferlist &bl) const { + ::encode(caps_wanted, bl); + ::encode(nonce, bl); + ::encode(authlock, bl); + ::encode(linklock, bl); + ::encode(dirfragtreelock, bl); + ::encode(filelock, bl); + ::encode(dirlock, bl); + } + void decode(bufferlist::iterator &bl) { + ::decode(caps_wanted, bl); + ::decode(nonce, bl); + ::decode(authlock, bl); + ::decode(linklock, bl); + ::decode(dirfragtreelock, bl); + ::decode(filelock, bl); + ::decode(dirlock, bl); + } }; + WRITE_CLASS_ENCODERS(inode_strong) + struct inode_full { inode_t inode; string symlink; @@ -64,24 +83,35 @@ class MMDSCacheRejoin : public Message { inode_full(const inode_t& i, const string& s, const fragtree_t& f) : inode(i), symlink(s), dirfragtree(f) {} - void _decode(bufferlist::iterator& p) { - ::_decode_simple(inode, p); - ::_decode_simple(symlink, p); + void decode(bufferlist::iterator& p) { + ::decode(inode, p); + ::decode(symlink, p); dirfragtree._decode(p); } - void _encode(bufferlist& bl) const { - ::_encode(inode, bl); - ::_encode(symlink, bl); + void encode(bufferlist& bl) const { + ::encode(inode, bl); + ::encode(symlink, bl); dirfragtree._encode(bl); } }; + WRITE_CLASS_ENCODERS(inode_full) struct dirfrag_strong { int32_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_ENCODERS(dirfrag_strong) + struct dn_strong { inodeno_t ino; inodeno_t remote_ino; @@ -95,13 +125,35 @@ class MMDSCacheRejoin : public Message { 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(ino, bl); + ::encode(remote_ino, bl); + ::encode(remote_d_type, bl); + ::encode(nonce, bl); + ::encode(lock, bl); + } + void decode(bufferlist::iterator &bl) { + ::decode(ino, bl); + ::decode(remote_ino, bl); + ::decode(remote_d_type, bl); + ::decode(nonce, bl); + ::decode(lock, bl); + } }; + WRITE_CLASS_ENCODERS(dn_strong) struct dn_weak { inodeno_t ino; dn_weak() : ino(0) {} dn_weak(inodeno_t pi) : ino(pi) {} + void encode(bufferlist &bl) const { + ::encode(ino, bl); + } + void decode(bufferlist::iterator &bl) { + ::decode(ino, bl); + } }; + WRITE_CLASS_ENCODERS(dn_weak) // -- data -- int32_t op; @@ -191,40 +243,46 @@ class MMDSCacheRejoin : public Message { // -- encoding -- void encode_payload() { - ::_encode(op, payload); - ::_encode(strong_inodes, payload); - ::_encode_complex(full_inodes, payload); - ::_encode(authpinned_inodes, payload); - ::_encode(xlocked_inodes, payload); - ::_encode(cap_export_bl, payload); - ::_encode(strong_dirfrags, payload); - ::_encode(weak, payload); - ::_encode(weak_inodes, payload); - ::_encode(strong_dentries, payload); - ::_encode(authpinned_dentries, payload); - ::_encode(xlocked_dentries, payload); + ::encode(op, payload); + ::encode(strong_inodes, payload); + ::encode(full_inodes, payload); + ::encode(authpinned_inodes, payload); + ::encode(xlocked_inodes, payload); + ::encode(cap_export_bl, payload); + ::encode(strong_dirfrags, payload); + ::encode(weak, payload); + ::encode(weak_inodes, payload); + ::encode(strong_dentries, payload); + ::encode(authpinned_dentries, payload); + ::encode(xlocked_dentries, payload); } void decode_payload() { bufferlist::iterator p = payload.begin(); - ::_decode_simple(op, p); - ::_decode_simple(strong_inodes, p); - ::_decode_complex(full_inodes, p); - ::_decode_simple(authpinned_inodes, p); - ::_decode_simple(xlocked_inodes, p); - ::_decode_simple(cap_export_bl, p); + ::decode(op, p); + ::decode(strong_inodes, p); + ::decode(full_inodes, p); + ::decode(authpinned_inodes, p); + ::decode(xlocked_inodes, p); + ::decode(cap_export_bl, p); if (cap_export_bl.length()) { bufferlist::iterator q = cap_export_bl.begin(); - ::_decode_simple(cap_exports, q); - ::_decode_simple(cap_export_paths, q); + ::decode(cap_exports, q); + ::decode(cap_export_paths, q); } - ::_decode_simple(strong_dirfrags, p); - ::_decode_simple(weak, p); - ::_decode_simple(weak_inodes, p); - ::_decode_simple(strong_dentries, p); - ::_decode_simple(authpinned_dentries, p); - ::_decode_simple(xlocked_dentries, p); + ::decode(strong_dirfrags, p); + ::decode(weak, p); + ::decode(weak_inodes, p); + ::decode(strong_dentries, p); + ::decode(authpinned_dentries, p); + ::decode(xlocked_dentries, p); } }; +WRITE_CLASS_ENCODERS(MMDSCacheRejoin::inode_strong) +WRITE_CLASS_ENCODERS(MMDSCacheRejoin::inode_full) +WRITE_CLASS_ENCODERS(MMDSCacheRejoin::dirfrag_strong) +WRITE_CLASS_ENCODERS(MMDSCacheRejoin::dn_strong) +WRITE_CLASS_ENCODERS(MMDSCacheRejoin::dn_weak) + #endif diff --git a/src/messages/MMDSGetMap.h b/src/messages/MMDSGetMap.h index da34e4128ccff..99b3af83bd79d 100644 --- a/src/messages/MMDSGetMap.h +++ b/src/messages/MMDSGetMap.h @@ -18,7 +18,6 @@ #include "msg/Message.h" #include "include/types.h" -#include "include/encodable.h" class MMDSGetMap : public Message { public: @@ -34,13 +33,13 @@ class MMDSGetMap : public Message { const char *get_type_name() { return "mds_getmap"; } void encode_payload() { - ::_encode_simple(fsid, payload); - ::_encode_simple(have, payload); + ::encode(fsid, payload); + ::encode(have, payload); } void decode_payload() { bufferlist::iterator p = payload.begin(); - ::_decode_simple(fsid, p); - ::_decode_simple(have, p); + ::decode(fsid, p); + ::decode(have, p); } }; diff --git a/src/messages/MMDSSlaveRequest.h b/src/messages/MMDSSlaveRequest.h index 5b4c63658ce7e..75888856455f3 100644 --- a/src/messages/MMDSSlaveRequest.h +++ b/src/messages/MMDSSlaveRequest.h @@ -18,7 +18,6 @@ #include "msg/Message.h" #include "mds/mdstypes.h" -#include "include/encodable.h" class MMDSSlaveRequest : public Message { public: @@ -105,35 +104,35 @@ public: Message(MSG_MDS_SLAVE_REQUEST), reqid(ri), op(o) { } void encode_payload() { - ::_encode(reqid, payload); - ::_encode(op, payload); - ::_encode(lock_type, payload); - object_info._encode(payload); - ::_encode_complex(authpins, payload); + ::encode(reqid, payload); + ::encode(op, payload); + ::encode(lock_type, payload); + ::encode(object_info, payload); + ::encode(authpins, payload); ::encode(srcdnpath, payload); ::encode(destdnpath, payload); - ::_encode(witnesses, payload); - ::_encode(now, payload); - ::_encode(inode_export, payload); - ::_encode(inode_export_v, payload); - ::_encode(srci_replica, payload); - ::_encode(stray, payload); + ::encode(witnesses, payload); + ::encode(now, payload); + ::encode(inode_export, payload); + ::encode(inode_export_v, payload); + ::encode(srci_replica, payload); + ::encode(stray, payload); } void decode_payload() { bufferlist::iterator p = payload.begin(); - ::_decode_simple(reqid, p); - ::_decode_simple(op, p); - ::_decode_simple(lock_type, p); - object_info._decode(p); - ::_decode_complex(authpins, p); + ::decode(reqid, p); + ::decode(op, p); + ::decode(lock_type, p); + ::decode(object_info, p); + ::decode(authpins, p); ::decode(srcdnpath, p); ::decode(destdnpath, p); - ::_decode_simple(witnesses, p); - ::_decode_simple(now, p); - ::_decode_simple(inode_export, p); - ::_decode_simple(inode_export_v, p); - ::_decode_simple(srci_replica, p); - ::_decode_simple(stray, p); + ::decode(witnesses, p); + ::decode(now, p); + ::decode(inode_export, p); + ::decode(inode_export_v, p); + ::decode(srci_replica, p); + ::decode(stray, p); } const char *get_type_name() { return "slave_request"; } -- 2.39.5