mds: rename SnapRealm::snaprealm to SnapRealm::srnode

diff --git a/src/librados.cc b/src/librados.cc
index 5227afcf090429b0f58b9e69829aa73e1ccc4021..0c63007063eaa12b2c7bceefd08e108c6b2c8e02 100644 (file)
--- a/src/librados.cc
+++ b/src/librados.cc
@@ -819,23 +819,23 @@ int RadosClient::write(PoolCtx& pool, const object_t& oid, off_t off, bufferlist
   static SnapContext snapc;
   static int i;
 
-  snapc.snaprealm.snaps.clear();
+  snapc.srnode.snaps.clear();
 
 #define START_SNAP 1
 
-  if (snapc.snaprealm.seq == 0)
-    snapc.snaprealm.seq = START_SNAP - 1;
+  if (snapc.srnode.seq == 0)
+    snapc.srnode.seq = START_SNAP - 1;
 
-  ++snapc.snaprealm.seq;
-  for (i=0; i<snapc.snaprealm.seq-START_SNAP + 1; i++) {
-     snapc.snaprealm.snaps.push_back(snapc.snaprealm.seq - i);
+  ++snapc.srnode.seq;
+  for (i=0; i<snapc.srnode.seq-START_SNAP + 1; i++) {
+     snapc.srnode.snaps.push_back(snapc.srnode.seq - i);
   }
   i = 0;
-  for (vector<snapid_t>::iterator iter = snapc.snaprealm.snaps.begin();
-       iter != snapc.snaprealm.snaps.end(); ++iter, ++i) {
+  for (vector<snapid_t>::iterator iter = snapc.srnode.snaps.begin();
+       iter != snapc.srnode.snaps.end(); ++iter, ++i) {
     dout(0) << "snapc[" << i << "] = " << *iter << dendl;
   }
-  dout(0) << "seq=" << snapc.snaprealm.seq << dendl;
+  dout(0) << "seq=" << snapc.srnode.seq << dendl;
   dout(0) << "snapc=" << snapc << dendl;
 #endif
   utime_t ut = g_clock.now();

diff --git a/src/mds/CInode.cc b/src/mds/CInode.cc
index f2174e08717a081c4f42c5b1d4a7fc1bd31f768d..850d5990b658086518dcdd0ad26ce0d72ab7d648 100644 (file)
--- a/src/mds/CInode.cc
+++ b/src/mds/CInode.cc
@@ -1176,9 +1176,9 @@ void CInode::decode_lock_state(int type, bufferlist& bl)
     {
       snapid_t seq = 0;
       if (snaprealm)
-       seq = snaprealm->snaprealm.seq;
+       seq = snaprealm->srnode.seq;
       decode_snap(p);
-      if (snaprealm && snaprealm->snaprealm.seq != seq)
+      if (snaprealm && snaprealm->srnode.seq != seq)
        mdcache->do_realm_invalidate_and_update_notify(this, seq ? CEPH_SNAP_OP_UPDATE:CEPH_SNAP_OP_SPLIT);
     }
     break;

diff --git a/src/mds/MDCache.cc b/src/mds/MDCache.cc
index 32f989be2dcf758dff18fc4e6cdaf90ab1c8b689..0e0bfaa0e4519870dc2d74da09f8871604b5bc26 100644 (file)
--- a/src/mds/MDCache.cc
+++ b/src/mds/MDCache.cc
@@ -265,7 +265,7 @@ CInode *MDCache::create_system_inode(inodeno_t ino, int mode)
     else
       in->inode_auth = pair<int,int>(in->ino() - MDS_INO_MDSDIR_OFFSET, CDIR_AUTH_UNKNOWN);
     in->open_snaprealm();  // empty snaprealm
-    in->snaprealm->snaprealm.seq = 1;
+    in->snaprealm->srnode.seq = 1;
   }
   
   add_inode(in);
@@ -6829,7 +6829,7 @@ void MDCache::snaprealm_create(MDRequest *mdr, CInode *in)
   ::decode(seq, p);
 
   SnapRealm t(this, in);
-  t.snaprealm.created = seq;
+  t.srnode.created = seq;
   bufferlist snapbl;
   ::encode(t, snapbl);
   
@@ -6920,9 +6920,9 @@ void MDCache::_snaprealm_create_finish(MDRequest *mdr, Mutation *mut, CInode *in
   ::decode(seq, p);
 
   in->open_snaprealm();
-  in->snaprealm->snaprealm.seq = seq;
-  in->snaprealm->snaprealm.created = seq;
-  in->snaprealm->snaprealm.current_parent_since = seq;
+  in->snaprealm->srnode.seq = seq;
+  in->snaprealm->srnode.created = seq;
+  in->snaprealm->srnode.current_parent_since = seq;
 
   do_realm_invalidate_and_update_notify(in, CEPH_SNAP_OP_SPLIT);
 
@@ -6996,7 +6996,7 @@ void MDCache::eval_stray(CDentry *dn)
          return;
        in->snaprealm->prune_past_parents();
        if (in->snaprealm->has_past_parents()) {
-         dout(20) << "  has past parents " << in->snaprealm->snaprealm.past_parents << dendl;
+         dout(20) << "  has past parents " << in->snaprealm->srnode.past_parents << dendl;
          return;  // not until some snaps are deleted.
        }
       }

diff --git a/src/mds/Server.cc b/src/mds/Server.cc
index c7ad7c42e2d6193a2857efd4448c5834feda0e38..818c6f7dd0598bc6c69bfab50dbf2080a0799e8e 100644 (file)
--- a/src/mds/Server.cc
+++ b/src/mds/Server.cc
@@ -4102,7 +4102,7 @@ void Server::_unlink_local_finish(MDRequest *mdr,
     bool isnew = false;
     if (!straydnl->get_inode()->snaprealm) {
       straydnl->get_inode()->open_snaprealm();
-      straydnl->get_inode()->snaprealm->snaprealm.seq = oldparent->get_newest_seq();
+      straydnl->get_inode()->snaprealm->srnode.seq = oldparent->get_newest_seq();
       isnew = true;
     }
     straydnl->get_inode()->snaprealm->add_past_parent(oldparent);
@@ -4160,7 +4160,7 @@ bool Server::_dir_is_nonempty(MDRequest *mdr, CInode *in)
   assert(in->is_auth());
 
   
-  if (in->snaprealm && in->snaprealm->snaprealm.snaps.size())
+  if (in->snaprealm && in->snaprealm->srnode.snaps.size())
     return true; //in a snapshot!
 
   list<frag_t> frags;
@@ -4896,7 +4896,7 @@ void Server::_rename_apply(MDRequest *mdr, CDentry *srcdn, CDentry *destdn, CDen
        bool isnew = false;
        if (!straydnl->get_inode()->snaprealm) {
          straydnl->get_inode()->open_snaprealm();
-         straydnl->get_inode()->snaprealm->snaprealm.seq = oldparent->get_newest_seq();
+         straydnl->get_inode()->snaprealm->srnode.seq = oldparent->get_newest_seq();
          isnew = true;
        }
        straydnl->get_inode()->snaprealm->add_past_parent(oldparent);
@@ -5748,21 +5748,22 @@ void Server::handle_client_mksnap(MDRequest *mdr)
   if (!diri->snaprealm) {
     newrealm = true;
     diri->open_snaprealm(true);
-    diri->snaprealm->snaprealm.created = snapid;
-    diri->snaprealm->snaprealm.current_parent_since = snapid;
-  }
-  snapid_t old_seq = diri->snaprealm->snaprealm.seq;
-  snapid_t old_lc = diri->snaprealm->snaprealm.last_created;
-  diri->snaprealm->snaprealm.snaps[snapid] = info;
-  diri->snaprealm->snaprealm.seq = snapid;
-  diri->snaprealm->snaprealm.last_created = snapid;
+    diri->snaprealm->srnode.created = snapid;
+    diri->snaprealm->srnode.current_parent_since = snapid;
+  }
+  snapid_t old_seq = diri->snaprealm->srnode.seq;
+  snapid_t old_lc = diri->snaprealm->srnode.last_created;
+  diri->snaprealm->srnode.snaps[snapid] = info;
+  diri->snaprealm->srnode.seq = snapid;
+  diri->snaprealm->srnode.last_created = snapid;
   diri->encode_snap_blob(snapbl);
-  diri->snaprealm->snaprealm.snaps.erase(snapid);
-  diri->snaprealm->snaprealm.seq = old_seq;
-  diri->snaprealm->snaprealm.last_created = old_lc;
+  diri->snaprealm->srnode.snaps.erase(snapid);
+  diri->snaprealm->srnode.seq = old_seq;
+  diri->snaprealm->srnode.last_created = old_lc;
   if (newrealm)
     diri->close_snaprealm(true);
   
+
   le->metablob.add_primary_dentry(diri->get_projected_parent_dn(), true, 0, 0, &snapbl);
 
   mdlog->submit_entry(le, new C_MDS_mksnap_finish(mds, mdr, diri, info));
@@ -5783,13 +5784,13 @@ void Server::_mksnap_finish(MDRequest *mdr, CInode *diri, SnapInfo &info)
   int op = CEPH_SNAP_OP_CREATE;
   if (!diri->snaprealm) {
     diri->open_snaprealm();
-    diri->snaprealm->snaprealm.created = snapid;
-    diri->snaprealm->snaprealm.current_parent_since = snapid;
+    diri->snaprealm->srnode.created = snapid;
+    diri->snaprealm->srnode.current_parent_since = snapid;
     op = CEPH_SNAP_OP_SPLIT;
   }
-  diri->snaprealm->snaprealm.snaps[snapid] = info;
-  diri->snaprealm->snaprealm.seq = snapid;
-  diri->snaprealm->snaprealm.last_created = snapid;
+  diri->snaprealm->srnode.snaps[snapid] = info;
+  diri->snaprealm->srnode.seq = snapid;
+  diri->snaprealm->srnode.last_created = snapid;
   dout(10) << "snaprealm now " << *diri->snaprealm << dendl;
 
   mdcache->do_realm_invalidate_and_update_notify(diri, op);
@@ -5892,16 +5893,16 @@ void Server::handle_client_rmsnap(MDRequest *mdr)
   
   // project the snaprealm.. hack!
   bufferlist snapbl;
-  snapid_t old_seq = diri->snaprealm->snaprealm.seq;
-  snapid_t old_ld = diri->snaprealm->snaprealm.last_destroyed;
-  SnapInfo old_info = diri->snaprealm->snaprealm.snaps[snapid];
-  diri->snaprealm->snaprealm.snaps.erase(snapid);
-  diri->snaprealm->snaprealm.seq = seq;
-  diri->snaprealm->snaprealm.last_destroyed = seq;
+  snapid_t old_seq = diri->snaprealm->srnode.seq;
+  snapid_t old_ld = diri->snaprealm->srnode.last_destroyed;
+  SnapInfo old_info = diri->snaprealm->srnode.snaps[snapid];
+  diri->snaprealm->srnode.snaps.erase(snapid);
+  diri->snaprealm->srnode.seq = seq;
+  diri->snaprealm->srnode.last_destroyed = seq;
   diri->encode_snap_blob(snapbl);
-  diri->snaprealm->snaprealm.snaps[snapid] = old_info;
-  diri->snaprealm->snaprealm.seq = old_seq;
-  diri->snaprealm->snaprealm.last_destroyed = old_ld;
+  diri->snaprealm->srnode.snaps[snapid] = old_info;
+  diri->snaprealm->srnode.seq = old_seq;
+  diri->snaprealm->srnode.last_destroyed = old_ld;
   le->metablob.add_primary_dentry(diri->get_projected_parent_dn(), true, 0, 0, &snapbl);
 
   mdlog->submit_entry(le, new C_MDS_rmsnap_finish(mds, mdr, diri, snapid));
@@ -5922,9 +5923,9 @@ void Server::_rmsnap_finish(MDRequest *mdr, CInode *diri, snapid_t snapid)
   mds->snapclient->commit(stid, mdr->ls);
 
   // remove snap
-  diri->snaprealm->snaprealm.snaps.erase(snapid);
-  diri->snaprealm->snaprealm.last_destroyed = seq;
-  diri->snaprealm->snaprealm.seq = seq;
+  diri->snaprealm->srnode.snaps.erase(snapid);
+  diri->snaprealm->srnode.last_destroyed = seq;
+  diri->snaprealm->srnode.seq = seq;
   dout(10) << "snaprealm now " << *diri->snaprealm << dendl;
 
   mdcache->do_realm_invalidate_and_update_notify(diri, CEPH_SNAP_OP_DESTROY);

diff --git a/src/mds/snap.cc b/src/mds/snap.cc
index 36da17f37d534be60f575c9c350d0ee75bc3badb..a04dafb2f29721e38241e7de2b98d9e03406cc22 100644 (file)
--- a/src/mds/snap.cc
+++ b/src/mds/snap.cc
@@ -24,7 +24,7 @@
 
 #define DOUT_SUBSYS mds
 #undef dout_prefix
-#define dout_prefix _prefix(mdcache->mds->get_nodeid(), inode, snaprealm.seq, this)
+#define dout_prefix _prefix(mdcache->mds->get_nodeid(), inode, srnode.seq, this)
 static ostream& _prefix(int whoami, CInode *inode, uint64_t seq, SnapRealm *realm) {
   return *_dout << dbeginl
                << " mds" << whoami
@@ -35,18 +35,18 @@ static ostream& _prefix(int whoami, CInode *inode, uint64_t seq, SnapRealm *real
 ostream& operator<<(ostream& out, const SnapRealm& realm) 
 {
   out << "snaprealm(" << realm.inode->ino()
-      << " seq " << realm.snaprealm.seq
-      << " lc " << realm.snaprealm.last_created
-      << " cr " << realm.snaprealm.created;
-  if (realm.snaprealm.created != realm.snaprealm.current_parent_since)
-    out << " cps " << realm.snaprealm.current_parent_since;
-  out << " snaps=" << realm.snaprealm.snaps;
-  if (realm.snaprealm.past_parents.size()) {
+      << " seq " << realm.srnode.seq
+      << " lc " << realm.srnode.last_created
+      << " cr " << realm.srnode.created;
+  if (realm.srnode.created != realm.srnode.current_parent_since)
+    out << " cps " << realm.srnode.current_parent_since;
+  out << " snaps=" << realm.srnode.snaps;
+  if (realm.srnode.past_parents.size()) {
     out << " past_parents=(";
-    for (map<snapid_t, snaplink_t>::const_iterator p = realm.snaprealm.past_parents.begin(); 
-        p != realm.snaprealm.past_parents.end(); 
+    for (map<snapid_t, snaplink_t>::const_iterator p = realm.srnode.past_parents.begin(); 
+        p != realm.srnode.past_parents.end(); 
         p++) {
-      if (p != realm.snaprealm.past_parents.begin()) out << ",";
+      if (p != realm.srnode.past_parents.begin()) out << ",";
       out << p->second.first << "-" << p->first
          << "=" << p->second.ino;
     }
@@ -73,18 +73,18 @@ bool SnapRealm::_open_parents(Context *finish, snapid_t first, snapid_t last)
 
   // make sure my current parents' parents are open...
   if (parent) {
-    dout(10) << " current parent [" << snaprealm.current_parent_since << ",head] is " << *parent
+    dout(10) << " current parent [" << srnode.current_parent_since << ",head] is " << *parent
             << " on " << *parent->inode << dendl;
-    if (last >= snaprealm.current_parent_since &&
-       !parent->_open_parents(finish, MAX(first, snaprealm.current_parent_since), last))
+    if (last >= srnode.current_parent_since &&
+       !parent->_open_parents(finish, MAX(first, srnode.current_parent_since), last))
       return false;
   }
 
   // and my past parents too!
-  assert(snaprealm.past_parents.size() >= open_past_parents.size());
-  if (snaprealm.past_parents.size() > open_past_parents.size()) {
-    for (map<snapid_t, snaplink_t>::iterator p = snaprealm.past_parents.begin();
-        p != snaprealm.past_parents.end();
+  assert(srnode.past_parents.size() >= open_past_parents.size());
+  if (srnode.past_parents.size() > open_past_parents.size()) {
+    for (map<snapid_t, snaplink_t>::iterator p = srnode.past_parents.begin();
+        p != srnode.past_parents.end();
         p++) {    
       dout(10) << " past_parent [" << p->second.first << "," << p->first << "] is "
               << p->second.ino << dendl;
@@ -112,8 +112,8 @@ bool SnapRealm::have_past_parents_open(snapid_t first, snapid_t last)
   if (open)
     return true;
 
-  for (map<snapid_t, snaplink_t>::iterator p = snaprealm.past_parents.lower_bound(first);
-       p != snaprealm.past_parents.end();
+  for (map<snapid_t, snaplink_t>::iterator p = srnode.past_parents.lower_bound(first);
+       p != srnode.past_parents.end();
        p++) {
     if (p->second.first > last)
       break;
@@ -152,22 +152,22 @@ void SnapRealm::build_snap_set(set<snapid_t> &s,
 {
   dout(10) << "build_snap_set [" << first << "," << last << "] on " << *this << dendl;
 
-  if (snaprealm.seq > max_seq)
-    max_seq = snaprealm.seq;
-  if (snaprealm.last_created > max_last_created)
-    max_last_created = snaprealm.last_created;
-  if (snaprealm.last_destroyed > max_last_destroyed)
-    max_last_destroyed = snaprealm.last_destroyed;
+  if (srnode.seq > max_seq)
+    max_seq = srnode.seq;
+  if (srnode.last_created > max_last_created)
+    max_last_created = srnode.last_created;
+  if (srnode.last_destroyed > max_last_destroyed)
+    max_last_destroyed = srnode.last_destroyed;
 
   // include my snaps within interval [first,last]
-  for (map<snapid_t, SnapInfo>::iterator p = snaprealm.snaps.lower_bound(first); // first element >= first
-       p != snaprealm.snaps.end() && p->first <= last;
+  for (map<snapid_t, SnapInfo>::iterator p = srnode.snaps.lower_bound(first); // first element >= first
+       p != srnode.snaps.end() && p->first <= last;
        p++)
     s.insert(p->first);
 
   // include snaps for parents during intervals that intersect [first,last]
-  for (map<snapid_t, snaplink_t>::iterator p = snaprealm.past_parents.lower_bound(first);
-       p != snaprealm.past_parents.end() && p->first >= first && p->second.first <= last;
+  for (map<snapid_t, snaplink_t>::iterator p = srnode.past_parents.lower_bound(first);
+       p != srnode.past_parents.end() && p->first >= first && p->second.first <= last;
        p++) {
     CInode *oldparent = mdcache->get_inode(p->second.ino);
     assert(oldparent);  // call open_parents first!
@@ -176,23 +176,23 @@ void SnapRealm::build_snap_set(set<snapid_t> &s,
                                         MAX(first, p->second.first),
                                         MIN(last, p->first));
   }
-  if (snaprealm.current_parent_since <= last && parent)
+  if (srnode.current_parent_since <= last && parent)
     parent->build_snap_set(s, max_seq, max_last_created, max_last_destroyed,
-                          MAX(first, snaprealm.current_parent_since), last);
+                          MAX(first, srnode.current_parent_since), last);
 }
 
 
 void SnapRealm::check_cache()
 {
-  if (cached_seq >= snaprealm.seq)
+  if (cached_seq >= srnode.seq)
     return;
 
   cached_snaps.clear();
   cached_snap_context.clear();
 
-  cached_last_created = snaprealm.last_created;
-  cached_last_destroyed = snaprealm.last_destroyed;
-  cached_seq = snaprealm.seq;
+  cached_last_created = srnode.last_created;
+  cached_last_destroyed = srnode.last_destroyed;
+  cached_seq = srnode.seq;
   build_snap_set(cached_snaps, cached_seq, cached_last_created, cached_last_destroyed,
                 0, CEPH_NOSNAP);
 
@@ -200,7 +200,7 @@ void SnapRealm::check_cache()
   build_snap_trace(cached_snap_trace);
   
   dout(10) << "check_cache rebuilt " << cached_snaps
-          << " seq " << snaprealm.seq
+          << " seq " << srnode.seq
           << " cached_seq " << cached_seq
           << " cached_last_created " << cached_last_created
           << " cached_last_destroyed " << cached_last_destroyed
@@ -211,7 +211,7 @@ const set<snapid_t>& SnapRealm::get_snaps()
 {
   check_cache();
   dout(10) << "get_snaps " << cached_snaps
-          << " (seq " << snaprealm.seq << " cached_seq " << cached_seq << ")"
+          << " (seq " << srnode.seq << " cached_seq " << cached_seq << ")"
           << dendl;
   return cached_snaps;
 }
@@ -241,14 +241,14 @@ void SnapRealm::get_snap_info(map<snapid_t,SnapInfo*>& infomap, snapid_t first,
   dout(10) << "get_snap_info snaps " << get_snaps() << dendl;
 
   // include my snaps within interval [first,last]
-  for (map<snapid_t, SnapInfo>::iterator p = snaprealm.snaps.lower_bound(first); // first element >= first
-       p != snaprealm.snaps.end() && p->first <= last;
+  for (map<snapid_t, SnapInfo>::iterator p = srnode.snaps.lower_bound(first); // first element >= first
+       p != srnode.snaps.end() && p->first <= last;
        p++)
     infomap[p->first] = &p->second;
 
   // include snaps for parents during intervals that intersect [first,last]
-  for (map<snapid_t, snaplink_t>::iterator p = snaprealm.past_parents.lower_bound(first);
-       p != snaprealm.past_parents.end() && p->first >= first && p->second.first <= last;
+  for (map<snapid_t, snaplink_t>::iterator p = srnode.past_parents.lower_bound(first);
+       p != srnode.past_parents.end() && p->first >= first && p->second.first <= last;
        p++) {
     CInode *oldparent = mdcache->get_inode(p->second.ino);
     assert(oldparent);  // call open_parents first!
@@ -257,8 +257,8 @@ void SnapRealm::get_snap_info(map<snapid_t,SnapInfo*>& infomap, snapid_t first,
                                        MAX(first, p->second.first),
                                        MIN(last, p->first));
   }
-  if (snaprealm.current_parent_since <= last && parent)
-    parent->get_snap_info(infomap, MAX(first, snaprealm.current_parent_since), last);
+  if (srnode.current_parent_since <= last && parent)
+    parent->get_snap_info(infomap, MAX(first, srnode.current_parent_since), last);
 }
 
 const string& SnapInfo::get_long_name()
@@ -273,22 +273,22 @@ const string& SnapInfo::get_long_name()
 
 const string& SnapRealm::get_snapname(snapid_t snapid, inodeno_t atino)
 {
-  if (snaprealm.snaps.count(snapid)) {
+  if (srnode.snaps.count(snapid)) {
     if (atino == inode->ino())
-      return snaprealm.snaps[snapid].name;
+      return srnode.snaps[snapid].name;
     else
-      return snaprealm.snaps[snapid].get_long_name();
+      return srnode.snaps[snapid].get_long_name();
   }
 
-  map<snapid_t,snaplink_t>::iterator p = snaprealm.past_parents.lower_bound(snapid);
-  if (p != snaprealm.past_parents.end() && p->second.first <= snapid) {
+  map<snapid_t,snaplink_t>::iterator p = srnode.past_parents.lower_bound(snapid);
+  if (p != srnode.past_parents.end() && p->second.first <= snapid) {
     CInode *oldparent = mdcache->get_inode(p->second.ino);
     assert(oldparent);  // call open_parents first!
     assert(oldparent->snaprealm);    
     return oldparent->snaprealm->get_snapname(snapid, atino);
   }
 
-  assert(snaprealm.current_parent_since <= snapid);
+  assert(srnode.current_parent_since <= snapid);
   assert(parent);
   return parent->get_snapname(snapid, atino);
 }
@@ -314,8 +314,8 @@ snapid_t SnapRealm::resolve_snapname(const string& n, inodeno_t atino, snapid_t
     dout(10) << " " << n << " parses to name '" << pname << "' dirino " << pino << dendl;
   }
 
-  for (map<snapid_t, SnapInfo>::iterator p = snaprealm.snaps.lower_bound(first); // first element >= first
-       p != snaprealm.snaps.end() && p->first <= last;
+  for (map<snapid_t, SnapInfo>::iterator p = srnode.snaps.lower_bound(first); // first element >= first
+       p != srnode.snaps.end() && p->first <= last;
        p++) {
     dout(15) << " ? " << p->second << dendl;
     //if (num && p->second.snapid == num)
@@ -327,8 +327,8 @@ snapid_t SnapRealm::resolve_snapname(const string& n, inodeno_t atino, snapid_t
   }
 
     // include snaps for parents during intervals that intersect [first,last]
-  for (map<snapid_t, snaplink_t>::iterator p = snaprealm.past_parents.lower_bound(first);
-       p != snaprealm.past_parents.end() && p->first >= first && p->second.first <= last;
+  for (map<snapid_t, snaplink_t>::iterator p = srnode.past_parents.lower_bound(first);
+       p != srnode.past_parents.end() && p->first >= first && p->second.first <= last;
        p++) {
     CInode *oldparent = mdcache->get_inode(p->second.ino);
     assert(oldparent);  // call open_parents first!
@@ -339,8 +339,8 @@ snapid_t SnapRealm::resolve_snapname(const string& n, inodeno_t atino, snapid_t
     if (r)
       return r;
   }
-  if (parent && snaprealm.current_parent_since <= last)
-    return parent->resolve_snapname(n, atino, MAX(first, snaprealm.current_parent_since), last);
+  if (parent && srnode.current_parent_since <= last)
+    return parent->resolve_snapname(n, atino, MAX(first, srnode.current_parent_since), last);
   return 0;
 }
 
@@ -434,12 +434,12 @@ const bufferlist& SnapRealm::get_snap_trace()
 
 void SnapRealm::build_snap_trace(bufferlist& snapbl)
 {
-  SnapRealmInfo info(inode->ino(), snaprealm.created, snaprealm.seq, snaprealm.current_parent_since);
+  SnapRealmInfo info(inode->ino(), srnode.created, srnode.seq, srnode.current_parent_since);
 
   if (parent) {
     info.h.parent = parent->inode->ino();
-    if (!snaprealm.past_parents.empty()) {
-      snapid_t last = snaprealm.past_parents.rbegin()->first;
+    if (!srnode.past_parents.empty()) {
+      snapid_t last = srnode.past_parents.rbegin()->first;
       set<snapid_t> past;
       snapid_t max_seq, max_last_created, max_last_destroyed;
       build_snap_set(past, max_seq, max_last_created, max_last_destroyed, 0, last);
@@ -452,9 +452,9 @@ void SnapRealm::build_snap_trace(bufferlist& snapbl)
   } else 
     info.h.parent = 0;
 
-  info.my_snaps.reserve(snaprealm.snaps.size());
-  for (map<snapid_t,SnapInfo>::reverse_iterator p = snaprealm.snaps.rbegin();
-       p != snaprealm.snaps.rend();
+  info.my_snaps.reserve(srnode.snaps.size());
+  for (map<snapid_t,SnapInfo>::reverse_iterator p = srnode.snaps.rbegin();
+       p != srnode.snaps.rend();
        p++)
     info.my_snaps.push_back(p->first);
   dout(10) << "build_snap_trace my_snaps " << info.my_snaps << dendl;
@@ -472,39 +472,39 @@ void SnapRealm::project_past_parent(SnapRealm *newparent, bufferlist& snapbl)
 {
   snapid_t newlast = newparent->get_last_created();
   snapid_t oldlast = parent->get_newest_seq();
-  snapid_t first = snaprealm.current_parent_since;
+  snapid_t first = srnode.current_parent_since;
 
-  if (oldlast >= snaprealm.current_parent_since) {
-    snaprealm.past_parents[oldlast].ino = parent->inode->ino();
-    snaprealm.past_parents[oldlast].first = first;
+  if (oldlast >= srnode.current_parent_since) {
+    srnode.past_parents[oldlast].ino = parent->inode->ino();
+    srnode.past_parents[oldlast].first = first;
     dout(10) << "project_past_parent new past_parent [" << first << "," << oldlast << "] = "
             << parent->inode->ino() << dendl;
   }
-  snaprealm.current_parent_since = MAX(oldlast, newlast) + 1;
-  dout(10) << "project_past_parent current_parent_since " << snaprealm.current_parent_since << dendl;
+  srnode.current_parent_since = MAX(oldlast, newlast) + 1;
+  dout(10) << "project_past_parent current_parent_since " << srnode.current_parent_since << dendl;
 
   ::encode(*this, snapbl);
 
   if (oldlast >= first)
-    snaprealm.past_parents.erase(oldlast);
-  snaprealm.current_parent_since = first;
+    srnode.past_parents.erase(oldlast);
+  srnode.current_parent_since = first;
 }
 
 void SnapRealm::add_past_parent(SnapRealm *oldparent)
 {
   snapid_t newlast = parent->get_last_created();
   snapid_t oldlast = oldparent->get_newest_seq();
-  snapid_t first = snaprealm.current_parent_since;
+  snapid_t first = srnode.current_parent_since;
   
-  if (oldlast >= snaprealm.current_parent_since) {
-    snaprealm.past_parents[oldlast].ino = oldparent->inode->ino();
-    snaprealm.past_parents[oldlast].first = first;
+  if (oldlast >= srnode.current_parent_since) {
+    srnode.past_parents[oldlast].ino = oldparent->inode->ino();
+    srnode.past_parents[oldlast].first = first;
     add_open_past_parent(oldparent);
     dout(10) << "add_past_parent [" << first << "," << oldlast << "] = "
             << oldparent->inode->ino() << dendl;
   }
-  snaprealm.current_parent_since = MAX(oldlast, newlast) + 1;
-  dout(10) << "add_past_parent current_parent_since " << snaprealm.current_parent_since << dendl;
+  srnode.current_parent_since = MAX(oldlast, newlast) + 1;
+  dout(10) << "add_past_parent current_parent_since " << srnode.current_parent_since << dendl;
 
   invalidate_cached_snaps();
 }
@@ -515,14 +515,14 @@ void SnapRealm::prune_past_parents()
   check_cache();
   assert(open);
 
-  map<snapid_t, snaplink_t>::iterator p = snaprealm.past_parents.begin();
-  while (p != snaprealm.past_parents.end()) {
+  map<snapid_t, snaplink_t>::iterator p = srnode.past_parents.begin();
+  while (p != srnode.past_parents.end()) {
     set<snapid_t>::iterator q = cached_snaps.lower_bound(p->second.first);
     if (q == cached_snaps.end() ||
        *q > p->first) {
       dout(10) << "prune_past_parents pruning [" << p->second.first << "," << p->first 
               << "] " << p->second.ino << dendl;
-      snaprealm.past_parents.erase(p++);
+      srnode.past_parents.erase(p++);
     } else {
       dout(10) << "prune_past_parents keeping [" << p->second.first << "," << p->first 
               << "] " << p->second.ino << dendl;

diff --git a/src/mds/snap.h b/src/mds/snap.h
index 40ee5b9f1b3fb6b68f2ba9fdba9349f9fa5cf68c..0dac3438ee69b8a2bea8e50fadf677fd713eaea2 100644 (file)
--- a/src/mds/snap.h
+++ b/src/mds/snap.h
@@ -138,26 +138,26 @@ WRITE_CLASS_ENCODER(sr_t);
 struct SnapRealm {
   // realm state
 
-  sr_t snaprealm;
+  sr_t srnode;
 
   void encode(bufferlist& bl) const {
     __u8 struct_v = 2;
     ::encode(struct_v, bl);
-    ::encode(snaprealm, bl);
+    ::encode(srnode, bl);
   }
   void decode(bufferlist::iterator& p) {
     __u8 struct_v;
     ::decode(struct_v, p);
     if (struct_v >= 2)
-      ::decode(snaprealm, p);
+      ::decode(srnode, p);
     else {
-      ::decode(snaprealm.seq, p);
-      ::decode(snaprealm.created, p);
-      ::decode(snaprealm.last_created, p);
-      ::decode(snaprealm.last_destroyed, p);
-      ::decode(snaprealm.current_parent_since, p);
-      ::decode(snaprealm.snaps, p);
-      ::decode(snaprealm.past_parents, p);
+      ::decode(srnode.seq, p);
+      ::decode(srnode.created, p);
+      ::decode(srnode.last_created, p);
+      ::decode(srnode.last_destroyed, p);
+      ::decode(srnode.current_parent_since, p);
+      ::decode(srnode.snaps, p);
+      ::decode(srnode.past_parents, p);
     }
   }
 
@@ -183,15 +183,15 @@ struct SnapRealm {
   map<client_t, xlist<Capability*> > client_caps;   // to identify clients who need snap notifications
 
   SnapRealm(MDCache *c, CInode *in) : 
-    snaprealm(),
+    srnode(),
     mdcache(c), inode(in),
     open(false), parent(0),
     inodes_with_caps(0) 
   { }
 
   bool exists(const string &name) {
-    for (map<snapid_t,SnapInfo>::iterator p = snaprealm.snaps.begin();
-        p != snaprealm.snaps.end();
+    for (map<snapid_t,SnapInfo>::iterator p = srnode.snaps.begin();
+        p != srnode.snaps.end();
         p++)
       if (p->second.name == name)
        return true;
@@ -212,7 +212,7 @@ struct SnapRealm {
   void project_past_parent(SnapRealm *newparent, bufferlist& snapbl);
   void add_past_parent(SnapRealm *oldparent);
   void prune_past_parents();
-  bool has_past_parents() { return !snaprealm.past_parents.empty(); }
+  bool has_past_parents() { return !srnode.past_parents.empty(); }
 
   void build_snap_set(set<snapid_t>& s, 
                      snapid_t& max_seq, snapid_t& max_last_created, snapid_t& max_last_destroyed,