Linux: Prevent some fakestat data inconsistencies

[openafs.git] / src / afs / LINUX / osi_vnodeops.c

diff --git a/src/afs/LINUX/osi_vnodeops.c b/src/afs/LINUX/osi_vnodeops.c
index a60027e..91111e8 100644 (file)
--- a/src/afs/LINUX/osi_vnodeops.c
+++ b/src/afs/LINUX/osi_vnodeops.c
@@ -802,6 +802,8 @@ struct file_operations afs_file_fops = {
 #ifdef HAVE_LINUX_GENERIC_FILE_AIO_READ
   .aio_read =  afs_linux_aio_read,
   .aio_write = afs_linux_aio_write,
+  .read =      do_sync_read,
+  .write =     do_sync_write,
 #else
   .read =      afs_linux_read,
   .write =     afs_linux_write,
@@ -1007,9 +1009,9 @@ iattr2vattr(struct vattr *vattrp, struct iattr *iattrp)
     if (iattrp->ia_valid & ATTR_MODE)
        vattrp->va_mode = iattrp->ia_mode;
     if (iattrp->ia_valid & ATTR_UID)
-       vattrp->va_uid = iattrp->ia_uid;
+       vattrp->va_uid = afs_from_kuid(iattrp->ia_uid);
     if (iattrp->ia_valid & ATTR_GID)
-       vattrp->va_gid = iattrp->ia_gid;
+       vattrp->va_gid = afs_from_kgid(iattrp->ia_gid);
     if (iattrp->ia_valid & ATTR_SIZE)
        vattrp->va_size = iattrp->ia_size;
     if (iattrp->ia_valid & ATTR_ATIME) {
@@ -1047,8 +1049,8 @@ vattr2inode(struct inode *ip, struct vattr *vp)
 #endif
     ip->i_rdev = vp->va_rdev;
     ip->i_mode = vp->va_mode;
-    ip->i_uid = vp->va_uid;
-    ip->i_gid = vp->va_gid;
+    ip->i_uid = afs_make_kuid(vp->va_uid);
+    ip->i_gid = afs_make_kgid(vp->va_gid);
     i_size_write(ip, vp->va_size);
     ip->i_atime.tv_sec = vp->va_atime.tv_sec;
     ip->i_atime.tv_nsec = 0;
@@ -1098,6 +1100,36 @@ afs_linux_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *sta
         return err;
 }
 
+static afs_uint32
+parent_vcache_dv(struct inode *inode, cred_t *credp)
+{
+    int free_cred = 0;
+    struct vcache *pvcp;
+
+    /*
+     * If parent is a mount point and we are using fakestat, we may need
+     * to look at the fake vcache entry instead of what the vfs is giving
+     * us.  The fake entry is the one with the useful DataVersion.
+     */
+    pvcp = VTOAFS(inode);
+    if (pvcp->mvstat == 1 && afs_fakestat_enable) {
+       struct vrequest treq;
+       struct afs_fakestat_state fakestate;
+
+       if (!credp) {
+           credp = crref();
+           free_cred = 1;
+       }
+       afs_InitReq(&treq, credp);
+       afs_InitFakeStat(&fakestate);
+       afs_TryEvalFakeStat(&pvcp, &fakestate, &treq);
+       if (free_cred)
+           crfree(credp);
+       afs_PutFakeStat(&fakestate);
+    }
+    return hgetlo(pvcp->f.m.DataVersion);
+}
+
 /* Validate a dentry. Return 1 if unchanged, 0 if VFS layer should re-evaluate.
  * In kernels 2.2.10 and above, we are passed an additional flags var which
  * may have either the LOOKUP_FOLLOW OR LOOKUP_DIRECTORY set in which case
@@ -1123,6 +1155,8 @@ afs_linux_dentry_revalidate(struct dentry *dp, int flags)
     int valid;
     struct afs_fakestat_state fakestate;
     int locked = 0;
+    int force_drop = 0;
+    afs_uint32 parent_dv;
 
 #ifdef LOOKUP_RCU
     /* We don't support RCU path walking */
@@ -1145,7 +1179,8 @@ afs_linux_dentry_revalidate(struct dentry *dp, int flags)
        parent = dget_parent(dp);
        pvcp = VTOAFS(parent->d_inode);
 
-       if ((vcp->mvstat == 1) || (vcp->mvstat == 2)) { /* need to lock */
+       if ((vcp->mvstat == 1) || (vcp->mvstat == 2) ||
+               (pvcp->mvstat == 1 && afs_fakestat_enable)) {   /* need to lock */
            credp = crref();
            AFS_GLOCK();
            locked = 1;
@@ -1194,22 +1229,28 @@ afs_linux_dentry_revalidate(struct dentry *dp, int flags)
        }
 #endif
 
+       parent_dv = parent_vcache_dv(parent->d_inode, credp);
 
        /* If the parent's DataVersion has changed or the vnode
         * is longer valid, we need to do a full lookup.  VerifyVCache
         * isn't enough since the vnode may have been renamed.
         */
 
-       if ((!locked) && (hgetlo(pvcp->f.m.DataVersion) > dp->d_time || !(vcp->f.states & CStatd)) ) {
+       if ((!locked) && (parent_dv > dp->d_time || !(vcp->f.states & CStatd)) ) {
            credp = crref();
            AFS_GLOCK();
            locked = 1;
        }
 
-       if (locked && (hgetlo(pvcp->f.m.DataVersion) > dp->d_time || !(vcp->f.states & CStatd))) {
-           afs_lookup(pvcp, (char *)dp->d_name.name, &tvc, credp);
+       if (locked && (parent_dv > dp->d_time || !(vcp->f.states & CStatd))) {
+           int code;
+
+           code = afs_lookup(pvcp, (char *)dp->d_name.name, &tvc, credp);
            if (!tvc || tvc != vcp) {
                dput(parent);
+               /* Force unhash if name is known not to exist. */
+               if (code == ENOENT)
+                   force_drop = 1;
                goto bad_dentry;
            }
 
@@ -1219,7 +1260,7 @@ afs_linux_dentry_revalidate(struct dentry *dp, int flags)
            }
 
            vattr2inode(AFSTOV(vcp), &vattr);
-           dp->d_time = hgetlo(pvcp->f.m.DataVersion);
+           dp->d_time = parent_dv;
        }
 
        /* should we always update the attributes at this point? */
@@ -1261,9 +1302,18 @@ afs_linux_dentry_revalidate(struct dentry *dp, int flags)
        crfree(credp);
 
     if (!valid) {
-       shrink_dcache_parent(dp);
-       d_drop(dp);
+       /*
+        * If we had a negative lookup for the name we want to forcibly
+        * unhash the dentry.
+        * Otherwise use d_invalidate which will not unhash it if still in use.
+        */
+       if (force_drop) {
+           shrink_dcache_parent(dp);
+           d_drop(dp);
+       } else
+           d_invalidate(dp);
     }
+
     return valid;
 
   bad_dentry:
@@ -1391,7 +1441,7 @@ afs_linux_create(struct inode *dip, struct dentry *dp, int mode)
 #if !defined(STRUCT_SUPER_BLOCK_HAS_S_D_OP)
        dp->d_op = &afs_dentry_operations;
 #endif
-       dp->d_time = hgetlo(VTOAFS(dip)->f.m.DataVersion);
+       dp->d_time = parent_vcache_dv(dip, credp);
        d_instantiate(dp, ip);
     }
     AFS_GUNLOCK();
@@ -1446,7 +1496,8 @@ afs_linux_lookup(struct inode *dip, struct dentry *dp)
 #if !defined(STRUCT_SUPER_BLOCK_HAS_S_D_OP)
     dp->d_op = &afs_dentry_operations;
 #endif
-    dp->d_time = hgetlo(VTOAFS(dip)->f.m.DataVersion);
+    dp->d_time = parent_vcache_dv(dip, credp);
+
     AFS_GUNLOCK();
 
     if (ip && S_ISDIR(ip->i_mode)) {
@@ -1594,7 +1645,8 @@ afs_linux_symlink(struct inode *dip, struct dentry *dp, const char *target)
 
     VATTR_NULL(&vattr);
     AFS_GLOCK();
-    code = afs_symlink(VTOAFS(dip), (char *)name, &vattr, (char *)target, credp);
+    code = afs_symlink(VTOAFS(dip), (char *)name, &vattr, (char *)target, NULL,
+                      credp);
     AFS_GUNLOCK();
     crfree(credp);
     return afs_convert_code(code);