mm: fixup pfnmap memory failure handling to use pgoff

The memory failure handling implementation for the PFNMAP memory with no
struct pages is faulty.  The VA of the mapping is determined based on the
the PFN.  It should instead be based on the file mapping offset.

At the occurrence of poison, the memory_failure_pfn is triggered on the
poisoned PFN.  Introduce a callback function that allows mm to translate
the PFN to the corresponding file page offset.  The kernel module using
the registration API must implement the callback function and provide the
translation.  The translated value is then used to determine the VA
information and sending the SIGBUS to the usermode process mapped to the
poisoned PFN.

The callback is also useful for the driver to be notified of the poisoned
PFN, which may then track it.

Link: https://lkml.kernel.org/r/20251211070603.338701-2-ankita@nvidia.com
Fixes: 2ec41967189c ("mm: handle poisoning of pfn without struct pages")
Signed-off-by: Ankit Agrawal <ankita@nvidia.com>
Suggested-by: Jason Gunthorpe <jgg@nvidia.com>
Cc: Kevin Tian <kevin.tian@intel.com>
Cc: Matthew R. Ochs <mochs@nvidia.com>
Cc: Miaohe Lin <linmiaohe@huawei.com>
Cc: Naoya Horiguchi <nao.horiguchi@gmail.com>
Cc: Neo Jia <cjia@nvidia.com>
Cc: Vikram Sethi <vsethi@nvidia.com>
Cc: Yishai Hadas <yishaih@nvidia.com>
Cc: Zhi Wang <zhiw@nvidia.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/include/linux/memory-failure.h b/include/linux/memory-failure.h
index bc326503d2d25fcd34e5307a6440f1549392818e..7b5e11cf905ffa71a2d9d3ca8c878cc97ed0b3b3 100644 (file)
--- a/include/linux/memory-failure.h
+++ b/include/linux/memory-failure.h
@@ -9,6 +9,8 @@ struct pfn_address_space;
 struct pfn_address_space {
        struct interval_tree_node node;
        struct address_space *mapping;
+       int (*pfn_to_vma_pgoff)(struct vm_area_struct *vma,
+                               unsigned long pfn, pgoff_t *pgoff);
 };
 
 int register_pfn_address_space(struct pfn_address_space *pfn_space);

diff --git a/mm/memory-failure.c b/mm/memory-failure.c
index fbc5a01260c89c309178954249ca45239ebb529a..c80c2907da3332e0210da7bbb1888634b2afd280 100644 (file)
--- a/mm/memory-failure.c
+++ b/mm/memory-failure.c
@@ -2161,6 +2161,9 @@ int register_pfn_address_space(struct pfn_address_space *pfn_space)
 {
        guard(mutex)(&pfn_space_lock);
 
+       if (!pfn_space->pfn_to_vma_pgoff)
+               return -EINVAL;
+
        if (interval_tree_iter_first(&pfn_space_itree,
                                     pfn_space->node.start,
                                     pfn_space->node.last))
@@ -2183,10 +2186,10 @@ void unregister_pfn_address_space(struct pfn_address_space *pfn_space)
 }
 EXPORT_SYMBOL_GPL(unregister_pfn_address_space);
 
-static void add_to_kill_pfn(struct task_struct *tsk,
-                           struct vm_area_struct *vma,
-                           struct list_head *to_kill,
-                           unsigned long pfn)
+static void add_to_kill_pgoff(struct task_struct *tsk,
+                             struct vm_area_struct *vma,
+                             struct list_head *to_kill,
+                             pgoff_t pgoff)
 {
        struct to_kill *tk;
 
@@ -2197,12 +2200,12 @@ static void add_to_kill_pfn(struct task_struct *tsk,
        }
 
        /* Check for pgoff not backed by struct page */
-       tk->addr = vma_address(vma, pfn, 1);
+       tk->addr = vma_address(vma, pgoff, 1);
        tk->size_shift = PAGE_SHIFT;
 
        if (tk->addr == -EFAULT)
                pr_info("Unable to find address %lx in %s\n",
-                       pfn, tsk->comm);
+                       pgoff, tsk->comm);
 
        get_task_struct(tsk);
        tk->tsk = tsk;
@@ -2212,11 +2215,12 @@ static void add_to_kill_pfn(struct task_struct *tsk,
 /*
  * Collect processes when the error hit a PFN not backed by struct page.
  */
-static void collect_procs_pfn(struct address_space *mapping,
+static void collect_procs_pfn(struct pfn_address_space *pfn_space,
                              unsigned long pfn, struct list_head *to_kill)
 {
        struct vm_area_struct *vma;
        struct task_struct *tsk;
+       struct address_space *mapping = pfn_space->mapping;
 
        i_mmap_lock_read(mapping);
        rcu_read_lock();
@@ -2226,9 +2230,12 @@ static void collect_procs_pfn(struct address_space *mapping,
                t = task_early_kill(tsk, true);
                if (!t)
                        continue;
-               vma_interval_tree_foreach(vma, &mapping->i_mmap, pfn, pfn) {
-                       if (vma->vm_mm == t->mm)
-                               add_to_kill_pfn(t, vma, to_kill, pfn);
+               vma_interval_tree_foreach(vma, &mapping->i_mmap, 0, ULONG_MAX) {
+                       pgoff_t pgoff;
+
+                       if (vma->vm_mm == t->mm &&
+                           !pfn_space->pfn_to_vma_pgoff(vma, pfn, &pgoff))
+                               add_to_kill_pgoff(t, vma, to_kill, pgoff);
                }
        }
        rcu_read_unlock();
@@ -2264,7 +2271,7 @@ static int memory_failure_pfn(unsigned long pfn, int flags)
                        struct pfn_address_space *pfn_space =
                                container_of(node, struct pfn_address_space, node);
 
-                       collect_procs_pfn(pfn_space->mapping, pfn, &tokill);
+                       collect_procs_pfn(pfn_space, pfn, &tokill);
 
                        mf_handled = true;
                }