LU-12631 llite: report latency for filesystem ops

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

diff --git a/lustre/llite/llite_mmap.c b/lustre/llite/llite_mmap.c
index 9dc934a..ead6b39 100644 (file)
--- a/lustre/llite/llite_mmap.c
+++ b/lustre/llite/llite_mmap.c
@@ -240,9 +240,6 @@ static inline int to_fault_error(int result)
        case 0:
                result = VM_FAULT_LOCKED;
                break;
-       case -EFAULT:
-               result = VM_FAULT_NOPAGE;
-               break;
        case -ENOMEM:
                result = VM_FAULT_OOM;
                break;
@@ -264,7 +261,7 @@ static inline int to_fault_error(int result)
  * \retval VM_FAULT_ERROR on general error
  * \retval NOPAGE_OOM not have memory for allocate new page
  */
-static int ll_fault0(struct vm_area_struct *vma, struct vm_fault *vmf)
+static vm_fault_t ll_fault0(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
        struct lu_env           *env;
        struct cl_io            *io;
@@ -343,29 +340,36 @@ out:
 }
 
 #ifdef HAVE_VM_OPS_USE_VM_FAULT_ONLY
-static int ll_fault(struct vm_fault *vmf)
+static vm_fault_t ll_fault(struct vm_fault *vmf)
 {
        struct vm_area_struct *vma = vmf->vma;
 #else
-static int ll_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
+static vm_fault_t ll_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
 #endif
        int count = 0;
        bool printed = false;
-       int result;
+       bool cached;
+       vm_fault_t result;
+       ktime_t kstart = ktime_get();
        sigset_t set;
 
+       result = pcc_fault(vma, vmf, &cached);
+       if (cached)
+               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
         * other signals. */
        set = cfs_block_sigsinv(sigmask(SIGKILL) | sigmask(SIGTERM));
 
-       ll_stats_ops_tally(ll_i2sbi(file_inode(vma->vm_file)),
-                          LPROC_LL_FAULT, 1);
-
+       /* make sure offset is not a negative number */
+       if (vmf->pgoff > (MAX_LFS_FILESIZE >> PAGE_SHIFT))
+               return VM_FAULT_SIGBUS;
 restart:
        result = ll_fault0(vma, vmf);
-       if (!(result & (VM_FAULT_RETRY | VM_FAULT_ERROR | VM_FAULT_LOCKED))) {
+       if (vmf->page &&
+           !(result & (VM_FAULT_RETRY | VM_FAULT_ERROR | VM_FAULT_LOCKED))) {
                 struct page *vmpage = vmf->page;
 
                 /* check if this page has been truncated */
@@ -388,31 +392,47 @@ restart:
                 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, LUSTRE_FPRIVATE(vma->vm_file),
+                                 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
-static int ll_page_mkwrite(struct vm_fault *vmf)
+static vm_fault_t ll_page_mkwrite(struct vm_fault *vmf)
 {
        struct vm_area_struct *vma = vmf->vma;
 #else
-static int ll_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
+static vm_fault_t ll_page_mkwrite(struct vm_area_struct *vma,
+                                 struct vm_fault *vmf)
 {
 #endif
        int count = 0;
        bool printed = false;
        bool retry;
-       int result;
+       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)
+               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"
@@ -443,7 +463,18 @@ static int ll_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
                 break;
         }
 
-        return result;
+out:
+       if (result == VM_FAULT_LOCKED) {
+               ll_rw_stats_tally(ll_i2sbi(file_inode(vma->vm_file)),
+                                 current->pid, LUSTRE_FPRIVATE(vma->vm_file),
+                                 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;
 }
 
 /**
@@ -458,6 +489,7 @@ static void ll_vm_open(struct vm_area_struct * vma)
        ENTRY;
        LASSERT(atomic_read(&vob->vob_mmap_cnt) >= 0);
        atomic_inc(&vob->vob_mmap_cnt);
+       pcc_vm_open(vma);
        EXIT;
 }
 
@@ -472,6 +504,7 @@ static void ll_vm_close(struct vm_area_struct *vma)
        ENTRY;
        atomic_dec(&vob->vob_mmap_cnt);
        LASSERT(atomic_read(&vob->vob_mmap_cnt) >= 0);
+       pcc_vm_close(vma);
        EXIT;
 }
 
@@ -486,7 +519,7 @@ int ll_teardown_mmaps(struct address_space *mapping, __u64 first, __u64 last)
         if (mapping_mapped(mapping)) {
                 rc = 0;
                unmap_mapping_range(mapping, first + PAGE_SIZE - 1,
-                                    last - first + 1, 0);
+                                   last - first + 1, 1);
         }
 
         RETURN(rc);
@@ -502,20 +535,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);
-        int rc;
-        ENTRY;
+       ktime_t kstart = ktime_get();
+       bool cached;
+       int rc;
 
-        if (ll_file_nolock(file))
-                RETURN(-EOPNOTSUPP);
-
-        ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_MAP, 1);
-        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 */
-                rc = ll_glimpse_size(inode);
-        }
+       ENTRY;
 
-        RETURN(rc);
+       if (ll_file_nolock(file))
+               RETURN(-EOPNOTSUPP);
+
+       rc = pcc_file_mmap(file, vma, &cached);
+       if (cached && rc != 0)
+               RETURN(rc);
+
+       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 */
+               if (!cached)
+                       rc = ll_glimpse_size(inode);
+       }
+
+       if (!rc)
+               ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_MMAP,
+                                  ktime_us_delta(ktime_get(), kstart));
+
+       RETURN(rc);
 }