mds: break CAP_RDCACHE into CAP_SHARED, CAP_CACHE

FILE_CAP_RDCACHE was being used to mean both read access to the
file attributes (size, mtime) and permission to retain cached
data.  That lead to an incorrect definition of the filelock in the
mds, and in turn bugs with multiple client access.  These are now
CAP_*_SHARED (all locks) and CAP_FILE_CACHE (filelock only).

The main observed symptom was a client creating files in a
directory and a second client not seeing them, due to RDCACHE not
being revoked and rdcache_gen thus not incrementing, allowing a
dcache readdir to proceed.

diff --git a/src/client/Client.cc b/src/client/Client.cc
index c6ddd0a9fd5a684019fdc28112ebefa775d1f28c..e7c946bf75a2371f14c20153a96e49c18bc383c5 100644 (file)
--- a/src/client/Client.cc
+++ b/src/client/Client.cc
@@ -333,7 +333,7 @@ void Client::update_inode_file_bits(Inode *in,
     if (time_warp_seq > in->inode.time_warp_seq)
       dout(0) << "WARNING: " << *in << " mds time_warp_seq "
              << time_warp_seq << " > " << in->inode.time_warp_seq << dendl;
-  } else if (issued & (CEPH_CAP_FILE_WR|CEPH_CAP_FILE_WRBUFFER)) {
+  } else if (issued & (CEPH_CAP_FILE_WR|CEPH_CAP_FILE_BUFFER)) {
     if (time_warp_seq > in->inode.time_warp_seq) {
       in->inode.ctime = ctime;
       in->inode.mtime = mtime;
@@ -497,7 +497,7 @@ void Client::insert_dentry_inode(Dir *dir, const string& dname, LeaseStat *dleas
       dn->lease_seq = dlease->seq;
     }
   }
-  dn->cap_rdcache_gen = dir->parent_inode->rdcache_gen;
+  dn->cap_shared_gen = dir->parent_inode->shared_gen;
 }
 
 
@@ -1339,7 +1339,7 @@ void Client::put_cap_ref(Inode *in, int cap)
       finish_cap_snap(in, &in->cap_snaps.rbegin()->second, in->caps_used());
       signal_cond_list(in->waitfor_caps);  // wake up blocked sync writers
     }
-    if (cap & CEPH_CAP_FILE_WRBUFFER) {
+    if (cap & CEPH_CAP_FILE_BUFFER) {
       for (map<snapid_t,CapSnap>::iterator p = in->cap_snaps.begin();
           p != in->cap_snaps.end();
           p++)
@@ -1426,11 +1426,10 @@ void Client::check_caps(Inode *in, bool is_delayed)
 
   int retain = wanted;
   if (!unmounting) {
-    retain |= CEPH_CAP_PIN | CEPH_CAP_EXPIREABLE;
-    
-    /* keep any EXCL bits too, while we are holding caps anyway */
-    if (wanted || in->inode.is_dir())
-      retain |= CEPH_CAP_ANY_EXCL;
+    if (wanted)
+      retain |= CEPH_CAP_ANY;
+    else
+      retain |= CEPH_CAP_ANY_SHARED;
   }
   
   dout(10) << "check_caps on " << *in
@@ -1536,7 +1535,7 @@ void Client::queue_cap_snap(Inode *in, snapid_t seq)
   capsnap->issued = in->caps_issued();
   capsnap->dirty = in->caps_dirty();  // a bit conservative?
   
-  capsnap->dirty_data = (used & CEPH_CAP_FILE_WRBUFFER);
+  capsnap->dirty_data = (used & CEPH_CAP_FILE_BUFFER);
 
   if (used & CEPH_CAP_FILE_WR) {
     dout(10) << "queue_cap_snap WR used on " << *in << dendl;
@@ -1554,7 +1553,7 @@ void Client::finish_cap_snap(Inode *in, CapSnap *capsnap, int used)
   capsnap->atime = in->inode.atime;
   capsnap->ctime = in->inode.ctime;
   capsnap->time_warp_seq = in->inode.time_warp_seq;
-  if (used & CEPH_CAP_FILE_WRBUFFER) {
+  if (used & CEPH_CAP_FILE_BUFFER) {
     dout(10) << "finish_cap_snap " << *in << " cap_snap " << capsnap << " used " << used
             << " WRBUFFER, delaying" << dendl;
   } else {
@@ -1632,12 +1631,12 @@ void Client::signal_cond_list(list<Cond*>& ls)
 
 void Client::_release(Inode *in, bool checkafter)
 {
-  if (in->cap_refs[CEPH_CAP_FILE_RDCACHE]) {
+  if (in->cap_refs[CEPH_CAP_FILE_CACHE]) {
     objectcacher->release_set(in->inode.ino);
     if (checkafter)
-      put_cap_ref(in, CEPH_CAP_FILE_RDCACHE);
+      put_cap_ref(in, CEPH_CAP_FILE_CACHE);
     else 
-      in->put_cap_ref(CEPH_CAP_FILE_RDCACHE);
+      in->put_cap_ref(CEPH_CAP_FILE_CACHE);
   }
 }
 
@@ -1666,13 +1665,13 @@ void Client::flush_set_callback(inodeno_t ino)
 void Client::_flushed(Inode *in)
 {
   dout(10) << "_flushed " << *in << dendl;
-  assert(in->cap_refs[CEPH_CAP_FILE_WRBUFFER] == 1);
+  assert(in->cap_refs[CEPH_CAP_FILE_BUFFER] == 1);
 
   // release clean pages too, if we dont hold RDCACHE reference
-  if (in->cap_refs[CEPH_CAP_FILE_RDCACHE] == 0)
+  if (in->cap_refs[CEPH_CAP_FILE_CACHE] == 0)
     objectcacher->release_set(in->inode.ino);
 
-  put_cap_ref(in, CEPH_CAP_FILE_WRBUFFER);
+  put_cap_ref(in, CEPH_CAP_FILE_BUFFER);
 }
 
 
@@ -1709,9 +1708,12 @@ void Client::add_update_cap(Inode *in, int mds, __u64 cap_id,
   if (flags & CEPH_CAP_FLAG_AUTH)
     in->auth_cap = cap;
 
-  if ((issued & CEPH_CAP_FILE_RDCACHE) &&
-      !(cap->issued & CEPH_CAP_FILE_RDCACHE))
-    in->rdcache_gen++;
+  if ((issued & CEPH_CAP_FILE_SHARED) &&
+      !(cap->issued & CEPH_CAP_FILE_SHARED))
+    in->shared_gen++;
+  if ((issued & CEPH_CAP_FILE_CACHE) &&
+      !(cap->issued & CEPH_CAP_FILE_CACHE))
+    in->cache_gen++;
 
   unsigned old_caps = cap->issued;
   cap->cap_id = cap_id;
@@ -2207,19 +2209,22 @@ void Client::handle_cap_grant(Inode *in, int mds, InodeCap *cap, MClientCaps *m)
     kick_writers = true;
   }
 
-  if ((issued & CEPH_CAP_FILE_RDCACHE) &&
-      !(cap->issued & CEPH_CAP_FILE_RDCACHE))
-    in->rdcache_gen++;
+  if ((issued & CEPH_CAP_FILE_CACHE) &&
+      !(cap->issued & CEPH_CAP_FILE_CACHE))
+    in->cache_gen++;
+  if ((issued & CEPH_CAP_FILE_SHARED) &&
+      !(cap->issued & CEPH_CAP_FILE_SHARED))
+    in->shared_gen++;
 
   // update caps
   if (old_caps & ~new_caps) { 
     dout(10) << "  revocation of " << ccap_string(~new_caps & old_caps) << dendl;
     cap->issued = new_caps;
 
-    if ((cap->issued & ~new_caps) & CEPH_CAP_FILE_RDCACHE)
+    if ((cap->issued & ~new_caps) & CEPH_CAP_FILE_CACHE)
       _release(in, false);
 
-    if ((used & ~new_caps) & CEPH_CAP_FILE_WRBUFFER)
+    if ((used & ~new_caps) & CEPH_CAP_FILE_BUFFER)
       _flush(in);
     else {
       check_caps(in, false);
@@ -2629,8 +2634,8 @@ int Client::_lookup(Inode *dir, const string& dname, Inode **target)
     // is lease valid?
     if ((dn->lease_mds >= 0 && 
         dn->lease_ttl > g_clock.now()) ||
-       ((dir->caps_issued() & CEPH_CAP_FILE_RDCACHE) &&
-        dn->cap_rdcache_gen == dir->rdcache_gen)) {
+       ((dir->caps_issued() & CEPH_CAP_FILE_SHARED) &&
+        dn->cap_shared_gen == dir->shared_gen)) {
       *target = dn->inode;
       goto done;
     }
@@ -3485,7 +3490,7 @@ int Client::_release(Fh *f)
 
   if (in->snapid == CEPH_NOSNAP) {
     if (in->put_open_ref(f->mode)) {
-      if (in->caps_used() & (CEPH_CAP_FILE_WRBUFFER|CEPH_CAP_FILE_WR))
+      if (in->caps_used() & (CEPH_CAP_FILE_BUFFER|CEPH_CAP_FILE_WR))
        _flush(in);
       check_caps(in, false);
     }
@@ -3625,7 +3630,7 @@ int Client::_read(Fh *f, __s64 offset, __u64 size, bufferlist *bl)
     }
     
     // async i/o?
-    if ((issued & (CEPH_CAP_FILE_WRBUFFER|CEPH_CAP_FILE_RDCACHE))) {
+    if ((issued & (CEPH_CAP_FILE_BUFFER|CEPH_CAP_FILE_CACHE))) {
 
       // FIXME: this logic needs to move info FileCache!
 
@@ -3669,10 +3674,10 @@ int Client::_read(Fh *f, __s64 offset, __u64 size, bufferlist *bl)
   int r = 0;
   if (g_conf.client_oc) {
 
-    if (issued & CEPH_CAP_FILE_RDCACHE) {
+    if (issued & CEPH_CAP_FILE_CACHE) {
       // we will populate the cache here
-      if (in->cap_refs[CEPH_CAP_FILE_RDCACHE] == 0)
-       in->get_cap_ref(CEPH_CAP_FILE_RDCACHE);
+      if (in->cap_refs[CEPH_CAP_FILE_CACHE] == 0)
+       in->get_cap_ref(CEPH_CAP_FILE_CACHE);
 
       // readahead?
       if (f->nr_consec_read &&
@@ -3787,7 +3792,7 @@ void Client::sync_write_commit(Inode *in)
   assert(unsafe_sync_write > 0);
   unsafe_sync_write--;
 
-  put_cap_ref(in, CEPH_CAP_FILE_WRBUFFER);
+  put_cap_ref(in, CEPH_CAP_FILE_BUFFER);
 
   dout(15) << "sync_write_commit unsafe_sync_write = " << unsafe_sync_write << dendl;
   if (unsafe_sync_write == 0 && unmounting) {
@@ -3879,10 +3884,10 @@ int Client::_write(Fh *f, __s64 offset, __u64 size, const char *buf)
   dout(10) << " snaprealm " << *in->snaprealm << dendl;
 
   if (g_conf.client_oc) {
-    if (in->caps_issued() & CEPH_CAP_FILE_WRBUFFER) {
+    if (in->caps_issued() & CEPH_CAP_FILE_BUFFER) {
       // do buffered write
-      if (in->cap_refs[CEPH_CAP_FILE_WRBUFFER] == 0)
-       in->get_cap_ref(CEPH_CAP_FILE_WRBUFFER);
+      if (in->cap_refs[CEPH_CAP_FILE_BUFFER] == 0)
+       in->get_cap_ref(CEPH_CAP_FILE_BUFFER);
       
       // wait? (this may block!)
       objectcacher->wait_for_write(size, client_lock);
@@ -3904,7 +3909,7 @@ int Client::_write(Fh *f, __s64 offset, __u64 size, const char *buf)
     Context *onsafe = new C_Client_SyncCommit(this, in);
 
     unsafe_sync_write++;
-    in->get_cap_ref(CEPH_CAP_FILE_WRBUFFER);
+    in->get_cap_ref(CEPH_CAP_FILE_BUFFER);
     
     filer->write(in->inode.ino, &in->inode.layout, in->snaprealm->get_snap_context(),
                 offset, size, bl, g_clock.now(), 0, onfinish, onsafe);
@@ -4004,8 +4009,8 @@ int Client::_fsync(Fh *f, bool syncdataonly)
   if (g_conf.client_oc)
     _flush(in);
   
-  while (in->cap_refs[CEPH_CAP_FILE_WRBUFFER] > 0) {
-    dout(10) << "ino " << in->inode.ino << " has " << in->cap_refs[CEPH_CAP_FILE_WRBUFFER]
+  while (in->cap_refs[CEPH_CAP_FILE_BUFFER] > 0) {
+    dout(10) << "ino " << in->inode.ino << " has " << in->cap_refs[CEPH_CAP_FILE_BUFFER]
             << " uncommitted, waiting" << dendl;
     wait_on_list(in->waitfor_commit);
   }    

diff --git a/src/client/Client.h b/src/client/Client.h
index c0da73d514fde714bc4eb0c24dcb7f0edb89aafc..a84c8e265f49bd4b259e1c0506e0b489e9d829c2 100644 (file)
--- a/src/client/Client.h
+++ b/src/client/Client.h
@@ -103,7 +103,7 @@ class Dentry : public LRUObject {
   int lease_mds;
   utime_t lease_ttl;
   ceph_seq_t lease_seq;
-  int cap_rdcache_gen;
+  int cap_shared_gen;
   
   void get() { 
     assert(ref == 0); ref++; lru_pin(); 
@@ -114,7 +114,7 @@ class Dentry : public LRUObject {
     //cout << "dentry.put on " << this << " " << name << " now " << ref << std::endl;
   }
   
-  Dentry() : dir(0), inode(0), ref(0), lease_mds(-1), lease_seq(0), cap_rdcache_gen(0) { }
+  Dentry() : dir(0), inode(0), ref(0), lease_mds(-1), lease_seq(0), cap_shared_gen(0) { }
 };
 
 class Dir {
@@ -209,7 +209,7 @@ class Inode {
   map<int,InodeCap*> caps;            // mds -> InodeCap
   InodeCap *auth_cap;
   unsigned dirty_caps, flushing_caps;
-  int rdcache_gen;
+  int shared_gen, cache_gen;
   int snap_caps, snap_cap_refs;
   unsigned exporting_issued;
   int exporting_mds;
@@ -294,7 +294,7 @@ class Inode {
     //inode(_inode),
     snapid(vino.snapid),
     dir_auth(-1), dir_hashed(false), dir_replicated(false), 
-    dirty_caps(0), flushing_caps(0), rdcache_gen(0),
+    dirty_caps(0), flushing_caps(0), shared_gen(0), cache_gen(0),
     snap_caps(0), snap_cap_refs(0),
     exporting_issued(0), exporting_mds(-1), exporting_mseq(0),
     cap_item(this),
@@ -364,7 +364,7 @@ class Inode {
   }
   int caps_wanted() {
     int want = caps_file_wanted() | caps_used();
-    if (want & (CEPH_CAP_GWRBUFFER << CEPH_CAP_SFILE))
+    if (want & CEPH_CAP_FILE_BUFFER)
       want |= CEPH_CAP_FILE_EXCL;
     return want;
   }
@@ -374,9 +374,7 @@ class Inode {
 
   bool have_valid_size() {
     // RD+RDCACHE or WR+WRBUFFER => valid size
-    if ((caps_issued() & (CEPH_CAP_FILE_RD|CEPH_CAP_FILE_RDCACHE)) == (CEPH_CAP_FILE_RD|CEPH_CAP_FILE_RDCACHE))
-      return true;
-    if ((caps_issued() & (CEPH_CAP_FILE_WR|CEPH_CAP_FILE_WRBUFFER)) == (CEPH_CAP_FILE_WR|CEPH_CAP_FILE_WRBUFFER))
+    if (caps_issued() & (CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_EXCL))
       return true;
     return false;
   }

diff --git a/src/include/ceph_fs.h b/src/include/ceph_fs.h
index 336e167ba4da097e803852a49f5c215f00fb0866..b0cec8c4bed3a2808c11ae5146bb44332ba62e5e 100644 (file)
--- a/src/include/ceph_fs.h
+++ b/src/include/ceph_fs.h
@@ -44,7 +44,7 @@
 #define CEPH_MDS_PROTOCOL     9 /* cluster internal */
 #define CEPH_MON_PROTOCOL     4 /* cluster internal */
 #define CEPH_OSDC_PROTOCOL   10 /* public/client */
-#define CEPH_MDSC_PROTOCOL   19 /* public/client */
+#define CEPH_MDSC_PROTOCOL   20 /* public/client */
 #define CEPH_MONC_PROTOCOL   12 /* public/client */
 
 
@@ -933,13 +933,14 @@ static inline int ceph_flags_to_mode(int flags)
 #define CEPH_CAP_PIN         1  /* no specific capabilities beyond the pin */
 
 /* generic cap bits */
-#define CEPH_CAP_GRDCACHE    1  /* client can cache reads */
-#define CEPH_CAP_GEXCL       2  /* client has exclusive access, can update */
-#define CEPH_CAP_GRD         4  /* (filelock) client can read */ 
-#define CEPH_CAP_GWR         8  /* (filelock) client can write */
-#define CEPH_CAP_GWRBUFFER  16  /* (filelock) client can buffer writes */
-#define CEPH_CAP_GWREXTEND  32  /* (filelock) client can extend EOF */
-#define CEPH_CAP_GLAZYIO    64  /* (filelock) client can perform lazy io */
+#define CEPH_CAP_GSHARED     1  /* client can reads */
+#define CEPH_CAP_GEXCL       2  /* client can read and update */
+#define CEPH_CAP_GCACHE      4  /* (file) client can cache reads */
+#define CEPH_CAP_GRD         8  /* (file) client can read */ 
+#define CEPH_CAP_GWR        16  /* (file) client can write */
+#define CEPH_CAP_GBUFFER    32  /* (file) client can buffer writes */
+#define CEPH_CAP_GWREXTEND  64  /* (file) client can extend EOF */
+#define CEPH_CAP_GLAZYIO   128  /* (file) client can perform lazy io */
 
 /* per-lock shift */
 #define CEPH_CAP_SAUTH      2
@@ -948,18 +949,19 @@ static inline int ceph_flags_to_mode(int flags)
 #define CEPH_CAP_SFILE      8   /* goes at the end (uses >2 cap bits) */
 
 /* composed values */
-#define CEPH_CAP_AUTH_RDCACHE  (CEPH_CAP_GRDCACHE  << CEPH_CAP_SAUTH)
+#define CEPH_CAP_AUTH_SHARED  (CEPH_CAP_GSHARED  << CEPH_CAP_SAUTH)
 #define CEPH_CAP_AUTH_EXCL     (CEPH_CAP_GEXCL     << CEPH_CAP_SAUTH)
-#define CEPH_CAP_LINK_RDCACHE  (CEPH_CAP_GRDCACHE  << CEPH_CAP_SLINK)
+#define CEPH_CAP_LINK_SHARED  (CEPH_CAP_GSHARED  << CEPH_CAP_SLINK)
 #define CEPH_CAP_LINK_EXCL     (CEPH_CAP_GEXCL     << CEPH_CAP_SLINK)
-#define CEPH_CAP_XATTR_RDCACHE (CEPH_CAP_GRDCACHE  << CEPH_CAP_SXATTR)
+#define CEPH_CAP_XATTR_SHARED (CEPH_CAP_GSHARED  << CEPH_CAP_SXATTR)
 #define CEPH_CAP_XATTR_EXCL    (CEPH_CAP_GEXCL     << CEPH_CAP_SXATTR)
 #define CEPH_CAP_FILE(x)    (x << CEPH_CAP_SFILE)
-#define CEPH_CAP_FILE_RDCACHE  (CEPH_CAP_GRDCACHE  << CEPH_CAP_SFILE)
+#define CEPH_CAP_FILE_SHARED   (CEPH_CAP_GSHARED   << CEPH_CAP_SFILE)
 #define CEPH_CAP_FILE_EXCL     (CEPH_CAP_GEXCL     << CEPH_CAP_SFILE)
+#define CEPH_CAP_FILE_CACHE    (CEPH_CAP_GCACHE    << CEPH_CAP_SFILE)
 #define CEPH_CAP_FILE_RD       (CEPH_CAP_GRD       << CEPH_CAP_SFILE)
 #define CEPH_CAP_FILE_WR       (CEPH_CAP_GWR       << CEPH_CAP_SFILE)
-#define CEPH_CAP_FILE_WRBUFFER (CEPH_CAP_GWRBUFFER << CEPH_CAP_SFILE)
+#define CEPH_CAP_FILE_BUFFER   (CEPH_CAP_GBUFFER   << CEPH_CAP_SFILE)
 #define CEPH_CAP_FILE_WREXTEND (CEPH_CAP_GWREXTEND << CEPH_CAP_SFILE)
 #define CEPH_CAP_FILE_LAZYIO   (CEPH_CAP_GLAZYIO   << CEPH_CAP_SFILE)
 
@@ -967,64 +969,56 @@ static inline int ceph_flags_to_mode(int flags)
 #define CEPH_STAT_CAP_INODE    CEPH_CAP_PIN
 #define CEPH_STAT_CAP_TYPE     CEPH_CAP_PIN  /* mode >> 12 */
 #define CEPH_STAT_CAP_SYMLINK  CEPH_CAP_PIN
-#define CEPH_STAT_CAP_UID      CEPH_CAP_AUTH_RDCACHE
-#define CEPH_STAT_CAP_GID      CEPH_CAP_AUTH_RDCACHE
-#define CEPH_STAT_CAP_MODE     CEPH_CAP_AUTH_RDCACHE
-#define CEPH_STAT_CAP_NLINK    CEPH_CAP_LINK_RDCACHE
-#define CEPH_STAT_CAP_LAYOUT   CEPH_CAP_FILE_RDCACHE
-#define CEPH_STAT_CAP_MTIME    CEPH_CAP_FILE_RDCACHE
-#define CEPH_STAT_CAP_SIZE     CEPH_CAP_FILE_RDCACHE
-#define CEPH_STAT_CAP_ATIME    CEPH_CAP_FILE_RDCACHE  /* fixme */
-#define CEPH_STAT_CAP_XATTR    CEPH_CAP_XATTR_RDCACHE
+#define CEPH_STAT_CAP_UID      CEPH_CAP_AUTH_SHARED
+#define CEPH_STAT_CAP_GID      CEPH_CAP_AUTH_SHARED
+#define CEPH_STAT_CAP_MODE     CEPH_CAP_AUTH_SHARED
+#define CEPH_STAT_CAP_NLINK    CEPH_CAP_LINK_SHARED
+#define CEPH_STAT_CAP_LAYOUT   CEPH_CAP_FILE_SHARED
+#define CEPH_STAT_CAP_MTIME    CEPH_CAP_FILE_SHARED
+#define CEPH_STAT_CAP_SIZE     CEPH_CAP_FILE_SHARED
+#define CEPH_STAT_CAP_ATIME    CEPH_CAP_FILE_SHARED  /* fixme */
+#define CEPH_STAT_CAP_XATTR    CEPH_CAP_XATTR_SHARED
 #define CEPH_STAT_CAP_INODE_ALL (CEPH_CAP_PIN |                        \
-                                CEPH_CAP_AUTH_RDCACHE |        \
-                                CEPH_CAP_LINK_RDCACHE |        \
-                                CEPH_CAP_FILE_RDCACHE |        \
-                                CEPH_CAP_XATTR_RDCACHE)
+                                CEPH_CAP_AUTH_SHARED | \
+                                CEPH_CAP_LINK_SHARED | \
+                                CEPH_CAP_FILE_SHARED | \
+                                CEPH_CAP_XATTR_SHARED)
 
-#define CEPH_CAP_ANY_RDCACHE (CEPH_CAP_AUTH_RDCACHE |                  \
-                             CEPH_CAP_LINK_RDCACHE |                   \
-                             CEPH_CAP_XATTR_RDCACHE |                  \
-                             CEPH_CAP_FILE_RDCACHE)
-#define CEPH_CAP_ANY_RD   (CEPH_CAP_ANY_RDCACHE | CEPH_CAP_FILE_RD)
+#define CEPH_CAP_ANY_SHARED (CEPH_CAP_AUTH_SHARED |                    \
+                             CEPH_CAP_LINK_SHARED |                    \
+                             CEPH_CAP_XATTR_SHARED |                   \
+                             CEPH_CAP_FILE_SHARED)
+#define CEPH_CAP_ANY_RD   (CEPH_CAP_ANY_SHARED | CEPH_CAP_FILE_RD | CEPH_CAP_FILE_CACHE)
 
 #define CEPH_CAP_ANY_EXCL (CEPH_CAP_AUTH_EXCL |                \
                           CEPH_CAP_LINK_EXCL |         \
                           CEPH_CAP_XATTR_EXCL |        \
                           CEPH_CAP_FILE_EXCL)
-#define CEPH_CAP_ANY_FILE_WR (CEPH_CAP_FILE_WR|CEPH_CAP_FILE_WRBUFFER)
+#define CEPH_CAP_ANY_FILE_WR (CEPH_CAP_FILE_WR|CEPH_CAP_FILE_BUFFER)
 #define CEPH_CAP_ANY_WR   (CEPH_CAP_ANY_EXCL | CEPH_CAP_ANY_FILE_WR)
 #define CEPH_CAP_ANY      (CEPH_CAP_ANY_RD|CEPH_CAP_ANY_EXCL|CEPH_CAP_ANY_FILE_WR|CEPH_CAP_PIN)
 
 #define CEPH_CAP_LOCKS (CEPH_LOCK_IFILE|CEPH_LOCK_IAUTH|CEPH_LOCK_ILINK|CEPH_LOCK_IXATTR)
 
-/*
- * these cap bits time out, if no others are held and nothing is
- * registered as 'wanted' by the client.
- */
-#define CEPH_CAP_EXPIREABLE (CEPH_CAP_PIN|CEPH_CAP_ANY_RDCACHE)
-
 static inline int ceph_caps_for_mode(int mode)
 {
        switch (mode) {
        case CEPH_FILE_MODE_PIN:
                return CEPH_CAP_PIN;
        case CEPH_FILE_MODE_RD:
-               return CEPH_CAP_PIN |
-                       CEPH_CAP_FILE_RDCACHE | CEPH_CAP_FILE_RD;
+               return CEPH_CAP_PIN | CEPH_CAP_FILE_SHARED |
+                       CEPH_CAP_FILE_RD | CEPH_CAP_FILE_CACHE;
        case CEPH_FILE_MODE_RDWR:
-               return CEPH_CAP_PIN |
-                       ((CEPH_CAP_GRD | CEPH_CAP_GRDCACHE |
-                         CEPH_CAP_GWR | CEPH_CAP_GWRBUFFER |
-                         CEPH_CAP_GEXCL) << CEPH_CAP_SFILE) |
-                       ((CEPH_CAP_GRDCACHE | CEPH_CAP_GEXCL) << CEPH_CAP_SAUTH) |
-                       ((CEPH_CAP_GRDCACHE | CEPH_CAP_GEXCL) << CEPH_CAP_SXATTR);
+               return CEPH_CAP_PIN | CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_EXCL |
+                       CEPH_CAP_FILE_RD | CEPH_CAP_FILE_CACHE |
+                       CEPH_CAP_FILE_WR | CEPH_CAP_FILE_BUFFER |
+                       CEPH_CAP_AUTH_SHARED | CEPH_CAP_AUTH_EXCL |
+                       CEPH_CAP_XATTR_SHARED | CEPH_CAP_XATTR_EXCL;
        case CEPH_FILE_MODE_WR:
-               return CEPH_CAP_PIN |
-                       ((CEPH_CAP_GWR | CEPH_CAP_GWRBUFFER |
-                         CEPH_CAP_GEXCL) << CEPH_CAP_SFILE) |
-                       ((CEPH_CAP_GRDCACHE | CEPH_CAP_GEXCL) << CEPH_CAP_SAUTH) |
-                       ((CEPH_CAP_GRDCACHE | CEPH_CAP_GEXCL) << CEPH_CAP_SXATTR);
+               return CEPH_CAP_PIN | CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_EXCL |
+                       CEPH_CAP_FILE_WR | CEPH_CAP_FILE_BUFFER |
+                       CEPH_CAP_AUTH_SHARED | CEPH_CAP_AUTH_EXCL |
+                       CEPH_CAP_XATTR_SHARED | CEPH_CAP_XATTR_EXCL;
        }
        return 0;
 }

diff --git a/src/kernel/addr.c b/src/kernel/addr.c
index 0b42eec3bd0702a4d167099badb97902af4887b3..5ed881a47a3d702b34420304cfef3a87bda9d1b3 100644 (file)
--- a/src/kernel/addr.c
+++ b/src/kernel/addr.c
@@ -570,7 +570,7 @@ static int ceph_writepages_start(struct address_space *mapping,
         * cap is being revoked.
         */
        do_sync = wbc->sync_mode == WB_SYNC_ALL;
-       if (ceph_caps_revoking(ci, CEPH_CAP_FILE_WRBUFFER))
+       if (ceph_caps_revoking(ci, CEPH_CAP_FILE_BUFFER))
                do_sync = 1;
        dout(10, "writepages_start %p dosync=%d (pdflush=%d mode=%s)\n",
             inode, do_sync, current_is_pdflush(),

diff --git a/src/kernel/caps.c b/src/kernel/caps.c
index 1097bd616bc18e9d009b8b13ad97c5dbd9fa997f..72c95c7b0099ceb02317087d60ff37bbef47f9cd 100644 (file)
--- a/src/kernel/caps.c
+++ b/src/kernel/caps.c
@@ -29,15 +29,17 @@ static int caps_reserve_count;
 
 static char *gcap_string(char *s, int c)
 {
-       if (c & CEPH_CAP_GRDCACHE)
-               *s++ = 'c';
+       if (c & CEPH_CAP_GSHARED)
+               *s++ = 's';
        if (c & CEPH_CAP_GEXCL)
                *s++ = 'x';
+       if (c & CEPH_CAP_GCACHE)
+               *s++ = 'c';
        if (c & CEPH_CAP_GRD)
                *s++ = 'r';
        if (c & CEPH_CAP_GWR)
                *s++ = 'w';
-       if (c & CEPH_CAP_GWRBUFFER)
+       if (c & CEPH_CAP_GBUFFER)
                *s++ = 'b';
        if (c & CEPH_CAP_GLAZYIO)
                *s++ = 'l';
@@ -292,7 +294,7 @@ static int __ceph_get_cap_mds(struct ceph_inode_info *ci, u32 *mseq)
                if (mseq)
                        *mseq = cap->mseq;
                if (cap->issued & (CEPH_CAP_FILE_WR |
-                                  CEPH_CAP_FILE_WRBUFFER |
+                                  CEPH_CAP_FILE_BUFFER |
                                   CEPH_CAP_FILE_EXCL))
                        break;
        }
@@ -498,13 +500,13 @@ retry:
        }
 
        /*
-        * if we are newly issued FILE_RDCACHE, clear I_COMPLETE; we
+        * if we are newly issued FILE_SHARED, clear I_COMPLETE; we
         * don't know what happened to this directory while we didn't
         * have the cap.
         */
        if (S_ISDIR(inode->i_mode) &&
-           (issued & CEPH_CAP_FILE_RDCACHE) &&
-           (cap->issued & CEPH_CAP_FILE_RDCACHE) == 0) {
+           (issued & CEPH_CAP_FILE_SHARED) &&
+           (cap->issued & CEPH_CAP_FILE_SHARED) == 0) {
                dout(10, " marking %p NOT complete\n", inode);
                ci->i_ceph_flags &= ~CEPH_I_COMPLETE;
        }
@@ -921,7 +923,7 @@ static int __send_cap(struct ceph_mds_client *mdsc, struct ceph_cap *cap,
 
        spin_unlock(&inode->i_lock);
 
-       if (dropping & CEPH_CAP_FILE_RDCACHE) {
+       if (dropping & CEPH_CAP_FILE_CACHE) {
                /* invalidate what we can */
                dout(20, "invalidating pages on %p\n", inode);
                invalidate_mapping_pages(&inode->i_data, 0, -1);
@@ -1125,7 +1127,7 @@ retry_locked:
                if (want) {
                        retain |= CEPH_CAP_ANY;       /* be greedy */
                } else {
-                       retain |= CEPH_CAP_ANY_RDCACHE;
+                       retain |= CEPH_CAP_ANY_SHARED;
                        /*
                         * keep RD only if we didn't have the file open RW,
                         * because then the mds would revoke it anyway to
@@ -1333,8 +1335,8 @@ int __ceph_mark_dirty_caps(struct ceph_inode_info *ci, int mask)
                igrab(inode);
                dirty |= I_DIRTY_SYNC;
        }
-       if ((was & CEPH_CAP_FILE_WRBUFFER) &&
-           (mask & CEPH_CAP_FILE_WRBUFFER))
+       if ((was & CEPH_CAP_FILE_BUFFER) &&
+           (mask & CEPH_CAP_FILE_BUFFER))
                dirty |= I_DIRTY_DATASYNC;
        if (dirty)
                __mark_inode_dirty(inode, dirty);
@@ -1443,11 +1445,11 @@ static void __take_cap_refs(struct ceph_inode_info *ci, int got)
                ci->i_pin_ref++;
        if (got & CEPH_CAP_FILE_RD)
                ci->i_rd_ref++;
-       if (got & CEPH_CAP_FILE_RDCACHE)
+       if (got & CEPH_CAP_FILE_CACHE)
                ci->i_rdcache_ref++;
        if (got & CEPH_CAP_FILE_WR)
                ci->i_wr_ref++;
-       if (got & CEPH_CAP_FILE_WRBUFFER) {
+       if (got & CEPH_CAP_FILE_BUFFER) {
                if (ci->i_wrbuffer_ref == 0)
                        igrab(&ci->vfs_inode);
                ci->i_wrbuffer_ref++;
@@ -1566,10 +1568,10 @@ void ceph_put_cap_refs(struct ceph_inode_info *ci, int had)
        if (had & CEPH_CAP_FILE_RD)
                if (--ci->i_rd_ref == 0)
                        last++;
-       if (had & CEPH_CAP_FILE_RDCACHE)
+       if (had & CEPH_CAP_FILE_CACHE)
                if (--ci->i_rdcache_ref == 0)
                        last++;
-       if (had & CEPH_CAP_FILE_WRBUFFER) {
+       if (had & CEPH_CAP_FILE_BUFFER) {
                if (--ci->i_wrbuffer_ref == 0)
                        last++;
                dout(30, "put_cap_refs %p wrbuffer %d -> %d (?)\n",
@@ -1709,12 +1711,12 @@ start:
        cap->gen = session->s_cap_gen;
 
        /*
-        * Each time we receive RDCACHE anew, we increment i_rdcache_gen.
+        * Each time we receive CACHE anew, we increment i_rdcache_gen.
         * Also clear I_COMPLETE: we don't know what happened to this directory
         */
-       if ((newcaps & CEPH_CAP_FILE_RDCACHE) &&          /* got RDCACHE */
-           (cap->issued & CEPH_CAP_FILE_RDCACHE) == 0 && /* but not before */
-           (__ceph_caps_issued(ci, NULL) & CEPH_CAP_FILE_RDCACHE) == 0) {
+       if ((newcaps & CEPH_CAP_FILE_CACHE) &&          /* got RDCACHE */
+           (cap->issued & CEPH_CAP_FILE_CACHE) == 0 && /* but not before */
+           (__ceph_caps_issued(ci, NULL) & CEPH_CAP_FILE_CACHE) == 0) {
                ci->i_rdcache_gen++;
 
                if (S_ISDIR(inode->i_mode)) {
@@ -1724,13 +1726,13 @@ start:
        }
 
        /*
-        * If RDCACHE is being revoked, and we have no dirty buffers,
+        * If CACHE is being revoked, and we have no dirty buffers,
         * try to invalidate (once).  (If there are dirty buffers, we
         * will invalidate _after_ writeback.)
         */
-       if (((cap->issued & ~newcaps) & CEPH_CAP_FILE_RDCACHE) &&
+       if (((cap->issued & ~newcaps) & CEPH_CAP_FILE_CACHE) &&
            !ci->i_wrbuffer_ref && !tried_invalidate) {
-               dout(10, "RDCACHE invalidation\n");
+               dout(10, "CACHE invalidation\n");
                spin_unlock(&inode->i_lock);
                tried_invalidate = 1;
 
@@ -1829,11 +1831,11 @@ start:
        if (cap->issued & ~newcaps) {
                dout(10, "revocation: %s -> %s\n", ceph_cap_string(cap->issued),
                     ceph_cap_string(newcaps));
-               if ((used & ~newcaps) & CEPH_CAP_FILE_WRBUFFER) {
+               if ((used & ~newcaps) & CEPH_CAP_FILE_BUFFER) {
                        writeback = 1; /* will delay ack */
                } else if (dirty & ~newcaps) {
                        reply = 2;     /* initiate writeback in check_caps */
-               } else if (((used & ~newcaps) & CEPH_CAP_FILE_RDCACHE) == 0 ||
+               } else if (((used & ~newcaps) & CEPH_CAP_FILE_CACHE) == 0 ||
                           revoked_rdcache) {
                        /*
                         * we're not using revoked caps.. ack now.

diff --git a/src/kernel/dir.c b/src/kernel/dir.c
index 0c5e6eaf5723b6035188906b42f2244f4da42ad3..845f24e379582c26a2db7a480b327fd892180f51 100644 (file)
--- a/src/kernel/dir.c
+++ b/src/kernel/dir.c
@@ -190,7 +190,7 @@ static int ceph_readdir(struct file *filp, void *dirent, filldir_t filldir)
        if ((filp->f_pos == 2 || fi->dentry) &&
            !ceph_test_opt(client, NOASYNCREADDIR) &&
            (ci->i_ceph_flags & CEPH_I_COMPLETE) &&
-           (__ceph_caps_issued(ci, NULL) & CEPH_CAP_FILE_RDCACHE)) {
+           (__ceph_caps_issued(ci, NULL) & CEPH_CAP_FILE_SHARED)) {
                err = __dcache_readdir(filp, dirent, filldir);
                if (err != -EAGAIN) {
                        spin_unlock(&inode->i_lock);
@@ -464,7 +464,7 @@ static struct dentry *ceph_lookup(struct inode *dir, struct dentry *dentry,
                            client->mount_args.snapdir_name,
                            dentry->d_name.len) &&
                    (ci->i_ceph_flags & CEPH_I_COMPLETE) &&
-                   (__ceph_caps_issued(ci, NULL) & CEPH_CAP_FILE_RDCACHE)) {
+                   (__ceph_caps_issued(ci, NULL) & CEPH_CAP_FILE_SHARED)) {
                        ceph_dentry(dentry)->offset = ci->i_max_offset++;
                        spin_unlock(&dir->i_lock);
                        dout(10, " dir %p complete, -ENOENT\n", dir);
@@ -538,7 +538,7 @@ static int ceph_mknod(struct inode *dir, struct dentry *dentry,
        req->r_locked_dir = dir;
        req->r_args.mknod.mode = cpu_to_le32(mode);
        req->r_args.mknod.rdev = cpu_to_le32(rdev);
-       req->r_dentry_drop = CEPH_CAP_FILE_RDCACHE;
+       req->r_dentry_drop = CEPH_CAP_FILE_SHARED;
        req->r_dentry_unless = CEPH_CAP_FILE_EXCL; 
        err = ceph_mdsc_do_request(mdsc, dir, req);
        if (!err && !req->r_reply_info.head->is_dentry)
@@ -592,7 +592,7 @@ static int ceph_symlink(struct inode *dir, struct dentry *dentry,
        req->r_num_caps = 2;
        req->r_path2 = dest;
        req->r_locked_dir = dir;
-       req->r_dentry_drop = CEPH_CAP_FILE_RDCACHE;
+       req->r_dentry_drop = CEPH_CAP_FILE_SHARED;
        req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
        err = ceph_mdsc_do_request(mdsc, dir, req);
        if (!err && !req->r_reply_info.head->is_dentry)
@@ -632,7 +632,7 @@ static int ceph_mkdir(struct inode *dir, struct dentry *dentry, int mode)
        req->r_num_caps = 2;
        req->r_locked_dir = dir;
        req->r_args.mkdir.mode = cpu_to_le32(mode);
-       req->r_dentry_drop = CEPH_CAP_FILE_RDCACHE;
+       req->r_dentry_drop = CEPH_CAP_FILE_SHARED;
        req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
        err = ceph_mdsc_do_request(mdsc, dir, req);
        if (!err && !req->r_reply_info.head->is_dentry)
@@ -666,7 +666,7 @@ static int ceph_link(struct dentry *old_dentry, struct inode *dir,
        req->r_num_caps = 2;
        req->r_old_dentry = dget(old_dentry); /* or inode? hrm. */
        req->r_locked_dir = dir;
-       req->r_dentry_drop = CEPH_CAP_FILE_RDCACHE;
+       req->r_dentry_drop = CEPH_CAP_FILE_SHARED;
        req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
        err = ceph_mdsc_do_request(mdsc, dir, req);
        if (err) {
@@ -686,7 +686,7 @@ static int ceph_link(struct dentry *old_dentry, struct inode *dir,
 static int drop_caps_for_unlink(struct inode *inode)
 {
        struct ceph_inode_info *ci = ceph_inode(inode);
-       int drop = CEPH_CAP_LINK_RDCACHE | CEPH_CAP_LINK_EXCL;
+       int drop = CEPH_CAP_LINK_SHARED | CEPH_CAP_LINK_EXCL;
 
        spin_lock(&inode->i_lock);
        if (inode->i_nlink == 1) {
@@ -729,7 +729,7 @@ static int ceph_unlink(struct inode *dir, struct dentry *dentry)
        req->r_dentry = dget(dentry);
        req->r_num_caps = 2;
        req->r_locked_dir = dir;
-       req->r_dentry_drop = CEPH_CAP_FILE_RDCACHE;
+       req->r_dentry_drop = CEPH_CAP_FILE_SHARED;
        req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
        req->r_inode_drop = drop_caps_for_unlink(inode);
        err = ceph_mdsc_do_request(mdsc, dir, req);
@@ -762,12 +762,12 @@ static int ceph_rename(struct inode *old_dir, struct dentry *old_dentry,
        req->r_num_caps = 2;
        req->r_old_dentry = dget(old_dentry);
        req->r_locked_dir = new_dir;
-       req->r_old_dentry_drop = CEPH_CAP_FILE_RDCACHE;
+       req->r_old_dentry_drop = CEPH_CAP_FILE_SHARED;
        req->r_old_dentry_unless = CEPH_CAP_FILE_EXCL;
-       req->r_dentry_drop = CEPH_CAP_FILE_RDCACHE;
+       req->r_dentry_drop = CEPH_CAP_FILE_SHARED;
        req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
        /* release LINK_RDCACHE on source inode (mds will lock it) */
-       req->r_old_inode_drop = CEPH_CAP_LINK_RDCACHE;
+       req->r_old_inode_drop = CEPH_CAP_LINK_SHARED;
        if (new_dentry->d_inode)
                req->r_inode_drop = drop_caps_for_unlink(new_dentry->d_inode);
        err = ceph_mdsc_do_request(mdsc, old_dir, req);
@@ -844,7 +844,7 @@ static int dir_lease_is_valid(struct inode *dir, struct dentry *dentry)
 
        spin_lock(&dir->i_lock);
        if (ci->i_rdcache_gen == dentry->d_time)
-               valid = __ceph_caps_issued(ci, NULL) & CEPH_CAP_FILE_RDCACHE;
+               valid = __ceph_caps_issued(ci, NULL) & CEPH_CAP_FILE_SHARED;
        spin_unlock(&dir->i_lock);
        dout(20, "dir_lease_is_valid dir %p v%u dentry %p v%lu = %d\n",
             dir, (unsigned)ci->i_rdcache_gen, dentry, dentry->d_time, valid);

diff --git a/src/kernel/file.c b/src/kernel/file.c
index 9d2ea333cc1650139bdf70207bd188b1769dceac..84d3bfa5b0194e17c6fce2e87be8ebad2fe83692 100644 (file)
--- a/src/kernel/file.c
+++ b/src/kernel/file.c
@@ -216,7 +216,7 @@ struct dentry *ceph_lookup_open(struct inode *dir, struct dentry *dentry,
        req->r_dentry = dget(dentry);
        req->r_num_caps = 2;
        if (flags & O_CREAT) {
-               req->r_dentry_drop = CEPH_CAP_FILE_RDCACHE;
+               req->r_dentry_drop = CEPH_CAP_FILE_SHARED;
                req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
        }
        req->r_locked_dir = dir;           /* caller holds dir->i_mutex */
@@ -658,14 +658,14 @@ static ssize_t ceph_aio_read(struct kiocb *iocb, const struct iovec *iov,
        dout(10, "aio_read %llx.%llx %llu~%u trying to get caps on %p\n",
             ceph_vinop(inode), pos, (unsigned)len, inode);
        __ceph_do_pending_vmtruncate(inode);
-       ret = ceph_get_caps(ci, CEPH_CAP_FILE_RD, CEPH_CAP_FILE_RDCACHE,
+       ret = ceph_get_caps(ci, CEPH_CAP_FILE_RD, CEPH_CAP_FILE_CACHE,
                            &got, -1);
        if (ret < 0)
                goto out;
        dout(10, "aio_read %llx.%llx %llu~%u got cap refs on %s\n",
             ceph_vinop(inode), pos, (unsigned)len, ceph_cap_string(got));
 
-       if ((got & CEPH_CAP_FILE_RDCACHE) == 0 ||
+       if ((got & CEPH_CAP_FILE_CACHE) == 0 ||
            (iocb->ki_filp->f_flags & O_DIRECT) ||
            (inode->i_sb->s_flags & MS_SYNCHRONOUS))
                /* hmm, this isn't really async... */
@@ -737,7 +737,7 @@ retry_snap:
        check_max_size(inode, endoff);
        dout(10, "aio_write %p %llu~%u getting caps. i_size %llu\n",
             inode, pos, (unsigned)iov->iov_len, inode->i_size);
-       ret = ceph_get_caps(ci, CEPH_CAP_FILE_WR, CEPH_CAP_FILE_WRBUFFER,
+       ret = ceph_get_caps(ci, CEPH_CAP_FILE_WR, CEPH_CAP_FILE_BUFFER,
                            &got, endoff);
        if (ret < 0)
                goto out;
@@ -745,7 +745,7 @@ retry_snap:
        dout(10, "aio_write %p %llu~%u  got cap refs on %s\n",
             inode, pos, (unsigned)iov->iov_len, ceph_cap_string(got));
 
-       if ((got & CEPH_CAP_FILE_WRBUFFER) == 0 ||
+       if ((got & CEPH_CAP_FILE_BUFFER) == 0 ||
            (iocb->ki_filp->f_flags & O_DIRECT) ||
            (inode->i_sb->s_flags & MS_SYNCHRONOUS)) {
                ret = ceph_sync_write(file, iov->iov_base, iov->iov_len,

diff --git a/src/kernel/inode.c b/src/kernel/inode.c
index 69d20acced7b942bed4cba763c6b687893878c4e..1a626e2c376bfc2aad9214b6ab68c55e20590aef 100644 (file)
--- a/src/kernel/inode.c
+++ b/src/kernel/inode.c
@@ -369,8 +369,8 @@ int ceph_fill_file_size(struct inode *inode, int issued,
                             ci->i_truncate_seq, truncate_seq);
                        ci->i_truncate_seq = truncate_seq;
                        ci->i_truncate_pending++;
-                       if (issued & (CEPH_CAP_FILE_RDCACHE|CEPH_CAP_FILE_RD|
-                                     CEPH_CAP_FILE_WR|CEPH_CAP_FILE_WRBUFFER|
+                       if (issued & (CEPH_CAP_FILE_CACHE|CEPH_CAP_FILE_RD|
+                                     CEPH_CAP_FILE_WR|CEPH_CAP_FILE_BUFFER|
                                      CEPH_CAP_FILE_EXCL))
                                queue_trunc = 1;
                }
@@ -393,7 +393,7 @@ void ceph_fill_file_time(struct inode *inode, int issued,
 
        if (issued & (CEPH_CAP_FILE_EXCL|
                      CEPH_CAP_FILE_WR|
-                     CEPH_CAP_FILE_WRBUFFER)) {
+                     CEPH_CAP_FILE_BUFFER)) {
                if (timespec_compare(ctime, &inode->i_ctime) > 0) {
                        dout(20, "ctime %ld.%09ld -> %ld.%09ld inc w/ cap\n",
                             inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec,
@@ -651,7 +651,7 @@ no_change:
                /* set dir completion flag? */
                if (ci->i_files == 0 && ci->i_subdirs == 0 &&
                    ceph_snap(inode) == CEPH_NOSNAP &&
-                   (le32_to_cpu(info->cap.caps) & CEPH_CAP_FILE_RDCACHE)) {
+                   (le32_to_cpu(info->cap.caps) & CEPH_CAP_FILE_SHARED)) {
                        dout(10, " marking %p complete (empty)\n", inode);
                        ci->i_ceph_flags |= CEPH_I_COMPLETE;
                        ci->i_max_offset = 2;
@@ -893,7 +893,7 @@ int ceph_fill_trace(struct super_block *sb, struct ceph_mds_request *req,
                /* do we have a lease on the whole dir? */
                have_dir_cap =
                        (le32_to_cpu(rinfo->diri.in->cap.caps) &
-                        CEPH_CAP_FILE_RDCACHE);
+                        CEPH_CAP_FILE_SHARED);
 
                /* do we have a dn lease? */
                have_lease = have_dir_cap ||
@@ -1344,11 +1344,11 @@ int ceph_setattr(struct dentry *dentry, struct iattr *attr)
                if (issued & CEPH_CAP_AUTH_EXCL) {
                        inode->i_uid = attr->ia_uid;
                        dirtied |= CEPH_CAP_AUTH_EXCL;
-               } else if ((issued & CEPH_CAP_AUTH_RDCACHE) == 0 ||
+               } else if ((issued & CEPH_CAP_AUTH_SHARED) == 0 ||
                           attr->ia_uid != inode->i_uid) {
                        req->r_args.setattr.uid = cpu_to_le32(attr->ia_uid);
                        mask |= CEPH_SETATTR_UID;
-                       release |= CEPH_CAP_AUTH_RDCACHE;
+                       release |= CEPH_CAP_AUTH_SHARED;
                }
        }
        if (ia_valid & ATTR_GID) {
@@ -1357,11 +1357,11 @@ int ceph_setattr(struct dentry *dentry, struct iattr *attr)
                if (issued & CEPH_CAP_AUTH_EXCL) {
                        inode->i_gid = attr->ia_gid;
                        dirtied |= CEPH_CAP_AUTH_EXCL;
-               } else if ((issued & CEPH_CAP_AUTH_RDCACHE) == 0 ||
+               } else if ((issued & CEPH_CAP_AUTH_SHARED) == 0 ||
                           attr->ia_gid != inode->i_gid) {
                        req->r_args.setattr.gid = cpu_to_le32(attr->ia_gid);
                        mask |= CEPH_SETATTR_GID;
-                       release |= CEPH_CAP_AUTH_RDCACHE;
+                       release |= CEPH_CAP_AUTH_SHARED;
                }
        }
        if (ia_valid & ATTR_MODE) {
@@ -1370,11 +1370,11 @@ int ceph_setattr(struct dentry *dentry, struct iattr *attr)
                if (issued & CEPH_CAP_AUTH_EXCL) {
                        inode->i_mode = attr->ia_mode;
                        dirtied |= CEPH_CAP_AUTH_EXCL;
-               } else if ((issued & CEPH_CAP_AUTH_RDCACHE) == 0 ||
+               } else if ((issued & CEPH_CAP_AUTH_SHARED) == 0 ||
                           attr->ia_mode != inode->i_mode) {
                        req->r_args.setattr.mode = cpu_to_le32(attr->ia_mode);
                        mask |= CEPH_SETATTR_MODE;
-                       release |= CEPH_CAP_AUTH_RDCACHE;
+                       release |= CEPH_CAP_AUTH_SHARED;
                }
        }
 
@@ -1391,12 +1391,12 @@ int ceph_setattr(struct dentry *dentry, struct iattr *attr)
                                            &attr->ia_atime) < 0) {
                        inode->i_atime = attr->ia_atime;
                        dirtied |= CEPH_CAP_FILE_WR;
-               } else if ((issued & CEPH_CAP_FILE_RDCACHE) == 0 ||
+               } else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||
                           !timespec_equal(&inode->i_atime, &attr->ia_atime)) {
                        ceph_encode_timespec(&req->r_args.setattr.atime,
                                             &attr->ia_atime);
                        mask |= CEPH_SETATTR_ATIME;
-                       release |= CEPH_CAP_FILE_RDCACHE | CEPH_CAP_FILE_RD |
+                       release |= CEPH_CAP_FILE_CACHE | CEPH_CAP_FILE_RD |
                                CEPH_CAP_FILE_WR;
                }
        }
@@ -1413,12 +1413,12 @@ int ceph_setattr(struct dentry *dentry, struct iattr *attr)
                                            &attr->ia_mtime) < 0) {
                        inode->i_mtime = attr->ia_mtime;
                        dirtied |= CEPH_CAP_FILE_WR;
-               } else if ((issued & CEPH_CAP_FILE_RDCACHE) == 0 ||
+               } else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||
                           !timespec_equal(&inode->i_mtime, &attr->ia_mtime)) {
                        ceph_encode_timespec(&req->r_args.setattr.mtime,
                                             &attr->ia_mtime);
                        mask |= CEPH_SETATTR_MTIME;
-                       release |= CEPH_CAP_FILE_RDCACHE | CEPH_CAP_FILE_RD |
+                       release |= CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_RD |
                                CEPH_CAP_FILE_WR;
                }
        }
@@ -1438,13 +1438,13 @@ int ceph_setattr(struct dentry *dentry, struct iattr *attr)
                        inode->i_ctime = attr->ia_ctime;
                        ci->i_reported_size = attr->ia_size;
                        dirtied |= CEPH_CAP_FILE_EXCL;
-               } else if ((issued & CEPH_CAP_FILE_RDCACHE) == 0 ||
+               } else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||
                           attr->ia_size != inode->i_size) {
                        req->r_args.setattr.size = cpu_to_le64(attr->ia_size);
                        req->r_args.setattr.old_size =
                                cpu_to_le64(inode->i_size);
                        mask |= CEPH_SETATTR_SIZE;
-                       release |= CEPH_CAP_FILE_RDCACHE | CEPH_CAP_FILE_RD |
+                       release |= CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_RD |
                                CEPH_CAP_FILE_WR;
                }
        }
@@ -1523,7 +1523,7 @@ int ceph_do_getattr(struct inode *inode, int mask)
  */
 int ceph_permission(struct inode *inode, int mask)
 {
-       int err = ceph_do_getattr(inode, CEPH_CAP_AUTH_RDCACHE);
+       int err = ceph_do_getattr(inode, CEPH_CAP_AUTH_SHARED);
 
        if (!err)
                err = generic_permission(inode, mask, NULL);
@@ -2012,7 +2012,7 @@ ssize_t ceph_getxattr(struct dentry *dentry, const char *name, void *value,
                        ceph_cap_string(issued),
                        ci->i_xattrs.version, ci->i_xattrs.index_version);
 
-        if ((issued & CEPH_CAP_XATTR_RDCACHE) &&
+        if ((issued & CEPH_CAP_XATTR_SHARED) &&
            (ci->i_xattrs.index_version >= ci->i_xattrs.version)) {
                goto get_xattr;
        } else {
@@ -2069,7 +2069,7 @@ ssize_t ceph_listxattr(struct dentry *dentry, char *names, size_t size)
                        ceph_cap_string(issued),
                        ci->i_xattrs.version, ci->i_xattrs.index_version);
 
-        if ((issued & CEPH_CAP_XATTR_RDCACHE) &&
+        if ((issued & CEPH_CAP_XATTR_SHARED) &&
            (ci->i_xattrs.index_version > ci->i_xattrs.version)) {
                goto list_xattr;
        } else {
@@ -2157,7 +2157,7 @@ static int ceph_sync_setxattr(struct dentry *dentry, const char *name,
        if (IS_ERR(req))
                return PTR_ERR(req);
        req->r_inode = igrab(inode);
-       req->r_inode_drop = CEPH_CAP_XATTR_RDCACHE;
+       req->r_inode_drop = CEPH_CAP_XATTR_SHARED;
        req->r_num_caps = 1;
        req->r_args.setxattr.flags = cpu_to_le32(flags);
        req->r_path2 = name;
@@ -2289,7 +2289,7 @@ static int ceph_send_removexattr(struct dentry *dentry, const char *name)
        if (IS_ERR(req))
                return PTR_ERR(req);
        req->r_inode = igrab(inode);
-       req->r_inode_drop = CEPH_CAP_XATTR_RDCACHE;
+       req->r_inode_drop = CEPH_CAP_XATTR_SHARED;
        req->r_num_caps = 1;
        req->r_path2 = name;
 

diff --git a/src/kernel/ioctl.c b/src/kernel/ioctl.c
index 0dd70722d06e2924cea2508622e1508e2fe62450..69c65c138eacbf8c0a00e963548197ac383fbfc6 100644 (file)
--- a/src/kernel/ioctl.c
+++ b/src/kernel/ioctl.c
@@ -43,7 +43,7 @@ static long ceph_ioctl_set_layout(struct file *file, void __user *arg)
        if (IS_ERR(req))
                return PTR_ERR(req);
        req->r_inode = igrab(inode);
-       req->r_inode_drop = CEPH_CAP_FILE_RDCACHE | CEPH_CAP_FILE_EXCL;
+       req->r_inode_drop = CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_EXCL;
        req->r_args.setlayout.layout = layout;
 
        err = ceph_mdsc_do_request(mdsc, parent_inode, req);

diff --git a/src/kernel/super.h b/src/kernel/super.h
index c827764dd1e329d6cd6103e87f11bec8519034e2..9a20f6ee72da9eddb949853e65e6f3da616b826d 100644 (file)
--- a/src/kernel/super.h
+++ b/src/kernel/super.h
@@ -535,11 +535,11 @@ static inline int __ceph_caps_used(struct ceph_inode_info *ci)
        if (ci->i_rd_ref)
                used |= CEPH_CAP_FILE_RD;
        if (ci->i_rdcache_ref || ci->i_rdcache_gen)
-               used |= CEPH_CAP_FILE_RDCACHE;
+               used |= CEPH_CAP_FILE_CACHE;
        if (ci->i_wr_ref)
                used |= CEPH_CAP_FILE_WR;
        if (ci->i_wrbuffer_ref)
-               used |= CEPH_CAP_FILE_WRBUFFER;
+               used |= CEPH_CAP_FILE_BUFFER;
        return used;
 }
 
@@ -562,7 +562,7 @@ static inline int __ceph_caps_file_wanted(struct ceph_inode_info *ci)
 static inline int __ceph_caps_wanted(struct ceph_inode_info *ci)
 {
        int w = __ceph_caps_file_wanted(ci) | __ceph_caps_used(ci);
-       if (w & CEPH_CAP_FILE_WRBUFFER)
+       if (w & CEPH_CAP_FILE_BUFFER)
                w |= (CEPH_CAP_FILE_EXCL);  /* we want EXCL if dirty data */
        return w;
 }

diff --git a/src/mds/CInode.cc b/src/mds/CInode.cc
index 65f9fd435e2f335e080dac9a955b2d10c150e166..84f482283afa57f6fea89be50cb861af68aa655c 100644 (file)
--- a/src/mds/CInode.cc
+++ b/src/mds/CInode.cc
@@ -1558,7 +1558,7 @@ bool CInode::encode_inodestat(bufferlist& bl, Session *session,
   e.fragtree.nsplits = dirfragtree._splits.size();
 
   i = pxattr ? pi:oi;
-  bool had_latest_xattrs = cap && (cap->issued() & CEPH_CAP_XATTR_RDCACHE) &&
+  bool had_latest_xattrs = cap && (cap->issued() & CEPH_CAP_XATTR_SHARED) &&
     cap->client_xattr_version == i->xattr_version;
   
   // include capability?
@@ -1624,7 +1624,7 @@ bool CInode::encode_inodestat(bufferlist& bl, Session *session,
   e.xattr_version = i->xattr_version;
   if (!had_latest_xattrs &&
       cap &&
-      (cap->pending() & CEPH_CAP_XATTR_RDCACHE)) {
+      (cap->pending() & CEPH_CAP_XATTR_SHARED)) {
     
     if (!pxattrs)
       pxattrs = pxattr ? get_projected_xattrs() : &xattrs;
@@ -1688,7 +1688,7 @@ void CInode::encode_cap_message(MClientCaps *m, Capability *cap)
 
   i = pxattr ? pi:oi;
   map<string,bufferptr> *ix = pxattr ? get_projected_xattrs() : &xattrs;
-  if ((cap->pending() & CEPH_CAP_XATTR_RDCACHE) &&
+  if ((cap->pending() & CEPH_CAP_XATTR_SHARED) &&
       i->xattr_version > cap->client_xattr_version) {
     dout(10) << "    including xattrs v " << i->xattr_version << dendl;
     ::encode(*ix, m->xattrbl);

diff --git a/src/mds/CInode.h b/src/mds/CInode.h
index f7347ea5ed900f34c0b978dc375f90175ab31a1a..7e460770c0435e9f8d96df2062528c3135595a31 100644 (file)
--- a/src/mds/CInode.h
+++ b/src/mds/CInode.h
@@ -661,7 +661,7 @@ public:
   // caps allowed
   int get_caps_liked() {
     if (is_dir())
-      return CEPH_CAP_PIN | CEPH_CAP_ANY_EXCL | CEPH_CAP_ANY_RDCACHE;  // but not, say, FILE_RD|WR|WRBUFFER
+      return CEPH_CAP_PIN | CEPH_CAP_ANY_EXCL | CEPH_CAP_ANY_SHARED;  // but not, say, FILE_RD|WR|WRBUFFER
     else
       return CEPH_CAP_ANY;
   }

diff --git a/src/mds/Locker.cc b/src/mds/Locker.cc
index 439512991c966b2ccbb03fb49025a01c74a5757a..0873a10fdc50c4ef6afd070e0402dd927662b1a5 100644 (file)
--- a/src/mds/Locker.cc
+++ b/src/mds/Locker.cc
@@ -547,7 +547,7 @@ bool Locker::eval(CInode *in, int mask)
   // choose loner?
   if (in->is_auth() && in->get_loner() < 0) {
     int wanted = in->get_caps_wanted();
-    if (((wanted & (CEPH_CAP_GWR|CEPH_CAP_GWRBUFFER|CEPH_CAP_GEXCL)) ||
+    if (((wanted & (CEPH_CAP_GWR|CEPH_CAP_GBUFFER|CEPH_CAP_GEXCL)) ||
         (in->inode.is_dir() && !in->has_subtree_root_dirfrag() &&
          !in->multiple_nonstale_caps())) &&
        in->try_choose_loner()) {
@@ -1412,7 +1412,7 @@ bool Locker::check_inode_max_size(CInode *in, bool force_wrlock, bool update_siz
   if (update_size)
     size = new_size;
   
-  if ((in->get_caps_wanted() & (CEPH_CAP_FILE_WR|CEPH_CAP_FILE_WRBUFFER)) == 0)
+  if ((in->get_caps_wanted() & (CEPH_CAP_FILE_WR|CEPH_CAP_FILE_BUFFER)) == 0)
     new_max = 0;
   else if ((size << 1) >= latest->max_size)
     new_max = latest->max_size ? (latest->max_size << 1):in->get_layout_size_increment();
@@ -2111,7 +2111,7 @@ int Locker::issue_client_lease(CDentry *dn, int client,
   CInode *diri = dn->get_dir()->get_inode();
   if (!diri->is_stray() &&  // do not issue dn leases in stray dir!
       ((!diri->filelock.can_lease(client) &&
-       (diri->get_client_cap_pending(client) & ((CEPH_CAP_GEXCL|CEPH_CAP_GRDCACHE) << CEPH_CAP_SFILE)) == 0)) &&
+       (diri->get_client_cap_pending(client) & (CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_EXCL)) == 0)) &&
       dn->lock.can_lease(client))
     mask |= CEPH_LOCK_DN;
   
@@ -3038,8 +3038,8 @@ void Locker::file_eval(ScatterLock *lock, bool *need_issue)
     int loner_issued, other_issued, xlocker_issued;
     in->get_caps_issued(&loner_issued, &other_issued, &xlocker_issued, CEPH_CAP_SFILE);
 
-    if (!(loner_issued & (CEPH_CAP_GEXCL|CEPH_CAP_GWR|CEPH_CAP_GWRBUFFER|CEPH_CAP_GRD)) ||
-        (other_wanted & (CEPH_CAP_GEXCL|CEPH_CAP_GWR|CEPH_CAP_GWRBUFFER|CEPH_CAP_GRD|CEPH_CAP_GRDCACHE)) ||
+    if (!(loner_issued & (CEPH_CAP_GEXCL|CEPH_CAP_GWR|CEPH_CAP_GBUFFER)) ||
+        (other_wanted & (CEPH_CAP_GEXCL|CEPH_CAP_GWR|CEPH_CAP_GBUFFER|CEPH_CAP_GRD|CEPH_CAP_GCACHE)) ||
        (in->inode.is_dir() && in->multiple_nonstale_caps())) {  // FIXME.. :/
       dout(20) << " should lose it" << dendl;
       // we should lose it.
@@ -3057,7 +3057,7 @@ void Locker::file_eval(ScatterLock *lock, bool *need_issue)
   else if (lock->get_state() != LOCK_EXCL &&
           //!lock->is_rdlocked() &&
           //!lock->is_waiter_for(SimpleLock::WAIT_WR) &&
-          ((wanted & (CEPH_CAP_GWR|CEPH_CAP_GWRBUFFER)) ||
+          ((wanted & (CEPH_CAP_GWR|CEPH_CAP_GBUFFER)) ||
            (in->inode.is_dir() && !in->has_subtree_root_dirfrag())) &&
           in->try_choose_loner()) {
     dout(7) << "file_eval stable, bump to loner " << *lock
@@ -3079,7 +3079,7 @@ void Locker::file_eval(ScatterLock *lock, bool *need_issue)
   // * -> sync?
   else if (lock->get_state() != LOCK_SYNC &&
           !in->filelock.is_waiter_for(SimpleLock::WAIT_WR) &&
-          !(wanted & (CEPH_CAP_GWR|CEPH_CAP_GWRBUFFER)) &&
+          !(wanted & (CEPH_CAP_GWR|CEPH_CAP_GBUFFER)) &&
           !(in->get_state() == LOCK_MIX &&
             in->is_dir() && in->has_subtree_root_dirfrag())  // if we are a delegation point, stay where we are
           //((wanted & CEPH_CAP_RD) || 

diff --git a/src/mds/MDCache.cc b/src/mds/MDCache.cc
index 6fa315feea195cc91149dce295b1a81ece881e4d..c054b21e1f61a452378f3115eff9746be076c528 100644 (file)
--- a/src/mds/MDCache.cc
+++ b/src/mds/MDCache.cc
@@ -3804,7 +3804,7 @@ void MDCache::process_reconnected_caps()
       // wr?
       if (issued & CEPH_CAP_ANY_WR) {
        in->loner_cap = -1;
-       if (issued & ((CEPH_CAP_GRDCACHE|CEPH_CAP_GWRBUFFER) << CEPH_CAP_SFILE)) {
+       if (issued & (CEPH_CAP_FILE_CACHE|CEPH_CAP_FILE_BUFFER)) {
          in->filelock.set_state(LOCK_EXCL);
          in->try_choose_loner();
        } else {

diff --git a/src/mds/Server.cc b/src/mds/Server.cc
index 23f06732f07e1b34884ffd6ee6f989cedcb38f8a..3710725d1befac33abf9f7ca3e8718985a965d69 100644 (file)
--- a/src/mds/Server.cc
+++ b/src/mds/Server.cc
@@ -1674,10 +1674,10 @@ void Server::handle_client_stat(MDRequest *mdr)
     issued = cap->issued();
 
   int mask = req->head.args.getattr.mask;
-  if ((mask & CEPH_CAP_LINK_RDCACHE) && (issued & CEPH_CAP_LINK_EXCL) == 0) rdlocks.insert(&ref->linklock);
-  if ((mask & CEPH_CAP_AUTH_RDCACHE) && (issued & CEPH_CAP_AUTH_EXCL) == 0) rdlocks.insert(&ref->authlock);
-  if ((mask & CEPH_CAP_FILE_RDCACHE) && (issued & CEPH_CAP_FILE_EXCL) == 0) rdlocks.insert(&ref->filelock);
-  if ((mask & CEPH_CAP_XATTR_RDCACHE) && (issued & CEPH_CAP_XATTR_EXCL) == 0) rdlocks.insert(&ref->xattrlock);
+  if ((mask & CEPH_CAP_LINK_SHARED) && (issued & CEPH_CAP_LINK_EXCL) == 0) rdlocks.insert(&ref->linklock);
+  if ((mask & CEPH_CAP_AUTH_SHARED) && (issued & CEPH_CAP_AUTH_EXCL) == 0) rdlocks.insert(&ref->authlock);
+  if ((mask & CEPH_CAP_FILE_SHARED) && (issued & CEPH_CAP_FILE_EXCL) == 0) rdlocks.insert(&ref->filelock);
+  if ((mask & CEPH_CAP_XATTR_SHARED) && (issued & CEPH_CAP_XATTR_EXCL) == 0) rdlocks.insert(&ref->xattrlock);
 
   if (!mds->locker->acquire_locks(mdr, rdlocks, wrlocks, xlocks))
     return;
@@ -2633,8 +2633,8 @@ void Server::handle_client_mkdir(MDRequest *mdr)
   newi->filelock.set_state(LOCK_EXCL);
   newi->authlock.set_state(LOCK_EXCL);
   newi->xattrlock.set_state(LOCK_EXCL);
-  cap->issue_norevoke(CEPH_CAP_AUTH_EXCL|CEPH_CAP_AUTH_RDCACHE|
-                     CEPH_CAP_XATTR_EXCL|CEPH_CAP_XATTR_RDCACHE);
+  cap->issue_norevoke(CEPH_CAP_AUTH_EXCL|CEPH_CAP_AUTH_SHARED|
+                     CEPH_CAP_XATTR_EXCL|CEPH_CAP_XATTR_SHARED);
 
   // make sure this inode gets into the journal
   le->metablob.add_opened_ino(newi->ino());

diff --git a/src/mds/SimpleLock.h b/src/mds/SimpleLock.h
index 68d39bddb4e59940e5ca4311bf074952f515777b..d47dd924bc87f7e8f490d1baf5a678a2131a31b7 100644 (file)
--- a/src/mds/SimpleLock.h
+++ b/src/mds/SimpleLock.h
@@ -423,7 +423,7 @@ public:
 
   int gcaps_xlocker_mask(int client) {
     if (client == xlock_by_client)
-      return CEPH_CAP_GRDCACHE | CEPH_CAP_GWRBUFFER;
+      return type == CEPH_LOCK_IFILE ? 0xffff : (CEPH_CAP_GSHARED|CEPH_CAP_GEXCL);
     return 0;
   }
 

diff --git a/src/mds/locks.c b/src/mds/locks.c
index d06e7e1f2ea53a0e8fec5a4f2780d28e59ef07e8..4ad3d5b8ddc12f343d778afdf704a41ab97b48f4 100644 (file)
--- a/src/mds/locks.c
+++ b/src/mds/locks.c
@@ -14,9 +14,9 @@ typedef char bool;
 
 struct sm_state_t simplelock[20] = {
                       // stable     loner  rep state  r     rp   rd   wr   l    x    caps,other
-    [LOCK_SYNC]      = { 0,         false, LOCK_SYNC, ANY,  0,   ANY, 0,   ANY, 0,   CEPH_CAP_GRDCACHE,0,0,CEPH_CAP_GRDCACHE },
+    [LOCK_SYNC]      = { 0,         false, LOCK_SYNC, ANY,  0,   ANY, 0,   ANY, 0,   CEPH_CAP_GSHARED,0,0,CEPH_CAP_GSHARED },
     [LOCK_LOCK_SYNC] = { LOCK_SYNC, false, LOCK_SYNC, ANY,  XCL, XCL, 0,   XCL, 0,   0,0,0,0 },
-    [LOCK_EXCL_SYNC] = { LOCK_SYNC, true,  LOCK_LOCK, 0,    0,   0,   0,   0,   0,   0,CEPH_CAP_GRDCACHE,0,0 },
+    [LOCK_EXCL_SYNC] = { LOCK_SYNC, true,  LOCK_LOCK, 0,    0,   0,   0,   0,   0,   0,CEPH_CAP_GSHARED,0,0 },
 
     [LOCK_LOCK]      = { 0,         false, LOCK_LOCK, AUTH, 0,   0,   0,   0,   0,   0,0,0,0 },
     [LOCK_SYNC_LOCK] = { LOCK_LOCK, false, LOCK_LOCK, ANY,  0,   0,   0,   0,   0,   0,0,0,0 }, 
@@ -24,21 +24,21 @@ struct sm_state_t simplelock[20] = {
 
     [LOCK_PREXLOCK]  = { LOCK_SYNC, false, LOCK_LOCK, 0,    XCL, 0,   0,   0,   ANY, 0,0,0 },
     [LOCK_XLOCK]     = { LOCK_SYNC, false, LOCK_LOCK, 0,    XCL, 0,   0,   0,   0,   0,0,0 },
-    [LOCK_XLOCKDONE] = { LOCK_SYNC, false, LOCK_LOCK, XCL,  XCL, XCL, 0,   XCL, 0,   0,0,CEPH_CAP_GRDCACHE,0 },
+    [LOCK_XLOCKDONE] = { LOCK_SYNC, false, LOCK_LOCK, XCL,  XCL, XCL, 0,   XCL, 0,   0,0,CEPH_CAP_GSHARED,0 },
     [LOCK_LOCK_XLOCK]= { LOCK_PREXLOCK,false,LOCK_LOCK,0,   XCL, 0,   0,   0,   XCL, 0,0,0,0 },
 
-    [LOCK_EXCL]      = { 0,         true,  LOCK_LOCK, 0,    0,   FW,  XCL, 0,   0,   0,CEPH_CAP_GEXCL|CEPH_CAP_GRDCACHE,0,0 },
-    [LOCK_SYNC_EXCL] = { LOCK_EXCL, true,  LOCK_LOCK, ANY,  0,   0,   0,   0,   0,   0,CEPH_CAP_GRDCACHE,0,0 },
-    [LOCK_LOCK_EXCL] = { LOCK_EXCL, false, LOCK_LOCK, ANY,  0,   0,   0,   0,   0,   CEPH_CAP_GRDCACHE,0,0,0 },
+    [LOCK_EXCL]      = { 0,         true,  LOCK_LOCK, 0,    0,   FW,  XCL, 0,   0,   0,CEPH_CAP_GEXCL|CEPH_CAP_GSHARED,0,0 },
+    [LOCK_SYNC_EXCL] = { LOCK_EXCL, true,  LOCK_LOCK, ANY,  0,   0,   0,   0,   0,   0,CEPH_CAP_GSHARED,0,0 },
+    [LOCK_LOCK_EXCL] = { LOCK_EXCL, false, LOCK_LOCK, ANY,  0,   0,   0,   0,   0,   CEPH_CAP_GSHARED,0,0,0 },
 
     [LOCK_REMOTEXLOCK]={ LOCK_LOCK, false, LOCK_LOCK, 0,    0,   0,   0,   0,   0,   0,0,0,0 },
 };
 
 struct sm_t sm_simplelock = {
        .states = simplelock,
-       .allowed_ever_auth = CEPH_CAP_GRDCACHE | CEPH_CAP_GEXCL,
-       .allowed_ever_replica = CEPH_CAP_GRDCACHE,
-       .careful = CEPH_CAP_GRDCACHE | CEPH_CAP_GEXCL,
+       .allowed_ever_auth = CEPH_CAP_GSHARED | CEPH_CAP_GEXCL,
+       .allowed_ever_replica = CEPH_CAP_GSHARED,
+       .careful = CEPH_CAP_GSHARED | CEPH_CAP_GEXCL,
        .can_remote_xlock = 1,
 };
 
@@ -50,7 +50,7 @@ struct sm_t sm_simplelock = {
 
 struct sm_state_t scatterlock[30] = {
                       // stable     loner  rep state  r     rp   rd   wr   l    x    caps,other
-    [LOCK_SYNC]      = { 0,         false, LOCK_SYNC, ANY,  0,   ANY, 0,   ANY, 0,   CEPH_CAP_GRDCACHE,0,0,CEPH_CAP_GRDCACHE },
+    [LOCK_SYNC]      = { 0,         false, LOCK_SYNC, ANY,  0,   ANY, 0,   ANY, 0,   CEPH_CAP_GSHARED,0,0,CEPH_CAP_GSHARED },
     [LOCK_LOCK_SYNC] = { LOCK_SYNC, false, LOCK_LOCK, AUTH, 0,   0,   0,   0,   0,   0,0,0,0 },
     [LOCK_MIX_SYNC]  = { LOCK_SYNC, false, LOCK_LOCK, 0,    0,   0,   0,   0,   0,   0,0,0,0 },
     
@@ -71,56 +71,59 @@ struct sm_state_t scatterlock[30] = {
 
 struct sm_t sm_scatterlock = {
        .states = scatterlock,
-       .allowed_ever_auth = CEPH_CAP_GRDCACHE | CEPH_CAP_GEXCL,
-       .allowed_ever_replica = CEPH_CAP_GRDCACHE,
-       .careful = CEPH_CAP_GRDCACHE | CEPH_CAP_GEXCL,
+       .allowed_ever_auth = CEPH_CAP_GSHARED | CEPH_CAP_GEXCL,
+       .allowed_ever_replica = CEPH_CAP_GSHARED,
+       .careful = CEPH_CAP_GSHARED | CEPH_CAP_GEXCL,
        .can_remote_xlock = 0,
 };
 
 struct sm_state_t filelock[30] = {
-                      // stable     loner  rep state  r     rp   rd   wr   l    x    caps,other
-    [LOCK_SYNC]      = { 0,         false, LOCK_SYNC, ANY,  0,   ANY, 0,   ANY, 0,   CEPH_CAP_GRDCACHE|CEPH_CAP_GRD,0,0,CEPH_CAP_GRDCACHE|CEPH_CAP_GRD },
-    [LOCK_LOCK_SYNC] = { LOCK_SYNC, false, LOCK_SYNC, AUTH, 0,   AUTH,0,   0,   0,   CEPH_CAP_GRDCACHE|CEPH_CAP_GWRBUFFER,0,0,0 },
-    [LOCK_EXCL_SYNC] = { LOCK_SYNC, true,  LOCK_LOCK, 0,    0,   0,   0,   0,   0,   0,CEPH_CAP_GRDCACHE|CEPH_CAP_GRD,0,0 },
+                      // stable     loner  rep state  r     rp   rd   wr   l    x    caps(any,loner,xlocker,replica)
+    [LOCK_SYNC]      = { 0,         false, LOCK_SYNC, ANY,  0,   ANY, 0,   ANY, 0,   CEPH_CAP_GSHARED|CEPH_CAP_GCACHE|CEPH_CAP_GRD,0,0,CEPH_CAP_GSHARED|CEPH_CAP_GCACHE|CEPH_CAP_GRD },
+    [LOCK_LOCK_SYNC] = { LOCK_SYNC, false, LOCK_SYNC, AUTH, 0,   AUTH,0,   0,   0,   CEPH_CAP_GCACHE,0,0,0 },
+    [LOCK_EXCL_SYNC] = { LOCK_SYNC, true,  LOCK_LOCK, 0,    0,   0,   0,   0,   0,   0,CEPH_CAP_GSHARED|CEPH_CAP_GCACHE|CEPH_CAP_GRD,0,0 },
     [LOCK_MIX_SYNC]  = { LOCK_SYNC, false, LOCK_MIX,  0,    0,   0,   0,   0,   0,   CEPH_CAP_GRD,0,0,CEPH_CAP_GRD },
     [LOCK_MIX_SYNC2] = { LOCK_SYNC, false, 0,         0,    0,   0,   0,   0,   0,   CEPH_CAP_GRD,0,0,CEPH_CAP_GRD },
     
-    [LOCK_LOCK]      = { 0,         false, LOCK_LOCK, AUTH, 0,   AUTH,AUTH,0,   0,   CEPH_CAP_GRDCACHE|CEPH_CAP_GWRBUFFER,0,0,0 },
-    [LOCK_SYNC_LOCK] = { LOCK_LOCK, false, LOCK_LOCK, AUTH, 0,   0,   0,   0,   0,   CEPH_CAP_GRDCACHE,0,0,CEPH_CAP_GRDCACHE },
-    [LOCK_EXCL_LOCK] = { LOCK_LOCK, false, LOCK_LOCK, 0,    0,   0,   0,   0,   0,   CEPH_CAP_GRDCACHE|CEPH_CAP_GWRBUFFER,0,0,CEPH_CAP_GRDCACHE },
+    [LOCK_LOCK]      = { 0,         false, LOCK_LOCK, AUTH, 0,   AUTH,AUTH,0,   0,   CEPH_CAP_GCACHE|CEPH_CAP_GBUFFER,0,0,0 },
+    [LOCK_SYNC_LOCK] = { LOCK_LOCK, false, LOCK_LOCK, AUTH, 0,   0,   0,   0,   0,   CEPH_CAP_GCACHE,0,0,CEPH_CAP_GCACHE },
+    [LOCK_EXCL_LOCK] = { LOCK_LOCK, false, LOCK_LOCK, 0,    0,   0,   0,   0,   0,   CEPH_CAP_GCACHE|CEPH_CAP_GBUFFER,0,0,CEPH_CAP_GCACHE },
     [LOCK_MIX_LOCK]  = { LOCK_LOCK, false, LOCK_LOCK, AUTH, 0,   0,   0,   0,   0,   0,0,0,0 },
 
-    [LOCK_PREXLOCK]  = { LOCK_SYNC, false, LOCK_LOCK, 0,    XCL, 0,   0,   0,   ANY, CEPH_CAP_GRDCACHE|CEPH_CAP_GWRBUFFER,0,0,0 },
-    [LOCK_XLOCK]     = { LOCK_SYNC, false, LOCK_LOCK, 0,    XCL, 0,   0,   0,   0,   CEPH_CAP_GRDCACHE|CEPH_CAP_GWRBUFFER,0,0,0 },
-    [LOCK_XLOCKDONE] = { LOCK_SYNC, false, LOCK_LOCK, XCL,  XCL, XCL, 0,   XCL, 0,   CEPH_CAP_GRDCACHE|CEPH_CAP_GWRBUFFER,0,0,0 },
-    [LOCK_LOCK_XLOCK]= { LOCK_PREXLOCK,false,LOCK_LOCK,0,   XCL, 0,   0,   0,   XCL, CEPH_CAP_GRDCACHE|CEPH_CAP_GWRBUFFER,0,0,0 },
+    [LOCK_PREXLOCK]  = { LOCK_SYNC, false, LOCK_LOCK, 0,    XCL, 0,   0,   0,   ANY, CEPH_CAP_GCACHE|CEPH_CAP_GBUFFER,0,0,0 },
+    [LOCK_XLOCK]     = { LOCK_SYNC, false, LOCK_LOCK, 0,    XCL, 0,   0,   0,   0,   CEPH_CAP_GCACHE|CEPH_CAP_GBUFFER,0,0,0 },
+    [LOCK_XLOCKDONE] = { LOCK_SYNC, false, LOCK_LOCK, XCL,  XCL, XCL, 0,   XCL, 0,   CEPH_CAP_GCACHE|CEPH_CAP_GBUFFER,0,CEPH_CAP_GSHARED,0 },
+    [LOCK_LOCK_XLOCK]= { LOCK_PREXLOCK,false,LOCK_LOCK,0,   XCL, 0,   0,   0,   XCL, CEPH_CAP_GCACHE|CEPH_CAP_GBUFFER,0,0,0 },
 
     [LOCK_MIX]       = { 0,         false, LOCK_MIX,  0,    0,   FW,  ANY, 0,   0,   CEPH_CAP_GRD|CEPH_CAP_GWR,0,0,CEPH_CAP_GRD },
     [LOCK_SYNC_MIX]  = { LOCK_MIX,  false, LOCK_MIX,  ANY,  0,   0,   0,   0,   0,   CEPH_CAP_GRD,0,0,CEPH_CAP_GRD },
     [LOCK_SYNC_MIX2] = { LOCK_MIX,  false, 0,         ANY,  0,   0,   0,   0,   0,   CEPH_CAP_GRD,0,0,CEPH_CAP_GRD },
     [LOCK_EXCL_MIX]  = { LOCK_MIX,  true,  LOCK_LOCK, 0,    0,   0,   XCL, 0,   0,   0,CEPH_CAP_GRD|CEPH_CAP_GWR,0,0 },
     
-    [LOCK_EXCL]      = { 0,         true,  LOCK_LOCK, 0,    0,   FW,  XCL, 0,   0,   0,CEPH_CAP_GRDCACHE|CEPH_CAP_GEXCL|CEPH_CAP_GRD|CEPH_CAP_GWR|CEPH_CAP_GWRBUFFER,0,0 },
-    [LOCK_SYNC_EXCL] = { LOCK_EXCL, true,  LOCK_LOCK, AUTH, 0,   0,   0,   0,   0,   0,CEPH_CAP_GRDCACHE|CEPH_CAP_GRD,0,0 },
+    [LOCK_EXCL]      = { 0,         true,  LOCK_LOCK, 0,    0,   FW,  XCL, 0,   0,   0,CEPH_CAP_GSHARED|CEPH_CAP_GEXCL|CEPH_CAP_GCACHE|CEPH_CAP_GRD|CEPH_CAP_GWR|CEPH_CAP_GBUFFER,0,0 },
+    [LOCK_SYNC_EXCL] = { LOCK_EXCL, true,  LOCK_LOCK, AUTH, 0,   0,   0,   0,   0,   0,CEPH_CAP_GSHARED|CEPH_CAP_GCACHE|CEPH_CAP_GRD,0,0 },
     [LOCK_MIX_EXCL]  = { LOCK_EXCL, true,  LOCK_LOCK, 0,    0,   0,   XCL, 0,   0,   0,CEPH_CAP_GRD|CEPH_CAP_GWR,0,0 },
-    [LOCK_LOCK_EXCL] = { LOCK_EXCL, true,  LOCK_LOCK, AUTH, 0,   0,   0,   0,   0,   0,CEPH_CAP_GRDCACHE|CEPH_CAP_GWRBUFFER,0,0 },
+    [LOCK_LOCK_EXCL] = { LOCK_EXCL, true,  LOCK_LOCK, AUTH, 0,   0,   0,   0,   0,   0,CEPH_CAP_GCACHE|CEPH_CAP_GBUFFER,0,0 },
 };
 
 struct sm_t sm_filelock = {
        .states = filelock,
-       .allowed_ever_auth = (CEPH_CAP_GRDCACHE |
+       .allowed_ever_auth = (CEPH_CAP_GSHARED |
                              CEPH_CAP_GEXCL |
+                             CEPH_CAP_GCACHE |
                              CEPH_CAP_GRD |
                              CEPH_CAP_GWR |
                              CEPH_CAP_GWREXTEND |
-                             CEPH_CAP_GWRBUFFER | 
+                             CEPH_CAP_GBUFFER | 
                              CEPH_CAP_GLAZYIO),
-       .allowed_ever_replica = (CEPH_CAP_GRDCACHE |
+       .allowed_ever_replica = (CEPH_CAP_GSHARED |
+                                CEPH_CAP_GCACHE |
                                 CEPH_CAP_GRD | 
                                 CEPH_CAP_GLAZYIO),
-       .careful = (CEPH_CAP_GRDCACHE | 
+       .careful = (CEPH_CAP_GSHARED | 
                    CEPH_CAP_GEXCL | 
-                   CEPH_CAP_GWRBUFFER),
+                   CEPH_CAP_GCACHE |
+                   CEPH_CAP_GBUFFER),
        .can_remote_xlock = 0,
 };
 

diff --git a/src/mds/mdstypes.h b/src/mds/mdstypes.h
index 5cde0b26c0b38a9fa2a5dbb516c78115a8786445..e83f19912a97cd0f89e0d9f09f6bf9bfcbdde725 100644 (file)
--- a/src/mds/mdstypes.h
+++ b/src/mds/mdstypes.h
@@ -64,11 +64,12 @@ using namespace std;
 inline string gcap_string(int cap)
 {
   string s;
-  if (cap & CEPH_CAP_GRDCACHE) s += "c";
+  if (cap & CEPH_CAP_GSHARED) s += "s";  
   if (cap & CEPH_CAP_GEXCL) s += "x";
+  if (cap & CEPH_CAP_GCACHE) s += "c";
   if (cap & CEPH_CAP_GRD) s += "r";
   if (cap & CEPH_CAP_GWR) s += "w";
-  if (cap & CEPH_CAP_GWRBUFFER) s += "b";
+  if (cap & CEPH_CAP_GBUFFER) s += "b";
   if (cap & CEPH_CAP_GWREXTEND) s += "a";
   if (cap & CEPH_CAP_GLAZYIO) s += "l";
   return s;