diff mbox series

[04/10] mm, fsdax: Refactor memory-failure handler for dax mapping

Message ID 20201230165601.845024-5-ruansy.fnst@cn.fujitsu.com (mailing list archive)
State Superseded
Headers show
Series fsdax: introduce fs query to support reflink | expand

Commit Message

Ruan Shiyang Dec. 30, 2020, 4:55 p.m. UTC
The current memory_failure_dev_pagemap() can only handle single-mapped
dax page for fsdax mode.  The dax page could be mapped by multiple files
and offsets if we let reflink feature & fsdax mode work together.  So,
we refactor current implementation to support handle memory failure on
each file and offset.

Signed-off-by: Shiyang Ruan <ruansy.fnst@cn.fujitsu.com>
---
 fs/dax.c            | 21 +++++++++++
 include/linux/dax.h |  1 +
 include/linux/mm.h  |  9 +++++
 mm/memory-failure.c | 91 ++++++++++++++++++++++++++++++++++-----------
 4 files changed, 100 insertions(+), 22 deletions(-)

Comments

Jan Kara Jan. 6, 2021, 3:41 p.m. UTC | #1
On Thu 31-12-20 00:55:55, Shiyang Ruan wrote:
> The current memory_failure_dev_pagemap() can only handle single-mapped
> dax page for fsdax mode.  The dax page could be mapped by multiple files
> and offsets if we let reflink feature & fsdax mode work together.  So,
> we refactor current implementation to support handle memory failure on
> each file and offset.
> 
> Signed-off-by: Shiyang Ruan <ruansy.fnst@cn.fujitsu.com>

Overall this looks OK to me, a few comments below.

> ---
>  fs/dax.c            | 21 +++++++++++
>  include/linux/dax.h |  1 +
>  include/linux/mm.h  |  9 +++++
>  mm/memory-failure.c | 91 ++++++++++++++++++++++++++++++++++-----------
>  4 files changed, 100 insertions(+), 22 deletions(-)
> 
> diff --git a/fs/dax.c b/fs/dax.c
> index 5b47834f2e1b..799210cfa687 100644
> --- a/fs/dax.c
> +++ b/fs/dax.c
> @@ -378,6 +378,27 @@ static struct page *dax_busy_page(void *entry)
>  	return NULL;
>  }
>  
> +/*
> + * dax_load_pfn - Load pfn of the DAX entry corresponding to a page
> + * @mapping: The file whose entry we want to load
> + * @index:   The offset where the DAX entry located in
> + *
> + * Return:   pfn of the DAX entry
> + */
> +unsigned long dax_load_pfn(struct address_space *mapping, unsigned long index)
> +{
> +	XA_STATE(xas, &mapping->i_pages, index);
> +	void *entry;
> +	unsigned long pfn;
> +
> +	xas_lock_irq(&xas);
> +	entry = xas_load(&xas);
> +	pfn = dax_to_pfn(entry);
> +	xas_unlock_irq(&xas);
> +
> +	return pfn;
> +}
> +
>  /*
>   * dax_lock_mapping_entry - Lock the DAX entry corresponding to a page
>   * @page: The page whose entry we want to lock
> diff --git a/include/linux/dax.h b/include/linux/dax.h
> index b52f084aa643..89e56ceeffc7 100644
> --- a/include/linux/dax.h
> +++ b/include/linux/dax.h
> @@ -150,6 +150,7 @@ int dax_writeback_mapping_range(struct address_space *mapping,
>  
>  struct page *dax_layout_busy_page(struct address_space *mapping);
>  struct page *dax_layout_busy_page_range(struct address_space *mapping, loff_t start, loff_t end);
> +unsigned long dax_load_pfn(struct address_space *mapping, unsigned long index);
>  dax_entry_t dax_lock_page(struct page *page);
>  void dax_unlock_page(struct page *page, dax_entry_t cookie);
>  #else
> diff --git a/include/linux/mm.h b/include/linux/mm.h
> index db6ae4d3fb4e..db3059a1853e 100644
> --- a/include/linux/mm.h
> +++ b/include/linux/mm.h
> @@ -1141,6 +1141,14 @@ static inline bool is_device_private_page(const struct page *page)
>  		page->pgmap->type == MEMORY_DEVICE_PRIVATE;
>  }
>  
> +static inline bool is_device_fsdax_page(const struct page *page)
> +{
> +	return IS_ENABLED(CONFIG_DEV_PAGEMAP_OPS) &&
> +		IS_ENABLED(CONFIG_DEVICE_PRIVATE) &&
> +		is_zone_device_page(page) &&
> +		page->pgmap->type == MEMORY_DEVICE_FS_DAX;
> +}
> +
>  static inline bool is_pci_p2pdma_page(const struct page *page)
>  {
>  	return IS_ENABLED(CONFIG_DEV_PAGEMAP_OPS) &&
> @@ -3030,6 +3038,7 @@ enum mf_flags {
>  	MF_MUST_KILL = 1 << 2,
>  	MF_SOFT_OFFLINE = 1 << 3,
>  };
> +extern int mf_dax_mapping_kill_procs(struct address_space *mapping, pgoff_t index, int flags);
>  extern int memory_failure(unsigned long pfn, int flags);
>  extern void memory_failure_queue(unsigned long pfn, int flags);
>  extern void memory_failure_queue_kick(int cpu);
> diff --git a/mm/memory-failure.c b/mm/memory-failure.c
> index 5d880d4eb9a2..37bc6e2a9564 100644
> --- a/mm/memory-failure.c
> +++ b/mm/memory-failure.c
> @@ -56,6 +56,7 @@
>  #include <linux/kfifo.h>
>  #include <linux/ratelimit.h>
>  #include <linux/page-isolation.h>
> +#include <linux/dax.h>
>  #include "internal.h"
>  #include "ras/ras_event.h"
>  
> @@ -120,6 +121,9 @@ static int hwpoison_filter_dev(struct page *p)
>  	if (PageSlab(p))
>  		return -EINVAL;
>  
> +	if (is_device_fsdax_page(p))
> +		return 0;
> +
>  	mapping = page_mapping(p);
>  	if (mapping == NULL || mapping->host == NULL)
>  		return -EINVAL;
> @@ -290,9 +294,8 @@ void shake_page(struct page *p, int access)
>  EXPORT_SYMBOL_GPL(shake_page);
>  
>  static unsigned long dev_pagemap_mapping_shift(struct page *page,
> -		struct vm_area_struct *vma)
> +		struct vm_area_struct *vma, unsigned long address)

The 'page' argument is now unused. Drop it?

>  {
> -	unsigned long address = vma_address(page, vma);
>  	pgd_t *pgd;
>  	p4d_t *p4d;
>  	pud_t *pud;
> @@ -333,8 +336,8 @@ static unsigned long dev_pagemap_mapping_shift(struct page *page,
>   * Uses GFP_ATOMIC allocations to avoid potential recursions in the VM.
>   */
>  static void add_to_kill(struct task_struct *tsk, struct page *p,
> -		       struct vm_area_struct *vma,
> -		       struct list_head *to_kill)
> +			struct address_space *mapping, pgoff_t pgoff,
> +			struct vm_area_struct *vma, struct list_head *to_kill)
>  {
>  	struct to_kill *tk;
>  
> @@ -345,9 +348,12 @@ static void add_to_kill(struct task_struct *tsk, struct page *p,
>  	}
>  
>  	tk->addr = page_address_in_vma(p, vma);
> -	if (is_zone_device_page(p))
> -		tk->size_shift = dev_pagemap_mapping_shift(p, vma);
> -	else
> +	if (is_zone_device_page(p)) {
> +		if (is_device_fsdax_page(p))
> +			tk->addr = vma->vm_start +
> +					((pgoff - vma->vm_pgoff) << PAGE_SHIFT);

It seems strange to use 'pgoff' for dax pages and not for any other page.
Why? I'd rather pass correct pgoff from all callers of add_to_kill() and
avoid this special casing...

> +		tk->size_shift = dev_pagemap_mapping_shift(p, vma, tk->addr);
> +	} else
>  		tk->size_shift = page_shift(compound_head(p));
>  
>  	/*
> @@ -495,7 +501,7 @@ static void collect_procs_anon(struct page *page, struct list_head *to_kill,
>  			if (!page_mapped_in_vma(page, vma))
>  				continue;
>  			if (vma->vm_mm == t->mm)
> -				add_to_kill(t, page, vma, to_kill);
> +				add_to_kill(t, page, NULL, 0, vma, to_kill);
>  		}
>  	}
>  	read_unlock(&tasklist_lock);
> @@ -505,24 +511,19 @@ static void collect_procs_anon(struct page *page, struct list_head *to_kill,
>  /*
>   * Collect processes when the error hit a file mapped page.
>   */
> -static void collect_procs_file(struct page *page, struct list_head *to_kill,
> -				int force_early)
> +static void collect_procs_file(struct page *page, struct address_space *mapping,
> +		pgoff_t pgoff, struct list_head *to_kill, int force_early)
>  {
>  	struct vm_area_struct *vma;
>  	struct task_struct *tsk;
> -	struct address_space *mapping = page->mapping;
> -	pgoff_t pgoff;
>  
>  	i_mmap_lock_read(mapping);
>  	read_lock(&tasklist_lock);
> -	pgoff = page_to_pgoff(page);
>  	for_each_process(tsk) {
>  		struct task_struct *t = task_early_kill(tsk, force_early);
> -
>  		if (!t)
>  			continue;
> -		vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff,
> -				      pgoff) {
> +		vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff, pgoff) {
>  			/*
>  			 * Send early kill signal to tasks where a vma covers
>  			 * the page but the corrupted page is not necessarily
> @@ -531,7 +532,7 @@ static void collect_procs_file(struct page *page, struct list_head *to_kill,
>  			 * to be informed of all such data corruptions.
>  			 */
>  			if (vma->vm_mm == t->mm)
> -				add_to_kill(t, page, vma, to_kill);
> +				add_to_kill(t, page, mapping, pgoff, vma, to_kill);
>  		}
>  	}
>  	read_unlock(&tasklist_lock);
> @@ -550,7 +551,8 @@ static void collect_procs(struct page *page, struct list_head *tokill,
>  	if (PageAnon(page))
>  		collect_procs_anon(page, tokill, force_early);
>  	else
> -		collect_procs_file(page, tokill, force_early);
> +		collect_procs_file(page, page->mapping, page_to_pgoff(page),

Why not use page_mapping() helper here? It would be safer for THPs if they
ever get here...

								Honza
Ruan Shiyang Jan. 12, 2021, 2:55 a.m. UTC | #2
On 2021/1/6 下午11:41, Jan Kara wrote:
> On Thu 31-12-20 00:55:55, Shiyang Ruan wrote:
>> The current memory_failure_dev_pagemap() can only handle single-mapped
>> dax page for fsdax mode.  The dax page could be mapped by multiple files
>> and offsets if we let reflink feature & fsdax mode work together.  So,
>> we refactor current implementation to support handle memory failure on
>> each file and offset.
>>
>> Signed-off-by: Shiyang Ruan <ruansy.fnst@cn.fujitsu.com>
> 
> Overall this looks OK to me, a few comments below.
> 
>> ---
>>   fs/dax.c            | 21 +++++++++++
>>   include/linux/dax.h |  1 +
>>   include/linux/mm.h  |  9 +++++
>>   mm/memory-failure.c | 91 ++++++++++++++++++++++++++++++++++-----------
>>   4 files changed, 100 insertions(+), 22 deletions(-)

...

>>   
>> @@ -345,9 +348,12 @@ static void add_to_kill(struct task_struct *tsk, struct page *p,
>>   	}
>>   
>>   	tk->addr = page_address_in_vma(p, vma);
>> -	if (is_zone_device_page(p))
>> -		tk->size_shift = dev_pagemap_mapping_shift(p, vma);
>> -	else
>> +	if (is_zone_device_page(p)) {
>> +		if (is_device_fsdax_page(p))
>> +			tk->addr = vma->vm_start +
>> +					((pgoff - vma->vm_pgoff) << PAGE_SHIFT);
> 
> It seems strange to use 'pgoff' for dax pages and not for any other page.
> Why? I'd rather pass correct pgoff from all callers of add_to_kill() and
> avoid this special casing...

Because one fsdax page can be shared by multiple pgoffs.  I have to pass 
each pgoff in each iteration to calculate the address in vma (for 
tk->addr).  Other kinds of pages don't need this.  They can get their 
unique address by calling "page_address_in_vma()".

So, I added this fsdax case here.  This patchset only implemented the 
fsdax case, other cases also need to be added here if to be implemented.


--
Thanks,
Ruan Shiyang.

> 
>> +		tk->size_shift = dev_pagemap_mapping_shift(p, vma, tk->addr);
>> +	} else
>>   		tk->size_shift = page_shift(compound_head(p));
>>   
>>   	/*
>> @@ -495,7 +501,7 @@ static void collect_procs_anon(struct page *page, struct list_head *to_kill,
>>   			if (!page_mapped_in_vma(page, vma))
>>   				continue;
>>   			if (vma->vm_mm == t->mm)
>> -				add_to_kill(t, page, vma, to_kill);
>> +				add_to_kill(t, page, NULL, 0, vma, to_kill);
>>   		}
>>   	}
>>   	read_unlock(&tasklist_lock);
>> @@ -505,24 +511,19 @@ static void collect_procs_anon(struct page *page, struct list_head *to_kill,
>>   /*
>>    * Collect processes when the error hit a file mapped page.
>>    */
>> -static void collect_procs_file(struct page *page, struct list_head *to_kill,
>> -				int force_early)
>> +static void collect_procs_file(struct page *page, struct address_space *mapping,
>> +		pgoff_t pgoff, struct list_head *to_kill, int force_early)
>>   {
>>   	struct vm_area_struct *vma;
>>   	struct task_struct *tsk;
>> -	struct address_space *mapping = page->mapping;
>> -	pgoff_t pgoff;
>>   
>>   	i_mmap_lock_read(mapping);
>>   	read_lock(&tasklist_lock);
>> -	pgoff = page_to_pgoff(page);
>>   	for_each_process(tsk) {
>>   		struct task_struct *t = task_early_kill(tsk, force_early);
>> -
>>   		if (!t)
>>   			continue;
>> -		vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff,
>> -				      pgoff) {
>> +		vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff, pgoff) {
>>   			/*
>>   			 * Send early kill signal to tasks where a vma covers
>>   			 * the page but the corrupted page is not necessarily
>> @@ -531,7 +532,7 @@ static void collect_procs_file(struct page *page, struct list_head *to_kill,
>>   			 * to be informed of all such data corruptions.
>>   			 */
>>   			if (vma->vm_mm == t->mm)
>> -				add_to_kill(t, page, vma, to_kill);
>> +				add_to_kill(t, page, mapping, pgoff, vma, to_kill);
>>   		}
>>   	}
>>   	read_unlock(&tasklist_lock);
>> @@ -550,7 +551,8 @@ static void collect_procs(struct page *page, struct list_head *tokill,
>>   	if (PageAnon(page))
>>   		collect_procs_anon(page, tokill, force_early);
>>   	else
>> -		collect_procs_file(page, tokill, force_early);
>> +		collect_procs_file(page, page->mapping, page_to_pgoff(page),
> 
> Why not use page_mapping() helper here? It would be safer for THPs if they
> ever get here...
> 
> 								Honza
>
zhongjiang-ali Jan. 13, 2021, 10:04 a.m. UTC | #3
On 2021/1/12 10:55 上午, Ruan Shiyang wrote:
>
>
> On 2021/1/6 下午11:41, Jan Kara wrote:
>> On Thu 31-12-20 00:55:55, Shiyang Ruan wrote:
>>> The current memory_failure_dev_pagemap() can only handle single-mapped
>>> dax page for fsdax mode.  The dax page could be mapped by multiple 
>>> files
>>> and offsets if we let reflink feature & fsdax mode work together.  So,
>>> we refactor current implementation to support handle memory failure on
>>> each file and offset.
>>>
>>> Signed-off-by: Shiyang Ruan <ruansy.fnst@cn.fujitsu.com>
>>
>> Overall this looks OK to me, a few comments below.
>>
>>> ---
>>>   fs/dax.c            | 21 +++++++++++
>>>   include/linux/dax.h |  1 +
>>>   include/linux/mm.h  |  9 +++++
>>>   mm/memory-failure.c | 91 
>>> ++++++++++++++++++++++++++++++++++-----------
>>>   4 files changed, 100 insertions(+), 22 deletions(-)
>
> ...
>
>>>   @@ -345,9 +348,12 @@ static void add_to_kill(struct task_struct 
>>> *tsk, struct page *p,
>>>       }
>>>         tk->addr = page_address_in_vma(p, vma);
>>> -    if (is_zone_device_page(p))
>>> -        tk->size_shift = dev_pagemap_mapping_shift(p, vma);
>>> -    else
>>> +    if (is_zone_device_page(p)) {
>>> +        if (is_device_fsdax_page(p))
>>> +            tk->addr = vma->vm_start +
>>> +                    ((pgoff - vma->vm_pgoff) << PAGE_SHIFT);
>>
>> It seems strange to use 'pgoff' for dax pages and not for any other 
>> page.
>> Why? I'd rather pass correct pgoff from all callers of add_to_kill() and
>> avoid this special casing...
>
> Because one fsdax page can be shared by multiple pgoffs.  I have to 
> pass each pgoff in each iteration to calculate the address in vma (for 
> tk->addr).  Other kinds of pages don't need this. They can get their 
> unique address by calling "page_address_in_vma()".
>
IMO,   an fsdax page can be shared by multiple files rather than 
multiple pgoffs if fs query support reflink.   Because an page only 
located in an mapping(page->mapping is exclusive),  hence it  only has 
an pgoff or index pointing at the node.

  or  I miss something for the feature ?  thanks,

> So, I added this fsdax case here.  This patchset only implemented the 
> fsdax case, other cases also need to be added here if to be implemented.
>
>
> -- 
> Thanks,
> Ruan Shiyang.
>
>>
>>> +        tk->size_shift = dev_pagemap_mapping_shift(p, vma, tk->addr);
>>> +    } else
>>>           tk->size_shift = page_shift(compound_head(p));
>>>         /*
>>> @@ -495,7 +501,7 @@ static void collect_procs_anon(struct page 
>>> *page, struct list_head *to_kill,
>>>               if (!page_mapped_in_vma(page, vma))
>>>                   continue;
>>>               if (vma->vm_mm == t->mm)
>>> -                add_to_kill(t, page, vma, to_kill);
>>> +                add_to_kill(t, page, NULL, 0, vma, to_kill);
>>>           }
>>>       }
>>>       read_unlock(&tasklist_lock);
>>> @@ -505,24 +511,19 @@ static void collect_procs_anon(struct page 
>>> *page, struct list_head *to_kill,
>>>   /*
>>>    * Collect processes when the error hit a file mapped page.
>>>    */
>>> -static void collect_procs_file(struct page *page, struct list_head 
>>> *to_kill,
>>> -                int force_early)
>>> +static void collect_procs_file(struct page *page, struct 
>>> address_space *mapping,
>>> +        pgoff_t pgoff, struct list_head *to_kill, int force_early)
>>>   {
>>>       struct vm_area_struct *vma;
>>>       struct task_struct *tsk;
>>> -    struct address_space *mapping = page->mapping;
>>> -    pgoff_t pgoff;
>>>         i_mmap_lock_read(mapping);
>>>       read_lock(&tasklist_lock);
>>> -    pgoff = page_to_pgoff(page);
>>>       for_each_process(tsk) {
>>>           struct task_struct *t = task_early_kill(tsk, force_early);
>>> -
>>>           if (!t)
>>>               continue;
>>> -        vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff,
>>> -                      pgoff) {
>>> +        vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff, 
>>> pgoff) {
>>>               /*
>>>                * Send early kill signal to tasks where a vma covers
>>>                * the page but the corrupted page is not necessarily
>>> @@ -531,7 +532,7 @@ static void collect_procs_file(struct page 
>>> *page, struct list_head *to_kill,
>>>                * to be informed of all such data corruptions.
>>>                */
>>>               if (vma->vm_mm == t->mm)
>>> -                add_to_kill(t, page, vma, to_kill);
>>> +                add_to_kill(t, page, mapping, pgoff, vma, to_kill);
>>>           }
>>>       }
>>>       read_unlock(&tasklist_lock);
>>> @@ -550,7 +551,8 @@ static void collect_procs(struct page *page, 
>>> struct list_head *tokill,
>>>       if (PageAnon(page))
>>>           collect_procs_anon(page, tokill, force_early);
>>>       else
>>> -        collect_procs_file(page, tokill, force_early);
>>> +        collect_procs_file(page, page->mapping, page_to_pgoff(page),
>>
>> Why not use page_mapping() helper here? It would be safer for THPs if 
>> they
>> ever get here...
>>
>>                                 Honza
>>
>
Ruan Shiyang Jan. 14, 2021, 1:44 a.m. UTC | #4
On 2021/1/13 下午6:04, zhong jiang wrote:
> 
> On 2021/1/12 10:55 上午, Ruan Shiyang wrote:
>>
>>
>> On 2021/1/6 下午11:41, Jan Kara wrote:
>>> On Thu 31-12-20 00:55:55, Shiyang Ruan wrote:
>>>> The current memory_failure_dev_pagemap() can only handle single-mapped
>>>> dax page for fsdax mode.  The dax page could be mapped by multiple 
>>>> files
>>>> and offsets if we let reflink feature & fsdax mode work together.  So,
>>>> we refactor current implementation to support handle memory failure on
>>>> each file and offset.
>>>>
>>>> Signed-off-by: Shiyang Ruan <ruansy.fnst@cn.fujitsu.com>
>>>
>>> Overall this looks OK to me, a few comments below.
>>>
>>>> ---
>>>>   fs/dax.c            | 21 +++++++++++
>>>>   include/linux/dax.h |  1 +
>>>>   include/linux/mm.h  |  9 +++++
>>>>   mm/memory-failure.c | 91 
>>>> ++++++++++++++++++++++++++++++++++-----------
>>>>   4 files changed, 100 insertions(+), 22 deletions(-)
>>
>> ...
>>
>>>>   @@ -345,9 +348,12 @@ static void add_to_kill(struct task_struct 
>>>> *tsk, struct page *p,
>>>>       }
>>>>         tk->addr = page_address_in_vma(p, vma);
>>>> -    if (is_zone_device_page(p))
>>>> -        tk->size_shift = dev_pagemap_mapping_shift(p, vma);
>>>> -    else
>>>> +    if (is_zone_device_page(p)) {
>>>> +        if (is_device_fsdax_page(p))
>>>> +            tk->addr = vma->vm_start +
>>>> +                    ((pgoff - vma->vm_pgoff) << PAGE_SHIFT);
>>>
>>> It seems strange to use 'pgoff' for dax pages and not for any other 
>>> page.
>>> Why? I'd rather pass correct pgoff from all callers of add_to_kill() and
>>> avoid this special casing...
>>
>> Because one fsdax page can be shared by multiple pgoffs.  I have to 
>> pass each pgoff in each iteration to calculate the address in vma (for 
>> tk->addr).  Other kinds of pages don't need this. They can get their 
>> unique address by calling "page_address_in_vma()".
>>
> IMO,   an fsdax page can be shared by multiple files rather than 
> multiple pgoffs if fs query support reflink.   Because an page only 
> located in an mapping(page->mapping is exclusive),  hence it  only has 
> an pgoff or index pointing at the node.
> 
>   or  I miss something for the feature ?  thanks,

Yes, a fsdax page is shared by multiple files because of reflink.  I 
think my description of 'pgoff' here is not correct.  This 'pgoff' means 
the offset within the a file.  (We use rmap to find out all the sharing 
files and their offsets.)  So, I said that "can be shared by multiple 
pgoffs".  It's my bad.

I think I should name it another word to avoid misunderstandings.


--
Thanks,
Ruan Shiyang.

> 
>> So, I added this fsdax case here.  This patchset only implemented the 
>> fsdax case, other cases also need to be added here if to be implemented.
>>
>>
>> -- 
>> Thanks,
>> Ruan Shiyang.
>>
>>>
>>>> +        tk->size_shift = dev_pagemap_mapping_shift(p, vma, tk->addr);
>>>> +    } else
>>>>           tk->size_shift = page_shift(compound_head(p));
>>>>         /*
>>>> @@ -495,7 +501,7 @@ static void collect_procs_anon(struct page 
>>>> *page, struct list_head *to_kill,
>>>>               if (!page_mapped_in_vma(page, vma))
>>>>                   continue;
>>>>               if (vma->vm_mm == t->mm)
>>>> -                add_to_kill(t, page, vma, to_kill);
>>>> +                add_to_kill(t, page, NULL, 0, vma, to_kill);
>>>>           }
>>>>       }
>>>>       read_unlock(&tasklist_lock);
>>>> @@ -505,24 +511,19 @@ static void collect_procs_anon(struct page 
>>>> *page, struct list_head *to_kill,
>>>>   /*
>>>>    * Collect processes when the error hit a file mapped page.
>>>>    */
>>>> -static void collect_procs_file(struct page *page, struct list_head 
>>>> *to_kill,
>>>> -                int force_early)
>>>> +static void collect_procs_file(struct page *page, struct 
>>>> address_space *mapping,
>>>> +        pgoff_t pgoff, struct list_head *to_kill, int force_early)
>>>>   {
>>>>       struct vm_area_struct *vma;
>>>>       struct task_struct *tsk;
>>>> -    struct address_space *mapping = page->mapping;
>>>> -    pgoff_t pgoff;
>>>>         i_mmap_lock_read(mapping);
>>>>       read_lock(&tasklist_lock);
>>>> -    pgoff = page_to_pgoff(page);
>>>>       for_each_process(tsk) {
>>>>           struct task_struct *t = task_early_kill(tsk, force_early);
>>>> -
>>>>           if (!t)
>>>>               continue;
>>>> -        vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff,
>>>> -                      pgoff) {
>>>> +        vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff, 
>>>> pgoff) {
>>>>               /*
>>>>                * Send early kill signal to tasks where a vma covers
>>>>                * the page but the corrupted page is not necessarily
>>>> @@ -531,7 +532,7 @@ static void collect_procs_file(struct page 
>>>> *page, struct list_head *to_kill,
>>>>                * to be informed of all such data corruptions.
>>>>                */
>>>>               if (vma->vm_mm == t->mm)
>>>> -                add_to_kill(t, page, vma, to_kill);
>>>> +                add_to_kill(t, page, mapping, pgoff, vma, to_kill);
>>>>           }
>>>>       }
>>>>       read_unlock(&tasklist_lock);
>>>> @@ -550,7 +551,8 @@ static void collect_procs(struct page *page, 
>>>> struct list_head *tokill,
>>>>       if (PageAnon(page))
>>>>           collect_procs_anon(page, tokill, force_early);
>>>>       else
>>>> -        collect_procs_file(page, tokill, force_early);
>>>> +        collect_procs_file(page, page->mapping, page_to_pgoff(page),
>>>
>>> Why not use page_mapping() helper here? It would be safer for THPs if 
>>> they
>>> ever get here...
>>>
>>>                                 Honza
>>>
>>
> 
>
zhongjiang-ali Jan. 14, 2021, 3:26 a.m. UTC | #5
On 2021/1/14 9:44 上午, Ruan Shiyang wrote:
>
>
> On 2021/1/13 下午6:04, zhong jiang wrote:
>>
>> On 2021/1/12 10:55 上午, Ruan Shiyang wrote:
>>>
>>>
>>> On 2021/1/6 下午11:41, Jan Kara wrote:
>>>> On Thu 31-12-20 00:55:55, Shiyang Ruan wrote:
>>>>> The current memory_failure_dev_pagemap() can only handle 
>>>>> single-mapped
>>>>> dax page for fsdax mode.  The dax page could be mapped by multiple 
>>>>> files
>>>>> and offsets if we let reflink feature & fsdax mode work together.  
>>>>> So,
>>>>> we refactor current implementation to support handle memory 
>>>>> failure on
>>>>> each file and offset.
>>>>>
>>>>> Signed-off-by: Shiyang Ruan <ruansy.fnst@cn.fujitsu.com>
>>>>
>>>> Overall this looks OK to me, a few comments below.
>>>>
>>>>> ---
>>>>>   fs/dax.c            | 21 +++++++++++
>>>>>   include/linux/dax.h |  1 +
>>>>>   include/linux/mm.h  |  9 +++++
>>>>>   mm/memory-failure.c | 91 
>>>>> ++++++++++++++++++++++++++++++++++-----------
>>>>>   4 files changed, 100 insertions(+), 22 deletions(-)
>>>
>>> ...
>>>
>>>>>   @@ -345,9 +348,12 @@ static void add_to_kill(struct task_struct 
>>>>> *tsk, struct page *p,
>>>>>       }
>>>>>         tk->addr = page_address_in_vma(p, vma);
>>>>> -    if (is_zone_device_page(p))
>>>>> -        tk->size_shift = dev_pagemap_mapping_shift(p, vma);
>>>>> -    else
>>>>> +    if (is_zone_device_page(p)) {
>>>>> +        if (is_device_fsdax_page(p))
>>>>> +            tk->addr = vma->vm_start +
>>>>> +                    ((pgoff - vma->vm_pgoff) << PAGE_SHIFT);
>>>>
>>>> It seems strange to use 'pgoff' for dax pages and not for any other 
>>>> page.
>>>> Why? I'd rather pass correct pgoff from all callers of 
>>>> add_to_kill() and
>>>> avoid this special casing...
>>>
>>> Because one fsdax page can be shared by multiple pgoffs.  I have to 
>>> pass each pgoff in each iteration to calculate the address in vma 
>>> (for tk->addr).  Other kinds of pages don't need this. They can get 
>>> their unique address by calling "page_address_in_vma()".
>>>
>> IMO,   an fsdax page can be shared by multiple files rather than 
>> multiple pgoffs if fs query support reflink.   Because an page only 
>> located in an mapping(page->mapping is exclusive), hence it  only has 
>> an pgoff or index pointing at the node.
>>
>>   or  I miss something for the feature ?  thanks,
>
> Yes, a fsdax page is shared by multiple files because of reflink. I 
> think my description of 'pgoff' here is not correct.  This 'pgoff' 
> means the offset within the a file.  (We use rmap to find out all the 
> sharing files and their offsets.)  So, I said that "can be shared by 
> multiple pgoffs".  It's my bad.
>
> I think I should name it another word to avoid misunderstandings.
>
IMO,  All the sharing files should be the same offset to share the fsdax 
page.  why not that ?  As you has said,  a shared fadax page should be 
inserted to different mapping files.  but page->index and page->mapping 
is exclusive.  hence an page only should be placed in an mapping tree.

And In the current patch,  we failed to found out that all process use 
the fsdax page shared by multiple files and kill them.


Thanks,

> -- 
> Thanks,
> Ruan Shiyang.
>
>>
>>> So, I added this fsdax case here.  This patchset only implemented 
>>> the fsdax case, other cases also need to be added here if to be 
>>> implemented.
>>>
>>>
>>> -- 
>>> Thanks,
>>> Ruan Shiyang.
>>>
>>>>
>>>>> +        tk->size_shift = dev_pagemap_mapping_shift(p, vma, 
>>>>> tk->addr);
>>>>> +    } else
>>>>>           tk->size_shift = page_shift(compound_head(p));
>>>>>         /*
>>>>> @@ -495,7 +501,7 @@ static void collect_procs_anon(struct page 
>>>>> *page, struct list_head *to_kill,
>>>>>               if (!page_mapped_in_vma(page, vma))
>>>>>                   continue;
>>>>>               if (vma->vm_mm == t->mm)
>>>>> -                add_to_kill(t, page, vma, to_kill);
>>>>> +                add_to_kill(t, page, NULL, 0, vma, to_kill);
>>>>>           }
>>>>>       }
>>>>>       read_unlock(&tasklist_lock);
>>>>> @@ -505,24 +511,19 @@ static void collect_procs_anon(struct page 
>>>>> *page, struct list_head *to_kill,
>>>>>   /*
>>>>>    * Collect processes when the error hit a file mapped page.
>>>>>    */
>>>>> -static void collect_procs_file(struct page *page, struct 
>>>>> list_head *to_kill,
>>>>> -                int force_early)
>>>>> +static void collect_procs_file(struct page *page, struct 
>>>>> address_space *mapping,
>>>>> +        pgoff_t pgoff, struct list_head *to_kill, int force_early)
>>>>>   {
>>>>>       struct vm_area_struct *vma;
>>>>>       struct task_struct *tsk;
>>>>> -    struct address_space *mapping = page->mapping;
>>>>> -    pgoff_t pgoff;
>>>>>         i_mmap_lock_read(mapping);
>>>>>       read_lock(&tasklist_lock);
>>>>> -    pgoff = page_to_pgoff(page);
>>>>>       for_each_process(tsk) {
>>>>>           struct task_struct *t = task_early_kill(tsk, force_early);
>>>>> -
>>>>>           if (!t)
>>>>>               continue;
>>>>> -        vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff,
>>>>> -                      pgoff) {
>>>>> +        vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff, 
>>>>> pgoff) {
>>>>>               /*
>>>>>                * Send early kill signal to tasks where a vma covers
>>>>>                * the page but the corrupted page is not necessarily
>>>>> @@ -531,7 +532,7 @@ static void collect_procs_file(struct page 
>>>>> *page, struct list_head *to_kill,
>>>>>                * to be informed of all such data corruptions.
>>>>>                */
>>>>>               if (vma->vm_mm == t->mm)
>>>>> -                add_to_kill(t, page, vma, to_kill);
>>>>> +                add_to_kill(t, page, mapping, pgoff, vma, to_kill);
>>>>>           }
>>>>>       }
>>>>>       read_unlock(&tasklist_lock);
>>>>> @@ -550,7 +551,8 @@ static void collect_procs(struct page *page, 
>>>>> struct list_head *tokill,
>>>>>       if (PageAnon(page))
>>>>>           collect_procs_anon(page, tokill, force_early);
>>>>>       else
>>>>> -        collect_procs_file(page, tokill, force_early);
>>>>> +        collect_procs_file(page, page->mapping, page_to_pgoff(page),
>>>>
>>>> Why not use page_mapping() helper here? It would be safer for THPs 
>>>> if they
>>>> ever get here...
>>>>
>>>>                                 Honza
>>>>
>>>
>>
>>
>
Ruan Shiyang Jan. 14, 2021, 3:52 a.m. UTC | #6
On 2021/1/14 上午11:26, zhong jiang wrote:
> 
> On 2021/1/14 9:44 上午, Ruan Shiyang wrote:
>>
>>
>> On 2021/1/13 下午6:04, zhong jiang wrote:
>>>
>>> On 2021/1/12 10:55 上午, Ruan Shiyang wrote:
>>>>
>>>>
>>>> On 2021/1/6 下午11:41, Jan Kara wrote:
>>>>> On Thu 31-12-20 00:55:55, Shiyang Ruan wrote:
>>>>>> The current memory_failure_dev_pagemap() can only handle 
>>>>>> single-mapped
>>>>>> dax page for fsdax mode.  The dax page could be mapped by multiple 
>>>>>> files
>>>>>> and offsets if we let reflink feature & fsdax mode work together. So,
>>>>>> we refactor current implementation to support handle memory 
>>>>>> failure on
>>>>>> each file and offset.
>>>>>>
>>>>>> Signed-off-by: Shiyang Ruan <ruansy.fnst@cn.fujitsu.com>
>>>>>
>>>>> Overall this looks OK to me, a few comments below.
>>>>>
>>>>>> ---
>>>>>>   fs/dax.c            | 21 +++++++++++
>>>>>>   include/linux/dax.h |  1 +
>>>>>>   include/linux/mm.h  |  9 +++++
>>>>>>   mm/memory-failure.c | 91 
>>>>>> ++++++++++++++++++++++++++++++++++-----------
>>>>>>   4 files changed, 100 insertions(+), 22 deletions(-)
>>>>
>>>> ...
>>>>
>>>>>>   @@ -345,9 +348,12 @@ static void add_to_kill(struct task_struct 
>>>>>> *tsk, struct page *p,
>>>>>>       }
>>>>>>         tk->addr = page_address_in_vma(p, vma);
>>>>>> -    if (is_zone_device_page(p))
>>>>>> -        tk->size_shift = dev_pagemap_mapping_shift(p, vma);
>>>>>> -    else
>>>>>> +    if (is_zone_device_page(p)) {
>>>>>> +        if (is_device_fsdax_page(p))
>>>>>> +            tk->addr = vma->vm_start +
>>>>>> +                    ((pgoff - vma->vm_pgoff) << PAGE_SHIFT);
>>>>>
>>>>> It seems strange to use 'pgoff' for dax pages and not for any other 
>>>>> page.
>>>>> Why? I'd rather pass correct pgoff from all callers of 
>>>>> add_to_kill() and
>>>>> avoid this special casing...
>>>>
>>>> Because one fsdax page can be shared by multiple pgoffs.  I have to 
>>>> pass each pgoff in each iteration to calculate the address in vma 
>>>> (for tk->addr).  Other kinds of pages don't need this. They can get 
>>>> their unique address by calling "page_address_in_vma()".
>>>>
>>> IMO,   an fsdax page can be shared by multiple files rather than 
>>> multiple pgoffs if fs query support reflink.   Because an page only 
>>> located in an mapping(page->mapping is exclusive), hence it  only has 
>>> an pgoff or index pointing at the node.
>>>
>>>   or  I miss something for the feature ?  thanks,
>>
>> Yes, a fsdax page is shared by multiple files because of reflink. I 
>> think my description of 'pgoff' here is not correct.  This 'pgoff' 
>> means the offset within the a file.  (We use rmap to find out all the 
>> sharing files and their offsets.)  So, I said that "can be shared by 
>> multiple pgoffs".  It's my bad.
>>
>> I think I should name it another word to avoid misunderstandings.
>>
> IMO,  All the sharing files should be the same offset to share the fsdax 
> page.  why not that ? 

The dedupe operation can let different files share their same data 
extent, though offsets are not same.  So, files can share one fsdax page 
at different offset.

> As you has said,  a shared fadax page should be 
> inserted to different mapping files.  but page->index and page->mapping 
> is exclusive.  hence an page only should be placed in an mapping tree.

We can't use page->mapping and page->index here for reflink & fsdax. 
And that's this patchset aims to solve.  I introduced a series of 
->corrupted_range(), from mm to pmem driver to block device and finally 
to filesystem, to use rmap feature of filesystem to find out all files 
sharing same data extent (fsdax page).


--
Thanks,
Ruan Shiyang.

> 
> And In the current patch,  we failed to found out that all process use 
> the fsdax page shared by multiple files and kill them.
> 
> 
> Thanks,
> 
>> -- 
>> Thanks,
>> Ruan Shiyang.
>>
>>>
>>>> So, I added this fsdax case here.  This patchset only implemented 
>>>> the fsdax case, other cases also need to be added here if to be 
>>>> implemented.
>>>>
>>>>
>>>> -- 
>>>> Thanks,
>>>> Ruan Shiyang.
>>>>
>>>>>
>>>>>> +        tk->size_shift = dev_pagemap_mapping_shift(p, vma, 
>>>>>> tk->addr);
>>>>>> +    } else
>>>>>>           tk->size_shift = page_shift(compound_head(p));
>>>>>>         /*
>>>>>> @@ -495,7 +501,7 @@ static void collect_procs_anon(struct page 
>>>>>> *page, struct list_head *to_kill,
>>>>>>               if (!page_mapped_in_vma(page, vma))
>>>>>>                   continue;
>>>>>>               if (vma->vm_mm == t->mm)
>>>>>> -                add_to_kill(t, page, vma, to_kill);
>>>>>> +                add_to_kill(t, page, NULL, 0, vma, to_kill);
>>>>>>           }
>>>>>>       }
>>>>>>       read_unlock(&tasklist_lock);
>>>>>> @@ -505,24 +511,19 @@ static void collect_procs_anon(struct page 
>>>>>> *page, struct list_head *to_kill,
>>>>>>   /*
>>>>>>    * Collect processes when the error hit a file mapped page.
>>>>>>    */
>>>>>> -static void collect_procs_file(struct page *page, struct 
>>>>>> list_head *to_kill,
>>>>>> -                int force_early)
>>>>>> +static void collect_procs_file(struct page *page, struct 
>>>>>> address_space *mapping,
>>>>>> +        pgoff_t pgoff, struct list_head *to_kill, int force_early)
>>>>>>   {
>>>>>>       struct vm_area_struct *vma;
>>>>>>       struct task_struct *tsk;
>>>>>> -    struct address_space *mapping = page->mapping;
>>>>>> -    pgoff_t pgoff;
>>>>>>         i_mmap_lock_read(mapping);
>>>>>>       read_lock(&tasklist_lock);
>>>>>> -    pgoff = page_to_pgoff(page);
>>>>>>       for_each_process(tsk) {
>>>>>>           struct task_struct *t = task_early_kill(tsk, force_early);
>>>>>> -
>>>>>>           if (!t)
>>>>>>               continue;
>>>>>> -        vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff,
>>>>>> -                      pgoff) {
>>>>>> +        vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff, 
>>>>>> pgoff) {
>>>>>>               /*
>>>>>>                * Send early kill signal to tasks where a vma covers
>>>>>>                * the page but the corrupted page is not necessarily
>>>>>> @@ -531,7 +532,7 @@ static void collect_procs_file(struct page 
>>>>>> *page, struct list_head *to_kill,
>>>>>>                * to be informed of all such data corruptions.
>>>>>>                */
>>>>>>               if (vma->vm_mm == t->mm)
>>>>>> -                add_to_kill(t, page, vma, to_kill);
>>>>>> +                add_to_kill(t, page, mapping, pgoff, vma, to_kill);
>>>>>>           }
>>>>>>       }
>>>>>>       read_unlock(&tasklist_lock);
>>>>>> @@ -550,7 +551,8 @@ static void collect_procs(struct page *page, 
>>>>>> struct list_head *tokill,
>>>>>>       if (PageAnon(page))
>>>>>>           collect_procs_anon(page, tokill, force_early);
>>>>>>       else
>>>>>> -        collect_procs_file(page, tokill, force_early);
>>>>>> +        collect_procs_file(page, page->mapping, page_to_pgoff(page),
>>>>>
>>>>> Why not use page_mapping() helper here? It would be safer for THPs 
>>>>> if they
>>>>> ever get here...
>>>>>
>>>>>                                 Honza
>>>>>
>>>>
>>>
>>>
>>
> 
>
zhongjiang-ali Jan. 14, 2021, 9:38 a.m. UTC | #7
On 2021/1/14 11:52 上午, Ruan Shiyang wrote:
>
>
> On 2021/1/14 上午11:26, zhong jiang wrote:
>>
>> On 2021/1/14 9:44 上午, Ruan Shiyang wrote:
>>>
>>>
>>> On 2021/1/13 下午6:04, zhong jiang wrote:
>>>>
>>>> On 2021/1/12 10:55 上午, Ruan Shiyang wrote:
>>>>>
>>>>>
>>>>> On 2021/1/6 下午11:41, Jan Kara wrote:
>>>>>> On Thu 31-12-20 00:55:55, Shiyang Ruan wrote:
>>>>>>> The current memory_failure_dev_pagemap() can only handle 
>>>>>>> single-mapped
>>>>>>> dax page for fsdax mode.  The dax page could be mapped by 
>>>>>>> multiple files
>>>>>>> and offsets if we let reflink feature & fsdax mode work 
>>>>>>> together. So,
>>>>>>> we refactor current implementation to support handle memory 
>>>>>>> failure on
>>>>>>> each file and offset.
>>>>>>>
>>>>>>> Signed-off-by: Shiyang Ruan <ruansy.fnst@cn.fujitsu.com>
>>>>>>
>>>>>> Overall this looks OK to me, a few comments below.
>>>>>>
>>>>>>> ---
>>>>>>>   fs/dax.c            | 21 +++++++++++
>>>>>>>   include/linux/dax.h |  1 +
>>>>>>>   include/linux/mm.h  |  9 +++++
>>>>>>>   mm/memory-failure.c | 91 
>>>>>>> ++++++++++++++++++++++++++++++++++-----------
>>>>>>>   4 files changed, 100 insertions(+), 22 deletions(-)
>>>>>
>>>>> ...
>>>>>
>>>>>>>   @@ -345,9 +348,12 @@ static void add_to_kill(struct 
>>>>>>> task_struct *tsk, struct page *p,
>>>>>>>       }
>>>>>>>         tk->addr = page_address_in_vma(p, vma);
>>>>>>> -    if (is_zone_device_page(p))
>>>>>>> -        tk->size_shift = dev_pagemap_mapping_shift(p, vma);
>>>>>>> -    else
>>>>>>> +    if (is_zone_device_page(p)) {
>>>>>>> +        if (is_device_fsdax_page(p))
>>>>>>> +            tk->addr = vma->vm_start +
>>>>>>> +                    ((pgoff - vma->vm_pgoff) << PAGE_SHIFT);
>>>>>>
>>>>>> It seems strange to use 'pgoff' for dax pages and not for any 
>>>>>> other page.
>>>>>> Why? I'd rather pass correct pgoff from all callers of 
>>>>>> add_to_kill() and
>>>>>> avoid this special casing...
>>>>>
>>>>> Because one fsdax page can be shared by multiple pgoffs. I have to 
>>>>> pass each pgoff in each iteration to calculate the address in vma 
>>>>> (for tk->addr).  Other kinds of pages don't need this. They can 
>>>>> get their unique address by calling "page_address_in_vma()".
>>>>>
>>>> IMO,   an fsdax page can be shared by multiple files rather than 
>>>> multiple pgoffs if fs query support reflink.   Because an page only 
>>>> located in an mapping(page->mapping is exclusive), hence it  only 
>>>> has an pgoff or index pointing at the node.
>>>>
>>>>   or  I miss something for the feature ?  thanks,
>>>
>>> Yes, a fsdax page is shared by multiple files because of reflink. I 
>>> think my description of 'pgoff' here is not correct.  This 'pgoff' 
>>> means the offset within the a file. (We use rmap to find out all the 
>>> sharing files and their offsets.)  So, I said that "can be shared by 
>>> multiple pgoffs".  It's my bad.
>>>
>>> I think I should name it another word to avoid misunderstandings.
>>>
>> IMO,  All the sharing files should be the same offset to share the 
>> fsdax page.  why not that ? 
>
> The dedupe operation can let different files share their same data 
> extent, though offsets are not same.  So, files can share one fsdax 
> page at different offset.
Ok,  Get it.
>
>> As you has said,  a shared fadax page should be inserted to different 
>> mapping files.  but page->index and page->mapping is exclusive.  
>> hence an page only should be placed in an mapping tree.
>
> We can't use page->mapping and page->index here for reflink & fsdax. 
> And that's this patchset aims to solve.  I introduced a series of 
> ->corrupted_range(), from mm to pmem driver to block device and 
> finally to filesystem, to use rmap feature of filesystem to find out 
> all files sharing same data extent (fsdax page).

 From this patch,  each file has mapping tree,  the shared page will be 
inserted into multiple file mapping tree.  then filesystem use file and 
offset to get the killed process.   Is it correct?

Thanks,

>
>
> -- 
> Thanks,
> Ruan Shiyang.
>
>>
>> And In the current patch,  we failed to found out that all process 
>> use the fsdax page shared by multiple files and kill them.
>>
>>
>> Thanks,
>>
>>> -- 
>>> Thanks,
>>> Ruan Shiyang.
>>>
>>>>
>>>>> So, I added this fsdax case here. This patchset only implemented 
>>>>> the fsdax case, other cases also need to be added here if to be 
>>>>> implemented.
>>>>>
>>>>>
>>>>> -- 
>>>>> Thanks,
>>>>> Ruan Shiyang.
>>>>>
>>>>>>
>>>>>>> +        tk->size_shift = dev_pagemap_mapping_shift(p, vma, 
>>>>>>> tk->addr);
>>>>>>> +    } else
>>>>>>>           tk->size_shift = page_shift(compound_head(p));
>>>>>>>         /*
>>>>>>> @@ -495,7 +501,7 @@ static void collect_procs_anon(struct page 
>>>>>>> *page, struct list_head *to_kill,
>>>>>>>               if (!page_mapped_in_vma(page, vma))
>>>>>>>                   continue;
>>>>>>>               if (vma->vm_mm == t->mm)
>>>>>>> -                add_to_kill(t, page, vma, to_kill);
>>>>>>> +                add_to_kill(t, page, NULL, 0, vma, to_kill);
>>>>>>>           }
>>>>>>>       }
>>>>>>>       read_unlock(&tasklist_lock);
>>>>>>> @@ -505,24 +511,19 @@ static void collect_procs_anon(struct page 
>>>>>>> *page, struct list_head *to_kill,
>>>>>>>   /*
>>>>>>>    * Collect processes when the error hit a file mapped page.
>>>>>>>    */
>>>>>>> -static void collect_procs_file(struct page *page, struct 
>>>>>>> list_head *to_kill,
>>>>>>> -                int force_early)
>>>>>>> +static void collect_procs_file(struct page *page, struct 
>>>>>>> address_space *mapping,
>>>>>>> +        pgoff_t pgoff, struct list_head *to_kill, int force_early)
>>>>>>>   {
>>>>>>>       struct vm_area_struct *vma;
>>>>>>>       struct task_struct *tsk;
>>>>>>> -    struct address_space *mapping = page->mapping;
>>>>>>> -    pgoff_t pgoff;
>>>>>>>         i_mmap_lock_read(mapping);
>>>>>>>       read_lock(&tasklist_lock);
>>>>>>> -    pgoff = page_to_pgoff(page);
>>>>>>>       for_each_process(tsk) {
>>>>>>>           struct task_struct *t = task_early_kill(tsk, 
>>>>>>> force_early);
>>>>>>> -
>>>>>>>           if (!t)
>>>>>>>               continue;
>>>>>>> -        vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff,
>>>>>>> -                      pgoff) {
>>>>>>> +        vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff, 
>>>>>>> pgoff) {
>>>>>>>               /*
>>>>>>>                * Send early kill signal to tasks where a vma covers
>>>>>>>                * the page but the corrupted page is not necessarily
>>>>>>> @@ -531,7 +532,7 @@ static void collect_procs_file(struct page 
>>>>>>> *page, struct list_head *to_kill,
>>>>>>>                * to be informed of all such data corruptions.
>>>>>>>                */
>>>>>>>               if (vma->vm_mm == t->mm)
>>>>>>> -                add_to_kill(t, page, vma, to_kill);
>>>>>>> +                add_to_kill(t, page, mapping, pgoff, vma, 
>>>>>>> to_kill);
>>>>>>>           }
>>>>>>>       }
>>>>>>>       read_unlock(&tasklist_lock);
>>>>>>> @@ -550,7 +551,8 @@ static void collect_procs(struct page *page, 
>>>>>>> struct list_head *tokill,
>>>>>>>       if (PageAnon(page))
>>>>>>>           collect_procs_anon(page, tokill, force_early);
>>>>>>>       else
>>>>>>> -        collect_procs_file(page, tokill, force_early);
>>>>>>> +        collect_procs_file(page, page->mapping, 
>>>>>>> page_to_pgoff(page),
>>>>>>
>>>>>> Why not use page_mapping() helper here? It would be safer for 
>>>>>> THPs if they
>>>>>> ever get here...
>>>>>>
>>>>>>                                 Honza
>>>>>>
>>>>>
>>>>
>>>>
>>>
>>
>>
>
Darrick J. Wong Jan. 14, 2021, 5:20 p.m. UTC | #8
On Thu, Jan 14, 2021 at 05:38:33PM +0800, zhong jiang wrote:
> 
> On 2021/1/14 11:52 上午, Ruan Shiyang wrote:
> > 
> > 
> > On 2021/1/14 上午11:26, zhong jiang wrote:
> > > 
> > > On 2021/1/14 9:44 上午, Ruan Shiyang wrote:
> > > > 
> > > > 
> > > > On 2021/1/13 下午6:04, zhong jiang wrote:
> > > > > 
> > > > > On 2021/1/12 10:55 上午, Ruan Shiyang wrote:
> > > > > > 
> > > > > > 
> > > > > > On 2021/1/6 下午11:41, Jan Kara wrote:
> > > > > > > On Thu 31-12-20 00:55:55, Shiyang Ruan wrote:
> > > > > > > > The current memory_failure_dev_pagemap() can
> > > > > > > > only handle single-mapped
> > > > > > > > dax page for fsdax mode.  The dax page could be
> > > > > > > > mapped by multiple files
> > > > > > > > and offsets if we let reflink feature & fsdax
> > > > > > > > mode work together. So,
> > > > > > > > we refactor current implementation to support
> > > > > > > > handle memory failure on
> > > > > > > > each file and offset.
> > > > > > > > 
> > > > > > > > Signed-off-by: Shiyang Ruan <ruansy.fnst@cn.fujitsu.com>
> > > > > > > 
> > > > > > > Overall this looks OK to me, a few comments below.
> > > > > > > 
> > > > > > > > ---
> > > > > > > >   fs/dax.c            | 21 +++++++++++
> > > > > > > >   include/linux/dax.h |  1 +
> > > > > > > >   include/linux/mm.h  |  9 +++++
> > > > > > > >   mm/memory-failure.c | 91
> > > > > > > > ++++++++++++++++++++++++++++++++++-----------
> > > > > > > >   4 files changed, 100 insertions(+), 22 deletions(-)
> > > > > > 
> > > > > > ...
> > > > > > 
> > > > > > > >   @@ -345,9 +348,12 @@ static void
> > > > > > > > add_to_kill(struct task_struct *tsk, struct page
> > > > > > > > *p,
> > > > > > > >       }
> > > > > > > >         tk->addr = page_address_in_vma(p, vma);
> > > > > > > > -    if (is_zone_device_page(p))
> > > > > > > > -        tk->size_shift = dev_pagemap_mapping_shift(p, vma);
> > > > > > > > -    else
> > > > > > > > +    if (is_zone_device_page(p)) {
> > > > > > > > +        if (is_device_fsdax_page(p))
> > > > > > > > +            tk->addr = vma->vm_start +
> > > > > > > > +                    ((pgoff - vma->vm_pgoff) << PAGE_SHIFT);
> > > > > > > 
> > > > > > > It seems strange to use 'pgoff' for dax pages and
> > > > > > > not for any other page.
> > > > > > > Why? I'd rather pass correct pgoff from all callers
> > > > > > > of add_to_kill() and
> > > > > > > avoid this special casing...
> > > > > > 
> > > > > > Because one fsdax page can be shared by multiple pgoffs.
> > > > > > I have to pass each pgoff in each iteration to calculate
> > > > > > the address in vma (for tk->addr).  Other kinds of pages
> > > > > > don't need this. They can get their unique address by
> > > > > > calling "page_address_in_vma()".
> > > > > > 
> > > > > IMO,   an fsdax page can be shared by multiple files rather
> > > > > than multiple pgoffs if fs query support reflink.   Because
> > > > > an page only located in an mapping(page->mapping is
> > > > > exclusive), hence it  only has an pgoff or index pointing at
> > > > > the node.
> > > > > 
> > > > >   or  I miss something for the feature ?  thanks,
> > > > 
> > > > Yes, a fsdax page is shared by multiple files because of
> > > > reflink. I think my description of 'pgoff' here is not correct. 
> > > > This 'pgoff' means the offset within the a file. (We use rmap to
> > > > find out all the sharing files and their offsets.)  So, I said
> > > > that "can be shared by multiple pgoffs".  It's my bad.
> > > > 
> > > > I think I should name it another word to avoid misunderstandings.
> > > > 
> > > IMO,  All the sharing files should be the same offset to share the
> > > fsdax page.  why not that ?
> > 
> > The dedupe operation can let different files share their same data
> > extent, though offsets are not same.  So, files can share one fsdax page
> > at different offset.
> Ok,  Get it.
> > 
> > > As you has said,  a shared fadax page should be inserted to
> > > different mapping files.  but page->index and page->mapping is
> > > exclusive.  hence an page only should be placed in an mapping tree.
> > 
> > We can't use page->mapping and page->index here for reflink & fsdax. And
> > that's this patchset aims to solve.  I introduced a series of
> > ->corrupted_range(), from mm to pmem driver to block device and finally
> > to filesystem, to use rmap feature of filesystem to find out all files
> > sharing same data extent (fsdax page).
> 
> From this patch,  each file has mapping tree,  the shared page will be
> inserted into multiple file mapping tree.  then filesystem use file and
> offset to get the killed process.   Is it correct?

FWIW I thought the purpose of this patchset is to remove the (dax)
memory poison code's reliance on the pagecache mapping structure by
pushing poison notifications directly into the filesystem and letting
the filesystem perform reverse lookup operations to figure out which
file(s) have gone bad, and using the file list to call back into the mm
to kill processes.

Once that's done, I think(?) that puts us significantly closer to being
able to share pmem between files in dax mode without having to rewrite
the entire memory manager's mapping and rmapping code to support
sharing.

--D

> Thanks,
> 
> > 
> > 
> > -- 
> > Thanks,
> > Ruan Shiyang.
> > 
> > > 
> > > And In the current patch,  we failed to found out that all process
> > > use the fsdax page shared by multiple files and kill them.
> > > 
> > > 
> > > Thanks,
> > > 
> > > > -- 
> > > > Thanks,
> > > > Ruan Shiyang.
> > > > 
> > > > > 
> > > > > > So, I added this fsdax case here. This patchset only
> > > > > > implemented the fsdax case, other cases also need to be
> > > > > > added here if to be implemented.
> > > > > > 
> > > > > > 
> > > > > > -- 
> > > > > > Thanks,
> > > > > > Ruan Shiyang.
> > > > > > 
> > > > > > > 
> > > > > > > > +        tk->size_shift =
> > > > > > > > dev_pagemap_mapping_shift(p, vma, tk->addr);
> > > > > > > > +    } else
> > > > > > > >           tk->size_shift = page_shift(compound_head(p));
> > > > > > > >         /*
> > > > > > > > @@ -495,7 +501,7 @@ static void
> > > > > > > > collect_procs_anon(struct page *page, struct
> > > > > > > > list_head *to_kill,
> > > > > > > >               if (!page_mapped_in_vma(page, vma))
> > > > > > > >                   continue;
> > > > > > > >               if (vma->vm_mm == t->mm)
> > > > > > > > -                add_to_kill(t, page, vma, to_kill);
> > > > > > > > +                add_to_kill(t, page, NULL, 0, vma, to_kill);
> > > > > > > >           }
> > > > > > > >       }
> > > > > > > >       read_unlock(&tasklist_lock);
> > > > > > > > @@ -505,24 +511,19 @@ static void
> > > > > > > > collect_procs_anon(struct page *page, struct
> > > > > > > > list_head *to_kill,
> > > > > > > >   /*
> > > > > > > >    * Collect processes when the error hit a file mapped page.
> > > > > > > >    */
> > > > > > > > -static void collect_procs_file(struct page
> > > > > > > > *page, struct list_head *to_kill,
> > > > > > > > -                int force_early)
> > > > > > > > +static void collect_procs_file(struct page
> > > > > > > > *page, struct address_space *mapping,
> > > > > > > > +        pgoff_t pgoff, struct list_head *to_kill, int force_early)
> > > > > > > >   {
> > > > > > > >       struct vm_area_struct *vma;
> > > > > > > >       struct task_struct *tsk;
> > > > > > > > -    struct address_space *mapping = page->mapping;
> > > > > > > > -    pgoff_t pgoff;
> > > > > > > >         i_mmap_lock_read(mapping);
> > > > > > > >       read_lock(&tasklist_lock);
> > > > > > > > -    pgoff = page_to_pgoff(page);
> > > > > > > >       for_each_process(tsk) {
> > > > > > > >           struct task_struct *t =
> > > > > > > > task_early_kill(tsk, force_early);
> > > > > > > > -
> > > > > > > >           if (!t)
> > > > > > > >               continue;
> > > > > > > > -        vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff,
> > > > > > > > -                      pgoff) {
> > > > > > > > +        vma_interval_tree_foreach(vma,
> > > > > > > > &mapping->i_mmap, pgoff, pgoff) {
> > > > > > > >               /*
> > > > > > > >                * Send early kill signal to tasks where a vma covers
> > > > > > > >                * the page but the corrupted page is not necessarily
> > > > > > > > @@ -531,7 +532,7 @@ static void
> > > > > > > > collect_procs_file(struct page *page, struct
> > > > > > > > list_head *to_kill,
> > > > > > > >                * to be informed of all such data corruptions.
> > > > > > > >                */
> > > > > > > >               if (vma->vm_mm == t->mm)
> > > > > > > > -                add_to_kill(t, page, vma, to_kill);
> > > > > > > > +                add_to_kill(t, page, mapping,
> > > > > > > > pgoff, vma, to_kill);
> > > > > > > >           }
> > > > > > > >       }
> > > > > > > >       read_unlock(&tasklist_lock);
> > > > > > > > @@ -550,7 +551,8 @@ static void
> > > > > > > > collect_procs(struct page *page, struct
> > > > > > > > list_head *tokill,
> > > > > > > >       if (PageAnon(page))
> > > > > > > >           collect_procs_anon(page, tokill, force_early);
> > > > > > > >       else
> > > > > > > > -        collect_procs_file(page, tokill, force_early);
> > > > > > > > +        collect_procs_file(page, page->mapping,
> > > > > > > > page_to_pgoff(page),
> > > > > > > 
> > > > > > > Why not use page_mapping() helper here? It would be
> > > > > > > safer for THPs if they
> > > > > > > ever get here...
> > > > > > > 
> > > > > > >                                 Honza
> > > > > > > 
> > > > > > 
> > > > > 
> > > > > 
> > > > 
> > > 
> > > 
> >
Dan Williams Jan. 14, 2021, 8:38 p.m. UTC | #9
On Wed, Dec 30, 2020 at 8:59 AM Shiyang Ruan <ruansy.fnst@cn.fujitsu.com> wrote:
>
> The current memory_failure_dev_pagemap() can only handle single-mapped
> dax page for fsdax mode.  The dax page could be mapped by multiple files
> and offsets if we let reflink feature & fsdax mode work together.  So,
> we refactor current implementation to support handle memory failure on
> each file and offset.
>
> Signed-off-by: Shiyang Ruan <ruansy.fnst@cn.fujitsu.com>
> ---
>  fs/dax.c            | 21 +++++++++++
>  include/linux/dax.h |  1 +
>  include/linux/mm.h  |  9 +++++
>  mm/memory-failure.c | 91 ++++++++++++++++++++++++++++++++++-----------
>  4 files changed, 100 insertions(+), 22 deletions(-)
>
> diff --git a/fs/dax.c b/fs/dax.c
> index 5b47834f2e1b..799210cfa687 100644
> --- a/fs/dax.c
> +++ b/fs/dax.c
> @@ -378,6 +378,27 @@ static struct page *dax_busy_page(void *entry)
>         return NULL;
>  }
>
> +/*
> + * dax_load_pfn - Load pfn of the DAX entry corresponding to a page
> + * @mapping: The file whose entry we want to load
> + * @index:   The offset where the DAX entry located in
> + *
> + * Return:   pfn of the DAX entry
> + */
> +unsigned long dax_load_pfn(struct address_space *mapping, unsigned long index)
> +{
> +       XA_STATE(xas, &mapping->i_pages, index);
> +       void *entry;
> +       unsigned long pfn;
> +
> +       xas_lock_irq(&xas);
> +       entry = xas_load(&xas);
> +       pfn = dax_to_pfn(entry);
> +       xas_unlock_irq(&xas);
> +
> +       return pfn;
> +}
> +
>  /*
>   * dax_lock_mapping_entry - Lock the DAX entry corresponding to a page
>   * @page: The page whose entry we want to lock
> diff --git a/include/linux/dax.h b/include/linux/dax.h
> index b52f084aa643..89e56ceeffc7 100644
> --- a/include/linux/dax.h
> +++ b/include/linux/dax.h
> @@ -150,6 +150,7 @@ int dax_writeback_mapping_range(struct address_space *mapping,
>
>  struct page *dax_layout_busy_page(struct address_space *mapping);
>  struct page *dax_layout_busy_page_range(struct address_space *mapping, loff_t start, loff_t end);
> +unsigned long dax_load_pfn(struct address_space *mapping, unsigned long index);
>  dax_entry_t dax_lock_page(struct page *page);
>  void dax_unlock_page(struct page *page, dax_entry_t cookie);
>  #else
> diff --git a/include/linux/mm.h b/include/linux/mm.h
> index db6ae4d3fb4e..db3059a1853e 100644
> --- a/include/linux/mm.h
> +++ b/include/linux/mm.h
> @@ -1141,6 +1141,14 @@ static inline bool is_device_private_page(const struct page *page)
>                 page->pgmap->type == MEMORY_DEVICE_PRIVATE;
>  }
>
> +static inline bool is_device_fsdax_page(const struct page *page)
> +{
> +       return IS_ENABLED(CONFIG_DEV_PAGEMAP_OPS) &&
> +               IS_ENABLED(CONFIG_DEVICE_PRIVATE) &&
> +               is_zone_device_page(page) &&
> +               page->pgmap->type == MEMORY_DEVICE_FS_DAX;
> +}
> +

Have a look at the recent fixes to pfn_to_online_page() vs DAX pages [1].

This above page type check is racy given that the pfn could stop being
pfn_valid() while this check is running. I think hwpoison_filter()
needs an explicit check for whether the page is already referenced or
not. For example the current call to hwpoison_filter() from
memory_failure_dev_pagemap() is safe because the page has already been
validated as ZONE_DEVICE and is safe to de-reference page->pgmap.

[1]: http://lore.kernel.org/r/161058499000.1840162.702316708443239771.stgit@dwillia2-desk3.amr.corp.intel.com
diff mbox series

Patch

diff --git a/fs/dax.c b/fs/dax.c
index 5b47834f2e1b..799210cfa687 100644
--- a/fs/dax.c
+++ b/fs/dax.c
@@ -378,6 +378,27 @@  static struct page *dax_busy_page(void *entry)
 	return NULL;
 }
 
+/*
+ * dax_load_pfn - Load pfn of the DAX entry corresponding to a page
+ * @mapping: The file whose entry we want to load
+ * @index:   The offset where the DAX entry located in
+ *
+ * Return:   pfn of the DAX entry
+ */
+unsigned long dax_load_pfn(struct address_space *mapping, unsigned long index)
+{
+	XA_STATE(xas, &mapping->i_pages, index);
+	void *entry;
+	unsigned long pfn;
+
+	xas_lock_irq(&xas);
+	entry = xas_load(&xas);
+	pfn = dax_to_pfn(entry);
+	xas_unlock_irq(&xas);
+
+	return pfn;
+}
+
 /*
  * dax_lock_mapping_entry - Lock the DAX entry corresponding to a page
  * @page: The page whose entry we want to lock
diff --git a/include/linux/dax.h b/include/linux/dax.h
index b52f084aa643..89e56ceeffc7 100644
--- a/include/linux/dax.h
+++ b/include/linux/dax.h
@@ -150,6 +150,7 @@  int dax_writeback_mapping_range(struct address_space *mapping,
 
 struct page *dax_layout_busy_page(struct address_space *mapping);
 struct page *dax_layout_busy_page_range(struct address_space *mapping, loff_t start, loff_t end);
+unsigned long dax_load_pfn(struct address_space *mapping, unsigned long index);
 dax_entry_t dax_lock_page(struct page *page);
 void dax_unlock_page(struct page *page, dax_entry_t cookie);
 #else
diff --git a/include/linux/mm.h b/include/linux/mm.h
index db6ae4d3fb4e..db3059a1853e 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -1141,6 +1141,14 @@  static inline bool is_device_private_page(const struct page *page)
 		page->pgmap->type == MEMORY_DEVICE_PRIVATE;
 }
 
+static inline bool is_device_fsdax_page(const struct page *page)
+{
+	return IS_ENABLED(CONFIG_DEV_PAGEMAP_OPS) &&
+		IS_ENABLED(CONFIG_DEVICE_PRIVATE) &&
+		is_zone_device_page(page) &&
+		page->pgmap->type == MEMORY_DEVICE_FS_DAX;
+}
+
 static inline bool is_pci_p2pdma_page(const struct page *page)
 {
 	return IS_ENABLED(CONFIG_DEV_PAGEMAP_OPS) &&
@@ -3030,6 +3038,7 @@  enum mf_flags {
 	MF_MUST_KILL = 1 << 2,
 	MF_SOFT_OFFLINE = 1 << 3,
 };
+extern int mf_dax_mapping_kill_procs(struct address_space *mapping, pgoff_t index, int flags);
 extern int memory_failure(unsigned long pfn, int flags);
 extern void memory_failure_queue(unsigned long pfn, int flags);
 extern void memory_failure_queue_kick(int cpu);
diff --git a/mm/memory-failure.c b/mm/memory-failure.c
index 5d880d4eb9a2..37bc6e2a9564 100644
--- a/mm/memory-failure.c
+++ b/mm/memory-failure.c
@@ -56,6 +56,7 @@ 
 #include <linux/kfifo.h>
 #include <linux/ratelimit.h>
 #include <linux/page-isolation.h>
+#include <linux/dax.h>
 #include "internal.h"
 #include "ras/ras_event.h"
 
@@ -120,6 +121,9 @@  static int hwpoison_filter_dev(struct page *p)
 	if (PageSlab(p))
 		return -EINVAL;
 
+	if (is_device_fsdax_page(p))
+		return 0;
+
 	mapping = page_mapping(p);
 	if (mapping == NULL || mapping->host == NULL)
 		return -EINVAL;
@@ -290,9 +294,8 @@  void shake_page(struct page *p, int access)
 EXPORT_SYMBOL_GPL(shake_page);
 
 static unsigned long dev_pagemap_mapping_shift(struct page *page,
-		struct vm_area_struct *vma)
+		struct vm_area_struct *vma, unsigned long address)
 {
-	unsigned long address = vma_address(page, vma);
 	pgd_t *pgd;
 	p4d_t *p4d;
 	pud_t *pud;
@@ -333,8 +336,8 @@  static unsigned long dev_pagemap_mapping_shift(struct page *page,
  * Uses GFP_ATOMIC allocations to avoid potential recursions in the VM.
  */
 static void add_to_kill(struct task_struct *tsk, struct page *p,
-		       struct vm_area_struct *vma,
-		       struct list_head *to_kill)
+			struct address_space *mapping, pgoff_t pgoff,
+			struct vm_area_struct *vma, struct list_head *to_kill)
 {
 	struct to_kill *tk;
 
@@ -345,9 +348,12 @@  static void add_to_kill(struct task_struct *tsk, struct page *p,
 	}
 
 	tk->addr = page_address_in_vma(p, vma);
-	if (is_zone_device_page(p))
-		tk->size_shift = dev_pagemap_mapping_shift(p, vma);
-	else
+	if (is_zone_device_page(p)) {
+		if (is_device_fsdax_page(p))
+			tk->addr = vma->vm_start +
+					((pgoff - vma->vm_pgoff) << PAGE_SHIFT);
+		tk->size_shift = dev_pagemap_mapping_shift(p, vma, tk->addr);
+	} else
 		tk->size_shift = page_shift(compound_head(p));
 
 	/*
@@ -495,7 +501,7 @@  static void collect_procs_anon(struct page *page, struct list_head *to_kill,
 			if (!page_mapped_in_vma(page, vma))
 				continue;
 			if (vma->vm_mm == t->mm)
-				add_to_kill(t, page, vma, to_kill);
+				add_to_kill(t, page, NULL, 0, vma, to_kill);
 		}
 	}
 	read_unlock(&tasklist_lock);
@@ -505,24 +511,19 @@  static void collect_procs_anon(struct page *page, struct list_head *to_kill,
 /*
  * Collect processes when the error hit a file mapped page.
  */
-static void collect_procs_file(struct page *page, struct list_head *to_kill,
-				int force_early)
+static void collect_procs_file(struct page *page, struct address_space *mapping,
+		pgoff_t pgoff, struct list_head *to_kill, int force_early)
 {
 	struct vm_area_struct *vma;
 	struct task_struct *tsk;
-	struct address_space *mapping = page->mapping;
-	pgoff_t pgoff;
 
 	i_mmap_lock_read(mapping);
 	read_lock(&tasklist_lock);
-	pgoff = page_to_pgoff(page);
 	for_each_process(tsk) {
 		struct task_struct *t = task_early_kill(tsk, force_early);
-
 		if (!t)
 			continue;
-		vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff,
-				      pgoff) {
+		vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff, pgoff) {
 			/*
 			 * Send early kill signal to tasks where a vma covers
 			 * the page but the corrupted page is not necessarily
@@ -531,7 +532,7 @@  static void collect_procs_file(struct page *page, struct list_head *to_kill,
 			 * to be informed of all such data corruptions.
 			 */
 			if (vma->vm_mm == t->mm)
-				add_to_kill(t, page, vma, to_kill);
+				add_to_kill(t, page, mapping, pgoff, vma, to_kill);
 		}
 	}
 	read_unlock(&tasklist_lock);
@@ -550,7 +551,8 @@  static void collect_procs(struct page *page, struct list_head *tokill,
 	if (PageAnon(page))
 		collect_procs_anon(page, tokill, force_early);
 	else
-		collect_procs_file(page, tokill, force_early);
+		collect_procs_file(page, page->mapping, page_to_pgoff(page),
+				   tokill, force_early);
 }
 
 static const char *action_name[] = {
@@ -1147,6 +1149,50 @@  static int try_to_split_thp_page(struct page *page, const char *msg)
 	return 0;
 }
 
+int mf_dax_mapping_kill_procs(struct address_space *mapping, pgoff_t index, int flags)
+{
+	const bool unmap_success = true;
+	unsigned long pfn, size = 0;
+	struct to_kill *tk;
+	LIST_HEAD(to_kill);
+	int rc = -EBUSY;
+	loff_t start;
+
+	/* load the pfn of the dax mapping file */
+	pfn = dax_load_pfn(mapping, index);
+	if (!pfn)
+		return rc;
+	/*
+	 * Unlike System-RAM there is no possibility to swap in a
+	 * different physical page at a given virtual address, so all
+	 * userspace consumption of ZONE_DEVICE memory necessitates
+	 * SIGBUS (i.e. MF_MUST_KILL)
+	 */
+	flags |= MF_ACTION_REQUIRED | MF_MUST_KILL;
+	collect_procs_file(pfn_to_page(pfn), mapping, index, &to_kill,
+			   flags & MF_ACTION_REQUIRED);
+
+	list_for_each_entry(tk, &to_kill, nd)
+		if (tk->size_shift)
+			size = max(size, 1UL << tk->size_shift);
+	if (size) {
+		/*
+		 * Unmap the largest mapping to avoid breaking up
+		 * device-dax mappings which are constant size. The
+		 * actual size of the mapping being torn down is
+		 * communicated in siginfo, see kill_proc()
+		 */
+		start = (index << PAGE_SHIFT) & ~(size - 1);
+		unmap_mapping_range(mapping, start, start + size, 0);
+	}
+
+	kill_procs(&to_kill, flags & MF_MUST_KILL, !unmap_success,
+		   pfn, flags);
+	rc = 0;
+	return rc;
+}
+EXPORT_SYMBOL_GPL(mf_dax_mapping_kill_procs);
+
 static int memory_failure_hugetlb(unsigned long pfn, int flags)
 {
 	struct page *p = pfn_to_page(pfn);
@@ -1226,7 +1272,7 @@  static int memory_failure_dev_pagemap(unsigned long pfn, int flags,
 	const bool unmap_success = true;
 	unsigned long size = 0;
 	struct to_kill *tk;
-	LIST_HEAD(tokill);
+	LIST_HEAD(to_kill);
 	int rc = -EBUSY;
 	loff_t start;
 	dax_entry_t cookie;
@@ -1268,9 +1314,10 @@  static int memory_failure_dev_pagemap(unsigned long pfn, int flags,
 	 * SIGBUS (i.e. MF_MUST_KILL)
 	 */
 	flags |= MF_ACTION_REQUIRED | MF_MUST_KILL;
-	collect_procs(page, &tokill, flags & MF_ACTION_REQUIRED);
+	collect_procs_file(page, page->mapping, page->index, &to_kill,
+			   flags & MF_ACTION_REQUIRED);
 
-	list_for_each_entry(tk, &tokill, nd)
+	list_for_each_entry(tk, &to_kill, nd)
 		if (tk->size_shift)
 			size = max(size, 1UL << tk->size_shift);
 	if (size) {
@@ -1283,7 +1330,7 @@  static int memory_failure_dev_pagemap(unsigned long pfn, int flags,
 		start = (page->index << PAGE_SHIFT) & ~(size - 1);
 		unmap_mapping_range(page->mapping, start, start + size, 0);
 	}
-	kill_procs(&tokill, flags & MF_MUST_KILL, !unmap_success, pfn, flags);
+	kill_procs(&to_kill, flags & MF_MUST_KILL, !unmap_success, pfn, flags);
 	rc = 0;
 unlock:
 	dax_unlock_page(page, cookie);