mds: simplify frag_info_t typing

diff --git a/src/client/Client.cc b/src/client/Client.cc
index 3511c341665257d3768bf5c8b641125f7e58c7b3..e30d545d4d61eb3f922b83841a48b564431b0f60 100644 (file)
--- a/src/client/Client.cc
+++ b/src/client/Client.cc
@@ -382,7 +382,7 @@ void Client::update_inode(Inode *in, InodeStat *st, LeaseStat *lease, utime_t fr
 
     in->dirfragtree = st->dirfragtree;  // FIXME look at the mask!
     in->xattrs.swap(st->xattrs);
-    in->inode.nested = st->nested;
+    in->inode.dirstat = st->dirstat;
 
     in->inode.ctime = st->ctime;
     in->inode.max_size = st->max_size;  // right?
@@ -2250,7 +2250,8 @@ int Client::fill_stat(Inode *in, struct stat *st)
   st->st_atime = in->inode.atime;
   st->st_mtime = in->inode.mtime;
   if (in->inode.is_dir()) {
-    st->st_size = in->inode.nested.rbytes;
+    //st->st_size = in->inode.dirstat.size();
+    st->st_size = in->inode.dirstat.rbytes;
     st->st_blocks = 1;
   } else {
     st->st_size = in->inode.size;

diff --git a/src/include/types.h b/src/include/types.h
index aac8974ff6a1358a5b2504e9a81f6dedae2ec585..85f09a0e1869ed48794dd1370fd892a6795aa51c 100644 (file)
--- a/src/include/types.h
+++ b/src/include/types.h
@@ -199,26 +199,40 @@ struct FileLayout {
   __u8  fl_pg_pool;      /* implies crush ruleset AND object namespace */
 };
 
-struct nested_info_t {
+
+struct frag_info_t {
+  version_t version;
+
+  utime_t mtime;
+  __u64 nfiles;        // files
+  __u64 nsubdirs;      // subdirs
+  __u64 size() { return nfiles + nsubdirs; }
+
   utime_t rctime;      // \max_{children}(ctime, nested_ctime)
   __u64 rbytes;
   __u64 rfiles;
   __u64 rsubdirs;
-  
+
   void encode(bufferlist &bl) const {
+    ::encode(mtime, bl);
+    ::encode(nfiles, bl);
+    ::encode(nsubdirs, bl);
     ::encode(rbytes, bl);
     ::encode(rfiles, bl);
     ::encode(rsubdirs, bl);
     ::encode(rctime, bl);
   }
   void decode(bufferlist::iterator &bl) {
+    ::decode(mtime, bl);
+    ::decode(nfiles, bl);
+    ::decode(nsubdirs, bl);
     ::decode(rbytes, bl);
     ::decode(rfiles, bl);
     ::decode(rsubdirs, bl);
     ::decode(rctime, bl);
-  }
+ }
 };
-WRITE_CLASS_ENCODER(nested_info_t)
+WRITE_CLASS_ENCODER(frag_info_t)
 
 struct inode_t {
   // base (immutable)
@@ -246,13 +260,8 @@ struct inode_t {
   uint64_t   time_warp_seq;  // count of (potential) mtime/atime timewarps (i.e., utimes())
 
   // dirfrag, recursive accounting
-  uint64_t nfiles, nsubdirs;
-  nested_info_t accounted_nested;  // what dirfrag has seen
-  nested_info_t nested;            // inline summation for child dirfrags.
-  /*
-   * if accounted_nested does not match nested, the parent dirfrag needs to be 
-   * adjusted by the difference.
-   */
+  frag_info_t dirstat;             
+  frag_info_t accounted_dirstat;   // what dirfrag has seen
  
   // special stuff
   version_t version;           // auth only
@@ -262,94 +271,64 @@ struct inode_t {
   bool is_symlink() const { return (mode & S_IFMT) == S_IFLNK; }
   bool is_dir()     const { return (mode & S_IFMT) == S_IFDIR; }
   bool is_file()    const { return (mode & S_IFMT) == S_IFREG; }
-};
-
-static inline void encode(const inode_t &i, bufferlist &bl) {
-  ::encode(i.ino, bl);
-  ::encode(i.layout, bl);
-  ::encode(i.rdev, bl);
-  ::encode(i.ctime, bl);
-  ::encode(i.mode, bl);
-  ::encode(i.uid, bl);
-  ::encode(i.gid, bl);
-  ::encode(i.nlink, bl);
-  ::encode(i.anchored, bl);
-  ::encode(i.size, bl);
-  ::encode(i.max_size, bl);
-  ::encode(i.mtime, bl);
-  ::encode(i.atime, bl);
-  ::encode(i.nfiles, bl);
-  ::encode(i.nsubdirs, bl);
-  ::encode(i.nested, bl);
-  ::encode(i.accounted_nested, bl);
-  ::encode(i.version, bl);
-  ::encode(i.file_data_version, bl);
-}
-static inline void decode(inode_t &i, bufferlist::iterator &p) {
-  ::decode(i.ino, p);
-  ::decode(i.layout, p);
-  ::decode(i.rdev, p);
-  ::decode(i.ctime, p);
-  ::decode(i.mode, p);
-  ::decode(i.uid, p);
-  ::decode(i.gid, p);
-  ::decode(i.nlink, p);
-  ::decode(i.anchored, p);
-  ::decode(i.size, p);
-  ::decode(i.max_size, p);
-  ::decode(i.mtime, p);
-  ::decode(i.atime, p);
-  ::decode(i.nfiles, p);
-  ::decode(i.nsubdirs, p);
-  ::decode(i.nested, p);
-  ::decode(i.accounted_nested, p);
-  ::decode(i.version, p);
-  ::decode(i.file_data_version, p);
-}
 
-/*
- * like an inode, but for a dir frag 
- */
-struct frag_info_t {
-  utime_t mtime;
-  __u64 nfiles;          // files
-  __u64 nsubdirs;        // subdirs
-
-  __u64 size() { return nfiles + nsubdirs; }
-  
   void encode(bufferlist &bl) const {
+    ::encode(ino, bl);
+    ::encode(layout, bl);
+    ::encode(rdev, bl);
+    ::encode(ctime, bl);
+    ::encode(mode, bl);
+    ::encode(uid, bl);
+    ::encode(gid, bl);
+    ::encode(nlink, bl);
+    ::encode(anchored, bl);
+    ::encode(size, bl);
+    ::encode(max_size, bl);
     ::encode(mtime, bl);
-    //::encode(size, bl);
-    ::encode(nfiles, bl);
-    ::encode(nsubdirs, bl);
+    ::encode(atime, bl);
+    ::encode(dirstat, bl);
+    ::encode(accounted_dirstat, bl);
+    ::encode(version, bl);
+    ::encode(file_data_version, bl);
+  }
+  void decode(bufferlist::iterator &p) {
+    ::decode(ino, p);
+    ::decode(layout, p);
+    ::decode(rdev, p);
+    ::decode(ctime, p);
+    ::decode(mode, p);
+    ::decode(uid, p);
+    ::decode(gid, p);
+    ::decode(nlink, p);
+    ::decode(anchored, p);
+    ::decode(size, p);
+    ::decode(max_size, p);
+    ::decode(mtime, p);
+    ::decode(atime, p);
+    ::decode(dirstat, p);
+    ::decode(accounted_dirstat, p);
+    ::decode(version, p);
+    ::decode(file_data_version, p);
   }
-  void decode(bufferlist::iterator &bl) {
-    ::decode(mtime, bl);
-    //::decode(size, bl);
-    ::decode(nfiles, bl);
-    ::decode(nsubdirs, bl);
- }
 };
-WRITE_CLASS_ENCODER(frag_info_t)
+WRITE_CLASS_ENCODER(inode_t)
 
+/*
+ * like an inode, but for a dir frag 
+ */
 struct fnode_t {
   version_t version;
-  frag_info_t fraginfo, accounted_fraginfo; // this dir
-  nested_info_t nested, accounted_nested;   // this dir + sum over children.
+  frag_info_t fragstat, accounted_fragstat;
 
   void encode(bufferlist &bl) const {
     ::encode(version, bl);
-    ::encode(fraginfo, bl);
-    ::encode(accounted_fraginfo, bl);
-    ::encode(nested, bl);
-    ::encode(accounted_nested, bl);
+    ::encode(fragstat, bl);
+    ::encode(accounted_fragstat, bl);
   }
   void decode(bufferlist::iterator &bl) {
     ::decode(version, bl);
-    ::decode(fraginfo, bl);
-    ::decode(accounted_fraginfo, bl);
-    ::decode(nested, bl);
-    ::decode(accounted_nested, bl);
+    ::decode(fragstat, bl);
+    ::decode(accounted_fragstat, bl);
   }
 };
 WRITE_CLASS_ENCODER(fnode_t)

diff --git a/src/mds/CDir.cc b/src/mds/CDir.cc
index 6c987fcf2d6390ed05b06a50a4b5a8f8ea61f70e..3274762726bb8f953138b1ceb52fe8dd6d675688 100644 (file)
--- a/src/mds/CDir.cc
+++ b/src/mds/CDir.cc
@@ -86,12 +86,12 @@ ostream& operator<<(ostream& out, CDir& dir)
   if (dir.state_test(CDir::STATE_EXPORTBOUND)) out << "|exportbound";
   if (dir.state_test(CDir::STATE_IMPORTBOUND)) out << "|importbound";
 
-  out << " s=" << dir.fnode.fraginfo.size() 
-      << "=" << dir.fnode.fraginfo.nfiles
-      << "+" << dir.fnode.fraginfo.nsubdirs;
-  out << " rb=" << dir.fnode.nested.rbytes << "/" << dir.fnode.accounted_nested.rbytes;
-  out << " rf=" << dir.fnode.nested.rfiles << "/" << dir.fnode.accounted_nested.rfiles;
-  out << " rd=" << dir.fnode.nested.rsubdirs << "/" << dir.fnode.accounted_nested.rsubdirs;
+  out << " s=" << dir.fnode.fragstat.size() 
+      << "=" << dir.fnode.fragstat.nfiles
+      << "+" << dir.fnode.fragstat.nsubdirs;
+  out << " rb=" << dir.fnode.fragstat.rbytes << "/" << dir.fnode.accounted_fragstat.rbytes;
+  out << " rf=" << dir.fnode.fragstat.rfiles << "/" << dir.fnode.accounted_fragstat.rfiles;
+  out << " rd=" << dir.fnode.fragstat.rsubdirs << "/" << dir.fnode.accounted_fragstat.rsubdirs;
 
   out << " sz=" << dir.get_nitems() << "+" << dir.get_nnull();
   if (dir.get_num_dirty())
@@ -493,19 +493,21 @@ void CDir::steal_dentry(CDentry *dn)
     nnull++;
   else {
     nitems++;
+    assert(0); // fixme fix accounting here
+    /* FIXME
     if (dn->is_primary()) {
-      fnode.nested.rbytes += dn->get_inode()->inode.accounted_nested.rbytes;
-      fnode.nested.rfiles += dn->get_inode()->inode.accounted_nested.rfiles;
+      fnode.fragstat.rbytes += dn->get_inode()->inode.accounted_fragstat.rbytes;
+      fnode.fragstat.rfiles += dn->get_inode()->inode.accounted_fragstat.rfiles;
       if (dn->get_inode()->is_dir())
-       fnode.fraginfo.nsubdirs++;
+       fnode.fragstat.nsubdirs++;
       else
-       fnode.fraginfo.nfiles++;
+       fnode.fragstat.nfiles++;
     } else if (dn->is_remote()) {
       if (dn->get_remote_d_type() == (S_IFDIR >> 12))
-       fnode.fraginfo.nsubdirs++;
+       fnode.fragstat.nsubdirs++;
       else
-       fnode.fraginfo.nfiles++;
-    }
+       fnode.fragstat.nfiles++;
+       }*/
   }
 
   nested_auth_pins += dn->auth_pins + dn->nested_auth_pins;

diff --git a/src/mds/CInode.cc b/src/mds/CInode.cc
index c8465c3358acc0ebfe9919d980931982a036dd45..fbde793e94a8c0008ff11a366ab245b6167e986f 100644 (file)
--- a/src/mds/CInode.cc
+++ b/src/mds/CInode.cc
@@ -71,9 +71,9 @@ ostream& operator<<(ostream& out, CInode& in)
   if (in.is_frozen_inode()) out << " FROZEN";
 
   out << " s=" << in.inode.size;
-  out << " rb=" << in.inode.nested.rbytes << "/" << in.inode.accounted_nested.rbytes;
-  out << " rf=" << in.inode.nested.rfiles << "/" << in.inode.accounted_nested.rfiles;
-  out << " rd=" << in.inode.nested.rsubdirs << "/" << in.inode.accounted_nested.rsubdirs;
+  out << " rb=" << in.inode.dirstat.rbytes << "/" << in.inode.accounted_dirstat.rbytes;
+  out << " rf=" << in.inode.dirstat.rfiles << "/" << in.inode.accounted_dirstat.rfiles;
+  out << " rd=" << in.inode.dirstat.rsubdirs << "/" << in.inode.accounted_dirstat.rsubdirs;
 
   // locks
   out << " " << in.authlock;
@@ -527,15 +527,17 @@ void CInode::encode_lock_state(int type, bufferlist& bl)
 
   case CEPH_LOCK_IDIR:
     {
-      ::encode(inode.size, bl);
       ::encode(inode.mtime, bl);
+      /*
+      ::encode(inode.size, bl);
       map<frag_t,int> frag_sizes;
       for (map<frag_t,CDir*>::iterator p = dirfrags.begin();
           p != dirfrags.end();
           ++p) 
        if (p->second->is_auth())
          frag_sizes[p->first] = dirfrag_size[p->first];
-      ::encode(frag_sizes, bl);
+         ::encode(frag_sizes, bl);
+      */
     }
     break;
 
@@ -545,6 +547,7 @@ void CInode::encode_lock_state(int type, bufferlist& bl)
   
   case CEPH_LOCK_INESTED:
     {
+      /*
       map<frag_t,nested_info_t> dfn;
       for (map<frag_t,CDir*>::iterator p = dirfrags.begin();
           p != dirfrags.end();
@@ -552,6 +555,7 @@ void CInode::encode_lock_state(int type, bufferlist& bl)
        if (p->second->is_auth())
          dfn[p->first] = dirfrag_nested[p->first];
       ::encode(dfn, bl);
+      */
     }
     break;
 
@@ -606,10 +610,11 @@ void CInode::decode_lock_state(int type, bufferlist& bl)
 
   case CEPH_LOCK_IDIR:
     {
+      ::decode(tm, p);
+      /*
       uint64_t sz;
       map<frag_t,int> dfsz;
       ::decode(sz, p);
-      ::decode(tm, p);
       ::decode(dfsz, p);
       
       if (is_auth()) {
@@ -629,6 +634,7 @@ void CInode::decode_lock_state(int type, bufferlist& bl)
        inode.size = sz;
        dirfrag_size.swap(dfsz);
       }
+      */
     }
     break;
 
@@ -638,12 +644,14 @@ void CInode::decode_lock_state(int type, bufferlist& bl)
 
   case CEPH_LOCK_INESTED:
     {
+      /*
       map<frag_t,nested_info_t> dfn;
       ::decode(dfn, p);
       for (map<frag_t,nested_info_t>::iterator p = dfn.begin(); p != dfn.end(); ++p) {
        dirfragtree.force_to_leaf(p->first);
        dirfrag_nested[p->first] = p->second;
       }
+      */
     }
     break;
 
@@ -676,10 +684,12 @@ void CInode::finish_scatter_gather_update(int type)
   switch (type) {
   case CEPH_LOCK_IDIR:
     {
+      /*
       inode_t *pi = get_projected_inode();
       pi->size = 0;
       for (map<frag_t,int>::iterator p = dirfrag_size.begin(); p != dirfrag_size.end(); ++p)
        pi->size += p->second;
+      */
     }
     break;
 

diff --git a/src/mds/CInode.h b/src/mds/CInode.h
index ae93cea69814ddc182964244addb9ff5265f7991..d83dfd53dd92cdb9ba537a1d07b4c3cd816f6b6e 100644 (file)
--- a/src/mds/CInode.h
+++ b/src/mds/CInode.h
@@ -133,8 +133,6 @@ class CInode : public MDSCacheObject {
   string           symlink;      // symlink dest, if symlink
   map<string, bufferptr> xattrs;
   fragtree_t       dirfragtree;  // dir frag tree, if any.  always consistent with our dirfrag map.
-  map<frag_t,int>  dirfrag_size; // size of each dirfrag
-  map<frag_t,nested_info_t> dirfrag_nested;
 
   off_t last_journaled;       // log offset for the last time i was journaled
   off_t last_open_journaled;  // log offset for the last journaled EOpen

diff --git a/src/mds/Locker.cc b/src/mds/Locker.cc
index 7f8faa9d924b3cf2b9c1445b44cf32efc926ec5e..fe3cd07ba5868869b3a87d7e1c99418326beabd9 100644 (file)
--- a/src/mds/Locker.cc
+++ b/src/mds/Locker.cc
@@ -1032,7 +1032,7 @@ void Locker::handle_client_file_caps(MClientFileCaps *m)
       dout(7) << "  size " << pi->size << " -> " << size
              << " for " << *in << dendl;
       pi->size = size;
-      pi->nested.rbytes = size;
+      pi->dirstat.rbytes = size;
     }
     if (dirty_atime) {
       dout(7) << "  atime " << pi->atime << " -> " << atime
@@ -1262,43 +1262,43 @@ void Locker::predirty_nested(Mutation *mut, EMetaBlob *blob,
 
     if (do_parent) {
       dout(10) << "predirty_nested updating mtime/size on " << *parent << dendl;
-      pf->fraginfo.mtime = mut->now;
+      pf->fragstat.mtime = mut->now;
       if (linkunlink) {
        if (in->is_dir())
-         pf->fraginfo.nsubdirs += linkunlink;
+         pf->fragstat.nsubdirs += linkunlink;
        else
-         pf->fraginfo.nfiles += linkunlink;
+         pf->fragstat.nfiles += linkunlink;
       }
     }
     if (primary_dn) {
       if (linkunlink == 0) {
-       drbytes = curi->nested.rbytes - curi->accounted_nested.rbytes;
-       drfiles = curi->nested.rfiles - curi->accounted_nested.rfiles;
-       drsubdirs = curi->nested.rsubdirs - curi->accounted_nested.rsubdirs;
+       drbytes = curi->dirstat.rbytes - curi->accounted_dirstat.rbytes;
+       drfiles = curi->dirstat.rfiles - curi->accounted_dirstat.rfiles;
+       drsubdirs = curi->dirstat.rsubdirs - curi->accounted_dirstat.rsubdirs;
       } else if (linkunlink < 0) {
-       drbytes = 0 - curi->accounted_nested.rbytes;
-       drfiles = 0 - curi->accounted_nested.rfiles;
-       drsubdirs = 0 - curi->accounted_nested.rsubdirs;
+       drbytes = 0 - curi->accounted_dirstat.rbytes;
+       drfiles = 0 - curi->accounted_dirstat.rfiles;
+       drsubdirs = 0 - curi->accounted_dirstat.rsubdirs;
       } else {
-       drbytes = curi->nested.rbytes;
-       drfiles = curi->nested.rfiles;
-       drsubdirs = curi->nested.rsubdirs;
+       drbytes = curi->dirstat.rbytes;
+       drfiles = curi->dirstat.rfiles;
+       drsubdirs = curi->dirstat.rsubdirs;
       }
-      rctime = MAX(curi->ctime, curi->nested.rctime);
+      rctime = MAX(curi->ctime, curi->dirstat.rctime);
 
       dout(10) << "predirty_nested delta "
               << drbytes << " bytes / " << drfiles << " files / " << drsubdirs << " subdirs for " 
               << *parent << dendl;
-      pf->nested.rbytes += drbytes;
-      pf->nested.rfiles += drfiles;
-      pf->nested.rsubdirs += drsubdirs;
-      pf->nested.rctime = rctime;
+      pf->fragstat.rbytes += drbytes;
+      pf->fragstat.rfiles += drfiles;
+      pf->fragstat.rsubdirs += drsubdirs;
+      pf->fragstat.rctime = rctime;
     
-      curi->accounted_nested = curi->nested;
+      curi->accounted_dirstat = curi->dirstat;
     } else {
       dout(10) << "predirty_nested no delta (remote dentry) in " << *parent << dendl;
       assert(!in->is_dir());
-      pf->nested.rfiles += linkunlink;
+      pf->fragstat.rfiles += linkunlink;
     }
 
 
@@ -1332,24 +1332,23 @@ void Locker::predirty_nested(Mutation *mut, EMetaBlob *blob,
 
     if (do_parent) {
       dout(10) << "predirty_nested updating size/mtime on " << *pin << dendl;
-      if (pf->fraginfo.mtime > pi->mtime)
-       pi->mtime = pf->fraginfo.mtime;
-      pi->nfiles += pf->fraginfo.nfiles - pf->accounted_fraginfo.nfiles;
-      pi->nsubdirs += pf->fraginfo.nsubdirs - pf->accounted_fraginfo.nsubdirs;
-      pi->size += pf->fraginfo.size() - pf->accounted_fraginfo.size();
-      pf->accounted_fraginfo = pf->fraginfo;
-    }
-    drbytes = pf->nested.rbytes - pf->accounted_nested.rbytes;
-    drfiles = pf->nested.rfiles - pf->accounted_nested.rfiles;
-    drsubdirs = pf->nested.rsubdirs - pf->accounted_nested.rsubdirs;
+      if (pf->fragstat.mtime > pi->mtime)
+       pi->mtime = pf->fragstat.mtime;
+      pi->dirstat.nfiles += pf->fragstat.nfiles - pf->accounted_fragstat.nfiles;
+      pi->dirstat.nsubdirs += pf->fragstat.nsubdirs - pf->accounted_fragstat.nsubdirs;
+      pf->accounted_fragstat = pf->fragstat;
+    }
+    drbytes = pf->fragstat.rbytes - pf->accounted_fragstat.rbytes;
+    drfiles = pf->fragstat.rfiles - pf->accounted_fragstat.rfiles;
+    drsubdirs = pf->fragstat.rsubdirs - pf->accounted_fragstat.rsubdirs;
     dout(10) << "predirty_nested delta " 
             << drbytes << " bytes / " << drfiles << " files / " << drsubdirs << " subdirs for " 
             << *pin << dendl;
-    pi->nested.rbytes += drbytes;
-    pi->nested.rfiles += drfiles;
-    pi->nested.rsubdirs += drsubdirs;
-    pi->nested.rctime = MAX(pf->fraginfo.mtime, pf->nested.rctime);
-    pf->accounted_nested = pf->nested;
+    pi->dirstat.rbytes += drbytes;
+    pi->dirstat.rfiles += drfiles;
+    pi->dirstat.rsubdirs += drsubdirs;
+    pi->dirstat.rctime = MAX(pf->fragstat.mtime, pf->fragstat.rctime);
+    pf->accounted_fragstat = pf->fragstat;
 
     // next parent!
     cur = pin;

diff --git a/src/mds/Server.cc b/src/mds/Server.cc
index 9648bfe57b5b0acec9f7c8b0c11e8c2f93939bd6..d1306c939323c1aed3a12e9a7ba68256174b0617 100644 (file)
--- a/src/mds/Server.cc
+++ b/src/mds/Server.cc
@@ -1497,8 +1497,6 @@ version_t Server::predirty_dn_diri(MDRequest *mdr, CDentry *dn, EMetaBlob *blob,
     dirpv = diri->pre_dirty();
     dout(10) << "predirty_dn_diri ctime/mtime " << mdr->now << " pv " << dirpv << " on " << *diri << dendl;
     
-    diri->dirfrag_size[dn->dir->dirfrag().frag] += deltasize;
-
     // predirty+journal
     inode_t *pi = diri->project_inode();
     if (dirpv) pi->version = dirpv;
@@ -2043,7 +2041,7 @@ void Server::handle_client_mknod(MDRequest *mdr)
   if ((newi->inode.mode & S_IFMT) == 0)
     newi->inode.mode |= S_IFREG;
   newi->inode.version = dn->pre_dirty() - 1;
-  newi->inode.nested.rfiles = 1;
+  newi->inode.dirstat.rfiles = 1;
   
   dout(10) << "mknod mode " << newi->inode.mode << " rdev " << newi->inode.rdev << dendl;
 
@@ -2084,7 +2082,7 @@ void Server::handle_client_mkdir(MDRequest *mdr)
   newi->inode.mode |= S_IFDIR;
   newi->inode.layout = g_default_mds_dir_layout;
   newi->inode.version = dn->pre_dirty() - 1;
-  newi->inode.nested.rsubdirs = 1;
+  newi->inode.dirstat.rsubdirs = 1;
 
   // ...and that new dir is empty.
   CDir *newdir = newi->get_or_open_dirfrag(mds->mdcache, frag_t());
@@ -2143,7 +2141,7 @@ void Server::handle_client_symlink(MDRequest *mdr)
   newi->symlink = req->get_path2();
   newi->inode.size = newi->symlink.length();
   newi->inode.version = dn->pre_dirty() - 1;
-  newi->inode.nested.rfiles = 1;
+  newi->inode.dirstat.rfiles = 1;
 
   // prepare finisher
   mdr->ls = mdlog->get_current_segment();
@@ -4342,7 +4340,7 @@ void Server::handle_client_openc(MDRequest *mdr)
   in->inode.mode |= S_IFREG;
   in->inode.version = dn->pre_dirty() - 1;
   in->inode.max_size = in->get_layout_size_increment();
-  in->inode.nested.rfiles = 1;
+  in->inode.dirstat.rfiles = 1;
   
   // prepare finisher
   mdr->ls = mdlog->get_current_segment();

diff --git a/src/messages/MClientReply.h b/src/messages/MClientReply.h
index b51d4cf041acb575c40c1e29441b2f6fed49b5e2..91189f5ec0263ff6f57c82776195909708e640eb 100644 (file)
--- a/src/messages/MClientReply.h
+++ b/src/messages/MClientReply.h
@@ -106,11 +106,10 @@ struct InodeStat {
   ceph_file_layout layout;
   utime_t ctime, mtime, atime;
   unsigned mode, uid, gid, nlink, rdev;
-  loff_t size, max_size, nested_size;
+  loff_t size, max_size;
   version_t time_warp_seq;
 
-  uint64_t nfiles, nsubdirs;
-  nested_info_t nested;
+  frag_info_t dirstat;
   
   string  symlink;   // symlink content (if symlink)
   fragtree_t dirfragtree;
@@ -140,12 +139,12 @@ struct InodeStat {
     max_size = e.max_size;
     rdev = e.rdev;
 
-    nfiles = e.files;
-    nsubdirs = e.subdirs;
-    nested.rctime.decode_timeval(&e.rctime);
-    nested.rbytes = e.rbytes;
-    nested.rfiles = e.rfiles;
-    nested.rsubdirs = e.rsubdirs;
+    dirstat.nfiles = e.files;
+    dirstat.nsubdirs = e.subdirs;
+    dirstat.rctime.decode_timeval(&e.rctime);
+    dirstat.rbytes = e.rbytes;
+    dirstat.rfiles = e.rfiles;
+    dirstat.rsubdirs = e.rsubdirs;
 
     int n = e.fragtree.nsplits;
     while (n) {
@@ -182,12 +181,12 @@ struct InodeStat {
     e.size = in->inode.size;
     e.max_size = in->inode.max_size;
 
-    e.files = in->inode.nfiles;
-    e.subdirs = in->inode.nsubdirs;
-    in->inode.nested.rctime.encode_timeval(&e.rctime);
-    e.rbytes = in->inode.nested.rbytes;
-    e.rfiles = in->inode.nested.rfiles;
-    e.rsubdirs = in->inode.nested.rsubdirs;
+    e.files = in->inode.dirstat.nfiles;
+    e.subdirs = in->inode.dirstat.nsubdirs;
+    in->inode.dirstat.rctime.encode_timeval(&e.rctime);
+    e.rbytes = in->inode.dirstat.rbytes;
+    e.rfiles = in->inode.dirstat.rfiles;
+    e.rsubdirs = in->inode.dirstat.rsubdirs;
 
     e.rdev = in->inode.rdev;
     e.fragtree.nsplits = in->dirfragtree._splits.size();