fsnotify: generate pre-content permission event on page fault

FS_PRE_ACCESS will be generated on page fault depending on the faulting
method. This pre-content event is meant to be used by hierarchical storage
managers that want to fill in the file content on first read access.

Export a simple helper that file systems that have their own ->fault()
will use, and have a more complicated helper to be do fancy things in
filemap_fault.

Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Jan Kara <jack@suse.cz>
Link: https://patch.msgid.link/aa56c50ce81b1fd18d7f5d71dd2dfced5eba9687.1731684329.git.josef@toxicpanda.com

diff --git a/include/linux/mm.h b/include/linux/mm.h
index c39c4945946c6f7cc3401cec14bd382ca3cae3e8..e6c3c9cbcfe509f15cedb4183df65e263f9e83cc 100644 (file)
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -3420,6 +3420,7 @@ extern vm_fault_t filemap_fault(struct vm_fault *vmf);
 extern vm_fault_t filemap_map_pages(struct vm_fault *vmf,
                pgoff_t start_pgoff, pgoff_t end_pgoff);
 extern vm_fault_t filemap_page_mkwrite(struct vm_fault *vmf);
+extern vm_fault_t filemap_fsnotify_fault(struct vm_fault *vmf);
 
 extern unsigned long stack_guard_gap;
 /* Generic expand stack which grows the stack according to GROWS{UP,DOWN} */

diff --git a/mm/filemap.c b/mm/filemap.c
index e9a0f330d33ee0df58df428fbc03497d6466484a..6fdd5dc093c0a5114f4ffeebdf191078ebedbe2e 100644 (file)
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -47,6 +47,7 @@
 #include <linux/splice.h>
 #include <linux/rcupdate_wait.h>
 #include <linux/sched/mm.h>
+#include <linux/fsnotify.h>
 #include <asm/pgalloc.h>
 #include <asm/tlbflush.h>
 #include "internal.h"
@@ -3288,6 +3289,48 @@ static vm_fault_t filemap_fault_recheck_pte_none(struct vm_fault *vmf)
        return ret;
 }
 
+/**
+ * filemap_fsnotify_fault - maybe emit a pre-content event.
+ * @vmf:       struct vm_fault containing details of the fault.
+ *
+ * If we have a pre-content watch on this file we will emit an event for this
+ * range.  If we return anything the fault caller should return immediately, we
+ * will return VM_FAULT_RETRY if we had to emit an event, which will trigger the
+ * fault again and then the fault handler will run the second time through.
+ *
+ * Return: a bitwise-OR of %VM_FAULT_ codes, 0 if nothing happened.
+ */
+vm_fault_t filemap_fsnotify_fault(struct vm_fault *vmf)
+{
+       struct file *fpin = NULL;
+       int mask = (vmf->flags & FAULT_FLAG_WRITE) ? MAY_WRITE : MAY_ACCESS;
+       loff_t pos = vmf->pgoff >> PAGE_SHIFT;
+       size_t count = PAGE_SIZE;
+       int err;
+
+       /*
+        * We already did this and now we're retrying with everything locked,
+        * don't emit the event and continue.
+        */
+       if (vmf->flags & FAULT_FLAG_TRIED)
+               return 0;
+
+       /* No watches, we're done. */
+       if (likely(!FMODE_FSNOTIFY_HSM(vmf->vma->vm_file->f_mode)))
+               return 0;
+
+       fpin = maybe_unlock_mmap_for_io(vmf, fpin);
+       if (!fpin)
+               return VM_FAULT_SIGBUS;
+
+       err = fsnotify_file_area_perm(fpin, mask, &pos, count);
+       fput(fpin);
+       if (err)
+               return VM_FAULT_SIGBUS;
+       return VM_FAULT_RETRY;
+}
+EXPORT_SYMBOL_GPL(filemap_fsnotify_fault);
+
 /**
  * filemap_fault - read in file data for page fault handling
  * @vmf:       struct vm_fault containing details of the fault
@@ -3391,6 +3434,37 @@ retry_find:
         * or because readahead was otherwise unable to retrieve it.
         */
        if (unlikely(!folio_test_uptodate(folio))) {
+               /*
+                * If this is a precontent file we have can now emit an event to
+                * try and populate the folio.
+                */
+               if (!(vmf->flags & FAULT_FLAG_TRIED) &&
+                   unlikely(FMODE_FSNOTIFY_HSM(file->f_mode))) {
+                       loff_t pos = folio_pos(folio);
+                       size_t count = folio_size(folio);
+
+                       /* We're NOWAIT, we have to retry. */
+                       if (vmf->flags & FAULT_FLAG_RETRY_NOWAIT) {
+                               folio_unlock(folio);
+                               goto out_retry;
+                       }
+
+                       if (mapping_locked)
+                               filemap_invalidate_unlock_shared(mapping);
+                       mapping_locked = false;
+
+                       folio_unlock(folio);
+                       fpin = maybe_unlock_mmap_for_io(vmf, fpin);
+                       if (!fpin)
+                               goto out_retry;
+
+                       error = fsnotify_file_area_perm(fpin, MAY_ACCESS, &pos,
+                                                       count);
+                       if (error)
+                               ret = VM_FAULT_SIGBUS;
+                       goto out_retry;
+               }
+
                /*
                 * If the invalidate lock is not held, the folio was in cache
                 * and uptodate and now it is not. Strange but possible since we

diff --git a/mm/nommu.c b/mm/nommu.c
index 9cb6e99215e2b8e3821a6896e2d57aa42fb596cf..baa79abdaf037c92c0447169702424cf13357859 100644 (file)
--- a/mm/nommu.c
+++ b/mm/nommu.c
@@ -1613,6 +1613,13 @@ int remap_vmalloc_range(struct vm_area_struct *vma, void *addr,
 }
 EXPORT_SYMBOL(remap_vmalloc_range);
 
+vm_fault_t filemap_fsnotify_fault(struct vm_fault *vmf)
+{
+       BUG();
+       return 0;
+}
+EXPORT_SYMBOL_GPL(filemap_fsnotify_fault);
+
 vm_fault_t filemap_fault(struct vm_fault *vmf)
 {
        BUG();