← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to fs/nfs/write.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

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