LU-9679 llite: Discard LUSTRE_FPRIVATE()

[fs/lustre-release.git] / lustre / llite / llite_mmap.c

diff --git a/lustre/llite/llite_mmap.c b/lustre/llite/llite_mmap.c
index 1009c70..673ff2c 100644 (file)
--- a/lustre/llite/llite_mmap.c
+++ b/lustre/llite/llite_mmap.c
@@ -119,7 +119,7 @@ restart:
        rc = cl_io_init(env, io, CIT_FAULT, io->ci_obj);
        if (rc == 0) {
                struct vvp_io *vio = vvp_env_io(env);
-               struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
+               struct ll_file_data *fd = file->private_data;
 
                LASSERT(vio->vui_cl.cis_io == io);
 
@@ -351,14 +351,12 @@ static vm_fault_t ll_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
        bool printed = false;
        bool cached;
        vm_fault_t result;
+       ktime_t kstart = ktime_get();
        sigset_t set;
 
-       ll_stats_ops_tally(ll_i2sbi(file_inode(vma->vm_file)),
-                          LPROC_LL_FAULT, 1);
-
        result = pcc_fault(vma, vmf, &cached);
        if (cached)
-               return result;
+               goto out;
 
        /* Only SIGKILL and SIGTERM is allowed for fault/nopage/mkwrite
         * so that it can be killed by admin but not cause segfault by
@@ -372,29 +370,40 @@ restart:
        result = ll_fault0(vma, vmf);
        if (vmf->page &&
            !(result & (VM_FAULT_RETRY | VM_FAULT_ERROR | VM_FAULT_LOCKED))) {
-                struct page *vmpage = vmf->page;
+               struct page *vmpage = vmf->page;
 
-                /* check if this page has been truncated */
-                lock_page(vmpage);
-                if (unlikely(vmpage->mapping == NULL)) { /* unlucky */
-                        unlock_page(vmpage);
+               /* check if this page has been truncated */
+               lock_page(vmpage);
+               if (unlikely(vmpage->mapping == NULL)) { /* unlucky */
+                       unlock_page(vmpage);
                        put_page(vmpage);
-                        vmf->page = NULL;
+                       vmf->page = NULL;
 
-                        if (!printed && ++count > 16) {
-                                CWARN("the page is under heavy contention,"
-                                      "maybe your app(%s) needs revising :-)\n",
-                                      current->comm);
-                                printed = true;
-                        }
+                       if (!printed && ++count > 16) {
+                               CWARN("the page is under heavy contention, maybe your app(%s) needs revising :-)\n",
+                                     current->comm);
+                               printed = true;
+                       }
 
-                        goto restart;
-                }
+                       goto restart;
+               }
 
-                result |= VM_FAULT_LOCKED;
-        }
+               result |= VM_FAULT_LOCKED;
+       }
        cfs_restore_sigs(set);
-        return result;
+
+out:
+       if (vmf->page && result == VM_FAULT_LOCKED) {
+               ll_rw_stats_tally(ll_i2sbi(file_inode(vma->vm_file)),
+                                 current->pid, vma->vm_file->private_data,
+                                 cl_offset(NULL, vmf->page->index), PAGE_SIZE,
+                                 READ);
+               ll_stats_ops_tally(ll_i2sbi(file_inode(vma->vm_file)),
+                                  LPROC_LL_FAULT,
+                                  ktime_us_delta(ktime_get(), kstart));
+       }
+
+       return result;
 }
 
 #ifdef HAVE_VM_OPS_USE_VM_FAULT_ONLY
@@ -410,52 +419,60 @@ static vm_fault_t ll_page_mkwrite(struct vm_area_struct *vma,
        bool printed = false;
        bool retry;
        bool cached;
+       ktime_t kstart = ktime_get();
        vm_fault_t result;
 
-       ll_stats_ops_tally(ll_i2sbi(file_inode(vma->vm_file)),
-                          LPROC_LL_MKWRITE, 1);
-
        result = pcc_page_mkwrite(vma, vmf, &cached);
        if (cached)
-               return result;
+               goto out;
 
        file_update_time(vma->vm_file);
-        do {
-                retry = false;
-                result = ll_page_mkwrite0(vma, vmf->page, &retry);
+       do {
+               retry = false;
+               result = ll_page_mkwrite0(vma, vmf->page, &retry);
 
-                if (!printed && ++count > 16) {
+               if (!printed && ++count > 16) {
                        const struct dentry *de = file_dentry(vma->vm_file);
 
-                       CWARN("app(%s): the page %lu of file "DFID" is under"
-                             " heavy contention\n",
+                       CWARN("app(%s): the page %lu of file "DFID" is under heavy contention\n",
                              current->comm, vmf->pgoff,
                              PFID(ll_inode2fid(de->d_inode)));
-                        printed = true;
-                }
-        } while (retry);
-
-        switch(result) {
-        case 0:
-                LASSERT(PageLocked(vmf->page));
-                result = VM_FAULT_LOCKED;
-                break;
-        case -ENODATA:
-        case -EFAULT:
-                result = VM_FAULT_NOPAGE;
-                break;
-        case -ENOMEM:
-                result = VM_FAULT_OOM;
-                break;
-        case -EAGAIN:
-                result = VM_FAULT_RETRY;
-                break;
-        default:
-                result = VM_FAULT_SIGBUS;
-                break;
-        }
+                       printed = true;
+               }
+       } while (retry);
 
-        return result;
+       switch (result) {
+       case 0:
+               LASSERT(PageLocked(vmf->page));
+               result = VM_FAULT_LOCKED;
+               break;
+       case -ENODATA:
+       case -EFAULT:
+               result = VM_FAULT_NOPAGE;
+               break;
+       case -ENOMEM:
+               result = VM_FAULT_OOM;
+               break;
+       case -EAGAIN:
+               result = VM_FAULT_RETRY;
+               break;
+       default:
+               result = VM_FAULT_SIGBUS;
+               break;
+       }
+
+out:
+       if (result == VM_FAULT_LOCKED) {
+               ll_rw_stats_tally(ll_i2sbi(file_inode(vma->vm_file)),
+                                 current->pid, vma->vm_file->private_data,
+                                 cl_offset(NULL, vmf->page->index), PAGE_SIZE,
+                                 WRITE);
+               ll_stats_ops_tally(ll_i2sbi(file_inode(vma->vm_file)),
+                                  LPROC_LL_MKWRITE,
+                                  ktime_us_delta(ktime_get(), kstart));
+       }
+
+       return result;
 }
 
 /**
@@ -516,27 +533,31 @@ static const struct vm_operations_struct ll_file_vm_ops = {
 int ll_file_mmap(struct file *file, struct vm_area_struct * vma)
 {
        struct inode *inode = file_inode(file);
+       ktime_t kstart = ktime_get();
        bool cached;
-        int rc;
+       int rc;
 
-        ENTRY;
+       ENTRY;
 
-        if (ll_file_nolock(file))
-                RETURN(-EOPNOTSUPP);
+       if (ll_file_nolock(file))
+               RETURN(-EOPNOTSUPP);
 
        rc = pcc_file_mmap(file, vma, &cached);
        if (cached && rc != 0)
                RETURN(rc);
 
-        ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_MAP, 1);
-        rc = generic_file_mmap(file, vma);
-        if (rc == 0) {
+       rc = generic_file_mmap(file, vma);
+       if (rc == 0) {
                vma->vm_ops = &ll_file_vm_ops;
-                vma->vm_ops->open(vma);
-                /* update the inode's size and mtime */
+               vma->vm_ops->open(vma);
+               /* update the inode's size and mtime */
                if (!cached)
                        rc = ll_glimpse_size(inode);
-        }
+       }
 
-        RETURN(rc);
+       if (!rc)
+               ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_MMAP,
+                                  ktime_us_delta(ktime_get(), kstart));
+
+       RETURN(rc);
 }