Commit 20f82999 authored by Andreas Gruenbacher's avatar Andreas Gruenbacher
Browse files

gfs2: Rework read and page fault locking 



So far, gfs2 has taken the inode glocks inside the ->readpage and
->readahead address space operations.  Since commit d4388340 ("fs:
convert mpage_readpages to mpage_readahead"), gfs2_readahead is passed
the pages to read ahead locked.  With that, the current holder of the
inode glock may be trying to lock one of those pages while
gfs2_readahead is trying to take the inode glock, resulting in a
deadlock.

Fix that by moving the lock taking to the higher-level ->read_iter file
and ->fault vm operations.  This also gets rid of an ugly lock inversion
workaround in gfs2_readpage.

The cache consistency model of filesystems like gfs2 is such that if
data is found in the page cache, the data is up to date and can be used
without taking any filesystem locks.  If a page is not cached,
filesystem locks must be taken before populating the page cache.

To avoid taking the inode glock when the data is already cached,
gfs2_file_read_iter first tries to read the data with the IOCB_NOIO flag
set.  If that fails, the inode glock is taken and the operation is
retried with the IOCB_NOIO flag cleared.

Signed-off-by: default avatarAndreas Gruenbacher <agruenba@redhat.com>
parent 41da51bc

fs/gfs2/aops.c

+1 −44
Original line number Diff line number Diff line
@@ -468,21 +468,10 @@ static int stuffed_readpage(struct gfs2_inode *ip, struct page *page) 
}





/**

 * __gfs2_readpage - readpage

 * @file: The file to read a page for

 * @page: The page to read

 *

 * This is the core of gfs2's readpage. It's used by the internal file

 * reading code as in that case we already hold the glock. Also it's

 * called by gfs2_readpage() once the required lock has been granted.

 */



static int __gfs2_readpage(void *file, struct page *page)

{

	struct gfs2_inode *ip = GFS2_I(page->mapping->host);

	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);



	int error;



	if (i_blocksize(page->mapping->host) == PAGE_SIZE &&
@@ -505,36 +494,11 @@ static int __gfs2_readpage(void *file, struct page *page) 
 * gfs2_readpage - read a page of a file

 * @file: The file to read

 * @page: The page of the file

 *

 * This deals with the locking required. We have to unlock and

 * relock the page in order to get the locking in the right

 * order.

 */



static int gfs2_readpage(struct file *file, struct page *page)

{

	struct address_space *mapping = page->mapping;

	struct gfs2_inode *ip = GFS2_I(mapping->host);

	struct gfs2_holder gh;

	int error;



	unlock_page(page);

	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);

	error = gfs2_glock_nq(&gh);

	if (unlikely(error))

		goto out;

	error = AOP_TRUNCATED_PAGE;

	lock_page(page);

	if (page->mapping == mapping && !PageUptodate(page))

		error = __gfs2_readpage(file, page);

	else

		unlock_page(page);

	gfs2_glock_dq(&gh);

out:

	gfs2_holder_uninit(&gh);

	if (error && error != AOP_TRUNCATED_PAGE)

		lock_page(page);

	return error;

	return __gfs2_readpage(file, page);

}



/**
@@ -598,16 +562,9 @@ static void gfs2_readahead(struct readahead_control *rac) 
{

	struct inode *inode = rac->mapping->host;

	struct gfs2_inode *ip = GFS2_I(inode);

	struct gfs2_holder gh;



	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);

	if (gfs2_glock_nq(&gh))

		goto out_uninit;

	if (!gfs2_is_stuffed(ip))

		mpage_readahead(rac, gfs2_block_map);

	gfs2_glock_dq(&gh);

out_uninit:

	gfs2_holder_uninit(&gh);

}



/**

fs/gfs2/file.c

+50 −2
Original line number Diff line number Diff line
@@ -558,8 +558,29 @@ out_uninit: 
	return block_page_mkwrite_return(ret);

}



static vm_fault_t gfs2_fault(struct vm_fault *vmf)

{

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

	struct gfs2_inode *ip = GFS2_I(inode);

	struct gfs2_holder gh;

	vm_fault_t ret;

	int err;



	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);

	err = gfs2_glock_nq(&gh);

	if (err) {

		ret = block_page_mkwrite_return(err);

		goto out_uninit;

	}

	ret = filemap_fault(vmf);

	gfs2_glock_dq(&gh);

out_uninit:

	gfs2_holder_uninit(&gh);

	return ret;

}



static const struct vm_operations_struct gfs2_vm_ops = {

	.fault = filemap_fault,

	.fault = gfs2_fault,

	.map_pages = filemap_map_pages,

	.page_mkwrite = gfs2_page_mkwrite,

};
@@ -824,6 +845,9 @@ out_uninit: 


static ssize_t gfs2_file_read_iter(struct kiocb *iocb, struct iov_iter *to)

{

	struct gfs2_inode *ip;

	struct gfs2_holder gh;

	size_t written = 0;

	ssize_t ret;



	if (iocb->ki_flags & IOCB_DIRECT) {
@@ -832,7 +856,31 @@ static ssize_t gfs2_file_read_iter(struct kiocb *iocb, struct iov_iter *to) 
			return ret;

		iocb->ki_flags &= ~IOCB_DIRECT;

	}

	return generic_file_read_iter(iocb, to);

	iocb->ki_flags |= IOCB_NOIO;

	ret = generic_file_read_iter(iocb, to);

	iocb->ki_flags &= ~IOCB_NOIO;

	if (ret >= 0) {

		if (!iov_iter_count(to))

			return ret;

		written = ret;

	} else {

		if (ret != -EAGAIN)

			return ret;

		if (iocb->ki_flags & IOCB_NOWAIT)

			return ret;

	}

	ip = GFS2_I(iocb->ki_filp->f_mapping->host);

	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);

	ret = gfs2_glock_nq(&gh);

	if (ret)

		goto out_uninit;

	ret = generic_file_read_iter(iocb, to);

	if (ret > 0)

		written += ret;

	gfs2_glock_dq(&gh);

out_uninit:

	gfs2_holder_uninit(&gh);

	return written ? written : ret;

}



/**

CRA Git | Maintained and supported by SUSTech CRA and CCSE