blob: 3aea3ca98ab788c5dae67c0769ff723eb9b94217 [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>
Trond Myklebust074cc1d2009-08-10 08:54:13 -040016#include <linux/migrate.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017
18#include <linux/sunrpc/clnt.h>
19#include <linux/nfs_fs.h>
20#include <linux/nfs_mount.h>
21#include <linux/nfs_page.h>
Andrew Morton3fcfab12006-10-19 23:28:16 -070022#include <linux/backing-dev.h>
23
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
26#include "delegation.h"
Trond Myklebust49a70f22006-12-05 00:35:38 -050027#include "internal.h"
Chuck Lever91d5b472006-03-20 13:44:14 -050028#include "iostat.h"
Andy Adamsondef6ed72009-04-01 09:22:26 -040029#include "nfs4_fs.h"
Trond Myklebust074cc1d2009-08-10 08:54:13 -040030#include "fscache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
32#define NFSDBG_FACILITY NFSDBG_PAGECACHE
33
34#define MIN_POOL_WRITE (32)
35#define MIN_POOL_COMMIT (4)
36
37/*
38 * Local function declarations
39 */
Trond Myklebustc63c7b02007-04-02 19:29:52 -040040static void nfs_pageio_init_write(struct nfs_pageio_descriptor *desc,
41 struct inode *inode, int ioflags);
Fred Isamanf8512ad2008-03-19 11:24:39 -040042static void nfs_redirty_request(struct nfs_page *req);
Trond Myklebust788e7a82006-03-20 13:44:27 -050043static const struct rpc_call_ops nfs_write_partial_ops;
44static const struct rpc_call_ops nfs_write_full_ops;
45static const struct rpc_call_ops nfs_commit_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
Christoph Lametere18b8902006-12-06 20:33:20 -080047static struct kmem_cache *nfs_wdata_cachep;
Trond Myklebust3feb2d42006-03-20 13:44:37 -050048static mempool_t *nfs_wdata_mempool;
Linus Torvalds1da177e2005-04-16 15:20:36 -070049static mempool_t *nfs_commit_mempool;
50
Trond Myklebustc9d8f892008-04-15 16:56:39 -040051struct nfs_write_data *nfs_commitdata_alloc(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070052{
Christoph Lametere6b4f8d2006-12-06 20:33:14 -080053 struct nfs_write_data *p = mempool_alloc(nfs_commit_mempool, GFP_NOFS);
Chuck Lever40859d72005-11-30 18:09:02 -050054
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 if (p) {
56 memset(p, 0, sizeof(*p));
57 INIT_LIST_HEAD(&p->pages);
Andy Adamson5f7dbd52009-04-01 09:22:05 -040058 p->res.seq_res.sr_slotid = NFS4_MAX_SLOT_TABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 }
60 return p;
61}
62
Trond Myklebust5e4424a2008-02-25 21:53:49 -080063void nfs_commit_free(struct nfs_write_data *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -070064{
Chuck Lever40859d72005-11-30 18:09:02 -050065 if (p && (p->pagevec != &p->page_array[0]))
66 kfree(p->pagevec);
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 mempool_free(p, nfs_commit_mempool);
68}
69
Trond Myklebust8d5658c2007-04-10 09:26:35 -040070struct nfs_write_data *nfs_writedata_alloc(unsigned int pagecount)
Trond Myklebust3feb2d42006-03-20 13:44:37 -050071{
Christoph Lametere6b4f8d2006-12-06 20:33:14 -080072 struct nfs_write_data *p = mempool_alloc(nfs_wdata_mempool, GFP_NOFS);
Trond Myklebust3feb2d42006-03-20 13:44:37 -050073
74 if (p) {
75 memset(p, 0, sizeof(*p));
76 INIT_LIST_HEAD(&p->pages);
Trond Myklebuste9f7bee2006-09-08 09:48:54 -070077 p->npages = pagecount;
Andy Adamson5f7dbd52009-04-01 09:22:05 -040078 p->res.seq_res.sr_slotid = NFS4_MAX_SLOT_TABLE;
Chuck Lever0d0b5cb2006-05-25 01:40:53 -040079 if (pagecount <= ARRAY_SIZE(p->page_array))
80 p->pagevec = p->page_array;
Trond Myklebust3feb2d42006-03-20 13:44:37 -050081 else {
Chuck Lever0d0b5cb2006-05-25 01:40:53 -040082 p->pagevec = kcalloc(pagecount, sizeof(struct page *), GFP_NOFS);
83 if (!p->pagevec) {
Trond Myklebust3feb2d42006-03-20 13:44:37 -050084 mempool_free(p, nfs_wdata_mempool);
85 p = NULL;
86 }
87 }
88 }
89 return p;
90}
91
Trond Myklebust1ae88b22009-08-12 09:12:30 -040092void nfs_writedata_free(struct nfs_write_data *p)
Trond Myklebust3feb2d42006-03-20 13:44:37 -050093{
94 if (p && (p->pagevec != &p->page_array[0]))
95 kfree(p->pagevec);
96 mempool_free(p, nfs_wdata_mempool);
97}
98
Trond Myklebust1ae88b22009-08-12 09:12:30 -040099static void nfs_writedata_release(struct nfs_write_data *wdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100{
Trond Myklebust383ba712008-02-19 20:04:20 -0500101 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;
Wu Fengguangb17621f2009-12-03 13:54:25 +0100181 if (wbc->for_kupdate || wbc->for_background)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 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
Trond Myklebusta6305dd2010-04-09 19:07:08 -0400204 page_cache_get(page);
Peter Zijlstra277866a2007-05-08 00:35:12 -0700205 if (atomic_long_inc_return(&nfss->writeback) >
Jens Axboe8aa7e842009-07-09 14:52:32 +0200206 NFS_CONGESTION_ON_THRESH) {
207 set_bdi_congested(&nfss->backing_dev_info,
208 BLK_RW_ASYNC);
209 }
Peter Zijlstra89a09142007-03-16 13:38:26 -0800210 }
Trond Myklebust5a6d41b2007-04-14 19:10:12 -0400211 return ret;
Peter Zijlstra89a09142007-03-16 13:38:26 -0800212}
213
214static void nfs_end_page_writeback(struct page *page)
215{
216 struct inode *inode = page->mapping->host;
217 struct nfs_server *nfss = NFS_SERVER(inode);
218
219 end_page_writeback(page);
Trond Myklebusta6305dd2010-04-09 19:07:08 -0400220 page_cache_release(page);
Peter Zijlstrac4dc4be2007-10-16 23:25:41 -0700221 if (atomic_long_dec_return(&nfss->writeback) < NFS_CONGESTION_OFF_THRESH)
Jens Axboe8aa7e842009-07-09 14:52:32 +0200222 clear_bdi_congested(&nfss->backing_dev_info, BLK_RW_ASYNC);
Peter Zijlstra89a09142007-03-16 13:38:26 -0800223}
224
Trond Myklebust074cc1d2009-08-10 08:54:13 -0400225static struct nfs_page *nfs_find_and_lock_request(struct page *page)
Trond Myklebuste261f512006-12-05 00:35:41 -0500226{
Trond Myklebust587142f2007-07-02 09:57:54 -0400227 struct inode *inode = page->mapping->host;
Trond Myklebuste261f512006-12-05 00:35:41 -0500228 struct nfs_page *req;
Trond Myklebuste261f512006-12-05 00:35:41 -0500229 int ret;
230
Trond Myklebust587142f2007-07-02 09:57:54 -0400231 spin_lock(&inode->i_lock);
Trond Myklebust074cc1d2009-08-10 08:54:13 -0400232 for (;;) {
Trond Myklebuste261f512006-12-05 00:35:41 -0500233 req = nfs_page_find_request_locked(page);
Trond Myklebust074cc1d2009-08-10 08:54:13 -0400234 if (req == NULL)
235 break;
Trond Myklebustacee4782008-01-22 17:13:07 -0500236 if (nfs_set_page_tag_locked(req))
Trond Myklebuste261f512006-12-05 00:35:41 -0500237 break;
238 /* Note: If we hold the page lock, as is the case in nfs_writepage,
Trond Myklebustacee4782008-01-22 17:13:07 -0500239 * then the call to nfs_set_page_tag_locked() will always
Trond Myklebuste261f512006-12-05 00:35:41 -0500240 * succeed provided that someone hasn't already marked the
241 * request as dirty (in which case we don't care).
242 */
Trond Myklebust587142f2007-07-02 09:57:54 -0400243 spin_unlock(&inode->i_lock);
Trond Myklebuste261f512006-12-05 00:35:41 -0500244 ret = nfs_wait_on_request(req);
245 nfs_release_request(req);
246 if (ret != 0)
Trond Myklebust074cc1d2009-08-10 08:54:13 -0400247 return ERR_PTR(ret);
Trond Myklebust587142f2007-07-02 09:57:54 -0400248 spin_lock(&inode->i_lock);
Trond Myklebuste261f512006-12-05 00:35:41 -0500249 }
Trond Myklebust587142f2007-07-02 09:57:54 -0400250 spin_unlock(&inode->i_lock);
Trond Myklebust074cc1d2009-08-10 08:54:13 -0400251 return req;
252}
253
254/*
255 * Find an associated nfs write request, and prepare to flush it out
256 * May return an error if the user signalled nfs_wait_on_request().
257 */
258static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio,
259 struct page *page)
260{
261 struct nfs_page *req;
262 int ret = 0;
263
264 req = nfs_find_and_lock_request(page);
265 if (!req)
266 goto out;
267 ret = PTR_ERR(req);
268 if (IS_ERR(req))
269 goto out;
270
271 ret = nfs_set_page_writeback(page);
272 BUG_ON(ret != 0);
273 BUG_ON(test_bit(PG_CLEAN, &req->wb_flags));
274
Fred Isamanf8512ad2008-03-19 11:24:39 -0400275 if (!nfs_pageio_add_request(pgio, req)) {
276 nfs_redirty_request(req);
Trond Myklebust074cc1d2009-08-10 08:54:13 -0400277 ret = pgio->pg_error;
Fred Isamanf8512ad2008-03-19 11:24:39 -0400278 }
Trond Myklebust074cc1d2009-08-10 08:54:13 -0400279out:
280 return ret;
Trond Myklebuste261f512006-12-05 00:35:41 -0500281}
282
Trond Myklebustf758c8852007-07-22 19:27:32 -0400283static int nfs_do_writepage(struct page *page, struct writeback_control *wbc, struct nfs_pageio_descriptor *pgio)
284{
285 struct inode *inode = page->mapping->host;
286
287 nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE);
288 nfs_add_stats(inode, NFSIOS_WRITEPAGES, 1);
289
290 nfs_pageio_cond_complete(pgio, page->index);
291 return nfs_page_async_flush(pgio, page);
292}
293
Trond Myklebuste261f512006-12-05 00:35:41 -0500294/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 * Write an mmapped page to the server.
296 */
Trond Myklebust4d770cc2006-12-05 00:35:41 -0500297static int nfs_writepage_locked(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298{
Trond Myklebustf758c8852007-07-22 19:27:32 -0400299 struct nfs_pageio_descriptor pgio;
Trond Myklebuste261f512006-12-05 00:35:41 -0500300 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
Trond Myklebustf758c8852007-07-22 19:27:32 -0400302 nfs_pageio_init_write(&pgio, page->mapping->host, wb_priority(wbc));
303 err = nfs_do_writepage(page, wbc, &pgio);
304 nfs_pageio_complete(&pgio);
305 if (err < 0)
306 return err;
307 if (pgio.pg_error < 0)
308 return pgio.pg_error;
309 return 0;
Trond Myklebust4d770cc2006-12-05 00:35:41 -0500310}
311
312int nfs_writepage(struct page *page, struct writeback_control *wbc)
313{
Trond Myklebustf758c8852007-07-22 19:27:32 -0400314 int ret;
Trond Myklebust4d770cc2006-12-05 00:35:41 -0500315
Trond Myklebustf758c8852007-07-22 19:27:32 -0400316 ret = nfs_writepage_locked(page, wbc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 unlock_page(page);
Trond Myklebustf758c8852007-07-22 19:27:32 -0400318 return ret;
319}
320
321static int nfs_writepages_callback(struct page *page, struct writeback_control *wbc, void *data)
322{
323 int ret;
324
325 ret = nfs_do_writepage(page, wbc, data);
326 unlock_page(page);
327 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328}
329
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330int nfs_writepages(struct address_space *mapping, struct writeback_control *wbc)
331{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 struct inode *inode = mapping->host;
Trond Myklebust72cb77f2009-03-11 14:10:30 -0400333 unsigned long *bitlock = &NFS_I(inode)->flags;
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400334 struct nfs_pageio_descriptor pgio;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 int err;
336
Trond Myklebust72cb77f2009-03-11 14:10:30 -0400337 /* Stop dirtying of new pages while we sync */
338 err = wait_on_bit_lock(bitlock, NFS_INO_FLUSHING,
339 nfs_wait_bit_killable, TASK_KILLABLE);
340 if (err)
341 goto out_err;
342
Chuck Lever91d5b472006-03-20 13:44:14 -0500343 nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGES);
344
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400345 nfs_pageio_init_write(&pgio, inode, wb_priority(wbc));
Trond Myklebustf758c8852007-07-22 19:27:32 -0400346 err = write_cache_pages(mapping, wbc, nfs_writepages_callback, &pgio);
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400347 nfs_pageio_complete(&pgio);
Trond Myklebust72cb77f2009-03-11 14:10:30 -0400348
349 clear_bit_unlock(NFS_INO_FLUSHING, bitlock);
350 smp_mb__after_clear_bit();
351 wake_up_bit(bitlock, NFS_INO_FLUSHING);
352
Trond Myklebustf758c8852007-07-22 19:27:32 -0400353 if (err < 0)
Trond Myklebust72cb77f2009-03-11 14:10:30 -0400354 goto out_err;
355 err = pgio.pg_error;
356 if (err < 0)
357 goto out_err;
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400358 return 0;
Trond Myklebust72cb77f2009-03-11 14:10:30 -0400359out_err:
360 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361}
362
363/*
364 * Insert a write request into an inode
365 */
Trond Myklebuste7d39062008-06-13 12:12:32 -0400366static int nfs_inode_add_request(struct inode *inode, struct nfs_page *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367{
368 struct nfs_inode *nfsi = NFS_I(inode);
369 int error;
370
Trond Myklebuste7d39062008-06-13 12:12:32 -0400371 error = radix_tree_preload(GFP_NOFS);
372 if (error != 0)
373 goto out;
374
375 /* Lock the request! */
376 nfs_lock_request_dontget(req);
377
378 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 error = radix_tree_insert(&nfsi->nfs_page_tree, req->wb_index, req);
Nick Piggin27852592008-02-04 23:48:37 -0800380 BUG_ON(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 if (!nfsi->npages) {
382 igrab(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 if (nfs_have_delegation(inode, FMODE_WRITE))
384 nfsi->change_attr++;
385 }
Trond Myklebustdeb7d632006-03-20 13:44:50 -0500386 SetPagePrivate(req->wb_page);
Trond Myklebust277459d2006-12-05 00:35:35 -0500387 set_page_private(req->wb_page, (unsigned long)req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 nfsi->npages++;
Trond Myklebustc03b4022007-06-17 13:26:38 -0400389 kref_get(&req->wb_kref);
Nick Piggin27852592008-02-04 23:48:37 -0800390 radix_tree_tag_set(&nfsi->nfs_page_tree, req->wb_index,
391 NFS_PAGE_TAG_LOCKED);
Trond Myklebuste7d39062008-06-13 12:12:32 -0400392 spin_unlock(&inode->i_lock);
393 radix_tree_preload_end();
394out:
395 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396}
397
398/*
Peter Zijlstra89a09142007-03-16 13:38:26 -0800399 * Remove a write request from an inode
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 */
401static void nfs_inode_remove_request(struct nfs_page *req)
402{
Trond Myklebust88be9f92007-06-05 10:42:27 -0400403 struct inode *inode = req->wb_context->path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 struct nfs_inode *nfsi = NFS_I(inode);
405
406 BUG_ON (!NFS_WBACK_BUSY(req));
407
Trond Myklebust587142f2007-07-02 09:57:54 -0400408 spin_lock(&inode->i_lock);
Trond Myklebust277459d2006-12-05 00:35:35 -0500409 set_page_private(req->wb_page, 0);
Trond Myklebustdeb7d632006-03-20 13:44:50 -0500410 ClearPagePrivate(req->wb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 radix_tree_delete(&nfsi->nfs_page_tree, req->wb_index);
412 nfsi->npages--;
413 if (!nfsi->npages) {
Trond Myklebust587142f2007-07-02 09:57:54 -0400414 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 iput(inode);
416 } else
Trond Myklebust587142f2007-07-02 09:57:54 -0400417 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 nfs_clear_request(req);
419 nfs_release_request(req);
420}
421
Trond Myklebust61822ab2006-12-05 00:35:42 -0500422static void
Fred6d884e82008-03-19 11:24:38 -0400423nfs_mark_request_dirty(struct nfs_page *req)
Trond Myklebust61822ab2006-12-05 00:35:42 -0500424{
Trond Myklebust61822ab2006-12-05 00:35:42 -0500425 __set_page_dirty_nobuffers(req->wb_page);
Trond Myklebustb80c3cb2010-04-09 19:07:07 -0400426 __mark_inode_dirty(req->wb_page->mapping->host, I_DIRTY_DATASYNC);
Trond Myklebust61822ab2006-12-05 00:35:42 -0500427}
428
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
430/*
431 * Add a request to the inode's commit list.
432 */
433static void
434nfs_mark_request_commit(struct nfs_page *req)
435{
Trond Myklebust88be9f92007-06-05 10:42:27 -0400436 struct inode *inode = req->wb_context->path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 struct nfs_inode *nfsi = NFS_I(inode);
438
Trond Myklebust587142f2007-07-02 09:57:54 -0400439 spin_lock(&inode->i_lock);
Trond Myklebuste468bae2008-06-13 13:25:22 -0400440 set_bit(PG_CLEAN, &(req)->wb_flags);
Trond Myklebust5c369682007-06-17 15:27:42 -0400441 radix_tree_tag_set(&nfsi->nfs_page_tree,
442 req->wb_index,
443 NFS_PAGE_TAG_COMMIT);
Trond Myklebustff778d02010-02-19 16:53:39 -0800444 nfsi->ncommit++;
Trond Myklebust587142f2007-07-02 09:57:54 -0400445 spin_unlock(&inode->i_lock);
Christoph Lameterfd39fc82006-06-30 01:55:40 -0700446 inc_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
Peter Zijlstrac9e51e42007-10-16 23:25:47 -0700447 inc_bdi_stat(req->wb_page->mapping->backing_dev_info, BDI_RECLAIMABLE);
Trond Myklebusta1803042006-12-05 00:45:19 -0500448 __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449}
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400450
Trond Myklebuste468bae2008-06-13 13:25:22 -0400451static int
452nfs_clear_request_commit(struct nfs_page *req)
453{
454 struct page *page = req->wb_page;
455
456 if (test_and_clear_bit(PG_CLEAN, &(req)->wb_flags)) {
457 dec_zone_page_state(page, NR_UNSTABLE_NFS);
458 dec_bdi_stat(page->mapping->backing_dev_info, BDI_RECLAIMABLE);
459 return 1;
460 }
461 return 0;
462}
463
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400464static inline
465int nfs_write_need_commit(struct nfs_write_data *data)
466{
467 return data->verf.committed != NFS_FILE_SYNC;
468}
469
470static inline
471int nfs_reschedule_unstable_write(struct nfs_page *req)
472{
Trond Myklebuste468bae2008-06-13 13:25:22 -0400473 if (test_and_clear_bit(PG_NEED_COMMIT, &req->wb_flags)) {
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400474 nfs_mark_request_commit(req);
475 return 1;
476 }
477 if (test_and_clear_bit(PG_NEED_RESCHED, &req->wb_flags)) {
Fred6d884e82008-03-19 11:24:38 -0400478 nfs_mark_request_dirty(req);
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400479 return 1;
480 }
481 return 0;
482}
483#else
484static inline void
485nfs_mark_request_commit(struct nfs_page *req)
486{
487}
488
Trond Myklebuste468bae2008-06-13 13:25:22 -0400489static inline int
490nfs_clear_request_commit(struct nfs_page *req)
491{
492 return 0;
493}
494
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400495static inline
496int nfs_write_need_commit(struct nfs_write_data *data)
497{
498 return 0;
499}
500
501static inline
502int nfs_reschedule_unstable_write(struct nfs_page *req)
503{
504 return 0;
505}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506#endif
507
Trond Myklebust47c62562009-03-16 08:13:41 -0400508#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
Trond Myklebustfb8a1f12009-03-11 14:10:29 -0400509static int
510nfs_need_commit(struct nfs_inode *nfsi)
511{
512 return radix_tree_tagged(&nfsi->nfs_page_tree, NFS_PAGE_TAG_COMMIT);
513}
514
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515/*
516 * nfs_scan_commit - Scan an inode for commit requests
517 * @inode: NFS inode to scan
518 * @dst: destination list
519 * @idx_start: lower bound of page->index to scan.
520 * @npages: idx_start + npages sets the upper bound to scan.
521 *
522 * Moves requests from the inode's 'commit' request list.
523 * The requests are *not* checked to ensure that they form a contiguous set.
524 */
525static int
Trond Myklebustca52fec2007-04-17 17:22:13 -0400526nfs_scan_commit(struct inode *inode, struct list_head *dst, pgoff_t idx_start, unsigned int npages)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527{
528 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebustff778d02010-02-19 16:53:39 -0800529 int ret;
Trond Myklebust3da28eb2005-06-22 17:16:31 +0000530
Trond Myklebustfb8a1f12009-03-11 14:10:29 -0400531 if (!nfs_need_commit(nfsi))
532 return 0;
533
Trond Myklebustff778d02010-02-19 16:53:39 -0800534 ret = nfs_scan_list(nfsi, dst, idx_start, npages, NFS_PAGE_TAG_COMMIT);
535 if (ret > 0)
536 nfsi->ncommit -= ret;
Trond Myklebust2928db12010-02-19 17:03:18 -0800537 if (nfs_need_commit(NFS_I(inode)))
538 __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
Trond Myklebustff778d02010-02-19 16:53:39 -0800539 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540}
Trond Myklebustc42de9d2006-03-20 13:44:51 -0500541#else
Trond Myklebustfb8a1f12009-03-11 14:10:29 -0400542static inline int nfs_need_commit(struct nfs_inode *nfsi)
543{
544 return 0;
545}
546
Trond Myklebustca52fec2007-04-17 17:22:13 -0400547static 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 -0500548{
549 return 0;
550}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551#endif
552
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553/*
Trond Myklebuste7d39062008-06-13 12:12:32 -0400554 * Search for an existing write request, and attempt to update
555 * it to reflect a new dirty region on a given page.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 *
Trond Myklebuste7d39062008-06-13 12:12:32 -0400557 * If the attempt fails, then the existing request is flushed out
558 * to disk.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 */
Trond Myklebuste7d39062008-06-13 12:12:32 -0400560static struct nfs_page *nfs_try_to_update_request(struct inode *inode,
561 struct page *page,
562 unsigned int offset,
563 unsigned int bytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564{
Trond Myklebuste7d39062008-06-13 12:12:32 -0400565 struct nfs_page *req;
566 unsigned int rqend;
567 unsigned int end;
568 int error;
569
570 if (!PagePrivate(page))
571 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572
573 end = offset + bytes;
Trond Myklebuste7d39062008-06-13 12:12:32 -0400574 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 for (;;) {
Trond Myklebust277459d2006-12-05 00:35:35 -0500577 req = nfs_page_find_request_locked(page);
Trond Myklebuste7d39062008-06-13 12:12:32 -0400578 if (req == NULL)
579 goto out_unlock;
Trond Myklebust277459d2006-12-05 00:35:35 -0500580
Trond Myklebuste7d39062008-06-13 12:12:32 -0400581 rqend = req->wb_offset + req->wb_bytes;
582 /*
583 * Tell the caller to flush out the request if
584 * the offsets are non-contiguous.
585 * Note: nfs_flush_incompatible() will already
586 * have flushed out requests having wrong owners.
587 */
Trond Myklebuste468bae2008-06-13 13:25:22 -0400588 if (offset > rqend
Trond Myklebuste7d39062008-06-13 12:12:32 -0400589 || end < req->wb_offset)
590 goto out_flushme;
591
592 if (nfs_set_page_tag_locked(req))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594
Trond Myklebuste7d39062008-06-13 12:12:32 -0400595 /* The request is locked, so wait and then retry */
Trond Myklebust587142f2007-07-02 09:57:54 -0400596 spin_unlock(&inode->i_lock);
Trond Myklebuste7d39062008-06-13 12:12:32 -0400597 error = nfs_wait_on_request(req);
598 nfs_release_request(req);
599 if (error != 0)
600 goto out_err;
601 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 }
603
Trond Myklebustff778d02010-02-19 16:53:39 -0800604 if (nfs_clear_request_commit(req) &&
605 radix_tree_tag_clear(&NFS_I(inode)->nfs_page_tree,
606 req->wb_index, NFS_PAGE_TAG_COMMIT) != NULL)
607 NFS_I(inode)->ncommit--;
Trond Myklebuste468bae2008-06-13 13:25:22 -0400608
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 /* Okay, the request matches. Update the region */
610 if (offset < req->wb_offset) {
611 req->wb_offset = offset;
612 req->wb_pgbase = offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 if (end > rqend)
615 req->wb_bytes = end - req->wb_offset;
Trond Myklebuste7d39062008-06-13 12:12:32 -0400616 else
617 req->wb_bytes = rqend - req->wb_offset;
618out_unlock:
619 spin_unlock(&inode->i_lock);
620 return req;
621out_flushme:
622 spin_unlock(&inode->i_lock);
623 nfs_release_request(req);
624 error = nfs_wb_page(inode, page);
625out_err:
626 return ERR_PTR(error);
627}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628
Trond Myklebuste7d39062008-06-13 12:12:32 -0400629/*
630 * Try to update an existing write request, or create one if there is none.
631 *
632 * Note: Should always be called with the Page Lock held to prevent races
633 * if we have to add a new request. Also assumes that the caller has
634 * already called nfs_flush_incompatible() if necessary.
635 */
636static struct nfs_page * nfs_setup_write_request(struct nfs_open_context* ctx,
637 struct page *page, unsigned int offset, unsigned int bytes)
638{
639 struct inode *inode = page->mapping->host;
640 struct nfs_page *req;
641 int error;
642
643 req = nfs_try_to_update_request(inode, page, offset, bytes);
644 if (req != NULL)
645 goto out;
646 req = nfs_create_request(ctx, inode, page, offset, bytes);
647 if (IS_ERR(req))
648 goto out;
649 error = nfs_inode_add_request(inode, req);
650 if (error != 0) {
651 nfs_release_request(req);
652 req = ERR_PTR(error);
653 }
Trond Myklebustefc91ed2008-06-10 18:31:00 -0400654out:
Trond Myklebust61e930a2007-10-18 17:08:05 -0400655 return req;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656}
657
Trond Myklebuste7d39062008-06-13 12:12:32 -0400658static int nfs_writepage_setup(struct nfs_open_context *ctx, struct page *page,
659 unsigned int offset, unsigned int count)
660{
661 struct nfs_page *req;
662
663 req = nfs_setup_write_request(ctx, page, offset, count);
664 if (IS_ERR(req))
665 return PTR_ERR(req);
Trond Myklebustb80c3cb2010-04-09 19:07:07 -0400666 nfs_mark_request_dirty(req);
Trond Myklebuste7d39062008-06-13 12:12:32 -0400667 /* Update file length */
668 nfs_grow_file(page, offset, count);
669 nfs_mark_uptodate(page, req->wb_pgbase, req->wb_bytes);
Trond Myklebusta6305dd2010-04-09 19:07:08 -0400670 nfs_mark_request_dirty(req);
Trond Myklebuste7d39062008-06-13 12:12:32 -0400671 nfs_clear_page_tag_locked(req);
672 return 0;
673}
674
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675int nfs_flush_incompatible(struct file *file, struct page *page)
676{
Trond Myklebustcd3758e2007-08-10 17:44:32 -0400677 struct nfs_open_context *ctx = nfs_file_open_context(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 struct nfs_page *req;
Trond Myklebust1a545332006-12-05 00:35:40 -0500679 int do_flush, status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 /*
681 * Look for a request corresponding to this page. If there
682 * is one, and it belongs to another file, we flush it out
683 * before we try to copy anything into the page. Do this
684 * due to the lack of an ACCESS-type call in NFSv2.
685 * Also do the same if we find a request from an existing
686 * dropped page.
687 */
Trond Myklebust1a545332006-12-05 00:35:40 -0500688 do {
689 req = nfs_page_find_request(page);
690 if (req == NULL)
691 return 0;
Trond Myklebuste468bae2008-06-13 13:25:22 -0400692 do_flush = req->wb_page != page || req->wb_context != ctx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 nfs_release_request(req);
Trond Myklebust1a545332006-12-05 00:35:40 -0500694 if (!do_flush)
695 return 0;
696 status = nfs_wb_page(page->mapping->host, page);
697 } while (status == 0);
698 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699}
700
701/*
Trond Myklebust5d47a352008-02-07 17:24:07 -0500702 * If the page cache is marked as unsafe or invalid, then we can't rely on
703 * the PageUptodate() flag. In this case, we will need to turn off
704 * write optimisations that depend on the page contents being correct.
705 */
706static int nfs_write_pageuptodate(struct page *page, struct inode *inode)
707{
708 return PageUptodate(page) &&
709 !(NFS_I(inode)->cache_validity & (NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_DATA));
710}
711
712/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 * Update and possibly write a cached page of an NFS file.
714 *
715 * XXX: Keep an eye on generic_file_read to make sure it doesn't do bad
716 * things with a page scheduled for an RPC call (e.g. invalidate it).
717 */
718int nfs_updatepage(struct file *file, struct page *page,
719 unsigned int offset, unsigned int count)
720{
Trond Myklebustcd3758e2007-08-10 17:44:32 -0400721 struct nfs_open_context *ctx = nfs_file_open_context(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 struct inode *inode = page->mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 int status = 0;
724
Chuck Lever91d5b472006-03-20 13:44:14 -0500725 nfs_inc_stats(inode, NFSIOS_VFSUPDATEPAGE);
726
Chuck Lever48186c72008-06-11 17:56:05 -0400727 dprintk("NFS: nfs_updatepage(%s/%s %d@%lld)\n",
Josef "Jeff" Sipek01cce932006-12-08 02:36:40 -0800728 file->f_path.dentry->d_parent->d_name.name,
729 file->f_path.dentry->d_name.name, count,
Chuck Lever48186c72008-06-11 17:56:05 -0400730 (long long)(page_offset(page) + offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 /* If we're not using byte range locks, and we know the page
Trond Myklebust5d47a352008-02-07 17:24:07 -0500733 * is up to date, it may be more efficient to extend the write
734 * to cover the entire page in order to avoid fragmentation
735 * inefficiencies.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 */
Trond Myklebust5d47a352008-02-07 17:24:07 -0500737 if (nfs_write_pageuptodate(page, inode) &&
738 inode->i_flock == NULL &&
Christoph Hellwig6b2f3d12009-10-27 11:05:28 +0100739 !(file->f_flags & O_DSYNC)) {
Trond Myklebust49a70f22006-12-05 00:35:38 -0500740 count = max(count + offset, nfs_page_length(page));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 }
743
Trond Myklebuste21195a2006-12-05 00:35:39 -0500744 status = nfs_writepage_setup(ctx, page, offset, count);
Trond Myklebust03fa9e82008-06-05 16:02:35 -0400745 if (status < 0)
746 nfs_set_pageerror(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747
Chuck Lever48186c72008-06-11 17:56:05 -0400748 dprintk("NFS: nfs_updatepage returns %d (isize %lld)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 status, (long long)i_size_read(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 return status;
751}
752
753static void nfs_writepage_release(struct nfs_page *req)
754{
Trond Myklebusta6305dd2010-04-09 19:07:08 -0400755 struct page *page = req->wb_page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
Trond Myklebusta6305dd2010-04-09 19:07:08 -0400757 if (PageError(req->wb_page) || !nfs_reschedule_unstable_write(req))
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400758 nfs_inode_remove_request(req);
Trond Myklebust9fd367f2007-06-17 15:10:24 -0400759 nfs_clear_page_tag_locked(req);
Trond Myklebusta6305dd2010-04-09 19:07:08 -0400760 nfs_end_page_writeback(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761}
762
Trond Myklebust3ff75762007-07-14 15:40:00 -0400763static int flush_task_priority(int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764{
765 switch (how & (FLUSH_HIGHPRI|FLUSH_LOWPRI)) {
766 case FLUSH_HIGHPRI:
767 return RPC_PRIORITY_HIGH;
768 case FLUSH_LOWPRI:
769 return RPC_PRIORITY_LOW;
770 }
771 return RPC_PRIORITY_NORMAL;
772}
773
774/*
775 * Set up the argument/result storage required for the RPC call.
776 */
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400777static int nfs_write_rpcsetup(struct nfs_page *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 struct nfs_write_data *data,
Trond Myklebust788e7a82006-03-20 13:44:27 -0500779 const struct rpc_call_ops *call_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 unsigned int count, unsigned int offset,
781 int how)
782{
Trond Myklebust84115e12007-07-14 15:39:59 -0400783 struct inode *inode = req->wb_context->path.dentry->d_inode;
Trond Myklebust3ff75762007-07-14 15:40:00 -0400784 int priority = flush_task_priority(how);
Trond Myklebust07737692007-10-25 18:42:54 -0400785 struct rpc_task *task;
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400786 struct rpc_message msg = {
787 .rpc_argp = &data->args,
788 .rpc_resp = &data->res,
789 .rpc_cred = req->wb_context->cred,
790 };
Trond Myklebust84115e12007-07-14 15:39:59 -0400791 struct rpc_task_setup task_setup_data = {
792 .rpc_client = NFS_CLIENT(inode),
Trond Myklebust07737692007-10-25 18:42:54 -0400793 .task = &data->task,
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400794 .rpc_message = &msg,
Trond Myklebust84115e12007-07-14 15:39:59 -0400795 .callback_ops = call_ops,
796 .callback_data = data,
Trond Myklebust101070c2008-02-19 20:04:23 -0500797 .workqueue = nfsiod_workqueue,
Trond Myklebust2c61be02010-04-09 19:54:50 -0400798 .flags = RPC_TASK_ASYNC,
Trond Myklebust3ff75762007-07-14 15:40:00 -0400799 .priority = priority,
Trond Myklebust84115e12007-07-14 15:39:59 -0400800 };
Trond Myklebust2c61be02010-04-09 19:54:50 -0400801 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
803 /* Set up the RPC argument and reply structs
804 * NB: take care not to mess about with data->commit et al. */
805
806 data->req = req;
Trond Myklebust88be9f92007-06-05 10:42:27 -0400807 data->inode = inode = req->wb_context->path.dentry->d_inode;
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400808 data->cred = msg.rpc_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809
810 data->args.fh = NFS_FH(inode);
811 data->args.offset = req_offset(req) + offset;
812 data->args.pgbase = req->wb_pgbase + offset;
813 data->args.pages = data->pagevec;
814 data->args.count = count;
Trond Myklebust383ba712008-02-19 20:04:20 -0500815 data->args.context = get_nfs_open_context(req->wb_context);
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400816 data->args.stable = NFS_UNSTABLE;
817 if (how & FLUSH_STABLE) {
818 data->args.stable = NFS_DATA_SYNC;
Trond Myklebustfb8a1f12009-03-11 14:10:29 -0400819 if (!nfs_need_commit(NFS_I(inode)))
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400820 data->args.stable = NFS_FILE_SYNC;
821 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822
823 data->res.fattr = &data->fattr;
824 data->res.count = count;
825 data->res.verf = &data->verf;
Trond Myklebust0e574af2005-10-27 22:12:38 -0400826 nfs_fattr_init(&data->fattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827
Trond Myklebust788e7a82006-03-20 13:44:27 -0500828 /* Set up the initial task struct. */
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400829 NFS_PROTO(inode)->write_setup(data, &msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830
Chuck Levera3f565b2007-01-31 12:14:01 -0500831 dprintk("NFS: %5u initiated write call "
Chuck Lever48186c72008-06-11 17:56:05 -0400832 "(req %s/%lld, %u bytes @ offset %llu)\n",
Chuck Lever0bbacc42005-11-01 16:53:32 -0500833 data->task.tk_pid,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 inode->i_sb->s_id,
835 (long long)NFS_FILEID(inode),
836 count,
837 (unsigned long long)data->args.offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838
Trond Myklebust07737692007-10-25 18:42:54 -0400839 task = rpc_run_task(&task_setup_data);
Trond Myklebust2c61be02010-04-09 19:54:50 -0400840 if (IS_ERR(task)) {
841 ret = PTR_ERR(task);
842 goto out;
843 }
844 if (how & FLUSH_SYNC) {
845 ret = rpc_wait_for_completion_task(task);
846 if (ret == 0)
847 ret = task->tk_status;
848 }
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400849 rpc_put_task(task);
Trond Myklebust2c61be02010-04-09 19:54:50 -0400850out:
851 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852}
853
Fred6d884e82008-03-19 11:24:38 -0400854/* If a nfs_flush_* function fails, it should remove reqs from @head and
855 * call this on each, which will prepare them to be retried on next
856 * writeback using standard nfs.
857 */
858static void nfs_redirty_request(struct nfs_page *req)
859{
Trond Myklebusta6305dd2010-04-09 19:07:08 -0400860 struct page *page = req->wb_page;
861
Fred6d884e82008-03-19 11:24:38 -0400862 nfs_mark_request_dirty(req);
Fred6d884e82008-03-19 11:24:38 -0400863 nfs_clear_page_tag_locked(req);
Trond Myklebusta6305dd2010-04-09 19:07:08 -0400864 nfs_end_page_writeback(page);
Fred6d884e82008-03-19 11:24:38 -0400865}
866
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867/*
868 * Generate multiple small requests to write out a single
869 * contiguous dirty area on one page.
870 */
Trond Myklebust8d5658c2007-04-10 09:26:35 -0400871static 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 -0700872{
873 struct nfs_page *req = nfs_list_entry(head->next);
874 struct page *page = req->wb_page;
875 struct nfs_write_data *data;
Trond Myklebuste9f7bee2006-09-08 09:48:54 -0700876 size_t wsize = NFS_SERVER(inode)->wsize, nbytes;
877 unsigned int offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 int requests = 0;
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400879 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 LIST_HEAD(list);
881
882 nfs_list_remove_request(req);
883
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400884 nbytes = count;
Trond Myklebuste9f7bee2006-09-08 09:48:54 -0700885 do {
886 size_t len = min(nbytes, wsize);
887
Trond Myklebust8d5658c2007-04-10 09:26:35 -0400888 data = nfs_writedata_alloc(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 if (!data)
890 goto out_bad;
891 list_add(&data->pages, &list);
892 requests++;
Trond Myklebuste9f7bee2006-09-08 09:48:54 -0700893 nbytes -= len;
894 } while (nbytes != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 atomic_set(&req->wb_complete, requests);
896
897 ClearPageError(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 offset = 0;
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400899 nbytes = count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 do {
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400901 int ret2;
902
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 data = list_entry(list.next, struct nfs_write_data, pages);
904 list_del_init(&data->pages);
905
906 data->pagevec[0] = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400908 if (nbytes < wsize)
909 wsize = nbytes;
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400910 ret2 = nfs_write_rpcsetup(req, data, &nfs_write_partial_ops,
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400911 wsize, offset, how);
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400912 if (ret == 0)
913 ret = ret2;
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400914 offset += wsize;
915 nbytes -= wsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 } while (nbytes != 0);
917
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400918 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919
920out_bad:
921 while (!list_empty(&list)) {
922 data = list_entry(list.next, struct nfs_write_data, pages);
923 list_del(&data->pages);
Trond Myklebust8aca67f2006-11-13 16:23:44 -0500924 nfs_writedata_release(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 }
Trond Myklebust61822ab2006-12-05 00:35:42 -0500926 nfs_redirty_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 return -ENOMEM;
928}
929
930/*
931 * Create an RPC task for the given write request and kick it.
932 * The page must have been locked by the caller.
933 *
934 * It may happen that the page we're passed is not marked dirty.
935 * This is the case if nfs_updatepage detects a conflicting request
936 * that has been written but not committed.
937 */
Trond Myklebust8d5658c2007-04-10 09:26:35 -0400938static 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 -0700939{
940 struct nfs_page *req;
941 struct page **pages;
942 struct nfs_write_data *data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943
Trond Myklebust8d5658c2007-04-10 09:26:35 -0400944 data = nfs_writedata_alloc(npages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 if (!data)
946 goto out_bad;
947
948 pages = data->pagevec;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 while (!list_empty(head)) {
950 req = nfs_list_entry(head->next);
951 nfs_list_remove_request(req);
952 nfs_list_add_request(req, &data->pages);
953 ClearPageError(req->wb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 *pages++ = req->wb_page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 }
956 req = nfs_list_entry(data->pages.next);
957
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 /* Set up the argument struct */
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400959 return nfs_write_rpcsetup(req, data, &nfs_write_full_ops, count, 0, how);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 out_bad:
961 while (!list_empty(head)) {
Trond Myklebust10afec92007-05-14 17:16:04 -0400962 req = nfs_list_entry(head->next);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 nfs_list_remove_request(req);
Trond Myklebust61822ab2006-12-05 00:35:42 -0500964 nfs_redirty_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 }
966 return -ENOMEM;
967}
968
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400969static void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio,
970 struct inode *inode, int ioflags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971{
Chuck Leverbf4285e2007-12-20 14:54:57 -0500972 size_t wsize = NFS_SERVER(inode)->wsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400974 if (wsize < PAGE_CACHE_SIZE)
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400975 nfs_pageio_init(pgio, inode, nfs_flush_multi, wsize, ioflags);
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400976 else
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400977 nfs_pageio_init(pgio, inode, nfs_flush_one, wsize, ioflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978}
979
980/*
981 * Handle a write reply that flushed part of a page.
982 */
Trond Myklebust788e7a82006-03-20 13:44:27 -0500983static void nfs_writeback_done_partial(struct rpc_task *task, void *calldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984{
Trond Myklebust788e7a82006-03-20 13:44:27 -0500985 struct nfs_write_data *data = calldata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986
Chuck Lever48186c72008-06-11 17:56:05 -0400987 dprintk("NFS: %5u write(%s/%lld %d@%lld)",
988 task->tk_pid,
989 data->req->wb_context->path.dentry->d_inode->i_sb->s_id,
990 (long long)
991 NFS_FILEID(data->req->wb_context->path.dentry->d_inode),
992 data->req->wb_bytes, (long long)req_offset(data->req));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993
Trond Myklebustc9d8f892008-04-15 16:56:39 -0400994 nfs_writeback_done(task, data);
995}
Trond Myklebust788e7a82006-03-20 13:44:27 -0500996
Trond Myklebustc9d8f892008-04-15 16:56:39 -0400997static void nfs_writeback_release_partial(void *calldata)
998{
999 struct nfs_write_data *data = calldata;
1000 struct nfs_page *req = data->req;
1001 struct page *page = req->wb_page;
1002 int status = data->task.tk_status;
1003
1004 if (status < 0) {
Trond Myklebusta301b772007-02-06 11:07:15 -08001005 nfs_set_pageerror(page);
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001006 nfs_context_set_write_error(req->wb_context, status);
1007 dprintk(", error = %d\n", status);
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001008 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 }
1010
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001011 if (nfs_write_need_commit(data)) {
Trond Myklebust587142f2007-07-02 09:57:54 -04001012 struct inode *inode = page->mapping->host;
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001013
Trond Myklebust587142f2007-07-02 09:57:54 -04001014 spin_lock(&inode->i_lock);
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001015 if (test_bit(PG_NEED_RESCHED, &req->wb_flags)) {
1016 /* Do nothing we need to resend the writes */
1017 } else if (!test_and_set_bit(PG_NEED_COMMIT, &req->wb_flags)) {
1018 memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf));
1019 dprintk(" defer commit\n");
1020 } else if (memcmp(&req->wb_verf, &data->verf, sizeof(req->wb_verf))) {
1021 set_bit(PG_NEED_RESCHED, &req->wb_flags);
1022 clear_bit(PG_NEED_COMMIT, &req->wb_flags);
1023 dprintk(" server reboot detected\n");
1024 }
Trond Myklebust587142f2007-07-02 09:57:54 -04001025 spin_unlock(&inode->i_lock);
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001026 } else
1027 dprintk(" OK\n");
1028
1029out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 if (atomic_dec_and_test(&req->wb_complete))
1031 nfs_writepage_release(req);
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001032 nfs_writedata_release(calldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033}
1034
Andy Adamsondef6ed72009-04-01 09:22:26 -04001035#if defined(CONFIG_NFS_V4_1)
1036void nfs_write_prepare(struct rpc_task *task, void *calldata)
1037{
1038 struct nfs_write_data *data = calldata;
1039 struct nfs_client *clp = (NFS_SERVER(data->inode))->nfs_client;
1040
1041 if (nfs4_setup_sequence(clp, &data->args.seq_args,
1042 &data->res.seq_res, 1, task))
1043 return;
1044 rpc_call_start(task);
1045}
1046#endif /* CONFIG_NFS_V4_1 */
1047
Trond Myklebust788e7a82006-03-20 13:44:27 -05001048static const struct rpc_call_ops nfs_write_partial_ops = {
Andy Adamsondef6ed72009-04-01 09:22:26 -04001049#if defined(CONFIG_NFS_V4_1)
1050 .rpc_call_prepare = nfs_write_prepare,
1051#endif /* CONFIG_NFS_V4_1 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001052 .rpc_call_done = nfs_writeback_done_partial,
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001053 .rpc_release = nfs_writeback_release_partial,
Trond Myklebust788e7a82006-03-20 13:44:27 -05001054};
1055
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056/*
1057 * Handle a write reply that flushes a whole page.
1058 *
1059 * FIXME: There is an inherent race with invalidate_inode_pages and
1060 * writebacks since the page->count is kept > 1 for as long
1061 * as the page has a write request pending.
1062 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001063static void nfs_writeback_done_full(struct rpc_task *task, void *calldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064{
Trond Myklebust788e7a82006-03-20 13:44:27 -05001065 struct nfs_write_data *data = calldata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001067 nfs_writeback_done(task, data);
1068}
1069
1070static void nfs_writeback_release_full(void *calldata)
1071{
1072 struct nfs_write_data *data = calldata;
1073 int status = data->task.tk_status;
Trond Myklebust788e7a82006-03-20 13:44:27 -05001074
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 /* Update attributes as result of writeback. */
1076 while (!list_empty(&data->pages)) {
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001077 struct nfs_page *req = nfs_list_entry(data->pages.next);
1078 struct page *page = req->wb_page;
1079
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 nfs_list_remove_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081
Chuck Lever48186c72008-06-11 17:56:05 -04001082 dprintk("NFS: %5u write (%s/%lld %d@%lld)",
1083 data->task.tk_pid,
Trond Myklebust88be9f92007-06-05 10:42:27 -04001084 req->wb_context->path.dentry->d_inode->i_sb->s_id,
1085 (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 req->wb_bytes,
1087 (long long)req_offset(req));
1088
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001089 if (status < 0) {
Trond Myklebusta301b772007-02-06 11:07:15 -08001090 nfs_set_pageerror(page);
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001091 nfs_context_set_write_error(req->wb_context, status);
1092 dprintk(", error = %d\n", status);
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001093 goto remove_request;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001096 if (nfs_write_need_commit(data)) {
1097 memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf));
1098 nfs_mark_request_commit(req);
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001099 dprintk(" marked for commit\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 goto next;
1101 }
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001102 dprintk(" OK\n");
1103remove_request:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 nfs_inode_remove_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 next:
Trond Myklebust9fd367f2007-06-17 15:10:24 -04001106 nfs_clear_page_tag_locked(req);
Trond Myklebusta6305dd2010-04-09 19:07:08 -04001107 nfs_end_page_writeback(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 }
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001109 nfs_writedata_release(calldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110}
1111
Trond Myklebust788e7a82006-03-20 13:44:27 -05001112static const struct rpc_call_ops nfs_write_full_ops = {
Andy Adamsondef6ed72009-04-01 09:22:26 -04001113#if defined(CONFIG_NFS_V4_1)
1114 .rpc_call_prepare = nfs_write_prepare,
1115#endif /* CONFIG_NFS_V4_1 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001116 .rpc_call_done = nfs_writeback_done_full,
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001117 .rpc_release = nfs_writeback_release_full,
Trond Myklebust788e7a82006-03-20 13:44:27 -05001118};
1119
1120
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121/*
1122 * This function is called when the WRITE call is complete.
1123 */
Chuck Lever462d5b32006-03-20 13:44:32 -05001124int nfs_writeback_done(struct rpc_task *task, struct nfs_write_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 struct nfs_writeargs *argp = &data->args;
1127 struct nfs_writeres *resp = &data->res;
Andy Adamsoneedc0202009-04-01 09:22:41 -04001128 struct nfs_server *server = NFS_SERVER(data->inode);
Trond Myklebust788e7a82006-03-20 13:44:27 -05001129 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130
Chuck Levera3f565b2007-01-31 12:14:01 -05001131 dprintk("NFS: %5u nfs_writeback_done (status %d)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 task->tk_pid, task->tk_status);
1133
Chuck Leverf551e442006-09-20 14:33:04 -04001134 /*
1135 * ->write_done will attempt to use post-op attributes to detect
1136 * conflicting writes by other clients. A strict interpretation
1137 * of close-to-open would allow us to continue caching even if
1138 * another writer had changed the file, but some applications
1139 * depend on tighter cache coherency when writing.
1140 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001141 status = NFS_PROTO(data->inode)->write_done(task, data);
1142 if (status != 0)
1143 return status;
Chuck Lever91d5b472006-03-20 13:44:14 -05001144 nfs_add_stats(data->inode, NFSIOS_SERVERWRITTENBYTES, resp->count);
1145
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
1147 if (resp->verf->committed < argp->stable && task->tk_status >= 0) {
1148 /* We tried a write call, but the server did not
1149 * commit data to stable storage even though we
1150 * requested it.
1151 * Note: There is a known bug in Tru64 < 5.0 in which
1152 * the server reports NFS_DATA_SYNC, but performs
1153 * NFS_FILE_SYNC. We therefore implement this checking
1154 * as a dprintk() in order to avoid filling syslog.
1155 */
1156 static unsigned long complain;
1157
1158 if (time_before(complain, jiffies)) {
Chuck Lever48186c72008-06-11 17:56:05 -04001159 dprintk("NFS: faulty NFS server %s:"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 " (committed = %d) != (stable = %d)\n",
Andy Adamsoneedc0202009-04-01 09:22:41 -04001161 server->nfs_client->cl_hostname,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 resp->verf->committed, argp->stable);
1163 complain = jiffies + 300 * HZ;
1164 }
1165 }
1166#endif
1167 /* Is this a short write? */
1168 if (task->tk_status >= 0 && resp->count < argp->count) {
1169 static unsigned long complain;
1170
Chuck Lever91d5b472006-03-20 13:44:14 -05001171 nfs_inc_stats(data->inode, NFSIOS_SHORTWRITE);
1172
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 /* Has the server at least made some progress? */
1174 if (resp->count != 0) {
1175 /* Was this an NFSv2 write or an NFSv3 stable write? */
1176 if (resp->verf->committed != NFS_UNSTABLE) {
1177 /* Resend from where the server left off */
1178 argp->offset += resp->count;
1179 argp->pgbase += resp->count;
1180 argp->count -= resp->count;
1181 } else {
1182 /* Resend as a stable write in order to avoid
1183 * headaches in the case of a server crash.
1184 */
1185 argp->stable = NFS_FILE_SYNC;
1186 }
Trond Myklebust0110ee12009-12-07 09:00:24 -05001187 nfs_restart_rpc(task, server->nfs_client);
Trond Myklebust788e7a82006-03-20 13:44:27 -05001188 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 }
1190 if (time_before(complain, jiffies)) {
1191 printk(KERN_WARNING
1192 "NFS: Server wrote zero bytes, expected %u.\n",
1193 argp->count);
1194 complain = jiffies + 300 * HZ;
1195 }
1196 /* Can't do anything about it except throw an error. */
1197 task->tk_status = -EIO;
1198 }
Trond Myklebust788e7a82006-03-20 13:44:27 -05001199 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200}
1201
1202
1203#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
Trond Myklebust71d0a612010-04-22 15:35:57 -04001204static int nfs_commit_set_lock(struct nfs_inode *nfsi, int may_wait)
1205{
1206 if (!test_and_set_bit(NFS_INO_COMMIT, &nfsi->flags))
1207 return 1;
1208 if (may_wait && !out_of_line_wait_on_bit_lock(&nfsi->flags,
1209 NFS_INO_COMMIT, nfs_wait_bit_killable,
1210 TASK_KILLABLE))
1211 return 1;
1212 return 0;
1213}
1214
1215static void nfs_commit_clear_lock(struct nfs_inode *nfsi)
1216{
1217 clear_bit(NFS_INO_COMMIT, &nfsi->flags);
1218 smp_mb__after_clear_bit();
1219 wake_up_bit(&nfsi->flags, NFS_INO_COMMIT);
1220}
1221
1222
H Hartley Sweeten0aa05882010-01-26 15:42:03 -05001223static void nfs_commitdata_release(void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224{
Trond Myklebust383ba712008-02-19 20:04:20 -05001225 struct nfs_write_data *wdata = data;
1226
1227 put_nfs_open_context(wdata->args.context);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 nfs_commit_free(wdata);
1229}
1230
1231/*
1232 * Set up the argument/result storage required for the RPC call.
1233 */
Trond Myklebustdbae4c72008-04-14 14:54:53 -04001234static int nfs_commit_rpcsetup(struct list_head *head,
Trond Myklebust788e7a82006-03-20 13:44:27 -05001235 struct nfs_write_data *data,
1236 int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237{
Trond Myklebust84115e12007-07-14 15:39:59 -04001238 struct nfs_page *first = nfs_list_entry(head->next);
1239 struct inode *inode = first->wb_context->path.dentry->d_inode;
Trond Myklebust3ff75762007-07-14 15:40:00 -04001240 int priority = flush_task_priority(how);
Trond Myklebust07737692007-10-25 18:42:54 -04001241 struct rpc_task *task;
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001242 struct rpc_message msg = {
1243 .rpc_argp = &data->args,
1244 .rpc_resp = &data->res,
1245 .rpc_cred = first->wb_context->cred,
1246 };
Trond Myklebust84115e12007-07-14 15:39:59 -04001247 struct rpc_task_setup task_setup_data = {
Trond Myklebust07737692007-10-25 18:42:54 -04001248 .task = &data->task,
Trond Myklebust84115e12007-07-14 15:39:59 -04001249 .rpc_client = NFS_CLIENT(inode),
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001250 .rpc_message = &msg,
Trond Myklebust84115e12007-07-14 15:39:59 -04001251 .callback_ops = &nfs_commit_ops,
1252 .callback_data = data,
Trond Myklebust101070c2008-02-19 20:04:23 -05001253 .workqueue = nfsiod_workqueue,
Trond Myklebust2c61be02010-04-09 19:54:50 -04001254 .flags = RPC_TASK_ASYNC,
Trond Myklebust3ff75762007-07-14 15:40:00 -04001255 .priority = priority,
Trond Myklebust84115e12007-07-14 15:39:59 -04001256 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257
1258 /* Set up the RPC argument and reply structs
1259 * NB: take care not to mess about with data->commit et al. */
1260
1261 list_splice_init(head, &data->pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 data->inode = inode;
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001264 data->cred = msg.rpc_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265
1266 data->args.fh = NFS_FH(data->inode);
Trond Myklebust3da28eb2005-06-22 17:16:31 +00001267 /* Note: we always request a commit of the entire inode */
1268 data->args.offset = 0;
1269 data->args.count = 0;
Trond Myklebust383ba712008-02-19 20:04:20 -05001270 data->args.context = get_nfs_open_context(first->wb_context);
Trond Myklebust3da28eb2005-06-22 17:16:31 +00001271 data->res.count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 data->res.fattr = &data->fattr;
1273 data->res.verf = &data->verf;
Trond Myklebust0e574af2005-10-27 22:12:38 -04001274 nfs_fattr_init(&data->fattr);
Trond Myklebust788e7a82006-03-20 13:44:27 -05001275
1276 /* Set up the initial task struct. */
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001277 NFS_PROTO(inode)->commit_setup(data, &msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278
Chuck Levera3f565b2007-01-31 12:14:01 -05001279 dprintk("NFS: %5u initiated commit call\n", data->task.tk_pid);
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001280
Trond Myklebust07737692007-10-25 18:42:54 -04001281 task = rpc_run_task(&task_setup_data);
Trond Myklebustdbae4c72008-04-14 14:54:53 -04001282 if (IS_ERR(task))
1283 return PTR_ERR(task);
1284 rpc_put_task(task);
1285 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286}
1287
1288/*
1289 * Commit dirty pages
1290 */
1291static int
Chuck Lever40859d72005-11-30 18:09:02 -05001292nfs_commit_list(struct inode *inode, struct list_head *head, int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293{
1294 struct nfs_write_data *data;
1295 struct nfs_page *req;
1296
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001297 data = nfs_commitdata_alloc();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298
1299 if (!data)
1300 goto out_bad;
1301
1302 /* Set up the argument struct */
Trond Myklebustdbae4c72008-04-14 14:54:53 -04001303 return nfs_commit_rpcsetup(head, data, how);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 out_bad:
1305 while (!list_empty(head)) {
1306 req = nfs_list_entry(head->next);
1307 nfs_list_remove_request(req);
1308 nfs_mark_request_commit(req);
Trond Myklebust83715ad2006-07-05 13:17:12 -04001309 dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
Peter Zijlstrac9e51e42007-10-16 23:25:47 -07001310 dec_bdi_stat(req->wb_page->mapping->backing_dev_info,
1311 BDI_RECLAIMABLE);
Trond Myklebust9fd367f2007-06-17 15:10:24 -04001312 nfs_clear_page_tag_locked(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 }
Trond Myklebust71d0a612010-04-22 15:35:57 -04001314 nfs_commit_clear_lock(NFS_I(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 return -ENOMEM;
1316}
1317
1318/*
1319 * COMMIT call returned
1320 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001321static void nfs_commit_done(struct rpc_task *task, void *calldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322{
Trond Myklebust963d8fe2006-01-03 09:55:04 +01001323 struct nfs_write_data *data = calldata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324
Chuck Levera3f565b2007-01-31 12:14:01 -05001325 dprintk("NFS: %5u nfs_commit_done (status %d)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 task->tk_pid, task->tk_status);
1327
Trond Myklebust788e7a82006-03-20 13:44:27 -05001328 /* Call the NFS version-specific code */
1329 if (NFS_PROTO(data->inode)->commit_done(task, data) != 0)
1330 return;
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001331}
1332
1333static void nfs_commit_release(void *calldata)
1334{
1335 struct nfs_write_data *data = calldata;
1336 struct nfs_page *req;
1337 int status = data->task.tk_status;
Trond Myklebust788e7a82006-03-20 13:44:27 -05001338
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 while (!list_empty(&data->pages)) {
1340 req = nfs_list_entry(data->pages.next);
1341 nfs_list_remove_request(req);
Trond Myklebuste468bae2008-06-13 13:25:22 -04001342 nfs_clear_request_commit(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343
Chuck Lever48186c72008-06-11 17:56:05 -04001344 dprintk("NFS: commit (%s/%lld %d@%lld)",
Trond Myklebust88be9f92007-06-05 10:42:27 -04001345 req->wb_context->path.dentry->d_inode->i_sb->s_id,
1346 (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 req->wb_bytes,
1348 (long long)req_offset(req));
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001349 if (status < 0) {
1350 nfs_context_set_write_error(req->wb_context, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 nfs_inode_remove_request(req);
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001352 dprintk(", error = %d\n", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 goto next;
1354 }
1355
1356 /* Okay, COMMIT succeeded, apparently. Check the verifier
1357 * returned by the server against all stored verfs. */
1358 if (!memcmp(req->wb_verf.verifier, data->verf.verifier, sizeof(data->verf.verifier))) {
1359 /* We have a match */
1360 nfs_inode_remove_request(req);
1361 dprintk(" OK\n");
1362 goto next;
1363 }
1364 /* We have a mismatch. Write the page again */
1365 dprintk(" mismatch\n");
Fred6d884e82008-03-19 11:24:38 -04001366 nfs_mark_request_dirty(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 next:
Trond Myklebust9fd367f2007-06-17 15:10:24 -04001368 nfs_clear_page_tag_locked(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 }
Trond Myklebust71d0a612010-04-22 15:35:57 -04001370 nfs_commit_clear_lock(NFS_I(data->inode));
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001371 nfs_commitdata_release(calldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372}
Trond Myklebust788e7a82006-03-20 13:44:27 -05001373
1374static const struct rpc_call_ops nfs_commit_ops = {
Andy Adamson21d9a852009-04-01 09:22:27 -04001375#if defined(CONFIG_NFS_V4_1)
1376 .rpc_call_prepare = nfs_write_prepare,
1377#endif /* CONFIG_NFS_V4_1 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001378 .rpc_call_done = nfs_commit_done,
1379 .rpc_release = nfs_commit_release,
1380};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381
Trond Myklebust8fc795f2010-02-19 16:46:56 -08001382static int nfs_commit_inode(struct inode *inode, int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 LIST_HEAD(head);
Trond Myklebust71d0a612010-04-22 15:35:57 -04001385 int may_wait = how & FLUSH_SYNC;
1386 int res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387
Trond Myklebust71d0a612010-04-22 15:35:57 -04001388 if (!nfs_commit_set_lock(NFS_I(inode), may_wait))
1389 goto out;
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;
Trond Myklebust71d0a612010-04-22 15:35:57 -04001397 if (may_wait)
1398 wait_on_bit(&NFS_I(inode)->flags, NFS_INO_COMMIT,
1399 nfs_wait_bit_killable,
1400 TASK_KILLABLE);
1401 } else
1402 nfs_commit_clear_lock(NFS_I(inode));
1403out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 return res;
1405}
Trond Myklebust8fc795f2010-02-19 16:46:56 -08001406
1407static int nfs_commit_unstable_pages(struct inode *inode, struct writeback_control *wbc)
1408{
Trond Myklebust420e3642010-02-19 17:00:02 -08001409 struct nfs_inode *nfsi = NFS_I(inode);
1410 int flags = FLUSH_SYNC;
1411 int ret = 0;
Trond Myklebust8fc795f2010-02-19 16:46:56 -08001412
Trond Myklebust420e3642010-02-19 17:00:02 -08001413 /* Don't commit yet if this is a non-blocking flush and there are
1414 * lots of outstanding writes for this mapping.
1415 */
1416 if (wbc->sync_mode == WB_SYNC_NONE &&
1417 nfsi->ncommit <= (nfsi->npages >> 1))
1418 goto out_mark_dirty;
1419
Trond Myklebust5bad5ab2010-02-19 17:02:24 -08001420 if (wbc->nonblocking || wbc->for_background)
Trond Myklebust420e3642010-02-19 17:00:02 -08001421 flags = 0;
1422 ret = nfs_commit_inode(inode, flags);
1423 if (ret >= 0) {
1424 if (wbc->sync_mode == WB_SYNC_NONE) {
1425 if (ret < wbc->nr_to_write)
1426 wbc->nr_to_write -= ret;
1427 else
1428 wbc->nr_to_write = 0;
1429 }
Trond Myklebust8fc795f2010-02-19 16:46:56 -08001430 return 0;
Trond Myklebust420e3642010-02-19 17:00:02 -08001431 }
1432out_mark_dirty:
Trond Myklebust8fc795f2010-02-19 16:46:56 -08001433 __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
1434 return ret;
1435}
Trond Myklebustc63c7b02007-04-02 19:29:52 -04001436#else
Trond Myklebust7f2f12d2010-02-19 17:03:28 -08001437static int nfs_commit_inode(struct inode *inode, int how)
Trond Myklebustc63c7b02007-04-02 19:29:52 -04001438{
1439 return 0;
1440}
Trond Myklebust8fc795f2010-02-19 16:46:56 -08001441
1442static int nfs_commit_unstable_pages(struct inode *inode, struct writeback_control *wbc)
1443{
1444 return 0;
1445}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446#endif
1447
Trond Myklebust8fc795f2010-02-19 16:46:56 -08001448int nfs_write_inode(struct inode *inode, struct writeback_control *wbc)
1449{
1450 return nfs_commit_unstable_pages(inode, wbc);
1451}
1452
Trond Myklebustacdc53b2010-02-19 17:03:26 -08001453/*
1454 * flush the inode to disk.
1455 */
1456int nfs_wb_all(struct inode *inode)
Trond Myklebust34901f72007-07-25 14:09:54 -04001457{
1458 struct writeback_control wbc = {
Trond Myklebust72cb77f2009-03-11 14:10:30 -04001459 .sync_mode = WB_SYNC_ALL,
Trond Myklebust34901f72007-07-25 14:09:54 -04001460 .nr_to_write = LONG_MAX,
Trond Myklebustd7fb1202008-10-06 20:08:56 -04001461 .range_start = 0,
1462 .range_end = LLONG_MAX,
Trond Myklebust34901f72007-07-25 14:09:54 -04001463 };
Trond Myklebust34901f72007-07-25 14:09:54 -04001464
Trond Myklebustacdc53b2010-02-19 17:03:26 -08001465 return sync_inode(inode, &wbc);
Trond Myklebust1c759502006-10-09 16:18:38 -04001466}
1467
Trond Myklebust1b3b4a12007-08-28 10:29:36 -04001468int nfs_wb_page_cancel(struct inode *inode, struct page *page)
1469{
1470 struct nfs_page *req;
Trond Myklebust1b3b4a12007-08-28 10:29:36 -04001471 int ret = 0;
1472
1473 BUG_ON(!PageLocked(page));
1474 for (;;) {
Trond Myklebustba8b06e2010-04-27 18:33:54 -04001475 wait_on_page_writeback(page);
Trond Myklebust1b3b4a12007-08-28 10:29:36 -04001476 req = nfs_page_find_request(page);
1477 if (req == NULL)
Trond Myklebust1b3b4a12007-08-28 10:29:36 -04001478 break;
Trond Myklebust1b3b4a12007-08-28 10:29:36 -04001479 if (nfs_lock_request_dontget(req)) {
1480 nfs_inode_remove_request(req);
1481 /*
1482 * In case nfs_inode_remove_request has marked the
1483 * page as being dirty
1484 */
1485 cancel_dirty_page(page, PAGE_CACHE_SIZE);
1486 nfs_unlock_request(req);
1487 break;
1488 }
1489 ret = nfs_wait_on_request(req);
Trond Myklebustc9edda72010-01-26 15:41:34 -05001490 nfs_release_request(req);
Trond Myklebust1b3b4a12007-08-28 10:29:36 -04001491 if (ret < 0)
Trond Myklebustc9889502010-02-19 17:03:21 -08001492 break;
Trond Myklebust1b3b4a12007-08-28 10:29:36 -04001493 }
Trond Myklebust1b3b4a12007-08-28 10:29:36 -04001494 return ret;
1495}
1496
Trond Myklebust7f2f12d2010-02-19 17:03:28 -08001497/*
1498 * Write back all requests on one page - we do this before reading it.
1499 */
1500int nfs_wb_page(struct inode *inode, struct page *page)
Trond Myklebust1c759502006-10-09 16:18:38 -04001501{
1502 loff_t range_start = page_offset(page);
1503 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
Trond Myklebust4d770cc2006-12-05 00:35:41 -05001504 struct writeback_control wbc = {
Trond Myklebust4d770cc2006-12-05 00:35:41 -05001505 .sync_mode = WB_SYNC_ALL,
Trond Myklebust7f2f12d2010-02-19 17:03:28 -08001506 .nr_to_write = 0,
Trond Myklebust4d770cc2006-12-05 00:35:41 -05001507 .range_start = range_start,
1508 .range_end = range_end,
1509 };
1510 int ret;
Trond Myklebust1c759502006-10-09 16:18:38 -04001511
Trond Myklebust7f2f12d2010-02-19 17:03:28 -08001512 while(PagePrivate(page)) {
Trond Myklebustba8b06e2010-04-27 18:33:54 -04001513 wait_on_page_writeback(page);
Trond Myklebust73e33022008-04-11 16:03:54 -04001514 if (clear_page_dirty_for_io(page)) {
1515 ret = nfs_writepage_locked(page, &wbc);
1516 if (ret < 0)
1517 goto out_error;
Trond Myklebust7f2f12d2010-02-19 17:03:28 -08001518 }
Trond Myklebustba8b06e2010-04-27 18:33:54 -04001519 ret = sync_inode(inode, &wbc);
1520 if (ret < 0)
Trond Myklebust73e33022008-04-11 16:03:54 -04001521 goto out_error;
Trond Myklebust7f2f12d2010-02-19 17:03:28 -08001522 }
Trond Myklebust73e33022008-04-11 16:03:54 -04001523 return 0;
1524out_error:
Trond Myklebust4d770cc2006-12-05 00:35:41 -05001525 return ret;
Trond Myklebust1c759502006-10-09 16:18:38 -04001526}
1527
Trond Myklebust074cc1d2009-08-10 08:54:13 -04001528#ifdef CONFIG_MIGRATION
1529int nfs_migrate_page(struct address_space *mapping, struct page *newpage,
1530 struct page *page)
1531{
1532 struct nfs_page *req;
1533 int ret;
1534
Trond Myklebust7549ad52010-02-08 09:32:34 -05001535 nfs_fscache_release_page(page, GFP_KERNEL);
Trond Myklebust074cc1d2009-08-10 08:54:13 -04001536
1537 req = nfs_find_and_lock_request(page);
1538 ret = PTR_ERR(req);
1539 if (IS_ERR(req))
1540 goto out;
1541
1542 ret = migrate_page(mapping, newpage, page);
1543 if (!req)
1544 goto out;
1545 if (ret)
1546 goto out_unlock;
1547 page_cache_get(newpage);
Trond Myklebust190f38e2009-12-10 09:05:55 -05001548 spin_lock(&mapping->host->i_lock);
Trond Myklebust074cc1d2009-08-10 08:54:13 -04001549 req->wb_page = newpage;
1550 SetPagePrivate(newpage);
Trond Myklebust190f38e2009-12-10 09:05:55 -05001551 set_page_private(newpage, (unsigned long)req);
Trond Myklebust074cc1d2009-08-10 08:54:13 -04001552 ClearPagePrivate(page);
1553 set_page_private(page, 0);
Trond Myklebust190f38e2009-12-10 09:05:55 -05001554 spin_unlock(&mapping->host->i_lock);
Trond Myklebust074cc1d2009-08-10 08:54:13 -04001555 page_cache_release(page);
1556out_unlock:
1557 nfs_clear_page_tag_locked(req);
Trond Myklebust074cc1d2009-08-10 08:54:13 -04001558out:
1559 return ret;
1560}
1561#endif
1562
David Howellsf7b422b2006-06-09 09:34:33 -04001563int __init nfs_init_writepagecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564{
1565 nfs_wdata_cachep = kmem_cache_create("nfs_write_data",
1566 sizeof(struct nfs_write_data),
1567 0, SLAB_HWCACHE_ALIGN,
Paul Mundt20c2df82007-07-20 10:11:58 +09001568 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569 if (nfs_wdata_cachep == NULL)
1570 return -ENOMEM;
1571
Matthew Dobson93d23412006-03-26 01:37:50 -08001572 nfs_wdata_mempool = mempool_create_slab_pool(MIN_POOL_WRITE,
1573 nfs_wdata_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 if (nfs_wdata_mempool == NULL)
1575 return -ENOMEM;
1576
Matthew Dobson93d23412006-03-26 01:37:50 -08001577 nfs_commit_mempool = mempool_create_slab_pool(MIN_POOL_COMMIT,
1578 nfs_wdata_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 if (nfs_commit_mempool == NULL)
1580 return -ENOMEM;
1581
Peter Zijlstra89a09142007-03-16 13:38:26 -08001582 /*
1583 * NFS congestion size, scale with available memory.
1584 *
1585 * 64MB: 8192k
1586 * 128MB: 11585k
1587 * 256MB: 16384k
1588 * 512MB: 23170k
1589 * 1GB: 32768k
1590 * 2GB: 46340k
1591 * 4GB: 65536k
1592 * 8GB: 92681k
1593 * 16GB: 131072k
1594 *
1595 * This allows larger machines to have larger/more transfers.
1596 * Limit the default to 256M
1597 */
1598 nfs_congestion_kb = (16*int_sqrt(totalram_pages)) << (PAGE_SHIFT-10);
1599 if (nfs_congestion_kb > 256*1024)
1600 nfs_congestion_kb = 256*1024;
1601
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 return 0;
1603}
1604
David Brownell266bee82006-06-27 12:59:15 -07001605void nfs_destroy_writepagecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606{
1607 mempool_destroy(nfs_commit_mempool);
1608 mempool_destroy(nfs_wdata_mempool);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001609 kmem_cache_destroy(nfs_wdata_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610}
1611