Commit 788e7a89 authored by Trond Myklebust's avatar Trond Myklebust
Browse files

NFS: Cleanup of NFS write code in preparation for asynchronous o_direct 



This patch inverts the callback hierarchy for NFS write calls.

Instead of having the NFSv2/v3/v4-specific code set up the RPC callback
ops, we allow the original caller to do so. This allows for more
flexibility w.r.t. how to set up and tear down the nfs_write_data
structure while still allowing the NFSv3/v4 code to perform error
handling.

The greater flexibility is needed by the asynchronous O_DIRECT code, which
wants to be able to hold on to the original nfs_write_data structures after
the WRITE RPC call has completed in order to be able to replay them if the
COMMIT call determines that the server has rebooted.

Signed-off-by: default avatarTrond Myklebust <Trond.Myklebust@netapp.com>
parent 7117bf3d

fs/nfs/nfs3proc.c

+17 −49
Original line number Diff line number Diff line
@@ -849,29 +849,17 @@ nfs3_proc_read_setup(struct nfs_read_data *data) 
	rpc_call_setup(task, &msg, 0);

}



static void nfs3_write_done(struct rpc_task *task, void *calldata)

static int nfs3_write_done(struct rpc_task *task, struct nfs_write_data *data)

{

	struct nfs_write_data *data = calldata;



	if (nfs3_async_handle_jukebox(task, data->inode))

		return;

		return -EAGAIN;

	if (task->tk_status >= 0)

		nfs_post_op_update_inode(data->inode, data->res.fattr);

	nfs_writeback_done(task, calldata);

	return 0;

}



static const struct rpc_call_ops nfs3_write_ops = {

	.rpc_call_done = nfs3_write_done,

	.rpc_release = nfs_writedata_release,

};



static void

nfs3_proc_write_setup(struct nfs_write_data *data, int how)

static void nfs3_proc_write_setup(struct nfs_write_data *data, int how)

{

	struct rpc_task		*task = &data->task;

	struct inode		*inode = data->inode;

	int			stable;

	int			flags;

	struct rpc_message	msg = {

		.rpc_proc	= &nfs3_procedures[NFS3PROC_WRITE],

		.rpc_argp	= &data->args,
@@ -879,45 +867,28 @@ nfs3_proc_write_setup(struct nfs_write_data *data, int how) 
		.rpc_cred	= data->cred,

	};



	data->args.stable = NFS_UNSTABLE;

	if (how & FLUSH_STABLE) {

		if (!NFS_I(inode)->ncommit)

			stable = NFS_FILE_SYNC;

		else

			stable = NFS_DATA_SYNC;

	} else

		stable = NFS_UNSTABLE;

	data->args.stable = stable;



	/* Set the initial flags for the task.  */

	flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;

		data->args.stable = NFS_FILE_SYNC;

		if (NFS_I(data->inode)->ncommit)

			data->args.stable = NFS_DATA_SYNC;

	}



	/* Finalize the task. */

	rpc_init_task(task, NFS_CLIENT(inode), flags, &nfs3_write_ops, data);

	rpc_call_setup(task, &msg, 0);

	rpc_call_setup(&data->task, &msg, 0);

}



static void nfs3_commit_done(struct rpc_task *task, void *calldata)

static int nfs3_commit_done(struct rpc_task *task, struct nfs_write_data *data)

{

	struct nfs_write_data *data = calldata;



	if (nfs3_async_handle_jukebox(task, data->inode))

		return;

		return -EAGAIN;

	if (task->tk_status >= 0)

		nfs_post_op_update_inode(data->inode, data->res.fattr);

	nfs_commit_done(task, calldata);

	return 0;

}



static const struct rpc_call_ops nfs3_commit_ops = {

	.rpc_call_done = nfs3_commit_done,

	.rpc_release = nfs_commit_release,

};



static void

nfs3_proc_commit_setup(struct nfs_write_data *data, int how)

static void nfs3_proc_commit_setup(struct nfs_write_data *data, int how)

{

	struct rpc_task		*task = &data->task;

	struct inode		*inode = data->inode;

	int			flags;

	struct rpc_message	msg = {

		.rpc_proc	= &nfs3_procedures[NFS3PROC_COMMIT],

		.rpc_argp	= &data->args,
@@ -925,12 +896,7 @@ nfs3_proc_commit_setup(struct nfs_write_data *data, int how) 
		.rpc_cred	= data->cred,

	};



	/* Set the initial flags for the task.  */

	flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;



	/* Finalize the task. */

	rpc_init_task(task, NFS_CLIENT(inode), flags, &nfs3_commit_ops, data);

	rpc_call_setup(task, &msg, 0);

	rpc_call_setup(&data->task, &msg, 0);

}



static int
@@ -970,7 +936,9 @@ struct nfs_rpc_ops nfs_v3_clientops = { 
	.decode_dirent	= nfs3_decode_dirent,

	.read_setup	= nfs3_proc_read_setup,

	.write_setup	= nfs3_proc_write_setup,

	.write_done	= nfs3_write_done,

	.commit_setup	= nfs3_proc_commit_setup,

	.commit_done	= nfs3_commit_done,

	.file_open	= nfs_open,

	.file_release	= nfs_release,

	.lock		= nfs3_proc_lock,

fs/nfs/nfs4proc.c

+13 −41
Original line number Diff line number Diff line
@@ -2388,32 +2388,23 @@ nfs4_proc_read_setup(struct nfs_read_data *data) 
	rpc_call_setup(task, &msg, 0);

}



static void nfs4_write_done(struct rpc_task *task, void *calldata)

static int nfs4_write_done(struct rpc_task *task, struct nfs_write_data *data)

{

	struct nfs_write_data *data = calldata;

	struct inode *inode = data->inode;

	

	if (nfs4_async_handle_error(task, NFS_SERVER(inode)) == -EAGAIN) {

		rpc_restart_call(task);

		return;

		return -EAGAIN;

	}

	if (task->tk_status >= 0) {

		renew_lease(NFS_SERVER(inode), data->timestamp);

		nfs_post_op_update_inode(inode, data->res.fattr);

	}

	/* Call back common NFS writeback processing */

	nfs_writeback_done(task, calldata);

	return 0;

}



static const struct rpc_call_ops nfs4_write_ops = {

	.rpc_call_done = nfs4_write_done,

	.rpc_release = nfs_writedata_release,

};



static void

nfs4_proc_write_setup(struct nfs_write_data *data, int how)

static void nfs4_proc_write_setup(struct nfs_write_data *data, int how)

{

	struct rpc_task	*task = &data->task;

	struct rpc_message msg = {

		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE],

		.rpc_argp = &data->args,
@@ -2423,7 +2414,6 @@ nfs4_proc_write_setup(struct nfs_write_data *data, int how) 
	struct inode *inode = data->inode;

	struct nfs_server *server = NFS_SERVER(inode);

	int stable;

	int flags;

	

	if (how & FLUSH_STABLE) {

		if (!NFS_I(inode)->ncommit)
@@ -2438,57 +2428,37 @@ nfs4_proc_write_setup(struct nfs_write_data *data, int how) 


	data->timestamp   = jiffies;



	/* Set the initial flags for the task.  */

	flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;



	/* Finalize the task. */

	rpc_init_task(task, NFS_CLIENT(inode), flags, &nfs4_write_ops, data);

	rpc_call_setup(task, &msg, 0);

	rpc_call_setup(&data->task, &msg, 0);

}



static void nfs4_commit_done(struct rpc_task *task, void *calldata)

static int nfs4_commit_done(struct rpc_task *task, struct nfs_write_data *data)

{

	struct nfs_write_data *data = calldata;

	struct inode *inode = data->inode;

	

	if (nfs4_async_handle_error(task, NFS_SERVER(inode)) == -EAGAIN) {

		rpc_restart_call(task);

		return;

		return -EAGAIN;

	}

	if (task->tk_status >= 0)

		nfs_post_op_update_inode(inode, data->res.fattr);

	/* Call back common NFS writeback processing */

	nfs_commit_done(task, calldata);

	return 0;

}



static const struct rpc_call_ops nfs4_commit_ops = {

	.rpc_call_done = nfs4_commit_done,

	.rpc_release = nfs_commit_release,

};



static void

nfs4_proc_commit_setup(struct nfs_write_data *data, int how)

static void nfs4_proc_commit_setup(struct nfs_write_data *data, int how)

{

	struct rpc_task	*task = &data->task;

	struct rpc_message msg = {

		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT],

		.rpc_argp = &data->args,

		.rpc_resp = &data->res,

		.rpc_cred = data->cred,

	};	

	struct inode *inode = data->inode;

	struct nfs_server *server = NFS_SERVER(inode);

	int flags;

	struct nfs_server *server = NFS_SERVER(data->inode);

	

	data->args.bitmask = server->attr_bitmask;

	data->res.server = server;



	/* Set the initial flags for the task.  */

	flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;



	/* Finalize the task. */

	rpc_init_task(task, NFS_CLIENT(inode), flags, &nfs4_commit_ops, data);

	rpc_call_setup(task, &msg, 0);	

	rpc_call_setup(&data->task, &msg, 0);

}



/*
@@ -3648,7 +3618,9 @@ struct nfs_rpc_ops nfs_v4_clientops = { 
	.decode_dirent	= nfs4_decode_dirent,

	.read_setup	= nfs4_proc_read_setup,

	.write_setup	= nfs4_proc_write_setup,

	.write_done	= nfs4_write_done,

	.commit_setup	= nfs4_proc_commit_setup,

	.commit_done	= nfs4_commit_done,

	.file_open      = nfs_open,

	.file_release   = nfs_release,

	.lock		= nfs4_proc_lock,

fs/nfs/proc.c

+5 −19
Original line number Diff line number Diff line
@@ -654,26 +654,15 @@ nfs_proc_read_setup(struct nfs_read_data *data) 
	rpc_call_setup(task, &msg, 0);

}



static void nfs_write_done(struct rpc_task *task, void *calldata)

static int nfs_write_done(struct rpc_task *task, struct nfs_write_data *data)

{

	struct nfs_write_data *data = calldata;



	if (task->tk_status >= 0)

		nfs_post_op_update_inode(data->inode, data->res.fattr);

	nfs_writeback_done(task, calldata);

	return 0;

}



static const struct rpc_call_ops nfs_write_ops = {

	.rpc_call_done = nfs_write_done,

	.rpc_release = nfs_writedata_release,

};



static void

nfs_proc_write_setup(struct nfs_write_data *data, int how)

static void nfs_proc_write_setup(struct nfs_write_data *data, int how)

{

	struct rpc_task		*task = &data->task;

	struct inode		*inode = data->inode;

	int			flags;

	struct rpc_message	msg = {

		.rpc_proc	= &nfs_procedures[NFSPROC_WRITE],

		.rpc_argp	= &data->args,
@@ -684,12 +673,8 @@ nfs_proc_write_setup(struct nfs_write_data *data, int how) 
	/* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */

	data->args.stable = NFS_FILE_SYNC;



	/* Set the initial flags for the task.  */

	flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;



	/* Finalize the task. */

	rpc_init_task(task, NFS_CLIENT(inode), flags, &nfs_write_ops, data);

	rpc_call_setup(task, &msg, 0);

	rpc_call_setup(&data->task, &msg, 0);

}



static void
@@ -736,6 +721,7 @@ struct nfs_rpc_ops nfs_v2_clientops = { 
	.decode_dirent	= nfs_decode_dirent,

	.read_setup	= nfs_proc_read_setup,

	.write_setup	= nfs_proc_write_setup,

	.write_done	= nfs_write_done,

	.commit_setup	= nfs_proc_commit_setup,

	.file_open	= nfs_open,

	.file_release	= nfs_release,

fs/nfs/write.c

+66 −26
Original line number Diff line number Diff line
@@ -77,12 +77,14 @@ static struct nfs_page * nfs_update_request(struct nfs_open_context*, 
					    struct inode *,

					    struct page *,

					    unsigned int, unsigned int);

static void nfs_writeback_done_partial(struct nfs_write_data *, int);

static void nfs_writeback_done_full(struct nfs_write_data *, int);

static int nfs_writeback_done(struct rpc_task *, struct nfs_write_data *);

static int nfs_wait_on_write_congestion(struct address_space *, int);

static int nfs_wait_on_requests(struct inode *, unsigned long, unsigned int);

static int nfs_flush_inode(struct inode *inode, unsigned long idx_start,

			   unsigned int npages, int how);

static const struct rpc_call_ops nfs_write_partial_ops;

static const struct rpc_call_ops nfs_write_full_ops;

static const struct rpc_call_ops nfs_commit_ops;



static kmem_cache_t *nfs_wdata_cachep;

mempool_t *nfs_wdata_mempool;
@@ -872,10 +874,12 @@ static inline int flush_task_priority(int how) 
 */

static void nfs_write_rpcsetup(struct nfs_page *req,

		struct nfs_write_data *data,

		const struct rpc_call_ops *call_ops,

		unsigned int count, unsigned int offset,

		int how)

{

	struct inode		*inode;

	int flags;



	/* Set up the RPC argument and reply structs

	 * NB: take care not to mess about with data->commit et al. */
@@ -896,6 +900,9 @@ static void nfs_write_rpcsetup(struct nfs_page *req, 
	data->res.verf    = &data->verf;

	nfs_fattr_init(&data->fattr);



	/* Set up the initial task struct.  */

	flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;

	rpc_init_task(&data->task, NFS_CLIENT(inode), flags, call_ops, data);

	NFS_PROTO(inode)->write_setup(data, how);



	data->task.tk_priority = flush_task_priority(how);
@@ -959,14 +966,15 @@ static int nfs_flush_multi(struct list_head *head, struct inode *inode, int how) 
		list_del_init(&data->pages);



		data->pagevec[0] = page;

		data->complete = nfs_writeback_done_partial;



		if (nbytes > wsize) {

			nfs_write_rpcsetup(req, data, wsize, offset, how);

			nfs_write_rpcsetup(req, data, &nfs_write_partial_ops,

					wsize, offset, how);

			offset += wsize;

			nbytes -= wsize;

		} else {

			nfs_write_rpcsetup(req, data, nbytes, offset, how);

			nfs_write_rpcsetup(req, data, &nfs_write_partial_ops,

					nbytes, offset, how);

			nbytes = 0;

		}

		nfs_execute_write(data);
@@ -1020,9 +1028,8 @@ static int nfs_flush_one(struct list_head *head, struct inode *inode, int how) 
	}

	req = nfs_list_entry(data->pages.next);



	data->complete = nfs_writeback_done_full;

	/* Set up the argument struct */

	nfs_write_rpcsetup(req, data, count, 0, how);

	nfs_write_rpcsetup(req, data, &nfs_write_full_ops, count, 0, how);



	nfs_execute_write(data);

	return 0;
@@ -1066,8 +1073,9 @@ nfs_flush_list(struct list_head *head, int wpages, int how) 
/*

 * Handle a write reply that flushed part of a page.

 */

static void nfs_writeback_done_partial(struct nfs_write_data *data, int status)

static void nfs_writeback_done_partial(struct rpc_task *task, void *calldata)

{

	struct nfs_write_data	*data = calldata;

	struct nfs_page		*req = data->req;

	struct page		*page = req->wb_page;
@@ -1077,11 +1085,14 @@ static void nfs_writeback_done_partial(struct nfs_write_data *data, int status) 
		req->wb_bytes,

		(long long)req_offset(req));



	if (status < 0) {

	if (nfs_writeback_done(task, data) != 0)

		return;



	if (task->tk_status < 0) {

		ClearPageUptodate(page);

		SetPageError(page);

		req->wb_context->error = status;

		dprintk(", error = %d\n", status);

		req->wb_context->error = task->tk_status;

		dprintk(", error = %d\n", task->tk_status);

	} else {

#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)

		if (data->verf.committed < NFS_FILE_SYNC) {
@@ -1102,6 +1113,11 @@ static void nfs_writeback_done_partial(struct nfs_write_data *data, int status) 
		nfs_writepage_release(req);

}



static const struct rpc_call_ops nfs_write_partial_ops = {

	.rpc_call_done = nfs_writeback_done_partial,

	.rpc_release = nfs_writedata_release,

};



/*

 * Handle a write reply that flushes a whole page.

 *
@@ -1109,11 +1125,15 @@ static void nfs_writeback_done_partial(struct nfs_write_data *data, int status) 
 *	  writebacks since the page->count is kept > 1 for as long

 *	  as the page has a write request pending.

 */

static void nfs_writeback_done_full(struct nfs_write_data *data, int status)

static void nfs_writeback_done_full(struct rpc_task *task, void *calldata)

{

	struct nfs_write_data	*data = calldata;

	struct nfs_page		*req;

	struct page		*page;



	if (nfs_writeback_done(task, data) != 0)

		return;



	/* Update attributes as result of writeback. */

	while (!list_empty(&data->pages)) {

		req = nfs_list_entry(data->pages.next);
@@ -1126,13 +1146,13 @@ static void nfs_writeback_done_full(struct nfs_write_data *data, int status) 
			req->wb_bytes,

			(long long)req_offset(req));



		if (status < 0) {

		if (task->tk_status < 0) {

			ClearPageUptodate(page);

			SetPageError(page);

			req->wb_context->error = status;

			req->wb_context->error = task->tk_status;

			end_page_writeback(page);

			nfs_inode_remove_request(req);

			dprintk(", error = %d\n", status);

			dprintk(", error = %d\n", task->tk_status);

			goto next;

		}

		end_page_writeback(page);
@@ -1154,18 +1174,28 @@ static void nfs_writeback_done_full(struct nfs_write_data *data, int status) 
	}

}



static const struct rpc_call_ops nfs_write_full_ops = {

	.rpc_call_done = nfs_writeback_done_full,

	.rpc_release = nfs_writedata_release,

};





/*

 * This function is called when the WRITE call is complete.

 */

void nfs_writeback_done(struct rpc_task *task, void *calldata)

static int nfs_writeback_done(struct rpc_task *task, struct nfs_write_data *data)

{

	struct nfs_write_data	*data = calldata;

	struct nfs_writeargs	*argp = &data->args;

	struct nfs_writeres	*resp = &data->res;

	int status;



	dprintk("NFS: %4d nfs_writeback_done (status %d)\n",

		task->tk_pid, task->tk_status);



	/* Call the NFS version-specific code */

	status = NFS_PROTO(data->inode)->write_done(task, data);

	if (status != 0)

		return status;

	nfs_add_stats(data->inode, NFSIOS_SERVERWRITTENBYTES, resp->count);



#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
@@ -1210,7 +1240,7 @@ void nfs_writeback_done(struct rpc_task *task, void *calldata) 
				argp->stable = NFS_FILE_SYNC;

			}

			rpc_restart_call(task);

			return;

			return -EAGAIN;

		}

		if (time_before(complain, jiffies)) {

			printk(KERN_WARNING
@@ -1221,11 +1251,7 @@ void nfs_writeback_done(struct rpc_task *task, void *calldata) 
		/* Can't do anything about it except throw an error. */

		task->tk_status = -EIO;

	}



	/*

	 * Process the nfs_page list

	 */

	data->complete(data, task->tk_status);

	return 0;

}
@@ -1239,10 +1265,12 @@ void nfs_commit_release(void *wdata) 
 * Set up the argument/result storage required for the RPC call.

 */

static void nfs_commit_rpcsetup(struct list_head *head,

		struct nfs_write_data *data, int how)

		struct nfs_write_data *data,

		int how)

{

	struct nfs_page		*first;

	struct inode		*inode;

	int flags;



	/* Set up the RPC argument and reply structs

	 * NB: take care not to mess about with data->commit et al. */
@@ -1263,6 +1291,9 @@ static void nfs_commit_rpcsetup(struct list_head *head, 
	data->res.verf    = &data->verf;

	nfs_fattr_init(&data->fattr);



	/* Set up the initial task struct.  */

	flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;

	rpc_init_task(&data->task, NFS_CLIENT(inode), flags, &nfs_commit_ops, data);

	NFS_PROTO(inode)->commit_setup(data, how);



	data->task.tk_priority = flush_task_priority(how);
@@ -1303,7 +1334,7 @@ nfs_commit_list(struct inode *inode, struct list_head *head, int how) 
/*

 * COMMIT call returned

 */

void nfs_commit_done(struct rpc_task *task, void *calldata)

static void nfs_commit_done(struct rpc_task *task, void *calldata)

{

	struct nfs_write_data	*data = calldata;

	struct nfs_page		*req;
@@ -1312,6 +1343,10 @@ void nfs_commit_done(struct rpc_task *task, void *calldata) 
        dprintk("NFS: %4d nfs_commit_done (status %d)\n",

                                task->tk_pid, task->tk_status);



	/* Call the NFS version-specific code */

	if (NFS_PROTO(data->inode)->commit_done(task, data) != 0)

		return;



	while (!list_empty(&data->pages)) {

		req = nfs_list_entry(data->pages.next);

		nfs_list_remove_request(req);
@@ -1345,6 +1380,11 @@ void nfs_commit_done(struct rpc_task *task, void *calldata) 
	}

	sub_page_state(nr_unstable,res);

}



static const struct rpc_call_ops nfs_commit_ops = {

	.rpc_call_done = nfs_commit_done,

	.rpc_release = nfs_commit_release,

};

#endif



static int nfs_flush_inode(struct inode *inode, unsigned long idx_start,

include/linux/nfs_fs.h

+0 −7
Original line number Diff line number Diff line
@@ -407,13 +407,6 @@ extern int nfs_writepage(struct page *page, struct writeback_control *wbc); 
extern int  nfs_writepages(struct address_space *, struct writeback_control *);

extern int  nfs_flush_incompatible(struct file *file, struct page *page);

extern int  nfs_updatepage(struct file *, struct page *, unsigned int, unsigned int);

extern void nfs_writeback_done(struct rpc_task *task, void *data);

extern void nfs_writedata_release(void *data);



#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)

extern void nfs_commit_done(struct rpc_task *, void *data);

extern void nfs_commit_release(void *data);

#endif



/*

 * Try to write back everything synchronously (but check the

CRA Git | Maintained and supported by SUSTech CRA and CCSE