Commit a62f8e3b authored by Trond Myklebust's avatar Trond Myklebust
Browse files

NFS: Clean up nfs_lock_and_join_requests() 



Clean up nfs_lock_and_join_requests() to simplify the calculation
of the range covered by the page group, taking into account the
presence of mirrors.

Signed-off-by: default avatarTrond Myklebust <trond.myklebust@hammerspace.com>
parent 377840ee

fs/nfs/pagelist.c

+74 −0
Original line number Diff line number Diff line
@@ -130,6 +130,80 @@ nfs_async_iocounter_wait(struct rpc_task *task, struct nfs_lock_context *l_ctx) 
}

EXPORT_SYMBOL_GPL(nfs_async_iocounter_wait);



/*

 * nfs_unroll_locks -  unlock all newly locked reqs and wait on @req

 * @head: head request of page group, must be holding head lock

 * @req: request that couldn't lock and needs to wait on the req bit lock

 *

 * This is a helper function for nfs_lock_and_join_requests

 * returns 0 on success, < 0 on error.

 */

static void

nfs_unroll_locks(struct nfs_page *head, struct nfs_page *req)

{

	struct nfs_page *tmp;



	/* relinquish all the locks successfully grabbed this run */

	for (tmp = head->wb_this_page ; tmp != req; tmp = tmp->wb_this_page) {

		if (!kref_read(&tmp->wb_kref))

			continue;

		nfs_unlock_and_release_request(tmp);

	}

}



/*

 * nfs_page_group_lock_subreq -  try to lock a subrequest

 * @head: head request of page group

 * @subreq: request to lock

 *

 * This is a helper function for nfs_lock_and_join_requests which

 * must be called with the head request and page group both locked.

 * On error, it returns with the page group unlocked.

 */

static int

nfs_page_group_lock_subreq(struct nfs_page *head, struct nfs_page *subreq)

{

	int ret;



	if (!kref_get_unless_zero(&subreq->wb_kref))

		return 0;

	while (!nfs_lock_request(subreq)) {

		nfs_page_group_unlock(head);

		ret = nfs_wait_on_request(subreq);

		if (!ret)

			ret = nfs_page_group_lock(head);

		if (ret < 0) {

			nfs_unroll_locks(head, subreq);

			nfs_release_request(subreq);

			return ret;

		}

	}

	return 0;

}



/*

 * nfs_page_group_lock_subrequests -  try to lock the subrequests

 * @head: head request of page group

 *

 * This is a helper function for nfs_lock_and_join_requests which

 * must be called with the head request and page group both locked.

 * On error, it returns with the page group unlocked.

 */

int nfs_page_group_lock_subrequests(struct nfs_page *head)

{

	struct nfs_page *subreq;

	int ret;



	/* lock each request in the page group */

	for (subreq = head->wb_this_page; subreq != head;

			subreq = subreq->wb_this_page) {

		ret = nfs_page_group_lock_subreq(head, subreq);

		if (ret < 0)

			return ret;

	}

	return 0;

}



/*

 * nfs_page_set_headlock - set the request PG_HEADLOCK

 * @req: request that is to be locked

fs/nfs/write.c

+20 −71
Original line number Diff line number Diff line
@@ -379,34 +379,6 @@ static void nfs_end_page_writeback(struct nfs_page *req) 
		clear_bdi_congested(inode_to_bdi(inode), BLK_RW_ASYNC);

}



/*

 * nfs_unroll_locks_and_wait -  unlock all newly locked reqs and wait on @req

 *

 * this is a helper function for nfs_lock_and_join_requests

 *

 * @inode - inode associated with request page group, must be holding inode lock

 * @head  - head request of page group, must be holding head lock

 * @req   - request that couldn't lock and needs to wait on the req bit lock

 *

 * NOTE: this must be called holding page_group bit lock

 *       which will be released before returning.

 *

 * returns 0 on success, < 0 on error.

 */

static void

nfs_unroll_locks(struct inode *inode, struct nfs_page *head,

			  struct nfs_page *req)

{

	struct nfs_page *tmp;



	/* relinquish all the locks successfully grabbed this run */

	for (tmp = head->wb_this_page ; tmp != req; tmp = tmp->wb_this_page) {

		if (!kref_read(&tmp->wb_kref))

			continue;

		nfs_unlock_and_release_request(tmp);

	}

}



/*

 * nfs_destroy_unlinked_subrequests - destroy recently unlinked subrequests

 *
@@ -487,7 +459,7 @@ nfs_lock_and_join_requests(struct page *page) 
	struct inode *inode = page_file_mapping(page)->host;

	struct nfs_page *head, *subreq;

	struct nfs_page *destroy_list = NULL;

	unsigned int total_bytes;

	unsigned int pgbase, off, bytes;

	int ret;



try_again:
@@ -520,49 +492,30 @@ nfs_lock_and_join_requests(struct page *page) 
		goto release_request;



	/* lock each request in the page group */

	total_bytes = head->wb_bytes;

	ret = nfs_page_group_lock_subrequests(head);

	if (ret < 0)

		goto release_request;



	pgbase = head->wb_pgbase;

	bytes = head->wb_bytes;

	off = head->wb_offset;

	for (subreq = head->wb_this_page; subreq != head;

			subreq = subreq->wb_this_page) {



		if (!kref_get_unless_zero(&subreq->wb_kref)) {

			if (subreq->wb_offset == head->wb_offset + total_bytes)

				total_bytes += subreq->wb_bytes;

			continue;

		}



		while (!nfs_lock_request(subreq)) {

			/*

			 * Unlock page to allow nfs_page_group_sync_on_bit()

			 * to succeed

			 */

			nfs_page_group_unlock(head);

			ret = nfs_wait_on_request(subreq);

			if (!ret)

				ret = nfs_page_group_lock(head);

			if (ret < 0) {

				nfs_unroll_locks(inode, head, subreq);

				nfs_release_request(subreq);

				goto release_request;

			}

		}

		/*

		 * Subrequests are always contiguous, non overlapping

		 * and in order - but may be repeated (mirrored writes).

		 */

		if (subreq->wb_offset == (head->wb_offset + total_bytes)) {

			/* keep track of how many bytes this group covers */

			total_bytes += subreq->wb_bytes;

		} else if (WARN_ON_ONCE(subreq->wb_offset < head->wb_offset ||

			    ((subreq->wb_offset + subreq->wb_bytes) >

			     (head->wb_offset + total_bytes)))) {

			nfs_page_group_unlock(head);

			nfs_unroll_locks(inode, head, subreq);

			nfs_unlock_and_release_request(subreq);

			ret = -EIO;

			goto release_request;

		/* Subrequests should always form a contiguous range */

		if (pgbase > subreq->wb_pgbase) {

			off -= pgbase - subreq->wb_pgbase;

			bytes += pgbase - subreq->wb_pgbase;

			pgbase = subreq->wb_pgbase;

		}

		bytes = max(subreq->wb_pgbase + subreq->wb_bytes

				- pgbase, bytes);

	}



	/* Set the head request's range to cover the former page group */

	head->wb_pgbase = pgbase;

	head->wb_bytes = bytes;

	head->wb_offset = off;



	/* Now that all requests are locked, make sure they aren't on any list.

	 * Commit list removal accounting is done after locks are dropped */

	subreq = head;
@@ -576,10 +529,6 @@ nfs_lock_and_join_requests(struct page *page) 
		/* destroy list will be terminated by head */

		destroy_list = head->wb_this_page;

		head->wb_this_page = head;



		/* change head request to cover whole range that

		 * the former page group covered */

		head->wb_bytes = total_bytes;

	}



	/* Postpone destruction of this request */

include/linux/nfs_page.h

+1 −0
Original line number Diff line number Diff line
@@ -139,6 +139,7 @@ extern size_t nfs_generic_pg_test(struct nfs_pageio_descriptor *desc, 
extern  int nfs_wait_on_request(struct nfs_page *);

extern	void nfs_unlock_request(struct nfs_page *req);

extern	void nfs_unlock_and_release_request(struct nfs_page *);

extern	int nfs_page_group_lock_subrequests(struct nfs_page *head);

extern int nfs_page_group_lock(struct nfs_page *);

extern void nfs_page_group_unlock(struct nfs_page *);

extern bool nfs_page_group_sync_on_bit(struct nfs_page *, unsigned int);