blob: a34fae21fe109c8dc9fd8a90e8b8123b937d5ee3 [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 Myklebust1ae88b22009-08-12 09:12:30 -040090void 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 Myklebust1ae88b22009-08-12 09:12:30 -040097static void nfs_writedata_release(struct nfs_write_data *wdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -070098{
Trond Myklebust383ba712008-02-19 20:04:20 -050099 put_nfs_open_context(wdata->args.context);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 nfs_writedata_free(wdata);
101}
102
Trond Myklebust7b159fc2007-07-25 14:09:54 -0400103static void nfs_context_set_write_error(struct nfs_open_context *ctx, int error)
104{
105 ctx->error = error;
106 smp_wmb();
107 set_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
108}
109
Trond Myklebust277459d2006-12-05 00:35:35 -0500110static struct nfs_page *nfs_page_find_request_locked(struct page *page)
111{
112 struct nfs_page *req = NULL;
113
114 if (PagePrivate(page)) {
115 req = (struct nfs_page *)page_private(page);
116 if (req != NULL)
Trond Myklebustc03b4022007-06-17 13:26:38 -0400117 kref_get(&req->wb_kref);
Trond Myklebust277459d2006-12-05 00:35:35 -0500118 }
119 return req;
120}
121
122static struct nfs_page *nfs_page_find_request(struct page *page)
123{
Trond Myklebust587142f2007-07-02 09:57:54 -0400124 struct inode *inode = page->mapping->host;
Trond Myklebust277459d2006-12-05 00:35:35 -0500125 struct nfs_page *req = NULL;
Trond Myklebust277459d2006-12-05 00:35:35 -0500126
Trond Myklebust587142f2007-07-02 09:57:54 -0400127 spin_lock(&inode->i_lock);
Trond Myklebust277459d2006-12-05 00:35:35 -0500128 req = nfs_page_find_request_locked(page);
Trond Myklebust587142f2007-07-02 09:57:54 -0400129 spin_unlock(&inode->i_lock);
Trond Myklebust277459d2006-12-05 00:35:35 -0500130 return req;
131}
132
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133/* Adjust the file length if we're writing beyond the end */
134static void nfs_grow_file(struct page *page, unsigned int offset, unsigned int count)
135{
136 struct inode *inode = page->mapping->host;
Trond Myklebusta3d01452008-06-11 12:21:19 -0400137 loff_t end, i_size;
138 pgoff_t end_index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139
Trond Myklebusta3d01452008-06-11 12:21:19 -0400140 spin_lock(&inode->i_lock);
141 i_size = i_size_read(inode);
142 end_index = (i_size - 1) >> PAGE_CACHE_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 if (i_size > 0 && page->index < end_index)
Trond Myklebusta3d01452008-06-11 12:21:19 -0400144 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 end = ((loff_t)page->index << PAGE_CACHE_SHIFT) + ((loff_t)offset+count);
146 if (i_size >= end)
Trond Myklebusta3d01452008-06-11 12:21:19 -0400147 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 i_size_write(inode, end);
Trond Myklebusta3d01452008-06-11 12:21:19 -0400149 nfs_inc_stats(inode, NFSIOS_EXTENDWRITE);
150out:
151 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152}
153
Trond Myklebusta301b772007-02-06 11:07:15 -0800154/* A writeback failed: mark the page as bad, and invalidate the page cache */
155static void nfs_set_pageerror(struct page *page)
156{
157 SetPageError(page);
158 nfs_zap_mapping(page->mapping->host, page->mapping);
159}
160
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161/* We can set the PG_uptodate flag if we see that a write request
162 * covers the full page.
163 */
164static void nfs_mark_uptodate(struct page *page, unsigned int base, unsigned int count)
165{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 if (PageUptodate(page))
167 return;
168 if (base != 0)
169 return;
Trond Myklebust49a70f22006-12-05 00:35:38 -0500170 if (count != nfs_page_length(page))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 return;
Trond Myklebust49a70f22006-12-05 00:35:38 -0500172 SetPageUptodate(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173}
174
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175static int wb_priority(struct writeback_control *wbc)
176{
177 if (wbc->for_reclaim)
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400178 return FLUSH_HIGHPRI | FLUSH_STABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 if (wbc->for_kupdate)
180 return FLUSH_LOWPRI;
181 return 0;
182}
183
184/*
Peter Zijlstra89a09142007-03-16 13:38:26 -0800185 * NFS congestion control
186 */
187
188int nfs_congestion_kb;
189
190#define NFS_CONGESTION_ON_THRESH (nfs_congestion_kb >> (PAGE_SHIFT-10))
191#define NFS_CONGESTION_OFF_THRESH \
192 (NFS_CONGESTION_ON_THRESH - (NFS_CONGESTION_ON_THRESH >> 2))
193
Trond Myklebust5a6d41b2007-04-14 19:10:12 -0400194static int nfs_set_page_writeback(struct page *page)
Peter Zijlstra89a09142007-03-16 13:38:26 -0800195{
Trond Myklebust5a6d41b2007-04-14 19:10:12 -0400196 int ret = test_set_page_writeback(page);
197
198 if (!ret) {
Peter Zijlstra89a09142007-03-16 13:38:26 -0800199 struct inode *inode = page->mapping->host;
200 struct nfs_server *nfss = NFS_SERVER(inode);
201
Peter Zijlstra277866a2007-05-08 00:35:12 -0700202 if (atomic_long_inc_return(&nfss->writeback) >
Jens Axboe8aa7e842009-07-09 14:52:32 +0200203 NFS_CONGESTION_ON_THRESH) {
204 set_bdi_congested(&nfss->backing_dev_info,
205 BLK_RW_ASYNC);
206 }
Peter Zijlstra89a09142007-03-16 13:38:26 -0800207 }
Trond Myklebust5a6d41b2007-04-14 19:10:12 -0400208 return ret;
Peter Zijlstra89a09142007-03-16 13:38:26 -0800209}
210
211static void nfs_end_page_writeback(struct page *page)
212{
213 struct inode *inode = page->mapping->host;
214 struct nfs_server *nfss = NFS_SERVER(inode);
215
216 end_page_writeback(page);
Peter Zijlstrac4dc4be2007-10-16 23:25:41 -0700217 if (atomic_long_dec_return(&nfss->writeback) < NFS_CONGESTION_OFF_THRESH)
Jens Axboe8aa7e842009-07-09 14:52:32 +0200218 clear_bdi_congested(&nfss->backing_dev_info, BLK_RW_ASYNC);
Peter Zijlstra89a09142007-03-16 13:38:26 -0800219}
220
221/*
Trond Myklebuste261f512006-12-05 00:35:41 -0500222 * Find an associated nfs write request, and prepare to flush it out
Trond Myklebust9cccef92007-07-22 17:09:05 -0400223 * May return an error if the user signalled nfs_wait_on_request().
Trond Myklebuste261f512006-12-05 00:35:41 -0500224 */
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400225static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio,
226 struct page *page)
Trond Myklebuste261f512006-12-05 00:35:41 -0500227{
Trond Myklebust587142f2007-07-02 09:57:54 -0400228 struct inode *inode = page->mapping->host;
Trond Myklebuste261f512006-12-05 00:35:41 -0500229 struct nfs_page *req;
Trond Myklebuste261f512006-12-05 00:35:41 -0500230 int ret;
231
Trond Myklebust587142f2007-07-02 09:57:54 -0400232 spin_lock(&inode->i_lock);
Trond Myklebuste261f512006-12-05 00:35:41 -0500233 for(;;) {
234 req = nfs_page_find_request_locked(page);
235 if (req == NULL) {
Trond Myklebust587142f2007-07-02 09:57:54 -0400236 spin_unlock(&inode->i_lock);
Trond Myklebust9cccef92007-07-22 17:09:05 -0400237 return 0;
Trond Myklebuste261f512006-12-05 00:35:41 -0500238 }
Trond Myklebustacee4782008-01-22 17:13:07 -0500239 if (nfs_set_page_tag_locked(req))
Trond Myklebuste261f512006-12-05 00:35:41 -0500240 break;
241 /* Note: If we hold the page lock, as is the case in nfs_writepage,
Trond Myklebustacee4782008-01-22 17:13:07 -0500242 * then the call to nfs_set_page_tag_locked() will always
Trond Myklebuste261f512006-12-05 00:35:41 -0500243 * succeed provided that someone hasn't already marked the
244 * request as dirty (in which case we don't care).
245 */
Trond Myklebust587142f2007-07-02 09:57:54 -0400246 spin_unlock(&inode->i_lock);
Trond Myklebuste261f512006-12-05 00:35:41 -0500247 ret = nfs_wait_on_request(req);
248 nfs_release_request(req);
249 if (ret != 0)
250 return ret;
Trond Myklebust587142f2007-07-02 09:57:54 -0400251 spin_lock(&inode->i_lock);
Trond Myklebuste261f512006-12-05 00:35:41 -0500252 }
Trond Myklebuste468bae2008-06-13 13:25:22 -0400253 if (test_bit(PG_CLEAN, &req->wb_flags)) {
Trond Myklebust587142f2007-07-02 09:57:54 -0400254 spin_unlock(&inode->i_lock);
Trond Myklebuste468bae2008-06-13 13:25:22 -0400255 BUG();
Trond Myklebust612c9382007-04-20 16:12:45 -0400256 }
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400257 if (nfs_set_page_writeback(page) != 0) {
Trond Myklebust587142f2007-07-02 09:57:54 -0400258 spin_unlock(&inode->i_lock);
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400259 BUG();
260 }
Trond Myklebust587142f2007-07-02 09:57:54 -0400261 spin_unlock(&inode->i_lock);
Fred Isamanf8512ad2008-03-19 11:24:39 -0400262 if (!nfs_pageio_add_request(pgio, req)) {
263 nfs_redirty_request(req);
Fred Isamanf8512ad2008-03-19 11:24:39 -0400264 return pgio->pg_error;
265 }
Trond Myklebust9cccef92007-07-22 17:09:05 -0400266 return 0;
Trond Myklebuste261f512006-12-05 00:35:41 -0500267}
268
Trond Myklebustf758c8852007-07-22 19:27:32 -0400269static int nfs_do_writepage(struct page *page, struct writeback_control *wbc, struct nfs_pageio_descriptor *pgio)
270{
271 struct inode *inode = page->mapping->host;
272
273 nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE);
274 nfs_add_stats(inode, NFSIOS_WRITEPAGES, 1);
275
276 nfs_pageio_cond_complete(pgio, page->index);
277 return nfs_page_async_flush(pgio, page);
278}
279
Trond Myklebuste261f512006-12-05 00:35:41 -0500280/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 * Write an mmapped page to the server.
282 */
Trond Myklebust4d770cc2006-12-05 00:35:41 -0500283static int nfs_writepage_locked(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284{
Trond Myklebustf758c8852007-07-22 19:27:32 -0400285 struct nfs_pageio_descriptor pgio;
Trond Myklebuste261f512006-12-05 00:35:41 -0500286 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
Trond Myklebustf758c8852007-07-22 19:27:32 -0400288 nfs_pageio_init_write(&pgio, page->mapping->host, wb_priority(wbc));
289 err = nfs_do_writepage(page, wbc, &pgio);
290 nfs_pageio_complete(&pgio);
291 if (err < 0)
292 return err;
293 if (pgio.pg_error < 0)
294 return pgio.pg_error;
295 return 0;
Trond Myklebust4d770cc2006-12-05 00:35:41 -0500296}
297
298int nfs_writepage(struct page *page, struct writeback_control *wbc)
299{
Trond Myklebustf758c8852007-07-22 19:27:32 -0400300 int ret;
Trond Myklebust4d770cc2006-12-05 00:35:41 -0500301
Trond Myklebustf758c8852007-07-22 19:27:32 -0400302 ret = nfs_writepage_locked(page, wbc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 unlock_page(page);
Trond Myklebustf758c8852007-07-22 19:27:32 -0400304 return ret;
305}
306
307static int nfs_writepages_callback(struct page *page, struct writeback_control *wbc, void *data)
308{
309 int ret;
310
311 ret = nfs_do_writepage(page, wbc, data);
312 unlock_page(page);
313 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314}
315
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316int nfs_writepages(struct address_space *mapping, struct writeback_control *wbc)
317{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 struct inode *inode = mapping->host;
Trond Myklebust72cb77f2009-03-11 14:10:30 -0400319 unsigned long *bitlock = &NFS_I(inode)->flags;
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400320 struct nfs_pageio_descriptor pgio;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 int err;
322
Trond Myklebust72cb77f2009-03-11 14:10:30 -0400323 /* Stop dirtying of new pages while we sync */
324 err = wait_on_bit_lock(bitlock, NFS_INO_FLUSHING,
325 nfs_wait_bit_killable, TASK_KILLABLE);
326 if (err)
327 goto out_err;
328
Chuck Lever91d5b472006-03-20 13:44:14 -0500329 nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGES);
330
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400331 nfs_pageio_init_write(&pgio, inode, wb_priority(wbc));
Trond Myklebustf758c8852007-07-22 19:27:32 -0400332 err = write_cache_pages(mapping, wbc, nfs_writepages_callback, &pgio);
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400333 nfs_pageio_complete(&pgio);
Trond Myklebust72cb77f2009-03-11 14:10:30 -0400334
335 clear_bit_unlock(NFS_INO_FLUSHING, bitlock);
336 smp_mb__after_clear_bit();
337 wake_up_bit(bitlock, NFS_INO_FLUSHING);
338
Trond Myklebustf758c8852007-07-22 19:27:32 -0400339 if (err < 0)
Trond Myklebust72cb77f2009-03-11 14:10:30 -0400340 goto out_err;
341 err = pgio.pg_error;
342 if (err < 0)
343 goto out_err;
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400344 return 0;
Trond Myklebust72cb77f2009-03-11 14:10:30 -0400345out_err:
346 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347}
348
349/*
350 * Insert a write request into an inode
351 */
Trond Myklebuste7d39062008-06-13 12:12:32 -0400352static int nfs_inode_add_request(struct inode *inode, struct nfs_page *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353{
354 struct nfs_inode *nfsi = NFS_I(inode);
355 int error;
356
Trond Myklebuste7d39062008-06-13 12:12:32 -0400357 error = radix_tree_preload(GFP_NOFS);
358 if (error != 0)
359 goto out;
360
361 /* Lock the request! */
362 nfs_lock_request_dontget(req);
363
364 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 error = radix_tree_insert(&nfsi->nfs_page_tree, req->wb_index, req);
Nick Piggin27852592008-02-04 23:48:37 -0800366 BUG_ON(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 if (!nfsi->npages) {
368 igrab(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 if (nfs_have_delegation(inode, FMODE_WRITE))
370 nfsi->change_attr++;
371 }
Trond Myklebustdeb7d632006-03-20 13:44:50 -0500372 SetPagePrivate(req->wb_page);
Trond Myklebust277459d2006-12-05 00:35:35 -0500373 set_page_private(req->wb_page, (unsigned long)req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 nfsi->npages++;
Trond Myklebustc03b4022007-06-17 13:26:38 -0400375 kref_get(&req->wb_kref);
Nick Piggin27852592008-02-04 23:48:37 -0800376 radix_tree_tag_set(&nfsi->nfs_page_tree, req->wb_index,
377 NFS_PAGE_TAG_LOCKED);
Trond Myklebuste7d39062008-06-13 12:12:32 -0400378 spin_unlock(&inode->i_lock);
379 radix_tree_preload_end();
380out:
381 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382}
383
384/*
Peter Zijlstra89a09142007-03-16 13:38:26 -0800385 * Remove a write request from an inode
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 */
387static void nfs_inode_remove_request(struct nfs_page *req)
388{
Trond Myklebust88be9f92007-06-05 10:42:27 -0400389 struct inode *inode = req->wb_context->path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 struct nfs_inode *nfsi = NFS_I(inode);
391
392 BUG_ON (!NFS_WBACK_BUSY(req));
393
Trond Myklebust587142f2007-07-02 09:57:54 -0400394 spin_lock(&inode->i_lock);
Trond Myklebust277459d2006-12-05 00:35:35 -0500395 set_page_private(req->wb_page, 0);
Trond Myklebustdeb7d632006-03-20 13:44:50 -0500396 ClearPagePrivate(req->wb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 radix_tree_delete(&nfsi->nfs_page_tree, req->wb_index);
398 nfsi->npages--;
399 if (!nfsi->npages) {
Trond Myklebust587142f2007-07-02 09:57:54 -0400400 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 iput(inode);
402 } else
Trond Myklebust587142f2007-07-02 09:57:54 -0400403 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 nfs_clear_request(req);
405 nfs_release_request(req);
406}
407
Trond Myklebust61822ab2006-12-05 00:35:42 -0500408static void
Fred6d884e82008-03-19 11:24:38 -0400409nfs_mark_request_dirty(struct nfs_page *req)
Trond Myklebust61822ab2006-12-05 00:35:42 -0500410{
Trond Myklebust61822ab2006-12-05 00:35:42 -0500411 __set_page_dirty_nobuffers(req->wb_page);
412}
413
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
415/*
416 * Add a request to the inode's commit list.
417 */
418static void
419nfs_mark_request_commit(struct nfs_page *req)
420{
Trond Myklebust88be9f92007-06-05 10:42:27 -0400421 struct inode *inode = req->wb_context->path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 struct nfs_inode *nfsi = NFS_I(inode);
423
Trond Myklebust587142f2007-07-02 09:57:54 -0400424 spin_lock(&inode->i_lock);
Trond Myklebuste468bae2008-06-13 13:25:22 -0400425 set_bit(PG_CLEAN, &(req)->wb_flags);
Trond Myklebust5c369682007-06-17 15:27:42 -0400426 radix_tree_tag_set(&nfsi->nfs_page_tree,
427 req->wb_index,
428 NFS_PAGE_TAG_COMMIT);
Trond Myklebust587142f2007-07-02 09:57:54 -0400429 spin_unlock(&inode->i_lock);
Christoph Lameterfd39fc82006-06-30 01:55:40 -0700430 inc_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
Peter Zijlstrac9e51e42007-10-16 23:25:47 -0700431 inc_bdi_stat(req->wb_page->mapping->backing_dev_info, BDI_RECLAIMABLE);
Trond Myklebusta1803042006-12-05 00:45:19 -0500432 __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433}
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400434
Trond Myklebuste468bae2008-06-13 13:25:22 -0400435static int
436nfs_clear_request_commit(struct nfs_page *req)
437{
438 struct page *page = req->wb_page;
439
440 if (test_and_clear_bit(PG_CLEAN, &(req)->wb_flags)) {
441 dec_zone_page_state(page, NR_UNSTABLE_NFS);
442 dec_bdi_stat(page->mapping->backing_dev_info, BDI_RECLAIMABLE);
443 return 1;
444 }
445 return 0;
446}
447
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400448static inline
449int nfs_write_need_commit(struct nfs_write_data *data)
450{
451 return data->verf.committed != NFS_FILE_SYNC;
452}
453
454static inline
455int nfs_reschedule_unstable_write(struct nfs_page *req)
456{
Trond Myklebuste468bae2008-06-13 13:25:22 -0400457 if (test_and_clear_bit(PG_NEED_COMMIT, &req->wb_flags)) {
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400458 nfs_mark_request_commit(req);
459 return 1;
460 }
461 if (test_and_clear_bit(PG_NEED_RESCHED, &req->wb_flags)) {
Fred6d884e82008-03-19 11:24:38 -0400462 nfs_mark_request_dirty(req);
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400463 return 1;
464 }
465 return 0;
466}
467#else
468static inline void
469nfs_mark_request_commit(struct nfs_page *req)
470{
471}
472
Trond Myklebuste468bae2008-06-13 13:25:22 -0400473static inline int
474nfs_clear_request_commit(struct nfs_page *req)
475{
476 return 0;
477}
478
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400479static inline
480int nfs_write_need_commit(struct nfs_write_data *data)
481{
482 return 0;
483}
484
485static inline
486int nfs_reschedule_unstable_write(struct nfs_page *req)
487{
488 return 0;
489}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490#endif
491
492/*
493 * Wait for a request to complete.
494 *
Matthew Wilcox150030b2007-12-06 16:24:39 -0500495 * Interruptible by fatal signals only.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 */
Trond Myklebustca52fec2007-04-17 17:22:13 -0400497static int nfs_wait_on_requests_locked(struct inode *inode, pgoff_t idx_start, unsigned int npages)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498{
499 struct nfs_inode *nfsi = NFS_I(inode);
500 struct nfs_page *req;
Trond Myklebustca52fec2007-04-17 17:22:13 -0400501 pgoff_t idx_end, next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 unsigned int res = 0;
503 int error;
504
505 if (npages == 0)
506 idx_end = ~0;
507 else
508 idx_end = idx_start + npages - 1;
509
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 next = idx_start;
Trond Myklebust9fd367f2007-06-17 15:10:24 -0400511 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 -0700512 if (req->wb_index > idx_end)
513 break;
514
515 next = req->wb_index + 1;
Trond Myklebustc6a556b2005-06-22 17:16:30 +0000516 BUG_ON(!NFS_WBACK_BUSY(req));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517
Trond Myklebustc03b4022007-06-17 13:26:38 -0400518 kref_get(&req->wb_kref);
Trond Myklebust587142f2007-07-02 09:57:54 -0400519 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 error = nfs_wait_on_request(req);
521 nfs_release_request(req);
Trond Myklebust587142f2007-07-02 09:57:54 -0400522 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 if (error < 0)
524 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 res++;
526 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 return res;
528}
529
Trond Myklebust83715ad2006-07-05 13:17:12 -0400530static void nfs_cancel_commit_list(struct list_head *head)
531{
532 struct nfs_page *req;
533
534 while(!list_empty(head)) {
535 req = nfs_list_entry(head->next);
536 nfs_list_remove_request(req);
Trond Myklebuste468bae2008-06-13 13:25:22 -0400537 nfs_clear_request_commit(req);
Trond Myklebust83715ad2006-07-05 13:17:12 -0400538 nfs_inode_remove_request(req);
Trond Myklebustb6dff262006-10-19 23:28:38 -0700539 nfs_unlock_request(req);
Trond Myklebust83715ad2006-07-05 13:17:12 -0400540 }
541}
542
Trond Myklebust47c62562009-03-16 08:13:41 -0400543#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
Trond Myklebustfb8a1f12009-03-11 14:10:29 -0400544static int
545nfs_need_commit(struct nfs_inode *nfsi)
546{
547 return radix_tree_tagged(&nfsi->nfs_page_tree, NFS_PAGE_TAG_COMMIT);
548}
549
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550/*
551 * nfs_scan_commit - Scan an inode for commit requests
552 * @inode: NFS inode to scan
553 * @dst: destination list
554 * @idx_start: lower bound of page->index to scan.
555 * @npages: idx_start + npages sets the upper bound to scan.
556 *
557 * Moves requests from the inode's 'commit' request list.
558 * The requests are *not* checked to ensure that they form a contiguous set.
559 */
560static int
Trond Myklebustca52fec2007-04-17 17:22:13 -0400561nfs_scan_commit(struct inode *inode, struct list_head *dst, pgoff_t idx_start, unsigned int npages)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562{
563 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebust3da28eb2005-06-22 17:16:31 +0000564
Trond Myklebustfb8a1f12009-03-11 14:10:29 -0400565 if (!nfs_need_commit(nfsi))
566 return 0;
567
568 return nfs_scan_list(nfsi, dst, idx_start, npages, NFS_PAGE_TAG_COMMIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569}
Trond Myklebustc42de9d2006-03-20 13:44:51 -0500570#else
Trond Myklebustfb8a1f12009-03-11 14:10:29 -0400571static inline int nfs_need_commit(struct nfs_inode *nfsi)
572{
573 return 0;
574}
575
Trond Myklebustca52fec2007-04-17 17:22:13 -0400576static 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 -0500577{
578 return 0;
579}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580#endif
581
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582/*
Trond Myklebuste7d39062008-06-13 12:12:32 -0400583 * Search for an existing write request, and attempt to update
584 * it to reflect a new dirty region on a given page.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 *
Trond Myklebuste7d39062008-06-13 12:12:32 -0400586 * If the attempt fails, then the existing request is flushed out
587 * to disk.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 */
Trond Myklebuste7d39062008-06-13 12:12:32 -0400589static struct nfs_page *nfs_try_to_update_request(struct inode *inode,
590 struct page *page,
591 unsigned int offset,
592 unsigned int bytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593{
Trond Myklebuste7d39062008-06-13 12:12:32 -0400594 struct nfs_page *req;
595 unsigned int rqend;
596 unsigned int end;
597 int error;
598
599 if (!PagePrivate(page))
600 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
602 end = offset + bytes;
Trond Myklebuste7d39062008-06-13 12:12:32 -0400603 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 for (;;) {
Trond Myklebust277459d2006-12-05 00:35:35 -0500606 req = nfs_page_find_request_locked(page);
Trond Myklebuste7d39062008-06-13 12:12:32 -0400607 if (req == NULL)
608 goto out_unlock;
Trond Myklebust277459d2006-12-05 00:35:35 -0500609
Trond Myklebuste7d39062008-06-13 12:12:32 -0400610 rqend = req->wb_offset + req->wb_bytes;
611 /*
612 * Tell the caller to flush out the request if
613 * the offsets are non-contiguous.
614 * Note: nfs_flush_incompatible() will already
615 * have flushed out requests having wrong owners.
616 */
Trond Myklebuste468bae2008-06-13 13:25:22 -0400617 if (offset > rqend
Trond Myklebuste7d39062008-06-13 12:12:32 -0400618 || end < req->wb_offset)
619 goto out_flushme;
620
621 if (nfs_set_page_tag_locked(req))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623
Trond Myklebuste7d39062008-06-13 12:12:32 -0400624 /* The request is locked, so wait and then retry */
Trond Myklebust587142f2007-07-02 09:57:54 -0400625 spin_unlock(&inode->i_lock);
Trond Myklebuste7d39062008-06-13 12:12:32 -0400626 error = nfs_wait_on_request(req);
627 nfs_release_request(req);
628 if (error != 0)
629 goto out_err;
630 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 }
632
Trond Myklebuste468bae2008-06-13 13:25:22 -0400633 if (nfs_clear_request_commit(req))
634 radix_tree_tag_clear(&NFS_I(inode)->nfs_page_tree,
635 req->wb_index, NFS_PAGE_TAG_COMMIT);
636
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 /* Okay, the request matches. Update the region */
638 if (offset < req->wb_offset) {
639 req->wb_offset = offset;
640 req->wb_pgbase = offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 if (end > rqend)
643 req->wb_bytes = end - req->wb_offset;
Trond Myklebuste7d39062008-06-13 12:12:32 -0400644 else
645 req->wb_bytes = rqend - req->wb_offset;
646out_unlock:
647 spin_unlock(&inode->i_lock);
648 return req;
649out_flushme:
650 spin_unlock(&inode->i_lock);
651 nfs_release_request(req);
652 error = nfs_wb_page(inode, page);
653out_err:
654 return ERR_PTR(error);
655}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
Trond Myklebuste7d39062008-06-13 12:12:32 -0400657/*
658 * Try to update an existing write request, or create one if there is none.
659 *
660 * Note: Should always be called with the Page Lock held to prevent races
661 * if we have to add a new request. Also assumes that the caller has
662 * already called nfs_flush_incompatible() if necessary.
663 */
664static struct nfs_page * nfs_setup_write_request(struct nfs_open_context* ctx,
665 struct page *page, unsigned int offset, unsigned int bytes)
666{
667 struct inode *inode = page->mapping->host;
668 struct nfs_page *req;
669 int error;
670
671 req = nfs_try_to_update_request(inode, page, offset, bytes);
672 if (req != NULL)
673 goto out;
674 req = nfs_create_request(ctx, inode, page, offset, bytes);
675 if (IS_ERR(req))
676 goto out;
677 error = nfs_inode_add_request(inode, req);
678 if (error != 0) {
679 nfs_release_request(req);
680 req = ERR_PTR(error);
681 }
Trond Myklebustefc91ed2008-06-10 18:31:00 -0400682out:
Trond Myklebust61e930a2007-10-18 17:08:05 -0400683 return req;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684}
685
Trond Myklebuste7d39062008-06-13 12:12:32 -0400686static int nfs_writepage_setup(struct nfs_open_context *ctx, struct page *page,
687 unsigned int offset, unsigned int count)
688{
689 struct nfs_page *req;
690
691 req = nfs_setup_write_request(ctx, page, offset, count);
692 if (IS_ERR(req))
693 return PTR_ERR(req);
694 /* Update file length */
695 nfs_grow_file(page, offset, count);
696 nfs_mark_uptodate(page, req->wb_pgbase, req->wb_bytes);
697 nfs_clear_page_tag_locked(req);
698 return 0;
699}
700
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701int nfs_flush_incompatible(struct file *file, struct page *page)
702{
Trond Myklebustcd3758e2007-08-10 17:44:32 -0400703 struct nfs_open_context *ctx = nfs_file_open_context(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 struct nfs_page *req;
Trond Myklebust1a545332006-12-05 00:35:40 -0500705 int do_flush, status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 /*
707 * Look for a request corresponding to this page. If there
708 * is one, and it belongs to another file, we flush it out
709 * before we try to copy anything into the page. Do this
710 * due to the lack of an ACCESS-type call in NFSv2.
711 * Also do the same if we find a request from an existing
712 * dropped page.
713 */
Trond Myklebust1a545332006-12-05 00:35:40 -0500714 do {
715 req = nfs_page_find_request(page);
716 if (req == NULL)
717 return 0;
Trond Myklebuste468bae2008-06-13 13:25:22 -0400718 do_flush = req->wb_page != page || req->wb_context != ctx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 nfs_release_request(req);
Trond Myklebust1a545332006-12-05 00:35:40 -0500720 if (!do_flush)
721 return 0;
722 status = nfs_wb_page(page->mapping->host, page);
723 } while (status == 0);
724 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725}
726
727/*
Trond Myklebust5d47a352008-02-07 17:24:07 -0500728 * If the page cache is marked as unsafe or invalid, then we can't rely on
729 * the PageUptodate() flag. In this case, we will need to turn off
730 * write optimisations that depend on the page contents being correct.
731 */
732static int nfs_write_pageuptodate(struct page *page, struct inode *inode)
733{
734 return PageUptodate(page) &&
735 !(NFS_I(inode)->cache_validity & (NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_DATA));
736}
737
738/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 * Update and possibly write a cached page of an NFS file.
740 *
741 * XXX: Keep an eye on generic_file_read to make sure it doesn't do bad
742 * things with a page scheduled for an RPC call (e.g. invalidate it).
743 */
744int nfs_updatepage(struct file *file, struct page *page,
745 unsigned int offset, unsigned int count)
746{
Trond Myklebustcd3758e2007-08-10 17:44:32 -0400747 struct nfs_open_context *ctx = nfs_file_open_context(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 struct inode *inode = page->mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 int status = 0;
750
Chuck Lever91d5b472006-03-20 13:44:14 -0500751 nfs_inc_stats(inode, NFSIOS_VFSUPDATEPAGE);
752
Chuck Lever48186c72008-06-11 17:56:05 -0400753 dprintk("NFS: nfs_updatepage(%s/%s %d@%lld)\n",
Josef "Jeff" Sipek01cce932006-12-08 02:36:40 -0800754 file->f_path.dentry->d_parent->d_name.name,
755 file->f_path.dentry->d_name.name, count,
Chuck Lever48186c72008-06-11 17:56:05 -0400756 (long long)(page_offset(page) + offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 /* If we're not using byte range locks, and we know the page
Trond Myklebust5d47a352008-02-07 17:24:07 -0500759 * is up to date, it may be more efficient to extend the write
760 * to cover the entire page in order to avoid fragmentation
761 * inefficiencies.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 */
Trond Myklebust5d47a352008-02-07 17:24:07 -0500763 if (nfs_write_pageuptodate(page, inode) &&
764 inode->i_flock == NULL &&
Trond Myklebust4b5621f2008-02-25 15:56:29 -0800765 !(file->f_flags & O_SYNC)) {
Trond Myklebust49a70f22006-12-05 00:35:38 -0500766 count = max(count + offset, nfs_page_length(page));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 }
769
Trond Myklebuste21195a2006-12-05 00:35:39 -0500770 status = nfs_writepage_setup(ctx, page, offset, count);
Trond Myklebust03fa9e82008-06-05 16:02:35 -0400771 if (status < 0)
772 nfs_set_pageerror(page);
773 else
774 __set_page_dirty_nobuffers(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775
Chuck Lever48186c72008-06-11 17:56:05 -0400776 dprintk("NFS: nfs_updatepage returns %d (isize %lld)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 status, (long long)i_size_read(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 return status;
779}
780
781static void nfs_writepage_release(struct nfs_page *req)
782{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
Trond Myklebust7e5f6142008-05-25 12:59:19 -0400784 if (PageError(req->wb_page) || !nfs_reschedule_unstable_write(req)) {
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400785 nfs_end_page_writeback(req->wb_page);
786 nfs_inode_remove_request(req);
787 } else
788 nfs_end_page_writeback(req->wb_page);
Trond Myklebust9fd367f2007-06-17 15:10:24 -0400789 nfs_clear_page_tag_locked(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790}
791
Trond Myklebust3ff75762007-07-14 15:40:00 -0400792static int flush_task_priority(int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793{
794 switch (how & (FLUSH_HIGHPRI|FLUSH_LOWPRI)) {
795 case FLUSH_HIGHPRI:
796 return RPC_PRIORITY_HIGH;
797 case FLUSH_LOWPRI:
798 return RPC_PRIORITY_LOW;
799 }
800 return RPC_PRIORITY_NORMAL;
801}
802
803/*
804 * Set up the argument/result storage required for the RPC call.
805 */
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400806static int nfs_write_rpcsetup(struct nfs_page *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 struct nfs_write_data *data,
Trond Myklebust788e7a82006-03-20 13:44:27 -0500808 const struct rpc_call_ops *call_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 unsigned int count, unsigned int offset,
810 int how)
811{
Trond Myklebust84115e12007-07-14 15:39:59 -0400812 struct inode *inode = req->wb_context->path.dentry->d_inode;
813 int flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
Trond Myklebust3ff75762007-07-14 15:40:00 -0400814 int priority = flush_task_priority(how);
Trond Myklebust07737692007-10-25 18:42:54 -0400815 struct rpc_task *task;
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400816 struct rpc_message msg = {
817 .rpc_argp = &data->args,
818 .rpc_resp = &data->res,
819 .rpc_cred = req->wb_context->cred,
820 };
Trond Myklebust84115e12007-07-14 15:39:59 -0400821 struct rpc_task_setup task_setup_data = {
822 .rpc_client = NFS_CLIENT(inode),
Trond Myklebust07737692007-10-25 18:42:54 -0400823 .task = &data->task,
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400824 .rpc_message = &msg,
Trond Myklebust84115e12007-07-14 15:39:59 -0400825 .callback_ops = call_ops,
826 .callback_data = data,
Trond Myklebust101070c2008-02-19 20:04:23 -0500827 .workqueue = nfsiod_workqueue,
Trond Myklebust84115e12007-07-14 15:39:59 -0400828 .flags = flags,
Trond Myklebust3ff75762007-07-14 15:40:00 -0400829 .priority = priority,
Trond Myklebust84115e12007-07-14 15:39:59 -0400830 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831
832 /* Set up the RPC argument and reply structs
833 * NB: take care not to mess about with data->commit et al. */
834
835 data->req = req;
Trond Myklebust88be9f92007-06-05 10:42:27 -0400836 data->inode = inode = req->wb_context->path.dentry->d_inode;
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400837 data->cred = msg.rpc_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838
839 data->args.fh = NFS_FH(inode);
840 data->args.offset = req_offset(req) + offset;
841 data->args.pgbase = req->wb_pgbase + offset;
842 data->args.pages = data->pagevec;
843 data->args.count = count;
Trond Myklebust383ba712008-02-19 20:04:20 -0500844 data->args.context = get_nfs_open_context(req->wb_context);
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400845 data->args.stable = NFS_UNSTABLE;
846 if (how & FLUSH_STABLE) {
847 data->args.stable = NFS_DATA_SYNC;
Trond Myklebustfb8a1f12009-03-11 14:10:29 -0400848 if (!nfs_need_commit(NFS_I(inode)))
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400849 data->args.stable = NFS_FILE_SYNC;
850 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851
852 data->res.fattr = &data->fattr;
853 data->res.count = count;
854 data->res.verf = &data->verf;
Trond Myklebust0e574af2005-10-27 22:12:38 -0400855 nfs_fattr_init(&data->fattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856
Trond Myklebust788e7a82006-03-20 13:44:27 -0500857 /* Set up the initial task struct. */
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400858 NFS_PROTO(inode)->write_setup(data, &msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859
Chuck Levera3f565b2007-01-31 12:14:01 -0500860 dprintk("NFS: %5u initiated write call "
Chuck Lever48186c72008-06-11 17:56:05 -0400861 "(req %s/%lld, %u bytes @ offset %llu)\n",
Chuck Lever0bbacc42005-11-01 16:53:32 -0500862 data->task.tk_pid,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 inode->i_sb->s_id,
864 (long long)NFS_FILEID(inode),
865 count,
866 (unsigned long long)data->args.offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867
Trond Myklebust07737692007-10-25 18:42:54 -0400868 task = rpc_run_task(&task_setup_data);
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400869 if (IS_ERR(task))
870 return PTR_ERR(task);
871 rpc_put_task(task);
872 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873}
874
Fred6d884e82008-03-19 11:24:38 -0400875/* If a nfs_flush_* function fails, it should remove reqs from @head and
876 * call this on each, which will prepare them to be retried on next
877 * writeback using standard nfs.
878 */
879static void nfs_redirty_request(struct nfs_page *req)
880{
881 nfs_mark_request_dirty(req);
882 nfs_end_page_writeback(req->wb_page);
883 nfs_clear_page_tag_locked(req);
884}
885
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886/*
887 * Generate multiple small requests to write out a single
888 * contiguous dirty area on one page.
889 */
Trond Myklebust8d5658c2007-04-10 09:26:35 -0400890static 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 -0700891{
892 struct nfs_page *req = nfs_list_entry(head->next);
893 struct page *page = req->wb_page;
894 struct nfs_write_data *data;
Trond Myklebuste9f7bee2006-09-08 09:48:54 -0700895 size_t wsize = NFS_SERVER(inode)->wsize, nbytes;
896 unsigned int offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 int requests = 0;
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400898 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 LIST_HEAD(list);
900
901 nfs_list_remove_request(req);
902
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400903 nbytes = count;
Trond Myklebuste9f7bee2006-09-08 09:48:54 -0700904 do {
905 size_t len = min(nbytes, wsize);
906
Trond Myklebust8d5658c2007-04-10 09:26:35 -0400907 data = nfs_writedata_alloc(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 if (!data)
909 goto out_bad;
910 list_add(&data->pages, &list);
911 requests++;
Trond Myklebuste9f7bee2006-09-08 09:48:54 -0700912 nbytes -= len;
913 } while (nbytes != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 atomic_set(&req->wb_complete, requests);
915
916 ClearPageError(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 offset = 0;
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400918 nbytes = count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 do {
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400920 int ret2;
921
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 data = list_entry(list.next, struct nfs_write_data, pages);
923 list_del_init(&data->pages);
924
925 data->pagevec[0] = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400927 if (nbytes < wsize)
928 wsize = nbytes;
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400929 ret2 = nfs_write_rpcsetup(req, data, &nfs_write_partial_ops,
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400930 wsize, offset, how);
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400931 if (ret == 0)
932 ret = ret2;
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400933 offset += wsize;
934 nbytes -= wsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 } while (nbytes != 0);
936
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400937 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938
939out_bad:
940 while (!list_empty(&list)) {
941 data = list_entry(list.next, struct nfs_write_data, pages);
942 list_del(&data->pages);
Trond Myklebust8aca67f2006-11-13 16:23:44 -0500943 nfs_writedata_release(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 }
Trond Myklebust61822ab2006-12-05 00:35:42 -0500945 nfs_redirty_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 return -ENOMEM;
947}
948
949/*
950 * Create an RPC task for the given write request and kick it.
951 * The page must have been locked by the caller.
952 *
953 * It may happen that the page we're passed is not marked dirty.
954 * This is the case if nfs_updatepage detects a conflicting request
955 * that has been written but not committed.
956 */
Trond Myklebust8d5658c2007-04-10 09:26:35 -0400957static 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 -0700958{
959 struct nfs_page *req;
960 struct page **pages;
961 struct nfs_write_data *data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962
Trond Myklebust8d5658c2007-04-10 09:26:35 -0400963 data = nfs_writedata_alloc(npages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 if (!data)
965 goto out_bad;
966
967 pages = data->pagevec;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 while (!list_empty(head)) {
969 req = nfs_list_entry(head->next);
970 nfs_list_remove_request(req);
971 nfs_list_add_request(req, &data->pages);
972 ClearPageError(req->wb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 *pages++ = req->wb_page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 }
975 req = nfs_list_entry(data->pages.next);
976
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 /* Set up the argument struct */
Trond Myklebustdbae4c72008-04-14 14:54:53 -0400978 return nfs_write_rpcsetup(req, data, &nfs_write_full_ops, count, 0, how);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 out_bad:
980 while (!list_empty(head)) {
Trond Myklebust10afec92007-05-14 17:16:04 -0400981 req = nfs_list_entry(head->next);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 nfs_list_remove_request(req);
Trond Myklebust61822ab2006-12-05 00:35:42 -0500983 nfs_redirty_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 }
985 return -ENOMEM;
986}
987
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400988static void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio,
989 struct inode *inode, int ioflags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990{
Chuck Leverbf4285e2007-12-20 14:54:57 -0500991 size_t wsize = NFS_SERVER(inode)->wsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400993 if (wsize < PAGE_CACHE_SIZE)
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400994 nfs_pageio_init(pgio, inode, nfs_flush_multi, wsize, ioflags);
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400995 else
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400996 nfs_pageio_init(pgio, inode, nfs_flush_one, wsize, ioflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997}
998
999/*
1000 * Handle a write reply that flushed part of a page.
1001 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001002static void nfs_writeback_done_partial(struct rpc_task *task, void *calldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003{
Trond Myklebust788e7a82006-03-20 13:44:27 -05001004 struct nfs_write_data *data = calldata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005
Chuck Lever48186c72008-06-11 17:56:05 -04001006 dprintk("NFS: %5u write(%s/%lld %d@%lld)",
1007 task->tk_pid,
1008 data->req->wb_context->path.dentry->d_inode->i_sb->s_id,
1009 (long long)
1010 NFS_FILEID(data->req->wb_context->path.dentry->d_inode),
1011 data->req->wb_bytes, (long long)req_offset(data->req));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001013 nfs_writeback_done(task, data);
1014}
Trond Myklebust788e7a82006-03-20 13:44:27 -05001015
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001016static void nfs_writeback_release_partial(void *calldata)
1017{
1018 struct nfs_write_data *data = calldata;
1019 struct nfs_page *req = data->req;
1020 struct page *page = req->wb_page;
1021 int status = data->task.tk_status;
1022
1023 if (status < 0) {
Trond Myklebusta301b772007-02-06 11:07:15 -08001024 nfs_set_pageerror(page);
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001025 nfs_context_set_write_error(req->wb_context, status);
1026 dprintk(", error = %d\n", status);
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001027 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 }
1029
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001030 if (nfs_write_need_commit(data)) {
Trond Myklebust587142f2007-07-02 09:57:54 -04001031 struct inode *inode = page->mapping->host;
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001032
Trond Myklebust587142f2007-07-02 09:57:54 -04001033 spin_lock(&inode->i_lock);
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001034 if (test_bit(PG_NEED_RESCHED, &req->wb_flags)) {
1035 /* Do nothing we need to resend the writes */
1036 } else if (!test_and_set_bit(PG_NEED_COMMIT, &req->wb_flags)) {
1037 memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf));
1038 dprintk(" defer commit\n");
1039 } else if (memcmp(&req->wb_verf, &data->verf, sizeof(req->wb_verf))) {
1040 set_bit(PG_NEED_RESCHED, &req->wb_flags);
1041 clear_bit(PG_NEED_COMMIT, &req->wb_flags);
1042 dprintk(" server reboot detected\n");
1043 }
Trond Myklebust587142f2007-07-02 09:57:54 -04001044 spin_unlock(&inode->i_lock);
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001045 } else
1046 dprintk(" OK\n");
1047
1048out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 if (atomic_dec_and_test(&req->wb_complete))
1050 nfs_writepage_release(req);
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001051 nfs_writedata_release(calldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052}
1053
Andy Adamsondef6ed72009-04-01 09:22:26 -04001054#if defined(CONFIG_NFS_V4_1)
1055void nfs_write_prepare(struct rpc_task *task, void *calldata)
1056{
1057 struct nfs_write_data *data = calldata;
1058 struct nfs_client *clp = (NFS_SERVER(data->inode))->nfs_client;
1059
1060 if (nfs4_setup_sequence(clp, &data->args.seq_args,
1061 &data->res.seq_res, 1, task))
1062 return;
1063 rpc_call_start(task);
1064}
1065#endif /* CONFIG_NFS_V4_1 */
1066
Trond Myklebust788e7a82006-03-20 13:44:27 -05001067static const struct rpc_call_ops nfs_write_partial_ops = {
Andy Adamsondef6ed72009-04-01 09:22:26 -04001068#if defined(CONFIG_NFS_V4_1)
1069 .rpc_call_prepare = nfs_write_prepare,
1070#endif /* CONFIG_NFS_V4_1 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001071 .rpc_call_done = nfs_writeback_done_partial,
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001072 .rpc_release = nfs_writeback_release_partial,
Trond Myklebust788e7a82006-03-20 13:44:27 -05001073};
1074
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075/*
1076 * Handle a write reply that flushes a whole page.
1077 *
1078 * FIXME: There is an inherent race with invalidate_inode_pages and
1079 * writebacks since the page->count is kept > 1 for as long
1080 * as the page has a write request pending.
1081 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001082static void nfs_writeback_done_full(struct rpc_task *task, void *calldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083{
Trond Myklebust788e7a82006-03-20 13:44:27 -05001084 struct nfs_write_data *data = calldata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001086 nfs_writeback_done(task, data);
1087}
1088
1089static void nfs_writeback_release_full(void *calldata)
1090{
1091 struct nfs_write_data *data = calldata;
1092 int status = data->task.tk_status;
Trond Myklebust788e7a82006-03-20 13:44:27 -05001093
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 /* Update attributes as result of writeback. */
1095 while (!list_empty(&data->pages)) {
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001096 struct nfs_page *req = nfs_list_entry(data->pages.next);
1097 struct page *page = req->wb_page;
1098
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 nfs_list_remove_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100
Chuck Lever48186c72008-06-11 17:56:05 -04001101 dprintk("NFS: %5u write (%s/%lld %d@%lld)",
1102 data->task.tk_pid,
Trond Myklebust88be9f92007-06-05 10:42:27 -04001103 req->wb_context->path.dentry->d_inode->i_sb->s_id,
1104 (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 req->wb_bytes,
1106 (long long)req_offset(req));
1107
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001108 if (status < 0) {
Trond Myklebusta301b772007-02-06 11:07:15 -08001109 nfs_set_pageerror(page);
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001110 nfs_context_set_write_error(req->wb_context, status);
1111 dprintk(", error = %d\n", status);
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001112 goto remove_request;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001115 if (nfs_write_need_commit(data)) {
1116 memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf));
1117 nfs_mark_request_commit(req);
1118 nfs_end_page_writeback(page);
1119 dprintk(" marked for commit\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 goto next;
1121 }
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001122 dprintk(" OK\n");
1123remove_request:
1124 nfs_end_page_writeback(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 nfs_inode_remove_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 next:
Trond Myklebust9fd367f2007-06-17 15:10:24 -04001127 nfs_clear_page_tag_locked(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 }
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001129 nfs_writedata_release(calldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130}
1131
Trond Myklebust788e7a82006-03-20 13:44:27 -05001132static const struct rpc_call_ops nfs_write_full_ops = {
Andy Adamsondef6ed72009-04-01 09:22:26 -04001133#if defined(CONFIG_NFS_V4_1)
1134 .rpc_call_prepare = nfs_write_prepare,
1135#endif /* CONFIG_NFS_V4_1 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001136 .rpc_call_done = nfs_writeback_done_full,
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001137 .rpc_release = nfs_writeback_release_full,
Trond Myklebust788e7a82006-03-20 13:44:27 -05001138};
1139
1140
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141/*
1142 * This function is called when the WRITE call is complete.
1143 */
Chuck Lever462d5b32006-03-20 13:44:32 -05001144int nfs_writeback_done(struct rpc_task *task, struct nfs_write_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 struct nfs_writeargs *argp = &data->args;
1147 struct nfs_writeres *resp = &data->res;
Andy Adamsoneedc0202009-04-01 09:22:41 -04001148 struct nfs_server *server = NFS_SERVER(data->inode);
Trond Myklebust788e7a82006-03-20 13:44:27 -05001149 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150
Chuck Levera3f565b2007-01-31 12:14:01 -05001151 dprintk("NFS: %5u nfs_writeback_done (status %d)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 task->tk_pid, task->tk_status);
1153
Chuck Leverf551e442006-09-20 14:33:04 -04001154 /*
1155 * ->write_done will attempt to use post-op attributes to detect
1156 * conflicting writes by other clients. A strict interpretation
1157 * of close-to-open would allow us to continue caching even if
1158 * another writer had changed the file, but some applications
1159 * depend on tighter cache coherency when writing.
1160 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001161 status = NFS_PROTO(data->inode)->write_done(task, data);
1162 if (status != 0)
1163 return status;
Chuck Lever91d5b472006-03-20 13:44:14 -05001164 nfs_add_stats(data->inode, NFSIOS_SERVERWRITTENBYTES, resp->count);
1165
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
1167 if (resp->verf->committed < argp->stable && task->tk_status >= 0) {
1168 /* We tried a write call, but the server did not
1169 * commit data to stable storage even though we
1170 * requested it.
1171 * Note: There is a known bug in Tru64 < 5.0 in which
1172 * the server reports NFS_DATA_SYNC, but performs
1173 * NFS_FILE_SYNC. We therefore implement this checking
1174 * as a dprintk() in order to avoid filling syslog.
1175 */
1176 static unsigned long complain;
1177
1178 if (time_before(complain, jiffies)) {
Chuck Lever48186c72008-06-11 17:56:05 -04001179 dprintk("NFS: faulty NFS server %s:"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 " (committed = %d) != (stable = %d)\n",
Andy Adamsoneedc0202009-04-01 09:22:41 -04001181 server->nfs_client->cl_hostname,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 resp->verf->committed, argp->stable);
1183 complain = jiffies + 300 * HZ;
1184 }
1185 }
1186#endif
1187 /* Is this a short write? */
1188 if (task->tk_status >= 0 && resp->count < argp->count) {
1189 static unsigned long complain;
1190
Chuck Lever91d5b472006-03-20 13:44:14 -05001191 nfs_inc_stats(data->inode, NFSIOS_SHORTWRITE);
1192
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 /* Has the server at least made some progress? */
1194 if (resp->count != 0) {
1195 /* Was this an NFSv2 write or an NFSv3 stable write? */
1196 if (resp->verf->committed != NFS_UNSTABLE) {
1197 /* Resend from where the server left off */
1198 argp->offset += resp->count;
1199 argp->pgbase += resp->count;
1200 argp->count -= resp->count;
1201 } else {
1202 /* Resend as a stable write in order to avoid
1203 * headaches in the case of a server crash.
1204 */
1205 argp->stable = NFS_FILE_SYNC;
1206 }
Andy Adamsoneedc0202009-04-01 09:22:41 -04001207 nfs4_restart_rpc(task, server->nfs_client);
Trond Myklebust788e7a82006-03-20 13:44:27 -05001208 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209 }
1210 if (time_before(complain, jiffies)) {
1211 printk(KERN_WARNING
1212 "NFS: Server wrote zero bytes, expected %u.\n",
1213 argp->count);
1214 complain = jiffies + 300 * HZ;
1215 }
1216 /* Can't do anything about it except throw an error. */
1217 task->tk_status = -EIO;
1218 }
Andy Adamsoneedc0202009-04-01 09:22:41 -04001219 nfs4_sequence_free_slot(server->nfs_client, &data->res.seq_res);
Trond Myklebust788e7a82006-03-20 13:44:27 -05001220 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221}
1222
1223
1224#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001225void nfs_commitdata_release(void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226{
Trond Myklebust383ba712008-02-19 20:04:20 -05001227 struct nfs_write_data *wdata = data;
1228
1229 put_nfs_open_context(wdata->args.context);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230 nfs_commit_free(wdata);
1231}
1232
1233/*
1234 * Set up the argument/result storage required for the RPC call.
1235 */
Trond Myklebustdbae4c72008-04-14 14:54:53 -04001236static int nfs_commit_rpcsetup(struct list_head *head,
Trond Myklebust788e7a82006-03-20 13:44:27 -05001237 struct nfs_write_data *data,
1238 int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239{
Trond Myklebust84115e12007-07-14 15:39:59 -04001240 struct nfs_page *first = nfs_list_entry(head->next);
1241 struct inode *inode = first->wb_context->path.dentry->d_inode;
1242 int flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
Trond Myklebust3ff75762007-07-14 15:40:00 -04001243 int priority = flush_task_priority(how);
Trond Myklebust07737692007-10-25 18:42:54 -04001244 struct rpc_task *task;
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001245 struct rpc_message msg = {
1246 .rpc_argp = &data->args,
1247 .rpc_resp = &data->res,
1248 .rpc_cred = first->wb_context->cred,
1249 };
Trond Myklebust84115e12007-07-14 15:39:59 -04001250 struct rpc_task_setup task_setup_data = {
Trond Myklebust07737692007-10-25 18:42:54 -04001251 .task = &data->task,
Trond Myklebust84115e12007-07-14 15:39:59 -04001252 .rpc_client = NFS_CLIENT(inode),
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001253 .rpc_message = &msg,
Trond Myklebust84115e12007-07-14 15:39:59 -04001254 .callback_ops = &nfs_commit_ops,
1255 .callback_data = data,
Trond Myklebust101070c2008-02-19 20:04:23 -05001256 .workqueue = nfsiod_workqueue,
Trond Myklebust84115e12007-07-14 15:39:59 -04001257 .flags = flags,
Trond Myklebust3ff75762007-07-14 15:40:00 -04001258 .priority = priority,
Trond Myklebust84115e12007-07-14 15:39:59 -04001259 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260
1261 /* Set up the RPC argument and reply structs
1262 * NB: take care not to mess about with data->commit et al. */
1263
1264 list_splice_init(head, &data->pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 data->inode = inode;
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001267 data->cred = msg.rpc_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268
1269 data->args.fh = NFS_FH(data->inode);
Trond Myklebust3da28eb2005-06-22 17:16:31 +00001270 /* Note: we always request a commit of the entire inode */
1271 data->args.offset = 0;
1272 data->args.count = 0;
Trond Myklebust383ba712008-02-19 20:04:20 -05001273 data->args.context = get_nfs_open_context(first->wb_context);
Trond Myklebust3da28eb2005-06-22 17:16:31 +00001274 data->res.count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 data->res.fattr = &data->fattr;
1276 data->res.verf = &data->verf;
Trond Myklebust0e574af2005-10-27 22:12:38 -04001277 nfs_fattr_init(&data->fattr);
Trond Myklebust788e7a82006-03-20 13:44:27 -05001278
1279 /* Set up the initial task struct. */
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001280 NFS_PROTO(inode)->commit_setup(data, &msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281
Chuck Levera3f565b2007-01-31 12:14:01 -05001282 dprintk("NFS: %5u initiated commit call\n", data->task.tk_pid);
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001283
Trond Myklebust07737692007-10-25 18:42:54 -04001284 task = rpc_run_task(&task_setup_data);
Trond Myklebustdbae4c72008-04-14 14:54:53 -04001285 if (IS_ERR(task))
1286 return PTR_ERR(task);
1287 rpc_put_task(task);
1288 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289}
1290
1291/*
1292 * Commit dirty pages
1293 */
1294static int
Chuck Lever40859d72005-11-30 18:09:02 -05001295nfs_commit_list(struct inode *inode, struct list_head *head, int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296{
1297 struct nfs_write_data *data;
1298 struct nfs_page *req;
1299
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001300 data = nfs_commitdata_alloc();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301
1302 if (!data)
1303 goto out_bad;
1304
1305 /* Set up the argument struct */
Trond Myklebustdbae4c72008-04-14 14:54:53 -04001306 return nfs_commit_rpcsetup(head, data, how);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 out_bad:
1308 while (!list_empty(head)) {
1309 req = nfs_list_entry(head->next);
1310 nfs_list_remove_request(req);
1311 nfs_mark_request_commit(req);
Trond Myklebust83715ad2006-07-05 13:17:12 -04001312 dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
Peter Zijlstrac9e51e42007-10-16 23:25:47 -07001313 dec_bdi_stat(req->wb_page->mapping->backing_dev_info,
1314 BDI_RECLAIMABLE);
Trond Myklebust9fd367f2007-06-17 15:10:24 -04001315 nfs_clear_page_tag_locked(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 }
1317 return -ENOMEM;
1318}
1319
1320/*
1321 * COMMIT call returned
1322 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001323static void nfs_commit_done(struct rpc_task *task, void *calldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324{
Trond Myklebust963d8fe2006-01-03 09:55:04 +01001325 struct nfs_write_data *data = calldata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326
Chuck Levera3f565b2007-01-31 12:14:01 -05001327 dprintk("NFS: %5u nfs_commit_done (status %d)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 task->tk_pid, task->tk_status);
1329
Trond Myklebust788e7a82006-03-20 13:44:27 -05001330 /* Call the NFS version-specific code */
1331 if (NFS_PROTO(data->inode)->commit_done(task, data) != 0)
1332 return;
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001333}
1334
1335static void nfs_commit_release(void *calldata)
1336{
1337 struct nfs_write_data *data = calldata;
1338 struct nfs_page *req;
1339 int status = data->task.tk_status;
Trond Myklebust788e7a82006-03-20 13:44:27 -05001340
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 while (!list_empty(&data->pages)) {
1342 req = nfs_list_entry(data->pages.next);
1343 nfs_list_remove_request(req);
Trond Myklebuste468bae2008-06-13 13:25:22 -04001344 nfs_clear_request_commit(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345
Chuck Lever48186c72008-06-11 17:56:05 -04001346 dprintk("NFS: commit (%s/%lld %d@%lld)",
Trond Myklebust88be9f92007-06-05 10:42:27 -04001347 req->wb_context->path.dentry->d_inode->i_sb->s_id,
1348 (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 req->wb_bytes,
1350 (long long)req_offset(req));
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001351 if (status < 0) {
1352 nfs_context_set_write_error(req->wb_context, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 nfs_inode_remove_request(req);
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001354 dprintk(", error = %d\n", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 goto next;
1356 }
1357
1358 /* Okay, COMMIT succeeded, apparently. Check the verifier
1359 * returned by the server against all stored verfs. */
1360 if (!memcmp(req->wb_verf.verifier, data->verf.verifier, sizeof(data->verf.verifier))) {
1361 /* We have a match */
1362 nfs_inode_remove_request(req);
1363 dprintk(" OK\n");
1364 goto next;
1365 }
1366 /* We have a mismatch. Write the page again */
1367 dprintk(" mismatch\n");
Fred6d884e82008-03-19 11:24:38 -04001368 nfs_mark_request_dirty(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 next:
Trond Myklebust9fd367f2007-06-17 15:10:24 -04001370 nfs_clear_page_tag_locked(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 }
Trond Myklebustc9d8f892008-04-15 16:56:39 -04001372 nfs_commitdata_release(calldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373}
Trond Myklebust788e7a82006-03-20 13:44:27 -05001374
1375static const struct rpc_call_ops nfs_commit_ops = {
Andy Adamson21d9a852009-04-01 09:22:27 -04001376#if defined(CONFIG_NFS_V4_1)
1377 .rpc_call_prepare = nfs_write_prepare,
1378#endif /* CONFIG_NFS_V4_1 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001379 .rpc_call_done = nfs_commit_done,
1380 .rpc_release = nfs_commit_release,
1381};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382
Trond Myklebust3da28eb2005-06-22 17:16:31 +00001383int nfs_commit_inode(struct inode *inode, int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 LIST_HEAD(head);
Trond Myklebust7d46a492006-03-20 13:44:50 -05001386 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387
Trond Myklebust587142f2007-07-02 09:57:54 -04001388 spin_lock(&inode->i_lock);
Trond Myklebust3da28eb2005-06-22 17:16:31 +00001389 res = nfs_scan_commit(inode, &head, 0, 0);
Trond Myklebust587142f2007-07-02 09:57:54 -04001390 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 if (res) {
Trond Myklebust7d46a492006-03-20 13:44:50 -05001392 int error = nfs_commit_list(inode, &head, how);
Trond Myklebust3da28eb2005-06-22 17:16:31 +00001393 if (error < 0)
1394 return error;
1395 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 return res;
1397}
Trond Myklebustc63c7b02007-04-02 19:29:52 -04001398#else
1399static inline int nfs_commit_list(struct inode *inode, struct list_head *head, int how)
1400{
1401 return 0;
1402}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403#endif
1404
Trond Myklebust1c759502006-10-09 16:18:38 -04001405long nfs_sync_mapping_wait(struct address_space *mapping, struct writeback_control *wbc, int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406{
Trond Myklebust1c759502006-10-09 16:18:38 -04001407 struct inode *inode = mapping->host;
Trond Myklebustca52fec2007-04-17 17:22:13 -04001408 pgoff_t idx_start, idx_end;
Trond Myklebust1c759502006-10-09 16:18:38 -04001409 unsigned int npages = 0;
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001410 LIST_HEAD(head);
Trond Myklebust70b9ecb2006-01-03 09:55:34 +01001411 int nocommit = how & FLUSH_NOCOMMIT;
Trond Myklebust3f442542006-09-17 14:46:44 -04001412 long pages, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413
Trond Myklebust1c759502006-10-09 16:18:38 -04001414 /* FIXME */
1415 if (wbc->range_cyclic)
1416 idx_start = 0;
1417 else {
1418 idx_start = wbc->range_start >> PAGE_CACHE_SHIFT;
1419 idx_end = wbc->range_end >> PAGE_CACHE_SHIFT;
1420 if (idx_end > idx_start) {
Trond Myklebustca52fec2007-04-17 17:22:13 -04001421 pgoff_t l_npages = 1 + idx_end - idx_start;
Trond Myklebust1c759502006-10-09 16:18:38 -04001422 npages = l_npages;
1423 if (sizeof(npages) != sizeof(l_npages) &&
Trond Myklebustca52fec2007-04-17 17:22:13 -04001424 (pgoff_t)npages != l_npages)
Trond Myklebust1c759502006-10-09 16:18:38 -04001425 npages = 0;
1426 }
1427 }
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001428 how &= ~FLUSH_NOCOMMIT;
Trond Myklebust587142f2007-07-02 09:57:54 -04001429 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 do {
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001431 ret = nfs_wait_on_requests_locked(inode, idx_start, npages);
1432 if (ret != 0)
Trond Myklebust70b9ecb2006-01-03 09:55:34 +01001433 continue;
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001434 if (nocommit)
1435 break;
Trond Myklebustd2ccddf2006-05-31 01:13:38 -04001436 pages = nfs_scan_commit(inode, &head, idx_start, npages);
Trond Myklebust724c4392007-04-17 17:22:13 -04001437 if (pages == 0)
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001438 break;
Trond Myklebustd2ccddf2006-05-31 01:13:38 -04001439 if (how & FLUSH_INVALIDATE) {
Trond Myklebust587142f2007-07-02 09:57:54 -04001440 spin_unlock(&inode->i_lock);
Trond Myklebust83715ad2006-07-05 13:17:12 -04001441 nfs_cancel_commit_list(&head);
Trond Myklebuste8e058e2006-11-15 17:31:56 -05001442 ret = pages;
Trond Myklebust587142f2007-07-02 09:57:54 -04001443 spin_lock(&inode->i_lock);
Trond Myklebustd2ccddf2006-05-31 01:13:38 -04001444 continue;
1445 }
1446 pages += nfs_scan_commit(inode, &head, 0, 0);
Trond Myklebust587142f2007-07-02 09:57:54 -04001447 spin_unlock(&inode->i_lock);
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001448 ret = nfs_commit_list(inode, &head, how);
Trond Myklebust587142f2007-07-02 09:57:54 -04001449 spin_lock(&inode->i_lock);
1450
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001451 } while (ret >= 0);
Trond Myklebust587142f2007-07-02 09:57:54 -04001452 spin_unlock(&inode->i_lock);
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001453 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454}
1455
Trond Myklebust34901f72007-07-25 14:09:54 -04001456static int __nfs_write_mapping(struct address_space *mapping, struct writeback_control *wbc, int how)
Trond Myklebust1c759502006-10-09 16:18:38 -04001457{
Trond Myklebust1c759502006-10-09 16:18:38 -04001458 int ret;
1459
Trond Myklebust34901f72007-07-25 14:09:54 -04001460 ret = nfs_writepages(mapping, wbc);
Trond Myklebust61822ab2006-12-05 00:35:42 -05001461 if (ret < 0)
1462 goto out;
Trond Myklebust34901f72007-07-25 14:09:54 -04001463 ret = nfs_sync_mapping_wait(mapping, wbc, how);
Trond Myklebusted90ef52007-07-20 13:13:28 -04001464 if (ret < 0)
1465 goto out;
1466 return 0;
Trond Myklebust61822ab2006-12-05 00:35:42 -05001467out:
Trond Myklebuste507d9e2006-12-05 00:35:42 -05001468 __mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
Trond Myklebust1c759502006-10-09 16:18:38 -04001469 return ret;
1470}
1471
Trond Myklebust34901f72007-07-25 14:09:54 -04001472/* Two pass sync: first using WB_SYNC_NONE, then WB_SYNC_ALL */
1473static int nfs_write_mapping(struct address_space *mapping, int how)
1474{
1475 struct writeback_control wbc = {
1476 .bdi = mapping->backing_dev_info,
Trond Myklebust72cb77f2009-03-11 14:10:30 -04001477 .sync_mode = WB_SYNC_ALL,
Trond Myklebust34901f72007-07-25 14:09:54 -04001478 .nr_to_write = LONG_MAX,
Trond Myklebustd7fb1202008-10-06 20:08:56 -04001479 .range_start = 0,
1480 .range_end = LLONG_MAX,
Trond Myklebust34901f72007-07-25 14:09:54 -04001481 .for_writepages = 1,
Trond Myklebust34901f72007-07-25 14:09:54 -04001482 };
Trond Myklebust34901f72007-07-25 14:09:54 -04001483
Trond Myklebust34901f72007-07-25 14:09:54 -04001484 return __nfs_write_mapping(mapping, &wbc, how);
1485}
1486
Trond Myklebusted90ef52007-07-20 13:13:28 -04001487/*
1488 * flush the inode to disk.
1489 */
1490int nfs_wb_all(struct inode *inode)
Trond Myklebust1c759502006-10-09 16:18:38 -04001491{
Trond Myklebusted90ef52007-07-20 13:13:28 -04001492 return nfs_write_mapping(inode->i_mapping, 0);
1493}
Trond Myklebust1c759502006-10-09 16:18:38 -04001494
Trond Myklebusted90ef52007-07-20 13:13:28 -04001495int nfs_wb_nocommit(struct inode *inode)
1496{
1497 return nfs_write_mapping(inode->i_mapping, FLUSH_NOCOMMIT);
Trond Myklebust1c759502006-10-09 16:18:38 -04001498}
1499
Trond Myklebust1b3b4a12007-08-28 10:29:36 -04001500int nfs_wb_page_cancel(struct inode *inode, struct page *page)
1501{
1502 struct nfs_page *req;
1503 loff_t range_start = page_offset(page);
1504 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
1505 struct writeback_control wbc = {
1506 .bdi = page->mapping->backing_dev_info,
1507 .sync_mode = WB_SYNC_ALL,
1508 .nr_to_write = LONG_MAX,
1509 .range_start = range_start,
1510 .range_end = range_end,
1511 };
1512 int ret = 0;
1513
1514 BUG_ON(!PageLocked(page));
1515 for (;;) {
1516 req = nfs_page_find_request(page);
1517 if (req == NULL)
1518 goto out;
Trond Myklebuste468bae2008-06-13 13:25:22 -04001519 if (test_bit(PG_CLEAN, &req->wb_flags)) {
Trond Myklebust1b3b4a12007-08-28 10:29:36 -04001520 nfs_release_request(req);
1521 break;
1522 }
1523 if (nfs_lock_request_dontget(req)) {
1524 nfs_inode_remove_request(req);
1525 /*
1526 * In case nfs_inode_remove_request has marked the
1527 * page as being dirty
1528 */
1529 cancel_dirty_page(page, PAGE_CACHE_SIZE);
1530 nfs_unlock_request(req);
1531 break;
1532 }
1533 ret = nfs_wait_on_request(req);
1534 if (ret < 0)
1535 goto out;
1536 }
1537 if (!PagePrivate(page))
1538 return 0;
1539 ret = nfs_sync_mapping_wait(page->mapping, &wbc, FLUSH_INVALIDATE);
1540out:
1541 return ret;
1542}
1543
Adrian Bunk5334eb12007-11-21 15:04:31 -08001544static int nfs_wb_page_priority(struct inode *inode, struct page *page,
1545 int how)
Trond Myklebust1c759502006-10-09 16:18:38 -04001546{
1547 loff_t range_start = page_offset(page);
1548 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
Trond Myklebust4d770cc2006-12-05 00:35:41 -05001549 struct writeback_control wbc = {
1550 .bdi = page->mapping->backing_dev_info,
1551 .sync_mode = WB_SYNC_ALL,
1552 .nr_to_write = LONG_MAX,
1553 .range_start = range_start,
1554 .range_end = range_end,
1555 };
1556 int ret;
Trond Myklebust1c759502006-10-09 16:18:38 -04001557
Trond Myklebust73e33022008-04-11 16:03:54 -04001558 do {
1559 if (clear_page_dirty_for_io(page)) {
1560 ret = nfs_writepage_locked(page, &wbc);
1561 if (ret < 0)
1562 goto out_error;
1563 } else if (!PagePrivate(page))
1564 break;
1565 ret = nfs_sync_mapping_wait(page->mapping, &wbc, how);
Trond Myklebust4d770cc2006-12-05 00:35:41 -05001566 if (ret < 0)
Trond Myklebust73e33022008-04-11 16:03:54 -04001567 goto out_error;
1568 } while (PagePrivate(page));
1569 return 0;
1570out_error:
Trond Myklebuste507d9e2006-12-05 00:35:42 -05001571 __mark_inode_dirty(inode, I_DIRTY_PAGES);
Trond Myklebust4d770cc2006-12-05 00:35:41 -05001572 return ret;
Trond Myklebust1c759502006-10-09 16:18:38 -04001573}
1574
1575/*
1576 * Write back all requests on one page - we do this before reading it.
1577 */
1578int nfs_wb_page(struct inode *inode, struct page* page)
1579{
Trond Myklebust4d770cc2006-12-05 00:35:41 -05001580 return nfs_wb_page_priority(inode, page, FLUSH_STABLE);
Trond Myklebust1c759502006-10-09 16:18:38 -04001581}
1582
David Howellsf7b422b2006-06-09 09:34:33 -04001583int __init nfs_init_writepagecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584{
1585 nfs_wdata_cachep = kmem_cache_create("nfs_write_data",
1586 sizeof(struct nfs_write_data),
1587 0, SLAB_HWCACHE_ALIGN,
Paul Mundt20c2df82007-07-20 10:11:58 +09001588 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589 if (nfs_wdata_cachep == NULL)
1590 return -ENOMEM;
1591
Matthew Dobson93d23412006-03-26 01:37:50 -08001592 nfs_wdata_mempool = mempool_create_slab_pool(MIN_POOL_WRITE,
1593 nfs_wdata_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594 if (nfs_wdata_mempool == NULL)
1595 return -ENOMEM;
1596
Matthew Dobson93d23412006-03-26 01:37:50 -08001597 nfs_commit_mempool = mempool_create_slab_pool(MIN_POOL_COMMIT,
1598 nfs_wdata_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 if (nfs_commit_mempool == NULL)
1600 return -ENOMEM;
1601
Peter Zijlstra89a09142007-03-16 13:38:26 -08001602 /*
1603 * NFS congestion size, scale with available memory.
1604 *
1605 * 64MB: 8192k
1606 * 128MB: 11585k
1607 * 256MB: 16384k
1608 * 512MB: 23170k
1609 * 1GB: 32768k
1610 * 2GB: 46340k
1611 * 4GB: 65536k
1612 * 8GB: 92681k
1613 * 16GB: 131072k
1614 *
1615 * This allows larger machines to have larger/more transfers.
1616 * Limit the default to 256M
1617 */
1618 nfs_congestion_kb = (16*int_sqrt(totalram_pages)) << (PAGE_SHIFT-10);
1619 if (nfs_congestion_kb > 256*1024)
1620 nfs_congestion_kb = 256*1024;
1621
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 return 0;
1623}
1624
David Brownell266bee82006-06-27 12:59:15 -07001625void nfs_destroy_writepagecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626{
1627 mempool_destroy(nfs_commit_mempool);
1628 mempool_destroy(nfs_wdata_mempool);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001629 kmem_cache_destroy(nfs_wdata_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630}
1631