xref: /linux/fs/nfs/write.c (revision b8413f98f997bb3ed7327e6d7117e7e91ce010c3)
11da177e4SLinus Torvalds /*
21da177e4SLinus Torvalds  * linux/fs/nfs/write.c
31da177e4SLinus Torvalds  *
47c85d900STrond Myklebust  * Write file data over NFS.
51da177e4SLinus Torvalds  *
61da177e4SLinus Torvalds  * Copyright (C) 1996, 1997, Olaf Kirch <okir@monad.swb.de>
71da177e4SLinus Torvalds  */
81da177e4SLinus Torvalds 
91da177e4SLinus Torvalds #include <linux/types.h>
101da177e4SLinus Torvalds #include <linux/slab.h>
111da177e4SLinus Torvalds #include <linux/mm.h>
121da177e4SLinus Torvalds #include <linux/pagemap.h>
131da177e4SLinus Torvalds #include <linux/file.h>
141da177e4SLinus Torvalds #include <linux/writeback.h>
1589a09141SPeter Zijlstra #include <linux/swap.h>
16074cc1deSTrond Myklebust #include <linux/migrate.h>
171da177e4SLinus Torvalds 
181da177e4SLinus Torvalds #include <linux/sunrpc/clnt.h>
191da177e4SLinus Torvalds #include <linux/nfs_fs.h>
201da177e4SLinus Torvalds #include <linux/nfs_mount.h>
211da177e4SLinus Torvalds #include <linux/nfs_page.h>
223fcfab16SAndrew Morton #include <linux/backing-dev.h>
233fcfab16SAndrew Morton 
241da177e4SLinus Torvalds #include <asm/uaccess.h>
251da177e4SLinus Torvalds 
261da177e4SLinus Torvalds #include "delegation.h"
2749a70f27STrond Myklebust #include "internal.h"
2891d5b470SChuck Lever #include "iostat.h"
29def6ed7eSAndy Adamson #include "nfs4_fs.h"
30074cc1deSTrond Myklebust #include "fscache.h"
3194ad1c80SFred Isaman #include "pnfs.h"
321da177e4SLinus Torvalds 
331da177e4SLinus Torvalds #define NFSDBG_FACILITY		NFSDBG_PAGECACHE
341da177e4SLinus Torvalds 
351da177e4SLinus Torvalds #define MIN_POOL_WRITE		(32)
361da177e4SLinus Torvalds #define MIN_POOL_COMMIT		(4)
371da177e4SLinus Torvalds 
381da177e4SLinus Torvalds /*
391da177e4SLinus Torvalds  * Local function declarations
401da177e4SLinus Torvalds  */
41c63c7b05STrond Myklebust static void nfs_pageio_init_write(struct nfs_pageio_descriptor *desc,
42c63c7b05STrond Myklebust 				  struct inode *inode, int ioflags);
43f8512ad0SFred Isaman static void nfs_redirty_request(struct nfs_page *req);
44788e7a89STrond Myklebust static const struct rpc_call_ops nfs_write_partial_ops;
45788e7a89STrond Myklebust static const struct rpc_call_ops nfs_write_full_ops;
46788e7a89STrond Myklebust static const struct rpc_call_ops nfs_commit_ops;
471da177e4SLinus Torvalds 
48e18b890bSChristoph Lameter static struct kmem_cache *nfs_wdata_cachep;
493feb2d49STrond Myklebust static mempool_t *nfs_wdata_mempool;
501da177e4SLinus Torvalds static mempool_t *nfs_commit_mempool;
511da177e4SLinus Torvalds 
52c9d8f89dSTrond Myklebust struct nfs_write_data *nfs_commitdata_alloc(void)
531da177e4SLinus Torvalds {
54e6b4f8daSChristoph Lameter 	struct nfs_write_data *p = mempool_alloc(nfs_commit_mempool, GFP_NOFS);
5540859d7eSChuck Lever 
561da177e4SLinus Torvalds 	if (p) {
571da177e4SLinus Torvalds 		memset(p, 0, sizeof(*p));
581da177e4SLinus Torvalds 		INIT_LIST_HEAD(&p->pages);
591da177e4SLinus Torvalds 	}
601da177e4SLinus Torvalds 	return p;
611da177e4SLinus Torvalds }
621da177e4SLinus Torvalds 
635e4424afSTrond Myklebust void nfs_commit_free(struct nfs_write_data *p)
641da177e4SLinus Torvalds {
6540859d7eSChuck Lever 	if (p && (p->pagevec != &p->page_array[0]))
6640859d7eSChuck Lever 		kfree(p->pagevec);
671da177e4SLinus Torvalds 	mempool_free(p, nfs_commit_mempool);
681da177e4SLinus Torvalds }
691da177e4SLinus Torvalds 
708d5658c9STrond Myklebust struct nfs_write_data *nfs_writedata_alloc(unsigned int pagecount)
713feb2d49STrond Myklebust {
72e6b4f8daSChristoph Lameter 	struct nfs_write_data *p = mempool_alloc(nfs_wdata_mempool, GFP_NOFS);
733feb2d49STrond Myklebust 
743feb2d49STrond Myklebust 	if (p) {
753feb2d49STrond Myklebust 		memset(p, 0, sizeof(*p));
763feb2d49STrond Myklebust 		INIT_LIST_HEAD(&p->pages);
77e9f7bee1STrond Myklebust 		p->npages = pagecount;
780d0b5cb3SChuck Lever 		if (pagecount <= ARRAY_SIZE(p->page_array))
790d0b5cb3SChuck Lever 			p->pagevec = p->page_array;
803feb2d49STrond Myklebust 		else {
810d0b5cb3SChuck Lever 			p->pagevec = kcalloc(pagecount, sizeof(struct page *), GFP_NOFS);
820d0b5cb3SChuck Lever 			if (!p->pagevec) {
833feb2d49STrond Myklebust 				mempool_free(p, nfs_wdata_mempool);
843feb2d49STrond Myklebust 				p = NULL;
853feb2d49STrond Myklebust 			}
863feb2d49STrond Myklebust 		}
873feb2d49STrond Myklebust 	}
883feb2d49STrond Myklebust 	return p;
893feb2d49STrond Myklebust }
903feb2d49STrond Myklebust 
911ae88b2eSTrond Myklebust void nfs_writedata_free(struct nfs_write_data *p)
923feb2d49STrond Myklebust {
933feb2d49STrond Myklebust 	if (p && (p->pagevec != &p->page_array[0]))
943feb2d49STrond Myklebust 		kfree(p->pagevec);
953feb2d49STrond Myklebust 	mempool_free(p, nfs_wdata_mempool);
963feb2d49STrond Myklebust }
973feb2d49STrond Myklebust 
981ae88b2eSTrond Myklebust static void nfs_writedata_release(struct nfs_write_data *wdata)
991da177e4SLinus Torvalds {
1005053aa56SFred Isaman 	put_lseg(wdata->lseg);
101383ba719STrond Myklebust 	put_nfs_open_context(wdata->args.context);
1021da177e4SLinus Torvalds 	nfs_writedata_free(wdata);
1031da177e4SLinus Torvalds }
1041da177e4SLinus Torvalds 
1057b159fc1STrond Myklebust static void nfs_context_set_write_error(struct nfs_open_context *ctx, int error)
1067b159fc1STrond Myklebust {
1077b159fc1STrond Myklebust 	ctx->error = error;
1087b159fc1STrond Myklebust 	smp_wmb();
1097b159fc1STrond Myklebust 	set_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
1107b159fc1STrond Myklebust }
1117b159fc1STrond Myklebust 
112277459d2STrond Myklebust static struct nfs_page *nfs_page_find_request_locked(struct page *page)
113277459d2STrond Myklebust {
114277459d2STrond Myklebust 	struct nfs_page *req = NULL;
115277459d2STrond Myklebust 
116277459d2STrond Myklebust 	if (PagePrivate(page)) {
117277459d2STrond Myklebust 		req = (struct nfs_page *)page_private(page);
118277459d2STrond Myklebust 		if (req != NULL)
119c03b4024STrond Myklebust 			kref_get(&req->wb_kref);
120277459d2STrond Myklebust 	}
121277459d2STrond Myklebust 	return req;
122277459d2STrond Myklebust }
123277459d2STrond Myklebust 
124277459d2STrond Myklebust static struct nfs_page *nfs_page_find_request(struct page *page)
125277459d2STrond Myklebust {
126587142f8STrond Myklebust 	struct inode *inode = page->mapping->host;
127277459d2STrond Myklebust 	struct nfs_page *req = NULL;
128277459d2STrond Myklebust 
129587142f8STrond Myklebust 	spin_lock(&inode->i_lock);
130277459d2STrond Myklebust 	req = nfs_page_find_request_locked(page);
131587142f8STrond Myklebust 	spin_unlock(&inode->i_lock);
132277459d2STrond Myklebust 	return req;
133277459d2STrond Myklebust }
134277459d2STrond Myklebust 
1351da177e4SLinus Torvalds /* Adjust the file length if we're writing beyond the end */
1361da177e4SLinus Torvalds static void nfs_grow_file(struct page *page, unsigned int offset, unsigned int count)
1371da177e4SLinus Torvalds {
1381da177e4SLinus Torvalds 	struct inode *inode = page->mapping->host;
139a3d01454STrond Myklebust 	loff_t end, i_size;
140a3d01454STrond Myklebust 	pgoff_t end_index;
1411da177e4SLinus Torvalds 
142a3d01454STrond Myklebust 	spin_lock(&inode->i_lock);
143a3d01454STrond Myklebust 	i_size = i_size_read(inode);
144a3d01454STrond Myklebust 	end_index = (i_size - 1) >> PAGE_CACHE_SHIFT;
1451da177e4SLinus Torvalds 	if (i_size > 0 && page->index < end_index)
146a3d01454STrond Myklebust 		goto out;
1471da177e4SLinus Torvalds 	end = ((loff_t)page->index << PAGE_CACHE_SHIFT) + ((loff_t)offset+count);
1481da177e4SLinus Torvalds 	if (i_size >= end)
149a3d01454STrond Myklebust 		goto out;
1501da177e4SLinus Torvalds 	i_size_write(inode, end);
151a3d01454STrond Myklebust 	nfs_inc_stats(inode, NFSIOS_EXTENDWRITE);
152a3d01454STrond Myklebust out:
153a3d01454STrond Myklebust 	spin_unlock(&inode->i_lock);
1541da177e4SLinus Torvalds }
1551da177e4SLinus Torvalds 
156a301b777STrond Myklebust /* A writeback failed: mark the page as bad, and invalidate the page cache */
157a301b777STrond Myklebust static void nfs_set_pageerror(struct page *page)
158a301b777STrond Myklebust {
159a301b777STrond Myklebust 	SetPageError(page);
160a301b777STrond Myklebust 	nfs_zap_mapping(page->mapping->host, page->mapping);
161a301b777STrond Myklebust }
162a301b777STrond Myklebust 
1631da177e4SLinus Torvalds /* We can set the PG_uptodate flag if we see that a write request
1641da177e4SLinus Torvalds  * covers the full page.
1651da177e4SLinus Torvalds  */
1661da177e4SLinus Torvalds static void nfs_mark_uptodate(struct page *page, unsigned int base, unsigned int count)
1671da177e4SLinus Torvalds {
1681da177e4SLinus Torvalds 	if (PageUptodate(page))
1691da177e4SLinus Torvalds 		return;
1701da177e4SLinus Torvalds 	if (base != 0)
1711da177e4SLinus Torvalds 		return;
17249a70f27STrond Myklebust 	if (count != nfs_page_length(page))
1731da177e4SLinus Torvalds 		return;
1741da177e4SLinus Torvalds 	SetPageUptodate(page);
1751da177e4SLinus Torvalds }
1761da177e4SLinus Torvalds 
1771da177e4SLinus Torvalds static int wb_priority(struct writeback_control *wbc)
1781da177e4SLinus Torvalds {
1791da177e4SLinus Torvalds 	if (wbc->for_reclaim)
180c63c7b05STrond Myklebust 		return FLUSH_HIGHPRI | FLUSH_STABLE;
181b17621feSWu Fengguang 	if (wbc->for_kupdate || wbc->for_background)
182b31268acSTrond Myklebust 		return FLUSH_LOWPRI | FLUSH_COND_STABLE;
183b31268acSTrond Myklebust 	return FLUSH_COND_STABLE;
1841da177e4SLinus Torvalds }
1851da177e4SLinus Torvalds 
1861da177e4SLinus Torvalds /*
18789a09141SPeter Zijlstra  * NFS congestion control
18889a09141SPeter Zijlstra  */
18989a09141SPeter Zijlstra 
19089a09141SPeter Zijlstra int nfs_congestion_kb;
19189a09141SPeter Zijlstra 
19289a09141SPeter Zijlstra #define NFS_CONGESTION_ON_THRESH 	(nfs_congestion_kb >> (PAGE_SHIFT-10))
19389a09141SPeter Zijlstra #define NFS_CONGESTION_OFF_THRESH	\
19489a09141SPeter Zijlstra 	(NFS_CONGESTION_ON_THRESH - (NFS_CONGESTION_ON_THRESH >> 2))
19589a09141SPeter Zijlstra 
1965a6d41b3STrond Myklebust static int nfs_set_page_writeback(struct page *page)
19789a09141SPeter Zijlstra {
1985a6d41b3STrond Myklebust 	int ret = test_set_page_writeback(page);
1995a6d41b3STrond Myklebust 
2005a6d41b3STrond Myklebust 	if (!ret) {
20189a09141SPeter Zijlstra 		struct inode *inode = page->mapping->host;
20289a09141SPeter Zijlstra 		struct nfs_server *nfss = NFS_SERVER(inode);
20389a09141SPeter Zijlstra 
204a6305ddbSTrond Myklebust 		page_cache_get(page);
205277866a0SPeter Zijlstra 		if (atomic_long_inc_return(&nfss->writeback) >
2068aa7e847SJens Axboe 				NFS_CONGESTION_ON_THRESH) {
2078aa7e847SJens Axboe 			set_bdi_congested(&nfss->backing_dev_info,
2088aa7e847SJens Axboe 						BLK_RW_ASYNC);
2098aa7e847SJens Axboe 		}
21089a09141SPeter Zijlstra 	}
2115a6d41b3STrond Myklebust 	return ret;
21289a09141SPeter Zijlstra }
21389a09141SPeter Zijlstra 
21489a09141SPeter Zijlstra static void nfs_end_page_writeback(struct page *page)
21589a09141SPeter Zijlstra {
21689a09141SPeter Zijlstra 	struct inode *inode = page->mapping->host;
21789a09141SPeter Zijlstra 	struct nfs_server *nfss = NFS_SERVER(inode);
21889a09141SPeter Zijlstra 
21989a09141SPeter Zijlstra 	end_page_writeback(page);
220a6305ddbSTrond Myklebust 	page_cache_release(page);
221c4dc4beeSPeter Zijlstra 	if (atomic_long_dec_return(&nfss->writeback) < NFS_CONGESTION_OFF_THRESH)
2228aa7e847SJens Axboe 		clear_bdi_congested(&nfss->backing_dev_info, BLK_RW_ASYNC);
22389a09141SPeter Zijlstra }
22489a09141SPeter Zijlstra 
225cfb506e1STrond Myklebust static struct nfs_page *nfs_find_and_lock_request(struct page *page, bool nonblock)
226e261f51fSTrond Myklebust {
227587142f8STrond Myklebust 	struct inode *inode = page->mapping->host;
228e261f51fSTrond Myklebust 	struct nfs_page *req;
229e261f51fSTrond Myklebust 	int ret;
230e261f51fSTrond Myklebust 
231587142f8STrond Myklebust 	spin_lock(&inode->i_lock);
232e261f51fSTrond Myklebust 	for (;;) {
233e261f51fSTrond Myklebust 		req = nfs_page_find_request_locked(page);
234074cc1deSTrond Myklebust 		if (req == NULL)
235074cc1deSTrond Myklebust 			break;
236acee478aSTrond Myklebust 		if (nfs_set_page_tag_locked(req))
237e261f51fSTrond Myklebust 			break;
238e261f51fSTrond Myklebust 		/* Note: If we hold the page lock, as is the case in nfs_writepage,
239acee478aSTrond Myklebust 		 *	 then the call to nfs_set_page_tag_locked() will always
240e261f51fSTrond Myklebust 		 *	 succeed provided that someone hasn't already marked the
241e261f51fSTrond Myklebust 		 *	 request as dirty (in which case we don't care).
242e261f51fSTrond Myklebust 		 */
243587142f8STrond Myklebust 		spin_unlock(&inode->i_lock);
244cfb506e1STrond Myklebust 		if (!nonblock)
245e261f51fSTrond Myklebust 			ret = nfs_wait_on_request(req);
246cfb506e1STrond Myklebust 		else
247cfb506e1STrond Myklebust 			ret = -EAGAIN;
248e261f51fSTrond Myklebust 		nfs_release_request(req);
249e261f51fSTrond Myklebust 		if (ret != 0)
250074cc1deSTrond Myklebust 			return ERR_PTR(ret);
251587142f8STrond Myklebust 		spin_lock(&inode->i_lock);
252e261f51fSTrond Myklebust 	}
253587142f8STrond Myklebust 	spin_unlock(&inode->i_lock);
254074cc1deSTrond Myklebust 	return req;
255612c9384STrond Myklebust }
256074cc1deSTrond Myklebust 
257074cc1deSTrond Myklebust /*
258074cc1deSTrond Myklebust  * Find an associated nfs write request, and prepare to flush it out
259074cc1deSTrond Myklebust  * May return an error if the user signalled nfs_wait_on_request().
260074cc1deSTrond Myklebust  */
261074cc1deSTrond Myklebust static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio,
262cfb506e1STrond Myklebust 				struct page *page, bool nonblock)
263074cc1deSTrond Myklebust {
264074cc1deSTrond Myklebust 	struct nfs_page *req;
265074cc1deSTrond Myklebust 	int ret = 0;
266074cc1deSTrond Myklebust 
267cfb506e1STrond Myklebust 	req = nfs_find_and_lock_request(page, nonblock);
268074cc1deSTrond Myklebust 	if (!req)
269074cc1deSTrond Myklebust 		goto out;
270074cc1deSTrond Myklebust 	ret = PTR_ERR(req);
271074cc1deSTrond Myklebust 	if (IS_ERR(req))
272074cc1deSTrond Myklebust 		goto out;
273074cc1deSTrond Myklebust 
274074cc1deSTrond Myklebust 	ret = nfs_set_page_writeback(page);
275074cc1deSTrond Myklebust 	BUG_ON(ret != 0);
276074cc1deSTrond Myklebust 	BUG_ON(test_bit(PG_CLEAN, &req->wb_flags));
277074cc1deSTrond Myklebust 
278f8512ad0SFred Isaman 	if (!nfs_pageio_add_request(pgio, req)) {
279f8512ad0SFred Isaman 		nfs_redirty_request(req);
280074cc1deSTrond Myklebust 		ret = pgio->pg_error;
281f8512ad0SFred Isaman 	}
282074cc1deSTrond Myklebust out:
283074cc1deSTrond Myklebust 	return ret;
284e261f51fSTrond Myklebust }
285e261f51fSTrond Myklebust 
286f758c885STrond Myklebust static int nfs_do_writepage(struct page *page, struct writeback_control *wbc, struct nfs_pageio_descriptor *pgio)
287f758c885STrond Myklebust {
288f758c885STrond Myklebust 	struct inode *inode = page->mapping->host;
289cfb506e1STrond Myklebust 	int ret;
290f758c885STrond Myklebust 
291f758c885STrond Myklebust 	nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE);
292f758c885STrond Myklebust 	nfs_add_stats(inode, NFSIOS_WRITEPAGES, 1);
293f758c885STrond Myklebust 
294f758c885STrond Myklebust 	nfs_pageio_cond_complete(pgio, page->index);
2951b430beeSWu Fengguang 	ret = nfs_page_async_flush(pgio, page, wbc->sync_mode == WB_SYNC_NONE);
296cfb506e1STrond Myklebust 	if (ret == -EAGAIN) {
297cfb506e1STrond Myklebust 		redirty_page_for_writepage(wbc, page);
298cfb506e1STrond Myklebust 		ret = 0;
299cfb506e1STrond Myklebust 	}
300cfb506e1STrond Myklebust 	return ret;
301f758c885STrond Myklebust }
302f758c885STrond Myklebust 
303e261f51fSTrond Myklebust /*
3041da177e4SLinus Torvalds  * Write an mmapped page to the server.
3051da177e4SLinus Torvalds  */
3064d770ccfSTrond Myklebust static int nfs_writepage_locked(struct page *page, struct writeback_control *wbc)
3071da177e4SLinus Torvalds {
308f758c885STrond Myklebust 	struct nfs_pageio_descriptor pgio;
309e261f51fSTrond Myklebust 	int err;
3101da177e4SLinus Torvalds 
311f758c885STrond Myklebust 	nfs_pageio_init_write(&pgio, page->mapping->host, wb_priority(wbc));
312f758c885STrond Myklebust 	err = nfs_do_writepage(page, wbc, &pgio);
313f758c885STrond Myklebust 	nfs_pageio_complete(&pgio);
314f758c885STrond Myklebust 	if (err < 0)
3154d770ccfSTrond Myklebust 		return err;
316f758c885STrond Myklebust 	if (pgio.pg_error < 0)
317f758c885STrond Myklebust 		return pgio.pg_error;
318f758c885STrond Myklebust 	return 0;
3194d770ccfSTrond Myklebust }
3204d770ccfSTrond Myklebust 
3214d770ccfSTrond Myklebust int nfs_writepage(struct page *page, struct writeback_control *wbc)
3224d770ccfSTrond Myklebust {
323f758c885STrond Myklebust 	int ret;
3244d770ccfSTrond Myklebust 
325f758c885STrond Myklebust 	ret = nfs_writepage_locked(page, wbc);
3261da177e4SLinus Torvalds 	unlock_page(page);
327f758c885STrond Myklebust 	return ret;
328f758c885STrond Myklebust }
329f758c885STrond Myklebust 
330f758c885STrond Myklebust static int nfs_writepages_callback(struct page *page, struct writeback_control *wbc, void *data)
331f758c885STrond Myklebust {
332f758c885STrond Myklebust 	int ret;
333f758c885STrond Myklebust 
334f758c885STrond Myklebust 	ret = nfs_do_writepage(page, wbc, data);
335f758c885STrond Myklebust 	unlock_page(page);
336f758c885STrond Myklebust 	return ret;
3371da177e4SLinus Torvalds }
3381da177e4SLinus Torvalds 
3391da177e4SLinus Torvalds int nfs_writepages(struct address_space *mapping, struct writeback_control *wbc)
3401da177e4SLinus Torvalds {
3411da177e4SLinus Torvalds 	struct inode *inode = mapping->host;
34272cb77f4STrond Myklebust 	unsigned long *bitlock = &NFS_I(inode)->flags;
343c63c7b05STrond Myklebust 	struct nfs_pageio_descriptor pgio;
3441da177e4SLinus Torvalds 	int err;
3451da177e4SLinus Torvalds 
34672cb77f4STrond Myklebust 	/* Stop dirtying of new pages while we sync */
34772cb77f4STrond Myklebust 	err = wait_on_bit_lock(bitlock, NFS_INO_FLUSHING,
34872cb77f4STrond Myklebust 			nfs_wait_bit_killable, TASK_KILLABLE);
34972cb77f4STrond Myklebust 	if (err)
35072cb77f4STrond Myklebust 		goto out_err;
35172cb77f4STrond Myklebust 
35291d5b470SChuck Lever 	nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGES);
35391d5b470SChuck Lever 
354c63c7b05STrond Myklebust 	nfs_pageio_init_write(&pgio, inode, wb_priority(wbc));
355f758c885STrond Myklebust 	err = write_cache_pages(mapping, wbc, nfs_writepages_callback, &pgio);
356c63c7b05STrond Myklebust 	nfs_pageio_complete(&pgio);
35772cb77f4STrond Myklebust 
35872cb77f4STrond Myklebust 	clear_bit_unlock(NFS_INO_FLUSHING, bitlock);
35972cb77f4STrond Myklebust 	smp_mb__after_clear_bit();
36072cb77f4STrond Myklebust 	wake_up_bit(bitlock, NFS_INO_FLUSHING);
36172cb77f4STrond Myklebust 
362f758c885STrond Myklebust 	if (err < 0)
36372cb77f4STrond Myklebust 		goto out_err;
36472cb77f4STrond Myklebust 	err = pgio.pg_error;
36572cb77f4STrond Myklebust 	if (err < 0)
36672cb77f4STrond Myklebust 		goto out_err;
367c63c7b05STrond Myklebust 	return 0;
36872cb77f4STrond Myklebust out_err:
36972cb77f4STrond Myklebust 	return err;
3701da177e4SLinus Torvalds }
3711da177e4SLinus Torvalds 
3721da177e4SLinus Torvalds /*
3731da177e4SLinus Torvalds  * Insert a write request into an inode
3741da177e4SLinus Torvalds  */
375e7d39069STrond Myklebust static int nfs_inode_add_request(struct inode *inode, struct nfs_page *req)
3761da177e4SLinus Torvalds {
3771da177e4SLinus Torvalds 	struct nfs_inode *nfsi = NFS_I(inode);
3781da177e4SLinus Torvalds 	int error;
3791da177e4SLinus Torvalds 
380e7d39069STrond Myklebust 	error = radix_tree_preload(GFP_NOFS);
381e7d39069STrond Myklebust 	if (error != 0)
382e7d39069STrond Myklebust 		goto out;
383e7d39069STrond Myklebust 
384e7d39069STrond Myklebust 	/* Lock the request! */
385e7d39069STrond Myklebust 	nfs_lock_request_dontget(req);
386e7d39069STrond Myklebust 
387e7d39069STrond Myklebust 	spin_lock(&inode->i_lock);
3881da177e4SLinus Torvalds 	error = radix_tree_insert(&nfsi->nfs_page_tree, req->wb_index, req);
38927852596SNick Piggin 	BUG_ON(error);
3901da177e4SLinus Torvalds 	if (!nfsi->npages) {
3911da177e4SLinus Torvalds 		igrab(inode);
3921da177e4SLinus Torvalds 		if (nfs_have_delegation(inode, FMODE_WRITE))
3931da177e4SLinus Torvalds 			nfsi->change_attr++;
3941da177e4SLinus Torvalds 	}
3952df485a7STrond Myklebust 	set_bit(PG_MAPPED, &req->wb_flags);
396deb7d638STrond Myklebust 	SetPagePrivate(req->wb_page);
397277459d2STrond Myklebust 	set_page_private(req->wb_page, (unsigned long)req);
3981da177e4SLinus Torvalds 	nfsi->npages++;
399c03b4024STrond Myklebust 	kref_get(&req->wb_kref);
40027852596SNick Piggin 	radix_tree_tag_set(&nfsi->nfs_page_tree, req->wb_index,
40127852596SNick Piggin 				NFS_PAGE_TAG_LOCKED);
402e7d39069STrond Myklebust 	spin_unlock(&inode->i_lock);
403e7d39069STrond Myklebust 	radix_tree_preload_end();
404e7d39069STrond Myklebust out:
405e7d39069STrond Myklebust 	return error;
4061da177e4SLinus Torvalds }
4071da177e4SLinus Torvalds 
4081da177e4SLinus Torvalds /*
40989a09141SPeter Zijlstra  * Remove a write request from an inode
4101da177e4SLinus Torvalds  */
4111da177e4SLinus Torvalds static void nfs_inode_remove_request(struct nfs_page *req)
4121da177e4SLinus Torvalds {
41388be9f99STrond Myklebust 	struct inode *inode = req->wb_context->path.dentry->d_inode;
4141da177e4SLinus Torvalds 	struct nfs_inode *nfsi = NFS_I(inode);
4151da177e4SLinus Torvalds 
4161da177e4SLinus Torvalds 	BUG_ON (!NFS_WBACK_BUSY(req));
4171da177e4SLinus Torvalds 
418587142f8STrond Myklebust 	spin_lock(&inode->i_lock);
419277459d2STrond Myklebust 	set_page_private(req->wb_page, 0);
420deb7d638STrond Myklebust 	ClearPagePrivate(req->wb_page);
4212df485a7STrond Myklebust 	clear_bit(PG_MAPPED, &req->wb_flags);
4221da177e4SLinus Torvalds 	radix_tree_delete(&nfsi->nfs_page_tree, req->wb_index);
4231da177e4SLinus Torvalds 	nfsi->npages--;
4241da177e4SLinus Torvalds 	if (!nfsi->npages) {
425587142f8STrond Myklebust 		spin_unlock(&inode->i_lock);
4261da177e4SLinus Torvalds 		iput(inode);
4271da177e4SLinus Torvalds 	} else
428587142f8STrond Myklebust 		spin_unlock(&inode->i_lock);
4291da177e4SLinus Torvalds 	nfs_release_request(req);
4301da177e4SLinus Torvalds }
4311da177e4SLinus Torvalds 
43261822ab5STrond Myklebust static void
4336d884e8fSFred nfs_mark_request_dirty(struct nfs_page *req)
43461822ab5STrond Myklebust {
43561822ab5STrond Myklebust 	__set_page_dirty_nobuffers(req->wb_page);
436b80c3cb6STrond Myklebust 	__mark_inode_dirty(req->wb_page->mapping->host, I_DIRTY_DATASYNC);
43761822ab5STrond Myklebust }
43861822ab5STrond Myklebust 
4391da177e4SLinus Torvalds #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
4401da177e4SLinus Torvalds /*
4411da177e4SLinus Torvalds  * Add a request to the inode's commit list.
4421da177e4SLinus Torvalds  */
4431da177e4SLinus Torvalds static void
4441da177e4SLinus Torvalds nfs_mark_request_commit(struct nfs_page *req)
4451da177e4SLinus Torvalds {
44688be9f99STrond Myklebust 	struct inode *inode = req->wb_context->path.dentry->d_inode;
4471da177e4SLinus Torvalds 	struct nfs_inode *nfsi = NFS_I(inode);
4481da177e4SLinus Torvalds 
449587142f8STrond Myklebust 	spin_lock(&inode->i_lock);
450e468bae9STrond Myklebust 	set_bit(PG_CLEAN, &(req)->wb_flags);
4515c369683STrond Myklebust 	radix_tree_tag_set(&nfsi->nfs_page_tree,
4525c369683STrond Myklebust 			req->wb_index,
4535c369683STrond Myklebust 			NFS_PAGE_TAG_COMMIT);
454ff778d02STrond Myklebust 	nfsi->ncommit++;
455587142f8STrond Myklebust 	spin_unlock(&inode->i_lock);
456fd39fc85SChristoph Lameter 	inc_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
457c9e51e41SPeter Zijlstra 	inc_bdi_stat(req->wb_page->mapping->backing_dev_info, BDI_RECLAIMABLE);
458a1803044STrond Myklebust 	__mark_inode_dirty(inode, I_DIRTY_DATASYNC);
4591da177e4SLinus Torvalds }
4608e821cadSTrond Myklebust 
461e468bae9STrond Myklebust static int
462e468bae9STrond Myklebust nfs_clear_request_commit(struct nfs_page *req)
463e468bae9STrond Myklebust {
464e468bae9STrond Myklebust 	struct page *page = req->wb_page;
465e468bae9STrond Myklebust 
466e468bae9STrond Myklebust 	if (test_and_clear_bit(PG_CLEAN, &(req)->wb_flags)) {
467e468bae9STrond Myklebust 		dec_zone_page_state(page, NR_UNSTABLE_NFS);
468e468bae9STrond Myklebust 		dec_bdi_stat(page->mapping->backing_dev_info, BDI_RECLAIMABLE);
469e468bae9STrond Myklebust 		return 1;
470e468bae9STrond Myklebust 	}
471e468bae9STrond Myklebust 	return 0;
472e468bae9STrond Myklebust }
473e468bae9STrond Myklebust 
4748e821cadSTrond Myklebust static inline
4758e821cadSTrond Myklebust int nfs_write_need_commit(struct nfs_write_data *data)
4768e821cadSTrond Myklebust {
4778e821cadSTrond Myklebust 	return data->verf.committed != NFS_FILE_SYNC;
4788e821cadSTrond Myklebust }
4798e821cadSTrond Myklebust 
4808e821cadSTrond Myklebust static inline
4818e821cadSTrond Myklebust int nfs_reschedule_unstable_write(struct nfs_page *req)
4828e821cadSTrond Myklebust {
483e468bae9STrond Myklebust 	if (test_and_clear_bit(PG_NEED_COMMIT, &req->wb_flags)) {
4848e821cadSTrond Myklebust 		nfs_mark_request_commit(req);
4858e821cadSTrond Myklebust 		return 1;
4868e821cadSTrond Myklebust 	}
4878e821cadSTrond Myklebust 	if (test_and_clear_bit(PG_NEED_RESCHED, &req->wb_flags)) {
4886d884e8fSFred 		nfs_mark_request_dirty(req);
4898e821cadSTrond Myklebust 		return 1;
4908e821cadSTrond Myklebust 	}
4918e821cadSTrond Myklebust 	return 0;
4928e821cadSTrond Myklebust }
4938e821cadSTrond Myklebust #else
4948e821cadSTrond Myklebust static inline void
4958e821cadSTrond Myklebust nfs_mark_request_commit(struct nfs_page *req)
4968e821cadSTrond Myklebust {
4978e821cadSTrond Myklebust }
4988e821cadSTrond Myklebust 
499e468bae9STrond Myklebust static inline int
500e468bae9STrond Myklebust nfs_clear_request_commit(struct nfs_page *req)
501e468bae9STrond Myklebust {
502e468bae9STrond Myklebust 	return 0;
503e468bae9STrond Myklebust }
504e468bae9STrond Myklebust 
5058e821cadSTrond Myklebust static inline
5068e821cadSTrond Myklebust int nfs_write_need_commit(struct nfs_write_data *data)
5078e821cadSTrond Myklebust {
5088e821cadSTrond Myklebust 	return 0;
5098e821cadSTrond Myklebust }
5108e821cadSTrond Myklebust 
5118e821cadSTrond Myklebust static inline
5128e821cadSTrond Myklebust int nfs_reschedule_unstable_write(struct nfs_page *req)
5138e821cadSTrond Myklebust {
5148e821cadSTrond Myklebust 	return 0;
5158e821cadSTrond Myklebust }
5161da177e4SLinus Torvalds #endif
5171da177e4SLinus Torvalds 
51847c62564STrond Myklebust #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
519fb8a1f11STrond Myklebust static int
520fb8a1f11STrond Myklebust nfs_need_commit(struct nfs_inode *nfsi)
521fb8a1f11STrond Myklebust {
522fb8a1f11STrond Myklebust 	return radix_tree_tagged(&nfsi->nfs_page_tree, NFS_PAGE_TAG_COMMIT);
523fb8a1f11STrond Myklebust }
524fb8a1f11STrond Myklebust 
5251da177e4SLinus Torvalds /*
5261da177e4SLinus Torvalds  * nfs_scan_commit - Scan an inode for commit requests
5271da177e4SLinus Torvalds  * @inode: NFS inode to scan
5281da177e4SLinus Torvalds  * @dst: destination list
5291da177e4SLinus Torvalds  * @idx_start: lower bound of page->index to scan.
5301da177e4SLinus Torvalds  * @npages: idx_start + npages sets the upper bound to scan.
5311da177e4SLinus Torvalds  *
5321da177e4SLinus Torvalds  * Moves requests from the inode's 'commit' request list.
5331da177e4SLinus Torvalds  * The requests are *not* checked to ensure that they form a contiguous set.
5341da177e4SLinus Torvalds  */
5351da177e4SLinus Torvalds static int
536ca52fec1STrond Myklebust nfs_scan_commit(struct inode *inode, struct list_head *dst, pgoff_t idx_start, unsigned int npages)
5371da177e4SLinus Torvalds {
5381da177e4SLinus Torvalds 	struct nfs_inode *nfsi = NFS_I(inode);
539ff778d02STrond Myklebust 	int ret;
5403da28eb1STrond Myklebust 
541fb8a1f11STrond Myklebust 	if (!nfs_need_commit(nfsi))
542fb8a1f11STrond Myklebust 		return 0;
543fb8a1f11STrond Myklebust 
544ff778d02STrond Myklebust 	ret = nfs_scan_list(nfsi, dst, idx_start, npages, NFS_PAGE_TAG_COMMIT);
545ff778d02STrond Myklebust 	if (ret > 0)
546ff778d02STrond Myklebust 		nfsi->ncommit -= ret;
5472928db1fSTrond Myklebust 	if (nfs_need_commit(NFS_I(inode)))
5482928db1fSTrond Myklebust 		__mark_inode_dirty(inode, I_DIRTY_DATASYNC);
549ff778d02STrond Myklebust 	return ret;
5501da177e4SLinus Torvalds }
551c42de9ddSTrond Myklebust #else
552fb8a1f11STrond Myklebust static inline int nfs_need_commit(struct nfs_inode *nfsi)
553fb8a1f11STrond Myklebust {
554fb8a1f11STrond Myklebust 	return 0;
555fb8a1f11STrond Myklebust }
556fb8a1f11STrond Myklebust 
557ca52fec1STrond Myklebust static inline int nfs_scan_commit(struct inode *inode, struct list_head *dst, pgoff_t idx_start, unsigned int npages)
558c42de9ddSTrond Myklebust {
559c42de9ddSTrond Myklebust 	return 0;
560c42de9ddSTrond Myklebust }
5611da177e4SLinus Torvalds #endif
5621da177e4SLinus Torvalds 
5631da177e4SLinus Torvalds /*
564e7d39069STrond Myklebust  * Search for an existing write request, and attempt to update
565e7d39069STrond Myklebust  * it to reflect a new dirty region on a given page.
5661da177e4SLinus Torvalds  *
567e7d39069STrond Myklebust  * If the attempt fails, then the existing request is flushed out
568e7d39069STrond Myklebust  * to disk.
5691da177e4SLinus Torvalds  */
570e7d39069STrond Myklebust static struct nfs_page *nfs_try_to_update_request(struct inode *inode,
571e7d39069STrond Myklebust 		struct page *page,
572e7d39069STrond Myklebust 		unsigned int offset,
573e7d39069STrond Myklebust 		unsigned int bytes)
5741da177e4SLinus Torvalds {
575e7d39069STrond Myklebust 	struct nfs_page *req;
576e7d39069STrond Myklebust 	unsigned int rqend;
577e7d39069STrond Myklebust 	unsigned int end;
5781da177e4SLinus Torvalds 	int error;
579277459d2STrond Myklebust 
580e7d39069STrond Myklebust 	if (!PagePrivate(page))
581e7d39069STrond Myklebust 		return NULL;
582e7d39069STrond Myklebust 
583e7d39069STrond Myklebust 	end = offset + bytes;
584e7d39069STrond Myklebust 	spin_lock(&inode->i_lock);
585e7d39069STrond Myklebust 
586e7d39069STrond Myklebust 	for (;;) {
587e7d39069STrond Myklebust 		req = nfs_page_find_request_locked(page);
588e7d39069STrond Myklebust 		if (req == NULL)
589e7d39069STrond Myklebust 			goto out_unlock;
590e7d39069STrond Myklebust 
591e7d39069STrond Myklebust 		rqend = req->wb_offset + req->wb_bytes;
592e7d39069STrond Myklebust 		/*
593e7d39069STrond Myklebust 		 * Tell the caller to flush out the request if
594e7d39069STrond Myklebust 		 * the offsets are non-contiguous.
595e7d39069STrond Myklebust 		 * Note: nfs_flush_incompatible() will already
596e7d39069STrond Myklebust 		 * have flushed out requests having wrong owners.
597e7d39069STrond Myklebust 		 */
598e468bae9STrond Myklebust 		if (offset > rqend
599e7d39069STrond Myklebust 		    || end < req->wb_offset)
600e7d39069STrond Myklebust 			goto out_flushme;
601e7d39069STrond Myklebust 
602e7d39069STrond Myklebust 		if (nfs_set_page_tag_locked(req))
603e7d39069STrond Myklebust 			break;
604e7d39069STrond Myklebust 
605e7d39069STrond Myklebust 		/* The request is locked, so wait and then retry */
606587142f8STrond Myklebust 		spin_unlock(&inode->i_lock);
6071da177e4SLinus Torvalds 		error = nfs_wait_on_request(req);
6081da177e4SLinus Torvalds 		nfs_release_request(req);
609e7d39069STrond Myklebust 		if (error != 0)
610e7d39069STrond Myklebust 			goto out_err;
611e7d39069STrond Myklebust 		spin_lock(&inode->i_lock);
6121da177e4SLinus Torvalds 	}
6131da177e4SLinus Torvalds 
614ff778d02STrond Myklebust 	if (nfs_clear_request_commit(req) &&
615e468bae9STrond Myklebust 			radix_tree_tag_clear(&NFS_I(inode)->nfs_page_tree,
616ff778d02STrond Myklebust 				req->wb_index, NFS_PAGE_TAG_COMMIT) != NULL)
617ff778d02STrond Myklebust 		NFS_I(inode)->ncommit--;
618e468bae9STrond Myklebust 
6191da177e4SLinus Torvalds 	/* Okay, the request matches. Update the region */
6201da177e4SLinus Torvalds 	if (offset < req->wb_offset) {
6211da177e4SLinus Torvalds 		req->wb_offset = offset;
6221da177e4SLinus Torvalds 		req->wb_pgbase = offset;
6231da177e4SLinus Torvalds 	}
6241da177e4SLinus Torvalds 	if (end > rqend)
6251da177e4SLinus Torvalds 		req->wb_bytes = end - req->wb_offset;
626e7d39069STrond Myklebust 	else
627e7d39069STrond Myklebust 		req->wb_bytes = rqend - req->wb_offset;
628e7d39069STrond Myklebust out_unlock:
629e7d39069STrond Myklebust 	spin_unlock(&inode->i_lock);
630e7d39069STrond Myklebust 	return req;
631e7d39069STrond Myklebust out_flushme:
632e7d39069STrond Myklebust 	spin_unlock(&inode->i_lock);
633e7d39069STrond Myklebust 	nfs_release_request(req);
634e7d39069STrond Myklebust 	error = nfs_wb_page(inode, page);
635e7d39069STrond Myklebust out_err:
636e7d39069STrond Myklebust 	return ERR_PTR(error);
637e7d39069STrond Myklebust }
6381da177e4SLinus Torvalds 
639e7d39069STrond Myklebust /*
640e7d39069STrond Myklebust  * Try to update an existing write request, or create one if there is none.
641e7d39069STrond Myklebust  *
642e7d39069STrond Myklebust  * Note: Should always be called with the Page Lock held to prevent races
643e7d39069STrond Myklebust  * if we have to add a new request. Also assumes that the caller has
644e7d39069STrond Myklebust  * already called nfs_flush_incompatible() if necessary.
645e7d39069STrond Myklebust  */
646e7d39069STrond Myklebust static struct nfs_page * nfs_setup_write_request(struct nfs_open_context* ctx,
647e7d39069STrond Myklebust 		struct page *page, unsigned int offset, unsigned int bytes)
648e7d39069STrond Myklebust {
649e7d39069STrond Myklebust 	struct inode *inode = page->mapping->host;
650e7d39069STrond Myklebust 	struct nfs_page	*req;
651e7d39069STrond Myklebust 	int error;
652e7d39069STrond Myklebust 
653e7d39069STrond Myklebust 	req = nfs_try_to_update_request(inode, page, offset, bytes);
654e7d39069STrond Myklebust 	if (req != NULL)
655e7d39069STrond Myklebust 		goto out;
656e7d39069STrond Myklebust 	req = nfs_create_request(ctx, inode, page, offset, bytes);
657e7d39069STrond Myklebust 	if (IS_ERR(req))
658e7d39069STrond Myklebust 		goto out;
659e7d39069STrond Myklebust 	error = nfs_inode_add_request(inode, req);
660e7d39069STrond Myklebust 	if (error != 0) {
661e7d39069STrond Myklebust 		nfs_release_request(req);
662e7d39069STrond Myklebust 		req = ERR_PTR(error);
663e7d39069STrond Myklebust 	}
664efc91ed0STrond Myklebust out:
66561e930a9STrond Myklebust 	return req;
6661da177e4SLinus Torvalds }
6671da177e4SLinus Torvalds 
668e7d39069STrond Myklebust static int nfs_writepage_setup(struct nfs_open_context *ctx, struct page *page,
669e7d39069STrond Myklebust 		unsigned int offset, unsigned int count)
670e7d39069STrond Myklebust {
671e7d39069STrond Myklebust 	struct nfs_page	*req;
672e7d39069STrond Myklebust 
673e7d39069STrond Myklebust 	req = nfs_setup_write_request(ctx, page, offset, count);
674e7d39069STrond Myklebust 	if (IS_ERR(req))
675e7d39069STrond Myklebust 		return PTR_ERR(req);
676b80c3cb6STrond Myklebust 	nfs_mark_request_dirty(req);
677e7d39069STrond Myklebust 	/* Update file length */
678e7d39069STrond Myklebust 	nfs_grow_file(page, offset, count);
679e7d39069STrond Myklebust 	nfs_mark_uptodate(page, req->wb_pgbase, req->wb_bytes);
680a6305ddbSTrond Myklebust 	nfs_mark_request_dirty(req);
681e7d39069STrond Myklebust 	nfs_clear_page_tag_locked(req);
682e7d39069STrond Myklebust 	return 0;
683e7d39069STrond Myklebust }
684e7d39069STrond Myklebust 
6851da177e4SLinus Torvalds int nfs_flush_incompatible(struct file *file, struct page *page)
6861da177e4SLinus Torvalds {
687cd3758e3STrond Myklebust 	struct nfs_open_context *ctx = nfs_file_open_context(file);
6881da177e4SLinus Torvalds 	struct nfs_page	*req;
6891a54533eSTrond Myklebust 	int do_flush, status;
6901da177e4SLinus Torvalds 	/*
6911da177e4SLinus Torvalds 	 * Look for a request corresponding to this page. If there
6921da177e4SLinus Torvalds 	 * is one, and it belongs to another file, we flush it out
6931da177e4SLinus Torvalds 	 * before we try to copy anything into the page. Do this
6941da177e4SLinus Torvalds 	 * due to the lack of an ACCESS-type call in NFSv2.
6951da177e4SLinus Torvalds 	 * Also do the same if we find a request from an existing
6961da177e4SLinus Torvalds 	 * dropped page.
6971da177e4SLinus Torvalds 	 */
6981a54533eSTrond Myklebust 	do {
699277459d2STrond Myklebust 		req = nfs_page_find_request(page);
7001a54533eSTrond Myklebust 		if (req == NULL)
7011a54533eSTrond Myklebust 			return 0;
702f11ac8dbSTrond Myklebust 		do_flush = req->wb_page != page || req->wb_context != ctx ||
703f11ac8dbSTrond Myklebust 			req->wb_lock_context->lockowner != current->files ||
704f11ac8dbSTrond Myklebust 			req->wb_lock_context->pid != current->tgid;
7051da177e4SLinus Torvalds 		nfs_release_request(req);
7061a54533eSTrond Myklebust 		if (!do_flush)
7071a54533eSTrond Myklebust 			return 0;
708277459d2STrond Myklebust 		status = nfs_wb_page(page->mapping->host, page);
7091a54533eSTrond Myklebust 	} while (status == 0);
7101a54533eSTrond Myklebust 	return status;
7111da177e4SLinus Torvalds }
7121da177e4SLinus Torvalds 
7131da177e4SLinus Torvalds /*
7145d47a356STrond Myklebust  * If the page cache is marked as unsafe or invalid, then we can't rely on
7155d47a356STrond Myklebust  * the PageUptodate() flag. In this case, we will need to turn off
7165d47a356STrond Myklebust  * write optimisations that depend on the page contents being correct.
7175d47a356STrond Myklebust  */
7185d47a356STrond Myklebust static int nfs_write_pageuptodate(struct page *page, struct inode *inode)
7195d47a356STrond Myklebust {
7205d47a356STrond Myklebust 	return PageUptodate(page) &&
7215d47a356STrond Myklebust 		!(NFS_I(inode)->cache_validity & (NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_DATA));
7225d47a356STrond Myklebust }
7235d47a356STrond Myklebust 
7245d47a356STrond Myklebust /*
7251da177e4SLinus Torvalds  * Update and possibly write a cached page of an NFS file.
7261da177e4SLinus Torvalds  *
7271da177e4SLinus Torvalds  * XXX: Keep an eye on generic_file_read to make sure it doesn't do bad
7281da177e4SLinus Torvalds  * things with a page scheduled for an RPC call (e.g. invalidate it).
7291da177e4SLinus Torvalds  */
7301da177e4SLinus Torvalds int nfs_updatepage(struct file *file, struct page *page,
7311da177e4SLinus Torvalds 		unsigned int offset, unsigned int count)
7321da177e4SLinus Torvalds {
733cd3758e3STrond Myklebust 	struct nfs_open_context *ctx = nfs_file_open_context(file);
7341da177e4SLinus Torvalds 	struct inode	*inode = page->mapping->host;
7351da177e4SLinus Torvalds 	int		status = 0;
7361da177e4SLinus Torvalds 
73791d5b470SChuck Lever 	nfs_inc_stats(inode, NFSIOS_VFSUPDATEPAGE);
73891d5b470SChuck Lever 
73948186c7dSChuck Lever 	dprintk("NFS:       nfs_updatepage(%s/%s %d@%lld)\n",
74001cce933SJosef "Jeff" Sipek 		file->f_path.dentry->d_parent->d_name.name,
74101cce933SJosef "Jeff" Sipek 		file->f_path.dentry->d_name.name, count,
7420bbacc40SChuck Lever 		(long long)(page_offset(page) + offset));
7431da177e4SLinus Torvalds 
7441da177e4SLinus Torvalds 	/* If we're not using byte range locks, and we know the page
7455d47a356STrond Myklebust 	 * is up to date, it may be more efficient to extend the write
7465d47a356STrond Myklebust 	 * to cover the entire page in order to avoid fragmentation
7475d47a356STrond Myklebust 	 * inefficiencies.
7481da177e4SLinus Torvalds 	 */
7495d47a356STrond Myklebust 	if (nfs_write_pageuptodate(page, inode) &&
7505d47a356STrond Myklebust 			inode->i_flock == NULL &&
7516b2f3d1fSChristoph Hellwig 			!(file->f_flags & O_DSYNC)) {
75249a70f27STrond Myklebust 		count = max(count + offset, nfs_page_length(page));
7531da177e4SLinus Torvalds 		offset = 0;
7541da177e4SLinus Torvalds 	}
7551da177e4SLinus Torvalds 
756e21195a7STrond Myklebust 	status = nfs_writepage_setup(ctx, page, offset, count);
75703fa9e84STrond Myklebust 	if (status < 0)
75803fa9e84STrond Myklebust 		nfs_set_pageerror(page);
7591da177e4SLinus Torvalds 
76048186c7dSChuck Lever 	dprintk("NFS:       nfs_updatepage returns %d (isize %lld)\n",
7611da177e4SLinus Torvalds 			status, (long long)i_size_read(inode));
7621da177e4SLinus Torvalds 	return status;
7631da177e4SLinus Torvalds }
7641da177e4SLinus Torvalds 
7651da177e4SLinus Torvalds static void nfs_writepage_release(struct nfs_page *req)
7661da177e4SLinus Torvalds {
767a6305ddbSTrond Myklebust 	struct page *page = req->wb_page;
7688e821cadSTrond Myklebust 
769a6305ddbSTrond Myklebust 	if (PageError(req->wb_page) || !nfs_reschedule_unstable_write(req))
7701da177e4SLinus Torvalds 		nfs_inode_remove_request(req);
7719fd367f0STrond Myklebust 	nfs_clear_page_tag_locked(req);
772a6305ddbSTrond Myklebust 	nfs_end_page_writeback(page);
7731da177e4SLinus Torvalds }
7741da177e4SLinus Torvalds 
7753ff7576dSTrond Myklebust static int flush_task_priority(int how)
7761da177e4SLinus Torvalds {
7771da177e4SLinus Torvalds 	switch (how & (FLUSH_HIGHPRI|FLUSH_LOWPRI)) {
7781da177e4SLinus Torvalds 		case FLUSH_HIGHPRI:
7791da177e4SLinus Torvalds 			return RPC_PRIORITY_HIGH;
7801da177e4SLinus Torvalds 		case FLUSH_LOWPRI:
7811da177e4SLinus Torvalds 			return RPC_PRIORITY_LOW;
7821da177e4SLinus Torvalds 	}
7831da177e4SLinus Torvalds 	return RPC_PRIORITY_NORMAL;
7841da177e4SLinus Torvalds }
7851da177e4SLinus Torvalds 
786a69aef14SFred Isaman int nfs_initiate_write(struct nfs_write_data *data,
787d138d5d1SAndy Adamson 		       struct rpc_clnt *clnt,
788788e7a89STrond Myklebust 		       const struct rpc_call_ops *call_ops,
7891da177e4SLinus Torvalds 		       int how)
7901da177e4SLinus Torvalds {
791d138d5d1SAndy Adamson 	struct inode *inode = data->inode;
7923ff7576dSTrond Myklebust 	int priority = flush_task_priority(how);
79307737691STrond Myklebust 	struct rpc_task *task;
794bdc7f021STrond Myklebust 	struct rpc_message msg = {
795bdc7f021STrond Myklebust 		.rpc_argp = &data->args,
796bdc7f021STrond Myklebust 		.rpc_resp = &data->res,
797d138d5d1SAndy Adamson 		.rpc_cred = data->cred,
798bdc7f021STrond Myklebust 	};
79984115e1cSTrond Myklebust 	struct rpc_task_setup task_setup_data = {
800d138d5d1SAndy Adamson 		.rpc_client = clnt,
80107737691STrond Myklebust 		.task = &data->task,
802bdc7f021STrond Myklebust 		.rpc_message = &msg,
80384115e1cSTrond Myklebust 		.callback_ops = call_ops,
80484115e1cSTrond Myklebust 		.callback_data = data,
805101070caSTrond Myklebust 		.workqueue = nfsiod_workqueue,
8062c61be0aSTrond Myklebust 		.flags = RPC_TASK_ASYNC,
8073ff7576dSTrond Myklebust 		.priority = priority,
80884115e1cSTrond Myklebust 	};
8092c61be0aSTrond Myklebust 	int ret = 0;
8101da177e4SLinus Torvalds 
811d138d5d1SAndy Adamson 	/* Set up the initial task struct.  */
812d138d5d1SAndy Adamson 	NFS_PROTO(inode)->write_setup(data, &msg);
813d138d5d1SAndy Adamson 
814d138d5d1SAndy Adamson 	dprintk("NFS: %5u initiated write call "
815d138d5d1SAndy Adamson 		"(req %s/%lld, %u bytes @ offset %llu)\n",
816d138d5d1SAndy Adamson 		data->task.tk_pid,
817d138d5d1SAndy Adamson 		inode->i_sb->s_id,
818d138d5d1SAndy Adamson 		(long long)NFS_FILEID(inode),
819d138d5d1SAndy Adamson 		data->args.count,
820d138d5d1SAndy Adamson 		(unsigned long long)data->args.offset);
821d138d5d1SAndy Adamson 
822d138d5d1SAndy Adamson 	task = rpc_run_task(&task_setup_data);
823d138d5d1SAndy Adamson 	if (IS_ERR(task)) {
824d138d5d1SAndy Adamson 		ret = PTR_ERR(task);
825d138d5d1SAndy Adamson 		goto out;
826d138d5d1SAndy Adamson 	}
827d138d5d1SAndy Adamson 	if (how & FLUSH_SYNC) {
828d138d5d1SAndy Adamson 		ret = rpc_wait_for_completion_task(task);
829d138d5d1SAndy Adamson 		if (ret == 0)
830d138d5d1SAndy Adamson 			ret = task->tk_status;
831d138d5d1SAndy Adamson 	}
832d138d5d1SAndy Adamson 	rpc_put_task(task);
833d138d5d1SAndy Adamson out:
834d138d5d1SAndy Adamson 	return ret;
835d138d5d1SAndy Adamson }
836a69aef14SFred Isaman EXPORT_SYMBOL_GPL(nfs_initiate_write);
837d138d5d1SAndy Adamson 
838d138d5d1SAndy Adamson /*
839d138d5d1SAndy Adamson  * Set up the argument/result storage required for the RPC call.
840d138d5d1SAndy Adamson  */
841d138d5d1SAndy Adamson static int nfs_write_rpcsetup(struct nfs_page *req,
842d138d5d1SAndy Adamson 		struct nfs_write_data *data,
843d138d5d1SAndy Adamson 		const struct rpc_call_ops *call_ops,
844d138d5d1SAndy Adamson 		unsigned int count, unsigned int offset,
8455053aa56SFred Isaman 		struct pnfs_layout_segment *lseg,
846d138d5d1SAndy Adamson 		int how)
847d138d5d1SAndy Adamson {
848d138d5d1SAndy Adamson 	struct inode *inode = req->wb_context->path.dentry->d_inode;
849d138d5d1SAndy Adamson 
8501da177e4SLinus Torvalds 	/* Set up the RPC argument and reply structs
8511da177e4SLinus Torvalds 	 * NB: take care not to mess about with data->commit et al. */
8521da177e4SLinus Torvalds 
8531da177e4SLinus Torvalds 	data->req = req;
85488be9f99STrond Myklebust 	data->inode = inode = req->wb_context->path.dentry->d_inode;
855d138d5d1SAndy Adamson 	data->cred = req->wb_context->cred;
8565053aa56SFred Isaman 	data->lseg = get_lseg(lseg);
8571da177e4SLinus Torvalds 
8581da177e4SLinus Torvalds 	data->args.fh     = NFS_FH(inode);
8591da177e4SLinus Torvalds 	data->args.offset = req_offset(req) + offset;
8601da177e4SLinus Torvalds 	data->args.pgbase = req->wb_pgbase + offset;
8611da177e4SLinus Torvalds 	data->args.pages  = data->pagevec;
8621da177e4SLinus Torvalds 	data->args.count  = count;
863383ba719STrond Myklebust 	data->args.context = get_nfs_open_context(req->wb_context);
864f11ac8dbSTrond Myklebust 	data->args.lock_context = req->wb_lock_context;
865bdc7f021STrond Myklebust 	data->args.stable  = NFS_UNSTABLE;
866b31268acSTrond Myklebust 	if (how & (FLUSH_STABLE | FLUSH_COND_STABLE)) {
867bdc7f021STrond Myklebust 		data->args.stable = NFS_DATA_SYNC;
868fb8a1f11STrond Myklebust 		if (!nfs_need_commit(NFS_I(inode)))
869bdc7f021STrond Myklebust 			data->args.stable = NFS_FILE_SYNC;
870bdc7f021STrond Myklebust 	}
8711da177e4SLinus Torvalds 
8721da177e4SLinus Torvalds 	data->res.fattr   = &data->fattr;
8731da177e4SLinus Torvalds 	data->res.count   = count;
8741da177e4SLinus Torvalds 	data->res.verf    = &data->verf;
8750e574af1STrond Myklebust 	nfs_fattr_init(&data->fattr);
8761da177e4SLinus Torvalds 
8770382b744SAndy Adamson 	if (data->lseg &&
8780382b744SAndy Adamson 	    (pnfs_try_to_write_data(data, call_ops, how) == PNFS_ATTEMPTED))
8790382b744SAndy Adamson 		return 0;
8800382b744SAndy Adamson 
881d138d5d1SAndy Adamson 	return nfs_initiate_write(data, NFS_CLIENT(inode), call_ops, how);
8821da177e4SLinus Torvalds }
8831da177e4SLinus Torvalds 
8846d884e8fSFred /* If a nfs_flush_* function fails, it should remove reqs from @head and
8856d884e8fSFred  * call this on each, which will prepare them to be retried on next
8866d884e8fSFred  * writeback using standard nfs.
8876d884e8fSFred  */
8886d884e8fSFred static void nfs_redirty_request(struct nfs_page *req)
8896d884e8fSFred {
890a6305ddbSTrond Myklebust 	struct page *page = req->wb_page;
891a6305ddbSTrond Myklebust 
8926d884e8fSFred 	nfs_mark_request_dirty(req);
8936d884e8fSFred 	nfs_clear_page_tag_locked(req);
894a6305ddbSTrond Myklebust 	nfs_end_page_writeback(page);
8956d884e8fSFred }
8966d884e8fSFred 
8971da177e4SLinus Torvalds /*
8981da177e4SLinus Torvalds  * Generate multiple small requests to write out a single
8991da177e4SLinus Torvalds  * contiguous dirty area on one page.
9001da177e4SLinus Torvalds  */
901c76069bdSFred Isaman static int nfs_flush_multi(struct nfs_pageio_descriptor *desc)
9021da177e4SLinus Torvalds {
903c76069bdSFred Isaman 	struct nfs_page *req = nfs_list_entry(desc->pg_list.next);
9041da177e4SLinus Torvalds 	struct page *page = req->wb_page;
9051da177e4SLinus Torvalds 	struct nfs_write_data *data;
906c76069bdSFred Isaman 	size_t wsize = NFS_SERVER(desc->pg_inode)->wsize, nbytes;
907e9f7bee1STrond Myklebust 	unsigned int offset;
9081da177e4SLinus Torvalds 	int requests = 0;
909dbae4c73STrond Myklebust 	int ret = 0;
910c76069bdSFred Isaman 	struct pnfs_layout_segment *lseg;
9111da177e4SLinus Torvalds 	LIST_HEAD(list);
9121da177e4SLinus Torvalds 
9131da177e4SLinus Torvalds 	nfs_list_remove_request(req);
9141da177e4SLinus Torvalds 
915b31268acSTrond Myklebust 	if ((desc->pg_ioflags & FLUSH_COND_STABLE) &&
916b31268acSTrond Myklebust 	    (desc->pg_moreio || NFS_I(desc->pg_inode)->ncommit ||
917b31268acSTrond Myklebust 	     desc->pg_count > wsize))
918b31268acSTrond Myklebust 		desc->pg_ioflags &= ~FLUSH_COND_STABLE;
919b31268acSTrond Myklebust 
920b31268acSTrond Myklebust 
921c76069bdSFred Isaman 	nbytes = desc->pg_count;
922e9f7bee1STrond Myklebust 	do {
923e9f7bee1STrond Myklebust 		size_t len = min(nbytes, wsize);
924e9f7bee1STrond Myklebust 
9258d5658c9STrond Myklebust 		data = nfs_writedata_alloc(1);
9261da177e4SLinus Torvalds 		if (!data)
9271da177e4SLinus Torvalds 			goto out_bad;
9281da177e4SLinus Torvalds 		list_add(&data->pages, &list);
9291da177e4SLinus Torvalds 		requests++;
930e9f7bee1STrond Myklebust 		nbytes -= len;
931e9f7bee1STrond Myklebust 	} while (nbytes != 0);
9321da177e4SLinus Torvalds 	atomic_set(&req->wb_complete, requests);
9331da177e4SLinus Torvalds 
934c76069bdSFred Isaman 	BUG_ON(desc->pg_lseg);
935c76069bdSFred Isaman 	lseg = pnfs_update_layout(desc->pg_inode, req->wb_context, IOMODE_RW);
9361da177e4SLinus Torvalds 	ClearPageError(page);
9371da177e4SLinus Torvalds 	offset = 0;
938c76069bdSFred Isaman 	nbytes = desc->pg_count;
9391da177e4SLinus Torvalds 	do {
940dbae4c73STrond Myklebust 		int ret2;
941dbae4c73STrond Myklebust 
9421da177e4SLinus Torvalds 		data = list_entry(list.next, struct nfs_write_data, pages);
9431da177e4SLinus Torvalds 		list_del_init(&data->pages);
9441da177e4SLinus Torvalds 
9451da177e4SLinus Torvalds 		data->pagevec[0] = page;
9461da177e4SLinus Torvalds 
947bcb71bbaSTrond Myklebust 		if (nbytes < wsize)
948bcb71bbaSTrond Myklebust 			wsize = nbytes;
949dbae4c73STrond Myklebust 		ret2 = nfs_write_rpcsetup(req, data, &nfs_write_partial_ops,
950c76069bdSFred Isaman 					  wsize, offset, lseg, desc->pg_ioflags);
951dbae4c73STrond Myklebust 		if (ret == 0)
952dbae4c73STrond Myklebust 			ret = ret2;
9531da177e4SLinus Torvalds 		offset += wsize;
9541da177e4SLinus Torvalds 		nbytes -= wsize;
9551da177e4SLinus Torvalds 	} while (nbytes != 0);
9561da177e4SLinus Torvalds 
95744b83799SFred Isaman 	put_lseg(lseg);
95836fe432dSFred Isaman 	desc->pg_lseg = NULL;
959dbae4c73STrond Myklebust 	return ret;
9601da177e4SLinus Torvalds 
9611da177e4SLinus Torvalds out_bad:
9621da177e4SLinus Torvalds 	while (!list_empty(&list)) {
9631da177e4SLinus Torvalds 		data = list_entry(list.next, struct nfs_write_data, pages);
9641da177e4SLinus Torvalds 		list_del(&data->pages);
9650da2a4acSFred Isaman 		nfs_writedata_free(data);
9661da177e4SLinus Torvalds 	}
96761822ab5STrond Myklebust 	nfs_redirty_request(req);
9681da177e4SLinus Torvalds 	return -ENOMEM;
9691da177e4SLinus Torvalds }
9701da177e4SLinus Torvalds 
9711da177e4SLinus Torvalds /*
9721da177e4SLinus Torvalds  * Create an RPC task for the given write request and kick it.
9731da177e4SLinus Torvalds  * The page must have been locked by the caller.
9741da177e4SLinus Torvalds  *
9751da177e4SLinus Torvalds  * It may happen that the page we're passed is not marked dirty.
9761da177e4SLinus Torvalds  * This is the case if nfs_updatepage detects a conflicting request
9771da177e4SLinus Torvalds  * that has been written but not committed.
9781da177e4SLinus Torvalds  */
979c76069bdSFred Isaman static int nfs_flush_one(struct nfs_pageio_descriptor *desc)
9801da177e4SLinus Torvalds {
9811da177e4SLinus Torvalds 	struct nfs_page		*req;
9821da177e4SLinus Torvalds 	struct page		**pages;
9831da177e4SLinus Torvalds 	struct nfs_write_data	*data;
984c76069bdSFred Isaman 	struct list_head *head = &desc->pg_list;
985c76069bdSFred Isaman 	struct pnfs_layout_segment *lseg = desc->pg_lseg;
98644b83799SFred Isaman 	int ret;
9871da177e4SLinus Torvalds 
988c76069bdSFred Isaman 	data = nfs_writedata_alloc(nfs_page_array_len(desc->pg_base,
989c76069bdSFred Isaman 						      desc->pg_count));
99044b83799SFred Isaman 	if (!data) {
99144b83799SFred Isaman 		while (!list_empty(head)) {
99244b83799SFred Isaman 			req = nfs_list_entry(head->next);
99344b83799SFred Isaman 			nfs_list_remove_request(req);
99444b83799SFred Isaman 			nfs_redirty_request(req);
99544b83799SFred Isaman 		}
99644b83799SFred Isaman 		ret = -ENOMEM;
99744b83799SFred Isaman 		goto out;
99844b83799SFred Isaman 	}
9991da177e4SLinus Torvalds 	pages = data->pagevec;
10001da177e4SLinus Torvalds 	while (!list_empty(head)) {
10011da177e4SLinus Torvalds 		req = nfs_list_entry(head->next);
10021da177e4SLinus Torvalds 		nfs_list_remove_request(req);
10031da177e4SLinus Torvalds 		nfs_list_add_request(req, &data->pages);
10041da177e4SLinus Torvalds 		ClearPageError(req->wb_page);
10051da177e4SLinus Torvalds 		*pages++ = req->wb_page;
10061da177e4SLinus Torvalds 	}
10071da177e4SLinus Torvalds 	req = nfs_list_entry(data->pages.next);
100844b83799SFred Isaman 	if ((!lseg) && list_is_singular(&data->pages))
1009c76069bdSFred Isaman 		lseg = pnfs_update_layout(desc->pg_inode, req->wb_context, IOMODE_RW);
10101da177e4SLinus Torvalds 
1011b31268acSTrond Myklebust 	if ((desc->pg_ioflags & FLUSH_COND_STABLE) &&
1012b31268acSTrond Myklebust 	    (desc->pg_moreio || NFS_I(desc->pg_inode)->ncommit))
1013b31268acSTrond Myklebust 		desc->pg_ioflags &= ~FLUSH_COND_STABLE;
1014b31268acSTrond Myklebust 
10151da177e4SLinus Torvalds 	/* Set up the argument struct */
1016c76069bdSFred Isaman 	ret = nfs_write_rpcsetup(req, data, &nfs_write_full_ops, desc->pg_count, 0, lseg, desc->pg_ioflags);
101744b83799SFred Isaman out:
101844b83799SFred Isaman 	put_lseg(lseg); /* Cleans any gotten in ->pg_test */
101936fe432dSFred Isaman 	desc->pg_lseg = NULL;
102044b83799SFred Isaman 	return ret;
10211da177e4SLinus Torvalds }
10221da177e4SLinus Torvalds 
1023c63c7b05STrond Myklebust static void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio,
1024c63c7b05STrond Myklebust 				  struct inode *inode, int ioflags)
10251da177e4SLinus Torvalds {
1026bf4285e7SChuck Lever 	size_t wsize = NFS_SERVER(inode)->wsize;
10271da177e4SLinus Torvalds 
102844b83799SFred Isaman 	pnfs_pageio_init_write(pgio, inode);
102994ad1c80SFred Isaman 
1030bcb71bbaSTrond Myklebust 	if (wsize < PAGE_CACHE_SIZE)
1031c63c7b05STrond Myklebust 		nfs_pageio_init(pgio, inode, nfs_flush_multi, wsize, ioflags);
1032bcb71bbaSTrond Myklebust 	else
1033c63c7b05STrond Myklebust 		nfs_pageio_init(pgio, inode, nfs_flush_one, wsize, ioflags);
10341da177e4SLinus Torvalds }
10351da177e4SLinus Torvalds 
10361da177e4SLinus Torvalds /*
10371da177e4SLinus Torvalds  * Handle a write reply that flushed part of a page.
10381da177e4SLinus Torvalds  */
1039788e7a89STrond Myklebust static void nfs_writeback_done_partial(struct rpc_task *task, void *calldata)
10401da177e4SLinus Torvalds {
1041788e7a89STrond Myklebust 	struct nfs_write_data	*data = calldata;
10421da177e4SLinus Torvalds 
104348186c7dSChuck Lever 	dprintk("NFS: %5u write(%s/%lld %d@%lld)",
104448186c7dSChuck Lever 		task->tk_pid,
104548186c7dSChuck Lever 		data->req->wb_context->path.dentry->d_inode->i_sb->s_id,
104648186c7dSChuck Lever 		(long long)
104748186c7dSChuck Lever 		  NFS_FILEID(data->req->wb_context->path.dentry->d_inode),
104848186c7dSChuck Lever 		data->req->wb_bytes, (long long)req_offset(data->req));
10491da177e4SLinus Torvalds 
1050c9d8f89dSTrond Myklebust 	nfs_writeback_done(task, data);
1051c9d8f89dSTrond Myklebust }
1052788e7a89STrond Myklebust 
1053c9d8f89dSTrond Myklebust static void nfs_writeback_release_partial(void *calldata)
1054c9d8f89dSTrond Myklebust {
1055c9d8f89dSTrond Myklebust 	struct nfs_write_data	*data = calldata;
1056c9d8f89dSTrond Myklebust 	struct nfs_page		*req = data->req;
1057c9d8f89dSTrond Myklebust 	struct page		*page = req->wb_page;
1058c9d8f89dSTrond Myklebust 	int status = data->task.tk_status;
1059c9d8f89dSTrond Myklebust 
1060c9d8f89dSTrond Myklebust 	if (status < 0) {
1061a301b777STrond Myklebust 		nfs_set_pageerror(page);
1062c9d8f89dSTrond Myklebust 		nfs_context_set_write_error(req->wb_context, status);
1063c9d8f89dSTrond Myklebust 		dprintk(", error = %d\n", status);
10648e821cadSTrond Myklebust 		goto out;
10658e821cadSTrond Myklebust 	}
10668e821cadSTrond Myklebust 
10678e821cadSTrond Myklebust 	if (nfs_write_need_commit(data)) {
1068587142f8STrond Myklebust 		struct inode *inode = page->mapping->host;
10698e821cadSTrond Myklebust 
1070587142f8STrond Myklebust 		spin_lock(&inode->i_lock);
10718e821cadSTrond Myklebust 		if (test_bit(PG_NEED_RESCHED, &req->wb_flags)) {
10728e821cadSTrond Myklebust 			/* Do nothing we need to resend the writes */
10738e821cadSTrond Myklebust 		} else if (!test_and_set_bit(PG_NEED_COMMIT, &req->wb_flags)) {
10741da177e4SLinus Torvalds 			memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf));
10751da177e4SLinus Torvalds 			dprintk(" defer commit\n");
10761da177e4SLinus Torvalds 		} else if (memcmp(&req->wb_verf, &data->verf, sizeof(req->wb_verf))) {
10778e821cadSTrond Myklebust 			set_bit(PG_NEED_RESCHED, &req->wb_flags);
10788e821cadSTrond Myklebust 			clear_bit(PG_NEED_COMMIT, &req->wb_flags);
10791da177e4SLinus Torvalds 			dprintk(" server reboot detected\n");
10801da177e4SLinus Torvalds 		}
1081587142f8STrond Myklebust 		spin_unlock(&inode->i_lock);
10821da177e4SLinus Torvalds 	} else
10831da177e4SLinus Torvalds 		dprintk(" OK\n");
10841da177e4SLinus Torvalds 
10858e821cadSTrond Myklebust out:
10861da177e4SLinus Torvalds 	if (atomic_dec_and_test(&req->wb_complete))
10871da177e4SLinus Torvalds 		nfs_writepage_release(req);
1088c9d8f89dSTrond Myklebust 	nfs_writedata_release(calldata);
10891da177e4SLinus Torvalds }
10901da177e4SLinus Torvalds 
1091def6ed7eSAndy Adamson #if defined(CONFIG_NFS_V4_1)
1092def6ed7eSAndy Adamson void nfs_write_prepare(struct rpc_task *task, void *calldata)
1093def6ed7eSAndy Adamson {
1094def6ed7eSAndy Adamson 	struct nfs_write_data *data = calldata;
1095def6ed7eSAndy Adamson 
1096035168abSTrond Myklebust 	if (nfs4_setup_sequence(NFS_SERVER(data->inode),
1097035168abSTrond Myklebust 				&data->args.seq_args,
1098def6ed7eSAndy Adamson 				&data->res.seq_res, 1, task))
1099def6ed7eSAndy Adamson 		return;
1100def6ed7eSAndy Adamson 	rpc_call_start(task);
1101def6ed7eSAndy Adamson }
1102def6ed7eSAndy Adamson #endif /* CONFIG_NFS_V4_1 */
1103def6ed7eSAndy Adamson 
1104788e7a89STrond Myklebust static const struct rpc_call_ops nfs_write_partial_ops = {
1105def6ed7eSAndy Adamson #if defined(CONFIG_NFS_V4_1)
1106def6ed7eSAndy Adamson 	.rpc_call_prepare = nfs_write_prepare,
1107def6ed7eSAndy Adamson #endif /* CONFIG_NFS_V4_1 */
1108788e7a89STrond Myklebust 	.rpc_call_done = nfs_writeback_done_partial,
1109c9d8f89dSTrond Myklebust 	.rpc_release = nfs_writeback_release_partial,
1110788e7a89STrond Myklebust };
1111788e7a89STrond Myklebust 
11121da177e4SLinus Torvalds /*
11131da177e4SLinus Torvalds  * Handle a write reply that flushes a whole page.
11141da177e4SLinus Torvalds  *
11151da177e4SLinus Torvalds  * FIXME: There is an inherent race with invalidate_inode_pages and
11161da177e4SLinus Torvalds  *	  writebacks since the page->count is kept > 1 for as long
11171da177e4SLinus Torvalds  *	  as the page has a write request pending.
11181da177e4SLinus Torvalds  */
1119788e7a89STrond Myklebust static void nfs_writeback_done_full(struct rpc_task *task, void *calldata)
11201da177e4SLinus Torvalds {
1121788e7a89STrond Myklebust 	struct nfs_write_data	*data = calldata;
11221da177e4SLinus Torvalds 
1123c9d8f89dSTrond Myklebust 	nfs_writeback_done(task, data);
1124c9d8f89dSTrond Myklebust }
1125c9d8f89dSTrond Myklebust 
1126c9d8f89dSTrond Myklebust static void nfs_writeback_release_full(void *calldata)
1127c9d8f89dSTrond Myklebust {
1128c9d8f89dSTrond Myklebust 	struct nfs_write_data	*data = calldata;
1129c9d8f89dSTrond Myklebust 	int status = data->task.tk_status;
1130788e7a89STrond Myklebust 
11311da177e4SLinus Torvalds 	/* Update attributes as result of writeback. */
11321da177e4SLinus Torvalds 	while (!list_empty(&data->pages)) {
1133c9d8f89dSTrond Myklebust 		struct nfs_page *req = nfs_list_entry(data->pages.next);
1134c9d8f89dSTrond Myklebust 		struct page *page = req->wb_page;
1135c9d8f89dSTrond Myklebust 
11361da177e4SLinus Torvalds 		nfs_list_remove_request(req);
11371da177e4SLinus Torvalds 
113848186c7dSChuck Lever 		dprintk("NFS: %5u write (%s/%lld %d@%lld)",
113948186c7dSChuck Lever 			data->task.tk_pid,
114088be9f99STrond Myklebust 			req->wb_context->path.dentry->d_inode->i_sb->s_id,
114188be9f99STrond Myklebust 			(long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
11421da177e4SLinus Torvalds 			req->wb_bytes,
11431da177e4SLinus Torvalds 			(long long)req_offset(req));
11441da177e4SLinus Torvalds 
1145c9d8f89dSTrond Myklebust 		if (status < 0) {
1146a301b777STrond Myklebust 			nfs_set_pageerror(page);
1147c9d8f89dSTrond Myklebust 			nfs_context_set_write_error(req->wb_context, status);
1148c9d8f89dSTrond Myklebust 			dprintk(", error = %d\n", status);
11498e821cadSTrond Myklebust 			goto remove_request;
11501da177e4SLinus Torvalds 		}
11511da177e4SLinus Torvalds 
11528e821cadSTrond Myklebust 		if (nfs_write_need_commit(data)) {
11531da177e4SLinus Torvalds 			memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf));
11541da177e4SLinus Torvalds 			nfs_mark_request_commit(req);
11551da177e4SLinus Torvalds 			dprintk(" marked for commit\n");
11568e821cadSTrond Myklebust 			goto next;
11578e821cadSTrond Myklebust 		}
11588e821cadSTrond Myklebust 		dprintk(" OK\n");
11598e821cadSTrond Myklebust remove_request:
11601da177e4SLinus Torvalds 		nfs_inode_remove_request(req);
11611da177e4SLinus Torvalds 	next:
11629fd367f0STrond Myklebust 		nfs_clear_page_tag_locked(req);
1163a6305ddbSTrond Myklebust 		nfs_end_page_writeback(page);
11641da177e4SLinus Torvalds 	}
1165c9d8f89dSTrond Myklebust 	nfs_writedata_release(calldata);
11661da177e4SLinus Torvalds }
11671da177e4SLinus Torvalds 
1168788e7a89STrond Myklebust static const struct rpc_call_ops nfs_write_full_ops = {
1169def6ed7eSAndy Adamson #if defined(CONFIG_NFS_V4_1)
1170def6ed7eSAndy Adamson 	.rpc_call_prepare = nfs_write_prepare,
1171def6ed7eSAndy Adamson #endif /* CONFIG_NFS_V4_1 */
1172788e7a89STrond Myklebust 	.rpc_call_done = nfs_writeback_done_full,
1173c9d8f89dSTrond Myklebust 	.rpc_release = nfs_writeback_release_full,
1174788e7a89STrond Myklebust };
1175788e7a89STrond Myklebust 
1176788e7a89STrond Myklebust 
11771da177e4SLinus Torvalds /*
11781da177e4SLinus Torvalds  * This function is called when the WRITE call is complete.
11791da177e4SLinus Torvalds  */
118013602896SFred Isaman void nfs_writeback_done(struct rpc_task *task, struct nfs_write_data *data)
11811da177e4SLinus Torvalds {
11821da177e4SLinus Torvalds 	struct nfs_writeargs	*argp = &data->args;
11831da177e4SLinus Torvalds 	struct nfs_writeres	*resp = &data->res;
1184eedc020eSAndy Adamson 	struct nfs_server	*server = NFS_SERVER(data->inode);
1185788e7a89STrond Myklebust 	int status;
11861da177e4SLinus Torvalds 
1187a3f565b1SChuck Lever 	dprintk("NFS: %5u nfs_writeback_done (status %d)\n",
11881da177e4SLinus Torvalds 		task->tk_pid, task->tk_status);
11891da177e4SLinus Torvalds 
1190f551e44fSChuck Lever 	/*
1191f551e44fSChuck Lever 	 * ->write_done will attempt to use post-op attributes to detect
1192f551e44fSChuck Lever 	 * conflicting writes by other clients.  A strict interpretation
1193f551e44fSChuck Lever 	 * of close-to-open would allow us to continue caching even if
1194f551e44fSChuck Lever 	 * another writer had changed the file, but some applications
1195f551e44fSChuck Lever 	 * depend on tighter cache coherency when writing.
1196f551e44fSChuck Lever 	 */
1197788e7a89STrond Myklebust 	status = NFS_PROTO(data->inode)->write_done(task, data);
1198788e7a89STrond Myklebust 	if (status != 0)
119913602896SFred Isaman 		return;
120091d5b470SChuck Lever 	nfs_add_stats(data->inode, NFSIOS_SERVERWRITTENBYTES, resp->count);
120191d5b470SChuck Lever 
12021da177e4SLinus Torvalds #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
12031da177e4SLinus Torvalds 	if (resp->verf->committed < argp->stable && task->tk_status >= 0) {
12041da177e4SLinus Torvalds 		/* We tried a write call, but the server did not
12051da177e4SLinus Torvalds 		 * commit data to stable storage even though we
12061da177e4SLinus Torvalds 		 * requested it.
12071da177e4SLinus Torvalds 		 * Note: There is a known bug in Tru64 < 5.0 in which
12081da177e4SLinus Torvalds 		 *	 the server reports NFS_DATA_SYNC, but performs
12091da177e4SLinus Torvalds 		 *	 NFS_FILE_SYNC. We therefore implement this checking
12101da177e4SLinus Torvalds 		 *	 as a dprintk() in order to avoid filling syslog.
12111da177e4SLinus Torvalds 		 */
12121da177e4SLinus Torvalds 		static unsigned long    complain;
12131da177e4SLinus Torvalds 
1214a69aef14SFred Isaman 		/* Note this will print the MDS for a DS write */
12151da177e4SLinus Torvalds 		if (time_before(complain, jiffies)) {
12161da177e4SLinus Torvalds 			dprintk("NFS:       faulty NFS server %s:"
12171da177e4SLinus Torvalds 				" (committed = %d) != (stable = %d)\n",
1218eedc020eSAndy Adamson 				server->nfs_client->cl_hostname,
12191da177e4SLinus Torvalds 				resp->verf->committed, argp->stable);
12201da177e4SLinus Torvalds 			complain = jiffies + 300 * HZ;
12211da177e4SLinus Torvalds 		}
12221da177e4SLinus Torvalds 	}
12231da177e4SLinus Torvalds #endif
12241da177e4SLinus Torvalds 	/* Is this a short write? */
12251da177e4SLinus Torvalds 	if (task->tk_status >= 0 && resp->count < argp->count) {
12261da177e4SLinus Torvalds 		static unsigned long    complain;
12271da177e4SLinus Torvalds 
122891d5b470SChuck Lever 		nfs_inc_stats(data->inode, NFSIOS_SHORTWRITE);
122991d5b470SChuck Lever 
12301da177e4SLinus Torvalds 		/* Has the server at least made some progress? */
12311da177e4SLinus Torvalds 		if (resp->count != 0) {
12321da177e4SLinus Torvalds 			/* Was this an NFSv2 write or an NFSv3 stable write? */
12331da177e4SLinus Torvalds 			if (resp->verf->committed != NFS_UNSTABLE) {
12341da177e4SLinus Torvalds 				/* Resend from where the server left off */
1235a69aef14SFred Isaman 				data->mds_offset += resp->count;
12361da177e4SLinus Torvalds 				argp->offset += resp->count;
12371da177e4SLinus Torvalds 				argp->pgbase += resp->count;
12381da177e4SLinus Torvalds 				argp->count -= resp->count;
12391da177e4SLinus Torvalds 			} else {
12401da177e4SLinus Torvalds 				/* Resend as a stable write in order to avoid
12411da177e4SLinus Torvalds 				 * headaches in the case of a server crash.
12421da177e4SLinus Torvalds 				 */
12431da177e4SLinus Torvalds 				argp->stable = NFS_FILE_SYNC;
12441da177e4SLinus Torvalds 			}
12450110ee15STrond Myklebust 			nfs_restart_rpc(task, server->nfs_client);
124613602896SFred Isaman 			return;
12471da177e4SLinus Torvalds 		}
12481da177e4SLinus Torvalds 		if (time_before(complain, jiffies)) {
12491da177e4SLinus Torvalds 			printk(KERN_WARNING
12501da177e4SLinus Torvalds 			       "NFS: Server wrote zero bytes, expected %u.\n",
12511da177e4SLinus Torvalds 					argp->count);
12521da177e4SLinus Torvalds 			complain = jiffies + 300 * HZ;
12531da177e4SLinus Torvalds 		}
12541da177e4SLinus Torvalds 		/* Can't do anything about it except throw an error. */
12551da177e4SLinus Torvalds 		task->tk_status = -EIO;
12561da177e4SLinus Torvalds 	}
125713602896SFred Isaman 	return;
12581da177e4SLinus Torvalds }
12591da177e4SLinus Torvalds 
12601da177e4SLinus Torvalds 
12611da177e4SLinus Torvalds #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
126271d0a611STrond Myklebust static int nfs_commit_set_lock(struct nfs_inode *nfsi, int may_wait)
126371d0a611STrond Myklebust {
1264*b8413f98STrond Myklebust 	int ret;
1265*b8413f98STrond Myklebust 
126671d0a611STrond Myklebust 	if (!test_and_set_bit(NFS_INO_COMMIT, &nfsi->flags))
126771d0a611STrond Myklebust 		return 1;
1268*b8413f98STrond Myklebust 	if (!may_wait)
126971d0a611STrond Myklebust 		return 0;
1270*b8413f98STrond Myklebust 	ret = out_of_line_wait_on_bit_lock(&nfsi->flags,
1271*b8413f98STrond Myklebust 				NFS_INO_COMMIT,
1272*b8413f98STrond Myklebust 				nfs_wait_bit_killable,
1273*b8413f98STrond Myklebust 				TASK_KILLABLE);
1274*b8413f98STrond Myklebust 	return (ret < 0) ? ret : 1;
127571d0a611STrond Myklebust }
127671d0a611STrond Myklebust 
127771d0a611STrond Myklebust static void nfs_commit_clear_lock(struct nfs_inode *nfsi)
127871d0a611STrond Myklebust {
127971d0a611STrond Myklebust 	clear_bit(NFS_INO_COMMIT, &nfsi->flags);
128071d0a611STrond Myklebust 	smp_mb__after_clear_bit();
128171d0a611STrond Myklebust 	wake_up_bit(&nfsi->flags, NFS_INO_COMMIT);
128271d0a611STrond Myklebust }
128371d0a611STrond Myklebust 
128471d0a611STrond Myklebust 
12850aa05887SH Hartley Sweeten static void nfs_commitdata_release(void *data)
12861da177e4SLinus Torvalds {
1287383ba719STrond Myklebust 	struct nfs_write_data *wdata = data;
1288383ba719STrond Myklebust 
1289383ba719STrond Myklebust 	put_nfs_open_context(wdata->args.context);
12901da177e4SLinus Torvalds 	nfs_commit_free(wdata);
12911da177e4SLinus Torvalds }
12921da177e4SLinus Torvalds 
12931da177e4SLinus Torvalds /*
12941da177e4SLinus Torvalds  * Set up the argument/result storage required for the RPC call.
12951da177e4SLinus Torvalds  */
1296dbae4c73STrond Myklebust static int nfs_commit_rpcsetup(struct list_head *head,
1297788e7a89STrond Myklebust 		struct nfs_write_data *data,
1298788e7a89STrond Myklebust 		int how)
12991da177e4SLinus Torvalds {
130084115e1cSTrond Myklebust 	struct nfs_page *first = nfs_list_entry(head->next);
130184115e1cSTrond Myklebust 	struct inode *inode = first->wb_context->path.dentry->d_inode;
13023ff7576dSTrond Myklebust 	int priority = flush_task_priority(how);
130307737691STrond Myklebust 	struct rpc_task *task;
1304bdc7f021STrond Myklebust 	struct rpc_message msg = {
1305bdc7f021STrond Myklebust 		.rpc_argp = &data->args,
1306bdc7f021STrond Myklebust 		.rpc_resp = &data->res,
1307bdc7f021STrond Myklebust 		.rpc_cred = first->wb_context->cred,
1308bdc7f021STrond Myklebust 	};
130984115e1cSTrond Myklebust 	struct rpc_task_setup task_setup_data = {
131007737691STrond Myklebust 		.task = &data->task,
131184115e1cSTrond Myklebust 		.rpc_client = NFS_CLIENT(inode),
1312bdc7f021STrond Myklebust 		.rpc_message = &msg,
131384115e1cSTrond Myklebust 		.callback_ops = &nfs_commit_ops,
131484115e1cSTrond Myklebust 		.callback_data = data,
1315101070caSTrond Myklebust 		.workqueue = nfsiod_workqueue,
13162c61be0aSTrond Myklebust 		.flags = RPC_TASK_ASYNC,
13173ff7576dSTrond Myklebust 		.priority = priority,
131884115e1cSTrond Myklebust 	};
13191da177e4SLinus Torvalds 
13201da177e4SLinus Torvalds 	/* Set up the RPC argument and reply structs
13211da177e4SLinus Torvalds 	 * NB: take care not to mess about with data->commit et al. */
13221da177e4SLinus Torvalds 
13231da177e4SLinus Torvalds 	list_splice_init(head, &data->pages);
13241da177e4SLinus Torvalds 
13251da177e4SLinus Torvalds 	data->inode	  = inode;
1326bdc7f021STrond Myklebust 	data->cred	  = msg.rpc_cred;
13271da177e4SLinus Torvalds 
13281da177e4SLinus Torvalds 	data->args.fh     = NFS_FH(data->inode);
13293da28eb1STrond Myklebust 	/* Note: we always request a commit of the entire inode */
13303da28eb1STrond Myklebust 	data->args.offset = 0;
13313da28eb1STrond Myklebust 	data->args.count  = 0;
1332383ba719STrond Myklebust 	data->args.context = get_nfs_open_context(first->wb_context);
13333da28eb1STrond Myklebust 	data->res.count   = 0;
13341da177e4SLinus Torvalds 	data->res.fattr   = &data->fattr;
13351da177e4SLinus Torvalds 	data->res.verf    = &data->verf;
13360e574af1STrond Myklebust 	nfs_fattr_init(&data->fattr);
13371da177e4SLinus Torvalds 
1338788e7a89STrond Myklebust 	/* Set up the initial task struct.  */
1339bdc7f021STrond Myklebust 	NFS_PROTO(inode)->commit_setup(data, &msg);
13401da177e4SLinus Torvalds 
1341a3f565b1SChuck Lever 	dprintk("NFS: %5u initiated commit call\n", data->task.tk_pid);
1342bdc7f021STrond Myklebust 
134307737691STrond Myklebust 	task = rpc_run_task(&task_setup_data);
1344dbae4c73STrond Myklebust 	if (IS_ERR(task))
1345dbae4c73STrond Myklebust 		return PTR_ERR(task);
1346d2224e7aSJeff Layton 	if (how & FLUSH_SYNC)
1347d2224e7aSJeff Layton 		rpc_wait_for_completion_task(task);
134807737691STrond Myklebust 	rpc_put_task(task);
1349dbae4c73STrond Myklebust 	return 0;
13501da177e4SLinus Torvalds }
13511da177e4SLinus Torvalds 
13521da177e4SLinus Torvalds /*
13531da177e4SLinus Torvalds  * Commit dirty pages
13541da177e4SLinus Torvalds  */
13551da177e4SLinus Torvalds static int
135640859d7eSChuck Lever nfs_commit_list(struct inode *inode, struct list_head *head, int how)
13571da177e4SLinus Torvalds {
13581da177e4SLinus Torvalds 	struct nfs_write_data	*data;
13591da177e4SLinus Torvalds 	struct nfs_page         *req;
13601da177e4SLinus Torvalds 
1361c9d8f89dSTrond Myklebust 	data = nfs_commitdata_alloc();
13621da177e4SLinus Torvalds 
13631da177e4SLinus Torvalds 	if (!data)
13641da177e4SLinus Torvalds 		goto out_bad;
13651da177e4SLinus Torvalds 
13661da177e4SLinus Torvalds 	/* Set up the argument struct */
1367dbae4c73STrond Myklebust 	return nfs_commit_rpcsetup(head, data, how);
13681da177e4SLinus Torvalds  out_bad:
13691da177e4SLinus Torvalds 	while (!list_empty(head)) {
13701da177e4SLinus Torvalds 		req = nfs_list_entry(head->next);
13711da177e4SLinus Torvalds 		nfs_list_remove_request(req);
13721da177e4SLinus Torvalds 		nfs_mark_request_commit(req);
137383715ad5STrond Myklebust 		dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
1374c9e51e41SPeter Zijlstra 		dec_bdi_stat(req->wb_page->mapping->backing_dev_info,
1375c9e51e41SPeter Zijlstra 				BDI_RECLAIMABLE);
13769fd367f0STrond Myklebust 		nfs_clear_page_tag_locked(req);
13771da177e4SLinus Torvalds 	}
137871d0a611STrond Myklebust 	nfs_commit_clear_lock(NFS_I(inode));
13791da177e4SLinus Torvalds 	return -ENOMEM;
13801da177e4SLinus Torvalds }
13811da177e4SLinus Torvalds 
13821da177e4SLinus Torvalds /*
13831da177e4SLinus Torvalds  * COMMIT call returned
13841da177e4SLinus Torvalds  */
1385788e7a89STrond Myklebust static void nfs_commit_done(struct rpc_task *task, void *calldata)
13861da177e4SLinus Torvalds {
1387963d8fe5STrond Myklebust 	struct nfs_write_data	*data = calldata;
13881da177e4SLinus Torvalds 
1389a3f565b1SChuck Lever         dprintk("NFS: %5u nfs_commit_done (status %d)\n",
13901da177e4SLinus Torvalds                                 task->tk_pid, task->tk_status);
13911da177e4SLinus Torvalds 
1392788e7a89STrond Myklebust 	/* Call the NFS version-specific code */
1393788e7a89STrond Myklebust 	if (NFS_PROTO(data->inode)->commit_done(task, data) != 0)
1394788e7a89STrond Myklebust 		return;
1395c9d8f89dSTrond Myklebust }
1396c9d8f89dSTrond Myklebust 
1397c9d8f89dSTrond Myklebust static void nfs_commit_release(void *calldata)
1398c9d8f89dSTrond Myklebust {
1399c9d8f89dSTrond Myklebust 	struct nfs_write_data	*data = calldata;
1400c9d8f89dSTrond Myklebust 	struct nfs_page		*req;
1401c9d8f89dSTrond Myklebust 	int status = data->task.tk_status;
1402788e7a89STrond Myklebust 
14031da177e4SLinus Torvalds 	while (!list_empty(&data->pages)) {
14041da177e4SLinus Torvalds 		req = nfs_list_entry(data->pages.next);
14051da177e4SLinus Torvalds 		nfs_list_remove_request(req);
1406e468bae9STrond Myklebust 		nfs_clear_request_commit(req);
14071da177e4SLinus Torvalds 
140848186c7dSChuck Lever 		dprintk("NFS:       commit (%s/%lld %d@%lld)",
140988be9f99STrond Myklebust 			req->wb_context->path.dentry->d_inode->i_sb->s_id,
141088be9f99STrond Myklebust 			(long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
14111da177e4SLinus Torvalds 			req->wb_bytes,
14121da177e4SLinus Torvalds 			(long long)req_offset(req));
1413c9d8f89dSTrond Myklebust 		if (status < 0) {
1414c9d8f89dSTrond Myklebust 			nfs_context_set_write_error(req->wb_context, status);
14151da177e4SLinus Torvalds 			nfs_inode_remove_request(req);
1416c9d8f89dSTrond Myklebust 			dprintk(", error = %d\n", status);
14171da177e4SLinus Torvalds 			goto next;
14181da177e4SLinus Torvalds 		}
14191da177e4SLinus Torvalds 
14201da177e4SLinus Torvalds 		/* Okay, COMMIT succeeded, apparently. Check the verifier
14211da177e4SLinus Torvalds 		 * returned by the server against all stored verfs. */
14221da177e4SLinus Torvalds 		if (!memcmp(req->wb_verf.verifier, data->verf.verifier, sizeof(data->verf.verifier))) {
14231da177e4SLinus Torvalds 			/* We have a match */
14241da177e4SLinus Torvalds 			nfs_inode_remove_request(req);
14251da177e4SLinus Torvalds 			dprintk(" OK\n");
14261da177e4SLinus Torvalds 			goto next;
14271da177e4SLinus Torvalds 		}
14281da177e4SLinus Torvalds 		/* We have a mismatch. Write the page again */
14291da177e4SLinus Torvalds 		dprintk(" mismatch\n");
14306d884e8fSFred 		nfs_mark_request_dirty(req);
14311da177e4SLinus Torvalds 	next:
14329fd367f0STrond Myklebust 		nfs_clear_page_tag_locked(req);
14331da177e4SLinus Torvalds 	}
143471d0a611STrond Myklebust 	nfs_commit_clear_lock(NFS_I(data->inode));
1435c9d8f89dSTrond Myklebust 	nfs_commitdata_release(calldata);
14361da177e4SLinus Torvalds }
1437788e7a89STrond Myklebust 
1438788e7a89STrond Myklebust static const struct rpc_call_ops nfs_commit_ops = {
143921d9a851SAndy Adamson #if defined(CONFIG_NFS_V4_1)
144021d9a851SAndy Adamson 	.rpc_call_prepare = nfs_write_prepare,
144121d9a851SAndy Adamson #endif /* CONFIG_NFS_V4_1 */
1442788e7a89STrond Myklebust 	.rpc_call_done = nfs_commit_done,
1443788e7a89STrond Myklebust 	.rpc_release = nfs_commit_release,
1444788e7a89STrond Myklebust };
14451da177e4SLinus Torvalds 
1446b608b283STrond Myklebust int nfs_commit_inode(struct inode *inode, int how)
14471da177e4SLinus Torvalds {
14481da177e4SLinus Torvalds 	LIST_HEAD(head);
144971d0a611STrond Myklebust 	int may_wait = how & FLUSH_SYNC;
1450*b8413f98STrond Myklebust 	int res;
14511da177e4SLinus Torvalds 
1452*b8413f98STrond Myklebust 	res = nfs_commit_set_lock(NFS_I(inode), may_wait);
1453*b8413f98STrond Myklebust 	if (res <= 0)
1454c5efa5fcSTrond Myklebust 		goto out_mark_dirty;
1455587142f8STrond Myklebust 	spin_lock(&inode->i_lock);
14563da28eb1STrond Myklebust 	res = nfs_scan_commit(inode, &head, 0, 0);
1457587142f8STrond Myklebust 	spin_unlock(&inode->i_lock);
14581da177e4SLinus Torvalds 	if (res) {
14597d46a49fSTrond Myklebust 		int error = nfs_commit_list(inode, &head, how);
14601da177e4SLinus Torvalds 		if (error < 0)
14611da177e4SLinus Torvalds 			return error;
1462*b8413f98STrond Myklebust 		if (!may_wait)
1463*b8413f98STrond Myklebust 			goto out_mark_dirty;
1464*b8413f98STrond Myklebust 		error = wait_on_bit(&NFS_I(inode)->flags,
1465*b8413f98STrond Myklebust 				NFS_INO_COMMIT,
146671d0a611STrond Myklebust 				nfs_wait_bit_killable,
146771d0a611STrond Myklebust 				TASK_KILLABLE);
1468*b8413f98STrond Myklebust 		if (error < 0)
1469*b8413f98STrond Myklebust 			return error;
147071d0a611STrond Myklebust 	} else
147171d0a611STrond Myklebust 		nfs_commit_clear_lock(NFS_I(inode));
1472c5efa5fcSTrond Myklebust 	return res;
1473c5efa5fcSTrond Myklebust 	/* Note: If we exit without ensuring that the commit is complete,
1474c5efa5fcSTrond Myklebust 	 * we must mark the inode as dirty. Otherwise, future calls to
1475c5efa5fcSTrond Myklebust 	 * sync_inode() with the WB_SYNC_ALL flag set will fail to ensure
1476c5efa5fcSTrond Myklebust 	 * that the data is on the disk.
1477c5efa5fcSTrond Myklebust 	 */
1478c5efa5fcSTrond Myklebust out_mark_dirty:
1479c5efa5fcSTrond Myklebust 	__mark_inode_dirty(inode, I_DIRTY_DATASYNC);
14801da177e4SLinus Torvalds 	return res;
14811da177e4SLinus Torvalds }
14828fc795f7STrond Myklebust 
14838fc795f7STrond Myklebust static int nfs_commit_unstable_pages(struct inode *inode, struct writeback_control *wbc)
14848fc795f7STrond Myklebust {
1485420e3646STrond Myklebust 	struct nfs_inode *nfsi = NFS_I(inode);
1486420e3646STrond Myklebust 	int flags = FLUSH_SYNC;
1487420e3646STrond Myklebust 	int ret = 0;
14888fc795f7STrond Myklebust 
1489a00dd6c0SJeff Layton 	if (wbc->sync_mode == WB_SYNC_NONE) {
1490a00dd6c0SJeff Layton 		/* Don't commit yet if this is a non-blocking flush and there
1491a00dd6c0SJeff Layton 		 * are a lot of outstanding writes for this mapping.
1492420e3646STrond Myklebust 		 */
1493a00dd6c0SJeff Layton 		if (nfsi->ncommit <= (nfsi->npages >> 1))
1494420e3646STrond Myklebust 			goto out_mark_dirty;
1495420e3646STrond Myklebust 
1496a00dd6c0SJeff Layton 		/* don't wait for the COMMIT response */
1497420e3646STrond Myklebust 		flags = 0;
1498a00dd6c0SJeff Layton 	}
1499a00dd6c0SJeff Layton 
1500420e3646STrond Myklebust 	ret = nfs_commit_inode(inode, flags);
1501420e3646STrond Myklebust 	if (ret >= 0) {
1502420e3646STrond Myklebust 		if (wbc->sync_mode == WB_SYNC_NONE) {
1503420e3646STrond Myklebust 			if (ret < wbc->nr_to_write)
1504420e3646STrond Myklebust 				wbc->nr_to_write -= ret;
1505420e3646STrond Myklebust 			else
1506420e3646STrond Myklebust 				wbc->nr_to_write = 0;
1507420e3646STrond Myklebust 		}
15088fc795f7STrond Myklebust 		return 0;
1509420e3646STrond Myklebust 	}
1510420e3646STrond Myklebust out_mark_dirty:
15118fc795f7STrond Myklebust 	__mark_inode_dirty(inode, I_DIRTY_DATASYNC);
15128fc795f7STrond Myklebust 	return ret;
15138fc795f7STrond Myklebust }
1514c63c7b05STrond Myklebust #else
15158fc795f7STrond Myklebust static int nfs_commit_unstable_pages(struct inode *inode, struct writeback_control *wbc)
15168fc795f7STrond Myklebust {
15178fc795f7STrond Myklebust 	return 0;
15188fc795f7STrond Myklebust }
15191da177e4SLinus Torvalds #endif
15201da177e4SLinus Torvalds 
15218fc795f7STrond Myklebust int nfs_write_inode(struct inode *inode, struct writeback_control *wbc)
15228fc795f7STrond Myklebust {
15238fc795f7STrond Myklebust 	return nfs_commit_unstable_pages(inode, wbc);
15248fc795f7STrond Myklebust }
15258fc795f7STrond Myklebust 
1526acdc53b2STrond Myklebust /*
1527acdc53b2STrond Myklebust  * flush the inode to disk.
1528acdc53b2STrond Myklebust  */
1529acdc53b2STrond Myklebust int nfs_wb_all(struct inode *inode)
153034901f70STrond Myklebust {
153134901f70STrond Myklebust 	struct writeback_control wbc = {
153272cb77f4STrond Myklebust 		.sync_mode = WB_SYNC_ALL,
153334901f70STrond Myklebust 		.nr_to_write = LONG_MAX,
1534d7fb1207STrond Myklebust 		.range_start = 0,
1535d7fb1207STrond Myklebust 		.range_end = LLONG_MAX,
153634901f70STrond Myklebust 	};
153734901f70STrond Myklebust 
1538acdc53b2STrond Myklebust 	return sync_inode(inode, &wbc);
15391c75950bSTrond Myklebust }
15401c75950bSTrond Myklebust 
15411b3b4a1aSTrond Myklebust int nfs_wb_page_cancel(struct inode *inode, struct page *page)
15421b3b4a1aSTrond Myklebust {
15431b3b4a1aSTrond Myklebust 	struct nfs_page *req;
15441b3b4a1aSTrond Myklebust 	int ret = 0;
15451b3b4a1aSTrond Myklebust 
15461b3b4a1aSTrond Myklebust 	BUG_ON(!PageLocked(page));
15471b3b4a1aSTrond Myklebust 	for (;;) {
1548ba8b06e6STrond Myklebust 		wait_on_page_writeback(page);
15491b3b4a1aSTrond Myklebust 		req = nfs_page_find_request(page);
15501b3b4a1aSTrond Myklebust 		if (req == NULL)
15511b3b4a1aSTrond Myklebust 			break;
15521b3b4a1aSTrond Myklebust 		if (nfs_lock_request_dontget(req)) {
15531b3b4a1aSTrond Myklebust 			nfs_inode_remove_request(req);
15541b3b4a1aSTrond Myklebust 			/*
15551b3b4a1aSTrond Myklebust 			 * In case nfs_inode_remove_request has marked the
15561b3b4a1aSTrond Myklebust 			 * page as being dirty
15571b3b4a1aSTrond Myklebust 			 */
15581b3b4a1aSTrond Myklebust 			cancel_dirty_page(page, PAGE_CACHE_SIZE);
15591b3b4a1aSTrond Myklebust 			nfs_unlock_request(req);
15601b3b4a1aSTrond Myklebust 			break;
15611b3b4a1aSTrond Myklebust 		}
15621b3b4a1aSTrond Myklebust 		ret = nfs_wait_on_request(req);
1563c9edda71STrond Myklebust 		nfs_release_request(req);
15641b3b4a1aSTrond Myklebust 		if (ret < 0)
1565c988950eSTrond Myklebust 			break;
15661b3b4a1aSTrond Myklebust 	}
15671b3b4a1aSTrond Myklebust 	return ret;
15681b3b4a1aSTrond Myklebust }
15691b3b4a1aSTrond Myklebust 
15701c75950bSTrond Myklebust /*
15711c75950bSTrond Myklebust  * Write back all requests on one page - we do this before reading it.
15721c75950bSTrond Myklebust  */
15731c75950bSTrond Myklebust int nfs_wb_page(struct inode *inode, struct page *page)
15741c75950bSTrond Myklebust {
15757f2f12d9STrond Myklebust 	loff_t range_start = page_offset(page);
15767f2f12d9STrond Myklebust 	loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
15777f2f12d9STrond Myklebust 	struct writeback_control wbc = {
15787f2f12d9STrond Myklebust 		.sync_mode = WB_SYNC_ALL,
15797f2f12d9STrond Myklebust 		.nr_to_write = 0,
15807f2f12d9STrond Myklebust 		.range_start = range_start,
15817f2f12d9STrond Myklebust 		.range_end = range_end,
15827f2f12d9STrond Myklebust 	};
15837f2f12d9STrond Myklebust 	int ret;
15847f2f12d9STrond Myklebust 
15850522f6adSTrond Myklebust 	for (;;) {
1586ba8b06e6STrond Myklebust 		wait_on_page_writeback(page);
15877f2f12d9STrond Myklebust 		if (clear_page_dirty_for_io(page)) {
15887f2f12d9STrond Myklebust 			ret = nfs_writepage_locked(page, &wbc);
15897f2f12d9STrond Myklebust 			if (ret < 0)
15907f2f12d9STrond Myklebust 				goto out_error;
15910522f6adSTrond Myklebust 			continue;
15927f2f12d9STrond Myklebust 		}
15930522f6adSTrond Myklebust 		if (!PagePrivate(page))
15940522f6adSTrond Myklebust 			break;
15950522f6adSTrond Myklebust 		ret = nfs_commit_inode(inode, FLUSH_SYNC);
15967f2f12d9STrond Myklebust 		if (ret < 0)
15977f2f12d9STrond Myklebust 			goto out_error;
15987f2f12d9STrond Myklebust 	}
15997f2f12d9STrond Myklebust 	return 0;
16007f2f12d9STrond Myklebust out_error:
16017f2f12d9STrond Myklebust 	return ret;
16021c75950bSTrond Myklebust }
16031c75950bSTrond Myklebust 
1604074cc1deSTrond Myklebust #ifdef CONFIG_MIGRATION
1605074cc1deSTrond Myklebust int nfs_migrate_page(struct address_space *mapping, struct page *newpage,
1606074cc1deSTrond Myklebust 		struct page *page)
1607074cc1deSTrond Myklebust {
1608074cc1deSTrond Myklebust 	struct nfs_page *req;
1609074cc1deSTrond Myklebust 	int ret;
1610074cc1deSTrond Myklebust 
1611074cc1deSTrond Myklebust 	nfs_fscache_release_page(page, GFP_KERNEL);
1612074cc1deSTrond Myklebust 
1613cfb506e1STrond Myklebust 	req = nfs_find_and_lock_request(page, false);
1614074cc1deSTrond Myklebust 	ret = PTR_ERR(req);
1615074cc1deSTrond Myklebust 	if (IS_ERR(req))
1616074cc1deSTrond Myklebust 		goto out;
1617074cc1deSTrond Myklebust 
1618074cc1deSTrond Myklebust 	ret = migrate_page(mapping, newpage, page);
1619074cc1deSTrond Myklebust 	if (!req)
1620074cc1deSTrond Myklebust 		goto out;
1621074cc1deSTrond Myklebust 	if (ret)
1622074cc1deSTrond Myklebust 		goto out_unlock;
1623074cc1deSTrond Myklebust 	page_cache_get(newpage);
1624190f38e5STrond Myklebust 	spin_lock(&mapping->host->i_lock);
1625074cc1deSTrond Myklebust 	req->wb_page = newpage;
1626074cc1deSTrond Myklebust 	SetPagePrivate(newpage);
1627190f38e5STrond Myklebust 	set_page_private(newpage, (unsigned long)req);
1628074cc1deSTrond Myklebust 	ClearPagePrivate(page);
1629074cc1deSTrond Myklebust 	set_page_private(page, 0);
1630190f38e5STrond Myklebust 	spin_unlock(&mapping->host->i_lock);
1631074cc1deSTrond Myklebust 	page_cache_release(page);
1632074cc1deSTrond Myklebust out_unlock:
1633074cc1deSTrond Myklebust 	nfs_clear_page_tag_locked(req);
1634074cc1deSTrond Myklebust out:
1635074cc1deSTrond Myklebust 	return ret;
1636074cc1deSTrond Myklebust }
1637074cc1deSTrond Myklebust #endif
1638074cc1deSTrond Myklebust 
1639f7b422b1SDavid Howells int __init nfs_init_writepagecache(void)
16401da177e4SLinus Torvalds {
16411da177e4SLinus Torvalds 	nfs_wdata_cachep = kmem_cache_create("nfs_write_data",
16421da177e4SLinus Torvalds 					     sizeof(struct nfs_write_data),
16431da177e4SLinus Torvalds 					     0, SLAB_HWCACHE_ALIGN,
164420c2df83SPaul Mundt 					     NULL);
16451da177e4SLinus Torvalds 	if (nfs_wdata_cachep == NULL)
16461da177e4SLinus Torvalds 		return -ENOMEM;
16471da177e4SLinus Torvalds 
164893d2341cSMatthew Dobson 	nfs_wdata_mempool = mempool_create_slab_pool(MIN_POOL_WRITE,
16491da177e4SLinus Torvalds 						     nfs_wdata_cachep);
16501da177e4SLinus Torvalds 	if (nfs_wdata_mempool == NULL)
16511da177e4SLinus Torvalds 		return -ENOMEM;
16521da177e4SLinus Torvalds 
165393d2341cSMatthew Dobson 	nfs_commit_mempool = mempool_create_slab_pool(MIN_POOL_COMMIT,
16541da177e4SLinus Torvalds 						      nfs_wdata_cachep);
16551da177e4SLinus Torvalds 	if (nfs_commit_mempool == NULL)
16561da177e4SLinus Torvalds 		return -ENOMEM;
16571da177e4SLinus Torvalds 
165889a09141SPeter Zijlstra 	/*
165989a09141SPeter Zijlstra 	 * NFS congestion size, scale with available memory.
166089a09141SPeter Zijlstra 	 *
166189a09141SPeter Zijlstra 	 *  64MB:    8192k
166289a09141SPeter Zijlstra 	 * 128MB:   11585k
166389a09141SPeter Zijlstra 	 * 256MB:   16384k
166489a09141SPeter Zijlstra 	 * 512MB:   23170k
166589a09141SPeter Zijlstra 	 *   1GB:   32768k
166689a09141SPeter Zijlstra 	 *   2GB:   46340k
166789a09141SPeter Zijlstra 	 *   4GB:   65536k
166889a09141SPeter Zijlstra 	 *   8GB:   92681k
166989a09141SPeter Zijlstra 	 *  16GB:  131072k
167089a09141SPeter Zijlstra 	 *
167189a09141SPeter Zijlstra 	 * This allows larger machines to have larger/more transfers.
167289a09141SPeter Zijlstra 	 * Limit the default to 256M
167389a09141SPeter Zijlstra 	 */
167489a09141SPeter Zijlstra 	nfs_congestion_kb = (16*int_sqrt(totalram_pages)) << (PAGE_SHIFT-10);
167589a09141SPeter Zijlstra 	if (nfs_congestion_kb > 256*1024)
167689a09141SPeter Zijlstra 		nfs_congestion_kb = 256*1024;
167789a09141SPeter Zijlstra 
16781da177e4SLinus Torvalds 	return 0;
16791da177e4SLinus Torvalds }
16801da177e4SLinus Torvalds 
1681266bee88SDavid Brownell void nfs_destroy_writepagecache(void)
16821da177e4SLinus Torvalds {
16831da177e4SLinus Torvalds 	mempool_destroy(nfs_commit_mempool);
16841da177e4SLinus Torvalds 	mempool_destroy(nfs_wdata_mempool);
16851a1d92c1SAlexey Dobriyan 	kmem_cache_destroy(nfs_wdata_cachep);
16861da177e4SLinus Torvalds }
16871da177e4SLinus Torvalds 
1688