]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - fs/nfs/write.c
NFSv4.1: filelayout driver specific code for COMMIT
[mirror_ubuntu-bionic-kernel.git] / fs / nfs / write.c
CommitLineData
1da177e4
LT
1/*
2 * linux/fs/nfs/write.c
3 *
7c85d900 4 * Write file data over NFS.
1da177e4
LT
5 *
6 * Copyright (C) 1996, 1997, Olaf Kirch <okir@monad.swb.de>
7 */
8
1da177e4
LT
9#include <linux/types.h>
10#include <linux/slab.h>
11#include <linux/mm.h>
12#include <linux/pagemap.h>
13#include <linux/file.h>
1da177e4 14#include <linux/writeback.h>
89a09141 15#include <linux/swap.h>
074cc1de 16#include <linux/migrate.h>
1da177e4
LT
17
18#include <linux/sunrpc/clnt.h>
19#include <linux/nfs_fs.h>
20#include <linux/nfs_mount.h>
21#include <linux/nfs_page.h>
3fcfab16
AM
22#include <linux/backing-dev.h>
23
1da177e4 24#include <asm/uaccess.h>
1da177e4
LT
25
26#include "delegation.h"
49a70f27 27#include "internal.h"
91d5b470 28#include "iostat.h"
def6ed7e 29#include "nfs4_fs.h"
074cc1de 30#include "fscache.h"
94ad1c80 31#include "pnfs.h"
1da177e4
LT
32
33#define NFSDBG_FACILITY NFSDBG_PAGECACHE
34
35#define MIN_POOL_WRITE (32)
36#define MIN_POOL_COMMIT (4)
37
38/*
39 * Local function declarations
40 */
c63c7b05
TM
41static void nfs_pageio_init_write(struct nfs_pageio_descriptor *desc,
42 struct inode *inode, int ioflags);
f8512ad0 43static void nfs_redirty_request(struct nfs_page *req);
788e7a89
TM
44static const struct rpc_call_ops nfs_write_partial_ops;
45static const struct rpc_call_ops nfs_write_full_ops;
46static const struct rpc_call_ops nfs_commit_ops;
1da177e4 47
e18b890b 48static struct kmem_cache *nfs_wdata_cachep;
3feb2d49 49static mempool_t *nfs_wdata_mempool;
1da177e4
LT
50static mempool_t *nfs_commit_mempool;
51
c9d8f89d 52struct nfs_write_data *nfs_commitdata_alloc(void)
1da177e4 53{
e6b4f8da 54 struct nfs_write_data *p = mempool_alloc(nfs_commit_mempool, GFP_NOFS);
40859d7e 55
1da177e4
LT
56 if (p) {
57 memset(p, 0, sizeof(*p));
58 INIT_LIST_HEAD(&p->pages);
59 }
60 return p;
61}
e0c2b380 62EXPORT_SYMBOL_GPL(nfs_commitdata_alloc);
1da177e4 63
5e4424af 64void nfs_commit_free(struct nfs_write_data *p)
1da177e4 65{
40859d7e
CL
66 if (p && (p->pagevec != &p->page_array[0]))
67 kfree(p->pagevec);
1da177e4
LT
68 mempool_free(p, nfs_commit_mempool);
69}
e0c2b380 70EXPORT_SYMBOL_GPL(nfs_commit_free);
1da177e4 71
8d5658c9 72struct nfs_write_data *nfs_writedata_alloc(unsigned int pagecount)
3feb2d49 73{
e6b4f8da 74 struct nfs_write_data *p = mempool_alloc(nfs_wdata_mempool, GFP_NOFS);
3feb2d49
TM
75
76 if (p) {
77 memset(p, 0, sizeof(*p));
78 INIT_LIST_HEAD(&p->pages);
e9f7bee1 79 p->npages = pagecount;
0d0b5cb3
CL
80 if (pagecount <= ARRAY_SIZE(p->page_array))
81 p->pagevec = p->page_array;
3feb2d49 82 else {
0d0b5cb3
CL
83 p->pagevec = kcalloc(pagecount, sizeof(struct page *), GFP_NOFS);
84 if (!p->pagevec) {
3feb2d49
TM
85 mempool_free(p, nfs_wdata_mempool);
86 p = NULL;
87 }
88 }
89 }
90 return p;
91}
92
1ae88b2e 93void nfs_writedata_free(struct nfs_write_data *p)
3feb2d49
TM
94{
95 if (p && (p->pagevec != &p->page_array[0]))
96 kfree(p->pagevec);
97 mempool_free(p, nfs_wdata_mempool);
98}
99
1ae88b2e 100static void nfs_writedata_release(struct nfs_write_data *wdata)
1da177e4 101{
5053aa56 102 put_lseg(wdata->lseg);
383ba719 103 put_nfs_open_context(wdata->args.context);
1da177e4
LT
104 nfs_writedata_free(wdata);
105}
106
7b159fc1
TM
107static void nfs_context_set_write_error(struct nfs_open_context *ctx, int error)
108{
109 ctx->error = error;
110 smp_wmb();
111 set_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
112}
113
277459d2
TM
114static struct nfs_page *nfs_page_find_request_locked(struct page *page)
115{
116 struct nfs_page *req = NULL;
117
118 if (PagePrivate(page)) {
119 req = (struct nfs_page *)page_private(page);
120 if (req != NULL)
c03b4024 121 kref_get(&req->wb_kref);
277459d2
TM
122 }
123 return req;
124}
125
126static struct nfs_page *nfs_page_find_request(struct page *page)
127{
587142f8 128 struct inode *inode = page->mapping->host;
277459d2 129 struct nfs_page *req = NULL;
277459d2 130
587142f8 131 spin_lock(&inode->i_lock);
277459d2 132 req = nfs_page_find_request_locked(page);
587142f8 133 spin_unlock(&inode->i_lock);
277459d2
TM
134 return req;
135}
136
1da177e4
LT
137/* Adjust the file length if we're writing beyond the end */
138static void nfs_grow_file(struct page *page, unsigned int offset, unsigned int count)
139{
140 struct inode *inode = page->mapping->host;
a3d01454
TM
141 loff_t end, i_size;
142 pgoff_t end_index;
1da177e4 143
a3d01454
TM
144 spin_lock(&inode->i_lock);
145 i_size = i_size_read(inode);
146 end_index = (i_size - 1) >> PAGE_CACHE_SHIFT;
1da177e4 147 if (i_size > 0 && page->index < end_index)
a3d01454 148 goto out;
1da177e4
LT
149 end = ((loff_t)page->index << PAGE_CACHE_SHIFT) + ((loff_t)offset+count);
150 if (i_size >= end)
a3d01454 151 goto out;
1da177e4 152 i_size_write(inode, end);
a3d01454
TM
153 nfs_inc_stats(inode, NFSIOS_EXTENDWRITE);
154out:
155 spin_unlock(&inode->i_lock);
1da177e4
LT
156}
157
a301b777
TM
158/* A writeback failed: mark the page as bad, and invalidate the page cache */
159static void nfs_set_pageerror(struct page *page)
160{
161 SetPageError(page);
162 nfs_zap_mapping(page->mapping->host, page->mapping);
163}
164
1da177e4
LT
165/* We can set the PG_uptodate flag if we see that a write request
166 * covers the full page.
167 */
168static void nfs_mark_uptodate(struct page *page, unsigned int base, unsigned int count)
169{
1da177e4
LT
170 if (PageUptodate(page))
171 return;
172 if (base != 0)
173 return;
49a70f27 174 if (count != nfs_page_length(page))
1da177e4 175 return;
49a70f27 176 SetPageUptodate(page);
1da177e4
LT
177}
178
1da177e4
LT
179static int wb_priority(struct writeback_control *wbc)
180{
181 if (wbc->for_reclaim)
c63c7b05 182 return FLUSH_HIGHPRI | FLUSH_STABLE;
b17621fe 183 if (wbc->for_kupdate || wbc->for_background)
b31268ac
TM
184 return FLUSH_LOWPRI | FLUSH_COND_STABLE;
185 return FLUSH_COND_STABLE;
1da177e4
LT
186}
187
89a09141
PZ
188/*
189 * NFS congestion control
190 */
191
192int nfs_congestion_kb;
193
194#define NFS_CONGESTION_ON_THRESH (nfs_congestion_kb >> (PAGE_SHIFT-10))
195#define NFS_CONGESTION_OFF_THRESH \
196 (NFS_CONGESTION_ON_THRESH - (NFS_CONGESTION_ON_THRESH >> 2))
197
5a6d41b3 198static int nfs_set_page_writeback(struct page *page)
89a09141 199{
5a6d41b3
TM
200 int ret = test_set_page_writeback(page);
201
202 if (!ret) {
89a09141
PZ
203 struct inode *inode = page->mapping->host;
204 struct nfs_server *nfss = NFS_SERVER(inode);
205
a6305ddb 206 page_cache_get(page);
277866a0 207 if (atomic_long_inc_return(&nfss->writeback) >
8aa7e847
JA
208 NFS_CONGESTION_ON_THRESH) {
209 set_bdi_congested(&nfss->backing_dev_info,
210 BLK_RW_ASYNC);
211 }
89a09141 212 }
5a6d41b3 213 return ret;
89a09141
PZ
214}
215
216static void nfs_end_page_writeback(struct page *page)
217{
218 struct inode *inode = page->mapping->host;
219 struct nfs_server *nfss = NFS_SERVER(inode);
220
221 end_page_writeback(page);
a6305ddb 222 page_cache_release(page);
c4dc4bee 223 if (atomic_long_dec_return(&nfss->writeback) < NFS_CONGESTION_OFF_THRESH)
8aa7e847 224 clear_bdi_congested(&nfss->backing_dev_info, BLK_RW_ASYNC);
89a09141
PZ
225}
226
cfb506e1 227static struct nfs_page *nfs_find_and_lock_request(struct page *page, bool nonblock)
e261f51f 228{
587142f8 229 struct inode *inode = page->mapping->host;
e261f51f 230 struct nfs_page *req;
e261f51f
TM
231 int ret;
232
587142f8 233 spin_lock(&inode->i_lock);
074cc1de 234 for (;;) {
e261f51f 235 req = nfs_page_find_request_locked(page);
074cc1de
TM
236 if (req == NULL)
237 break;
acee478a 238 if (nfs_set_page_tag_locked(req))
e261f51f
TM
239 break;
240 /* Note: If we hold the page lock, as is the case in nfs_writepage,
acee478a 241 * then the call to nfs_set_page_tag_locked() will always
e261f51f
TM
242 * succeed provided that someone hasn't already marked the
243 * request as dirty (in which case we don't care).
244 */
587142f8 245 spin_unlock(&inode->i_lock);
cfb506e1
TM
246 if (!nonblock)
247 ret = nfs_wait_on_request(req);
248 else
249 ret = -EAGAIN;
e261f51f
TM
250 nfs_release_request(req);
251 if (ret != 0)
074cc1de 252 return ERR_PTR(ret);
587142f8 253 spin_lock(&inode->i_lock);
e261f51f 254 }
587142f8 255 spin_unlock(&inode->i_lock);
074cc1de
TM
256 return req;
257}
258
259/*
260 * Find an associated nfs write request, and prepare to flush it out
261 * May return an error if the user signalled nfs_wait_on_request().
262 */
263static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio,
cfb506e1 264 struct page *page, bool nonblock)
074cc1de
TM
265{
266 struct nfs_page *req;
267 int ret = 0;
268
cfb506e1 269 req = nfs_find_and_lock_request(page, nonblock);
074cc1de
TM
270 if (!req)
271 goto out;
272 ret = PTR_ERR(req);
273 if (IS_ERR(req))
274 goto out;
275
276 ret = nfs_set_page_writeback(page);
277 BUG_ON(ret != 0);
278 BUG_ON(test_bit(PG_CLEAN, &req->wb_flags));
279
f8512ad0
FI
280 if (!nfs_pageio_add_request(pgio, req)) {
281 nfs_redirty_request(req);
074cc1de 282 ret = pgio->pg_error;
f8512ad0 283 }
074cc1de
TM
284out:
285 return ret;
e261f51f
TM
286}
287
f758c885 288static int nfs_do_writepage(struct page *page, struct writeback_control *wbc, struct nfs_pageio_descriptor *pgio)
1da177e4 289{
1da177e4 290 struct inode *inode = page->mapping->host;
cfb506e1 291 int ret;
1da177e4 292
91d5b470
CL
293 nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE);
294 nfs_add_stats(inode, NFSIOS_WRITEPAGES, 1);
295
7fe7f848 296 nfs_pageio_cond_complete(pgio, page->index);
1b430bee 297 ret = nfs_page_async_flush(pgio, page, wbc->sync_mode == WB_SYNC_NONE);
cfb506e1
TM
298 if (ret == -EAGAIN) {
299 redirty_page_for_writepage(wbc, page);
300 ret = 0;
301 }
302 return ret;
f758c885 303}
7fe7f848 304
f758c885
TM
305/*
306 * Write an mmapped page to the server.
307 */
308static int nfs_writepage_locked(struct page *page, struct writeback_control *wbc)
309{
310 struct nfs_pageio_descriptor pgio;
311 int err;
49a70f27 312
f758c885
TM
313 nfs_pageio_init_write(&pgio, page->mapping->host, wb_priority(wbc));
314 err = nfs_do_writepage(page, wbc, &pgio);
315 nfs_pageio_complete(&pgio);
316 if (err < 0)
317 return err;
318 if (pgio.pg_error < 0)
319 return pgio.pg_error;
320 return 0;
4d770ccf
TM
321}
322
323int nfs_writepage(struct page *page, struct writeback_control *wbc)
324{
f758c885 325 int ret;
4d770ccf 326
f758c885 327 ret = nfs_writepage_locked(page, wbc);
1da177e4 328 unlock_page(page);
f758c885
TM
329 return ret;
330}
331
332static int nfs_writepages_callback(struct page *page, struct writeback_control *wbc, void *data)
333{
334 int ret;
335
336 ret = nfs_do_writepage(page, wbc, data);
337 unlock_page(page);
338 return ret;
1da177e4
LT
339}
340
1da177e4
LT
341int nfs_writepages(struct address_space *mapping, struct writeback_control *wbc)
342{
1da177e4 343 struct inode *inode = mapping->host;
72cb77f4 344 unsigned long *bitlock = &NFS_I(inode)->flags;
c63c7b05 345 struct nfs_pageio_descriptor pgio;
1da177e4
LT
346 int err;
347
72cb77f4
TM
348 /* Stop dirtying of new pages while we sync */
349 err = wait_on_bit_lock(bitlock, NFS_INO_FLUSHING,
350 nfs_wait_bit_killable, TASK_KILLABLE);
351 if (err)
352 goto out_err;
353
91d5b470
CL
354 nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGES);
355
c63c7b05 356 nfs_pageio_init_write(&pgio, inode, wb_priority(wbc));
f758c885 357 err = write_cache_pages(mapping, wbc, nfs_writepages_callback, &pgio);
c63c7b05 358 nfs_pageio_complete(&pgio);
72cb77f4
TM
359
360 clear_bit_unlock(NFS_INO_FLUSHING, bitlock);
361 smp_mb__after_clear_bit();
362 wake_up_bit(bitlock, NFS_INO_FLUSHING);
363
f758c885 364 if (err < 0)
72cb77f4
TM
365 goto out_err;
366 err = pgio.pg_error;
367 if (err < 0)
368 goto out_err;
c63c7b05 369 return 0;
72cb77f4
TM
370out_err:
371 return err;
1da177e4
LT
372}
373
374/*
375 * Insert a write request into an inode
376 */
e7d39069 377static int nfs_inode_add_request(struct inode *inode, struct nfs_page *req)
1da177e4
LT
378{
379 struct nfs_inode *nfsi = NFS_I(inode);
380 int error;
381
e7d39069
TM
382 error = radix_tree_preload(GFP_NOFS);
383 if (error != 0)
384 goto out;
385
386 /* Lock the request! */
387 nfs_lock_request_dontget(req);
388
389 spin_lock(&inode->i_lock);
1da177e4 390 error = radix_tree_insert(&nfsi->nfs_page_tree, req->wb_index, req);
27852596 391 BUG_ON(error);
1da177e4
LT
392 if (!nfsi->npages) {
393 igrab(inode);
1da177e4
LT
394 if (nfs_have_delegation(inode, FMODE_WRITE))
395 nfsi->change_attr++;
396 }
2df485a7 397 set_bit(PG_MAPPED, &req->wb_flags);
deb7d638 398 SetPagePrivate(req->wb_page);
277459d2 399 set_page_private(req->wb_page, (unsigned long)req);
1da177e4 400 nfsi->npages++;
c03b4024 401 kref_get(&req->wb_kref);
27852596
NP
402 radix_tree_tag_set(&nfsi->nfs_page_tree, req->wb_index,
403 NFS_PAGE_TAG_LOCKED);
e7d39069
TM
404 spin_unlock(&inode->i_lock);
405 radix_tree_preload_end();
406out:
407 return error;
1da177e4
LT
408}
409
410/*
89a09141 411 * Remove a write request from an inode
1da177e4
LT
412 */
413static void nfs_inode_remove_request(struct nfs_page *req)
414{
88be9f99 415 struct inode *inode = req->wb_context->path.dentry->d_inode;
1da177e4
LT
416 struct nfs_inode *nfsi = NFS_I(inode);
417
418 BUG_ON (!NFS_WBACK_BUSY(req));
419
587142f8 420 spin_lock(&inode->i_lock);
277459d2 421 set_page_private(req->wb_page, 0);
deb7d638 422 ClearPagePrivate(req->wb_page);
2df485a7 423 clear_bit(PG_MAPPED, &req->wb_flags);
1da177e4
LT
424 radix_tree_delete(&nfsi->nfs_page_tree, req->wb_index);
425 nfsi->npages--;
426 if (!nfsi->npages) {
587142f8 427 spin_unlock(&inode->i_lock);
1da177e4
LT
428 iput(inode);
429 } else
587142f8 430 spin_unlock(&inode->i_lock);
1da177e4
LT
431 nfs_release_request(req);
432}
433
61822ab5 434static void
6d884e8f 435nfs_mark_request_dirty(struct nfs_page *req)
61822ab5 436{
61822ab5 437 __set_page_dirty_nobuffers(req->wb_page);
b80c3cb6 438 __mark_inode_dirty(req->wb_page->mapping->host, I_DIRTY_DATASYNC);
61822ab5
TM
439}
440
1da177e4
LT
441#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
442/*
443 * Add a request to the inode's commit list.
444 */
445static void
a861a1e1 446nfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg)
1da177e4 447{
88be9f99 448 struct inode *inode = req->wb_context->path.dentry->d_inode;
1da177e4
LT
449 struct nfs_inode *nfsi = NFS_I(inode);
450
587142f8 451 spin_lock(&inode->i_lock);
e468bae9 452 set_bit(PG_CLEAN, &(req)->wb_flags);
5c369683
TM
453 radix_tree_tag_set(&nfsi->nfs_page_tree,
454 req->wb_index,
455 NFS_PAGE_TAG_COMMIT);
ff778d02 456 nfsi->ncommit++;
587142f8 457 spin_unlock(&inode->i_lock);
a861a1e1 458 pnfs_mark_request_commit(req, lseg);
fd39fc85 459 inc_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
c9e51e41 460 inc_bdi_stat(req->wb_page->mapping->backing_dev_info, BDI_RECLAIMABLE);
a1803044 461 __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
1da177e4 462}
8e821cad 463
e468bae9
TM
464static int
465nfs_clear_request_commit(struct nfs_page *req)
466{
467 struct page *page = req->wb_page;
468
469 if (test_and_clear_bit(PG_CLEAN, &(req)->wb_flags)) {
470 dec_zone_page_state(page, NR_UNSTABLE_NFS);
471 dec_bdi_stat(page->mapping->backing_dev_info, BDI_RECLAIMABLE);
472 return 1;
473 }
474 return 0;
475}
476
8e821cad
TM
477static inline
478int nfs_write_need_commit(struct nfs_write_data *data)
479{
465d5243
FI
480 if (data->verf.committed == NFS_DATA_SYNC)
481 return data->lseg == NULL;
482 else
483 return data->verf.committed != NFS_FILE_SYNC;
8e821cad
TM
484}
485
486static inline
a861a1e1
FI
487int nfs_reschedule_unstable_write(struct nfs_page *req,
488 struct nfs_write_data *data)
8e821cad 489{
e468bae9 490 if (test_and_clear_bit(PG_NEED_COMMIT, &req->wb_flags)) {
a861a1e1 491 nfs_mark_request_commit(req, data->lseg);
8e821cad
TM
492 return 1;
493 }
494 if (test_and_clear_bit(PG_NEED_RESCHED, &req->wb_flags)) {
6d884e8f 495 nfs_mark_request_dirty(req);
8e821cad
TM
496 return 1;
497 }
498 return 0;
499}
500#else
501static inline void
a861a1e1 502nfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg)
8e821cad
TM
503{
504}
505
e468bae9
TM
506static inline int
507nfs_clear_request_commit(struct nfs_page *req)
508{
509 return 0;
510}
511
8e821cad
TM
512static inline
513int nfs_write_need_commit(struct nfs_write_data *data)
514{
515 return 0;
516}
517
518static inline
a861a1e1
FI
519int nfs_reschedule_unstable_write(struct nfs_page *req,
520 struct nfs_write_data *data)
8e821cad
TM
521{
522 return 0;
523}
1da177e4
LT
524#endif
525
47c62564 526#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
fb8a1f11
TM
527static int
528nfs_need_commit(struct nfs_inode *nfsi)
529{
530 return radix_tree_tagged(&nfsi->nfs_page_tree, NFS_PAGE_TAG_COMMIT);
531}
532
1da177e4
LT
533/*
534 * nfs_scan_commit - Scan an inode for commit requests
535 * @inode: NFS inode to scan
536 * @dst: destination list
537 * @idx_start: lower bound of page->index to scan.
538 * @npages: idx_start + npages sets the upper bound to scan.
539 *
540 * Moves requests from the inode's 'commit' request list.
541 * The requests are *not* checked to ensure that they form a contiguous set.
542 */
543static int
ca52fec1 544nfs_scan_commit(struct inode *inode, struct list_head *dst, pgoff_t idx_start, unsigned int npages)
1da177e4
LT
545{
546 struct nfs_inode *nfsi = NFS_I(inode);
ff778d02 547 int ret;
3da28eb1 548
fb8a1f11
TM
549 if (!nfs_need_commit(nfsi))
550 return 0;
551
ff778d02
TM
552 ret = nfs_scan_list(nfsi, dst, idx_start, npages, NFS_PAGE_TAG_COMMIT);
553 if (ret > 0)
554 nfsi->ncommit -= ret;
2928db1f
TM
555 if (nfs_need_commit(NFS_I(inode)))
556 __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
ff778d02 557 return ret;
1da177e4 558}
c42de9dd 559#else
fb8a1f11
TM
560static inline int nfs_need_commit(struct nfs_inode *nfsi)
561{
562 return 0;
563}
564
ca52fec1 565static inline int nfs_scan_commit(struct inode *inode, struct list_head *dst, pgoff_t idx_start, unsigned int npages)
c42de9dd
TM
566{
567 return 0;
568}
1da177e4
LT
569#endif
570
1da177e4 571/*
e7d39069
TM
572 * Search for an existing write request, and attempt to update
573 * it to reflect a new dirty region on a given page.
1da177e4 574 *
e7d39069
TM
575 * If the attempt fails, then the existing request is flushed out
576 * to disk.
1da177e4 577 */
e7d39069
TM
578static struct nfs_page *nfs_try_to_update_request(struct inode *inode,
579 struct page *page,
580 unsigned int offset,
581 unsigned int bytes)
1da177e4 582{
e7d39069
TM
583 struct nfs_page *req;
584 unsigned int rqend;
585 unsigned int end;
586 int error;
587
588 if (!PagePrivate(page))
589 return NULL;
1da177e4
LT
590
591 end = offset + bytes;
e7d39069 592 spin_lock(&inode->i_lock);
1da177e4 593
1da177e4 594 for (;;) {
277459d2 595 req = nfs_page_find_request_locked(page);
e7d39069
TM
596 if (req == NULL)
597 goto out_unlock;
598
599 rqend = req->wb_offset + req->wb_bytes;
600 /*
601 * Tell the caller to flush out the request if
602 * the offsets are non-contiguous.
603 * Note: nfs_flush_incompatible() will already
604 * have flushed out requests having wrong owners.
605 */
e468bae9 606 if (offset > rqend
e7d39069
TM
607 || end < req->wb_offset)
608 goto out_flushme;
609
610 if (nfs_set_page_tag_locked(req))
1da177e4 611 break;
1da177e4 612
e7d39069 613 /* The request is locked, so wait and then retry */
587142f8 614 spin_unlock(&inode->i_lock);
e7d39069
TM
615 error = nfs_wait_on_request(req);
616 nfs_release_request(req);
617 if (error != 0)
618 goto out_err;
619 spin_lock(&inode->i_lock);
1da177e4
LT
620 }
621
ff778d02 622 if (nfs_clear_request_commit(req) &&
a861a1e1
FI
623 radix_tree_tag_clear(&NFS_I(inode)->nfs_page_tree,
624 req->wb_index, NFS_PAGE_TAG_COMMIT) != NULL) {
ff778d02 625 NFS_I(inode)->ncommit--;
a861a1e1
FI
626 pnfs_clear_request_commit(req);
627 }
e468bae9 628
1da177e4
LT
629 /* Okay, the request matches. Update the region */
630 if (offset < req->wb_offset) {
631 req->wb_offset = offset;
632 req->wb_pgbase = offset;
1da177e4 633 }
1da177e4
LT
634 if (end > rqend)
635 req->wb_bytes = end - req->wb_offset;
e7d39069
TM
636 else
637 req->wb_bytes = rqend - req->wb_offset;
638out_unlock:
639 spin_unlock(&inode->i_lock);
640 return req;
641out_flushme:
642 spin_unlock(&inode->i_lock);
643 nfs_release_request(req);
644 error = nfs_wb_page(inode, page);
645out_err:
646 return ERR_PTR(error);
647}
648
649/*
650 * Try to update an existing write request, or create one if there is none.
651 *
652 * Note: Should always be called with the Page Lock held to prevent races
653 * if we have to add a new request. Also assumes that the caller has
654 * already called nfs_flush_incompatible() if necessary.
655 */
656static struct nfs_page * nfs_setup_write_request(struct nfs_open_context* ctx,
657 struct page *page, unsigned int offset, unsigned int bytes)
658{
659 struct inode *inode = page->mapping->host;
660 struct nfs_page *req;
661 int error;
1da177e4 662
e7d39069
TM
663 req = nfs_try_to_update_request(inode, page, offset, bytes);
664 if (req != NULL)
665 goto out;
666 req = nfs_create_request(ctx, inode, page, offset, bytes);
667 if (IS_ERR(req))
668 goto out;
669 error = nfs_inode_add_request(inode, req);
670 if (error != 0) {
671 nfs_release_request(req);
672 req = ERR_PTR(error);
673 }
efc91ed0 674out:
61e930a9 675 return req;
1da177e4
LT
676}
677
e7d39069
TM
678static int nfs_writepage_setup(struct nfs_open_context *ctx, struct page *page,
679 unsigned int offset, unsigned int count)
680{
681 struct nfs_page *req;
682
683 req = nfs_setup_write_request(ctx, page, offset, count);
684 if (IS_ERR(req))
685 return PTR_ERR(req);
b80c3cb6 686 nfs_mark_request_dirty(req);
e7d39069
TM
687 /* Update file length */
688 nfs_grow_file(page, offset, count);
689 nfs_mark_uptodate(page, req->wb_pgbase, req->wb_bytes);
a6305ddb 690 nfs_mark_request_dirty(req);
e7d39069
TM
691 nfs_clear_page_tag_locked(req);
692 return 0;
693}
694
1da177e4
LT
695int nfs_flush_incompatible(struct file *file, struct page *page)
696{
cd3758e3 697 struct nfs_open_context *ctx = nfs_file_open_context(file);
1da177e4 698 struct nfs_page *req;
1a54533e 699 int do_flush, status;
1da177e4
LT
700 /*
701 * Look for a request corresponding to this page. If there
702 * is one, and it belongs to another file, we flush it out
703 * before we try to copy anything into the page. Do this
704 * due to the lack of an ACCESS-type call in NFSv2.
705 * Also do the same if we find a request from an existing
706 * dropped page.
707 */
1a54533e
TM
708 do {
709 req = nfs_page_find_request(page);
710 if (req == NULL)
711 return 0;
f11ac8db
TM
712 do_flush = req->wb_page != page || req->wb_context != ctx ||
713 req->wb_lock_context->lockowner != current->files ||
714 req->wb_lock_context->pid != current->tgid;
1da177e4 715 nfs_release_request(req);
1a54533e
TM
716 if (!do_flush)
717 return 0;
718 status = nfs_wb_page(page->mapping->host, page);
719 } while (status == 0);
720 return status;
1da177e4
LT
721}
722
5d47a356
TM
723/*
724 * If the page cache is marked as unsafe or invalid, then we can't rely on
725 * the PageUptodate() flag. In this case, we will need to turn off
726 * write optimisations that depend on the page contents being correct.
727 */
728static int nfs_write_pageuptodate(struct page *page, struct inode *inode)
729{
730 return PageUptodate(page) &&
731 !(NFS_I(inode)->cache_validity & (NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_DATA));
732}
733
1da177e4
LT
734/*
735 * Update and possibly write a cached page of an NFS file.
736 *
737 * XXX: Keep an eye on generic_file_read to make sure it doesn't do bad
738 * things with a page scheduled for an RPC call (e.g. invalidate it).
739 */
740int nfs_updatepage(struct file *file, struct page *page,
741 unsigned int offset, unsigned int count)
742{
cd3758e3 743 struct nfs_open_context *ctx = nfs_file_open_context(file);
1da177e4 744 struct inode *inode = page->mapping->host;
1da177e4
LT
745 int status = 0;
746
91d5b470
CL
747 nfs_inc_stats(inode, NFSIOS_VFSUPDATEPAGE);
748
48186c7d 749 dprintk("NFS: nfs_updatepage(%s/%s %d@%lld)\n",
01cce933
JJS
750 file->f_path.dentry->d_parent->d_name.name,
751 file->f_path.dentry->d_name.name, count,
48186c7d 752 (long long)(page_offset(page) + offset));
1da177e4 753
1da177e4 754 /* If we're not using byte range locks, and we know the page
5d47a356
TM
755 * is up to date, it may be more efficient to extend the write
756 * to cover the entire page in order to avoid fragmentation
757 * inefficiencies.
1da177e4 758 */
5d47a356
TM
759 if (nfs_write_pageuptodate(page, inode) &&
760 inode->i_flock == NULL &&
6b2f3d1f 761 !(file->f_flags & O_DSYNC)) {
49a70f27 762 count = max(count + offset, nfs_page_length(page));
1da177e4 763 offset = 0;
1da177e4
LT
764 }
765
e21195a7 766 status = nfs_writepage_setup(ctx, page, offset, count);
03fa9e84
TM
767 if (status < 0)
768 nfs_set_pageerror(page);
1da177e4 769
48186c7d 770 dprintk("NFS: nfs_updatepage returns %d (isize %lld)\n",
1da177e4 771 status, (long long)i_size_read(inode));
1da177e4
LT
772 return status;
773}
774
a861a1e1
FI
775static void nfs_writepage_release(struct nfs_page *req,
776 struct nfs_write_data *data)
1da177e4 777{
a6305ddb 778 struct page *page = req->wb_page;
1da177e4 779
a861a1e1 780 if (PageError(req->wb_page) || !nfs_reschedule_unstable_write(req, data))
8e821cad 781 nfs_inode_remove_request(req);
9fd367f0 782 nfs_clear_page_tag_locked(req);
a6305ddb 783 nfs_end_page_writeback(page);
1da177e4
LT
784}
785
3ff7576d 786static int flush_task_priority(int how)
1da177e4
LT
787{
788 switch (how & (FLUSH_HIGHPRI|FLUSH_LOWPRI)) {
789 case FLUSH_HIGHPRI:
790 return RPC_PRIORITY_HIGH;
791 case FLUSH_LOWPRI:
792 return RPC_PRIORITY_LOW;
793 }
794 return RPC_PRIORITY_NORMAL;
795}
796
a69aef14 797int nfs_initiate_write(struct nfs_write_data *data,
d138d5d1
AA
798 struct rpc_clnt *clnt,
799 const struct rpc_call_ops *call_ops,
800 int how)
1da177e4 801{
d138d5d1 802 struct inode *inode = data->inode;
3ff7576d 803 int priority = flush_task_priority(how);
07737691 804 struct rpc_task *task;
bdc7f021
TM
805 struct rpc_message msg = {
806 .rpc_argp = &data->args,
807 .rpc_resp = &data->res,
d138d5d1 808 .rpc_cred = data->cred,
bdc7f021 809 };
84115e1c 810 struct rpc_task_setup task_setup_data = {
d138d5d1 811 .rpc_client = clnt,
07737691 812 .task = &data->task,
bdc7f021 813 .rpc_message = &msg,
84115e1c
TM
814 .callback_ops = call_ops,
815 .callback_data = data,
101070ca 816 .workqueue = nfsiod_workqueue,
2c61be0a 817 .flags = RPC_TASK_ASYNC,
3ff7576d 818 .priority = priority,
84115e1c 819 };
2c61be0a 820 int ret = 0;
1da177e4 821
d138d5d1
AA
822 /* Set up the initial task struct. */
823 NFS_PROTO(inode)->write_setup(data, &msg);
824
825 dprintk("NFS: %5u initiated write call "
826 "(req %s/%lld, %u bytes @ offset %llu)\n",
827 data->task.tk_pid,
828 inode->i_sb->s_id,
829 (long long)NFS_FILEID(inode),
830 data->args.count,
831 (unsigned long long)data->args.offset);
832
833 task = rpc_run_task(&task_setup_data);
834 if (IS_ERR(task)) {
835 ret = PTR_ERR(task);
836 goto out;
837 }
838 if (how & FLUSH_SYNC) {
839 ret = rpc_wait_for_completion_task(task);
840 if (ret == 0)
841 ret = task->tk_status;
842 }
843 rpc_put_task(task);
844out:
845 return ret;
846}
a69aef14 847EXPORT_SYMBOL_GPL(nfs_initiate_write);
d138d5d1
AA
848
849/*
850 * Set up the argument/result storage required for the RPC call.
851 */
852static int nfs_write_rpcsetup(struct nfs_page *req,
853 struct nfs_write_data *data,
854 const struct rpc_call_ops *call_ops,
855 unsigned int count, unsigned int offset,
5053aa56 856 struct pnfs_layout_segment *lseg,
d138d5d1
AA
857 int how)
858{
859 struct inode *inode = req->wb_context->path.dentry->d_inode;
860
1da177e4
LT
861 /* Set up the RPC argument and reply structs
862 * NB: take care not to mess about with data->commit et al. */
863
864 data->req = req;
88be9f99 865 data->inode = inode = req->wb_context->path.dentry->d_inode;
d138d5d1 866 data->cred = req->wb_context->cred;
5053aa56 867 data->lseg = get_lseg(lseg);
1da177e4
LT
868
869 data->args.fh = NFS_FH(inode);
870 data->args.offset = req_offset(req) + offset;
871 data->args.pgbase = req->wb_pgbase + offset;
872 data->args.pages = data->pagevec;
873 data->args.count = count;
383ba719 874 data->args.context = get_nfs_open_context(req->wb_context);
f11ac8db 875 data->args.lock_context = req->wb_lock_context;
bdc7f021 876 data->args.stable = NFS_UNSTABLE;
b31268ac 877 if (how & (FLUSH_STABLE | FLUSH_COND_STABLE)) {
bdc7f021 878 data->args.stable = NFS_DATA_SYNC;
fb8a1f11 879 if (!nfs_need_commit(NFS_I(inode)))
bdc7f021
TM
880 data->args.stable = NFS_FILE_SYNC;
881 }
1da177e4
LT
882
883 data->res.fattr = &data->fattr;
884 data->res.count = count;
885 data->res.verf = &data->verf;
0e574af1 886 nfs_fattr_init(&data->fattr);
1da177e4 887
0382b744
AA
888 if (data->lseg &&
889 (pnfs_try_to_write_data(data, call_ops, how) == PNFS_ATTEMPTED))
890 return 0;
891
d138d5d1 892 return nfs_initiate_write(data, NFS_CLIENT(inode), call_ops, how);
1da177e4
LT
893}
894
6d884e8f
F
895/* If a nfs_flush_* function fails, it should remove reqs from @head and
896 * call this on each, which will prepare them to be retried on next
897 * writeback using standard nfs.
898 */
899static void nfs_redirty_request(struct nfs_page *req)
900{
a6305ddb
TM
901 struct page *page = req->wb_page;
902
6d884e8f 903 nfs_mark_request_dirty(req);
6d884e8f 904 nfs_clear_page_tag_locked(req);
a6305ddb 905 nfs_end_page_writeback(page);
6d884e8f
F
906}
907
1da177e4
LT
908/*
909 * Generate multiple small requests to write out a single
910 * contiguous dirty area on one page.
911 */
c76069bd 912static int nfs_flush_multi(struct nfs_pageio_descriptor *desc)
1da177e4 913{
c76069bd 914 struct nfs_page *req = nfs_list_entry(desc->pg_list.next);
1da177e4
LT
915 struct page *page = req->wb_page;
916 struct nfs_write_data *data;
c76069bd 917 size_t wsize = NFS_SERVER(desc->pg_inode)->wsize, nbytes;
e9f7bee1 918 unsigned int offset;
1da177e4 919 int requests = 0;
dbae4c73 920 int ret = 0;
c76069bd 921 struct pnfs_layout_segment *lseg;
1da177e4
LT
922 LIST_HEAD(list);
923
924 nfs_list_remove_request(req);
925
b31268ac
TM
926 if ((desc->pg_ioflags & FLUSH_COND_STABLE) &&
927 (desc->pg_moreio || NFS_I(desc->pg_inode)->ncommit ||
928 desc->pg_count > wsize))
929 desc->pg_ioflags &= ~FLUSH_COND_STABLE;
930
931
c76069bd 932 nbytes = desc->pg_count;
e9f7bee1
TM
933 do {
934 size_t len = min(nbytes, wsize);
935
8d5658c9 936 data = nfs_writedata_alloc(1);
1da177e4
LT
937 if (!data)
938 goto out_bad;
939 list_add(&data->pages, &list);
940 requests++;
e9f7bee1
TM
941 nbytes -= len;
942 } while (nbytes != 0);
1da177e4
LT
943 atomic_set(&req->wb_complete, requests);
944
c76069bd
FI
945 BUG_ON(desc->pg_lseg);
946 lseg = pnfs_update_layout(desc->pg_inode, req->wb_context, IOMODE_RW);
1da177e4 947 ClearPageError(page);
1da177e4 948 offset = 0;
c76069bd 949 nbytes = desc->pg_count;
1da177e4 950 do {
dbae4c73
TM
951 int ret2;
952
1da177e4
LT
953 data = list_entry(list.next, struct nfs_write_data, pages);
954 list_del_init(&data->pages);
955
956 data->pagevec[0] = page;
1da177e4 957
bcb71bba
TM
958 if (nbytes < wsize)
959 wsize = nbytes;
dbae4c73 960 ret2 = nfs_write_rpcsetup(req, data, &nfs_write_partial_ops,
c76069bd 961 wsize, offset, lseg, desc->pg_ioflags);
dbae4c73
TM
962 if (ret == 0)
963 ret = ret2;
bcb71bba
TM
964 offset += wsize;
965 nbytes -= wsize;
1da177e4
LT
966 } while (nbytes != 0);
967
44b83799 968 put_lseg(lseg);
36fe432d 969 desc->pg_lseg = NULL;
dbae4c73 970 return ret;
1da177e4
LT
971
972out_bad:
973 while (!list_empty(&list)) {
974 data = list_entry(list.next, struct nfs_write_data, pages);
975 list_del(&data->pages);
0da2a4ac 976 nfs_writedata_free(data);
1da177e4 977 }
61822ab5 978 nfs_redirty_request(req);
1da177e4
LT
979 return -ENOMEM;
980}
981
982/*
983 * Create an RPC task for the given write request and kick it.
984 * The page must have been locked by the caller.
985 *
986 * It may happen that the page we're passed is not marked dirty.
987 * This is the case if nfs_updatepage detects a conflicting request
988 * that has been written but not committed.
989 */
c76069bd 990static int nfs_flush_one(struct nfs_pageio_descriptor *desc)
1da177e4
LT
991{
992 struct nfs_page *req;
993 struct page **pages;
994 struct nfs_write_data *data;
c76069bd
FI
995 struct list_head *head = &desc->pg_list;
996 struct pnfs_layout_segment *lseg = desc->pg_lseg;
44b83799 997 int ret;
1da177e4 998
c76069bd
FI
999 data = nfs_writedata_alloc(nfs_page_array_len(desc->pg_base,
1000 desc->pg_count));
44b83799
FI
1001 if (!data) {
1002 while (!list_empty(head)) {
1003 req = nfs_list_entry(head->next);
1004 nfs_list_remove_request(req);
1005 nfs_redirty_request(req);
1006 }
1007 ret = -ENOMEM;
1008 goto out;
1009 }
1da177e4 1010 pages = data->pagevec;
1da177e4
LT
1011 while (!list_empty(head)) {
1012 req = nfs_list_entry(head->next);
1013 nfs_list_remove_request(req);
1014 nfs_list_add_request(req, &data->pages);
1015 ClearPageError(req->wb_page);
1da177e4 1016 *pages++ = req->wb_page;
1da177e4
LT
1017 }
1018 req = nfs_list_entry(data->pages.next);
44b83799 1019 if ((!lseg) && list_is_singular(&data->pages))
c76069bd 1020 lseg = pnfs_update_layout(desc->pg_inode, req->wb_context, IOMODE_RW);
1da177e4 1021
b31268ac
TM
1022 if ((desc->pg_ioflags & FLUSH_COND_STABLE) &&
1023 (desc->pg_moreio || NFS_I(desc->pg_inode)->ncommit))
1024 desc->pg_ioflags &= ~FLUSH_COND_STABLE;
1025
1da177e4 1026 /* Set up the argument struct */
c76069bd 1027 ret = nfs_write_rpcsetup(req, data, &nfs_write_full_ops, desc->pg_count, 0, lseg, desc->pg_ioflags);
44b83799
FI
1028out:
1029 put_lseg(lseg); /* Cleans any gotten in ->pg_test */
36fe432d 1030 desc->pg_lseg = NULL;
44b83799 1031 return ret;
1da177e4
LT
1032}
1033
c63c7b05
TM
1034static void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio,
1035 struct inode *inode, int ioflags)
1da177e4 1036{
bf4285e7 1037 size_t wsize = NFS_SERVER(inode)->wsize;
1da177e4 1038
44b83799 1039 pnfs_pageio_init_write(pgio, inode);
94ad1c80 1040
bcb71bba 1041 if (wsize < PAGE_CACHE_SIZE)
c63c7b05 1042 nfs_pageio_init(pgio, inode, nfs_flush_multi, wsize, ioflags);
bcb71bba 1043 else
c63c7b05 1044 nfs_pageio_init(pgio, inode, nfs_flush_one, wsize, ioflags);
1da177e4
LT
1045}
1046
1047/*
1048 * Handle a write reply that flushed part of a page.
1049 */
788e7a89 1050static void nfs_writeback_done_partial(struct rpc_task *task, void *calldata)
1da177e4 1051{
788e7a89 1052 struct nfs_write_data *data = calldata;
1da177e4 1053
48186c7d
CL
1054 dprintk("NFS: %5u write(%s/%lld %d@%lld)",
1055 task->tk_pid,
1056 data->req->wb_context->path.dentry->d_inode->i_sb->s_id,
1057 (long long)
1058 NFS_FILEID(data->req->wb_context->path.dentry->d_inode),
1059 data->req->wb_bytes, (long long)req_offset(data->req));
1da177e4 1060
c9d8f89d
TM
1061 nfs_writeback_done(task, data);
1062}
788e7a89 1063
c9d8f89d
TM
1064static void nfs_writeback_release_partial(void *calldata)
1065{
1066 struct nfs_write_data *data = calldata;
1067 struct nfs_page *req = data->req;
1068 struct page *page = req->wb_page;
1069 int status = data->task.tk_status;
1070
1071 if (status < 0) {
a301b777 1072 nfs_set_pageerror(page);
c9d8f89d
TM
1073 nfs_context_set_write_error(req->wb_context, status);
1074 dprintk(", error = %d\n", status);
8e821cad 1075 goto out;
1da177e4
LT
1076 }
1077
8e821cad 1078 if (nfs_write_need_commit(data)) {
587142f8 1079 struct inode *inode = page->mapping->host;
8e821cad 1080
587142f8 1081 spin_lock(&inode->i_lock);
8e821cad
TM
1082 if (test_bit(PG_NEED_RESCHED, &req->wb_flags)) {
1083 /* Do nothing we need to resend the writes */
1084 } else if (!test_and_set_bit(PG_NEED_COMMIT, &req->wb_flags)) {
1085 memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf));
1086 dprintk(" defer commit\n");
1087 } else if (memcmp(&req->wb_verf, &data->verf, sizeof(req->wb_verf))) {
1088 set_bit(PG_NEED_RESCHED, &req->wb_flags);
1089 clear_bit(PG_NEED_COMMIT, &req->wb_flags);
1090 dprintk(" server reboot detected\n");
1091 }
587142f8 1092 spin_unlock(&inode->i_lock);
8e821cad
TM
1093 } else
1094 dprintk(" OK\n");
1095
1096out:
1da177e4 1097 if (atomic_dec_and_test(&req->wb_complete))
a861a1e1 1098 nfs_writepage_release(req, data);
c9d8f89d 1099 nfs_writedata_release(calldata);
1da177e4
LT
1100}
1101
def6ed7e
AA
1102#if defined(CONFIG_NFS_V4_1)
1103void nfs_write_prepare(struct rpc_task *task, void *calldata)
1104{
1105 struct nfs_write_data *data = calldata;
def6ed7e 1106
035168ab
TM
1107 if (nfs4_setup_sequence(NFS_SERVER(data->inode),
1108 &data->args.seq_args,
def6ed7e
AA
1109 &data->res.seq_res, 1, task))
1110 return;
1111 rpc_call_start(task);
1112}
1113#endif /* CONFIG_NFS_V4_1 */
1114
788e7a89 1115static const struct rpc_call_ops nfs_write_partial_ops = {
def6ed7e
AA
1116#if defined(CONFIG_NFS_V4_1)
1117 .rpc_call_prepare = nfs_write_prepare,
1118#endif /* CONFIG_NFS_V4_1 */
788e7a89 1119 .rpc_call_done = nfs_writeback_done_partial,
c9d8f89d 1120 .rpc_release = nfs_writeback_release_partial,
788e7a89
TM
1121};
1122
1da177e4
LT
1123/*
1124 * Handle a write reply that flushes a whole page.
1125 *
1126 * FIXME: There is an inherent race with invalidate_inode_pages and
1127 * writebacks since the page->count is kept > 1 for as long
1128 * as the page has a write request pending.
1129 */
788e7a89 1130static void nfs_writeback_done_full(struct rpc_task *task, void *calldata)
1da177e4 1131{
788e7a89 1132 struct nfs_write_data *data = calldata;
1da177e4 1133
c9d8f89d
TM
1134 nfs_writeback_done(task, data);
1135}
1136
1137static void nfs_writeback_release_full(void *calldata)
1138{
1139 struct nfs_write_data *data = calldata;
1140 int status = data->task.tk_status;
788e7a89 1141
1da177e4
LT
1142 /* Update attributes as result of writeback. */
1143 while (!list_empty(&data->pages)) {
c9d8f89d
TM
1144 struct nfs_page *req = nfs_list_entry(data->pages.next);
1145 struct page *page = req->wb_page;
1146
1da177e4 1147 nfs_list_remove_request(req);
1da177e4 1148
48186c7d
CL
1149 dprintk("NFS: %5u write (%s/%lld %d@%lld)",
1150 data->task.tk_pid,
88be9f99
TM
1151 req->wb_context->path.dentry->d_inode->i_sb->s_id,
1152 (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
1da177e4
LT
1153 req->wb_bytes,
1154 (long long)req_offset(req));
1155
c9d8f89d 1156 if (status < 0) {
a301b777 1157 nfs_set_pageerror(page);
c9d8f89d
TM
1158 nfs_context_set_write_error(req->wb_context, status);
1159 dprintk(", error = %d\n", status);
8e821cad 1160 goto remove_request;
1da177e4 1161 }
1da177e4 1162
8e821cad
TM
1163 if (nfs_write_need_commit(data)) {
1164 memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf));
a861a1e1 1165 nfs_mark_request_commit(req, data->lseg);
8e821cad 1166 dprintk(" marked for commit\n");
1da177e4
LT
1167 goto next;
1168 }
8e821cad
TM
1169 dprintk(" OK\n");
1170remove_request:
1da177e4 1171 nfs_inode_remove_request(req);
1da177e4 1172 next:
9fd367f0 1173 nfs_clear_page_tag_locked(req);
a6305ddb 1174 nfs_end_page_writeback(page);
1da177e4 1175 }
c9d8f89d 1176 nfs_writedata_release(calldata);
1da177e4
LT
1177}
1178
788e7a89 1179static const struct rpc_call_ops nfs_write_full_ops = {
def6ed7e
AA
1180#if defined(CONFIG_NFS_V4_1)
1181 .rpc_call_prepare = nfs_write_prepare,
1182#endif /* CONFIG_NFS_V4_1 */
788e7a89 1183 .rpc_call_done = nfs_writeback_done_full,
c9d8f89d 1184 .rpc_release = nfs_writeback_release_full,
788e7a89
TM
1185};
1186
1187
1da177e4
LT
1188/*
1189 * This function is called when the WRITE call is complete.
1190 */
13602896 1191void nfs_writeback_done(struct rpc_task *task, struct nfs_write_data *data)
1da177e4 1192{
1da177e4
LT
1193 struct nfs_writeargs *argp = &data->args;
1194 struct nfs_writeres *resp = &data->res;
eedc020e 1195 struct nfs_server *server = NFS_SERVER(data->inode);
788e7a89 1196 int status;
1da177e4 1197
a3f565b1 1198 dprintk("NFS: %5u nfs_writeback_done (status %d)\n",
1da177e4
LT
1199 task->tk_pid, task->tk_status);
1200
f551e44f
CL
1201 /*
1202 * ->write_done will attempt to use post-op attributes to detect
1203 * conflicting writes by other clients. A strict interpretation
1204 * of close-to-open would allow us to continue caching even if
1205 * another writer had changed the file, but some applications
1206 * depend on tighter cache coherency when writing.
1207 */
788e7a89
TM
1208 status = NFS_PROTO(data->inode)->write_done(task, data);
1209 if (status != 0)
13602896 1210 return;
91d5b470
CL
1211 nfs_add_stats(data->inode, NFSIOS_SERVERWRITTENBYTES, resp->count);
1212
1da177e4
LT
1213#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
1214 if (resp->verf->committed < argp->stable && task->tk_status >= 0) {
1215 /* We tried a write call, but the server did not
1216 * commit data to stable storage even though we
1217 * requested it.
1218 * Note: There is a known bug in Tru64 < 5.0 in which
1219 * the server reports NFS_DATA_SYNC, but performs
1220 * NFS_FILE_SYNC. We therefore implement this checking
1221 * as a dprintk() in order to avoid filling syslog.
1222 */
1223 static unsigned long complain;
1224
a69aef14 1225 /* Note this will print the MDS for a DS write */
1da177e4 1226 if (time_before(complain, jiffies)) {
48186c7d 1227 dprintk("NFS: faulty NFS server %s:"
1da177e4 1228 " (committed = %d) != (stable = %d)\n",
eedc020e 1229 server->nfs_client->cl_hostname,
1da177e4
LT
1230 resp->verf->committed, argp->stable);
1231 complain = jiffies + 300 * HZ;
1232 }
1233 }
1234#endif
1235 /* Is this a short write? */
1236 if (task->tk_status >= 0 && resp->count < argp->count) {
1237 static unsigned long complain;
1238
91d5b470
CL
1239 nfs_inc_stats(data->inode, NFSIOS_SHORTWRITE);
1240
1da177e4
LT
1241 /* Has the server at least made some progress? */
1242 if (resp->count != 0) {
1243 /* Was this an NFSv2 write or an NFSv3 stable write? */
1244 if (resp->verf->committed != NFS_UNSTABLE) {
1245 /* Resend from where the server left off */
a69aef14 1246 data->mds_offset += resp->count;
1da177e4
LT
1247 argp->offset += resp->count;
1248 argp->pgbase += resp->count;
1249 argp->count -= resp->count;
1250 } else {
1251 /* Resend as a stable write in order to avoid
1252 * headaches in the case of a server crash.
1253 */
1254 argp->stable = NFS_FILE_SYNC;
1255 }
0110ee15 1256 nfs_restart_rpc(task, server->nfs_client);
13602896 1257 return;
1da177e4
LT
1258 }
1259 if (time_before(complain, jiffies)) {
1260 printk(KERN_WARNING
1261 "NFS: Server wrote zero bytes, expected %u.\n",
1262 argp->count);
1263 complain = jiffies + 300 * HZ;
1264 }
1265 /* Can't do anything about it except throw an error. */
1266 task->tk_status = -EIO;
1267 }
13602896 1268 return;
1da177e4
LT
1269}
1270
1271
1272#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
71d0a611
TM
1273static int nfs_commit_set_lock(struct nfs_inode *nfsi, int may_wait)
1274{
b8413f98
TM
1275 int ret;
1276
71d0a611
TM
1277 if (!test_and_set_bit(NFS_INO_COMMIT, &nfsi->flags))
1278 return 1;
b8413f98
TM
1279 if (!may_wait)
1280 return 0;
1281 ret = out_of_line_wait_on_bit_lock(&nfsi->flags,
1282 NFS_INO_COMMIT,
1283 nfs_wait_bit_killable,
1284 TASK_KILLABLE);
1285 return (ret < 0) ? ret : 1;
71d0a611
TM
1286}
1287
e0c2b380 1288void nfs_commit_clear_lock(struct nfs_inode *nfsi)
71d0a611
TM
1289{
1290 clear_bit(NFS_INO_COMMIT, &nfsi->flags);
1291 smp_mb__after_clear_bit();
1292 wake_up_bit(&nfsi->flags, NFS_INO_COMMIT);
1293}
e0c2b380 1294EXPORT_SYMBOL_GPL(nfs_commit_clear_lock);
71d0a611 1295
e0c2b380 1296void nfs_commitdata_release(void *data)
1da177e4 1297{
383ba719
TM
1298 struct nfs_write_data *wdata = data;
1299
988b6dce 1300 put_lseg(wdata->lseg);
383ba719 1301 put_nfs_open_context(wdata->args.context);
1da177e4
LT
1302 nfs_commit_free(wdata);
1303}
e0c2b380 1304EXPORT_SYMBOL_GPL(nfs_commitdata_release);
1da177e4 1305
e0c2b380 1306int nfs_initiate_commit(struct nfs_write_data *data, struct rpc_clnt *clnt,
9ace33cd
FI
1307 const struct rpc_call_ops *call_ops,
1308 int how)
1da177e4 1309{
07737691 1310 struct rpc_task *task;
9ace33cd 1311 int priority = flush_task_priority(how);
bdc7f021
TM
1312 struct rpc_message msg = {
1313 .rpc_argp = &data->args,
1314 .rpc_resp = &data->res,
9ace33cd 1315 .rpc_cred = data->cred,
bdc7f021 1316 };
84115e1c 1317 struct rpc_task_setup task_setup_data = {
07737691 1318 .task = &data->task,
9ace33cd 1319 .rpc_client = clnt,
bdc7f021 1320 .rpc_message = &msg,
9ace33cd 1321 .callback_ops = call_ops,
84115e1c 1322 .callback_data = data,
101070ca 1323 .workqueue = nfsiod_workqueue,
2c61be0a 1324 .flags = RPC_TASK_ASYNC,
3ff7576d 1325 .priority = priority,
84115e1c 1326 };
9ace33cd
FI
1327 /* Set up the initial task struct. */
1328 NFS_PROTO(data->inode)->commit_setup(data, &msg);
1329
1330 dprintk("NFS: %5u initiated commit call\n", data->task.tk_pid);
1331
1332 task = rpc_run_task(&task_setup_data);
1333 if (IS_ERR(task))
1334 return PTR_ERR(task);
1335 if (how & FLUSH_SYNC)
1336 rpc_wait_for_completion_task(task);
1337 rpc_put_task(task);
1338 return 0;
1339}
e0c2b380 1340EXPORT_SYMBOL_GPL(nfs_initiate_commit);
9ace33cd
FI
1341
1342/*
1343 * Set up the argument/result storage required for the RPC call.
1344 */
e0c2b380 1345void nfs_init_commit(struct nfs_write_data *data,
988b6dce
FI
1346 struct list_head *head,
1347 struct pnfs_layout_segment *lseg)
9ace33cd
FI
1348{
1349 struct nfs_page *first = nfs_list_entry(head->next);
1350 struct inode *inode = first->wb_context->path.dentry->d_inode;
1da177e4
LT
1351
1352 /* Set up the RPC argument and reply structs
1353 * NB: take care not to mess about with data->commit et al. */
1354
1355 list_splice_init(head, &data->pages);
1da177e4 1356
1da177e4 1357 data->inode = inode;
9ace33cd 1358 data->cred = first->wb_context->cred;
988b6dce 1359 data->lseg = lseg; /* reference transferred */
9ace33cd 1360 data->mds_ops = &nfs_commit_ops;
1da177e4
LT
1361
1362 data->args.fh = NFS_FH(data->inode);
3da28eb1
TM
1363 /* Note: we always request a commit of the entire inode */
1364 data->args.offset = 0;
1365 data->args.count = 0;
383ba719 1366 data->args.context = get_nfs_open_context(first->wb_context);
3da28eb1 1367 data->res.count = 0;
1da177e4
LT
1368 data->res.fattr = &data->fattr;
1369 data->res.verf = &data->verf;
0e574af1 1370 nfs_fattr_init(&data->fattr);
1da177e4 1371}
e0c2b380 1372EXPORT_SYMBOL_GPL(nfs_init_commit);
1da177e4 1373
e0c2b380 1374void nfs_retry_commit(struct list_head *page_list,
a861a1e1 1375 struct pnfs_layout_segment *lseg)
64bfeb49
FI
1376{
1377 struct nfs_page *req;
1378
1379 while (!list_empty(page_list)) {
1380 req = nfs_list_entry(page_list->next);
1381 nfs_list_remove_request(req);
a861a1e1 1382 nfs_mark_request_commit(req, lseg);
64bfeb49
FI
1383 dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
1384 dec_bdi_stat(req->wb_page->mapping->backing_dev_info,
1385 BDI_RECLAIMABLE);
1386 nfs_clear_page_tag_locked(req);
1387 }
1388}
e0c2b380 1389EXPORT_SYMBOL_GPL(nfs_retry_commit);
64bfeb49 1390
1da177e4
LT
1391/*
1392 * Commit dirty pages
1393 */
1394static int
40859d7e 1395nfs_commit_list(struct inode *inode, struct list_head *head, int how)
1da177e4
LT
1396{
1397 struct nfs_write_data *data;
1da177e4 1398
c9d8f89d 1399 data = nfs_commitdata_alloc();
1da177e4
LT
1400
1401 if (!data)
1402 goto out_bad;
1403
1404 /* Set up the argument struct */
988b6dce 1405 nfs_init_commit(data, head, NULL);
9ace33cd 1406 return nfs_initiate_commit(data, NFS_CLIENT(inode), data->mds_ops, how);
1da177e4 1407 out_bad:
a861a1e1 1408 nfs_retry_commit(head, NULL);
71d0a611 1409 nfs_commit_clear_lock(NFS_I(inode));
1da177e4
LT
1410 return -ENOMEM;
1411}
1412
1413/*
1414 * COMMIT call returned
1415 */
788e7a89 1416static void nfs_commit_done(struct rpc_task *task, void *calldata)
1da177e4 1417{
963d8fe5 1418 struct nfs_write_data *data = calldata;
1da177e4 1419
a3f565b1 1420 dprintk("NFS: %5u nfs_commit_done (status %d)\n",
1da177e4
LT
1421 task->tk_pid, task->tk_status);
1422
788e7a89
TM
1423 /* Call the NFS version-specific code */
1424 if (NFS_PROTO(data->inode)->commit_done(task, data) != 0)
1425 return;
c9d8f89d
TM
1426}
1427
e0c2b380 1428void nfs_commit_release_pages(struct nfs_write_data *data)
c9d8f89d 1429{
5917ce84 1430 struct nfs_page *req;
c9d8f89d 1431 int status = data->task.tk_status;
788e7a89 1432
1da177e4
LT
1433 while (!list_empty(&data->pages)) {
1434 req = nfs_list_entry(data->pages.next);
1435 nfs_list_remove_request(req);
e468bae9 1436 nfs_clear_request_commit(req);
1da177e4 1437
48186c7d 1438 dprintk("NFS: commit (%s/%lld %d@%lld)",
88be9f99
TM
1439 req->wb_context->path.dentry->d_inode->i_sb->s_id,
1440 (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
1da177e4
LT
1441 req->wb_bytes,
1442 (long long)req_offset(req));
c9d8f89d
TM
1443 if (status < 0) {
1444 nfs_context_set_write_error(req->wb_context, status);
1da177e4 1445 nfs_inode_remove_request(req);
c9d8f89d 1446 dprintk(", error = %d\n", status);
1da177e4
LT
1447 goto next;
1448 }
1449
1450 /* Okay, COMMIT succeeded, apparently. Check the verifier
1451 * returned by the server against all stored verfs. */
1452 if (!memcmp(req->wb_verf.verifier, data->verf.verifier, sizeof(data->verf.verifier))) {
1453 /* We have a match */
1454 nfs_inode_remove_request(req);
1455 dprintk(" OK\n");
1456 goto next;
1457 }
1458 /* We have a mismatch. Write the page again */
1459 dprintk(" mismatch\n");
6d884e8f 1460 nfs_mark_request_dirty(req);
1da177e4 1461 next:
9fd367f0 1462 nfs_clear_page_tag_locked(req);
1da177e4 1463 }
5917ce84 1464}
e0c2b380 1465EXPORT_SYMBOL_GPL(nfs_commit_release_pages);
5917ce84
FI
1466
1467static void nfs_commit_release(void *calldata)
1468{
1469 struct nfs_write_data *data = calldata;
1470
1471 nfs_commit_release_pages(data);
71d0a611 1472 nfs_commit_clear_lock(NFS_I(data->inode));
c9d8f89d 1473 nfs_commitdata_release(calldata);
1da177e4 1474}
788e7a89
TM
1475
1476static const struct rpc_call_ops nfs_commit_ops = {
21d9a851
AA
1477#if defined(CONFIG_NFS_V4_1)
1478 .rpc_call_prepare = nfs_write_prepare,
1479#endif /* CONFIG_NFS_V4_1 */
788e7a89
TM
1480 .rpc_call_done = nfs_commit_done,
1481 .rpc_release = nfs_commit_release,
1482};
1da177e4 1483
b608b283 1484int nfs_commit_inode(struct inode *inode, int how)
1da177e4 1485{
1da177e4 1486 LIST_HEAD(head);
71d0a611 1487 int may_wait = how & FLUSH_SYNC;
b8413f98 1488 int res;
1da177e4 1489
b8413f98
TM
1490 res = nfs_commit_set_lock(NFS_I(inode), may_wait);
1491 if (res <= 0)
c5efa5fc 1492 goto out_mark_dirty;
587142f8 1493 spin_lock(&inode->i_lock);
3da28eb1 1494 res = nfs_scan_commit(inode, &head, 0, 0);
587142f8 1495 spin_unlock(&inode->i_lock);
1da177e4 1496 if (res) {
a861a1e1
FI
1497 int error;
1498
1499 error = pnfs_commit_list(inode, &head, how);
1500 if (error == PNFS_NOT_ATTEMPTED)
1501 error = nfs_commit_list(inode, &head, how);
3da28eb1
TM
1502 if (error < 0)
1503 return error;
b8413f98 1504 if (!may_wait)
c5efa5fc 1505 goto out_mark_dirty;
b8413f98
TM
1506 error = wait_on_bit(&NFS_I(inode)->flags,
1507 NFS_INO_COMMIT,
1508 nfs_wait_bit_killable,
1509 TASK_KILLABLE);
1510 if (error < 0)
1511 return error;
71d0a611
TM
1512 } else
1513 nfs_commit_clear_lock(NFS_I(inode));
c5efa5fc
TM
1514 return res;
1515 /* Note: If we exit without ensuring that the commit is complete,
1516 * we must mark the inode as dirty. Otherwise, future calls to
1517 * sync_inode() with the WB_SYNC_ALL flag set will fail to ensure
1518 * that the data is on the disk.
1519 */
1520out_mark_dirty:
1521 __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
1da177e4
LT
1522 return res;
1523}
8fc795f7
TM
1524
1525static int nfs_commit_unstable_pages(struct inode *inode, struct writeback_control *wbc)
1526{
420e3646
TM
1527 struct nfs_inode *nfsi = NFS_I(inode);
1528 int flags = FLUSH_SYNC;
1529 int ret = 0;
8fc795f7 1530
a00dd6c0
JL
1531 if (wbc->sync_mode == WB_SYNC_NONE) {
1532 /* Don't commit yet if this is a non-blocking flush and there
1533 * are a lot of outstanding writes for this mapping.
1534 */
1535 if (nfsi->ncommit <= (nfsi->npages >> 1))
1536 goto out_mark_dirty;
420e3646 1537
a00dd6c0 1538 /* don't wait for the COMMIT response */
420e3646 1539 flags = 0;
a00dd6c0
JL
1540 }
1541
420e3646
TM
1542 ret = nfs_commit_inode(inode, flags);
1543 if (ret >= 0) {
1544 if (wbc->sync_mode == WB_SYNC_NONE) {
1545 if (ret < wbc->nr_to_write)
1546 wbc->nr_to_write -= ret;
1547 else
1548 wbc->nr_to_write = 0;
1549 }
8fc795f7 1550 return 0;
420e3646
TM
1551 }
1552out_mark_dirty:
8fc795f7
TM
1553 __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
1554 return ret;
1555}
c63c7b05 1556#else
8fc795f7
TM
1557static int nfs_commit_unstable_pages(struct inode *inode, struct writeback_control *wbc)
1558{
1559 return 0;
1560}
1da177e4
LT
1561#endif
1562
8fc795f7
TM
1563int nfs_write_inode(struct inode *inode, struct writeback_control *wbc)
1564{
1565 return nfs_commit_unstable_pages(inode, wbc);
1566}
1567
acdc53b2
TM
1568/*
1569 * flush the inode to disk.
1570 */
1571int nfs_wb_all(struct inode *inode)
34901f70
TM
1572{
1573 struct writeback_control wbc = {
72cb77f4 1574 .sync_mode = WB_SYNC_ALL,
34901f70 1575 .nr_to_write = LONG_MAX,
d7fb1207
TM
1576 .range_start = 0,
1577 .range_end = LLONG_MAX,
34901f70 1578 };
34901f70 1579
acdc53b2 1580 return sync_inode(inode, &wbc);
1c75950b
TM
1581}
1582
1b3b4a1a
TM
1583int nfs_wb_page_cancel(struct inode *inode, struct page *page)
1584{
1585 struct nfs_page *req;
1b3b4a1a
TM
1586 int ret = 0;
1587
1588 BUG_ON(!PageLocked(page));
1589 for (;;) {
ba8b06e6 1590 wait_on_page_writeback(page);
1b3b4a1a
TM
1591 req = nfs_page_find_request(page);
1592 if (req == NULL)
1b3b4a1a 1593 break;
1b3b4a1a
TM
1594 if (nfs_lock_request_dontget(req)) {
1595 nfs_inode_remove_request(req);
1596 /*
1597 * In case nfs_inode_remove_request has marked the
1598 * page as being dirty
1599 */
1600 cancel_dirty_page(page, PAGE_CACHE_SIZE);
1601 nfs_unlock_request(req);
1602 break;
1603 }
1604 ret = nfs_wait_on_request(req);
c9edda71 1605 nfs_release_request(req);
1b3b4a1a 1606 if (ret < 0)
c988950e 1607 break;
1b3b4a1a 1608 }
1b3b4a1a
TM
1609 return ret;
1610}
1611
7f2f12d9
TM
1612/*
1613 * Write back all requests on one page - we do this before reading it.
1614 */
1615int nfs_wb_page(struct inode *inode, struct page *page)
1c75950b
TM
1616{
1617 loff_t range_start = page_offset(page);
1618 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
4d770ccf 1619 struct writeback_control wbc = {
4d770ccf 1620 .sync_mode = WB_SYNC_ALL,
7f2f12d9 1621 .nr_to_write = 0,
4d770ccf
TM
1622 .range_start = range_start,
1623 .range_end = range_end,
1624 };
1625 int ret;
1c75950b 1626
0522f6ad 1627 for (;;) {
ba8b06e6 1628 wait_on_page_writeback(page);
73e3302f
TM
1629 if (clear_page_dirty_for_io(page)) {
1630 ret = nfs_writepage_locked(page, &wbc);
1631 if (ret < 0)
1632 goto out_error;
0522f6ad 1633 continue;
7f2f12d9 1634 }
0522f6ad
TM
1635 if (!PagePrivate(page))
1636 break;
1637 ret = nfs_commit_inode(inode, FLUSH_SYNC);
ba8b06e6 1638 if (ret < 0)
73e3302f 1639 goto out_error;
7f2f12d9 1640 }
73e3302f
TM
1641 return 0;
1642out_error:
4d770ccf 1643 return ret;
1c75950b
TM
1644}
1645
074cc1de
TM
1646#ifdef CONFIG_MIGRATION
1647int nfs_migrate_page(struct address_space *mapping, struct page *newpage,
1648 struct page *page)
1649{
1650 struct nfs_page *req;
1651 int ret;
1652
7549ad5f 1653 nfs_fscache_release_page(page, GFP_KERNEL);
074cc1de 1654
cfb506e1 1655 req = nfs_find_and_lock_request(page, false);
074cc1de
TM
1656 ret = PTR_ERR(req);
1657 if (IS_ERR(req))
1658 goto out;
1659
1660 ret = migrate_page(mapping, newpage, page);
1661 if (!req)
1662 goto out;
1663 if (ret)
1664 goto out_unlock;
1665 page_cache_get(newpage);
190f38e5 1666 spin_lock(&mapping->host->i_lock);
074cc1de
TM
1667 req->wb_page = newpage;
1668 SetPagePrivate(newpage);
190f38e5 1669 set_page_private(newpage, (unsigned long)req);
074cc1de
TM
1670 ClearPagePrivate(page);
1671 set_page_private(page, 0);
190f38e5 1672 spin_unlock(&mapping->host->i_lock);
074cc1de
TM
1673 page_cache_release(page);
1674out_unlock:
1675 nfs_clear_page_tag_locked(req);
074cc1de
TM
1676out:
1677 return ret;
1678}
1679#endif
1680
f7b422b1 1681int __init nfs_init_writepagecache(void)
1da177e4
LT
1682{
1683 nfs_wdata_cachep = kmem_cache_create("nfs_write_data",
1684 sizeof(struct nfs_write_data),
1685 0, SLAB_HWCACHE_ALIGN,
20c2df83 1686 NULL);
1da177e4
LT
1687 if (nfs_wdata_cachep == NULL)
1688 return -ENOMEM;
1689
93d2341c
MD
1690 nfs_wdata_mempool = mempool_create_slab_pool(MIN_POOL_WRITE,
1691 nfs_wdata_cachep);
1da177e4
LT
1692 if (nfs_wdata_mempool == NULL)
1693 return -ENOMEM;
1694
93d2341c
MD
1695 nfs_commit_mempool = mempool_create_slab_pool(MIN_POOL_COMMIT,
1696 nfs_wdata_cachep);
1da177e4
LT
1697 if (nfs_commit_mempool == NULL)
1698 return -ENOMEM;
1699
89a09141
PZ
1700 /*
1701 * NFS congestion size, scale with available memory.
1702 *
1703 * 64MB: 8192k
1704 * 128MB: 11585k
1705 * 256MB: 16384k
1706 * 512MB: 23170k
1707 * 1GB: 32768k
1708 * 2GB: 46340k
1709 * 4GB: 65536k
1710 * 8GB: 92681k
1711 * 16GB: 131072k
1712 *
1713 * This allows larger machines to have larger/more transfers.
1714 * Limit the default to 256M
1715 */
1716 nfs_congestion_kb = (16*int_sqrt(totalram_pages)) << (PAGE_SHIFT-10);
1717 if (nfs_congestion_kb > 256*1024)
1718 nfs_congestion_kb = 256*1024;
1719
1da177e4
LT
1720 return 0;
1721}
1722
266bee88 1723void nfs_destroy_writepagecache(void)
1da177e4
LT
1724{
1725 mempool_destroy(nfs_commit_mempool);
1726 mempool_destroy(nfs_wdata_mempool);
1a1d92c1 1727 kmem_cache_destroy(nfs_wdata_cachep);
1da177e4
LT
1728}
1729