Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 72cb77f4 authored by Trond Myklebust's avatar Trond Myklebust
Browse files

NFS: Throttle page dirtying while we're flushing to disk 



The following patch is a combination of a patch by myself and Peter
Staubach.

Trond: If we allow other processes to dirty pages while a process is doing
a consistency sync to disk, we can end up never making progress.

Peter: Attached is a patch which addresses a continuing problem with
the NFS client generating out of order WRITE requests.  While
this is compliant with all of the current protocol
specifications, there are servers in the market which can not
handle out of order WRITE requests very well.  Also, this may
lead to sub-optimal block allocations in the underlying file
system on the server.  This may cause the read throughputs to
be reduced when reading the file from the server.

Peter: There has been a lot of work recently done to address out of
order issues on a systemic level.  However, the NFS client is
still susceptible to the problem.  Out of order WRITE
requests can occur when pdflush is in the middle of writing
out pages while the process dirtying the pages calls
generic_file_buffered_write which calls
generic_perform_write which calls
balance_dirty_pages_rate_limited which ends up calling
writeback_inodes which ends up calling back into the NFS
client to writes out dirty pages for the same file that
pdflush happens to be working with.

Signed-off-by: default avatarPeter Staubach <staubach@redhat.com>
[modification by Trond to merge the two similar patches]
Signed-off-by: default avatarTrond Myklebust <Trond.Myklebust@netapp.com>
parent fb8a1f11

fs/nfs/file.c

+9 −0
Original line number Diff line number Diff line
@@ -354,6 +354,15 @@ static int nfs_write_begin(struct file *file, struct address_space *mapping, 
		file->f_path.dentry->d_name.name,

		mapping->host->i_ino, len, (long long) pos);



	/*

	 * Prevent starvation issues if someone is doing a consistency

	 * sync-to-disk

	 */

	ret = wait_on_bit(&NFS_I(mapping->host)->flags, NFS_INO_FLUSHING,

			nfs_wait_bit_killable, TASK_KILLABLE);

	if (ret)

		return ret;



	page = grab_cache_page_write_begin(mapping, index, flags);

	if (!page)

		return -ENOMEM;

fs/nfs/inode.c

+12 −0
Original line number Diff line number Diff line
@@ -65,6 +65,18 @@ nfs_fattr_to_ino_t(struct nfs_fattr *fattr) 
	return nfs_fileid_to_ino_t(fattr->fileid);

}



/**

 * nfs_wait_bit_killable - helper for functions that are sleeping on bit locks

 * @word: long word containing the bit lock

 */

int nfs_wait_bit_killable(void *word)

{

	if (fatal_signal_pending(current))

		return -ERESTARTSYS;

	schedule();

	return 0;

}



/**

 * nfs_compat_user_ino64 - returns the user-visible inode number

 * @fileid: 64-bit fileid

fs/nfs/internal.h

+1 −0
Original line number Diff line number Diff line
@@ -165,6 +165,7 @@ extern void nfs_clear_inode(struct inode *); 
extern void nfs4_clear_inode(struct inode *);

#endif

void nfs_zap_acl_cache(struct inode *inode);

extern int nfs_wait_bit_killable(void *word);



/* super.c */

void nfs_parse_ip_address(char *, size_t, struct sockaddr *, size_t *);

fs/nfs/nfs4proc.c

+1 −9
Original line number Diff line number Diff line
@@ -193,14 +193,6 @@ static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dent 
	kunmap_atomic(start, KM_USER0);

}



static int nfs4_wait_bit_killable(void *word)

{

	if (fatal_signal_pending(current))

		return -ERESTARTSYS;

	schedule();

	return 0;

}



static int nfs4_wait_clnt_recover(struct nfs_client *clp)

{

	int res;
@@ -208,7 +200,7 @@ static int nfs4_wait_clnt_recover(struct nfs_client *clp) 
	might_sleep();



	res = wait_on_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING,

			nfs4_wait_bit_killable, TASK_KILLABLE);

			nfs_wait_bit_killable, TASK_KILLABLE);

	return res;

}

fs/nfs/pagelist.c

+0 −11
Original line number Diff line number Diff line
@@ -176,17 +176,6 @@ void nfs_release_request(struct nfs_page *req) 
	kref_put(&req->wb_kref, nfs_free_request);

}



static int nfs_wait_bit_killable(void *word)

{

	int ret = 0;



	if (fatal_signal_pending(current))

		ret = -ERESTARTSYS;

	else

		schedule();

	return ret;

}



/**

 * nfs_wait_on_request - Wait for a request to complete.

 * @req: request to wait upon.