xref: /openbmc/linux/fs/nfs/write.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
1 /*
2  * linux/fs/nfs/write.c
3  *
4  * Writing file data over NFS.
5  *
6  * We do it like this: When a (user) process wishes to write data to an
7  * NFS file, a write request is allocated that contains the RPC task data
8  * plus some info on the page to be written, and added to the inode's
9  * write chain. If the process writes past the end of the page, an async
10  * RPC call to write the page is scheduled immediately; otherwise, the call
11  * is delayed for a few seconds.
12  *
13  * Just like readahead, no async I/O is performed if wsize < PAGE_SIZE.
14  *
15  * Write requests are kept on the inode's writeback list. Each entry in
16  * that list references the page (portion) to be written. When the
17  * cache timeout has expired, the RPC task is woken up, and tries to
18  * lock the page. As soon as it manages to do so, the request is moved
19  * from the writeback list to the writelock list.
20  *
21  * Note: we must make sure never to confuse the inode passed in the
22  * write_page request with the one in page->inode. As far as I understand
23  * it, these are different when doing a swap-out.
24  *
25  * To understand everything that goes on here and in the NFS read code,
26  * one should be aware that a page is locked in exactly one of the following
27  * cases:
28  *
29  *  -	A write request is in progress.
30  *  -	A user process is in generic_file_write/nfs_update_page
31  *  -	A user process is in generic_file_read
32  *
33  * Also note that because of the way pages are invalidated in
34  * nfs_revalidate_inode, the following assertions hold:
35  *
36  *  -	If a page is dirty, there will be no read requests (a page will
37  *	not be re-read unless invalidated by nfs_revalidate_inode).
38  *  -	If the page is not uptodate, there will be no pending write
39  *	requests, and no process will be in nfs_update_page.
40  *
41  * FIXME: Interaction with the vmscan routines is not optimal yet.
42  * Either vmscan must be made nfs-savvy, or we need a different page
43  * reclaim concept that supports something like FS-independent
44  * buffer_heads with a b_ops-> field.
45  *
46  * Copyright (C) 1996, 1997, Olaf Kirch <okir@monad.swb.de>
47  */
48 
49 #include <linux/config.h>
50 #include <linux/types.h>
51 #include <linux/slab.h>
52 #include <linux/mm.h>
53 #include <linux/pagemap.h>
54 #include <linux/file.h>
55 #include <linux/mpage.h>
56 #include <linux/writeback.h>
57 
58 #include <linux/sunrpc/clnt.h>
59 #include <linux/nfs_fs.h>
60 #include <linux/nfs_mount.h>
61 #include <linux/nfs_page.h>
62 #include <asm/uaccess.h>
63 #include <linux/smp_lock.h>
64 
65 #include "delegation.h"
66 
67 #define NFSDBG_FACILITY		NFSDBG_PAGECACHE
68 
69 #define MIN_POOL_WRITE		(32)
70 #define MIN_POOL_COMMIT		(4)
71 
72 /*
73  * Local function declarations
74  */
75 static struct nfs_page * nfs_update_request(struct nfs_open_context*,
76 					    struct inode *,
77 					    struct page *,
78 					    unsigned int, unsigned int);
79 static void nfs_writeback_done_partial(struct nfs_write_data *, int);
80 static void nfs_writeback_done_full(struct nfs_write_data *, int);
81 static int nfs_wait_on_write_congestion(struct address_space *, int);
82 static int nfs_wait_on_requests(struct inode *, unsigned long, unsigned int);
83 static int nfs_flush_inode(struct inode *inode, unsigned long idx_start,
84 			   unsigned int npages, int how);
85 
86 static kmem_cache_t *nfs_wdata_cachep;
87 mempool_t *nfs_wdata_mempool;
88 static mempool_t *nfs_commit_mempool;
89 
90 static DECLARE_WAIT_QUEUE_HEAD(nfs_write_congestion);
91 
92 static inline struct nfs_write_data *nfs_commit_alloc(void)
93 {
94 	struct nfs_write_data *p = mempool_alloc(nfs_commit_mempool, SLAB_NOFS);
95 	if (p) {
96 		memset(p, 0, sizeof(*p));
97 		INIT_LIST_HEAD(&p->pages);
98 	}
99 	return p;
100 }
101 
102 static inline void nfs_commit_free(struct nfs_write_data *p)
103 {
104 	mempool_free(p, nfs_commit_mempool);
105 }
106 
107 static void nfs_writedata_release(struct rpc_task *task)
108 {
109 	struct nfs_write_data	*wdata = (struct nfs_write_data *)task->tk_calldata;
110 	nfs_writedata_free(wdata);
111 }
112 
113 /* Adjust the file length if we're writing beyond the end */
114 static void nfs_grow_file(struct page *page, unsigned int offset, unsigned int count)
115 {
116 	struct inode *inode = page->mapping->host;
117 	loff_t end, i_size = i_size_read(inode);
118 	unsigned long end_index = (i_size - 1) >> PAGE_CACHE_SHIFT;
119 
120 	if (i_size > 0 && page->index < end_index)
121 		return;
122 	end = ((loff_t)page->index << PAGE_CACHE_SHIFT) + ((loff_t)offset+count);
123 	if (i_size >= end)
124 		return;
125 	i_size_write(inode, end);
126 }
127 
128 /* We can set the PG_uptodate flag if we see that a write request
129  * covers the full page.
130  */
131 static void nfs_mark_uptodate(struct page *page, unsigned int base, unsigned int count)
132 {
133 	loff_t end_offs;
134 
135 	if (PageUptodate(page))
136 		return;
137 	if (base != 0)
138 		return;
139 	if (count == PAGE_CACHE_SIZE) {
140 		SetPageUptodate(page);
141 		return;
142 	}
143 
144 	end_offs = i_size_read(page->mapping->host) - 1;
145 	if (end_offs < 0)
146 		return;
147 	/* Is this the last page? */
148 	if (page->index != (unsigned long)(end_offs >> PAGE_CACHE_SHIFT))
149 		return;
150 	/* This is the last page: set PG_uptodate if we cover the entire
151 	 * extent of the data, then zero the rest of the page.
152 	 */
153 	if (count == (unsigned int)(end_offs & (PAGE_CACHE_SIZE - 1)) + 1) {
154 		memclear_highpage_flush(page, count, PAGE_CACHE_SIZE - count);
155 		SetPageUptodate(page);
156 	}
157 }
158 
159 /*
160  * Write a page synchronously.
161  * Offset is the data offset within the page.
162  */
163 static int nfs_writepage_sync(struct nfs_open_context *ctx, struct inode *inode,
164 		struct page *page, unsigned int offset, unsigned int count,
165 		int how)
166 {
167 	unsigned int	wsize = NFS_SERVER(inode)->wsize;
168 	int		result, written = 0;
169 	struct nfs_write_data *wdata;
170 
171 	wdata = nfs_writedata_alloc();
172 	if (!wdata)
173 		return -ENOMEM;
174 
175 	wdata->flags = how;
176 	wdata->cred = ctx->cred;
177 	wdata->inode = inode;
178 	wdata->args.fh = NFS_FH(inode);
179 	wdata->args.context = ctx;
180 	wdata->args.pages = &page;
181 	wdata->args.stable = NFS_FILE_SYNC;
182 	wdata->args.pgbase = offset;
183 	wdata->args.count = wsize;
184 	wdata->res.fattr = &wdata->fattr;
185 	wdata->res.verf = &wdata->verf;
186 
187 	dprintk("NFS:      nfs_writepage_sync(%s/%Ld %d@%Ld)\n",
188 		inode->i_sb->s_id,
189 		(long long)NFS_FILEID(inode),
190 		count, (long long)(page_offset(page) + offset));
191 
192 	nfs_begin_data_update(inode);
193 	do {
194 		if (count < wsize)
195 			wdata->args.count = count;
196 		wdata->args.offset = page_offset(page) + wdata->args.pgbase;
197 
198 		result = NFS_PROTO(inode)->write(wdata);
199 
200 		if (result < 0) {
201 			/* Must mark the page invalid after I/O error */
202 			ClearPageUptodate(page);
203 			goto io_error;
204 		}
205 		if (result < wdata->args.count)
206 			printk(KERN_WARNING "NFS: short write, count=%u, result=%d\n",
207 					wdata->args.count, result);
208 
209 		wdata->args.offset += result;
210 	        wdata->args.pgbase += result;
211 		written += result;
212 		count -= result;
213 	} while (count);
214 	/* Update file length */
215 	nfs_grow_file(page, offset, written);
216 	/* Set the PG_uptodate flag? */
217 	nfs_mark_uptodate(page, offset, written);
218 
219 	if (PageError(page))
220 		ClearPageError(page);
221 
222 io_error:
223 	nfs_end_data_update(inode);
224 	nfs_writedata_free(wdata);
225 	return written ? written : result;
226 }
227 
228 static int nfs_writepage_async(struct nfs_open_context *ctx,
229 		struct inode *inode, struct page *page,
230 		unsigned int offset, unsigned int count)
231 {
232 	struct nfs_page	*req;
233 	int		status;
234 
235 	req = nfs_update_request(ctx, inode, page, offset, count);
236 	status = (IS_ERR(req)) ? PTR_ERR(req) : 0;
237 	if (status < 0)
238 		goto out;
239 	/* Update file length */
240 	nfs_grow_file(page, offset, count);
241 	/* Set the PG_uptodate flag? */
242 	nfs_mark_uptodate(page, offset, count);
243 	nfs_unlock_request(req);
244  out:
245 	return status;
246 }
247 
248 static int wb_priority(struct writeback_control *wbc)
249 {
250 	if (wbc->for_reclaim)
251 		return FLUSH_HIGHPRI;
252 	if (wbc->for_kupdate)
253 		return FLUSH_LOWPRI;
254 	return 0;
255 }
256 
257 /*
258  * Write an mmapped page to the server.
259  */
260 int nfs_writepage(struct page *page, struct writeback_control *wbc)
261 {
262 	struct nfs_open_context *ctx;
263 	struct inode *inode = page->mapping->host;
264 	unsigned long end_index;
265 	unsigned offset = PAGE_CACHE_SIZE;
266 	loff_t i_size = i_size_read(inode);
267 	int inode_referenced = 0;
268 	int priority = wb_priority(wbc);
269 	int err;
270 
271 	/*
272 	 * Note: We need to ensure that we have a reference to the inode
273 	 *       if we are to do asynchronous writes. If not, waiting
274 	 *       in nfs_wait_on_request() may deadlock with clear_inode().
275 	 *
276 	 *       If igrab() fails here, then it is in any case safe to
277 	 *       call nfs_wb_page(), since there will be no pending writes.
278 	 */
279 	if (igrab(inode) != 0)
280 		inode_referenced = 1;
281 	end_index = i_size >> PAGE_CACHE_SHIFT;
282 
283 	/* Ensure we've flushed out any previous writes */
284 	nfs_wb_page_priority(inode, page, priority);
285 
286 	/* easy case */
287 	if (page->index < end_index)
288 		goto do_it;
289 	/* things got complicated... */
290 	offset = i_size & (PAGE_CACHE_SIZE-1);
291 
292 	/* OK, are we completely out? */
293 	err = 0; /* potential race with truncate - ignore */
294 	if (page->index >= end_index+1 || !offset)
295 		goto out;
296 do_it:
297 	ctx = nfs_find_open_context(inode, NULL, FMODE_WRITE);
298 	if (ctx == NULL) {
299 		err = -EBADF;
300 		goto out;
301 	}
302 	lock_kernel();
303 	if (!IS_SYNC(inode) && inode_referenced) {
304 		err = nfs_writepage_async(ctx, inode, page, 0, offset);
305 		if (err >= 0) {
306 			err = 0;
307 			if (wbc->for_reclaim)
308 				nfs_flush_inode(inode, 0, 0, FLUSH_STABLE);
309 		}
310 	} else {
311 		err = nfs_writepage_sync(ctx, inode, page, 0,
312 						offset, priority);
313 		if (err >= 0) {
314 			if (err != offset)
315 				redirty_page_for_writepage(wbc, page);
316 			err = 0;
317 		}
318 	}
319 	unlock_kernel();
320 	put_nfs_open_context(ctx);
321 out:
322 	unlock_page(page);
323 	if (inode_referenced)
324 		iput(inode);
325 	return err;
326 }
327 
328 /*
329  * Note: causes nfs_update_request() to block on the assumption
330  * 	 that the writeback is generated due to memory pressure.
331  */
332 int nfs_writepages(struct address_space *mapping, struct writeback_control *wbc)
333 {
334 	struct backing_dev_info *bdi = mapping->backing_dev_info;
335 	struct inode *inode = mapping->host;
336 	int err;
337 
338 	err = generic_writepages(mapping, wbc);
339 	if (err)
340 		return err;
341 	while (test_and_set_bit(BDI_write_congested, &bdi->state) != 0) {
342 		if (wbc->nonblocking)
343 			return 0;
344 		nfs_wait_on_write_congestion(mapping, 0);
345 	}
346 	err = nfs_flush_inode(inode, 0, 0, wb_priority(wbc));
347 	if (err < 0)
348 		goto out;
349 	wbc->nr_to_write -= err;
350 	if (!wbc->nonblocking && wbc->sync_mode == WB_SYNC_ALL) {
351 		err = nfs_wait_on_requests(inode, 0, 0);
352 		if (err < 0)
353 			goto out;
354 	}
355 	err = nfs_commit_inode(inode, wb_priority(wbc));
356 	if (err > 0) {
357 		wbc->nr_to_write -= err;
358 		err = 0;
359 	}
360 out:
361 	clear_bit(BDI_write_congested, &bdi->state);
362 	wake_up_all(&nfs_write_congestion);
363 	return err;
364 }
365 
366 /*
367  * Insert a write request into an inode
368  */
369 static int nfs_inode_add_request(struct inode *inode, struct nfs_page *req)
370 {
371 	struct nfs_inode *nfsi = NFS_I(inode);
372 	int error;
373 
374 	error = radix_tree_insert(&nfsi->nfs_page_tree, req->wb_index, req);
375 	BUG_ON(error == -EEXIST);
376 	if (error)
377 		return error;
378 	if (!nfsi->npages) {
379 		igrab(inode);
380 		nfs_begin_data_update(inode);
381 		if (nfs_have_delegation(inode, FMODE_WRITE))
382 			nfsi->change_attr++;
383 	}
384 	nfsi->npages++;
385 	atomic_inc(&req->wb_count);
386 	return 0;
387 }
388 
389 /*
390  * Insert a write request into an inode
391  */
392 static void nfs_inode_remove_request(struct nfs_page *req)
393 {
394 	struct inode *inode = req->wb_context->dentry->d_inode;
395 	struct nfs_inode *nfsi = NFS_I(inode);
396 
397 	BUG_ON (!NFS_WBACK_BUSY(req));
398 
399 	spin_lock(&nfsi->req_lock);
400 	radix_tree_delete(&nfsi->nfs_page_tree, req->wb_index);
401 	nfsi->npages--;
402 	if (!nfsi->npages) {
403 		spin_unlock(&nfsi->req_lock);
404 		nfs_end_data_update(inode);
405 		iput(inode);
406 	} else
407 		spin_unlock(&nfsi->req_lock);
408 	nfs_clear_request(req);
409 	nfs_release_request(req);
410 }
411 
412 /*
413  * Find a request
414  */
415 static inline struct nfs_page *
416 _nfs_find_request(struct inode *inode, unsigned long index)
417 {
418 	struct nfs_inode *nfsi = NFS_I(inode);
419 	struct nfs_page *req;
420 
421 	req = (struct nfs_page*)radix_tree_lookup(&nfsi->nfs_page_tree, index);
422 	if (req)
423 		atomic_inc(&req->wb_count);
424 	return req;
425 }
426 
427 static struct nfs_page *
428 nfs_find_request(struct inode *inode, unsigned long index)
429 {
430 	struct nfs_page		*req;
431 	struct nfs_inode	*nfsi = NFS_I(inode);
432 
433 	spin_lock(&nfsi->req_lock);
434 	req = _nfs_find_request(inode, index);
435 	spin_unlock(&nfsi->req_lock);
436 	return req;
437 }
438 
439 /*
440  * Add a request to the inode's dirty list.
441  */
442 static void
443 nfs_mark_request_dirty(struct nfs_page *req)
444 {
445 	struct inode *inode = req->wb_context->dentry->d_inode;
446 	struct nfs_inode *nfsi = NFS_I(inode);
447 
448 	spin_lock(&nfsi->req_lock);
449 	radix_tree_tag_set(&nfsi->nfs_page_tree,
450 			req->wb_index, NFS_PAGE_TAG_DIRTY);
451 	nfs_list_add_request(req, &nfsi->dirty);
452 	nfsi->ndirty++;
453 	spin_unlock(&nfsi->req_lock);
454 	inc_page_state(nr_dirty);
455 	mark_inode_dirty(inode);
456 }
457 
458 /*
459  * Check if a request is dirty
460  */
461 static inline int
462 nfs_dirty_request(struct nfs_page *req)
463 {
464 	struct nfs_inode *nfsi = NFS_I(req->wb_context->dentry->d_inode);
465 	return !list_empty(&req->wb_list) && req->wb_list_head == &nfsi->dirty;
466 }
467 
468 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
469 /*
470  * Add a request to the inode's commit list.
471  */
472 static void
473 nfs_mark_request_commit(struct nfs_page *req)
474 {
475 	struct inode *inode = req->wb_context->dentry->d_inode;
476 	struct nfs_inode *nfsi = NFS_I(inode);
477 
478 	spin_lock(&nfsi->req_lock);
479 	nfs_list_add_request(req, &nfsi->commit);
480 	nfsi->ncommit++;
481 	spin_unlock(&nfsi->req_lock);
482 	inc_page_state(nr_unstable);
483 	mark_inode_dirty(inode);
484 }
485 #endif
486 
487 /*
488  * Wait for a request to complete.
489  *
490  * Interruptible by signals only if mounted with intr flag.
491  */
492 static int
493 nfs_wait_on_requests(struct inode *inode, unsigned long idx_start, unsigned int npages)
494 {
495 	struct nfs_inode *nfsi = NFS_I(inode);
496 	struct nfs_page *req;
497 	unsigned long		idx_end, next;
498 	unsigned int		res = 0;
499 	int			error;
500 
501 	if (npages == 0)
502 		idx_end = ~0;
503 	else
504 		idx_end = idx_start + npages - 1;
505 
506 	spin_lock(&nfsi->req_lock);
507 	next = idx_start;
508 	while (radix_tree_gang_lookup_tag(&nfsi->nfs_page_tree, (void **)&req, next, 1, NFS_PAGE_TAG_WRITEBACK)) {
509 		if (req->wb_index > idx_end)
510 			break;
511 
512 		next = req->wb_index + 1;
513 		BUG_ON(!NFS_WBACK_BUSY(req));
514 
515 		atomic_inc(&req->wb_count);
516 		spin_unlock(&nfsi->req_lock);
517 		error = nfs_wait_on_request(req);
518 		nfs_release_request(req);
519 		if (error < 0)
520 			return error;
521 		spin_lock(&nfsi->req_lock);
522 		res++;
523 	}
524 	spin_unlock(&nfsi->req_lock);
525 	return res;
526 }
527 
528 /*
529  * nfs_scan_dirty - Scan an inode for dirty requests
530  * @inode: NFS inode to scan
531  * @dst: destination list
532  * @idx_start: lower bound of page->index to scan.
533  * @npages: idx_start + npages sets the upper bound to scan.
534  *
535  * Moves requests from the inode's dirty page list.
536  * The requests are *not* checked to ensure that they form a contiguous set.
537  */
538 static int
539 nfs_scan_dirty(struct inode *inode, struct list_head *dst, unsigned long idx_start, unsigned int npages)
540 {
541 	struct nfs_inode *nfsi = NFS_I(inode);
542 	int res = 0;
543 
544 	if (nfsi->ndirty != 0) {
545 		res = nfs_scan_lock_dirty(nfsi, dst, idx_start, npages);
546 		nfsi->ndirty -= res;
547 		sub_page_state(nr_dirty,res);
548 		if ((nfsi->ndirty == 0) != list_empty(&nfsi->dirty))
549 			printk(KERN_ERR "NFS: desynchronized value of nfs_i.ndirty.\n");
550 	}
551 	return res;
552 }
553 
554 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
555 /*
556  * nfs_scan_commit - Scan an inode for commit requests
557  * @inode: NFS inode to scan
558  * @dst: destination list
559  * @idx_start: lower bound of page->index to scan.
560  * @npages: idx_start + npages sets the upper bound to scan.
561  *
562  * Moves requests from the inode's 'commit' request list.
563  * The requests are *not* checked to ensure that they form a contiguous set.
564  */
565 static int
566 nfs_scan_commit(struct inode *inode, struct list_head *dst, unsigned long idx_start, unsigned int npages)
567 {
568 	struct nfs_inode *nfsi = NFS_I(inode);
569 	int res = 0;
570 
571 	if (nfsi->ncommit != 0) {
572 		res = nfs_scan_list(&nfsi->commit, dst, idx_start, npages);
573 		nfsi->ncommit -= res;
574 		if ((nfsi->ncommit == 0) != list_empty(&nfsi->commit))
575 			printk(KERN_ERR "NFS: desynchronized value of nfs_i.ncommit.\n");
576 	}
577 	return res;
578 }
579 #endif
580 
581 static int nfs_wait_on_write_congestion(struct address_space *mapping, int intr)
582 {
583 	struct backing_dev_info *bdi = mapping->backing_dev_info;
584 	DEFINE_WAIT(wait);
585 	int ret = 0;
586 
587 	might_sleep();
588 
589 	if (!bdi_write_congested(bdi))
590 		return 0;
591 	if (intr) {
592 		struct rpc_clnt *clnt = NFS_CLIENT(mapping->host);
593 		sigset_t oldset;
594 
595 		rpc_clnt_sigmask(clnt, &oldset);
596 		prepare_to_wait(&nfs_write_congestion, &wait, TASK_INTERRUPTIBLE);
597 		if (bdi_write_congested(bdi)) {
598 			if (signalled())
599 				ret = -ERESTARTSYS;
600 			else
601 				schedule();
602 		}
603 		rpc_clnt_sigunmask(clnt, &oldset);
604 	} else {
605 		prepare_to_wait(&nfs_write_congestion, &wait, TASK_UNINTERRUPTIBLE);
606 		if (bdi_write_congested(bdi))
607 			schedule();
608 	}
609 	finish_wait(&nfs_write_congestion, &wait);
610 	return ret;
611 }
612 
613 
614 /*
615  * Try to update any existing write request, or create one if there is none.
616  * In order to match, the request's credentials must match those of
617  * the calling process.
618  *
619  * Note: Should always be called with the Page Lock held!
620  */
621 static struct nfs_page * nfs_update_request(struct nfs_open_context* ctx,
622 		struct inode *inode, struct page *page,
623 		unsigned int offset, unsigned int bytes)
624 {
625 	struct nfs_server *server = NFS_SERVER(inode);
626 	struct nfs_inode *nfsi = NFS_I(inode);
627 	struct nfs_page		*req, *new = NULL;
628 	unsigned long		rqend, end;
629 
630 	end = offset + bytes;
631 
632 	if (nfs_wait_on_write_congestion(page->mapping, server->flags & NFS_MOUNT_INTR))
633 		return ERR_PTR(-ERESTARTSYS);
634 	for (;;) {
635 		/* Loop over all inode entries and see if we find
636 		 * A request for the page we wish to update
637 		 */
638 		spin_lock(&nfsi->req_lock);
639 		req = _nfs_find_request(inode, page->index);
640 		if (req) {
641 			if (!nfs_lock_request_dontget(req)) {
642 				int error;
643 				spin_unlock(&nfsi->req_lock);
644 				error = nfs_wait_on_request(req);
645 				nfs_release_request(req);
646 				if (error < 0)
647 					return ERR_PTR(error);
648 				continue;
649 			}
650 			spin_unlock(&nfsi->req_lock);
651 			if (new)
652 				nfs_release_request(new);
653 			break;
654 		}
655 
656 		if (new) {
657 			int error;
658 			nfs_lock_request_dontget(new);
659 			error = nfs_inode_add_request(inode, new);
660 			if (error) {
661 				spin_unlock(&nfsi->req_lock);
662 				nfs_unlock_request(new);
663 				return ERR_PTR(error);
664 			}
665 			spin_unlock(&nfsi->req_lock);
666 			nfs_mark_request_dirty(new);
667 			return new;
668 		}
669 		spin_unlock(&nfsi->req_lock);
670 
671 		new = nfs_create_request(ctx, inode, page, offset, bytes);
672 		if (IS_ERR(new))
673 			return new;
674 	}
675 
676 	/* We have a request for our page.
677 	 * If the creds don't match, or the
678 	 * page addresses don't match,
679 	 * tell the caller to wait on the conflicting
680 	 * request.
681 	 */
682 	rqend = req->wb_offset + req->wb_bytes;
683 	if (req->wb_context != ctx
684 	    || req->wb_page != page
685 	    || !nfs_dirty_request(req)
686 	    || offset > rqend || end < req->wb_offset) {
687 		nfs_unlock_request(req);
688 		return ERR_PTR(-EBUSY);
689 	}
690 
691 	/* Okay, the request matches. Update the region */
692 	if (offset < req->wb_offset) {
693 		req->wb_offset = offset;
694 		req->wb_pgbase = offset;
695 		req->wb_bytes = rqend - req->wb_offset;
696 	}
697 
698 	if (end > rqend)
699 		req->wb_bytes = end - req->wb_offset;
700 
701 	return req;
702 }
703 
704 int nfs_flush_incompatible(struct file *file, struct page *page)
705 {
706 	struct nfs_open_context *ctx = (struct nfs_open_context *)file->private_data;
707 	struct inode	*inode = page->mapping->host;
708 	struct nfs_page	*req;
709 	int		status = 0;
710 	/*
711 	 * Look for a request corresponding to this page. If there
712 	 * is one, and it belongs to another file, we flush it out
713 	 * before we try to copy anything into the page. Do this
714 	 * due to the lack of an ACCESS-type call in NFSv2.
715 	 * Also do the same if we find a request from an existing
716 	 * dropped page.
717 	 */
718 	req = nfs_find_request(inode, page->index);
719 	if (req) {
720 		if (req->wb_page != page || ctx != req->wb_context)
721 			status = nfs_wb_page(inode, page);
722 		nfs_release_request(req);
723 	}
724 	return (status < 0) ? status : 0;
725 }
726 
727 /*
728  * Update and possibly write a cached page of an NFS file.
729  *
730  * XXX: Keep an eye on generic_file_read to make sure it doesn't do bad
731  * things with a page scheduled for an RPC call (e.g. invalidate it).
732  */
733 int nfs_updatepage(struct file *file, struct page *page,
734 		unsigned int offset, unsigned int count)
735 {
736 	struct nfs_open_context *ctx = (struct nfs_open_context *)file->private_data;
737 	struct inode	*inode = page->mapping->host;
738 	struct nfs_page	*req;
739 	int		status = 0;
740 
741 	dprintk("NFS:      nfs_updatepage(%s/%s %d@%Ld)\n",
742 		file->f_dentry->d_parent->d_name.name,
743 		file->f_dentry->d_name.name, count,
744 		(long long)(page_offset(page) +offset));
745 
746 	if (IS_SYNC(inode)) {
747 		status = nfs_writepage_sync(ctx, inode, page, offset, count, 0);
748 		if (status > 0) {
749 			if (offset == 0 && status == PAGE_CACHE_SIZE)
750 				SetPageUptodate(page);
751 			return 0;
752 		}
753 		return status;
754 	}
755 
756 	/* If we're not using byte range locks, and we know the page
757 	 * is entirely in cache, it may be more efficient to avoid
758 	 * fragmenting write requests.
759 	 */
760 	if (PageUptodate(page) && inode->i_flock == NULL && !(file->f_mode & O_SYNC)) {
761 		loff_t end_offs = i_size_read(inode) - 1;
762 		unsigned long end_index = end_offs >> PAGE_CACHE_SHIFT;
763 
764 		count += offset;
765 		offset = 0;
766 		if (unlikely(end_offs < 0)) {
767 			/* Do nothing */
768 		} else if (page->index == end_index) {
769 			unsigned int pglen;
770 			pglen = (unsigned int)(end_offs & (PAGE_CACHE_SIZE-1)) + 1;
771 			if (count < pglen)
772 				count = pglen;
773 		} else if (page->index < end_index)
774 			count = PAGE_CACHE_SIZE;
775 	}
776 
777 	/*
778 	 * Try to find an NFS request corresponding to this page
779 	 * and update it.
780 	 * If the existing request cannot be updated, we must flush
781 	 * it out now.
782 	 */
783 	do {
784 		req = nfs_update_request(ctx, inode, page, offset, count);
785 		status = (IS_ERR(req)) ? PTR_ERR(req) : 0;
786 		if (status != -EBUSY)
787 			break;
788 		/* Request could not be updated. Flush it out and try again */
789 		status = nfs_wb_page(inode, page);
790 	} while (status >= 0);
791 	if (status < 0)
792 		goto done;
793 
794 	status = 0;
795 
796 	/* Update file length */
797 	nfs_grow_file(page, offset, count);
798 	/* Set the PG_uptodate flag? */
799 	nfs_mark_uptodate(page, req->wb_pgbase, req->wb_bytes);
800 	nfs_unlock_request(req);
801 done:
802         dprintk("NFS:      nfs_updatepage returns %d (isize %Ld)\n",
803 			status, (long long)i_size_read(inode));
804 	if (status < 0)
805 		ClearPageUptodate(page);
806 	return status;
807 }
808 
809 static void nfs_writepage_release(struct nfs_page *req)
810 {
811 	end_page_writeback(req->wb_page);
812 
813 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
814 	if (!PageError(req->wb_page)) {
815 		if (NFS_NEED_RESCHED(req)) {
816 			nfs_mark_request_dirty(req);
817 			goto out;
818 		} else if (NFS_NEED_COMMIT(req)) {
819 			nfs_mark_request_commit(req);
820 			goto out;
821 		}
822 	}
823 	nfs_inode_remove_request(req);
824 
825 out:
826 	nfs_clear_commit(req);
827 	nfs_clear_reschedule(req);
828 #else
829 	nfs_inode_remove_request(req);
830 #endif
831 	nfs_clear_page_writeback(req);
832 }
833 
834 static inline int flush_task_priority(int how)
835 {
836 	switch (how & (FLUSH_HIGHPRI|FLUSH_LOWPRI)) {
837 		case FLUSH_HIGHPRI:
838 			return RPC_PRIORITY_HIGH;
839 		case FLUSH_LOWPRI:
840 			return RPC_PRIORITY_LOW;
841 	}
842 	return RPC_PRIORITY_NORMAL;
843 }
844 
845 /*
846  * Set up the argument/result storage required for the RPC call.
847  */
848 static void nfs_write_rpcsetup(struct nfs_page *req,
849 		struct nfs_write_data *data,
850 		unsigned int count, unsigned int offset,
851 		int how)
852 {
853 	struct inode		*inode;
854 
855 	/* Set up the RPC argument and reply structs
856 	 * NB: take care not to mess about with data->commit et al. */
857 
858 	data->req = req;
859 	data->inode = inode = req->wb_context->dentry->d_inode;
860 	data->cred = req->wb_context->cred;
861 
862 	data->args.fh     = NFS_FH(inode);
863 	data->args.offset = req_offset(req) + offset;
864 	data->args.pgbase = req->wb_pgbase + offset;
865 	data->args.pages  = data->pagevec;
866 	data->args.count  = count;
867 	data->args.context = req->wb_context;
868 
869 	data->res.fattr   = &data->fattr;
870 	data->res.count   = count;
871 	data->res.verf    = &data->verf;
872 	nfs_fattr_init(&data->fattr);
873 
874 	NFS_PROTO(inode)->write_setup(data, how);
875 
876 	data->task.tk_priority = flush_task_priority(how);
877 	data->task.tk_cookie = (unsigned long)inode;
878 	data->task.tk_calldata = data;
879 	/* Release requests */
880 	data->task.tk_release = nfs_writedata_release;
881 
882 	dprintk("NFS: %4d initiated write call (req %s/%Ld, %u bytes @ offset %Lu)\n",
883 		data->task.tk_pid,
884 		inode->i_sb->s_id,
885 		(long long)NFS_FILEID(inode),
886 		count,
887 		(unsigned long long)data->args.offset);
888 }
889 
890 static void nfs_execute_write(struct nfs_write_data *data)
891 {
892 	struct rpc_clnt *clnt = NFS_CLIENT(data->inode);
893 	sigset_t oldset;
894 
895 	rpc_clnt_sigmask(clnt, &oldset);
896 	lock_kernel();
897 	rpc_execute(&data->task);
898 	unlock_kernel();
899 	rpc_clnt_sigunmask(clnt, &oldset);
900 }
901 
902 /*
903  * Generate multiple small requests to write out a single
904  * contiguous dirty area on one page.
905  */
906 static int nfs_flush_multi(struct list_head *head, struct inode *inode, int how)
907 {
908 	struct nfs_page *req = nfs_list_entry(head->next);
909 	struct page *page = req->wb_page;
910 	struct nfs_write_data *data;
911 	unsigned int wsize = NFS_SERVER(inode)->wsize;
912 	unsigned int nbytes, offset;
913 	int requests = 0;
914 	LIST_HEAD(list);
915 
916 	nfs_list_remove_request(req);
917 
918 	nbytes = req->wb_bytes;
919 	for (;;) {
920 		data = nfs_writedata_alloc();
921 		if (!data)
922 			goto out_bad;
923 		list_add(&data->pages, &list);
924 		requests++;
925 		if (nbytes <= wsize)
926 			break;
927 		nbytes -= wsize;
928 	}
929 	atomic_set(&req->wb_complete, requests);
930 
931 	ClearPageError(page);
932 	SetPageWriteback(page);
933 	offset = 0;
934 	nbytes = req->wb_bytes;
935 	do {
936 		data = list_entry(list.next, struct nfs_write_data, pages);
937 		list_del_init(&data->pages);
938 
939 		data->pagevec[0] = page;
940 		data->complete = nfs_writeback_done_partial;
941 
942 		if (nbytes > wsize) {
943 			nfs_write_rpcsetup(req, data, wsize, offset, how);
944 			offset += wsize;
945 			nbytes -= wsize;
946 		} else {
947 			nfs_write_rpcsetup(req, data, nbytes, offset, how);
948 			nbytes = 0;
949 		}
950 		nfs_execute_write(data);
951 	} while (nbytes != 0);
952 
953 	return 0;
954 
955 out_bad:
956 	while (!list_empty(&list)) {
957 		data = list_entry(list.next, struct nfs_write_data, pages);
958 		list_del(&data->pages);
959 		nfs_writedata_free(data);
960 	}
961 	nfs_mark_request_dirty(req);
962 	nfs_clear_page_writeback(req);
963 	return -ENOMEM;
964 }
965 
966 /*
967  * Create an RPC task for the given write request and kick it.
968  * The page must have been locked by the caller.
969  *
970  * It may happen that the page we're passed is not marked dirty.
971  * This is the case if nfs_updatepage detects a conflicting request
972  * that has been written but not committed.
973  */
974 static int nfs_flush_one(struct list_head *head, struct inode *inode, int how)
975 {
976 	struct nfs_page		*req;
977 	struct page		**pages;
978 	struct nfs_write_data	*data;
979 	unsigned int		count;
980 
981 	if (NFS_SERVER(inode)->wsize < PAGE_CACHE_SIZE)
982 		return nfs_flush_multi(head, inode, how);
983 
984 	data = nfs_writedata_alloc();
985 	if (!data)
986 		goto out_bad;
987 
988 	pages = data->pagevec;
989 	count = 0;
990 	while (!list_empty(head)) {
991 		req = nfs_list_entry(head->next);
992 		nfs_list_remove_request(req);
993 		nfs_list_add_request(req, &data->pages);
994 		ClearPageError(req->wb_page);
995 		SetPageWriteback(req->wb_page);
996 		*pages++ = req->wb_page;
997 		count += req->wb_bytes;
998 	}
999 	req = nfs_list_entry(data->pages.next);
1000 
1001 	data->complete = nfs_writeback_done_full;
1002 	/* Set up the argument struct */
1003 	nfs_write_rpcsetup(req, data, count, 0, how);
1004 
1005 	nfs_execute_write(data);
1006 	return 0;
1007  out_bad:
1008 	while (!list_empty(head)) {
1009 		struct nfs_page *req = nfs_list_entry(head->next);
1010 		nfs_list_remove_request(req);
1011 		nfs_mark_request_dirty(req);
1012 		nfs_clear_page_writeback(req);
1013 	}
1014 	return -ENOMEM;
1015 }
1016 
1017 static int
1018 nfs_flush_list(struct list_head *head, int wpages, int how)
1019 {
1020 	LIST_HEAD(one_request);
1021 	struct nfs_page		*req;
1022 	int			error = 0;
1023 	unsigned int		pages = 0;
1024 
1025 	while (!list_empty(head)) {
1026 		pages += nfs_coalesce_requests(head, &one_request, wpages);
1027 		req = nfs_list_entry(one_request.next);
1028 		error = nfs_flush_one(&one_request, req->wb_context->dentry->d_inode, how);
1029 		if (error < 0)
1030 			break;
1031 	}
1032 	if (error >= 0)
1033 		return pages;
1034 
1035 	while (!list_empty(head)) {
1036 		req = nfs_list_entry(head->next);
1037 		nfs_list_remove_request(req);
1038 		nfs_mark_request_dirty(req);
1039 		nfs_clear_page_writeback(req);
1040 	}
1041 	return error;
1042 }
1043 
1044 /*
1045  * Handle a write reply that flushed part of a page.
1046  */
1047 static void nfs_writeback_done_partial(struct nfs_write_data *data, int status)
1048 {
1049 	struct nfs_page		*req = data->req;
1050 	struct page		*page = req->wb_page;
1051 
1052 	dprintk("NFS: write (%s/%Ld %d@%Ld)",
1053 		req->wb_context->dentry->d_inode->i_sb->s_id,
1054 		(long long)NFS_FILEID(req->wb_context->dentry->d_inode),
1055 		req->wb_bytes,
1056 		(long long)req_offset(req));
1057 
1058 	if (status < 0) {
1059 		ClearPageUptodate(page);
1060 		SetPageError(page);
1061 		req->wb_context->error = status;
1062 		dprintk(", error = %d\n", status);
1063 	} else {
1064 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
1065 		if (data->verf.committed < NFS_FILE_SYNC) {
1066 			if (!NFS_NEED_COMMIT(req)) {
1067 				nfs_defer_commit(req);
1068 				memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf));
1069 				dprintk(" defer commit\n");
1070 			} else if (memcmp(&req->wb_verf, &data->verf, sizeof(req->wb_verf))) {
1071 				nfs_defer_reschedule(req);
1072 				dprintk(" server reboot detected\n");
1073 			}
1074 		} else
1075 #endif
1076 			dprintk(" OK\n");
1077 	}
1078 
1079 	if (atomic_dec_and_test(&req->wb_complete))
1080 		nfs_writepage_release(req);
1081 }
1082 
1083 /*
1084  * Handle a write reply that flushes a whole page.
1085  *
1086  * FIXME: There is an inherent race with invalidate_inode_pages and
1087  *	  writebacks since the page->count is kept > 1 for as long
1088  *	  as the page has a write request pending.
1089  */
1090 static void nfs_writeback_done_full(struct nfs_write_data *data, int status)
1091 {
1092 	struct nfs_page		*req;
1093 	struct page		*page;
1094 
1095 	/* Update attributes as result of writeback. */
1096 	while (!list_empty(&data->pages)) {
1097 		req = nfs_list_entry(data->pages.next);
1098 		nfs_list_remove_request(req);
1099 		page = req->wb_page;
1100 
1101 		dprintk("NFS: write (%s/%Ld %d@%Ld)",
1102 			req->wb_context->dentry->d_inode->i_sb->s_id,
1103 			(long long)NFS_FILEID(req->wb_context->dentry->d_inode),
1104 			req->wb_bytes,
1105 			(long long)req_offset(req));
1106 
1107 		if (status < 0) {
1108 			ClearPageUptodate(page);
1109 			SetPageError(page);
1110 			req->wb_context->error = status;
1111 			end_page_writeback(page);
1112 			nfs_inode_remove_request(req);
1113 			dprintk(", error = %d\n", status);
1114 			goto next;
1115 		}
1116 		end_page_writeback(page);
1117 
1118 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
1119 		if (data->args.stable != NFS_UNSTABLE || data->verf.committed == NFS_FILE_SYNC) {
1120 			nfs_inode_remove_request(req);
1121 			dprintk(" OK\n");
1122 			goto next;
1123 		}
1124 		memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf));
1125 		nfs_mark_request_commit(req);
1126 		dprintk(" marked for commit\n");
1127 #else
1128 		nfs_inode_remove_request(req);
1129 #endif
1130 	next:
1131 		nfs_clear_page_writeback(req);
1132 	}
1133 }
1134 
1135 /*
1136  * This function is called when the WRITE call is complete.
1137  */
1138 void nfs_writeback_done(struct rpc_task *task)
1139 {
1140 	struct nfs_write_data	*data = (struct nfs_write_data *) task->tk_calldata;
1141 	struct nfs_writeargs	*argp = &data->args;
1142 	struct nfs_writeres	*resp = &data->res;
1143 
1144 	dprintk("NFS: %4d nfs_writeback_done (status %d)\n",
1145 		task->tk_pid, task->tk_status);
1146 
1147 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
1148 	if (resp->verf->committed < argp->stable && task->tk_status >= 0) {
1149 		/* We tried a write call, but the server did not
1150 		 * commit data to stable storage even though we
1151 		 * requested it.
1152 		 * Note: There is a known bug in Tru64 < 5.0 in which
1153 		 *	 the server reports NFS_DATA_SYNC, but performs
1154 		 *	 NFS_FILE_SYNC. We therefore implement this checking
1155 		 *	 as a dprintk() in order to avoid filling syslog.
1156 		 */
1157 		static unsigned long    complain;
1158 
1159 		if (time_before(complain, jiffies)) {
1160 			dprintk("NFS: faulty NFS server %s:"
1161 				" (committed = %d) != (stable = %d)\n",
1162 				NFS_SERVER(data->inode)->hostname,
1163 				resp->verf->committed, argp->stable);
1164 			complain = jiffies + 300 * HZ;
1165 		}
1166 	}
1167 #endif
1168 	/* Is this a short write? */
1169 	if (task->tk_status >= 0 && resp->count < argp->count) {
1170 		static unsigned long    complain;
1171 
1172 		/* Has the server at least made some progress? */
1173 		if (resp->count != 0) {
1174 			/* Was this an NFSv2 write or an NFSv3 stable write? */
1175 			if (resp->verf->committed != NFS_UNSTABLE) {
1176 				/* Resend from where the server left off */
1177 				argp->offset += resp->count;
1178 				argp->pgbase += resp->count;
1179 				argp->count -= resp->count;
1180 			} else {
1181 				/* Resend as a stable write in order to avoid
1182 				 * headaches in the case of a server crash.
1183 				 */
1184 				argp->stable = NFS_FILE_SYNC;
1185 			}
1186 			rpc_restart_call(task);
1187 			return;
1188 		}
1189 		if (time_before(complain, jiffies)) {
1190 			printk(KERN_WARNING
1191 			       "NFS: Server wrote zero bytes, expected %u.\n",
1192 					argp->count);
1193 			complain = jiffies + 300 * HZ;
1194 		}
1195 		/* Can't do anything about it except throw an error. */
1196 		task->tk_status = -EIO;
1197 	}
1198 
1199 	/*
1200 	 * Process the nfs_page list
1201 	 */
1202 	data->complete(data, task->tk_status);
1203 }
1204 
1205 
1206 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
1207 static void nfs_commit_release(struct rpc_task *task)
1208 {
1209 	struct nfs_write_data	*wdata = (struct nfs_write_data *)task->tk_calldata;
1210 	nfs_commit_free(wdata);
1211 }
1212 
1213 /*
1214  * Set up the argument/result storage required for the RPC call.
1215  */
1216 static void nfs_commit_rpcsetup(struct list_head *head,
1217 		struct nfs_write_data *data, int how)
1218 {
1219 	struct nfs_page		*first;
1220 	struct inode		*inode;
1221 
1222 	/* Set up the RPC argument and reply structs
1223 	 * NB: take care not to mess about with data->commit et al. */
1224 
1225 	list_splice_init(head, &data->pages);
1226 	first = nfs_list_entry(data->pages.next);
1227 	inode = first->wb_context->dentry->d_inode;
1228 
1229 	data->inode	  = inode;
1230 	data->cred	  = first->wb_context->cred;
1231 
1232 	data->args.fh     = NFS_FH(data->inode);
1233 	/* Note: we always request a commit of the entire inode */
1234 	data->args.offset = 0;
1235 	data->args.count  = 0;
1236 	data->res.count   = 0;
1237 	data->res.fattr   = &data->fattr;
1238 	data->res.verf    = &data->verf;
1239 	nfs_fattr_init(&data->fattr);
1240 
1241 	NFS_PROTO(inode)->commit_setup(data, how);
1242 
1243 	data->task.tk_priority = flush_task_priority(how);
1244 	data->task.tk_cookie = (unsigned long)inode;
1245 	data->task.tk_calldata = data;
1246 	/* Release requests */
1247 	data->task.tk_release = nfs_commit_release;
1248 
1249 	dprintk("NFS: %4d initiated commit call\n", data->task.tk_pid);
1250 }
1251 
1252 /*
1253  * Commit dirty pages
1254  */
1255 static int
1256 nfs_commit_list(struct list_head *head, int how)
1257 {
1258 	struct nfs_write_data	*data;
1259 	struct nfs_page         *req;
1260 
1261 	data = nfs_commit_alloc();
1262 
1263 	if (!data)
1264 		goto out_bad;
1265 
1266 	/* Set up the argument struct */
1267 	nfs_commit_rpcsetup(head, data, how);
1268 
1269 	nfs_execute_write(data);
1270 	return 0;
1271  out_bad:
1272 	while (!list_empty(head)) {
1273 		req = nfs_list_entry(head->next);
1274 		nfs_list_remove_request(req);
1275 		nfs_mark_request_commit(req);
1276 		nfs_clear_page_writeback(req);
1277 	}
1278 	return -ENOMEM;
1279 }
1280 
1281 /*
1282  * COMMIT call returned
1283  */
1284 void
1285 nfs_commit_done(struct rpc_task *task)
1286 {
1287 	struct nfs_write_data	*data = (struct nfs_write_data *)task->tk_calldata;
1288 	struct nfs_page		*req;
1289 	int res = 0;
1290 
1291         dprintk("NFS: %4d nfs_commit_done (status %d)\n",
1292                                 task->tk_pid, task->tk_status);
1293 
1294 	while (!list_empty(&data->pages)) {
1295 		req = nfs_list_entry(data->pages.next);
1296 		nfs_list_remove_request(req);
1297 
1298 		dprintk("NFS: commit (%s/%Ld %d@%Ld)",
1299 			req->wb_context->dentry->d_inode->i_sb->s_id,
1300 			(long long)NFS_FILEID(req->wb_context->dentry->d_inode),
1301 			req->wb_bytes,
1302 			(long long)req_offset(req));
1303 		if (task->tk_status < 0) {
1304 			req->wb_context->error = task->tk_status;
1305 			nfs_inode_remove_request(req);
1306 			dprintk(", error = %d\n", task->tk_status);
1307 			goto next;
1308 		}
1309 
1310 		/* Okay, COMMIT succeeded, apparently. Check the verifier
1311 		 * returned by the server against all stored verfs. */
1312 		if (!memcmp(req->wb_verf.verifier, data->verf.verifier, sizeof(data->verf.verifier))) {
1313 			/* We have a match */
1314 			nfs_inode_remove_request(req);
1315 			dprintk(" OK\n");
1316 			goto next;
1317 		}
1318 		/* We have a mismatch. Write the page again */
1319 		dprintk(" mismatch\n");
1320 		nfs_mark_request_dirty(req);
1321 	next:
1322 		nfs_clear_page_writeback(req);
1323 		res++;
1324 	}
1325 	sub_page_state(nr_unstable,res);
1326 }
1327 #endif
1328 
1329 static int nfs_flush_inode(struct inode *inode, unsigned long idx_start,
1330 			   unsigned int npages, int how)
1331 {
1332 	struct nfs_inode *nfsi = NFS_I(inode);
1333 	LIST_HEAD(head);
1334 	int			res,
1335 				error = 0;
1336 
1337 	spin_lock(&nfsi->req_lock);
1338 	res = nfs_scan_dirty(inode, &head, idx_start, npages);
1339 	spin_unlock(&nfsi->req_lock);
1340 	if (res) {
1341 		struct nfs_server *server = NFS_SERVER(inode);
1342 
1343 		/* For single writes, FLUSH_STABLE is more efficient */
1344 		if (res == nfsi->npages && nfsi->npages <= server->wpages) {
1345 			if (res > 1 || nfs_list_entry(head.next)->wb_bytes <= server->wsize)
1346 				how |= FLUSH_STABLE;
1347 		}
1348 		error = nfs_flush_list(&head, server->wpages, how);
1349 	}
1350 	if (error < 0)
1351 		return error;
1352 	return res;
1353 }
1354 
1355 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
1356 int nfs_commit_inode(struct inode *inode, int how)
1357 {
1358 	struct nfs_inode *nfsi = NFS_I(inode);
1359 	LIST_HEAD(head);
1360 	int			res,
1361 				error = 0;
1362 
1363 	spin_lock(&nfsi->req_lock);
1364 	res = nfs_scan_commit(inode, &head, 0, 0);
1365 	spin_unlock(&nfsi->req_lock);
1366 	if (res) {
1367 		error = nfs_commit_list(&head, how);
1368 		if (error < 0)
1369 			return error;
1370 	}
1371 	return res;
1372 }
1373 #endif
1374 
1375 int nfs_sync_inode(struct inode *inode, unsigned long idx_start,
1376 		  unsigned int npages, int how)
1377 {
1378 	int	error,
1379 		wait;
1380 
1381 	wait = how & FLUSH_WAIT;
1382 	how &= ~FLUSH_WAIT;
1383 
1384 	do {
1385 		error = 0;
1386 		if (wait)
1387 			error = nfs_wait_on_requests(inode, idx_start, npages);
1388 		if (error == 0)
1389 			error = nfs_flush_inode(inode, idx_start, npages, how);
1390 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
1391 		if (error == 0)
1392 			error = nfs_commit_inode(inode, how);
1393 #endif
1394 	} while (error > 0);
1395 	return error;
1396 }
1397 
1398 int nfs_init_writepagecache(void)
1399 {
1400 	nfs_wdata_cachep = kmem_cache_create("nfs_write_data",
1401 					     sizeof(struct nfs_write_data),
1402 					     0, SLAB_HWCACHE_ALIGN,
1403 					     NULL, NULL);
1404 	if (nfs_wdata_cachep == NULL)
1405 		return -ENOMEM;
1406 
1407 	nfs_wdata_mempool = mempool_create(MIN_POOL_WRITE,
1408 					   mempool_alloc_slab,
1409 					   mempool_free_slab,
1410 					   nfs_wdata_cachep);
1411 	if (nfs_wdata_mempool == NULL)
1412 		return -ENOMEM;
1413 
1414 	nfs_commit_mempool = mempool_create(MIN_POOL_COMMIT,
1415 					   mempool_alloc_slab,
1416 					   mempool_free_slab,
1417 					   nfs_wdata_cachep);
1418 	if (nfs_commit_mempool == NULL)
1419 		return -ENOMEM;
1420 
1421 	return 0;
1422 }
1423 
1424 void nfs_destroy_writepagecache(void)
1425 {
1426 	mempool_destroy(nfs_commit_mempool);
1427 	mempool_destroy(nfs_wdata_mempool);
1428 	if (kmem_cache_destroy(nfs_wdata_cachep))
1429 		printk(KERN_INFO "nfs_write_data: not all structures were freed\n");
1430 }
1431 
1432