afs: fix afs_linux_mmap fstrace entry

[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 e3422ca..4617a34 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);
@@ -533,9 +533,9 @@ afs_linux_mmap(struct file *fp, struct vm_area_struct *vmap)
     int code;
 
     AFS_GLOCK();
-    afs_Trace3(afs_iclSetp, CM_TRACE_GMAP, ICL_TYPE_POINTER, vcp,
-              ICL_TYPE_POINTER, vmap->vm_start, ICL_TYPE_INT32,
-              vmap->vm_end - vmap->vm_start);
+    afs_Trace4(afs_iclSetp, CM_TRACE_GMAP, ICL_TYPE_POINTER, vcp,
+              ICL_TYPE_POINTER, vmap->vm_start, ICL_TYPE_LONG,
+              vmap->vm_end - vmap->vm_start, ICL_TYPE_LONG, 0);
 
     /* get a validated vcache entry */
     code = afs_linux_VerifyVCache(vcp, NULL);
@@ -1008,15 +1008,15 @@ iattr2vattr(struct vattr *vattrp, struct iattr *iattrp)
        vattrp->va_size = iattrp->ia_size;
     if (iattrp->ia_valid & ATTR_ATIME) {
        vattrp->va_atime.tv_sec = iattrp->ia_atime.tv_sec;
-       vattrp->va_atime.tv_usec = 0;
+       vattrp->va_atime.tv_nsec = 0;
     }
     if (iattrp->ia_valid & ATTR_MTIME) {
        vattrp->va_mtime.tv_sec = iattrp->ia_mtime.tv_sec;
-       vattrp->va_mtime.tv_usec = 0;
+       vattrp->va_mtime.tv_nsec = 0;
     }
     if (iattrp->ia_valid & ATTR_CTIME) {
        vattrp->va_ctime.tv_sec = iattrp->ia_ctime.tv_sec;
-       vattrp->va_ctime.tv_usec = 0;
+       vattrp->va_ctime.tv_nsec = 0;
     }
 }
 
@@ -1289,20 +1289,6 @@ afs_linux_dentry_revalidate(struct dentry *dp, int flags)
            osi_Assert(vcp->mvid.parent != NULL);
        }
 
-#ifdef notdef
-       /* If the last looker changes, we should make sure the current
-        * looker still has permission to examine this file.  This would
-        * always require a crref() which would be "slow".
-        */
-       if (vcp->last_looker != treq.uid) {
-           if (!afs_AccessOK(vcp, (vType(vcp) == VREG) ? PRSFS_READ : PRSFS_LOOKUP, &treq, CHECK_MODE_BITS)) {
-               goto bad_dentry;
-           }
-
-           vcp->last_looker = treq.uid;
-       }
-#endif
-
        parent = dget_parent(dp);
        pvcp = VTOAFS(parent->d_inode);
        parent_dv = parent_vcache_dv(parent->d_inode, credp);
@@ -1453,12 +1439,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);
@@ -2080,7 +2074,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,
@@ -2144,7 +2139,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);
        }
@@ -2167,11 +2164,11 @@ afs_linux_read_cache(struct file *cachefp, struct page *page,
        }
     }
 
+ out:
     if (code && task) {
         unlock_page(page);
     }
 
-out:
     if (cachepage)
        put_page(cachepage);
 
@@ -2256,7 +2253,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;
 
@@ -2583,6 +2580,7 @@ afs_linux_can_bypass(struct inode *ip) {
        case LARGE_FILES_BYPASS_CACHE:
            if (i_size_read(ip) > cache_bypass_threshold)
                return 1;
+           /* fall through */
        default:
            return 0;
      }
@@ -2687,7 +2685,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);
@@ -2711,6 +2709,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);