blob: 0a0a2ff767c318d5924c603a3f67ed7f5ccc9402 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/nfs/write.c
3 *
Trond Myklebust7c85d902006-12-13 15:23:48 -05004 * Write file data over NFS.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
6 * Copyright (C) 1996, 1997, Olaf Kirch <okir@monad.swb.de>
7 */
8
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/types.h>
10#include <linux/slab.h>
11#include <linux/mm.h>
12#include <linux/pagemap.h>
13#include <linux/file.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/writeback.h>
Peter Zijlstra89a09142007-03-16 13:38:26 -080015#include <linux/swap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016
17#include <linux/sunrpc/clnt.h>
18#include <linux/nfs_fs.h>
19#include <linux/nfs_mount.h>
20#include <linux/nfs_page.h>
Andrew Morton3fcfab12006-10-19 23:28:16 -070021#include <linux/backing-dev.h>
22
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
25#include "delegation.h"
Trond Myklebust49a70f22006-12-05 00:35:38 -050026#include "internal.h"
Chuck Lever91d5b472006-03-20 13:44:14 -050027#include "iostat.h"
Andy Adamsondef6ed72009-04-01 09:22:26 -040028#include "nfs4_fs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
30#define NFSDBG_FACILITY NFSDBG_PAGECACHE
31
32#define MIN_POOL_WRITE (32)
33#define MIN_POOL_COMMIT (4)
34
35/*
36 * Local function declarations
37 */
Trond Myklebustc63c7b02007-04-02 19:29:52 -040038static void nfs_pageio_init_write(struct nfs_pageio_descriptor *desc,
39 struct inode *inode, int ioflags);
Fred Isamanf8512ad2008-03-19 11:24:39 -040040static void nfs_redirty_request(struct nfs_page *req);
Trond Myklebust788e7a82006-03-20 13:44:27 -050041static const struct rpc_call_ops nfs_write_partial_ops;
42static const struct rpc_call_ops nfs_write_full_ops;
43static const struct rpc_call_ops nfs_commit_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
Christoph Lametere18b8902006-12-06 20:33:20 -080045static struct kmem_cache *nfs_wdata_cachep;
Trond Myklebust3feb2d42006-03-20 13:44:37 -050046static mempool_t *nfs_wdata_mempool;
Linus Torvalds1da177e2005-04-16 15:20:36 -070047static mempool_t *nfs_commit_mempool;
48
Trond Myklebustc9d8f892008-04-15 16:56:39 -040049struct nfs_write_data *nfs_commitdata_alloc(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070050{
Christoph Lametere6b4f8d2006-12-06 20:33:14 -080051 struct nfs_write_data *p = mempool_alloc(nfs_commit_mempool, GFP_NOFS);
Chuck Lever40859d72005-11-30 18:09:02 -050052
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 if (p) {
54 memset(p, 0, sizeof(*p));
55 INIT_LIST_HEAD(&p->pages);
Andy Adamson5f7dbd52009-04-01 09:22:05 -040056 p->res.seq_res.sr_slotid = NFS4_MAX_SLOT_TABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 }
58 return p;
59}
60
Trond Myklebust5e4424a2008-02-25 21:53:49 -080061void nfs_commit_free(struct nfs_write_data *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -070062{
Chuck Lever40859d72005-11-30 18:09:02 -050063 if (p && (p->pagevec != &p->page_array[0]))
64 kfree(p->pagevec);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 mempool_free(p, nfs_commit_mempool);
66}
67
Trond Myklebust8d5658c2007-04-10 09:26:35 -040068struct nfs_write_data *nfs_writedata_alloc(unsigned int pagecount)
Trond Myklebust3feb2d42006-03-20 13:44:37 -050069{
Christoph Lametere6b4f8d2006-12-06 20:33:14 -080070 struct nfs_write_data *p = mempool_alloc(nfs_wdata_mempool, GFP_NOFS);
Trond Myklebust3feb2d42006-03-20 13:44:37 -050071
72 if (p) {
73 memset(p, 0, sizeof(*p));
74 INIT_LIST_HEAD(&p->pages);
Trond Myklebuste9f7bee2006-09-08 09:48:54 -070075 p->npages = pagecount;
Andy Adamson5f7dbd52009-04-01 09:22:05 -040076 p->res.seq_res.sr_slotid = NFS4_MAX_SLOT_TABLE;
Chuck Lever0d0b5cb2006-05-25 01:40:53 -040077 if (pagecount <= ARRAY_SIZE(p->page_array))
78 p->pagevec = p->page_array;
Trond Myklebust3feb2d42006-03-20 13:44:37 -050079 else {
Chuck Lever0d0b5cb2006-05-25 01:40:53 -040080 p->pagevec = kcalloc(pagecount, sizeof(struct page *), GFP_NOFS);
81 if (!p->pagevec) {
Trond Myklebust3feb2d42006-03-20 13:44:37 -050082 mempool_free(p, nfs_wdata_mempool);
83 p = NULL;
84 }
85 }
86 }
87 return p;
88}
89
Trond Myklebust5e4424a2008-02-25 21:53:49 -080090static void nfs_writedata_free(struct nfs_write_data *p)
Trond Myklebust3feb2d42006-03-20 13:44:37 -050091{
92 if (p && (p->pagevec != &p->page_array[0]))
93 kfree(p->pagevec);
94 mempool_free(p, nfs_wdata_mempool);
95}
96
Trond Myklebust383ba712008-02-19 20:04:20 -050097void nfs_writedata_release(void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -070098{
Trond Myklebust383ba712008-02-19 20:04:20 -050099 struct nfs_write_data *wdata = data;
100
101 put_nfs_open_context(wdata->args.context);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 nfs_writedata_free(wdata);
103}
104
Trond Myklebust7b159fc2007-07-25 14:09:54 -0400105static void nfs_context_set_write_error(struct nfs_open_context *ctx, int error)
106{
107 ctx->error = error;
108 smp_wmb();
109 set_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
110}
111
Trond Myklebust277459d2006-12-05 00:35:35 -0500112static struct nfs_page *nfs_page_find_request_locked(struct page *page)
113{
114 struct nfs_page *req = NULL;
115
116 if (PagePrivate(page)) {
117 req = (struct nfs_page *)page_private(page);
118 if (req != NULL)
Trond Myklebustc03b4022007-06-17 13:26:38 -0400119 kref_get(&req->wb_kref);
Trond Myklebust277459d2006-12-05 00:35:35 -0500120 }
121 return req;
122}
123
124static struct nfs_page *nfs_page_find_request(struct page *page)
125{
Trond Myklebust587142f2007-07-02 09:57:54 -0400126 struct inode *inode = page->mapping->host;
Trond Myklebust277459d2006-12-05 00:35:35 -0500127 struct nfs_page *req = NULL;
Trond Myklebust277459d2006-12-05 00:35:35 -0500128
Trond Myklebust587142f2007-07-02 09:57:54 -0400129 spin_lock(&inode->i_lock);
Trond Myklebust277459d2006-12-05 00:35:35 -0500130 req = nfs_page_find_request_locked(page);
Trond Myklebust587142f2007-07-02 09:57:54 -0400131 spin_unlock(&inode->i_lock);
Trond Myklebust277459d2006-12-05 00:35:35 -0500132 return req;
133}
134
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135/* Adjust the file length if we're writing beyond the end */
136static void nfs_grow_file(struct page *page, unsigned int offset, unsigned int count)
137{
138 struct inode *inode = page->mapping->host;
Trond Myklebusta3d01452008-06-11 12:21:19 -0400139 loff_t end, i_size;
140 pgoff_t end_index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141
Trond Myklebusta3d01452008-06-11 12:21:19 -0400142 spin_lock(&inode->i_lock);
143 i_size = i_size_read(inode);
144 end_index = (i_size - 1) >> PAGE_CACHE_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 if (i_size > 0 && page->index < end_index)
Trond Myklebusta3d01452008-06-11 12:21:19 -0400146 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 end = ((loff_t)page->index << PAGE_CACHE_SHIFT) + ((loff_t)offset+count);
148 if (i_size >= end)
Trond Myklebusta3d01452008-06-11 12:21:19 -0400149 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 i_size_write(inode, end);
Trond Myklebusta3d01452008-06-11 12:21:19 -0400151 nfs_inc_stats(inode, NFSIOS_EXTENDWRITE);
152out:
153 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154}
155
Trond Myklebusta301b772007-02-06 11:07:15 -0800156/* A writeback failed: mark the page as bad, and invalidate the page cache */
157static void nfs_set_pageerror(struct page *page)
158{
159 SetPageError(page);
160 nfs_zap_mapping(page->mapping->host, page->mapping);
161}
162
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163/* We can set the PG_uptodate flag if we see that a write request
164 * covers the full page.
165 */
166static void nfs_mark_uptodate(struct page *page, unsigned int base, unsigned int count)
167{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 if (PageUptodate(page))
169 return;
170 if (base != 0)
171 return;
Trond Myklebust49a70f22006-12-05 00:35:38 -0500172 if (count != nfs_page_length(page))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 return;
Trond Myklebust49a70f22006-12-05 00:35:38 -0500174 SetPageUptodate(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175}
176
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177static int wb_priority(struct writeback_control *wbc)
178{
179 if (wbc->for_reclaim)
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400180 return FLUSH_HIGHPRI | FLUSH_STABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 if (wbc->for_kupdate)
182 return FLUSH_LOWPRI;
183 return 0;
184}
185
186/*
Peter Zijlstra89a09142007-03-16 13:38:26 -0800187 * NFS congestion control
188 */
189
190int nfs_congestion_kb;
191
192#define NFS_CONGESTION_ON_THRESH (nfs_congestion_kb >> (PAGE_SHIFT-10))
193#define NFS_CONGESTION_OFF_THRESH \
194 (NFS_CONGESTION_ON_THRESH - (NFS_CONGESTION_ON_THRESH >> 2))
195
Trond Myklebust5a6d41b2007-04-14 19:10:12 -0400196static int nfs_set_page_writeback(struct page *page)
Peter Zijlstra89a09142007-03-16 13:38:26 -0800197{
Trond Myklebust5a6d41b2007-04-14 19:10:12 -0400198 int ret = test_set_page_writeback(page);
199
200 if (!ret) {
Peter Zijlstra89a09142007-03-16 13:38:26 -0800201 struct inode *inode = page->mapping->host;
202 struct nfs_server *nfss = NFS_SERVER(inode);
203
Peter Zijlstra277866a2007-05-08 00:35:12 -0700204 if (atomic_long_inc_return(&nfss->writeback) >
Jens Axboe8aa7e842009-07-09 14:52:32 +0200205 NFS_CONGESTION_ON_THRESH) {
206 set_bdi_congested(&nfss->backing_dev_info,
207 BLK_RW_ASYNC);
208 }
Peter Zijlstra89a09142007-03-16 13:38:26 -0800209 }
Trond Myklebust5a6d41b2007-04-14 19:10:12 -0400210 return ret;
Peter Zijlstra89a09142007-03-16 13:38:26 -0800211}
212
213static void nfs_end_page_writeback(struct page *page)
214{
215 struct inode *inode = page->mapping->host;
216 struct nfs_server *nfss = NFS_SERVER(inode);
217
218 end_page_writeback(page);
Peter Zijlstrac4dc4be2007-10-16 23:25:41 -0700219 if (atomic_long_dec_return(&nfss->writeback) < NFS_CONGESTION_OFF_THRESH)
Jens Axboe8aa7e842009-07-09 14:52:32 +0200220 clear_bdi_congested(&nfss->backing_dev_info, BLK_RW_ASYNC);
Peter Zijlstra89a09142007-03-16 13:38:26 -0800221}
222
223/*
Trond Myklebuste261f512006-12-05 00:35:41 -0500224 * Find an associated nfs write request, and prepare to flush it out
Trond Myklebust9cccef92007-07-22 17:09:05 -0400225 * May return an error if the user signalled nfs_wait_on_request().
Trond Myklebuste261f512006-12-05 00:35:41 -0500226 */
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400227static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio,
228 struct page *page)
Trond Myklebuste261f512006-12-05 00:35:41 -0500229{
Trond Myklebust587142f2007-07-02 09:57:54 -0400230 struct inode *inode = page->mapping->host;
Trond Myklebuste261f512006-12-05 00:35:41 -0500231 struct nfs_page *req;
Trond Myklebuste261f512006-12-05 00:35:41 -0500232 int ret;
233
Trond Myklebust587142f2007-07-02 09:57:54 -0400234 spin_lock(&inode->i_lock);
Trond Myklebuste261f512006-12-05 00:35:41 -0500235 for(;;) {
236 req = nfs_page_find_request_locked(page);
237 if (req == NULL) {
Trond Myklebust587142f2007-07-02 09:57:54 -0400238 spin_unlock(&inode->i_lock);
Trond Myklebust9cccef92007-07-22 17:09:05 -0400239 return 0;
Trond Myklebuste261f512006-12-05 00:35:41 -0500240 }
Trond Myklebustacee4782008-01-22 17:13:07 -0500241 if (nfs_set_page_tag_locked(req))
Trond Myklebuste261f512006-12-05 00:35:41 -0500242 break;
243 /* Note: If we hold the page lock, as is the case in nfs_writepage,
Trond Myklebustacee4782008-01-22 17:13:07 -0500244 * then the call to nfs_set_page_tag_locked() will always
Trond Myklebuste261f512006-12-05 00:35:41 -0500245 * succeed provided that someone hasn't already marked the
246 * request as dirty (in which case we don't care).
247 */
Trond Myklebust587142f2007-07-02 09:57:54 -0400248 spin_unlock(&inode->i_lock);
Trond Myklebuste261f512006-12-05 00:35:41 -0500249 ret = nfs_wait_on_request(req);
250 nfs_release_request(req);
251 if (ret != 0)
252 return ret;
Trond Myklebust587142f2007-07-02 09:57:54 -0400253 spin_lock(&inode->i_lock);
Trond Myklebuste261f512006-12-05 00:35:41 -0500254 }
Trond Myklebuste468bae2008-06-13 13:25:22 -0400255 if (test_bit(PG_CLEAN, &req->wb_flags)) {
Trond Myklebust587142f2007-07-02 09:57:54 -0400256 spin_unlock(&inode->i_lock);
Trond Myklebuste468bae2008-06-13 13:25:22 -0400257 BUG();
Trond Myklebust612c9382007-04-20 16:12:45 -0400258 }
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400259 if (nfs_set_page_writeback(page) != 0) {
Trond Myklebust587142f2007-07-02 09:57:54 -0400260 spin_unlock(&inode->i_lock);
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400261 BUG();
262 }
Trond Myklebust587142f2007-07-02 09:57:54 -0400263 spin_unlock(&inode->i_lock);
Fred Isamanf8512ad2008-03-19 11:24:39 -0400264 if (!nfs_pageio_add_request(pgio, req)) {
265 nfs_redirty_request(req);
Fred Isamanf8512ad2008-03-19 11:24:39 -0400266 return pgio->pg_error;
267 }
Trond Myklebust9cccef92007-07-22 17:09:05 -0400268 return 0;
Trond Myklebuste261f512006-12-05 00:35:41 -0500269}
270
Trond Myklebustf758c8852007-07-22 19:27:32 -0400271static int nfs_do_writepage(struct page *page, struct writeback_control *wbc, struct nfs_pageio_descriptor *pgio)
272{
273 struct inode *inode = page->mapping->host;
274
275 nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE);
276 nfs_add_stats(inode, NFSIOS_WRITEPAGES, 1);
277
278 nfs_pageio_cond_complete(pgio, page->index);
279 return nfs_page_async_flush(pgio, page);
280}
281
Trond Myklebuste261f512006-12-05 00:35:41 -0500282/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 * Write an mmapped page to the server.
284 */
Trond Myklebust4d770cc2006-12-05 00:35:41 -0500285static int nfs_writepage_locked(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286{
Trond Myklebustf758c8852007-07-22 19:27:32 -0400287 struct nfs_pageio_descriptor pgio;
Trond Myklebuste261f512006-12-05 00:35:41 -0500288 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
Trond Myklebustf758c8852007-07-22 19:27:32 -0400290 nfs_pageio_init_write(&pgio, page->mapping->host, wb_priority(wbc));
291 err = nfs_do_writepage(page, wbc, &pgio);
292 nfs_pageio_complete(&pgio);
293 if (err < 0)
294 return err;
295 if (pgio.pg_error < 0)
296 return pgio.pg_error;
297 return 0;
Trond Myklebust4d770cc2006-12-05 00:35:41 -0500298}
299
300int nfs_writepage(struct page *page, struct writeback_control *wbc)
301{
Trond Myklebustf758c8852007-07-22 19:27:32 -0400302 int ret;
Trond Myklebust4d770cc2006-12-05 00:35:41 -0500303
Trond Myklebustf758c8852007-07-22 19:27:32 -0400304 ret = nfs_writepage_locked(page, wbc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 unlock_page(page);
Trond Myklebustf758c8852007-07-22 19:27:32 -0400306 return ret;
307}
308
309static int nfs_writepages_callback(struct page *page, struct writeback_control *wbc, void *data)
310{
311 int ret;
312
313 ret = nfs_do_writepage(page, wbc, data);
314 unlock_page(page);
315 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316}
317
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318int nfs_writepages(struct address_space *mapping, struct writeback_control *wbc)
319{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 struct inode *inode = mapping->host;
Trond Myklebust72cb77f2009-03-11 14:10:30 -0400321 unsigned long *bitlock = &NFS_I(inode)->flags;
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400322 struct nfs_pageio_descriptor pgio;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 int err;
324
Trond Myklebust72cb77f2009-03-11 14:10:30 -0400325 /* Stop dirtying of new pages while we sync */
326 err = wait_on_bit_lock(bitlock, NFS_INO_FLUSHING,
327 nfs_wait_bit_killable, TASK_KILLABLE);
328 if (err)
329 goto out_err;
330
Chuck Lever91d5b472006-03-20 13:44:14 -0500331 nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGES);
332
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400333 nfs_pageio_init_write(&pgio, inode, wb_priority(wbc));
Trond Myklebustf758c8852007-07-22 19:27:32 -0400334 err = write_cache_pages(mapping, wbc, nfs_writepages_callback, &pgio);
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400335 nfs_pageio_complete(&pgio);
Trond Myklebust72cb77f2009-03-11 14:10:30 -0400336
337 clear_bit_unlock(NFS_INO_FLUSHING, bitlock);
338 smp_mb__after_clear_bit();
339 wake_up_bit(bitlock, NFS_INO_FLUSHING);
340
Trond Myklebustf758c8852007-07-22 19:27:32 -0400341 if (err < 0)
Trond Myklebust72cb77f2009-03-11 14:10:30 -0400342 goto out_err;
343 err = pgio.pg_error;
344 if (err < 0)
345 goto out_err;
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400346 return 0;
Trond Myklebust72cb77f2009-03-11 14:10:30 -0400347out_err:
348 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349}
350
351/*
352 * Insert a write request into an inode
353 */
Trond Myklebuste7d39062008-06-13 12:12:32 -0400354static int nfs_inode_add_request(struct inode *inode, struct nfs_page *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355{
356 struct nfs_inode *nfsi = NFS_I(inode);
357 int error;
358
Trond Myklebuste7d39062008-06-13 12:12:32 -0400359 error = radix_tree_preload(GFP_NOFS);
360 if (error != 0)
361 goto out;
362
363 /* Lock the request! */
364 nfs_lock_request_dontget(req);
365
366 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 error = radix_tree_insert(&nfsi->nfs_page_tree, req->wb_index, req);
Nick Piggin27852592008-02-04 23:48:37 -0800368 BUG_ON(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 if (!nfsi->npages) {
370 igrab(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 if (nfs_have_delegation(inode, FMODE_WRITE))
372 nfsi->change_attr++;
373 }
Trond Myklebustdeb7d632006-03-20 13:44:50 -0500374 SetPagePrivate(req->wb_page);
Trond Myklebust277459d2006-12-05 00:35:35 -0500375 set_page_private(req->wb_page, (unsigned long)req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 nfsi->npages++;
Trond Myklebustc03b4022007-06-17 13:26:38 -0400377 kref_get(&req->wb_kref);
Nick Piggin27852592008-02-04 23:48:37 -0800378 radix_tree_tag_set(&nfsi->nfs_page_tree, req->wb_index,
379 NFS_PAGE_TAG_LOCKED);
Trond Myklebuste7d39062008-06-13 12:12:32 -0400380 spin_unlock(&inode->i_lock);
381 radix_tree_preload_end();
382out:
383 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384}
385
386/*
Peter Zijlstra89a09142007-03-16 13:38:26 -0800387 * Remove a write request from an inode
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 */
389static void nfs_inode_remove_request(struct nfs_page *req)
390{
Trond Myklebust88be9f92007-06-05 10:42:27 -0400391 struct inode *inode = req->wb_context->path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 struct nfs_inode *nfsi = NFS_I(inode);
393
394 BUG_ON (!NFS_WBACK_BUSY(req));
395
Trond Myklebust587142f2007-07-02 09:57:54 -0400396 spin_lock(&inode->i_lock);
Trond Myklebust277459d2006-12-05 00:35:35 -0500397 set_page_private(req->wb_page, 0);
Trond Myklebustdeb7d632006-03-20 13:44:50 -0500398 ClearPagePrivate(req->wb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 radix_tree_delete(&nfsi->nfs_page_tree, req->wb_index);
400 nfsi->npages--;
401 if (!nfsi->npages) {
Trond Myklebust587142f2007-07-02 09:57:54 -0400402 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 iput(inode);
404 } else
Trond Myklebust587142f2007-07-02 09:57:54 -0400405 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 nfs_clear_request(req);
407 nfs_release_request(req);
408}
409
Trond Myklebust61822ab2006-12-05 00:35:42 -0500410static void
Fred6d884e82008-03-19 11:24:38 -0400411nfs_mark_request_dirty(struct nfs_page *req)
Trond Myklebust61822ab2006-12-05 00:35:42 -0500412{
Trond Myklebust61822ab2006-12-05 00:35:42 -0500413 __set_page_dirty_nobuffers(req->wb_page);
414}
415
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
417/*
418 * Add a request to the inode's commit list.
419 */
420static void
421nfs_mark_request_commit(struct nfs_page *req)
422{
Trond Myklebust88be9f92007-06-05 10:42:27 -0400423 struct inode *inode = req->wb_context->path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 struct nfs_inode *nfsi = NFS_I(inode);
425
Trond Myklebust587142f2007-07-02 09:57:54 -0400426 spin_lock(&inode->i_lock);
Trond Myklebuste468bae2008-06-13 13:25:22 -0400427 set_bit(PG_CLEAN, &(req)->wb_flags);
Trond Myklebust5c369682007-06-17 15:27:42 -0400428 radix_tree_tag_set(&nfsi->nfs_page_tree,
429 req->wb_index,
430 NFS_PAGE_TAG_COMMIT);
Trond Myklebust587142f2007-07-02 09:57:54 -0400431 spin_unlock(&inode->i_lock);
Christoph Lameterfd39fc82006-06-30 01:55:40 -0700432 inc_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
Peter Zijlstrac9e51e42007-10-16 23:25:47 -0700433 inc_bdi_stat(req->wb_page->mapping->backing_dev_info, BDI_RECLAIMABLE);
Trond Myklebusta1803042006-12-05 00:45:19 -0500434 __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435}
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400436
Trond Myklebuste468bae2008-06-13 13:25:22 -0400437static int
438nfs_clear_request_commit(struct nfs_page *req)
439{
440 struct page *page = req->wb_page;
441
442 if (test_and_clear_bit(PG_CLEAN, &(req)->wb_flags)) {
443 dec_zone_page_state(page, NR_UNSTABLE_NFS);
444 dec_bdi_stat(page->mapping->backing_dev_info, BDI_RECLAIMABLE);
445 return 1;
446 }
447 return 0;
448}
449
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400450static inline
451int nfs_write_need_commit(struct nfs_write_data *data)
452{
453 return data->verf.committed != NFS_FILE_SYNC;
454}
455
456static inline
457int nfs_reschedule_unstable_write(struct nfs_page *req)
458{
Trond Myklebuste468bae2008-06-13 13:25:22 -0400459 if (test_and_clear_bit(PG_NEED_COMMIT, &req->wb_flags)) {
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400460 nfs_mark_request_commit(req);
461 return 1;
462 }
463 if (test_and_clear_bit(PG_NEED_RESCHED, &req->wb_flags)) {
Fred6d884e82008-03-19 11:24:38 -0400464 nfs_mark_request_dirty(req);
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400465 return 1;
466 }
467 return 0;
468}
469#else
470static inline void
471nfs_mark_request_commit(struct nfs_page *req)
472{
473}
474
Trond Myklebuste468bae2008-06-13 13:25:22 -0400475static inline int
476nfs_clear_request_commit(struct nfs_page *req)
477{
478 return 0;
479}
480
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400481static inline
482int nfs_write_need_commit(struct nfs_write_data *data)
483{
484 return 0;
485}
486
487static inline
488int nfs_reschedule_unstable_write(struct nfs_page *req)
489{
490 return 0;
491}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492#endif
493
494/*
495 * Wait for a request to complete.
496 *
Matthew Wilcox150030b2007-12-06 16:24:39 -0500497 * Interruptible by fatal signals only.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 */
Trond Myklebustca52fec2007-04-17 17:22:13 -0400499static int nfs_wait_on_requests_locked(struct inode *inode, pgoff_t idx_start, unsigned int npages)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500{
501 struct nfs_inode *nfsi = NFS_I(inode);
502 struct nfs_page *req;
Trond Myklebustca52fec2007-04-17 17:22:13 -0400503 pgoff_t idx_end, next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 unsigned int res = 0;
505 int error;
506
507 if (npages == 0)
508 idx_end = ~0;
509 else
510 idx_end = idx_start + npages - 1;
511
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 next = idx_start;
Trond Myklebust9fd367f2007-06-17 15:10:24 -0400513 while (radix_tree_gang_lookup_tag(&nfsi->nfs_page_tree, (void **)&req, next, 1, NFS_PAGE_TAG_LOCKED)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 if (req->wb_index > idx_end)
515 break;
516
517 next = req->wb_index + 1;
Trond Myklebustc6a556b2005-06-22 17:16:30 +0000518 BUG_ON(!NFS_WBACK_BUSY(req));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
Trond Myklebustc03b4022007-06-17 13:26:38 -0400520 kref_get(&req->wb_kref);
Trond Myklebust587142f2007-07-02 09:57:54 -0400521 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 error = nfs_wait_on_request(req);
523 nfs_release_request(req);
Trond Myklebust587142f2007-07-02 09:57:54 -0400524 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 if (error < 0)
526 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 res++;
528 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 return res;
530}
531
Trond Myklebust83715ad2006-07-05 13:17:12 -0400532static void nfs_cancel_commit_list(struct list_head *head)
533{
534 struct nfs_page *req;
535
536 while(!list_empty(head)) {
537 req = nfs_list_entry(head->next);
538 nfs_list_remove_request(req);
Trond Myklebuste468bae2008-06-13 13:25:22 -0400539 nfs_clear_request_commit(req);
Trond Myklebust83715ad2006-07-05 13:17:12 -0400540 nfs_inode_remove_request(req);
Trond Myklebustb6dff262006-10-19 23:28:38 -0700541 nfs_unlock_request(req);
Trond Myklebust83715ad2006-07-05 13:17:12 -0400542 }
543}
544
Trond Myklebust47c62562009-03-16 08:13:41 -0400545#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
Trond Myklebustfb8a1f12009-03-11 14:10:29 -0400546static int
547nfs_need_commit(struct nfs_inode *nfsi)
548{
549 return radix_tree_tagged(&nfsi->nfs_page_tree, NFS_PAGE_TAG_COMMIT);
550}
551
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552/*
553 * nfs_scan_commit - Scan an inode for commit requests
554 * @inode: NFS inode to scan
555 * @dst: destination list
556 * @idx_start: lower bound of page->index to scan.
557 * @npages: idx_start + npages sets the upper bound to scan.
558 *
559 * Moves requests from the inode's 'commit' request list.
560 * The requests are *not* checked to ensure that they form a contiguous set.
561 */
562static int
Trond Myklebustca52fec2007-04-17 17:22:13 -0400563nfs_scan_commit(struct inode *inode, struct list_head *dst, pgoff_t idx_start, unsigned int npages)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564{
565 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebust3da28eb2005-06-22 17:16:31 +0000566
Trond Myklebustfb8a1f12009-03-11 14:10:29 -0400567 if (!nfs_need_commit(nfsi))
568 return 0;
569
570 return nfs_scan_list(nfsi, dst, idx_start, npages, NFS_PAGE_TAG_COMMIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571}
Trond Myklebustc42de9d2006-03-20 13:44:51 -0500572#else
Trond Myklebustfb8a1f12009-03-11 14:10:29 -0400573static inline int nfs_need_commit(struct nfs_inode *nfsi)
574{
575 return 0;
576}
577
Trond Myklebustca52fec2007-04-17 17:22:13 -0400578static inline int nfs_scan_commit(struct inode *inode, struct list_head *dst, pgoff_t idx_start, unsigned int npages)
Trond Myklebustc42de9d2006-03-20 13:44:51 -0500579{
580 return 0;
581}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582#endif
583
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584/*
Trond Myklebuste7d39062008-06-13 12:12:32 -0400585 * Search for an existing write request, and attempt to update
586 * it to reflect a new dirty region on a given page.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 *
Trond Myklebuste7d39062008-06-13 12:12:32 -0400588 * If the attempt fails, then the existing request is flushed out
589 * to disk.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 */
Trond Myklebuste7d39062008-06-13 12:12:32 -0400591static struct nfs_page *nfs_try_to_update_request(struct inode *inode,
592 struct page *page,
593 unsigned int offset,
594 unsigned int bytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595{
Trond Myklebuste7d39062008-06-13 12:12:32 -0400596 struct nfs_page *req;
597 unsigned int rqend;
598 unsigned int end;
599 int error;
600
601 if (!PagePrivate(page))
602 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603
604 end = offset + bytes;
Trond Myklebuste7d39062008-06-13 12:12:32 -0400605 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 for (;;) {
Trond Myklebust277459d2006-12-05 00:35:35 -0500608 req = nfs_page_find_request_locked(page);
Trond Myklebuste7d39062008-06-13 12:12:32 -0400609 if (req == NULL)
610 goto out_unlock;
Trond Myklebust277459d2006-12-05 00:35:35 -0500611
Trond Myklebuste7d39062008-06-13 12:12:32 -0400612 rqend = req->wb_offset + req->wb_bytes;
613 /*
614 * Tell the caller to flush out the request if
615 * the offsets are non-contiguous.
616 * Note: nfs_flush_incompatible() will already
617 * have flushed out requests having wrong owners.
618 */
Trond Myklebuste468bae2008-06-13 13:25:22 -0400619 if (offset > rqend
Trond Myklebuste7d39062008-06-13 12:12:32 -0400620 || end < req->wb_offset)
621 goto out_flushme;
622
623 if (nfs_set_page_tag_locked(req))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625
Trond Myklebuste7d39062008-06-13 12:12:32 -0400626 /* The request is locked, so wait and then retry */
Trond Myklebust587142f2007-07-02 09:57:54 -0400627 spin_unlock(&inode->i_lock);
Trond Myklebuste7d39062008-06-13 12:12:32 -0400628 error = nfs_wait_on_request(req);
629 nfs_release_request(req);
630 if (error != 0)
631 goto out_err;
632 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 }
634
Trond Myklebuste468bae2008-06-13 13:25:22 -0400635 if (nfs_clear_request_commit(req))
636 radix_tree_tag_clear(&NFS_I(inode)->nfs_page_tree,
637 req->wb_index, NFS_PAGE_TAG_COMMIT);
638
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 /* Okay, the request matches. Update the region */
640 if (offset < req->wb_offset) {
641 req->wb_offset = offset;
642 req->wb_pgbase = offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 if (end > rqend)
645 req->wb_bytes = end - req->wb_offset;
Trond Myklebuste7d39062008-06-13 12:12:32 -0400646 else
647 req->wb_bytes = rqend - req->wb_offset;
648out_unlock:
649 spin_unlock(&inode->i_lock);
650 return req;
651out_flushme:
652 spin_unlock(&inode->i_lock);
653 nfs_release_request(req);
654 error = nfs_wb_page(inode, page);
655out_err:
656 return ERR_PTR(error);
657}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658
Trond Myklebuste7d39062008-06-13 12:12:32 -0400659/*
660 * Try to update an existing write request, or create one if there is none.
661 *
662 * Note: Should always be called with the Page Lock held to prevent races
663 * if we have to add a new request. Also assumes that the caller has
664 * already called nfs_flush_incompatible() if necessary.
665 */
666static struct nfs_page * nfs_setup_write_request(struct nfs_open_context* ctx,
667 struct page *page, unsigned int offset, unsigned int bytes)
668{
669 struct inode *inode = page->mapping->host;
670 struct nfs_page *req;
671 int error;
672
673 req = nfs_try_to_update_request(inode, page, offset, bytes);
674 if (req != NULL)
675 goto out;
676 req = nfs_create_request(ctx, inode, page, offset, bytes);
677 if (IS_ERR(req))
678 goto out;
679 error = nfs_inode_add_request(inode, req);
680 if (error != 0) {
681 nfs_release_request(req);
682 req = ERR_PTR(error);
683 }
Trond Myklebustefc91ed2008-06-10 18:31:00 -0400684out:
Trond Myklebust61e930a2007-10-18 17:08:05 -0400685 return req;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686}
687
Trond Myklebuste7d39062008-06-13 12:12:32 -0400688static int nfs_writepage_setup(struct nfs_open_context *ctx, struct page *page,
689 unsigned int offset, unsigned int count)
690{
691 struct nfs_page *req;
692
693 req = nfs_setup_write_request(ctx, page, offset, count);
694 if (IS_ERR(req))
695 return PTR_ERR(req);
696 /* Update file length */
697 nfs_grow_file(page, offset, count);
698 nfs_mark_uptodate(page, req->wb_pgbase, req->wb_bytes);
699 nfs_clear_page_tag_locked(req);
700 return 0;
701}
702
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703int nfs_flush_incompatible(struct file *file, struct page *page)
704{
Trond Myklebustcd3758e2007-08-10 17:44:32 -0400705 struct nfs_open_context *ctx = nfs_file_open_context(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 struct nfs_page *req;
Trond Myklebust1a545332006-12-05 00:35:40 -0500707 int do_flush, status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 /*
709 * Look for a request corresponding to this page. If there
710 * is one, and it belongs to another file, we flush it out
711 * before we try to copy anything into the page. Do this
712 * due to the lack of an ACCESS-type call in NFSv2.
713 * Also do the same if we find a request from an existing
714 * dropped page.
715 */
Trond Myklebust1a545332006-12-05 00:35:40 -0500716 do {
717 req = nfs_page_find_request(page);
718 if (req == NULL)
719 return 0;
Trond Myklebuste468bae2008-06-13 13:25:22 -0400720 do_flush = req->wb_page != page || req->wb_context != ctx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 nfs_release_request(req);
Trond Myklebust1a545332006-12-05 00:35:40 -0500722 if (!do_flush)
723 return 0;
724 status = nfs_wb_page(page->mapping->host, page);
725 } while (status == 0);
726 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727}
728
729/*
Trond Myklebust5d47a352008-02-07 17:24:07 -0500730 * If the page cache is marked as unsafe or invalid, then we can't rely on
731 * the PageUptodate() flag. In this case, we will need to turn off
732 * write optimisations that depend on the page contents being correct.
733 */
734static int nfs_write_pageuptodate(struct page *page, struct inode *inode)
735{
736 return PageUptodate(page) &&
737 !(NFS_I(inode)->cache_validity & (NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_DATA));
738}
739
740/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 * Update and possibly write a cached page of an NFS file.
742 *
743 * XXX: Keep an eye on generic_file_read to make sure it doesn't do bad
744 * things with a page scheduled for an RPC call (e.g. invalidate it).
745 */
746int nfs_updatepage(struct file *file, struct page *page,
747 unsigned int offset, unsigned int count)
748{
Trond Myklebustcd3758e2007-08-10 17:44:32 -0400749 struct nfs_open_context *ctx = nfs_file_open_context(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 struct inode *inode = page->mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 int status = 0;
752
Chuck Lever91d5b472006-03-20 13:44:14 -0500753 nfs_inc_stats(inode, NFSIOS_VFSUPDATEPAGE);
754
Chuck Lever48186c72008-06-11 17:56:05 -0400755 dprintk("NFS: nfs_updatepage(%s/%s %d@%lld)\n",
Josef "Jeff" Sipek01cce932006-12-08 02:36:40 -0800756 file->f_path.dentry->d_parent->d_name.name,
757 file->f_path.dentry->d_name.name, count,
Chuck Lever48186c72008-06-11 17:56:05 -0400758 (long long)(page_offset(page) + offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 /* If we're not using byte range locks, and we know the page
Trond Myklebust5d47a352008-02-07 17:24:07 -0500761 * is up to date, it may be more efficient to extend the write
762 * to cover the entire page in order to avoid fragmentation
763 * inefficiencies.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 */
Trond Myklebust5d47a352008-02-07 17:24:07 -0500765 if (nfs_write_pageuptodate(page, inode) &&
766 inode->i_flock == NULL &&
Trond Myklebust4b5621f2008-02-25 15:56:29 -0800767 !(file->f_flags & O_SYNC)) {
Trond Myklebust49a70f22006-12-05 00:35:38 -0500768 count = max(count + offset, nfs_page_length(page));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 }
771
Trond Myklebuste21195a2006-12-05 00:35:39 -0500772 status = nfs_writepage_setup(ctx, page, offset, count);
Trond Myklebust03fa9e82008-06-05 16:02:35 -0400773 if (status < 0)
774 nfs_set_pageerror(page);
775 else
776 __set_page_dirty_nobuffers(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777
Chuck Lever48186c72008-06-11 17:56:05 -0400778 dprintk("NFS: nfs_updatepage returns %d (isize %lld)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 status, (long long)i_size_read(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 return status;
781}
782
783static void nfs_writepage_release(struct nfs_page *req)
784{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
Trond Myklebust7e5f6142008-05-25 12:59:19 -0400786 if (PageError(req->wb_page) || !nfs_reschedule_unstable_write(req)) {
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400787 nfs_end_page_writeback(req->wb_page);
788 nfs_inode_remove_request(req);
789 } else
790 nfs_end_page_writeback(req->wb_page);
Trond Myklebust9fd367f2007-06-17 15:10:24 -0400791 nfs_clear_page_tag_locked(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792}
793
Trond Myklebust3ff75762007-07-14 15:40:00 -0400794static int flush_task_priority(int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795{
796 switch (how & (FLUSH_HIGHPRI|FLUSH_LOWPRI)) {
797 case FLUSH_HIGHPRI:
798 return RPC_PRIORITY_HIGH;
799 case FLUSH_LOWPRI:
800 return RPC_PRIORITY_LOW;
801 }
802 return RPC_PRIORITY_NORMAL;
803}
804
805/*
806 * Set up the argument/result storage required for the RPC call.
807 */
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400808static int nfs_write_rpcsetup(struct nfs_page *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 struct nfs_write_data *data,
Trond Myklebust788e7a82006-03-20 13:44:27 -0500810 const struct rpc_call_ops *call_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 unsigned int count, unsigned int offset,
812 int how)
813{
Trond Myklebust84115e12007-07-14 15:39:59 -0400814 struct inode *inode = req->wb_context->path.dentry->d_inode;
815 int flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
Trond Myklebust3ff75762007-07-14 15:40:00 -0400816 int priority = flush_task_priority(how);
Trond Myklebust07737692007-10-25 18:42:54 -0400817 struct rpc_task *task;
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400818 struct rpc_message msg = {
819 .rpc_argp = &data->args,
820 .rpc_resp = &data->res,
821 .rpc_cred = req->wb_context->cred,
822 };
Trond Myklebust84115e12007-07-14 15:39:59 -0400823 struct rpc_task_setup task_setup_data = {
824 .rpc_client = NFS_CLIENT(inode),
Trond Myklebust07737692007-10-25 18:42:54 -0400825 .task = &data->task,
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400826 .rpc_message = &msg,
Trond Myklebust84115e12007-07-14 15:39:59 -0400827 .callback_ops = call_ops,
828 .callback_data = data,
Trond Myklebust101070c2008-02-19 20:04:23 -0500829 .workqueue = nfsiod_workqueue,
Trond Myklebust84115e12007-07-14 15:39:59 -0400830 .flags = flags,
Trond Myklebust3ff75762007-07-14 15:40:00 -0400831 .priority = priority,
Trond Myklebust84115e12007-07-14 15:39:59 -0400832 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833
834 /* Set up the RPC argument and reply structs
835 * NB: take care not to mess about with data->commit et al. */
836
837 data->req = req;
Trond Myklebust88be9f92007-06-05 10:42:27 -0400838 data->inode = inode = req->wb_context->path.dentry->d_inode;
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400839 data->cred = msg.rpc_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840
841 data->args.fh = NFS_FH(inode);
842 data->args.offset = req_offset(req) + offset;
843 data->args.pgbase = req->wb_pgbase + offset;
844 data->args.pages = data->pagevec;
845 data->args.count = count;
Trond Myklebust383ba712008-02-19 20:04:20 -0500846 data->args.context = get_nfs_open_context(req->wb_context);
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400847 data->args.stable = NFS_UNSTABLE;
848 if (how & FLUSH_STABLE) {
849 data->args.stable = NFS_DATA_SYNC;
Trond Myklebustfb8a1f12009-03-11 14:10:29 -0400850 if (!nfs_need_commit(NFS_I(inode)))
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400851 data->args.stable = NFS_FILE_SYNC;
852 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853
854 data->res.fattr = &data->fattr;
855 data->res.count = count;
856 data->res.verf = &data->verf;
Trond Myklebust0e574af2005-10-27 22:12:38 -0400857 nfs_fattr_init(&data->fattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858
Trond Myklebust788e7a82006-03-20 13:44:27 -0500859 /* Set up the initial task struct. */
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400860 NFS_PROTO(inode)->write_setup(data, &msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861
Chuck Levera3f565b2007-01-31 12:14:01 -0500862 dprintk("NFS: %5u initiated write call "
Chuck Lever48186c72008-06-11 17:56:05 -0400863 "(req %s/%lld, %u bytes @ offset %llu)\n",
Chuck Lever0bbacc42005-11-01 16:53:32 -0500864 data->task.tk_pid,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 inode->i_sb->s_id,
866 (long long)NFS_FILEID(inode),
867 count,
868 (unsigned long long)data->args.offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869
Trond Myklebust07737692007-10-25 18:42:54 -0400870 task = rpc_run_task(&task_setup_data);
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400871 if (IS_ERR(task))
872 return PTR_ERR(task);
873 rpc_put_task(task);
874 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875}
876
Fred6d884e82008-03-19 11:24:38 -0400877/* If a nfs_flush_* function fails, it should remove reqs from @head and
878 * call this on each, which will prepare them to be retried on next
879 * writeback using standard nfs.
880 */
881static void nfs_redirty_request(struct nfs_page *req)
882{
883 nfs_mark_request_dirty(req);
884 nfs_end_page_writeback(req->wb_page);
885 nfs_clear_page_tag_locked(req);
886}
887
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888/*
889 * Generate multiple small requests to write out a single
890 * contiguous dirty area on one page.
891 */
Trond Myklebust8d5658c2007-04-10 09:26:35 -0400892static int nfs_flush_multi(struct inode *inode, struct list_head *head, unsigned int npages, size_t count, int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893{
894 struct nfs_page *req = nfs_list_entry(head->next);
895 struct page *page = req->wb_page;
896 struct nfs_write_data *data;
Trond Myklebuste9f7bee2006-09-08 09:48:54 -0700897 size_t wsize = NFS_SERVER(inode)->wsize, nbytes;
898 unsigned int offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 int requests = 0;
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400900 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 LIST_HEAD(list);
902
903 nfs_list_remove_request(req);
904
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400905 nbytes = count;
Trond Myklebuste9f7bee2006-09-08 09:48:54 -0700906 do {
907 size_t len = min(nbytes, wsize);
908
Trond Myklebust8d5658c2007-04-10 09:26:35 -0400909 data = nfs_writedata_alloc(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 if (!data)
911 goto out_bad;
912 list_add(&data->pages, &list);
913 requests++;
Trond Myklebuste9f7bee2006-09-08 09:48:54 -0700914 nbytes -= len;
915 } while (nbytes != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 atomic_set(&req->wb_complete, requests);
917
918 ClearPageError(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 offset = 0;
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400920 nbytes = count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 do {
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400922 int ret2;
923
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 data = list_entry(list.next, struct nfs_write_data, pages);
925 list_del_init(&data->pages);
926
927 data->pagevec[0] = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400929 if (nbytes < wsize)
930 wsize = nbytes;
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400931 ret2 = nfs_write_rpcsetup(req, data, &nfs_write_partial_ops,
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400932 wsize, offset, how);
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400933 if (ret == 0)
934 ret = ret2;
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400935 offset += wsize;
936 nbytes -= wsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 } while (nbytes != 0);
938
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400939 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940
941out_bad:
942 while (!list_empty(&list)) {
943 data = list_entry(list.next, struct nfs_write_data, pages);
944 list_del(&data->pages);
Trond Myklebust8aca67f2006-11-13 16:23:44 -0500945 nfs_writedata_release(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 }
Trond Myklebust61822ab2006-12-05 00:35:42 -0500947 nfs_redirty_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 return -ENOMEM;
949}
950
951/*
952 * Create an RPC task for the given write request and kick it.
953 * The page must have been locked by the caller.
954 *
955 * It may happen that the page we're passed is not marked dirty.
956 * This is the case if nfs_updatepage detects a conflicting request
957 * that has been written but not committed.
958 */
Trond Myklebust8d5658c2007-04-10 09:26:35 -0400959static int nfs_flush_one(struct inode *inode, struct list_head *head, unsigned int npages, size_t count, int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960{
961 struct nfs_page *req;
962 struct page **pages;
963 struct nfs_write_data *data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964
Trond Myklebust8d5658c2007-04-10 09:26:35 -0400965 data = nfs_writedata_alloc(npages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 if (!data)
967 goto out_bad;
968
969 pages = data->pagevec;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 while (!list_empty(head)) {
971 req = nfs_list_entry(head->next);
972 nfs_list_remove_request(req);
973 nfs_list_add_request(req, &data->pages);
974 ClearPageError(req->wb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 *pages++ = req->wb_page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 }
977 req = nfs_list_entry(data->pages.next);
978
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 /* Set up the argument struct */
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400980 return nfs_write_rpcsetup(req, data, &nfs_write_full_ops, count, 0, how);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 out_bad:
982 while (!list_empty(head)) {
Trond Myklebust10afec92007-05-14 17:16:04 -0400983 req = nfs_list_entry(head->next);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 nfs_list_remove_request(req);
Trond Myklebust61822ab2006-12-05 00:35:42 -0500985 nfs_redirty_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 }
987 return -ENOMEM;
988}
989
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400990static void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio,
991 struct inode *inode, int ioflags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992{
Chuck Leverbf4285e2007-12-20 14:54:57 -0500993 size_t wsize = NFS_SERVER(inode)->wsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400995 if (wsize < PAGE_CACHE_SIZE)
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400996 nfs_pageio_init(pgio, inode, nfs_flush_multi, wsize, ioflags);
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400997 else
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400998 nfs_pageio_init(pgio, inode, nfs_flush_one, wsize, ioflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999}
1000
1001/*
1002 * Handle a write reply that flushed part of a page.
1003 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001004static void nfs_writeback_done_partial(struct rpc_task *task, void *calldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005{
Trond Myklebust788e7a82006-03-20 13:44:27 -05001006 struct nfs_write_data *data = calldata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007
Chuck Lever48186c72008-06-11 17:56:05 -04001008 dprintk("NFS: %5u write(%s/%lld %d@%lld)",
1009 task->tk_pid,
1010 data->req->wb_context->path.dentry->d_inode->i_sb->s_id,
1011 (long long)
1012 NFS_FILEID(data->req->wb_context->path.dentry->d_inode),
1013 data->req->wb_bytes, (long long)req_offset(data->req));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001015 nfs_writeback_done(task, data);
1016}
Trond Myklebust788e7a82006-03-20 13:44:27 -05001017
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001018static void nfs_writeback_release_partial(void *calldata)
1019{
1020 struct nfs_write_data *data = calldata;
1021 struct nfs_page *req = data->req;
1022 struct page *page = req->wb_page;
1023 int status = data->task.tk_status;
1024
1025 if (status < 0) {
Trond Myklebusta301b772007-02-06 11:07:15 -08001026 nfs_set_pageerror(page);
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001027 nfs_context_set_write_error(req->wb_context, status);
1028 dprintk(", error = %d\n", status);
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001029 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 }
1031
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001032 if (nfs_write_need_commit(data)) {
Trond Myklebust587142f2007-07-02 09:57:54 -04001033 struct inode *inode = page->mapping->host;
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001034
Trond Myklebust587142f2007-07-02 09:57:54 -04001035 spin_lock(&inode->i_lock);
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001036 if (test_bit(PG_NEED_RESCHED, &req->wb_flags)) {
1037 /* Do nothing we need to resend the writes */
1038 } else if (!test_and_set_bit(PG_NEED_COMMIT, &req->wb_flags)) {
1039 memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf));
1040 dprintk(" defer commit\n");
1041 } else if (memcmp(&req->wb_verf, &data->verf, sizeof(req->wb_verf))) {
1042 set_bit(PG_NEED_RESCHED, &req->wb_flags);
1043 clear_bit(PG_NEED_COMMIT, &req->wb_flags);
1044 dprintk(" server reboot detected\n");
1045 }
Trond Myklebust587142f2007-07-02 09:57:54 -04001046 spin_unlock(&inode->i_lock);
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001047 } else
1048 dprintk(" OK\n");
1049
1050out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 if (atomic_dec_and_test(&req->wb_complete))
1052 nfs_writepage_release(req);
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001053 nfs_writedata_release(calldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054}
1055
Andy Adamsondef6ed72009-04-01 09:22:26 -04001056#if defined(CONFIG_NFS_V4_1)
1057void nfs_write_prepare(struct rpc_task *task, void *calldata)
1058{
1059 struct nfs_write_data *data = calldata;
1060 struct nfs_client *clp = (NFS_SERVER(data->inode))->nfs_client;
1061
1062 if (nfs4_setup_sequence(clp, &data->args.seq_args,
1063 &data->res.seq_res, 1, task))
1064 return;
1065 rpc_call_start(task);
1066}
1067#endif /* CONFIG_NFS_V4_1 */
1068
Trond Myklebust788e7a82006-03-20 13:44:27 -05001069static const struct rpc_call_ops nfs_write_partial_ops = {
Andy Adamsondef6ed72009-04-01 09:22:26 -04001070#if defined(CONFIG_NFS_V4_1)
1071 .rpc_call_prepare = nfs_write_prepare,
1072#endif /* CONFIG_NFS_V4_1 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001073 .rpc_call_done = nfs_writeback_done_partial,
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001074 .rpc_release = nfs_writeback_release_partial,
Trond Myklebust788e7a82006-03-20 13:44:27 -05001075};
1076
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077/*
1078 * Handle a write reply that flushes a whole page.
1079 *
1080 * FIXME: There is an inherent race with invalidate_inode_pages and
1081 * writebacks since the page->count is kept > 1 for as long
1082 * as the page has a write request pending.
1083 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001084static void nfs_writeback_done_full(struct rpc_task *task, void *calldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085{
Trond Myklebust788e7a82006-03-20 13:44:27 -05001086 struct nfs_write_data *data = calldata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001088 nfs_writeback_done(task, data);
1089}
1090
1091static void nfs_writeback_release_full(void *calldata)
1092{
1093 struct nfs_write_data *data = calldata;
1094 int status = data->task.tk_status;
Trond Myklebust788e7a82006-03-20 13:44:27 -05001095
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 /* Update attributes as result of writeback. */
1097 while (!list_empty(&data->pages)) {
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001098 struct nfs_page *req = nfs_list_entry(data->pages.next);
1099 struct page *page = req->wb_page;
1100
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 nfs_list_remove_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102
Chuck Lever48186c72008-06-11 17:56:05 -04001103 dprintk("NFS: %5u write (%s/%lld %d@%lld)",
1104 data->task.tk_pid,
Trond Myklebust88be9f92007-06-05 10:42:27 -04001105 req->wb_context->path.dentry->d_inode->i_sb->s_id,
1106 (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 req->wb_bytes,
1108 (long long)req_offset(req));
1109
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001110 if (status < 0) {
Trond Myklebusta301b772007-02-06 11:07:15 -08001111 nfs_set_pageerror(page);
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001112 nfs_context_set_write_error(req->wb_context, status);
1113 dprintk(", error = %d\n", status);
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001114 goto remove_request;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001117 if (nfs_write_need_commit(data)) {
1118 memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf));
1119 nfs_mark_request_commit(req);
1120 nfs_end_page_writeback(page);
1121 dprintk(" marked for commit\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 goto next;
1123 }
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001124 dprintk(" OK\n");
1125remove_request:
1126 nfs_end_page_writeback(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 nfs_inode_remove_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 next:
Trond Myklebust9fd367f2007-06-17 15:10:24 -04001129 nfs_clear_page_tag_locked(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 }
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001131 nfs_writedata_release(calldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132}
1133
Trond Myklebust788e7a82006-03-20 13:44:27 -05001134static const struct rpc_call_ops nfs_write_full_ops = {
Andy Adamsondef6ed72009-04-01 09:22:26 -04001135#if defined(CONFIG_NFS_V4_1)
1136 .rpc_call_prepare = nfs_write_prepare,
1137#endif /* CONFIG_NFS_V4_1 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001138 .rpc_call_done = nfs_writeback_done_full,
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001139 .rpc_release = nfs_writeback_release_full,
Trond Myklebust788e7a82006-03-20 13:44:27 -05001140};
1141
1142
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143/*
1144 * This function is called when the WRITE call is complete.
1145 */
Chuck Lever462d5b32006-03-20 13:44:32 -05001146int nfs_writeback_done(struct rpc_task *task, struct nfs_write_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 struct nfs_writeargs *argp = &data->args;
1149 struct nfs_writeres *resp = &data->res;
Andy Adamsoneedc0202009-04-01 09:22:41 -04001150 struct nfs_server *server = NFS_SERVER(data->inode);
Trond Myklebust788e7a82006-03-20 13:44:27 -05001151 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152
Chuck Levera3f565b2007-01-31 12:14:01 -05001153 dprintk("NFS: %5u nfs_writeback_done (status %d)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 task->tk_pid, task->tk_status);
1155
Chuck Leverf551e442006-09-20 14:33:04 -04001156 /*
1157 * ->write_done will attempt to use post-op attributes to detect
1158 * conflicting writes by other clients. A strict interpretation
1159 * of close-to-open would allow us to continue caching even if
1160 * another writer had changed the file, but some applications
1161 * depend on tighter cache coherency when writing.
1162 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001163 status = NFS_PROTO(data->inode)->write_done(task, data);
1164 if (status != 0)
1165 return status;
Chuck Lever91d5b472006-03-20 13:44:14 -05001166 nfs_add_stats(data->inode, NFSIOS_SERVERWRITTENBYTES, resp->count);
1167
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
1169 if (resp->verf->committed < argp->stable && task->tk_status >= 0) {
1170 /* We tried a write call, but the server did not
1171 * commit data to stable storage even though we
1172 * requested it.
1173 * Note: There is a known bug in Tru64 < 5.0 in which
1174 * the server reports NFS_DATA_SYNC, but performs
1175 * NFS_FILE_SYNC. We therefore implement this checking
1176 * as a dprintk() in order to avoid filling syslog.
1177 */
1178 static unsigned long complain;
1179
1180 if (time_before(complain, jiffies)) {
Chuck Lever48186c72008-06-11 17:56:05 -04001181 dprintk("NFS: faulty NFS server %s:"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 " (committed = %d) != (stable = %d)\n",
Andy Adamsoneedc0202009-04-01 09:22:41 -04001183 server->nfs_client->cl_hostname,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 resp->verf->committed, argp->stable);
1185 complain = jiffies + 300 * HZ;
1186 }
1187 }
1188#endif
1189 /* Is this a short write? */
1190 if (task->tk_status >= 0 && resp->count < argp->count) {
1191 static unsigned long complain;
1192
Chuck Lever91d5b472006-03-20 13:44:14 -05001193 nfs_inc_stats(data->inode, NFSIOS_SHORTWRITE);
1194
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 /* Has the server at least made some progress? */
1196 if (resp->count != 0) {
1197 /* Was this an NFSv2 write or an NFSv3 stable write? */
1198 if (resp->verf->committed != NFS_UNSTABLE) {
1199 /* Resend from where the server left off */
1200 argp->offset += resp->count;
1201 argp->pgbase += resp->count;
1202 argp->count -= resp->count;
1203 } else {
1204 /* Resend as a stable write in order to avoid
1205 * headaches in the case of a server crash.
1206 */
1207 argp->stable = NFS_FILE_SYNC;
1208 }
Andy Adamsoneedc0202009-04-01 09:22:41 -04001209 nfs4_restart_rpc(task, server->nfs_client);
Trond Myklebust788e7a82006-03-20 13:44:27 -05001210 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211 }
1212 if (time_before(complain, jiffies)) {
1213 printk(KERN_WARNING
1214 "NFS: Server wrote zero bytes, expected %u.\n",
1215 argp->count);
1216 complain = jiffies + 300 * HZ;
1217 }
1218 /* Can't do anything about it except throw an error. */
1219 task->tk_status = -EIO;
1220 }
Andy Adamsoneedc0202009-04-01 09:22:41 -04001221 nfs4_sequence_free_slot(server->nfs_client, &data->res.seq_res);
Trond Myklebust788e7a82006-03-20 13:44:27 -05001222 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223}
1224
1225
1226#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001227void nfs_commitdata_release(void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228{
Trond Myklebust383ba712008-02-19 20:04:20 -05001229 struct nfs_write_data *wdata = data;
1230
1231 put_nfs_open_context(wdata->args.context);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 nfs_commit_free(wdata);
1233}
1234
1235/*
1236 * Set up the argument/result storage required for the RPC call.
1237 */
Trond Myklebustdbae4c72008-04-14 14:54:53 -04001238static int nfs_commit_rpcsetup(struct list_head *head,
Trond Myklebust788e7a82006-03-20 13:44:27 -05001239 struct nfs_write_data *data,
1240 int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241{
Trond Myklebust84115e12007-07-14 15:39:59 -04001242 struct nfs_page *first = nfs_list_entry(head->next);
1243 struct inode *inode = first->wb_context->path.dentry->d_inode;
1244 int flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
Trond Myklebust3ff75762007-07-14 15:40:00 -04001245 int priority = flush_task_priority(how);
Trond Myklebust07737692007-10-25 18:42:54 -04001246 struct rpc_task *task;
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001247 struct rpc_message msg = {
1248 .rpc_argp = &data->args,
1249 .rpc_resp = &data->res,
1250 .rpc_cred = first->wb_context->cred,
1251 };
Trond Myklebust84115e12007-07-14 15:39:59 -04001252 struct rpc_task_setup task_setup_data = {
Trond Myklebust07737692007-10-25 18:42:54 -04001253 .task = &data->task,
Trond Myklebust84115e12007-07-14 15:39:59 -04001254 .rpc_client = NFS_CLIENT(inode),
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001255 .rpc_message = &msg,
Trond Myklebust84115e12007-07-14 15:39:59 -04001256 .callback_ops = &nfs_commit_ops,
1257 .callback_data = data,
Trond Myklebust101070c2008-02-19 20:04:23 -05001258 .workqueue = nfsiod_workqueue,
Trond Myklebust84115e12007-07-14 15:39:59 -04001259 .flags = flags,
Trond Myklebust3ff75762007-07-14 15:40:00 -04001260 .priority = priority,
Trond Myklebust84115e12007-07-14 15:39:59 -04001261 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262
1263 /* Set up the RPC argument and reply structs
1264 * NB: take care not to mess about with data->commit et al. */
1265
1266 list_splice_init(head, &data->pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 data->inode = inode;
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001269 data->cred = msg.rpc_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270
1271 data->args.fh = NFS_FH(data->inode);
Trond Myklebust3da28eb2005-06-22 17:16:31 +00001272 /* Note: we always request a commit of the entire inode */
1273 data->args.offset = 0;
1274 data->args.count = 0;
Trond Myklebust383ba712008-02-19 20:04:20 -05001275 data->args.context = get_nfs_open_context(first->wb_context);
Trond Myklebust3da28eb2005-06-22 17:16:31 +00001276 data->res.count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 data->res.fattr = &data->fattr;
1278 data->res.verf = &data->verf;
Trond Myklebust0e574af2005-10-27 22:12:38 -04001279 nfs_fattr_init(&data->fattr);
Trond Myklebust788e7a82006-03-20 13:44:27 -05001280
1281 /* Set up the initial task struct. */
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001282 NFS_PROTO(inode)->commit_setup(data, &msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283
Chuck Levera3f565b2007-01-31 12:14:01 -05001284 dprintk("NFS: %5u initiated commit call\n", data->task.tk_pid);
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001285
Trond Myklebust07737692007-10-25 18:42:54 -04001286 task = rpc_run_task(&task_setup_data);
Trond Myklebustdbae4c72008-04-14 14:54:53 -04001287 if (IS_ERR(task))
1288 return PTR_ERR(task);
1289 rpc_put_task(task);
1290 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291}
1292
1293/*
1294 * Commit dirty pages
1295 */
1296static int
Chuck Lever40859d72005-11-30 18:09:02 -05001297nfs_commit_list(struct inode *inode, struct list_head *head, int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298{
1299 struct nfs_write_data *data;
1300 struct nfs_page *req;
1301
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001302 data = nfs_commitdata_alloc();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303
1304 if (!data)
1305 goto out_bad;
1306
1307 /* Set up the argument struct */
Trond Myklebustdbae4c72008-04-14 14:54:53 -04001308 return nfs_commit_rpcsetup(head, data, how);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 out_bad:
1310 while (!list_empty(head)) {
1311 req = nfs_list_entry(head->next);
1312 nfs_list_remove_request(req);
1313 nfs_mark_request_commit(req);
Trond Myklebust83715ad2006-07-05 13:17:12 -04001314 dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
Peter Zijlstrac9e51e42007-10-16 23:25:47 -07001315 dec_bdi_stat(req->wb_page->mapping->backing_dev_info,
1316 BDI_RECLAIMABLE);
Trond Myklebust9fd367f2007-06-17 15:10:24 -04001317 nfs_clear_page_tag_locked(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 }
1319 return -ENOMEM;
1320}
1321
1322/*
1323 * COMMIT call returned
1324 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001325static void nfs_commit_done(struct rpc_task *task, void *calldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326{
Trond Myklebust963d8fe2006-01-03 09:55:04 +01001327 struct nfs_write_data *data = calldata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328
Chuck Levera3f565b2007-01-31 12:14:01 -05001329 dprintk("NFS: %5u nfs_commit_done (status %d)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330 task->tk_pid, task->tk_status);
1331
Trond Myklebust788e7a82006-03-20 13:44:27 -05001332 /* Call the NFS version-specific code */
1333 if (NFS_PROTO(data->inode)->commit_done(task, data) != 0)
1334 return;
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001335}
1336
1337static void nfs_commit_release(void *calldata)
1338{
1339 struct nfs_write_data *data = calldata;
1340 struct nfs_page *req;
1341 int status = data->task.tk_status;
Trond Myklebust788e7a82006-03-20 13:44:27 -05001342
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 while (!list_empty(&data->pages)) {
1344 req = nfs_list_entry(data->pages.next);
1345 nfs_list_remove_request(req);
Trond Myklebuste468bae2008-06-13 13:25:22 -04001346 nfs_clear_request_commit(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347
Chuck Lever48186c72008-06-11 17:56:05 -04001348 dprintk("NFS: commit (%s/%lld %d@%lld)",
Trond Myklebust88be9f92007-06-05 10:42:27 -04001349 req->wb_context->path.dentry->d_inode->i_sb->s_id,
1350 (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 req->wb_bytes,
1352 (long long)req_offset(req));
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001353 if (status < 0) {
1354 nfs_context_set_write_error(req->wb_context, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 nfs_inode_remove_request(req);
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001356 dprintk(", error = %d\n", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 goto next;
1358 }
1359
1360 /* Okay, COMMIT succeeded, apparently. Check the verifier
1361 * returned by the server against all stored verfs. */
1362 if (!memcmp(req->wb_verf.verifier, data->verf.verifier, sizeof(data->verf.verifier))) {
1363 /* We have a match */
1364 nfs_inode_remove_request(req);
1365 dprintk(" OK\n");
1366 goto next;
1367 }
1368 /* We have a mismatch. Write the page again */
1369 dprintk(" mismatch\n");
Fred6d884e82008-03-19 11:24:38 -04001370 nfs_mark_request_dirty(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 next:
Trond Myklebust9fd367f2007-06-17 15:10:24 -04001372 nfs_clear_page_tag_locked(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 }
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001374 nfs_commitdata_release(calldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375}
Trond Myklebust788e7a82006-03-20 13:44:27 -05001376
1377static const struct rpc_call_ops nfs_commit_ops = {
Andy Adamson21d9a852009-04-01 09:22:27 -04001378#if defined(CONFIG_NFS_V4_1)
1379 .rpc_call_prepare = nfs_write_prepare,
1380#endif /* CONFIG_NFS_V4_1 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001381 .rpc_call_done = nfs_commit_done,
1382 .rpc_release = nfs_commit_release,
1383};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384
Trond Myklebust3da28eb2005-06-22 17:16:31 +00001385int nfs_commit_inode(struct inode *inode, int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 LIST_HEAD(head);
Trond Myklebust7d46a492006-03-20 13:44:50 -05001388 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389
Trond Myklebust587142f2007-07-02 09:57:54 -04001390 spin_lock(&inode->i_lock);
Trond Myklebust3da28eb2005-06-22 17:16:31 +00001391 res = nfs_scan_commit(inode, &head, 0, 0);
Trond Myklebust587142f2007-07-02 09:57:54 -04001392 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 if (res) {
Trond Myklebust7d46a492006-03-20 13:44:50 -05001394 int error = nfs_commit_list(inode, &head, how);
Trond Myklebust3da28eb2005-06-22 17:16:31 +00001395 if (error < 0)
1396 return error;
1397 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 return res;
1399}
Trond Myklebustc63c7b02007-04-02 19:29:52 -04001400#else
1401static inline int nfs_commit_list(struct inode *inode, struct list_head *head, int how)
1402{
1403 return 0;
1404}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405#endif
1406
Trond Myklebust1c759502006-10-09 16:18:38 -04001407long nfs_sync_mapping_wait(struct address_space *mapping, struct writeback_control *wbc, int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408{
Trond Myklebust1c759502006-10-09 16:18:38 -04001409 struct inode *inode = mapping->host;
Trond Myklebustca52fec2007-04-17 17:22:13 -04001410 pgoff_t idx_start, idx_end;
Trond Myklebust1c759502006-10-09 16:18:38 -04001411 unsigned int npages = 0;
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001412 LIST_HEAD(head);
Trond Myklebust70b9ecb2006-01-03 09:55:34 +01001413 int nocommit = how & FLUSH_NOCOMMIT;
Trond Myklebust3f442542006-09-17 14:46:44 -04001414 long pages, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415
Trond Myklebust1c759502006-10-09 16:18:38 -04001416 /* FIXME */
1417 if (wbc->range_cyclic)
1418 idx_start = 0;
1419 else {
1420 idx_start = wbc->range_start >> PAGE_CACHE_SHIFT;
1421 idx_end = wbc->range_end >> PAGE_CACHE_SHIFT;
1422 if (idx_end > idx_start) {
Trond Myklebustca52fec2007-04-17 17:22:13 -04001423 pgoff_t l_npages = 1 + idx_end - idx_start;
Trond Myklebust1c759502006-10-09 16:18:38 -04001424 npages = l_npages;
1425 if (sizeof(npages) != sizeof(l_npages) &&
Trond Myklebustca52fec2007-04-17 17:22:13 -04001426 (pgoff_t)npages != l_npages)
Trond Myklebust1c759502006-10-09 16:18:38 -04001427 npages = 0;
1428 }
1429 }
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001430 how &= ~FLUSH_NOCOMMIT;
Trond Myklebust587142f2007-07-02 09:57:54 -04001431 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432 do {
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001433 ret = nfs_wait_on_requests_locked(inode, idx_start, npages);
1434 if (ret != 0)
Trond Myklebust70b9ecb2006-01-03 09:55:34 +01001435 continue;
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001436 if (nocommit)
1437 break;
Trond Myklebustd2ccddf2006-05-31 01:13:38 -04001438 pages = nfs_scan_commit(inode, &head, idx_start, npages);
Trond Myklebust724c4392007-04-17 17:22:13 -04001439 if (pages == 0)
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001440 break;
Trond Myklebustd2ccddf2006-05-31 01:13:38 -04001441 if (how & FLUSH_INVALIDATE) {
Trond Myklebust587142f2007-07-02 09:57:54 -04001442 spin_unlock(&inode->i_lock);
Trond Myklebust83715ad2006-07-05 13:17:12 -04001443 nfs_cancel_commit_list(&head);
Trond Myklebuste8e058e2006-11-15 17:31:56 -05001444 ret = pages;
Trond Myklebust587142f2007-07-02 09:57:54 -04001445 spin_lock(&inode->i_lock);
Trond Myklebustd2ccddf2006-05-31 01:13:38 -04001446 continue;
1447 }
1448 pages += nfs_scan_commit(inode, &head, 0, 0);
Trond Myklebust587142f2007-07-02 09:57:54 -04001449 spin_unlock(&inode->i_lock);
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001450 ret = nfs_commit_list(inode, &head, how);
Trond Myklebust587142f2007-07-02 09:57:54 -04001451 spin_lock(&inode->i_lock);
1452
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001453 } while (ret >= 0);
Trond Myklebust587142f2007-07-02 09:57:54 -04001454 spin_unlock(&inode->i_lock);
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001455 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456}
1457
Trond Myklebust34901f72007-07-25 14:09:54 -04001458static int __nfs_write_mapping(struct address_space *mapping, struct writeback_control *wbc, int how)
Trond Myklebust1c759502006-10-09 16:18:38 -04001459{
Trond Myklebust1c759502006-10-09 16:18:38 -04001460 int ret;
1461
Trond Myklebust34901f72007-07-25 14:09:54 -04001462 ret = nfs_writepages(mapping, wbc);
Trond Myklebust61822ab2006-12-05 00:35:42 -05001463 if (ret < 0)
1464 goto out;
Trond Myklebust34901f72007-07-25 14:09:54 -04001465 ret = nfs_sync_mapping_wait(mapping, wbc, how);
Trond Myklebusted90ef52007-07-20 13:13:28 -04001466 if (ret < 0)
1467 goto out;
1468 return 0;
Trond Myklebust61822ab2006-12-05 00:35:42 -05001469out:
Trond Myklebuste507d9e2006-12-05 00:35:42 -05001470 __mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
Trond Myklebust1c759502006-10-09 16:18:38 -04001471 return ret;
1472}
1473
Trond Myklebust34901f72007-07-25 14:09:54 -04001474/* Two pass sync: first using WB_SYNC_NONE, then WB_SYNC_ALL */
1475static int nfs_write_mapping(struct address_space *mapping, int how)
1476{
1477 struct writeback_control wbc = {
1478 .bdi = mapping->backing_dev_info,
Trond Myklebust72cb77f2009-03-11 14:10:30 -04001479 .sync_mode = WB_SYNC_ALL,
Trond Myklebust34901f72007-07-25 14:09:54 -04001480 .nr_to_write = LONG_MAX,
Trond Myklebustd7fb1202008-10-06 20:08:56 -04001481 .range_start = 0,
1482 .range_end = LLONG_MAX,
Trond Myklebust34901f72007-07-25 14:09:54 -04001483 .for_writepages = 1,
Trond Myklebust34901f72007-07-25 14:09:54 -04001484 };
Trond Myklebust34901f72007-07-25 14:09:54 -04001485
Trond Myklebust34901f72007-07-25 14:09:54 -04001486 return __nfs_write_mapping(mapping, &wbc, how);
1487}
1488
Trond Myklebusted90ef52007-07-20 13:13:28 -04001489/*
1490 * flush the inode to disk.
1491 */
1492int nfs_wb_all(struct inode *inode)
Trond Myklebust1c759502006-10-09 16:18:38 -04001493{
Trond Myklebusted90ef52007-07-20 13:13:28 -04001494 return nfs_write_mapping(inode->i_mapping, 0);
1495}
Trond Myklebust1c759502006-10-09 16:18:38 -04001496
Trond Myklebusted90ef52007-07-20 13:13:28 -04001497int nfs_wb_nocommit(struct inode *inode)
1498{
1499 return nfs_write_mapping(inode->i_mapping, FLUSH_NOCOMMIT);
Trond Myklebust1c759502006-10-09 16:18:38 -04001500}
1501
Trond Myklebust1b3b4a12007-08-28 10:29:36 -04001502int nfs_wb_page_cancel(struct inode *inode, struct page *page)
1503{
1504 struct nfs_page *req;
1505 loff_t range_start = page_offset(page);
1506 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
1507 struct writeback_control wbc = {
1508 .bdi = page->mapping->backing_dev_info,
1509 .sync_mode = WB_SYNC_ALL,
1510 .nr_to_write = LONG_MAX,
1511 .range_start = range_start,
1512 .range_end = range_end,
1513 };
1514 int ret = 0;
1515
1516 BUG_ON(!PageLocked(page));
1517 for (;;) {
1518 req = nfs_page_find_request(page);
1519 if (req == NULL)
1520 goto out;
Trond Myklebuste468bae2008-06-13 13:25:22 -04001521 if (test_bit(PG_CLEAN, &req->wb_flags)) {
Trond Myklebust1b3b4a12007-08-28 10:29:36 -04001522 nfs_release_request(req);
1523 break;
1524 }
1525 if (nfs_lock_request_dontget(req)) {
1526 nfs_inode_remove_request(req);
1527 /*
1528 * In case nfs_inode_remove_request has marked the
1529 * page as being dirty
1530 */
1531 cancel_dirty_page(page, PAGE_CACHE_SIZE);
1532 nfs_unlock_request(req);
1533 break;
1534 }
1535 ret = nfs_wait_on_request(req);
1536 if (ret < 0)
1537 goto out;
1538 }
1539 if (!PagePrivate(page))
1540 return 0;
1541 ret = nfs_sync_mapping_wait(page->mapping, &wbc, FLUSH_INVALIDATE);
1542out:
1543 return ret;
1544}
1545
Adrian Bunk5334eb12007-11-21 15:04:31 -08001546static int nfs_wb_page_priority(struct inode *inode, struct page *page,
1547 int how)
Trond Myklebust1c759502006-10-09 16:18:38 -04001548{
1549 loff_t range_start = page_offset(page);
1550 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
Trond Myklebust4d770cc2006-12-05 00:35:41 -05001551 struct writeback_control wbc = {
1552 .bdi = page->mapping->backing_dev_info,
1553 .sync_mode = WB_SYNC_ALL,
1554 .nr_to_write = LONG_MAX,
1555 .range_start = range_start,
1556 .range_end = range_end,
1557 };
1558 int ret;
Trond Myklebust1c759502006-10-09 16:18:38 -04001559
Trond Myklebust73e33022008-04-11 16:03:54 -04001560 do {
1561 if (clear_page_dirty_for_io(page)) {
1562 ret = nfs_writepage_locked(page, &wbc);
1563 if (ret < 0)
1564 goto out_error;
1565 } else if (!PagePrivate(page))
1566 break;
1567 ret = nfs_sync_mapping_wait(page->mapping, &wbc, how);
Trond Myklebust4d770cc2006-12-05 00:35:41 -05001568 if (ret < 0)
Trond Myklebust73e33022008-04-11 16:03:54 -04001569 goto out_error;
1570 } while (PagePrivate(page));
1571 return 0;
1572out_error:
Trond Myklebuste507d9e2006-12-05 00:35:42 -05001573 __mark_inode_dirty(inode, I_DIRTY_PAGES);
Trond Myklebust4d770cc2006-12-05 00:35:41 -05001574 return ret;
Trond Myklebust1c759502006-10-09 16:18:38 -04001575}
1576
1577/*
1578 * Write back all requests on one page - we do this before reading it.
1579 */
1580int nfs_wb_page(struct inode *inode, struct page* page)
1581{
Trond Myklebust4d770cc2006-12-05 00:35:41 -05001582 return nfs_wb_page_priority(inode, page, FLUSH_STABLE);
Trond Myklebust1c759502006-10-09 16:18:38 -04001583}
1584
David Howellsf7b422b2006-06-09 09:34:33 -04001585int __init nfs_init_writepagecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586{
1587 nfs_wdata_cachep = kmem_cache_create("nfs_write_data",
1588 sizeof(struct nfs_write_data),
1589 0, SLAB_HWCACHE_ALIGN,
Paul Mundt20c2df82007-07-20 10:11:58 +09001590 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 if (nfs_wdata_cachep == NULL)
1592 return -ENOMEM;
1593
Matthew Dobson93d23412006-03-26 01:37:50 -08001594 nfs_wdata_mempool = mempool_create_slab_pool(MIN_POOL_WRITE,
1595 nfs_wdata_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 if (nfs_wdata_mempool == NULL)
1597 return -ENOMEM;
1598
Matthew Dobson93d23412006-03-26 01:37:50 -08001599 nfs_commit_mempool = mempool_create_slab_pool(MIN_POOL_COMMIT,
1600 nfs_wdata_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 if (nfs_commit_mempool == NULL)
1602 return -ENOMEM;
1603
Peter Zijlstra89a09142007-03-16 13:38:26 -08001604 /*
1605 * NFS congestion size, scale with available memory.
1606 *
1607 * 64MB: 8192k
1608 * 128MB: 11585k
1609 * 256MB: 16384k
1610 * 512MB: 23170k
1611 * 1GB: 32768k
1612 * 2GB: 46340k
1613 * 4GB: 65536k
1614 * 8GB: 92681k
1615 * 16GB: 131072k
1616 *
1617 * This allows larger machines to have larger/more transfers.
1618 * Limit the default to 256M
1619 */
1620 nfs_congestion_kb = (16*int_sqrt(totalram_pages)) << (PAGE_SHIFT-10);
1621 if (nfs_congestion_kb > 256*1024)
1622 nfs_congestion_kb = 256*1024;
1623
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624 return 0;
1625}
1626
David Brownell266bee82006-06-27 12:59:15 -07001627void nfs_destroy_writepagecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628{
1629 mempool_destroy(nfs_commit_mempool);
1630 mempool_destroy(nfs_wdata_mempool);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001631 kmem_cache_destroy(nfs_wdata_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632}
1633