LINUX: Avoid re-taking global lock in afs_dentry_iput

[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 9a070f2..0ca2646 100644 (file)
--- a/src/afs/LINUX/osi_vnodeops.c
+++ b/src/afs/LINUX/osi_vnodeops.c
@@ -368,7 +368,7 @@ afs_linux_readdir(struct file *fp, void *dirbuf, filldir_t filldir)
      */
     while ((avc->f.states & CStatd)
           && (tdc->dflags & DFFetching)
-          && hsame(avc->f.m.DataVersion, tdc->f.versionNo)) {
+          && afs_IsDCacheFresh(tdc, avc)) {
        ReleaseReadLock(&tdc->lock);
        ReleaseWriteLock(&avc->lock);
        afs_osi_Sleep(&tdc->validPos);
@@ -376,7 +376,7 @@ afs_linux_readdir(struct file *fp, void *dirbuf, filldir_t filldir)
        ObtainReadLock(&tdc->lock);
     }
     if (!(avc->f.states & CStatd)
-       || !hsame(avc->f.m.DataVersion, tdc->f.versionNo)) {
+       || !afs_IsDCacheFresh(tdc, avc)) {
        ReleaseReadLock(&tdc->lock);
        ReleaseWriteLock(&avc->lock);
        afs_PutDCache(tdc);
@@ -401,11 +401,17 @@ afs_linux_readdir(struct file *fp, void *dirbuf, filldir_t filldir)
     offset = (int) fp->f_pos;
 #endif
     while (1) {
+        dirpos = 0;
        code = BlobScan(tdc, offset, &dirpos);
-       if (code || !dirpos)
-           break;
+        if (code == 0 && dirpos == 0) {
+            /* We've reached EOF of the dir blob, so we can stop looking for
+             * entries. */
+            break;
+        }
 
-       code = afs_dir_GetVerifiedBlob(tdc, dirpos, &entry);
+        if (code == 0) {
+            code = afs_dir_GetVerifiedBlob(tdc, dirpos, &entry);
+        }
        if (code) {
            if (!(avc->f.states & CCorrupt)) {
                struct cell *tc = afs_GetCellStale(avc->f.fid.Cell, READ_LOCK);
@@ -1135,6 +1141,17 @@ parent_vcache_dv(struct inode *inode, cred_t *credp)
     return hgetlo(pvcp->f.m.DataVersion);
 }
 
+static inline int
+filter_enoent(int code)
+{
+#ifdef HAVE_LINUX_FATAL_SIGNAL_PENDING
+    if (code == ENOENT && fatal_signal_pending(current)) {
+        return EINTR;
+    }
+#endif
+    return code;
+}
+
 #ifndef D_SPLICE_ALIAS_RACE
 
 static inline void dentry_race_lock(void) {}
@@ -1304,6 +1321,7 @@ afs_linux_dentry_revalidate(struct dentry *dp, int flags)
                credp = crref();
            }
            code = afs_lookup(pvcp, (char *)dp->d_name.name, &tvc, credp);
+            code = filter_enoent(code);
 
            if (code) {
                /* We couldn't perform the lookup, so we're not okay. */
@@ -1435,12 +1453,20 @@ static void
 afs_dentry_iput(struct dentry *dp, struct inode *ip)
 {
     struct vcache *vcp = VTOAFS(ip);
+    int haveGlock = ISAFS_GLOCK();
+
+    if (!haveGlock) {
+        AFS_GLOCK();
+    }
 
-    AFS_GLOCK();
     if (!AFS_IS_DISCONNECTED || (vcp->f.states & CUnlinked)) {
        (void) afs_InactiveVCache(vcp, NULL);
     }
-    AFS_GUNLOCK();
+
+    if (!haveGlock) {
+        AFS_GUNLOCK();
+    }
+
     afs_linux_clear_nfsfs_renamed(dp);
 
     iput(ip);
@@ -1595,6 +1621,7 @@ afs_linux_lookup(struct inode *dip, struct dentry *dp)
     AFS_GLOCK();
 
     code = afs_lookup(VTOAFS(dip), (char *)comp, &vcp, credp);
+    code = filter_enoent(code);
     if (code == ENOENT) {
         /* It's ok for the file to not be found. That's noted by the caller by
          * seeing that the dp->d_inode field is NULL (set by d_splice_alias or
@@ -2061,7 +2088,8 @@ afs_linux_put_link(struct dentry *dentry, struct nameidata *nd)
  * If task is NULL, the page copy occurs syncronously, and the routine
  * returns with page still locked. If task is non-NULL, then page copies
  * may occur in the background, and the page will be unlocked when it is
- * ready for use.
+ * ready for use. Note that if task is non-NULL and we encounter an error
+ * before we start the background copy, we MUST unlock 'page' before we return.
  */
 static int
 afs_linux_read_cache(struct file *cachefp, struct page *page,
@@ -2125,7 +2153,9 @@ afs_linux_read_cache(struct file *cachefp, struct page *page,
 
     if (!PageUptodate(cachepage)) {
        ClearPageError(cachepage);
-        code = cachemapping->a_ops->readpage(NULL, cachepage);
+       /* Note that ->readpage always handles unlocking the given page, even
+        * when an error is returned. */
+       code = cachemapping->a_ops->readpage(NULL, cachepage);
        if (!code && !task) {
            wait_on_page_locked(cachepage);
        }
@@ -2148,11 +2178,11 @@ afs_linux_read_cache(struct file *cachefp, struct page *page,
        }
     }
 
+ out:
     if (code && task) {
         unlock_page(page);
     }
 
-out:
     if (cachepage)
        put_page(cachepage);
 
@@ -2237,7 +2267,7 @@ afs_linux_readpage_fastpath(struct file *fp, struct page *pp, int *codep)
        ObtainReadLock(&tdc->lock);
 
     /* Is the dcache we've been given currently up to date */
-    if (!hsame(avc->f.m.DataVersion, tdc->f.versionNo) ||
+    if (!afs_IsDCacheFresh(tdc, avc) ||
        (tdc->dflags & DFFetching))
        goto out;
 
@@ -2668,7 +2698,7 @@ afs_linux_readpages(struct file *fp, struct address_space *mapping,
            AFS_GLOCK();
            if ((tdc = afs_FindDCache(avc, offset))) {
                ObtainReadLock(&tdc->lock);
-               if (!hsame(avc->f.m.DataVersion, tdc->f.versionNo) ||
+               if (!afs_IsDCacheFresh(tdc, avc) ||
                    (tdc->dflags & DFFetching)) {
                    ReleaseReadLock(&tdc->lock);
                    afs_PutDCache(tdc);
@@ -2692,6 +2722,8 @@ afs_linux_readpages(struct file *fp, struct address_space *mapping,
            if (!pagevec_add(&lrupv, page))
                __pagevec_lru_add_file(&lrupv);
 
+           /* Note that add_to_page_cache() locked 'page'.
+            * afs_linux_read_cache() is guaranteed to handle unlocking it. */
            afs_linux_read_cache(cacheFp, page, tdc->f.chunk, &lrupv, task);
        }
        put_page(page);
@@ -3082,6 +3114,10 @@ afs_linux_write_begin(struct file *file, struct address_space *mapping,
     int code;
 
     page = grab_cache_page_write_begin(mapping, index, flags);
+    if (!page) {
+        return -ENOMEM;
+    }
+
     *pagep = page;
 
     code = afs_linux_prepare_write(file, page, from, from + len);