Commit d8a849e1 authored by Dave Jiang's avatar Dave Jiang Committed by Linus Torvalds
Browse files

mm, dax: make pmd_fault() and friends be the same as fault() 

Instead of passing in multiple parameters in the pmd_fault() handler,
a vmf can be passed in just like a fault() handler. This will simplify
code and remove the need for the actual pmd fault handlers to allocate a
vmf. Related functions are also modified to do the same.

[dave.jiang@intel.com: fix issue with xfs_tests stall when DAX option is off]
  Link: http://lkml.kernel.org/r/148469861071.195597.3619476895250028518.stgit@djiang5-desk3.ch.intel.com
Link: http://lkml.kernel.org/r/1484085142-2297-7-git-send-email-ross.zwisler@linux.intel.com


Signed-off-by: default avatarDave Jiang <dave.jiang@intel.com>
Reviewed-by: default avatarRoss Zwisler <ross.zwisler@linux.intel.com>
Reviewed-by: default avatarJan Kara <jack@suse.cz>
Cc: Dave Chinner <david@fromorbit.com>
Cc: Matthew Wilcox <mawilcox@microsoft.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 27a7ffac

drivers/dax/dax.c

+7 −9
Original line number Diff line number Diff line
@@ -473,10 +473,9 @@ static int dax_dev_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 
}



static int __dax_dev_pmd_fault(struct dax_dev *dax_dev,

		struct vm_area_struct *vma, unsigned long addr, pmd_t *pmd,

		unsigned int flags)

		struct vm_area_struct *vma, struct vm_fault *vmf)

{

	unsigned long pmd_addr = addr & PMD_MASK;

	unsigned long pmd_addr = vmf->address & PMD_MASK;

	struct device *dev = &dax_dev->dev;

	struct dax_region *dax_region;

	phys_addr_t phys;
@@ -508,23 +507,22 @@ static int __dax_dev_pmd_fault(struct dax_dev *dax_dev, 


	pfn = phys_to_pfn_t(phys, dax_region->pfn_flags);



	return vmf_insert_pfn_pmd(vma, addr, pmd, pfn,

			flags & FAULT_FLAG_WRITE);

	return vmf_insert_pfn_pmd(vma, vmf->address, vmf->pmd, pfn,

			vmf->flags & FAULT_FLAG_WRITE);

}



static int dax_dev_pmd_fault(struct vm_area_struct *vma, unsigned long addr,

		pmd_t *pmd, unsigned int flags)

static int dax_dev_pmd_fault(struct vm_area_struct *vma, struct vm_fault *vmf)

{

	int rc;

	struct file *filp = vma->vm_file;

	struct dax_dev *dax_dev = filp->private_data;



	dev_dbg(&dax_dev->dev, "%s: %s: %s (%#lx - %#lx)\n", __func__,

			current->comm, (flags & FAULT_FLAG_WRITE)

			current->comm, (vmf->flags & FAULT_FLAG_WRITE)

			? "write" : "read", vma->vm_start, vma->vm_end);



	rcu_read_lock();

	rc = __dax_dev_pmd_fault(dax_dev, vma, addr, pmd, flags);

	rc = __dax_dev_pmd_fault(dax_dev, vma, vmf);

	rcu_read_unlock();



	return rc;

fs/dax.c

+11 −17
Original line number Diff line number Diff line
@@ -1340,18 +1340,17 @@ fallback: 
	return VM_FAULT_FALLBACK;

}



int dax_iomap_pmd_fault(struct vm_area_struct *vma, unsigned long address,

		pmd_t *pmd, unsigned int flags, struct iomap_ops *ops)

int dax_iomap_pmd_fault(struct vm_area_struct *vma, struct vm_fault *vmf,

		struct iomap_ops *ops)

{

	struct address_space *mapping = vma->vm_file->f_mapping;

	unsigned long pmd_addr = address & PMD_MASK;

	bool write = flags & FAULT_FLAG_WRITE;

	unsigned long pmd_addr = vmf->address & PMD_MASK;

	bool write = vmf->flags & FAULT_FLAG_WRITE;

	unsigned int iomap_flags = (write ? IOMAP_WRITE : 0) | IOMAP_FAULT;

	struct inode *inode = mapping->host;

	int result = VM_FAULT_FALLBACK;

	struct iomap iomap = { 0 };

	pgoff_t max_pgoff, pgoff;

	struct vm_fault vmf;

	void *entry;

	loff_t pos;

	int error;
@@ -1364,7 +1363,7 @@ int dax_iomap_pmd_fault(struct vm_area_struct *vma, unsigned long address, 
	pgoff = linear_page_index(vma, pmd_addr);

	max_pgoff = (i_size_read(inode) - 1) >> PAGE_SHIFT;



	trace_dax_pmd_fault(inode, vma, address, flags, pgoff, max_pgoff, 0);

	trace_dax_pmd_fault(inode, vma, vmf, max_pgoff, 0);



	/* Fall back to PTEs if we're going to COW */

	if (write && !(vma->vm_flags & VM_SHARED))
@@ -1408,21 +1407,17 @@ int dax_iomap_pmd_fault(struct vm_area_struct *vma, unsigned long address, 
	if (IS_ERR(entry))

		goto finish_iomap;



	vmf.pgoff = pgoff;

	vmf.flags = flags;

	vmf.gfp_mask = mapping_gfp_mask(mapping) | __GFP_IO;



	switch (iomap.type) {

	case IOMAP_MAPPED:

		result = dax_pmd_insert_mapping(vma, pmd, &vmf, address,

				&iomap, pos, write, &entry);

		result = dax_pmd_insert_mapping(vma, vmf->pmd, vmf,

				vmf->address, &iomap, pos, write, &entry);

		break;

	case IOMAP_UNWRITTEN:

	case IOMAP_HOLE:

		if (WARN_ON_ONCE(write))

			goto unlock_entry;

		result = dax_pmd_load_hole(vma, pmd, &vmf, address, &iomap,

				&entry);

		result = dax_pmd_load_hole(vma, vmf->pmd, vmf, vmf->address,

				&iomap, &entry);

		break;

	default:

		WARN_ON_ONCE(1);
@@ -1448,12 +1443,11 @@ int dax_iomap_pmd_fault(struct vm_area_struct *vma, unsigned long address, 
	}

 fallback:

	if (result == VM_FAULT_FALLBACK) {

		split_huge_pmd(vma, pmd, address);

		split_huge_pmd(vma, vmf->pmd, vmf->address);

		count_vm_event(THP_FAULT_FALLBACK);

	}

out:

	trace_dax_pmd_fault_done(inode, vma, address, flags, pgoff, max_pgoff,

			result);

	trace_dax_pmd_fault_done(inode, vma, vmf, max_pgoff, result);

	return result;

}

EXPORT_SYMBOL_GPL(dax_iomap_pmd_fault);

fs/ext4/file.c

+4 −5
Original line number Diff line number Diff line
@@ -273,21 +273,20 @@ static int ext4_dax_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 
	return result;

}



static int ext4_dax_pmd_fault(struct vm_area_struct *vma, unsigned long addr,

						pmd_t *pmd, unsigned int flags)

static int

ext4_dax_pmd_fault(struct vm_area_struct *vma, struct vm_fault *vmf)

{

	int result;

	struct inode *inode = file_inode(vma->vm_file);

	struct super_block *sb = inode->i_sb;

	bool write = flags & FAULT_FLAG_WRITE;

	bool write = vmf->flags & FAULT_FLAG_WRITE;



	if (write) {

		sb_start_pagefault(sb);

		file_update_time(vma->vm_file);

	}

	down_read(&EXT4_I(inode)->i_mmap_sem);

	result = dax_iomap_pmd_fault(vma, addr, pmd, flags,

				     &ext4_iomap_ops);

	result = dax_iomap_pmd_fault(vma, vmf, &ext4_iomap_ops);

	up_read(&EXT4_I(inode)->i_mmap_sem);

	if (write)

		sb_end_pagefault(sb);

fs/xfs/xfs_file.c

+4 −6
Original line number Diff line number Diff line
@@ -1432,9 +1432,7 @@ xfs_filemap_fault( 
STATIC int

xfs_filemap_pmd_fault(

	struct vm_area_struct	*vma,

	unsigned long		addr,

	pmd_t			*pmd,

	unsigned int		flags)

	struct vm_fault		*vmf)

{

	struct inode		*inode = file_inode(vma->vm_file);

	struct xfs_inode	*ip = XFS_I(inode);
@@ -1445,16 +1443,16 @@ xfs_filemap_pmd_fault( 


	trace_xfs_filemap_pmd_fault(ip);



	if (flags & FAULT_FLAG_WRITE) {

	if (vmf->flags & FAULT_FLAG_WRITE) {

		sb_start_pagefault(inode->i_sb);

		file_update_time(vma->vm_file);

	}



	xfs_ilock(XFS_I(inode), XFS_MMAPLOCK_SHARED);

	ret = dax_iomap_pmd_fault(vma, addr, pmd, flags, &xfs_iomap_ops);

	ret = dax_iomap_pmd_fault(vma, vmf, &xfs_iomap_ops);

	xfs_iunlock(XFS_I(inode), XFS_MMAPLOCK_SHARED);



	if (flags & FAULT_FLAG_WRITE)

	if (vmf->flags & FAULT_FLAG_WRITE)

		sb_end_pagefault(inode->i_sb);



	return ret;

include/linux/dax.h

+3 −4
Original line number Diff line number Diff line
@@ -71,16 +71,15 @@ static inline unsigned int dax_radix_order(void *entry) 
		return PMD_SHIFT - PAGE_SHIFT;

	return 0;

}

int dax_iomap_pmd_fault(struct vm_area_struct *vma, unsigned long address,

		pmd_t *pmd, unsigned int flags, struct iomap_ops *ops);

int dax_iomap_pmd_fault(struct vm_area_struct *vma, struct vm_fault *vmf,

		struct iomap_ops *ops);

#else

static inline unsigned int dax_radix_order(void *entry)

{

	return 0;

}

static inline int dax_iomap_pmd_fault(struct vm_area_struct *vma,

		unsigned long address, pmd_t *pmd, unsigned int flags,

		struct iomap_ops *ops)

		struct vm_fault *vmf, struct iomap_ops *ops)

{

	return VM_FAULT_FALLBACK;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE