Commit 2433480a authored by Jan Kara's avatar Jan Kara
Browse files

xfs: Convert to use invalidate_lock 



Use invalidate_lock instead of XFS internal i_mmap_lock. The intended
purpose of invalidate_lock is exactly the same. Note that the locking in
__xfs_filemap_fault() slightly changes as filemap_fault() already takes
invalidate_lock.

Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarDarrick J. Wong <djwong@kernel.org>
CC: <linux-xfs@vger.kernel.org>
CC: "Darrick J. Wong" <djwong@kernel.org>
Signed-off-by: default avatarJan Kara <jack@suse.cz>
parent e31cbde7

fs/xfs/xfs_file.c

+8 −5
Original line number Diff line number Diff line
@@ -1302,7 +1302,7 @@ xfs_file_llseek( 
 *

 * mmap_lock (MM)

 *   sb_start_pagefault(vfs, freeze)

 *     i_mmaplock (XFS - truncate serialisation)

 *     invalidate_lock (vfs/XFS_MMAPLOCK - truncate serialisation)

 *       page_lock (MM)

 *         i_lock (XFS - extent map serialisation)

 */
@@ -1323,24 +1323,27 @@ __xfs_filemap_fault( 
		file_update_time(vmf->vma->vm_file);

	}



	xfs_ilock(XFS_I(inode), XFS_MMAPLOCK_SHARED);

	if (IS_DAX(inode)) {

		pfn_t pfn;



		xfs_ilock(XFS_I(inode), XFS_MMAPLOCK_SHARED);

		ret = dax_iomap_fault(vmf, pe_size, &pfn, NULL,

				(write_fault && !vmf->cow_page) ?

				 &xfs_direct_write_iomap_ops :

				 &xfs_read_iomap_ops);

		if (ret & VM_FAULT_NEEDDSYNC)

			ret = dax_finish_sync_fault(vmf, pe_size, pfn);

		xfs_iunlock(XFS_I(inode), XFS_MMAPLOCK_SHARED);

	} else {

		if (write_fault)

		if (write_fault) {

			xfs_ilock(XFS_I(inode), XFS_MMAPLOCK_SHARED);

			ret = iomap_page_mkwrite(vmf,

					&xfs_buffered_write_iomap_ops);

		else

			xfs_iunlock(XFS_I(inode), XFS_MMAPLOCK_SHARED);

		} else {

			ret = filemap_fault(vmf);

		}

	xfs_iunlock(XFS_I(inode), XFS_MMAPLOCK_SHARED);

	}



	if (write_fault)

		sb_end_pagefault(inode->i_sb);

fs/xfs/xfs_inode.c

+26 −24
Original line number Diff line number Diff line
@@ -132,7 +132,7 @@ xfs_ilock_attr_map_shared( 


/*

 * In addition to i_rwsem in the VFS inode, the xfs inode contains 2

 * multi-reader locks: i_mmap_lock and the i_lock.  This routine allows

 * multi-reader locks: invalidate_lock and the i_lock.  This routine allows

 * various combinations of the locks to be obtained.

 *

 * The 3 locks should always be ordered so that the IO lock is obtained first,
@@ -140,23 +140,23 @@ xfs_ilock_attr_map_shared( 
 *

 * Basic locking order:

 *

 * i_rwsem -> i_mmap_lock -> page_lock -> i_ilock

 * i_rwsem -> invalidate_lock -> page_lock -> i_ilock

 *

 * mmap_lock locking order:

 *

 * i_rwsem -> page lock -> mmap_lock

 * mmap_lock -> i_mmap_lock -> page_lock

 * mmap_lock -> invalidate_lock -> page_lock

 *

 * The difference in mmap_lock locking order mean that we cannot hold the

 * i_mmap_lock over syscall based read(2)/write(2) based IO. These IO paths can

 * fault in pages during copy in/out (for buffered IO) or require the mmap_lock

 * in get_user_pages() to map the user pages into the kernel address space for

 * direct IO. Similarly the i_rwsem cannot be taken inside a page fault because

 * page faults already hold the mmap_lock.

 * invalidate_lock over syscall based read(2)/write(2) based IO. These IO paths

 * can fault in pages during copy in/out (for buffered IO) or require the

 * mmap_lock in get_user_pages() to map the user pages into the kernel address

 * space for direct IO. Similarly the i_rwsem cannot be taken inside a page

 * fault because page faults already hold the mmap_lock.

 *

 * Hence to serialise fully against both syscall and mmap based IO, we need to

 * take both the i_rwsem and the i_mmap_lock. These locks should *only* be both

 * taken in places where we need to invalidate the page cache in a race

 * take both the i_rwsem and the invalidate_lock. These locks should *only* be

 * both taken in places where we need to invalidate the page cache in a race

 * free manner (e.g. truncate, hole punch and other extent manipulation

 * functions).

 */
@@ -188,10 +188,13 @@ xfs_ilock( 
				 XFS_IOLOCK_DEP(lock_flags));

	}



	if (lock_flags & XFS_MMAPLOCK_EXCL)

		mrupdate_nested(&ip->i_mmaplock, XFS_MMAPLOCK_DEP(lock_flags));

	else if (lock_flags & XFS_MMAPLOCK_SHARED)

		mraccess_nested(&ip->i_mmaplock, XFS_MMAPLOCK_DEP(lock_flags));

	if (lock_flags & XFS_MMAPLOCK_EXCL) {

		down_write_nested(&VFS_I(ip)->i_mapping->invalidate_lock,

				  XFS_MMAPLOCK_DEP(lock_flags));

	} else if (lock_flags & XFS_MMAPLOCK_SHARED) {

		down_read_nested(&VFS_I(ip)->i_mapping->invalidate_lock,

				 XFS_MMAPLOCK_DEP(lock_flags));

	}



	if (lock_flags & XFS_ILOCK_EXCL)

		mrupdate_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
@@ -240,10 +243,10 @@ xfs_ilock_nowait( 
	}



	if (lock_flags & XFS_MMAPLOCK_EXCL) {

		if (!mrtryupdate(&ip->i_mmaplock))

		if (!down_write_trylock(&VFS_I(ip)->i_mapping->invalidate_lock))

			goto out_undo_iolock;

	} else if (lock_flags & XFS_MMAPLOCK_SHARED) {

		if (!mrtryaccess(&ip->i_mmaplock))

		if (!down_read_trylock(&VFS_I(ip)->i_mapping->invalidate_lock))

			goto out_undo_iolock;

	}
@@ -258,9 +261,9 @@ xfs_ilock_nowait( 


out_undo_mmaplock:

	if (lock_flags & XFS_MMAPLOCK_EXCL)

		mrunlock_excl(&ip->i_mmaplock);

		up_write(&VFS_I(ip)->i_mapping->invalidate_lock);

	else if (lock_flags & XFS_MMAPLOCK_SHARED)

		mrunlock_shared(&ip->i_mmaplock);

		up_read(&VFS_I(ip)->i_mapping->invalidate_lock);

out_undo_iolock:

	if (lock_flags & XFS_IOLOCK_EXCL)

		up_write(&VFS_I(ip)->i_rwsem);
@@ -307,9 +310,9 @@ xfs_iunlock( 
		up_read(&VFS_I(ip)->i_rwsem);



	if (lock_flags & XFS_MMAPLOCK_EXCL)

		mrunlock_excl(&ip->i_mmaplock);

		up_write(&VFS_I(ip)->i_mapping->invalidate_lock);

	else if (lock_flags & XFS_MMAPLOCK_SHARED)

		mrunlock_shared(&ip->i_mmaplock);

		up_read(&VFS_I(ip)->i_mapping->invalidate_lock);



	if (lock_flags & XFS_ILOCK_EXCL)

		mrunlock_excl(&ip->i_lock);
@@ -335,7 +338,7 @@ xfs_ilock_demote( 
	if (lock_flags & XFS_ILOCK_EXCL)

		mrdemote(&ip->i_lock);

	if (lock_flags & XFS_MMAPLOCK_EXCL)

		mrdemote(&ip->i_mmaplock);

		downgrade_write(&VFS_I(ip)->i_mapping->invalidate_lock);

	if (lock_flags & XFS_IOLOCK_EXCL)

		downgrade_write(&VFS_I(ip)->i_rwsem);
@@ -375,9 +378,8 @@ xfs_isilocked( 
	}



	if (lock_flags & (XFS_MMAPLOCK_EXCL|XFS_MMAPLOCK_SHARED)) {

		if (!(lock_flags & XFS_MMAPLOCK_SHARED))

			return !!ip->i_mmaplock.mr_writer;

		return rwsem_is_locked(&ip->i_mmaplock.mr_lock);

		return __xfs_rwsem_islocked(&VFS_I(ip)->i_rwsem,

				(lock_flags & XFS_IOLOCK_SHARED));

	}



	if (lock_flags & (XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED)) {

fs/xfs/xfs_inode.h

+0 −1
Original line number Diff line number Diff line
@@ -40,7 +40,6 @@ typedef struct xfs_inode { 
	/* Transaction and locking information. */

	struct xfs_inode_log_item *i_itemp;	/* logging information */

	mrlock_t		i_lock;		/* inode lock */

	mrlock_t		i_mmaplock;	/* inode mmap IO lock */

	atomic_t		i_pincount;	/* inode pin count */



	/*

fs/xfs/xfs_super.c

+0 −2
Original line number Diff line number Diff line
@@ -709,8 +709,6 @@ xfs_fs_inode_init_once( 
	atomic_set(&ip->i_pincount, 0);

	spin_lock_init(&ip->i_flags_lock);



	mrlock_init(&ip->i_mmaplock, MRLOCK_ALLOW_EQUAL_PRI|MRLOCK_BARRIER,

		     "xfsino", ip->i_ino);

	mrlock_init(&ip->i_lock, MRLOCK_ALLOW_EQUAL_PRI|MRLOCK_BARRIER,

		     "xfsino", ip->i_ino);

}