From 1ed36b50ce8d04d5cf640126294f564374d360ba Mon Sep 17 00:00:00 2001 From: Sage Weil Date: Mon, 28 Jul 2008 14:30:25 -0700 Subject: [PATCH] mds: huge discover rewrite --- src/mds/CDentry.cc | 33 ++++-- src/mds/CDentry.h | 65 ++-------- src/mds/CDir.cc | 10 -- src/mds/CDir.h | 73 +++--------- src/mds/CInode.cc | 45 ++++--- src/mds/CInode.h | 95 ++++----------- src/mds/MDCache.cc | 203 ++++++++++++++------------------ src/mds/MDCache.h | 32 +++-- src/mds/Migrator.cc | 126 +++++++++----------- src/mds/Server.cc | 21 ++-- src/mds/SimpleLock.h | 9 +- src/messages/MDentryUnlink.h | 33 +----- src/messages/MDiscoverReply.h | 82 ++----------- src/messages/MExportDirPrep.h | 90 +++----------- src/messages/MLock.h | 2 +- src/messages/MMDSSlaveRequest.h | 4 +- 16 files changed, 309 insertions(+), 614 deletions(-) diff --git a/src/mds/CDentry.cc b/src/mds/CDentry.cc index 527cb27090870..02dc114faac5a 100644 --- a/src/mds/CDentry.cc +++ b/src/mds/CDentry.cc @@ -274,13 +274,6 @@ void CDentry::unlink_remote() } -CDentryDiscover *CDentry::replicate_to(int who) -{ - int nonce = add_replica(who); - return new CDentryDiscover(this, nonce); -} - - // ---------------------------- // auth pins @@ -353,6 +346,32 @@ void CDentry::adjust_nested_anchors(int by) dir->adjust_nested_anchors(by); } + +void CDentry::decode_replica(bufferlist::iterator& p, bool is_new) +{ + __u32 nonce; + ::decode(nonce, p); + replica_nonce = nonce; + + inodeno_t rino; + unsigned char rdtype; + ::decode(rino, p); + ::decode(rdtype, p); + if (rino) { + if (is_null()) + dir->link_remote_inode(this, rino, rdtype); + else + assert(is_remote() && remote_ino == rino); + } + + __s32 ls; + ::decode(ls, p); + if (is_new) + lock.set_state(ls); +} + + + // ---------------------------- // locking diff --git a/src/mds/CDentry.h b/src/mds/CDentry.h index 93d9e00c773d7..ce8165a2405df 100644 --- a/src/mds/CDentry.h +++ b/src/mds/CDentry.h @@ -37,7 +37,6 @@ class CDir; class MDRequest; class Message; -class CDentryDiscover; class Anchor; class CDentry; @@ -213,8 +212,15 @@ public: bool is_new() { return state_test(STATE_NEW); } // -- replication - CDentryDiscover *replicate_to(int rep); - + void encode_replica(int mds, bufferlist& bl) { + __u32 nonce = add_replica(mds); + ::encode(nonce, bl); + ::encode(remote_ino, bl); + ::encode(remote_d_type, bl); + __s32 ls = lock.get_replica_state(); + ::encode(ls, bl); + } + void decode_replica(bufferlist::iterator& p, bool is_new); // -- exporting // note: this assumes the dentry already exists. @@ -275,57 +281,4 @@ public: ostream& operator<<(ostream& out, CDentry& dn); - -class CDentryDiscover { - nstring dname; - __s32 replica_nonce; - __s32 lockstate; - __s64 dir_offset; - inodeno_t remote_ino; - unsigned char remote_d_type; - -public: - CDentryDiscover() {} - CDentryDiscover(CDentry *dn, int nonce) : - dname(dn->get_name()), replica_nonce(nonce), - lockstate(dn->lock.get_replica_state()), - dir_offset(dn->get_dir_offset()), - remote_ino(dn->get_remote_ino()), remote_d_type(dn->get_remote_d_type()) { } - CDentryDiscover(bufferlist::iterator &p) { decode(p); } - - nstring& get_dname() { return dname; } - int get_nonce() { return replica_nonce; } - bool is_remote() { return remote_ino ? true:false; } - inodeno_t get_remote_ino() { return remote_ino; } - unsigned char get_remote_d_type() { return remote_d_type; } - - void update_dentry(CDentry *dn) { - dn->set_dir_offset(dir_offset); - dn->set_replica_nonce(replica_nonce); - } - void init_dentry_lock(CDentry *dn) { - dn->lock.set_state( lockstate ); - } - - void encode(bufferlist &bl) const { - ::encode(dname, bl); - ::encode(dir_offset, bl); - ::encode(remote_ino, bl); - ::encode(remote_d_type, bl); - ::encode(replica_nonce, bl); - ::encode(lockstate, bl); - } - - void decode(bufferlist::iterator &bl) { - ::decode(dname, bl); - ::decode(dir_offset, bl); - ::decode(remote_ino, bl); - ::decode(remote_d_type, bl); - ::decode(replica_nonce, bl); - ::decode(lockstate, bl); - } -}; -WRITE_CLASS_ENCODER(CDentryDiscover) - - #endif diff --git a/src/mds/CDir.cc b/src/mds/CDir.cc index 2c91b1455b34f..5e0084671c2f4 100644 --- a/src/mds/CDir.cc +++ b/src/mds/CDir.cc @@ -750,16 +750,6 @@ void CDir::merge(int bits, list& waiters, bool replay) -CDirDiscover *CDir::replicate_to(int mds) -{ - assert(is_auth()); - return new CDirDiscover( this, add_replica(mds) ); -} - - - - - /**************************************** * WAITING */ diff --git a/src/mds/CDir.h b/src/mds/CDir.h index 2512ad8f652ea..15bfe03fe14b2 100644 --- a/src/mds/CDir.h +++ b/src/mds/CDir.h @@ -42,7 +42,6 @@ class CDentry; class MDCache; class MDCluster; class Context; -class CDirDiscover; @@ -233,8 +232,8 @@ protected: int nested_anchors; // cache control (defined for authority; hints for replicas) - int dir_rep; - set dir_rep_by; // if dir_rep == REP_LIST + __s32 dir_rep; + set<__s32> dir_rep_by; // if dir_rep == REP_LIST // popularity dirfrag_load_vec_t pop_me; @@ -390,7 +389,20 @@ private: ::encode(dist, bl); } - CDirDiscover *replicate_to(int mds); + void encode_replica(int who, bufferlist& bl) { + __u32 nonce = add_replica(who); + ::encode(nonce, bl); + ::encode(dir_rep, bl); + ::encode(dir_rep_by, bl); + } + void decode_replica(bufferlist::iterator& p) { + __u32 nonce; + ::decode(nonce, p); + replica_nonce = nonce; + ::decode(dir_rep, p); + ::decode(dir_rep_by, p); + } + // -- state -- @@ -554,61 +566,8 @@ public: CDir *get_frozen_tree_root(); - ostream& print_db_line_prefix(ostream& out); void print(ostream& out); }; - - -// -- encoded state -- - -// discover - -class CDirDiscover { - dirfrag_t dirfrag; - __s32 nonce; - __s32 dir_rep; - set<__s32> rep_by; - - public: - CDirDiscover() {} - CDirDiscover(CDir *dir, int nonce) { - dirfrag = dir->dirfrag(); - this->nonce = nonce; - dir_rep = dir->dir_rep; - rep_by = dir->dir_rep_by; - } - CDirDiscover(bufferlist::iterator &p) { decode(p); } - - void update_dir(CDir *dir) { - assert(dir->dirfrag() == dirfrag); - assert(!dir->is_auth()); - - dir->replica_nonce = nonce; - dir->dir_rep = dir_rep; - dir->dir_rep_by = rep_by; - } - - dirfrag_t get_dirfrag() { return dirfrag; } - - void encode(bufferlist& bl) const { - ::encode(dirfrag, bl); - ::encode(nonce, bl); - ::encode(dir_rep, bl); - ::encode(rep_by, bl); - } - - void decode(bufferlist::iterator &bl) { - ::decode(dirfrag, bl); - ::decode(nonce, bl); - ::decode(dir_rep, bl); - ::decode(rep_by, bl); - } - -}; -WRITE_CLASS_ENCODER(CDirDiscover) - - - #endif diff --git a/src/mds/CInode.cc b/src/mds/CInode.cc index b9e4bcae42d82..5f76aa9a622a0 100644 --- a/src/mds/CInode.cc +++ b/src/mds/CInode.cc @@ -533,6 +533,8 @@ void CInode::set_object_info(MDSCacheObjectInfo &info) void CInode::encode_lock_state(int type, bufferlist& bl) { + ::encode(first, bl); + switch (type) { case CEPH_LOCK_IAUTH: ::encode(inode.ctime, bl); @@ -642,6 +644,15 @@ void CInode::decode_lock_state(int type, bufferlist& bl) bufferlist::iterator p = bl.begin(); utime_t tm; + snapid_t newfirst; + ::decode(newfirst, p); + + if (!is_auth() && newfirst != first) { + assert(newfirst > first); + dout(10) << "decode_lock_state first " << first << " -> " << newfirst << dendl; + first = newfirst; + } + switch (type) { case CEPH_LOCK_IAUTH: ::decode(tm, p); @@ -1077,20 +1088,6 @@ pair CInode::authority() } -CInodeDiscover* CInode::replicate_to( int rep ) -{ - assert(is_auth()); - - // relax locks? - if (!is_replicated()) - replicate_relax_locks(); - - // return the thinger - int nonce = add_replica( rep ); - return new CInodeDiscover( this, nonce ); -} - - // SNAP snapid_t CInode::get_oldest_snap() @@ -1286,7 +1283,7 @@ void CInode::encode_inodestat(bufferlist& bl, snapid_t snapid) void CInode::_encode_base(bufferlist& bl) { - ::encode(inode, bl); + ::encode(inode, bl); ::encode(symlink, bl); ::encode(dirfragtree, bl); ::encode(xattrs, bl); @@ -1339,16 +1336,16 @@ void CInode::_encode_locks_state(bufferlist& bl) xattrlock.encode_state(bl); snaplock.encode_state(bl); } -void CInode::_decode_locks_state(bufferlist::iterator& p) +void CInode::_decode_locks_state(bufferlist::iterator& p, bool is_new) { - authlock.decode_state(p); - linklock.decode_state(p); - dirfragtreelock.decode_state(p); - filelock.decode_state(p); - dirlock.decode_state(p); - nestlock.decode_state(p); - xattrlock.decode_state(p); - snaplock.decode_state(p); + authlock.decode_state(p, is_new); + linklock.decode_state(p, is_new); + dirfragtreelock.decode_state(p, is_new); + filelock.decode_state(p, is_new); + dirlock.decode_state(p, is_new); + nestlock.decode_state(p, is_new); + xattrlock.decode_state(p, is_new); + snaplock.decode_state(p, is_new); } void CInode::_decode_locks_rejoin(bufferlist::iterator& p, list& waiters) { diff --git a/src/mds/CInode.h b/src/mds/CInode.h index 8f43328ae0061..0b22f913feefb 100644 --- a/src/mds/CInode.h +++ b/src/mds/CInode.h @@ -44,7 +44,6 @@ class CDentry; class CDir; class Message; class CInode; -class CInodeDiscover; class MDCache; class LogSegment; class SnapRealm; @@ -270,7 +269,6 @@ private: friend class MDCache; friend class CDir; friend class CInodeExport; - friend class CInodeDiscover; public: // --------------------------- @@ -367,7 +365,28 @@ private: void mark_clean(); - CInodeDiscover* replicate_to(int rep); + void encode_replica(int rep, bufferlist& bl) { + assert(is_auth()); + + // relax locks? + if (!is_replicated()) + replicate_relax_locks(); + + + __u32 nonce = add_replica(rep); + ::encode(nonce, bl); + + _encode_base(bl); + _encode_locks_state(bl); + } + void decode_replica(bufferlist::iterator& p, bool is_new) { + __u32 nonce; + ::decode(nonce, p); + replica_nonce = nonce; + + _decode_base(p); + _decode_locks_state(p, is_new); + } // -- waiting -- @@ -380,7 +399,7 @@ private: void _encode_locks_full(bufferlist& bl); void _decode_locks_full(bufferlist::iterator& p); void _encode_locks_state(bufferlist& bl); - void _decode_locks_state(bufferlist::iterator& p); + void _decode_locks_state(bufferlist::iterator& p, bool is_new); void _decode_locks_rejoin(bufferlist::iterator& p, list& waiters); @@ -670,76 +689,8 @@ public: return remote_parents.size(); } - - /* - // for giving to clients - void get_dist_spec(set& ls, int auth, timepair_t& now) { - if (( is_dir() && popularity[MDS_POP_CURDOM].get(now) > g_conf.mds_bal_replicate_threshold) || - (!is_dir() && popularity[MDS_POP_JUSTME].get(now) > g_conf.mds_bal_replicate_threshold)) { - //if (!cached_by.empty() && inode.ino > 1) dout(1) << "distributed spec for " << *this << dendl; - ls = cached_by; - } - } - */ - void print(ostream& out); }; - - - -// -- encoded state - -// discover - -class CInodeDiscover { - inodeno_t ino; - bufferlist base; - bufferlist locks; - __s32 replica_nonce; - - public: - CInodeDiscover() {} - CInodeDiscover(CInode *in, int nonce) { - ino = in->ino(); - in->_encode_base(base); - in->_encode_locks_state(locks); - replica_nonce = nonce; - } - CInodeDiscover(bufferlist::iterator &p) { - decode(p); - } - - inodeno_t get_ino() { return ino; } - int get_replica_nonce() { return replica_nonce; } - - void update_inode(CInode *in) { - bufferlist::iterator p = base.begin(); - in->_decode_base(p); - in->replica_nonce = replica_nonce; - } - void init_inode_locks(CInode *in) { - bufferlist::iterator p = base.begin(); - in->_decode_locks_state(p); - } - - void encode(bufferlist &bl) const { - ::encode(ino, bl); - ::encode(base, bl); - ::encode(locks, bl); - ::encode(replica_nonce, bl); - } - - void decode(bufferlist::iterator &p) { - ::decode(ino, p); - ::decode(base, p); - ::decode(locks, p); - ::decode(replica_nonce, p); - } - -}; -WRITE_CLASS_ENCODER(CInodeDiscover) - - #endif diff --git a/src/mds/MDCache.cc b/src/mds/MDCache.cc index 29bb436b062ad..f68146b962d7f 100644 --- a/src/mds/MDCache.cc +++ b/src/mds/MDCache.cc @@ -6150,7 +6150,8 @@ void MDCache::handle_discover(MDiscover *dis) assert(root->is_auth()); // add root - reply->add_inode( root->replicate_to( dis->get_asker() ) ); + reply->starts_with = MDiscoverReply::INODE; + replicate_inode(root, dis->get_asker(), reply->trace); dout(10) << "added root " << *root << dendl; cur = root; @@ -6160,7 +6161,8 @@ void MDCache::handle_discover(MDiscover *dis) dout(7) << "handle_discover from mds" << dis->get_asker() << " wants stray + " << dis->get_want().get_path() << dendl; - reply->add_inode( stray->replicate_to( dis->get_asker() ) ); + reply->starts_with = MDiscoverReply::INODE; + replicate_inode(stray, dis->get_asker(), reply->trace); dout(10) << "added stray " << *stray << dendl; cur = stray; @@ -6276,7 +6278,9 @@ void MDCache::handle_discover(MDiscover *dis) dout(7) << "handle_discover not adding unwanted base dir " << *curdir << dendl; } else { assert(!curdir->is_ambiguous_auth()); // would be frozen. - reply->add_dir( curdir->replicate_to(dis->get_asker()) ); + if (!reply->trace.length()) + reply->starts_with = MDiscoverReply::DIR; + replicate_dir(curdir, dis->get_asker(), reply->trace); dout(7) << "handle_discover added dir " << *curdir << dendl; } @@ -6357,7 +6361,9 @@ void MDCache::handle_discover(MDiscover *dis) } // add dentry - reply->add_dentry( dn->replicate_to( dis->get_asker() ) ); + if (!reply->trace.length()) + reply->starts_with = MDiscoverReply::DENTRY; + replicate_dentry(dn, dis->get_asker(), reply->trace); dout(7) << "handle_discover added dentry " << *dn << dendl; if (!dn->is_primary()) break; // stop on null or remote link. @@ -6366,7 +6372,7 @@ void MDCache::handle_discover(MDiscover *dis) CInode *next = dn->inode; assert(next->is_auth()); - reply->add_inode( next->replicate_to( dis->get_asker() ) ); + replicate_inode(next, dis->get_asker(), reply->trace); dout(7) << "handle_discover added inode " << *next << dendl; // descend, keep going. @@ -6392,22 +6398,24 @@ void MDCache::handle_discover_reply(MDiscoverReply *m) return; } */ + dout(7) << "discover_reply " << *m << dendl; list finished, error; int from = m->get_source().num(); // starting point CInode *cur = get_inode(m->get_base_ino()); + bufferlist::iterator p = m->trace.begin(); - if (m->has_base_inode()) { - assert(m->get_base_ino() < MDS_INO_BASE); - assert(!m->has_base_dentry()); - assert(!m->has_base_dir()); + int next = m->starts_with; + if (next == MDiscoverReply::INODE) { // add base inode - cur = add_replica_inode(m->get_inode(0), NULL, finished); - + cur = add_replica_inode(p, NULL, finished); dout(7) << "discover_reply got base inode " << *cur << dendl; + assert(cur->is_base()); + + next = MDiscoverReply::DIR; // take waiters finished.swap(waiting_for_base_ino[from][cur->ino()]); @@ -6415,10 +6423,6 @@ void MDCache::handle_discover_reply(MDiscoverReply *m) } assert(cur); - dout(7) << "discover_reply " << *cur - << " + " << m->get_num_dentries() << " dn, " - << m->get_num_inodes() << " inodes" - << dendl; // fyi if (m->is_flag_error_dir()) @@ -6428,13 +6432,6 @@ void MDCache::handle_discover_reply(MDiscoverReply *m) if (m->is_flag_error_ino()) dout(7) << " flag error, ino = " << m->get_wanted_ino() << dendl; - dout(10) << "depth = " << m->get_depth() - << ", has base_dir/base_dn/root = " - << m->has_base_dir() << " / " << m->has_base_dentry() << " / " << m->has_base_inode() - << ", num dirs/dentries/inodes = " - << m->get_num_dirs() << " / " << m->get_num_dentries() << " / " << m->get_num_inodes() - << dendl; - // decrement discover counters if (!m->is_unsolicited()) { if (m->get_wanted_base_dir()) { @@ -6453,26 +6450,23 @@ void MDCache::handle_discover_reply(MDiscoverReply *m) // loop over discover results. // indexes follow each ([[dir] dentry] inode) // can start, end with any type. - for (int i=m->has_base_inode(); iget_depth(); i++) { - dout(10) << "discover_reply i=" << i << " cur " << *cur << dendl; - + while (!p.end()) { // dir frag_t fg; CDir *curdir = 0; - if (i > 0 || m->has_base_dir()) { - assert(m->get_dir(i).get_dirfrag().ino == cur->ino()); - fg = m->get_dir(i).get_dirfrag().frag; - curdir = add_replica_dir(cur, fg, m->get_dir(i), - m->get_source().num(), - finished); - } - if (!curdir) { - fg = cur->pick_dirfrag(m->get_dentry(i).get_dname()); - curdir = cur->get_dirfrag(fg); + if (next == MDiscoverReply::DIR) + curdir = add_replica_dir(p, cur, m->get_source().num(), finished); + else { + // note: this can only happen our first way around this loop. + if (p.end() && m->is_flag_error_dn()) { + fg = cur->pick_dirfrag(m->get_error_dentry()); + curdir = cur->get_dirfrag(fg); + } else + curdir = cur->get_dirfrag(m->get_base_dir_frag()); } - + // dentry error? - if (i == m->get_depth()-1 && (m->is_flag_error_dn() || m->is_flag_error_ino())) { + if (p.end() && (m->is_flag_error_dn() || m->is_flag_error_ino())) { // error! assert(cur->is_dir()); if (curdir) { @@ -6486,26 +6480,27 @@ void MDCache::handle_discover_reply(MDiscoverReply *m) curdir->take_ino_waiting(m->get_wanted_ino(), error); } } else { - dout(7) << " flag_error on dentry " << m->get_error_dentry() + dout(7) << " flag_error on dentry " << m->get_error_dentry() << ", triggering dir?" << dendl; - cur->take_waiting(CInode::WAIT_DIR, error); + cur->take_waiting(CInode::WAIT_DIR, error); } break; } - assert(curdir); + if (p.end()) + break; + // dentry - CDentry *dn = 0; - if (i >= m->get_last_dentry()) break; - if (i > 0 || m->has_base_dentry()) - dn = add_replica_dentry(curdir, m->get_dentry(i), finished); - + CDentry *dn = add_replica_dentry(p, curdir, finished); + // inode - if (i >= m->get_last_inode()) break; - cur = add_replica_inode(m->get_inode(i), dn, finished); + cur = add_replica_inode(p, dn, finished); + + next = MDiscoverReply::DIR; } + // dir error? // or dir_auth hint? if (m->is_flag_error_dir() && !cur->is_dir()) { @@ -6561,28 +6556,32 @@ void MDCache::handle_discover_reply(MDiscoverReply *m) // ---------------------------- // REPLICAS -CDir *MDCache::add_replica_dir(CInode *diri, - frag_t fg, CDirDiscover &dis, int from, +CDir *MDCache::add_replica_dir(bufferlist::iterator& p, CInode *diri, int from, list& finished) { + dirfrag_t df; + ::decode(df, p); + + assert(diri->ino() == df.ino); + // add it (_replica_) - CDir *dir = diri->get_dirfrag(fg); + CDir *dir = diri->get_dirfrag(df.frag); if (dir) { // had replica. update w/ new nonce. - dis.update_dir(dir); + dir->decode_replica(p); dout(7) << "add_replica_dir had " << *dir << " nonce " << dir->replica_nonce << dendl; } else { // force frag to leaf in the diri tree - if (!diri->dirfragtree.is_leaf(fg)) { - dout(7) << "add_replica_dir forcing frag " << fg << " to leaf in the fragtree " + if (!diri->dirfragtree.is_leaf(df.frag)) { + dout(7) << "add_replica_dir forcing frag " << df.frag << " to leaf in the fragtree " << diri->dirfragtree << dendl; - diri->dirfragtree.force_to_leaf(fg); + diri->dirfragtree.force_to_leaf(df.frag); } // add replica. - dir = diri->add_dirfrag( new CDir(diri, fg, this, false) ); - dis.update_dir(dir); + dir = diri->add_dirfrag( new CDir(diri, df.frag, this, false) ); + dir->decode_replica(p); // is this a dir_auth delegation boundary? if (from != diri->authority().first || @@ -6613,43 +6612,37 @@ CDir *MDCache::forge_replica_dir(CInode *diri, frag_t fg, int from) return dir; } - -CDentry *MDCache::add_replica_dentry(CDir *dir, CDentryDiscover &dis, list& finished) + +CDentry *MDCache::add_replica_dentry(bufferlist::iterator& p, CDir *dir, list& finished) { - CDentry *dn = dir->lookup( dis.get_dname() ); + nstring name; + ::decode(name, p); + + CDentry *dn = dir->lookup(name); // have it? if (dn) { - dis.update_dentry(dn); + dn->decode_replica(p, false); dout(7) << "add_replica_dentry had " << *dn << dendl; } else { - dn = dir->add_null_dentry(dis.get_dname()); - dis.update_dentry(dn); - dis.init_dentry_lock(dn); + dn = dir->add_null_dentry(name); + dn->decode_replica(p, true); dout(7) << "add_replica_dentry added " << *dn << dendl; } - - // remote_ino linkage? - if (dis.get_remote_ino()) { - if (dn->is_null()) - dir->link_remote_inode(dn, dis.get_remote_ino(), dis.get_remote_d_type()); - - // hrm. yeah. - assert(dn->is_remote() && dn->get_remote_ino() == dis.get_remote_ino()); - } - dir->take_dentry_waiting(dis.get_dname(), finished); + dir->take_dentry_waiting(name, finished); return dn; } -CInode *MDCache::add_replica_inode(CInodeDiscover& dis, CDentry *dn, list& finished) +CInode *MDCache::add_replica_inode(bufferlist::iterator& p, CDentry *dn, list& finished) { - CInode *in = get_inode(dis.get_ino()); + inodeno_t ino; + ::decode(ino, p); + CInode *in = get_inode(ino); if (!in) { in = new CInode(this, false); - dis.update_inode(in); - dis.init_inode_locks(in); + in->decode_replica(p, true); add_inode(in); if (in->is_base()) { if (in->ino() == MDS_INO_ROOT) @@ -6660,11 +6653,14 @@ CInode *MDCache::add_replica_inode(CInodeDiscover& dis, CDentry *dn, listis_null()) + if (dn) { + assert(dn->is_null()); dn->dir->link_primary_inode(dn, in); + } } else { - dis.update_inode(in); + in->decode_replica(p, false); dout(10) << "add_replica_inode had " << *in << dendl; + assert(!dn || dn->inode == in); } if (dn) { @@ -6678,31 +6674,19 @@ CInode *MDCache::add_replica_inode(CInodeDiscover& dis, CDentry *dn, list finished; bufferlist::iterator p = bl.begin(); - - // inode - CInodeDiscover indis(p); - CInode *strayin = add_replica_inode(indis, NULL, finished); + + CInode *strayin = add_replica_inode(p, NULL, finished); dout(15) << "strayin " << *strayin << dendl; - - // dir - CDirDiscover dirdis(p); - CDir *straydir = add_replica_dir(strayin, dirdis.get_dirfrag().frag, dirdis, - from, finished); + CDir *straydir = add_replica_dir(p, strayin, from, finished); dout(15) << "straydir " << *straydir << dendl; - - // dentry - CDentryDiscover dndis(p); - - string straydname; - in->name_stray_dentry(straydname); - CDentry *straydn = add_replica_dentry(straydir, dndis, finished); + CDentry *straydn = add_replica_dentry(p, straydir, finished); + dout(15) << "straydn " << *straydn << dendl; mds->queue_waiters(finished); - return straydn; } @@ -6861,16 +6845,13 @@ void MDCache::handle_dentry_unlink(MDentryUnlink *m) } else { dout(7) << "handle_dentry_unlink on " << *dn << dendl; - // move to stray? - CDentry *straydn = 0; - if (m->strayin) { - list finished; - CInode *in = add_replica_inode(*m->strayin, NULL, finished); - CDir *dir = add_replica_dir(in, m->straydir->get_dirfrag().frag, *m->straydir, - m->get_source().num(), finished); - straydn = add_replica_dentry(dir, *m->straydn, finished); - if (!finished.empty()) mds->queue_waiters(finished); - } + // straydn + bufferlist::iterator p = m->straybl.begin(); + list finished; + CInode *strayin = add_replica_inode(p, NULL, finished); + CDir *straydir = add_replica_dir(p, strayin, m->get_source().num(), finished); + CDentry *straydn = add_replica_dentry(p, straydir, finished); + if (!finished.empty()) mds->queue_waiters(finished); // open inode? if (dn->is_primary()) { @@ -7258,9 +7239,7 @@ void MDCache::fragment_logged(MDRequest *mdr) if (bits < 0) { // freshly replicate new basedir to peer on merge CDir *base = resultfrags.front(); - CDirDiscover *basedis = base->replicate_to(p->first); - basedis->encode(notify->basebl); - delete basedis; + replicate_dir(base, p->first, notify->basebl); } mds->send_message_mds(notify, p->first); } @@ -7307,9 +7286,7 @@ void MDCache::handle_fragment_notify(MMDSFragmentNotify *notify) // (adjust_dir_fragments expects base to already exist, if non-auth) if (notify->get_bits() < 0) { bufferlist::iterator p = notify->basebl.begin(); - CDirDiscover basedis(p); - add_replica_dir(diri, notify->get_basefrag(), basedis, - notify->get_source().num(), waiters); + add_replica_dir(p, diri, notify->get_source().num(), waiters); } // refragment diff --git a/src/mds/MDCache.h b/src/mds/MDCache.h index 838d2a73d8f2e..3fde3afadeac3 100644 --- a/src/mds/MDCache.h +++ b/src/mds/MDCache.h @@ -820,22 +820,28 @@ protected: void handle_discover(MDiscover *dis); void handle_discover_reply(MDiscoverReply *m); - CDir* add_replica_dir(CInode *diri, - frag_t fg, CDirDiscover& dis, - int from, - list& finished); +public: + void replicate_dir(CDir *dir, int to, bufferlist& bl) { + dirfrag_t df = dir->dirfrag(); + ::encode(df, bl); + dir->encode_replica(to, bl); + } + void replicate_dentry(CDentry *dn, int to, bufferlist& bl) { + ::encode(dn->name, bl); + dn->encode_replica(to, bl); + } + void replicate_inode(CInode *in, int to, bufferlist& bl) { + ::encode(in->inode.ino, bl); // bleh, minor assymetry here + in->encode_replica(to, bl); + } + + CDir* add_replica_dir(bufferlist::iterator& p, CInode *diri, int from, list& finished); CDir* forge_replica_dir(CInode *diri, frag_t fg, int from); + CDentry *add_replica_dentry(bufferlist::iterator& p, CDir *dir, list& finished); + CInode *add_replica_inode(bufferlist::iterator& p, CDentry *dn, list& finished); + CDentry *add_replica_stray(bufferlist &bl, int from); - CDentry *add_replica_dentry(CDir *dir, CDentryDiscover &dis, list& finished); -public: // for Server::handle_slave_rename_prep - CInode *add_replica_inode(CInodeDiscover& dis, CDentry *dn, list& finished); - -public: - CDentry *add_replica_stray(bufferlist &bl, CInode *strayin, int from); protected: - - - // -- namespace -- void handle_dentry_unlink(MDentryUnlink *m); diff --git a/src/mds/Migrator.cc b/src/mds/Migrator.cc index 4924861ae786c..8b14cccd6ad64 100644 --- a/src/mds/Migrator.cc +++ b/src/mds/Migrator.cc @@ -659,17 +659,20 @@ void Migrator::export_frozen(CDir *dir) } } - /* include spanning tree for all nested exports. + // include base dirfrag + cache->replicate_dir(dir, dest, prep->basedir); + + /* + * include spanning tree for all nested exports. * these need to be on the destination _before_ the final export so that * dir_auth updates on any nested exports are properly absorbed. * this includes inodes and dirfrags included in the subtree, but * only the inodes at the bounds. + * + * each trace is: df dentry inode (dir dentry inode)* */ set inodes_added; - // include base dirfrag - prep->add_dirfrag( new CDirDiscover(dir, dir->add_replica(dest)) ); - // check bounds for (set::iterator it = bounds.begin(); it != bounds.end(); @@ -681,46 +684,41 @@ void Migrator::export_frozen(CDir *dir) bound->state_set(CDir::STATE_EXPORTBOUND); dout(7) << " export bound " << *bound << dendl; + prep->add_bound( bound->dirfrag() ); - prep->add_export( bound->dirfrag() ); + // trace to bound + bufferlist tracebl; + CDir *cur = bound; + + while (1) { + // prepend dentry + inode + assert(cur->inode->is_auth()); + bufferlist bl; + cache->replicate_dentry(cur->inode->parent, dest, bl); + dout(7) << " added " << *cur->inode->parent << dendl; + cache->replicate_inode(cur->inode, dest, bl); + dout(7) << " added " << *cur->inode << dendl; + bl.claim_append(tracebl); + tracebl.claim(bl); - /* first assemble each trace, in trace order, and put in message */ - list inode_trace; + cur = cur->get_parent_dir(); - // trace to dir - CDir *cur = bound; - while (cur != dir) { // don't repeat ourselves - if (inodes_added.count(cur->ino())) break; // did already! + if (inodes_added.count(cur->ino()) || + cur == dir) break; // did already! inodes_added.insert(cur->ino()); - // inode - assert(cur->inode->is_auth()); - inode_trace.push_front(cur->inode); - dout(7) << " will add " << *cur->inode << dendl; - - // include the dirfrag? only if it's not the bounding subtree root. - if (cur != bound) { - assert(cur->is_auth()); - prep->add_dirfrag( cur->replicate_to(dest) ); // yay! - dout(7) << " added " << *cur << dendl; - } - - cur = cur->get_parent_dir(); - } - - for (list::iterator it = inode_trace.begin(); - it != inode_trace.end(); - it++) { - CInode *in = *it; - dout(7) << " added " << *in->parent << dendl; - dout(7) << " added " << *in << dendl; - prep->add_inode( in->parent->get_dir()->dirfrag(), - in->parent->get_name(), - in->parent->replicate_to(dest), - in->replicate_to(dest) ); + // prepend dir + cache->replicate_dir(cur, dest, bl); + dout(7) << " added " << *cur << dendl; + bl.claim_append(tracebl); + tracebl.claim(bl); } - + bufferlist final; + dirfrag_t df = cur->dirfrag(); + ::encode(df, final); + final.claim_append(tracebl); + prep->add_trace(final); } // send. @@ -1469,9 +1467,8 @@ void Migrator::handle_export_prep(MExportDirPrep *m) CDir *dir; if (!m->did_assim()) { - dir = cache->add_replica_dir(diri, - m->get_dirfrag().frag, *m->get_dirfrag_discover(m->get_dirfrag()), - oldauth, finished); + bufferlist::iterator p = m->basedir.begin(); + dir = cache->add_replica_dir(p, diri, oldauth, finished); dout(7) << "handle_export_prep on " << *dir << " (first pass)" << dendl; } else { dir = cache->get_dirfrag(m->get_dirfrag()); @@ -1510,36 +1507,25 @@ void Migrator::handle_export_prep(MExportDirPrep *m) dout(7) << "bystanders are " << import_bystanders[dir] << dendl; // assimilate traces to exports - for (list::iterator it = m->get_inodes().begin(); - it != m->get_inodes().end(); - it++) { - // inode - CInode *in = cache->get_inode( (*it)->get_ino() ); - if (in) { - (*it)->update_inode(in); - dout(7) << " updated " << *in << dendl; - } else { - in = new CInode(mds->mdcache, false); - (*it)->update_inode(in); - - // link to the containing dir - CDir *condir = cache->get_dirfrag( m->get_containing_dirfrag(in->ino()) ); - assert(condir); - cache->add_inode( in ); - condir->add_primary_dentry( m->get_dentry(in->ino()), in ); - - dout(7) << " added " << *in << dendl; - } - - assert( in->get_parent_dir()->dirfrag() == m->get_containing_dirfrag(in->ino()) ); - - // dirs - for (list::iterator pf = m->get_inode_dirfrags(in->ino()).begin(); - pf != m->get_inode_dirfrags(in->ino()).end(); - ++pf) { - // add/update - cache->add_replica_dir(in, *pf, *m->get_dirfrag_discover(dirfrag_t(in->ino(), *pf)), - oldauth, finished); + // each trace is: df dentry inode (dir dentry inode)* + for (list::iterator p = m->traces.begin(); + p != m->traces.end(); + p++) { + bufferlist::iterator q = p->begin(); + dirfrag_t df; + ::decode(df, q); + dout(10) << " trace from " << df << dendl; + CDir *cur = cache->get_dirfrag(df); + assert(cur); + dout(10) << " had " << *cur << dendl; + while (1) { + CDentry *dn = cache->add_replica_dentry(q, cur, finished); + dout(10) << " added " << *dn << dendl; + CInode *in = cache->add_replica_inode(q, dn, finished); + dout(10) << " added " << *in << dendl; + if (q.end()) break; + cur = cache->add_replica_dir(q, in, oldauth, finished); + dout(10) << " added " << *cur << dendl; } } diff --git a/src/mds/Server.cc b/src/mds/Server.cc index a203dc6391bfb..bdeb3fc32d823 100644 --- a/src/mds/Server.cc +++ b/src/mds/Server.cc @@ -3002,9 +3002,9 @@ void Server::_unlink_local_finish(MDRequest *mdr, dout(7) << "_unlink_local_finish sending MDentryUnlink to mds" << it->first << dendl; MDentryUnlink *unlink = new MDentryUnlink(dn->dir->dirfrag(), dn->name); if (straydn) { - unlink->strayin = straydn->dir->inode->replicate_to(it->first); - unlink->straydir = straydn->dir->replicate_to(it->first); - unlink->straydn = straydn->replicate_to(it->first); + mdcache->replicate_inode(straydn->dir->inode, it->first, unlink->straybl); + mdcache->replicate_dir(straydn->dir, it->first, unlink->straybl); + mdcache->replicate_dentry(straydn, it->first, unlink->straybl); } mds->send_message_mds(unlink, it->first); } @@ -3518,15 +3518,9 @@ void Server::_rename_prepare_witness(MDRequest *mdr, int who, CDentry *srcdn, CD req->now = mdr->now; if (straydn) { - CInodeDiscover *indis = straydn->dir->inode->replicate_to(who); - CDirDiscover *dirdis = straydn->dir->replicate_to(who); - CDentryDiscover *dndis = straydn->replicate_to(who); - indis->encode(req->stray); - dirdis->encode(req->stray); - dndis->encode(req->stray); - delete indis; - delete dirdis; - delete dndis; + mdcache->replicate_inode(straydn->dir->inode, who, req->stray); + mdcache->replicate_dir(straydn->dir, who, req->stray); + mdcache->replicate_dentry(straydn, who, req->stray); } // srcdn auth will verify our current witness list is sufficient @@ -3943,8 +3937,7 @@ void Server::handle_slave_rename_prep(MDRequest *mdr) CDentry *straydn = 0; if (destdn->is_primary() && !linkmerge) { assert(mdr->slave_request->stray.length() > 0); - straydn = mdcache->add_replica_stray(mdr->slave_request->stray, - destdn->inode, mdr->slave_to_mds); + straydn = mdcache->add_replica_stray(mdr->slave_request->stray, mdr->slave_to_mds); assert(straydn); mdr->pin(straydn); } diff --git a/src/mds/SimpleLock.h b/src/mds/SimpleLock.h index 0be17e0d4c862..a8226d2b8b1c9 100644 --- a/src/mds/SimpleLock.h +++ b/src/mds/SimpleLock.h @@ -248,8 +248,13 @@ public: void encode_state(bufferlist& bl) const { ::encode(state, bl); } - void decode_state(bufferlist::iterator& p) { - ::decode(state, p); + void decode_state(bufferlist::iterator& p, bool is_new=true) { + if (is_new) + ::decode(state, p); + else { + __s32 blah; + ::decode(blah, p); + } } void decode_state_rejoin(bufferlist::iterator& p, list& waiters) { __s32 s; diff --git a/src/messages/MDentryUnlink.h b/src/messages/MDentryUnlink.h index 074e149b66e78..135cfbc3b4ade 100644 --- a/src/messages/MDentryUnlink.h +++ b/src/messages/MDentryUnlink.h @@ -24,23 +24,14 @@ class MDentryUnlink : public Message { dirfrag_t get_dirfrag() { return dirfrag; } nstring& get_dn() { return dn; } - CInodeDiscover *strayin; - CDirDiscover *straydir; - CDentryDiscover *straydn; + bufferlist straybl; MDentryUnlink() : - Message(MSG_MDS_DENTRYUNLINK), - strayin(0), straydir(0), straydn(0) { } + Message(MSG_MDS_DENTRYUNLINK) { } MDentryUnlink(dirfrag_t df, nstring& n) : Message(MSG_MDS_DENTRYUNLINK), dirfrag(df), - dn(n), - strayin(0), straydir(0), straydn(0) { } - ~MDentryUnlink() { - delete strayin; - delete straydir; - delete straydn; - } + dn(n) {} const char *get_type_name() { return "dentry_unlink";} void print(ostream& o) { @@ -51,26 +42,12 @@ class MDentryUnlink : public Message { bufferlist::iterator p = payload.begin(); ::decode(dirfrag, p); ::decode(dn, p); - - bool isstray; - ::decode(isstray, p); - if (isstray) { - strayin = new CInodeDiscover(p); - straydir = new CDirDiscover(p); - straydn = new CDentryDiscover(p); - } + ::decode(straybl, p); } void encode_payload() { ::encode(dirfrag, payload); ::encode(dn, payload); - - bool isstray = strayin ? true:false; - ::encode(isstray, payload); - if (isstray) { - strayin->encode(payload); - straydir->encode(payload); - straydn->encode(payload); - } + ::encode(straybl, payload); } }; diff --git a/src/messages/MDiscoverReply.h b/src/messages/MDiscoverReply.h index 1426c35f78930..38b8e448ef470 100644 --- a/src/messages/MDiscoverReply.h +++ b/src/messages/MDiscoverReply.h @@ -80,19 +80,17 @@ class MDiscoverReply : public Message { bool flag_error_dn; bool flag_error_ino; bool flag_error_dir; - bool no_base_dir; // no base dir (but IS dentry+inode) - bool no_base_dentry; // no base dentry (but IS inode) string error_dentry; // dentry that was not found (to trigger waiters on asker) bool unsolicited; __s32 dir_auth_hint; - vector dirs; // not inode-aligned if no_base_dir = true. - vector dentries; // not inode-aligned if no_base_dentry = true - vector inodes; + public: + __u8 starts_with; + bufferlist trace; + enum { DIR, DENTRY, INODE }; - public: // accessors inodeno_t get_base_ino() { return base_ino; } frag_t get_base_dir_frag() { return base_dir_frag; } @@ -100,40 +98,18 @@ class MDiscoverReply : public Message { bool get_wanted_xlocked() { return wanted_xlocked; } inodeno_t get_wanted_ino() { return wanted_ino; } - int get_num_inodes() { return inodes.size(); } - int get_num_dentries() { return dentries.size(); } - int get_num_dirs() { return dirs.size(); } - - int get_last_inode() { return inodes.size(); } - int get_last_dentry() { return dentries.size() + no_base_dentry; } - int get_last_dir() { return dirs.size() + no_base_dir; } - - int get_depth() { // return depth of deepest object (in dir/dentry/inode units) - return max( inodes.size(), // at least this many - max( no_base_dentry + dentries.size() + flag_error_dn, // inode start + path + possible error - dirs.size() + no_base_dir )); // dn/inode + dirs - } - - bool has_base_dir() { return !no_base_dir && dirs.size(); } - bool has_base_dentry() { return !no_base_dentry && dentries.size(); } - bool has_base_inode() { return no_base_dir && no_base_dentry; } - bool is_flag_error_dn() { return flag_error_dn; } bool is_flag_error_ino() { return flag_error_ino; } bool is_flag_error_dir() { return flag_error_dir; } string& get_error_dentry() { return error_dentry; } + int get_starts_with() { return starts_with; } + int get_dir_auth_hint() { return dir_auth_hint; } bool is_unsolicited() { return unsolicited; } void mark_unsolicited() { unsolicited = true; } - // these index _arguments_ are aligned to each ([[dir, ] dentry, ] inode) set. - CInodeDiscover& get_inode(int n) { return *(inodes[n]); } - CDentryDiscover& get_dentry(int n) { return *(dentries[n - no_base_dentry]); } - CDirDiscover& get_dir(int n) { return *(dirs[n - no_base_dir]); } - inodeno_t get_ino(int n) { return inodes[n]->get_ino(); } - // cons MDiscoverReply() {} MDiscoverReply(MDiscover *dis) : @@ -146,7 +122,6 @@ class MDiscoverReply : public Message { flag_error_dn(false), flag_error_ino(false), flag_error_dir(false), - no_base_dir(false), no_base_dentry(false), dir_auth_hint(CDIR_AUTH_UNKNOWN) { } MDiscoverReply(dirfrag_t df) : @@ -159,47 +134,18 @@ class MDiscoverReply : public Message { flag_error_dn(false), flag_error_ino(false), flag_error_dir(false), - no_base_dir(false), no_base_dentry(false), dir_auth_hint(CDIR_AUTH_UNKNOWN) { } - ~MDiscoverReply() { - for (vector::iterator it = dirs.begin(); - it != dirs.end(); - it++) - delete *it; - for (vector::iterator it = dentries.begin(); - it != dentries.end(); - it++) - delete *it; - for (vector::iterator it = inodes.begin(); - it != inodes.end(); - it++) - delete *it; - } const char *get_type_name() { return "DisR"; } // builders bool is_empty() { - return dirs.empty() && dentries.empty() && inodes.empty() && + return trace.length() == 0 && !flag_error_dn && !flag_error_ino && !flag_error_dir && dir_auth_hint == CDIR_AUTH_UNKNOWN; } - void add_dentry(CDentryDiscover* ddis) { - if (dentries.empty() && dirs.empty()) no_base_dir = true; - dentries.push_back(ddis); - } - - void add_inode(CInodeDiscover* din) { - if (inodes.empty() && dentries.empty()) no_base_dir = no_base_dentry = true; - inodes.push_back( din ); - } - - void add_dir(CDirDiscover* dir) { - dirs.push_back( dir ); - } - // void set_flag_forward() { flag_forward = true; } void set_flag_error_dn(const string& dn) { @@ -230,15 +176,12 @@ class MDiscoverReply : public Message { ::decode(flag_error_dn, p); ::decode(flag_error_ino, p); ::decode(flag_error_dir, p); - ::decode(no_base_dir, p); - ::decode(no_base_dentry, p); ::decode(error_dentry, p); ::decode(dir_auth_hint, p); ::decode(unsolicited, p); - ::decode(dirs, p); - ::decode(inodes, p); - ::decode(dentries, p); + ::decode(starts_with, p); + ::decode(trace, p); } void encode_payload() { ::encode(base_ino, payload); @@ -248,15 +191,12 @@ class MDiscoverReply : public Message { ::encode(flag_error_dn, payload); ::encode(flag_error_ino, payload); ::encode(flag_error_dir, payload); - ::encode(no_base_dir, payload); - ::encode(no_base_dentry, payload); ::encode(error_dentry, payload); ::encode(dir_auth_hint, payload); ::encode(unsolicited, payload); - ::encode(dirs, payload); - ::encode(inodes, payload); - ::encode(dentries, payload); + ::encode(starts_with, payload); + ::encode(trace, payload); } }; diff --git a/src/messages/MExportDirPrep.h b/src/messages/MExportDirPrep.h index 7ee9f5f5ac16d..b074bbbcee141 100644 --- a/src/messages/MExportDirPrep.h +++ b/src/messages/MExportDirPrep.h @@ -22,46 +22,17 @@ class MExportDirPrep : public Message { dirfrag_t dirfrag; - - /* nested export discover payload. - not all inodes will have dirs; they may require a separate discover. - dentries are the links to each inode. - dirs map includes base dir (ino) - */ - list bounds; - - list inodes; - list dentries; - map inode_dirfrag; - map inode_dentry; - - map > frags_by_ino; - map dirfrags; - - set<__s32> bystanders; - + public: + bufferlist basedir; + list bounds; + list traces; +private: + set<__s32> bystanders; bool b_did_assim; - public: +public: dirfrag_t get_dirfrag() { return dirfrag; } list& get_bounds() { return bounds; } - list& get_inodes() { return inodes; } - list& get_dentries() { return dentries; } - list& get_inode_dirfrags(inodeno_t ino) { - return frags_by_ino[ino]; - } - dirfrag_t get_containing_dirfrag(inodeno_t ino) { - return inode_dirfrag[ino]; - } - nstring& get_dentry(inodeno_t ino) { - return inode_dentry[ino]; - } - bool have_dirfrag(dirfrag_t df) { - return dirfrags.count(df); - } - CDirDiscover* get_dirfrag_discover(dirfrag_t df) { - return dirfrags[df]; - } set<__s32> &get_bystanders() { return bystanders; } bool did_assim() { return b_did_assim; } @@ -74,20 +45,6 @@ class MExportDirPrep : public Message { Message(MSG_MDS_EXPORTDIRPREP), dirfrag(df), b_did_assim(false) { } - ~MExportDirPrep() { - for (list::iterator iit = inodes.begin(); - iit != inodes.end(); - iit++) - delete *iit; - for (list::iterator p = dentries.begin(); - p != dentries.end(); - p++) - delete *p; - for (map::iterator dit = dirfrags.begin(); - dit != dirfrags.end(); - dit++) - delete dit->second; - } const char *get_type_name() { return "ExP"; } @@ -95,45 +52,30 @@ class MExportDirPrep : public Message { o << "export_prep(" << dirfrag << ")"; } - void add_export(dirfrag_t df) { + void add_bound(dirfrag_t df) { bounds.push_back( df ); } - void add_inode(dirfrag_t df, const nstring& name, CDentryDiscover *dn, CInodeDiscover *in) { - inodes.push_back(in); - dentries.push_back(dn); - inode_dirfrag[in->get_ino()] = df; - inode_dentry[in->get_ino()] = name; - } - void add_dirfrag(CDirDiscover *dir) { - dirfrags[dir->get_dirfrag()] = dir; - frags_by_ino[dir->get_dirfrag().ino].push_back(dir->get_dirfrag().frag); + void add_trace(bufferlist& bl) { + traces.push_back(bl); } void add_bystander(int who) { bystanders.insert(who); } - virtual void decode_payload() { + void decode_payload() { bufferlist::iterator p = payload.begin(); ::decode(dirfrag, p); + ::decode(basedir, p); ::decode(bounds, p); - ::decode(inodes, p); - ::decode(dentries, p); - ::decode(inode_dirfrag, p); - ::decode(inode_dentry, p); - ::decode(frags_by_ino, p); - ::decode(dirfrags, p); + ::decode(traces, p); ::decode(bystanders, p); } - virtual void encode_payload() { + void encode_payload() { ::encode(dirfrag, payload); + ::encode(basedir, payload); ::encode(bounds, payload); - ::encode(inodes, payload); - ::encode(dentries, payload); - ::encode(inode_dirfrag, payload); - ::encode(inode_dentry, payload); - ::encode(frags_by_ino, payload); - ::encode(dirfrags, payload); + ::encode(traces, payload); ::encode(bystanders, payload); } }; diff --git a/src/messages/MLock.h b/src/messages/MLock.h index eb2004733f427..fd85bccb0f139 100644 --- a/src/messages/MLock.h +++ b/src/messages/MLock.h @@ -61,7 +61,7 @@ class MLock : public Message { int32_t asker; // who is initiating this request metareqid_t reqid; // for remote lock requests - char lock_type; // lock object type + __u16 lock_type; // lock object type MDSCacheObjectInfo object_info; bufferlist lockdata; // and possibly some data diff --git a/src/messages/MMDSSlaveRequest.h b/src/messages/MMDSSlaveRequest.h index 6e1e84e0e737b..c0ceeda863ea8 100644 --- a/src/messages/MMDSSlaveRequest.h +++ b/src/messages/MMDSSlaveRequest.h @@ -68,10 +68,10 @@ class MMDSSlaveRequest : public Message { private: metareqid_t reqid; - char op; + __s16 op; // for locking - char lock_type; // lock object type + __u16 lock_type; // lock object type MDSCacheObjectInfo object_info; // for authpins -- 2.39.5