blob: f55c437124a2287e1ae80834af5059c0f3388d38 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/nfs/write.c
3 *
Trond Myklebust7c85d902006-12-13 15:23:48 -05004 * Write file data over NFS.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
6 * Copyright (C) 1996, 1997, Olaf Kirch <okir@monad.swb.de>
7 */
8
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/types.h>
10#include <linux/slab.h>
11#include <linux/mm.h>
12#include <linux/pagemap.h>
13#include <linux/file.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/writeback.h>
Peter Zijlstra89a09142007-03-16 13:38:26 -080015#include <linux/swap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016
17#include <linux/sunrpc/clnt.h>
18#include <linux/nfs_fs.h>
19#include <linux/nfs_mount.h>
20#include <linux/nfs_page.h>
Andrew Morton3fcfab12006-10-19 23:28:16 -070021#include <linux/backing-dev.h>
22
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
25#include "delegation.h"
Trond Myklebust49a70f22006-12-05 00:35:38 -050026#include "internal.h"
Chuck Lever91d5b472006-03-20 13:44:14 -050027#include "iostat.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
29#define NFSDBG_FACILITY NFSDBG_PAGECACHE
30
31#define MIN_POOL_WRITE (32)
32#define MIN_POOL_COMMIT (4)
33
34/*
35 * Local function declarations
36 */
37static struct nfs_page * nfs_update_request(struct nfs_open_context*,
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 struct page *,
39 unsigned int, unsigned int);
Trond Myklebustc63c7b02007-04-02 19:29:52 -040040static void nfs_pageio_init_write(struct nfs_pageio_descriptor *desc,
41 struct inode *inode, int ioflags);
Trond Myklebust788e7a82006-03-20 13:44:27 -050042static const struct rpc_call_ops nfs_write_partial_ops;
43static const struct rpc_call_ops nfs_write_full_ops;
44static const struct rpc_call_ops nfs_commit_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
Christoph Lametere18b8902006-12-06 20:33:20 -080046static struct kmem_cache *nfs_wdata_cachep;
Trond Myklebust3feb2d42006-03-20 13:44:37 -050047static mempool_t *nfs_wdata_mempool;
Linus Torvalds1da177e2005-04-16 15:20:36 -070048static mempool_t *nfs_commit_mempool;
49
Trond Myklebuste9f7bee2006-09-08 09:48:54 -070050struct nfs_write_data *nfs_commit_alloc(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070051{
Christoph Lametere6b4f8d2006-12-06 20:33:14 -080052 struct nfs_write_data *p = mempool_alloc(nfs_commit_mempool, GFP_NOFS);
Chuck Lever40859d72005-11-30 18:09:02 -050053
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 if (p) {
55 memset(p, 0, sizeof(*p));
56 INIT_LIST_HEAD(&p->pages);
57 }
58 return p;
59}
60
Trond Myklebust10afec92007-05-14 17:16:04 -040061static void nfs_commit_rcu_free(struct rcu_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -070062{
Trond Myklebust8aca67f2006-11-13 16:23:44 -050063 struct nfs_write_data *p = container_of(head, struct nfs_write_data, task.u.tk_rcu);
Chuck Lever40859d72005-11-30 18:09:02 -050064 if (p && (p->pagevec != &p->page_array[0]))
65 kfree(p->pagevec);
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 mempool_free(p, nfs_commit_mempool);
67}
68
Trond Myklebust8aca67f2006-11-13 16:23:44 -050069void nfs_commit_free(struct nfs_write_data *wdata)
70{
71 call_rcu_bh(&wdata->task.u.tk_rcu, nfs_commit_rcu_free);
72}
73
Trond Myklebust8d5658c2007-04-10 09:26:35 -040074struct nfs_write_data *nfs_writedata_alloc(unsigned int pagecount)
Trond Myklebust3feb2d42006-03-20 13:44:37 -050075{
Christoph Lametere6b4f8d2006-12-06 20:33:14 -080076 struct nfs_write_data *p = mempool_alloc(nfs_wdata_mempool, GFP_NOFS);
Trond Myklebust3feb2d42006-03-20 13:44:37 -050077
78 if (p) {
79 memset(p, 0, sizeof(*p));
80 INIT_LIST_HEAD(&p->pages);
Trond Myklebuste9f7bee2006-09-08 09:48:54 -070081 p->npages = pagecount;
Chuck Lever0d0b5cb2006-05-25 01:40:53 -040082 if (pagecount <= ARRAY_SIZE(p->page_array))
83 p->pagevec = p->page_array;
Trond Myklebust3feb2d42006-03-20 13:44:37 -050084 else {
Chuck Lever0d0b5cb2006-05-25 01:40:53 -040085 p->pagevec = kcalloc(pagecount, sizeof(struct page *), GFP_NOFS);
86 if (!p->pagevec) {
Trond Myklebust3feb2d42006-03-20 13:44:37 -050087 mempool_free(p, nfs_wdata_mempool);
88 p = NULL;
89 }
90 }
91 }
92 return p;
93}
94
Trond Myklebust8aca67f2006-11-13 16:23:44 -050095static void nfs_writedata_rcu_free(struct rcu_head *head)
Trond Myklebust3feb2d42006-03-20 13:44:37 -050096{
Trond Myklebust8aca67f2006-11-13 16:23:44 -050097 struct nfs_write_data *p = container_of(head, struct nfs_write_data, task.u.tk_rcu);
Trond Myklebust3feb2d42006-03-20 13:44:37 -050098 if (p && (p->pagevec != &p->page_array[0]))
99 kfree(p->pagevec);
100 mempool_free(p, nfs_wdata_mempool);
101}
102
Trond Myklebust8aca67f2006-11-13 16:23:44 -0500103static void nfs_writedata_free(struct nfs_write_data *wdata)
104{
105 call_rcu_bh(&wdata->task.u.tk_rcu, nfs_writedata_rcu_free);
106}
107
Trond Myklebust963d8fe2006-01-03 09:55:04 +0100108void nfs_writedata_release(void *wdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 nfs_writedata_free(wdata);
111}
112
Trond Myklebust7b159fc2007-07-25 14:09:54 -0400113static void nfs_context_set_write_error(struct nfs_open_context *ctx, int error)
114{
115 ctx->error = error;
116 smp_wmb();
117 set_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
118}
119
Trond Myklebust277459d2006-12-05 00:35:35 -0500120static struct nfs_page *nfs_page_find_request_locked(struct page *page)
121{
122 struct nfs_page *req = NULL;
123
124 if (PagePrivate(page)) {
125 req = (struct nfs_page *)page_private(page);
126 if (req != NULL)
Trond Myklebustc03b4022007-06-17 13:26:38 -0400127 kref_get(&req->wb_kref);
Trond Myklebust277459d2006-12-05 00:35:35 -0500128 }
129 return req;
130}
131
132static struct nfs_page *nfs_page_find_request(struct page *page)
133{
Trond Myklebust587142f2007-07-02 09:57:54 -0400134 struct inode *inode = page->mapping->host;
Trond Myklebust277459d2006-12-05 00:35:35 -0500135 struct nfs_page *req = NULL;
Trond Myklebust277459d2006-12-05 00:35:35 -0500136
Trond Myklebust587142f2007-07-02 09:57:54 -0400137 spin_lock(&inode->i_lock);
Trond Myklebust277459d2006-12-05 00:35:35 -0500138 req = nfs_page_find_request_locked(page);
Trond Myklebust587142f2007-07-02 09:57:54 -0400139 spin_unlock(&inode->i_lock);
Trond Myklebust277459d2006-12-05 00:35:35 -0500140 return req;
141}
142
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143/* Adjust the file length if we're writing beyond the end */
144static void nfs_grow_file(struct page *page, unsigned int offset, unsigned int count)
145{
146 struct inode *inode = page->mapping->host;
147 loff_t end, i_size = i_size_read(inode);
Trond Myklebustca52fec2007-04-17 17:22:13 -0400148 pgoff_t end_index = (i_size - 1) >> PAGE_CACHE_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
150 if (i_size > 0 && page->index < end_index)
151 return;
152 end = ((loff_t)page->index << PAGE_CACHE_SHIFT) + ((loff_t)offset+count);
153 if (i_size >= end)
154 return;
Chuck Lever91d5b472006-03-20 13:44:14 -0500155 nfs_inc_stats(inode, NFSIOS_EXTENDWRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 i_size_write(inode, end);
157}
158
Trond Myklebusta301b772007-02-06 11:07:15 -0800159/* A writeback failed: mark the page as bad, and invalidate the page cache */
160static void nfs_set_pageerror(struct page *page)
161{
162 SetPageError(page);
163 nfs_zap_mapping(page->mapping->host, page->mapping);
164}
165
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166/* We can set the PG_uptodate flag if we see that a write request
167 * covers the full page.
168 */
169static void nfs_mark_uptodate(struct page *page, unsigned int base, unsigned int count)
170{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 if (PageUptodate(page))
172 return;
173 if (base != 0)
174 return;
Trond Myklebust49a70f22006-12-05 00:35:38 -0500175 if (count != nfs_page_length(page))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 return;
Trond Myklebust49a70f22006-12-05 00:35:38 -0500177 SetPageUptodate(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178}
179
Trond Myklebuste21195a2006-12-05 00:35:39 -0500180static int nfs_writepage_setup(struct nfs_open_context *ctx, struct page *page,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 unsigned int offset, unsigned int count)
182{
183 struct nfs_page *req;
Trond Myklebuste21195a2006-12-05 00:35:39 -0500184 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185
Trond Myklebuste21195a2006-12-05 00:35:39 -0500186 for (;;) {
187 req = nfs_update_request(ctx, page, offset, count);
188 if (!IS_ERR(req))
189 break;
190 ret = PTR_ERR(req);
191 if (ret != -EBUSY)
192 return ret;
193 ret = nfs_wb_page(page->mapping->host, page);
194 if (ret != 0)
195 return ret;
196 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 /* Update file length */
198 nfs_grow_file(page, offset, count);
Trond Myklebustacee4782008-01-22 17:13:07 -0500199 nfs_clear_page_tag_locked(req);
Trond Myklebustabd3e642006-01-03 09:55:02 +0100200 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201}
202
203static int wb_priority(struct writeback_control *wbc)
204{
205 if (wbc->for_reclaim)
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400206 return FLUSH_HIGHPRI | FLUSH_STABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 if (wbc->for_kupdate)
208 return FLUSH_LOWPRI;
209 return 0;
210}
211
212/*
Peter Zijlstra89a09142007-03-16 13:38:26 -0800213 * NFS congestion control
214 */
215
216int nfs_congestion_kb;
217
218#define NFS_CONGESTION_ON_THRESH (nfs_congestion_kb >> (PAGE_SHIFT-10))
219#define NFS_CONGESTION_OFF_THRESH \
220 (NFS_CONGESTION_ON_THRESH - (NFS_CONGESTION_ON_THRESH >> 2))
221
Trond Myklebust5a6d41b2007-04-14 19:10:12 -0400222static int nfs_set_page_writeback(struct page *page)
Peter Zijlstra89a09142007-03-16 13:38:26 -0800223{
Trond Myklebust5a6d41b2007-04-14 19:10:12 -0400224 int ret = test_set_page_writeback(page);
225
226 if (!ret) {
Peter Zijlstra89a09142007-03-16 13:38:26 -0800227 struct inode *inode = page->mapping->host;
228 struct nfs_server *nfss = NFS_SERVER(inode);
229
Peter Zijlstra277866a2007-05-08 00:35:12 -0700230 if (atomic_long_inc_return(&nfss->writeback) >
Peter Zijlstra89a09142007-03-16 13:38:26 -0800231 NFS_CONGESTION_ON_THRESH)
232 set_bdi_congested(&nfss->backing_dev_info, WRITE);
233 }
Trond Myklebust5a6d41b2007-04-14 19:10:12 -0400234 return ret;
Peter Zijlstra89a09142007-03-16 13:38:26 -0800235}
236
237static void nfs_end_page_writeback(struct page *page)
238{
239 struct inode *inode = page->mapping->host;
240 struct nfs_server *nfss = NFS_SERVER(inode);
241
242 end_page_writeback(page);
Peter Zijlstrac4dc4be2007-10-16 23:25:41 -0700243 if (atomic_long_dec_return(&nfss->writeback) < NFS_CONGESTION_OFF_THRESH)
Peter Zijlstra89a09142007-03-16 13:38:26 -0800244 clear_bdi_congested(&nfss->backing_dev_info, WRITE);
Peter Zijlstra89a09142007-03-16 13:38:26 -0800245}
246
247/*
Trond Myklebuste261f512006-12-05 00:35:41 -0500248 * Find an associated nfs write request, and prepare to flush it out
Trond Myklebust9cccef92007-07-22 17:09:05 -0400249 * May return an error if the user signalled nfs_wait_on_request().
Trond Myklebuste261f512006-12-05 00:35:41 -0500250 */
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400251static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio,
252 struct page *page)
Trond Myklebuste261f512006-12-05 00:35:41 -0500253{
Trond Myklebust587142f2007-07-02 09:57:54 -0400254 struct inode *inode = page->mapping->host;
Trond Myklebuste261f512006-12-05 00:35:41 -0500255 struct nfs_page *req;
Trond Myklebuste261f512006-12-05 00:35:41 -0500256 int ret;
257
Trond Myklebust587142f2007-07-02 09:57:54 -0400258 spin_lock(&inode->i_lock);
Trond Myklebuste261f512006-12-05 00:35:41 -0500259 for(;;) {
260 req = nfs_page_find_request_locked(page);
261 if (req == NULL) {
Trond Myklebust587142f2007-07-02 09:57:54 -0400262 spin_unlock(&inode->i_lock);
Trond Myklebust9cccef92007-07-22 17:09:05 -0400263 return 0;
Trond Myklebuste261f512006-12-05 00:35:41 -0500264 }
Trond Myklebustacee4782008-01-22 17:13:07 -0500265 if (nfs_set_page_tag_locked(req))
Trond Myklebuste261f512006-12-05 00:35:41 -0500266 break;
267 /* Note: If we hold the page lock, as is the case in nfs_writepage,
Trond Myklebustacee4782008-01-22 17:13:07 -0500268 * then the call to nfs_set_page_tag_locked() will always
Trond Myklebuste261f512006-12-05 00:35:41 -0500269 * succeed provided that someone hasn't already marked the
270 * request as dirty (in which case we don't care).
271 */
Trond Myklebust587142f2007-07-02 09:57:54 -0400272 spin_unlock(&inode->i_lock);
Trond Myklebuste261f512006-12-05 00:35:41 -0500273 ret = nfs_wait_on_request(req);
274 nfs_release_request(req);
275 if (ret != 0)
276 return ret;
Trond Myklebust587142f2007-07-02 09:57:54 -0400277 spin_lock(&inode->i_lock);
Trond Myklebuste261f512006-12-05 00:35:41 -0500278 }
Trond Myklebust612c9382007-04-20 16:12:45 -0400279 if (test_bit(PG_NEED_COMMIT, &req->wb_flags)) {
280 /* This request is marked for commit */
Trond Myklebust587142f2007-07-02 09:57:54 -0400281 spin_unlock(&inode->i_lock);
Trond Myklebustacee4782008-01-22 17:13:07 -0500282 nfs_clear_page_tag_locked(req);
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400283 nfs_pageio_complete(pgio);
Trond Myklebust9cccef92007-07-22 17:09:05 -0400284 return 0;
Trond Myklebust612c9382007-04-20 16:12:45 -0400285 }
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400286 if (nfs_set_page_writeback(page) != 0) {
Trond Myklebust587142f2007-07-02 09:57:54 -0400287 spin_unlock(&inode->i_lock);
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400288 BUG();
289 }
Trond Myklebust587142f2007-07-02 09:57:54 -0400290 spin_unlock(&inode->i_lock);
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400291 nfs_pageio_add_request(pgio, req);
Trond Myklebust9cccef92007-07-22 17:09:05 -0400292 return 0;
Trond Myklebuste261f512006-12-05 00:35:41 -0500293}
294
Trond Myklebustf758c8852007-07-22 19:27:32 -0400295static int nfs_do_writepage(struct page *page, struct writeback_control *wbc, struct nfs_pageio_descriptor *pgio)
296{
297 struct inode *inode = page->mapping->host;
298
299 nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE);
300 nfs_add_stats(inode, NFSIOS_WRITEPAGES, 1);
301
302 nfs_pageio_cond_complete(pgio, page->index);
303 return nfs_page_async_flush(pgio, page);
304}
305
Trond Myklebuste261f512006-12-05 00:35:41 -0500306/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 * Write an mmapped page to the server.
308 */
Trond Myklebust4d770cc2006-12-05 00:35:41 -0500309static int nfs_writepage_locked(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310{
Trond Myklebustf758c8852007-07-22 19:27:32 -0400311 struct nfs_pageio_descriptor pgio;
Trond Myklebuste261f512006-12-05 00:35:41 -0500312 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313
Trond Myklebustf758c8852007-07-22 19:27:32 -0400314 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;
Trond Myklebust4d770cc2006-12-05 00:35:41 -0500322}
323
324int nfs_writepage(struct page *page, struct writeback_control *wbc)
325{
Trond Myklebustf758c8852007-07-22 19:27:32 -0400326 int ret;
Trond Myklebust4d770cc2006-12-05 00:35:41 -0500327
Trond Myklebustf758c8852007-07-22 19:27:32 -0400328 ret = nfs_writepage_locked(page, wbc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 unlock_page(page);
Trond Myklebustf758c8852007-07-22 19:27:32 -0400330 return ret;
331}
332
333static 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340}
341
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342int nfs_writepages(struct address_space *mapping, struct writeback_control *wbc)
343{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 struct inode *inode = mapping->host;
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400345 struct nfs_pageio_descriptor pgio;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 int err;
347
Chuck Lever91d5b472006-03-20 13:44:14 -0500348 nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGES);
349
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400350 nfs_pageio_init_write(&pgio, inode, wb_priority(wbc));
Trond Myklebustf758c8852007-07-22 19:27:32 -0400351 err = write_cache_pages(mapping, wbc, nfs_writepages_callback, &pgio);
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400352 nfs_pageio_complete(&pgio);
Trond Myklebustf758c8852007-07-22 19:27:32 -0400353 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 return err;
Trond Myklebustf758c8852007-07-22 19:27:32 -0400355 if (pgio.pg_error < 0)
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400356 return pgio.pg_error;
357 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358}
359
360/*
361 * Insert a write request into an inode
362 */
363static int nfs_inode_add_request(struct inode *inode, struct nfs_page *req)
364{
365 struct nfs_inode *nfsi = NFS_I(inode);
366 int error;
367
368 error = radix_tree_insert(&nfsi->nfs_page_tree, req->wb_index, req);
369 BUG_ON(error == -EEXIST);
370 if (error)
371 return error;
372 if (!nfsi->npages) {
373 igrab(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 if (nfs_have_delegation(inode, FMODE_WRITE))
375 nfsi->change_attr++;
376 }
Trond Myklebustdeb7d632006-03-20 13:44:50 -0500377 SetPagePrivate(req->wb_page);
Trond Myklebust277459d2006-12-05 00:35:35 -0500378 set_page_private(req->wb_page, (unsigned long)req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 nfsi->npages++;
Trond Myklebustc03b4022007-06-17 13:26:38 -0400380 kref_get(&req->wb_kref);
Trond Myklebustacee4782008-01-22 17:13:07 -0500381 radix_tree_tag_set(&nfsi->nfs_page_tree, req->wb_index, NFS_PAGE_TAG_LOCKED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 return 0;
383}
384
385/*
Peter Zijlstra89a09142007-03-16 13:38:26 -0800386 * Remove a write request from an inode
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 */
388static void nfs_inode_remove_request(struct nfs_page *req)
389{
Trond Myklebust88be9f92007-06-05 10:42:27 -0400390 struct inode *inode = req->wb_context->path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 struct nfs_inode *nfsi = NFS_I(inode);
392
393 BUG_ON (!NFS_WBACK_BUSY(req));
394
Trond Myklebust587142f2007-07-02 09:57:54 -0400395 spin_lock(&inode->i_lock);
Trond Myklebust277459d2006-12-05 00:35:35 -0500396 set_page_private(req->wb_page, 0);
Trond Myklebustdeb7d632006-03-20 13:44:50 -0500397 ClearPagePrivate(req->wb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 radix_tree_delete(&nfsi->nfs_page_tree, req->wb_index);
399 nfsi->npages--;
400 if (!nfsi->npages) {
Trond Myklebust587142f2007-07-02 09:57:54 -0400401 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 iput(inode);
403 } else
Trond Myklebust587142f2007-07-02 09:57:54 -0400404 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 nfs_clear_request(req);
406 nfs_release_request(req);
407}
408
Trond Myklebust61822ab2006-12-05 00:35:42 -0500409static void
410nfs_redirty_request(struct nfs_page *req)
411{
Trond Myklebust61822ab2006-12-05 00:35:42 -0500412 __set_page_dirty_nobuffers(req->wb_page);
413}
414
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415/*
416 * Check if a request is dirty
417 */
418static inline int
419nfs_dirty_request(struct nfs_page *req)
420{
Trond Myklebust5a6d41b2007-04-14 19:10:12 -0400421 struct page *page = req->wb_page;
422
Trond Myklebust612c9382007-04-20 16:12:45 -0400423 if (page == NULL || test_bit(PG_NEED_COMMIT, &req->wb_flags))
Trond Myklebust5a6d41b2007-04-14 19:10:12 -0400424 return 0;
425 return !PageWriteback(req->wb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426}
427
428#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
429/*
430 * Add a request to the inode's commit list.
431 */
432static void
433nfs_mark_request_commit(struct nfs_page *req)
434{
Trond Myklebust88be9f92007-06-05 10:42:27 -0400435 struct inode *inode = req->wb_context->path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 struct nfs_inode *nfsi = NFS_I(inode);
437
Trond Myklebust587142f2007-07-02 09:57:54 -0400438 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 nfsi->ncommit++;
Trond Myklebust612c9382007-04-20 16:12:45 -0400440 set_bit(PG_NEED_COMMIT, &(req)->wb_flags);
Trond Myklebust5c369682007-06-17 15:27:42 -0400441 radix_tree_tag_set(&nfsi->nfs_page_tree,
442 req->wb_index,
443 NFS_PAGE_TAG_COMMIT);
Trond Myklebust587142f2007-07-02 09:57:54 -0400444 spin_unlock(&inode->i_lock);
Christoph Lameterfd39fc82006-06-30 01:55:40 -0700445 inc_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
Peter Zijlstrac9e51e42007-10-16 23:25:47 -0700446 inc_bdi_stat(req->wb_page->mapping->backing_dev_info, BDI_RECLAIMABLE);
Trond Myklebusta1803042006-12-05 00:45:19 -0500447 __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448}
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400449
450static inline
451int nfs_write_need_commit(struct nfs_write_data *data)
452{
453 return data->verf.committed != NFS_FILE_SYNC;
454}
455
456static inline
457int nfs_reschedule_unstable_write(struct nfs_page *req)
458{
Trond Myklebust612c9382007-04-20 16:12:45 -0400459 if (test_bit(PG_NEED_COMMIT, &req->wb_flags)) {
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400460 nfs_mark_request_commit(req);
461 return 1;
462 }
463 if (test_and_clear_bit(PG_NEED_RESCHED, &req->wb_flags)) {
464 nfs_redirty_request(req);
465 return 1;
466 }
467 return 0;
468}
469#else
470static inline void
471nfs_mark_request_commit(struct nfs_page *req)
472{
473}
474
475static inline
476int nfs_write_need_commit(struct nfs_write_data *data)
477{
478 return 0;
479}
480
481static inline
482int nfs_reschedule_unstable_write(struct nfs_page *req)
483{
484 return 0;
485}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486#endif
487
488/*
489 * Wait for a request to complete.
490 *
Matthew Wilcox150030b2007-12-06 16:24:39 -0500491 * Interruptible by fatal signals only.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 */
Trond Myklebustca52fec2007-04-17 17:22:13 -0400493static int nfs_wait_on_requests_locked(struct inode *inode, pgoff_t idx_start, unsigned int npages)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494{
495 struct nfs_inode *nfsi = NFS_I(inode);
496 struct nfs_page *req;
Trond Myklebustca52fec2007-04-17 17:22:13 -0400497 pgoff_t idx_end, next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 unsigned int res = 0;
499 int error;
500
501 if (npages == 0)
502 idx_end = ~0;
503 else
504 idx_end = idx_start + npages - 1;
505
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 next = idx_start;
Trond Myklebust9fd367f2007-06-17 15:10:24 -0400507 while (radix_tree_gang_lookup_tag(&nfsi->nfs_page_tree, (void **)&req, next, 1, NFS_PAGE_TAG_LOCKED)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 if (req->wb_index > idx_end)
509 break;
510
511 next = req->wb_index + 1;
Trond Myklebustc6a556b2005-06-22 17:16:30 +0000512 BUG_ON(!NFS_WBACK_BUSY(req));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513
Trond Myklebustc03b4022007-06-17 13:26:38 -0400514 kref_get(&req->wb_kref);
Trond Myklebust587142f2007-07-02 09:57:54 -0400515 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 error = nfs_wait_on_request(req);
517 nfs_release_request(req);
Trond Myklebust587142f2007-07-02 09:57:54 -0400518 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 if (error < 0)
520 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 res++;
522 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 return res;
524}
525
Trond Myklebust83715ad2006-07-05 13:17:12 -0400526static void nfs_cancel_commit_list(struct list_head *head)
527{
528 struct nfs_page *req;
529
530 while(!list_empty(head)) {
531 req = nfs_list_entry(head->next);
Trond Myklebustb6dff262006-10-19 23:28:38 -0700532 dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
Peter Zijlstrac9e51e42007-10-16 23:25:47 -0700533 dec_bdi_stat(req->wb_page->mapping->backing_dev_info,
534 BDI_RECLAIMABLE);
Trond Myklebust83715ad2006-07-05 13:17:12 -0400535 nfs_list_remove_request(req);
Trond Myklebust612c9382007-04-20 16:12:45 -0400536 clear_bit(PG_NEED_COMMIT, &(req)->wb_flags);
Trond Myklebust83715ad2006-07-05 13:17:12 -0400537 nfs_inode_remove_request(req);
Trond Myklebustb6dff262006-10-19 23:28:38 -0700538 nfs_unlock_request(req);
Trond Myklebust83715ad2006-07-05 13:17:12 -0400539 }
540}
541
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
543/*
544 * nfs_scan_commit - Scan an inode for commit requests
545 * @inode: NFS inode to scan
546 * @dst: destination list
547 * @idx_start: lower bound of page->index to scan.
548 * @npages: idx_start + npages sets the upper bound to scan.
549 *
550 * Moves requests from the inode's 'commit' request list.
551 * The requests are *not* checked to ensure that they form a contiguous set.
552 */
553static int
Trond Myklebustca52fec2007-04-17 17:22:13 -0400554nfs_scan_commit(struct inode *inode, struct list_head *dst, pgoff_t idx_start, unsigned int npages)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555{
556 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebust3da28eb2005-06-22 17:16:31 +0000557 int res = 0;
558
559 if (nfsi->ncommit != 0) {
Trond Myklebust5c369682007-06-17 15:27:42 -0400560 res = nfs_scan_list(nfsi, dst, idx_start, npages,
561 NFS_PAGE_TAG_COMMIT);
Trond Myklebust3da28eb2005-06-22 17:16:31 +0000562 nfsi->ncommit -= res;
Trond Myklebust3da28eb2005-06-22 17:16:31 +0000563 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 return res;
565}
Trond Myklebustc42de9d2006-03-20 13:44:51 -0500566#else
Trond Myklebustca52fec2007-04-17 17:22:13 -0400567static inline int nfs_scan_commit(struct inode *inode, struct list_head *dst, pgoff_t idx_start, unsigned int npages)
Trond Myklebustc42de9d2006-03-20 13:44:51 -0500568{
569 return 0;
570}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571#endif
572
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573/*
574 * Try to update any existing write request, or create one if there is none.
575 * In order to match, the request's credentials must match those of
576 * the calling process.
577 *
578 * Note: Should always be called with the Page Lock held!
579 */
580static struct nfs_page * nfs_update_request(struct nfs_open_context* ctx,
Trond Myklebuste21195a2006-12-05 00:35:39 -0500581 struct page *page, unsigned int offset, unsigned int bytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582{
Peter Zijlstra89a09142007-03-16 13:38:26 -0800583 struct address_space *mapping = page->mapping;
584 struct inode *inode = mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 struct nfs_page *req, *new = NULL;
Trond Myklebustca52fec2007-04-17 17:22:13 -0400586 pgoff_t rqend, end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587
588 end = offset + bytes;
589
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 for (;;) {
591 /* Loop over all inode entries and see if we find
592 * A request for the page we wish to update
593 */
Trond Myklebust587142f2007-07-02 09:57:54 -0400594 spin_lock(&inode->i_lock);
Trond Myklebust277459d2006-12-05 00:35:35 -0500595 req = nfs_page_find_request_locked(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 if (req) {
Trond Myklebustacee4782008-01-22 17:13:07 -0500597 if (!nfs_set_page_tag_locked(req)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 int error;
Trond Myklebust277459d2006-12-05 00:35:35 -0500599
Trond Myklebust587142f2007-07-02 09:57:54 -0400600 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 error = nfs_wait_on_request(req);
602 nfs_release_request(req);
Neil Brown1dd594b2006-03-20 13:44:04 -0500603 if (error < 0) {
604 if (new)
605 nfs_release_request(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 return ERR_PTR(error);
Neil Brown1dd594b2006-03-20 13:44:04 -0500607 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 continue;
609 }
Trond Myklebust587142f2007-07-02 09:57:54 -0400610 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 if (new)
612 nfs_release_request(new);
613 break;
614 }
615
616 if (new) {
617 int error;
618 nfs_lock_request_dontget(new);
619 error = nfs_inode_add_request(inode, new);
620 if (error) {
Trond Myklebust587142f2007-07-02 09:57:54 -0400621 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 nfs_unlock_request(new);
623 return ERR_PTR(error);
624 }
Trond Myklebust587142f2007-07-02 09:57:54 -0400625 spin_unlock(&inode->i_lock);
Trond Myklebust61e930a2007-10-18 17:08:05 -0400626 req = new;
627 goto zero_page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 }
Trond Myklebust587142f2007-07-02 09:57:54 -0400629 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630
631 new = nfs_create_request(ctx, inode, page, offset, bytes);
632 if (IS_ERR(new))
633 return new;
634 }
635
636 /* We have a request for our page.
637 * If the creds don't match, or the
638 * page addresses don't match,
639 * tell the caller to wait on the conflicting
640 * request.
641 */
642 rqend = req->wb_offset + req->wb_bytes;
643 if (req->wb_context != ctx
644 || req->wb_page != page
645 || !nfs_dirty_request(req)
646 || offset > rqend || end < req->wb_offset) {
Trond Myklebustacee4782008-01-22 17:13:07 -0500647 nfs_clear_page_tag_locked(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 return ERR_PTR(-EBUSY);
649 }
650
651 /* Okay, the request matches. Update the region */
652 if (offset < req->wb_offset) {
653 req->wb_offset = offset;
654 req->wb_pgbase = offset;
Trond Myklebust61e930a2007-10-18 17:08:05 -0400655 req->wb_bytes = max(end, rqend) - req->wb_offset;
656 goto zero_page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 }
658
659 if (end > rqend)
660 req->wb_bytes = end - req->wb_offset;
661
662 return req;
Trond Myklebust61e930a2007-10-18 17:08:05 -0400663zero_page:
664 /* If this page might potentially be marked as up to date,
665 * then we need to zero any uninitalised data. */
666 if (req->wb_pgbase == 0 && req->wb_bytes != PAGE_CACHE_SIZE
667 && !PageUptodate(req->wb_page))
Christoph Lametereebd2aa2008-02-04 22:28:29 -0800668 zero_user_segment(req->wb_page, req->wb_bytes, PAGE_CACHE_SIZE);
Trond Myklebust61e930a2007-10-18 17:08:05 -0400669 return req;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670}
671
672int nfs_flush_incompatible(struct file *file, struct page *page)
673{
Trond Myklebustcd3758e2007-08-10 17:44:32 -0400674 struct nfs_open_context *ctx = nfs_file_open_context(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 struct nfs_page *req;
Trond Myklebust1a545332006-12-05 00:35:40 -0500676 int do_flush, status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 /*
678 * Look for a request corresponding to this page. If there
679 * is one, and it belongs to another file, we flush it out
680 * before we try to copy anything into the page. Do this
681 * due to the lack of an ACCESS-type call in NFSv2.
682 * Also do the same if we find a request from an existing
683 * dropped page.
684 */
Trond Myklebust1a545332006-12-05 00:35:40 -0500685 do {
686 req = nfs_page_find_request(page);
687 if (req == NULL)
688 return 0;
689 do_flush = req->wb_page != page || req->wb_context != ctx
Trond Myklebuste261f512006-12-05 00:35:41 -0500690 || !nfs_dirty_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 nfs_release_request(req);
Trond Myklebust1a545332006-12-05 00:35:40 -0500692 if (!do_flush)
693 return 0;
694 status = nfs_wb_page(page->mapping->host, page);
695 } while (status == 0);
696 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697}
698
699/*
Trond Myklebust5d47a352008-02-07 17:24:07 -0500700 * If the page cache is marked as unsafe or invalid, then we can't rely on
701 * the PageUptodate() flag. In this case, we will need to turn off
702 * write optimisations that depend on the page contents being correct.
703 */
704static int nfs_write_pageuptodate(struct page *page, struct inode *inode)
705{
706 return PageUptodate(page) &&
707 !(NFS_I(inode)->cache_validity & (NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_DATA));
708}
709
710/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 * Update and possibly write a cached page of an NFS file.
712 *
713 * XXX: Keep an eye on generic_file_read to make sure it doesn't do bad
714 * things with a page scheduled for an RPC call (e.g. invalidate it).
715 */
716int nfs_updatepage(struct file *file, struct page *page,
717 unsigned int offset, unsigned int count)
718{
Trond Myklebustcd3758e2007-08-10 17:44:32 -0400719 struct nfs_open_context *ctx = nfs_file_open_context(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 struct inode *inode = page->mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 int status = 0;
722
Chuck Lever91d5b472006-03-20 13:44:14 -0500723 nfs_inc_stats(inode, NFSIOS_VFSUPDATEPAGE);
724
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 dprintk("NFS: nfs_updatepage(%s/%s %d@%Ld)\n",
Josef "Jeff" Sipek01cce932006-12-08 02:36:40 -0800726 file->f_path.dentry->d_parent->d_name.name,
727 file->f_path.dentry->d_name.name, count,
Chuck Lever0bbacc42005-11-01 16:53:32 -0500728 (long long)(page_offset(page) +offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 /* If we're not using byte range locks, and we know the page
Trond Myklebust5d47a352008-02-07 17:24:07 -0500731 * is up to date, it may be more efficient to extend the write
732 * to cover the entire page in order to avoid fragmentation
733 * inefficiencies.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 */
Trond Myklebust5d47a352008-02-07 17:24:07 -0500735 if (nfs_write_pageuptodate(page, inode) &&
736 inode->i_flock == NULL &&
737 !(file->f_mode & O_SYNC)) {
Trond Myklebust49a70f22006-12-05 00:35:38 -0500738 count = max(count + offset, nfs_page_length(page));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 }
741
Trond Myklebuste21195a2006-12-05 00:35:39 -0500742 status = nfs_writepage_setup(ctx, page, offset, count);
Trond Myklebuste261f512006-12-05 00:35:41 -0500743 __set_page_dirty_nobuffers(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 dprintk("NFS: nfs_updatepage returns %d (isize %Ld)\n",
746 status, (long long)i_size_read(inode));
747 if (status < 0)
Trond Myklebusta301b772007-02-06 11:07:15 -0800748 nfs_set_pageerror(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 return status;
750}
751
752static void nfs_writepage_release(struct nfs_page *req)
753{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754
Trond Myklebust44dd1512007-05-19 11:58:03 -0400755 if (PageError(req->wb_page)) {
756 nfs_end_page_writeback(req->wb_page);
757 nfs_inode_remove_request(req);
758 } else if (!nfs_reschedule_unstable_write(req)) {
759 /* Set the PG_uptodate flag */
760 nfs_mark_uptodate(req->wb_page, req->wb_pgbase, req->wb_bytes);
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400761 nfs_end_page_writeback(req->wb_page);
762 nfs_inode_remove_request(req);
763 } else
764 nfs_end_page_writeback(req->wb_page);
Trond Myklebust9fd367f2007-06-17 15:10:24 -0400765 nfs_clear_page_tag_locked(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766}
767
Trond Myklebust3ff75762007-07-14 15:40:00 -0400768static int flush_task_priority(int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769{
770 switch (how & (FLUSH_HIGHPRI|FLUSH_LOWPRI)) {
771 case FLUSH_HIGHPRI:
772 return RPC_PRIORITY_HIGH;
773 case FLUSH_LOWPRI:
774 return RPC_PRIORITY_LOW;
775 }
776 return RPC_PRIORITY_NORMAL;
777}
778
779/*
780 * Set up the argument/result storage required for the RPC call.
781 */
782static void nfs_write_rpcsetup(struct nfs_page *req,
783 struct nfs_write_data *data,
Trond Myklebust788e7a82006-03-20 13:44:27 -0500784 const struct rpc_call_ops *call_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 unsigned int count, unsigned int offset,
786 int how)
787{
Trond Myklebust84115e12007-07-14 15:39:59 -0400788 struct inode *inode = req->wb_context->path.dentry->d_inode;
789 int flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
Trond Myklebust3ff75762007-07-14 15:40:00 -0400790 int priority = flush_task_priority(how);
Trond Myklebust07737692007-10-25 18:42:54 -0400791 struct rpc_task *task;
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400792 struct rpc_message msg = {
793 .rpc_argp = &data->args,
794 .rpc_resp = &data->res,
795 .rpc_cred = req->wb_context->cred,
796 };
Trond Myklebust84115e12007-07-14 15:39:59 -0400797 struct rpc_task_setup task_setup_data = {
798 .rpc_client = NFS_CLIENT(inode),
Trond Myklebust07737692007-10-25 18:42:54 -0400799 .task = &data->task,
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400800 .rpc_message = &msg,
Trond Myklebust84115e12007-07-14 15:39:59 -0400801 .callback_ops = call_ops,
802 .callback_data = data,
803 .flags = flags,
Trond Myklebust3ff75762007-07-14 15:40:00 -0400804 .priority = priority,
Trond Myklebust84115e12007-07-14 15:39:59 -0400805 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806
807 /* Set up the RPC argument and reply structs
808 * NB: take care not to mess about with data->commit et al. */
809
810 data->req = req;
Trond Myklebust88be9f92007-06-05 10:42:27 -0400811 data->inode = inode = req->wb_context->path.dentry->d_inode;
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400812 data->cred = msg.rpc_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
814 data->args.fh = NFS_FH(inode);
815 data->args.offset = req_offset(req) + offset;
816 data->args.pgbase = req->wb_pgbase + offset;
817 data->args.pages = data->pagevec;
818 data->args.count = count;
819 data->args.context = req->wb_context;
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400820 data->args.stable = NFS_UNSTABLE;
821 if (how & FLUSH_STABLE) {
822 data->args.stable = NFS_DATA_SYNC;
823 if (!NFS_I(inode)->ncommit)
824 data->args.stable = NFS_FILE_SYNC;
825 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826
827 data->res.fattr = &data->fattr;
828 data->res.count = count;
829 data->res.verf = &data->verf;
Trond Myklebust0e574af2005-10-27 22:12:38 -0400830 nfs_fattr_init(&data->fattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831
Trond Myklebust788e7a82006-03-20 13:44:27 -0500832 /* Set up the initial task struct. */
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400833 NFS_PROTO(inode)->write_setup(data, &msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834
Chuck Levera3f565b2007-01-31 12:14:01 -0500835 dprintk("NFS: %5u initiated write call "
836 "(req %s/%Ld, %u bytes @ offset %Lu)\n",
Chuck Lever0bbacc42005-11-01 16:53:32 -0500837 data->task.tk_pid,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 inode->i_sb->s_id,
839 (long long)NFS_FILEID(inode),
840 count,
841 (unsigned long long)data->args.offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842
Trond Myklebust07737692007-10-25 18:42:54 -0400843 task = rpc_run_task(&task_setup_data);
844 if (!IS_ERR(task))
845 rpc_put_task(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846}
847
848/*
849 * Generate multiple small requests to write out a single
850 * contiguous dirty area on one page.
851 */
Trond Myklebust8d5658c2007-04-10 09:26:35 -0400852static int nfs_flush_multi(struct inode *inode, struct list_head *head, unsigned int npages, size_t count, int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853{
854 struct nfs_page *req = nfs_list_entry(head->next);
855 struct page *page = req->wb_page;
856 struct nfs_write_data *data;
Trond Myklebuste9f7bee2006-09-08 09:48:54 -0700857 size_t wsize = NFS_SERVER(inode)->wsize, nbytes;
858 unsigned int offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 int requests = 0;
860 LIST_HEAD(list);
861
862 nfs_list_remove_request(req);
863
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400864 nbytes = count;
Trond Myklebuste9f7bee2006-09-08 09:48:54 -0700865 do {
866 size_t len = min(nbytes, wsize);
867
Trond Myklebust8d5658c2007-04-10 09:26:35 -0400868 data = nfs_writedata_alloc(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 if (!data)
870 goto out_bad;
871 list_add(&data->pages, &list);
872 requests++;
Trond Myklebuste9f7bee2006-09-08 09:48:54 -0700873 nbytes -= len;
874 } while (nbytes != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 atomic_set(&req->wb_complete, requests);
876
877 ClearPageError(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 offset = 0;
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400879 nbytes = count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 do {
881 data = list_entry(list.next, struct nfs_write_data, pages);
882 list_del_init(&data->pages);
883
884 data->pagevec[0] = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400886 if (nbytes < wsize)
887 wsize = nbytes;
888 nfs_write_rpcsetup(req, data, &nfs_write_partial_ops,
889 wsize, offset, how);
890 offset += wsize;
891 nbytes -= wsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 } while (nbytes != 0);
893
894 return 0;
895
896out_bad:
897 while (!list_empty(&list)) {
898 data = list_entry(list.next, struct nfs_write_data, pages);
899 list_del(&data->pages);
Trond Myklebust8aca67f2006-11-13 16:23:44 -0500900 nfs_writedata_release(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 }
Trond Myklebust61822ab2006-12-05 00:35:42 -0500902 nfs_redirty_request(req);
Trond Myklebust6d677e32007-04-20 16:12:40 -0400903 nfs_end_page_writeback(req->wb_page);
Trond Myklebust9fd367f2007-06-17 15:10:24 -0400904 nfs_clear_page_tag_locked(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 return -ENOMEM;
906}
907
908/*
909 * Create an RPC task for the given write request and kick it.
910 * The page must have been locked by the caller.
911 *
912 * It may happen that the page we're passed is not marked dirty.
913 * This is the case if nfs_updatepage detects a conflicting request
914 * that has been written but not committed.
915 */
Trond Myklebust8d5658c2007-04-10 09:26:35 -0400916static int nfs_flush_one(struct inode *inode, struct list_head *head, unsigned int npages, size_t count, int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917{
918 struct nfs_page *req;
919 struct page **pages;
920 struct nfs_write_data *data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921
Trond Myklebust8d5658c2007-04-10 09:26:35 -0400922 data = nfs_writedata_alloc(npages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 if (!data)
924 goto out_bad;
925
926 pages = data->pagevec;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 while (!list_empty(head)) {
928 req = nfs_list_entry(head->next);
929 nfs_list_remove_request(req);
930 nfs_list_add_request(req, &data->pages);
931 ClearPageError(req->wb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 *pages++ = req->wb_page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 }
934 req = nfs_list_entry(data->pages.next);
935
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 /* Set up the argument struct */
Trond Myklebust788e7a82006-03-20 13:44:27 -0500937 nfs_write_rpcsetup(req, data, &nfs_write_full_ops, count, 0, how);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 return 0;
940 out_bad:
941 while (!list_empty(head)) {
Trond Myklebust10afec92007-05-14 17:16:04 -0400942 req = nfs_list_entry(head->next);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 nfs_list_remove_request(req);
Trond Myklebust61822ab2006-12-05 00:35:42 -0500944 nfs_redirty_request(req);
Trond Myklebust6d677e32007-04-20 16:12:40 -0400945 nfs_end_page_writeback(req->wb_page);
Trond Myklebust9fd367f2007-06-17 15:10:24 -0400946 nfs_clear_page_tag_locked(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 }
948 return -ENOMEM;
949}
950
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400951static void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio,
952 struct inode *inode, int ioflags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953{
Chuck Leverbf4285e2007-12-20 14:54:57 -0500954 size_t wsize = NFS_SERVER(inode)->wsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400956 if (wsize < PAGE_CACHE_SIZE)
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400957 nfs_pageio_init(pgio, inode, nfs_flush_multi, wsize, ioflags);
Trond Myklebustbcb71bb2007-04-02 18:48:28 -0400958 else
Trond Myklebustc63c7b02007-04-02 19:29:52 -0400959 nfs_pageio_init(pgio, inode, nfs_flush_one, wsize, ioflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960}
961
962/*
963 * Handle a write reply that flushed part of a page.
964 */
Trond Myklebust788e7a82006-03-20 13:44:27 -0500965static void nfs_writeback_done_partial(struct rpc_task *task, void *calldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966{
Trond Myklebust788e7a82006-03-20 13:44:27 -0500967 struct nfs_write_data *data = calldata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 struct nfs_page *req = data->req;
969 struct page *page = req->wb_page;
970
971 dprintk("NFS: write (%s/%Ld %d@%Ld)",
Trond Myklebust88be9f92007-06-05 10:42:27 -0400972 req->wb_context->path.dentry->d_inode->i_sb->s_id,
973 (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 req->wb_bytes,
975 (long long)req_offset(req));
976
Trond Myklebust788e7a82006-03-20 13:44:27 -0500977 if (nfs_writeback_done(task, data) != 0)
978 return;
979
980 if (task->tk_status < 0) {
Trond Myklebusta301b772007-02-06 11:07:15 -0800981 nfs_set_pageerror(page);
Trond Myklebust7b159fc2007-07-25 14:09:54 -0400982 nfs_context_set_write_error(req->wb_context, task->tk_status);
Trond Myklebust788e7a82006-03-20 13:44:27 -0500983 dprintk(", error = %d\n", task->tk_status);
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400984 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 }
986
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400987 if (nfs_write_need_commit(data)) {
Trond Myklebust587142f2007-07-02 09:57:54 -0400988 struct inode *inode = page->mapping->host;
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400989
Trond Myklebust587142f2007-07-02 09:57:54 -0400990 spin_lock(&inode->i_lock);
Trond Myklebust8e821ca2007-04-20 16:12:34 -0400991 if (test_bit(PG_NEED_RESCHED, &req->wb_flags)) {
992 /* Do nothing we need to resend the writes */
993 } else if (!test_and_set_bit(PG_NEED_COMMIT, &req->wb_flags)) {
994 memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf));
995 dprintk(" defer commit\n");
996 } else if (memcmp(&req->wb_verf, &data->verf, sizeof(req->wb_verf))) {
997 set_bit(PG_NEED_RESCHED, &req->wb_flags);
998 clear_bit(PG_NEED_COMMIT, &req->wb_flags);
999 dprintk(" server reboot detected\n");
1000 }
Trond Myklebust587142f2007-07-02 09:57:54 -04001001 spin_unlock(&inode->i_lock);
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001002 } else
1003 dprintk(" OK\n");
1004
1005out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 if (atomic_dec_and_test(&req->wb_complete))
1007 nfs_writepage_release(req);
1008}
1009
Trond Myklebust788e7a82006-03-20 13:44:27 -05001010static const struct rpc_call_ops nfs_write_partial_ops = {
1011 .rpc_call_done = nfs_writeback_done_partial,
1012 .rpc_release = nfs_writedata_release,
1013};
1014
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015/*
1016 * Handle a write reply that flushes a whole page.
1017 *
1018 * FIXME: There is an inherent race with invalidate_inode_pages and
1019 * writebacks since the page->count is kept > 1 for as long
1020 * as the page has a write request pending.
1021 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001022static void nfs_writeback_done_full(struct rpc_task *task, void *calldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023{
Trond Myklebust788e7a82006-03-20 13:44:27 -05001024 struct nfs_write_data *data = calldata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 struct nfs_page *req;
1026 struct page *page;
1027
Trond Myklebust788e7a82006-03-20 13:44:27 -05001028 if (nfs_writeback_done(task, data) != 0)
1029 return;
1030
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 /* Update attributes as result of writeback. */
1032 while (!list_empty(&data->pages)) {
1033 req = nfs_list_entry(data->pages.next);
1034 nfs_list_remove_request(req);
1035 page = req->wb_page;
1036
1037 dprintk("NFS: write (%s/%Ld %d@%Ld)",
Trond Myklebust88be9f92007-06-05 10:42:27 -04001038 req->wb_context->path.dentry->d_inode->i_sb->s_id,
1039 (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 req->wb_bytes,
1041 (long long)req_offset(req));
1042
Trond Myklebust788e7a82006-03-20 13:44:27 -05001043 if (task->tk_status < 0) {
Trond Myklebusta301b772007-02-06 11:07:15 -08001044 nfs_set_pageerror(page);
Trond Myklebust7b159fc2007-07-25 14:09:54 -04001045 nfs_context_set_write_error(req->wb_context, task->tk_status);
Trond Myklebust788e7a82006-03-20 13:44:27 -05001046 dprintk(", error = %d\n", task->tk_status);
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001047 goto remove_request;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001050 if (nfs_write_need_commit(data)) {
1051 memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf));
1052 nfs_mark_request_commit(req);
1053 nfs_end_page_writeback(page);
1054 dprintk(" marked for commit\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 goto next;
1056 }
Trond Myklebust44dd1512007-05-19 11:58:03 -04001057 /* Set the PG_uptodate flag? */
1058 nfs_mark_uptodate(page, req->wb_pgbase, req->wb_bytes);
Trond Myklebust8e821ca2007-04-20 16:12:34 -04001059 dprintk(" OK\n");
1060remove_request:
1061 nfs_end_page_writeback(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 nfs_inode_remove_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 next:
Trond Myklebust9fd367f2007-06-17 15:10:24 -04001064 nfs_clear_page_tag_locked(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 }
1066}
1067
Trond Myklebust788e7a82006-03-20 13:44:27 -05001068static const struct rpc_call_ops nfs_write_full_ops = {
1069 .rpc_call_done = nfs_writeback_done_full,
1070 .rpc_release = nfs_writedata_release,
1071};
1072
1073
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074/*
1075 * This function is called when the WRITE call is complete.
1076 */
Chuck Lever462d5b32006-03-20 13:44:32 -05001077int nfs_writeback_done(struct rpc_task *task, struct nfs_write_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 struct nfs_writeargs *argp = &data->args;
1080 struct nfs_writeres *resp = &data->res;
Trond Myklebust788e7a82006-03-20 13:44:27 -05001081 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082
Chuck Levera3f565b2007-01-31 12:14:01 -05001083 dprintk("NFS: %5u nfs_writeback_done (status %d)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 task->tk_pid, task->tk_status);
1085
Chuck Leverf551e442006-09-20 14:33:04 -04001086 /*
1087 * ->write_done will attempt to use post-op attributes to detect
1088 * conflicting writes by other clients. A strict interpretation
1089 * of close-to-open would allow us to continue caching even if
1090 * another writer had changed the file, but some applications
1091 * depend on tighter cache coherency when writing.
1092 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001093 status = NFS_PROTO(data->inode)->write_done(task, data);
1094 if (status != 0)
1095 return status;
Chuck Lever91d5b472006-03-20 13:44:14 -05001096 nfs_add_stats(data->inode, NFSIOS_SERVERWRITTENBYTES, resp->count);
1097
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
1099 if (resp->verf->committed < argp->stable && task->tk_status >= 0) {
1100 /* We tried a write call, but the server did not
1101 * commit data to stable storage even though we
1102 * requested it.
1103 * Note: There is a known bug in Tru64 < 5.0 in which
1104 * the server reports NFS_DATA_SYNC, but performs
1105 * NFS_FILE_SYNC. We therefore implement this checking
1106 * as a dprintk() in order to avoid filling syslog.
1107 */
1108 static unsigned long complain;
1109
1110 if (time_before(complain, jiffies)) {
1111 dprintk("NFS: faulty NFS server %s:"
1112 " (committed = %d) != (stable = %d)\n",
David Howells54ceac42006-08-22 20:06:13 -04001113 NFS_SERVER(data->inode)->nfs_client->cl_hostname,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 resp->verf->committed, argp->stable);
1115 complain = jiffies + 300 * HZ;
1116 }
1117 }
1118#endif
1119 /* Is this a short write? */
1120 if (task->tk_status >= 0 && resp->count < argp->count) {
1121 static unsigned long complain;
1122
Chuck Lever91d5b472006-03-20 13:44:14 -05001123 nfs_inc_stats(data->inode, NFSIOS_SHORTWRITE);
1124
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 /* Has the server at least made some progress? */
1126 if (resp->count != 0) {
1127 /* Was this an NFSv2 write or an NFSv3 stable write? */
1128 if (resp->verf->committed != NFS_UNSTABLE) {
1129 /* Resend from where the server left off */
1130 argp->offset += resp->count;
1131 argp->pgbase += resp->count;
1132 argp->count -= resp->count;
1133 } else {
1134 /* Resend as a stable write in order to avoid
1135 * headaches in the case of a server crash.
1136 */
1137 argp->stable = NFS_FILE_SYNC;
1138 }
1139 rpc_restart_call(task);
Trond Myklebust788e7a82006-03-20 13:44:27 -05001140 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 }
1142 if (time_before(complain, jiffies)) {
1143 printk(KERN_WARNING
1144 "NFS: Server wrote zero bytes, expected %u.\n",
1145 argp->count);
1146 complain = jiffies + 300 * HZ;
1147 }
1148 /* Can't do anything about it except throw an error. */
1149 task->tk_status = -EIO;
1150 }
Trond Myklebust788e7a82006-03-20 13:44:27 -05001151 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152}
1153
1154
1155#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
Trond Myklebust963d8fe2006-01-03 09:55:04 +01001156void nfs_commit_release(void *wdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 nfs_commit_free(wdata);
1159}
1160
1161/*
1162 * Set up the argument/result storage required for the RPC call.
1163 */
1164static void nfs_commit_rpcsetup(struct list_head *head,
Trond Myklebust788e7a82006-03-20 13:44:27 -05001165 struct nfs_write_data *data,
1166 int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167{
Trond Myklebust84115e12007-07-14 15:39:59 -04001168 struct nfs_page *first = nfs_list_entry(head->next);
1169 struct inode *inode = first->wb_context->path.dentry->d_inode;
1170 int flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
Trond Myklebust3ff75762007-07-14 15:40:00 -04001171 int priority = flush_task_priority(how);
Trond Myklebust07737692007-10-25 18:42:54 -04001172 struct rpc_task *task;
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001173 struct rpc_message msg = {
1174 .rpc_argp = &data->args,
1175 .rpc_resp = &data->res,
1176 .rpc_cred = first->wb_context->cred,
1177 };
Trond Myklebust84115e12007-07-14 15:39:59 -04001178 struct rpc_task_setup task_setup_data = {
Trond Myklebust07737692007-10-25 18:42:54 -04001179 .task = &data->task,
Trond Myklebust84115e12007-07-14 15:39:59 -04001180 .rpc_client = NFS_CLIENT(inode),
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001181 .rpc_message = &msg,
Trond Myklebust84115e12007-07-14 15:39:59 -04001182 .callback_ops = &nfs_commit_ops,
1183 .callback_data = data,
1184 .flags = flags,
Trond Myklebust3ff75762007-07-14 15:40:00 -04001185 .priority = priority,
Trond Myklebust84115e12007-07-14 15:39:59 -04001186 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187
1188 /* Set up the RPC argument and reply structs
1189 * NB: take care not to mess about with data->commit et al. */
1190
1191 list_splice_init(head, &data->pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 data->inode = inode;
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001194 data->cred = msg.rpc_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195
1196 data->args.fh = NFS_FH(data->inode);
Trond Myklebust3da28eb2005-06-22 17:16:31 +00001197 /* Note: we always request a commit of the entire inode */
1198 data->args.offset = 0;
1199 data->args.count = 0;
1200 data->res.count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 data->res.fattr = &data->fattr;
1202 data->res.verf = &data->verf;
Trond Myklebust0e574af2005-10-27 22:12:38 -04001203 nfs_fattr_init(&data->fattr);
Trond Myklebust788e7a82006-03-20 13:44:27 -05001204
1205 /* Set up the initial task struct. */
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001206 NFS_PROTO(inode)->commit_setup(data, &msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207
Chuck Levera3f565b2007-01-31 12:14:01 -05001208 dprintk("NFS: %5u initiated commit call\n", data->task.tk_pid);
Trond Myklebustbdc7f022007-07-14 15:40:00 -04001209
Trond Myklebust07737692007-10-25 18:42:54 -04001210 task = rpc_run_task(&task_setup_data);
1211 if (!IS_ERR(task))
1212 rpc_put_task(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213}
1214
1215/*
1216 * Commit dirty pages
1217 */
1218static int
Chuck Lever40859d72005-11-30 18:09:02 -05001219nfs_commit_list(struct inode *inode, struct list_head *head, int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220{
1221 struct nfs_write_data *data;
1222 struct nfs_page *req;
1223
Trond Myklebuste9f7bee2006-09-08 09:48:54 -07001224 data = nfs_commit_alloc();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225
1226 if (!data)
1227 goto out_bad;
1228
1229 /* Set up the argument struct */
1230 nfs_commit_rpcsetup(head, data, how);
1231
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 return 0;
1233 out_bad:
1234 while (!list_empty(head)) {
1235 req = nfs_list_entry(head->next);
1236 nfs_list_remove_request(req);
1237 nfs_mark_request_commit(req);
Trond Myklebust83715ad2006-07-05 13:17:12 -04001238 dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
Peter Zijlstrac9e51e42007-10-16 23:25:47 -07001239 dec_bdi_stat(req->wb_page->mapping->backing_dev_info,
1240 BDI_RECLAIMABLE);
Trond Myklebust9fd367f2007-06-17 15:10:24 -04001241 nfs_clear_page_tag_locked(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 }
1243 return -ENOMEM;
1244}
1245
1246/*
1247 * COMMIT call returned
1248 */
Trond Myklebust788e7a82006-03-20 13:44:27 -05001249static void nfs_commit_done(struct rpc_task *task, void *calldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250{
Trond Myklebust963d8fe2006-01-03 09:55:04 +01001251 struct nfs_write_data *data = calldata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 struct nfs_page *req;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253
Chuck Levera3f565b2007-01-31 12:14:01 -05001254 dprintk("NFS: %5u nfs_commit_done (status %d)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 task->tk_pid, task->tk_status);
1256
Trond Myklebust788e7a82006-03-20 13:44:27 -05001257 /* Call the NFS version-specific code */
1258 if (NFS_PROTO(data->inode)->commit_done(task, data) != 0)
1259 return;
1260
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 while (!list_empty(&data->pages)) {
1262 req = nfs_list_entry(data->pages.next);
1263 nfs_list_remove_request(req);
Trond Myklebust612c9382007-04-20 16:12:45 -04001264 clear_bit(PG_NEED_COMMIT, &(req)->wb_flags);
Christoph Lameterfd39fc82006-06-30 01:55:40 -07001265 dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
Peter Zijlstrac9e51e42007-10-16 23:25:47 -07001266 dec_bdi_stat(req->wb_page->mapping->backing_dev_info,
1267 BDI_RECLAIMABLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268
1269 dprintk("NFS: commit (%s/%Ld %d@%Ld)",
Trond Myklebust88be9f92007-06-05 10:42:27 -04001270 req->wb_context->path.dentry->d_inode->i_sb->s_id,
1271 (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 req->wb_bytes,
1273 (long long)req_offset(req));
1274 if (task->tk_status < 0) {
Trond Myklebust7b159fc2007-07-25 14:09:54 -04001275 nfs_context_set_write_error(req->wb_context, task->tk_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 nfs_inode_remove_request(req);
1277 dprintk(", error = %d\n", task->tk_status);
1278 goto next;
1279 }
1280
1281 /* Okay, COMMIT succeeded, apparently. Check the verifier
1282 * returned by the server against all stored verfs. */
1283 if (!memcmp(req->wb_verf.verifier, data->verf.verifier, sizeof(data->verf.verifier))) {
1284 /* We have a match */
Trond Myklebust44dd1512007-05-19 11:58:03 -04001285 /* Set the PG_uptodate flag */
1286 nfs_mark_uptodate(req->wb_page, req->wb_pgbase,
1287 req->wb_bytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 nfs_inode_remove_request(req);
1289 dprintk(" OK\n");
1290 goto next;
1291 }
1292 /* We have a mismatch. Write the page again */
1293 dprintk(" mismatch\n");
Trond Myklebust61822ab2006-12-05 00:35:42 -05001294 nfs_redirty_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 next:
Trond Myklebust9fd367f2007-06-17 15:10:24 -04001296 nfs_clear_page_tag_locked(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298}
Trond Myklebust788e7a82006-03-20 13:44:27 -05001299
1300static const struct rpc_call_ops nfs_commit_ops = {
1301 .rpc_call_done = nfs_commit_done,
1302 .rpc_release = nfs_commit_release,
1303};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304
Trond Myklebust3da28eb2005-06-22 17:16:31 +00001305int nfs_commit_inode(struct inode *inode, int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 LIST_HEAD(head);
Trond Myklebust7d46a492006-03-20 13:44:50 -05001308 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309
Trond Myklebust587142f2007-07-02 09:57:54 -04001310 spin_lock(&inode->i_lock);
Trond Myklebust3da28eb2005-06-22 17:16:31 +00001311 res = nfs_scan_commit(inode, &head, 0, 0);
Trond Myklebust587142f2007-07-02 09:57:54 -04001312 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 if (res) {
Trond Myklebust7d46a492006-03-20 13:44:50 -05001314 int error = nfs_commit_list(inode, &head, how);
Trond Myklebust3da28eb2005-06-22 17:16:31 +00001315 if (error < 0)
1316 return error;
1317 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 return res;
1319}
Trond Myklebustc63c7b02007-04-02 19:29:52 -04001320#else
1321static inline int nfs_commit_list(struct inode *inode, struct list_head *head, int how)
1322{
1323 return 0;
1324}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325#endif
1326
Trond Myklebust1c759502006-10-09 16:18:38 -04001327long nfs_sync_mapping_wait(struct address_space *mapping, struct writeback_control *wbc, int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328{
Trond Myklebust1c759502006-10-09 16:18:38 -04001329 struct inode *inode = mapping->host;
Trond Myklebustca52fec2007-04-17 17:22:13 -04001330 pgoff_t idx_start, idx_end;
Trond Myklebust1c759502006-10-09 16:18:38 -04001331 unsigned int npages = 0;
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001332 LIST_HEAD(head);
Trond Myklebust70b9ecb2006-01-03 09:55:34 +01001333 int nocommit = how & FLUSH_NOCOMMIT;
Trond Myklebust3f442542006-09-17 14:46:44 -04001334 long pages, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335
Trond Myklebust1c759502006-10-09 16:18:38 -04001336 /* FIXME */
1337 if (wbc->range_cyclic)
1338 idx_start = 0;
1339 else {
1340 idx_start = wbc->range_start >> PAGE_CACHE_SHIFT;
1341 idx_end = wbc->range_end >> PAGE_CACHE_SHIFT;
1342 if (idx_end > idx_start) {
Trond Myklebustca52fec2007-04-17 17:22:13 -04001343 pgoff_t l_npages = 1 + idx_end - idx_start;
Trond Myklebust1c759502006-10-09 16:18:38 -04001344 npages = l_npages;
1345 if (sizeof(npages) != sizeof(l_npages) &&
Trond Myklebustca52fec2007-04-17 17:22:13 -04001346 (pgoff_t)npages != l_npages)
Trond Myklebust1c759502006-10-09 16:18:38 -04001347 npages = 0;
1348 }
1349 }
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001350 how &= ~FLUSH_NOCOMMIT;
Trond Myklebust587142f2007-07-02 09:57:54 -04001351 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 do {
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001353 ret = nfs_wait_on_requests_locked(inode, idx_start, npages);
1354 if (ret != 0)
Trond Myklebust70b9ecb2006-01-03 09:55:34 +01001355 continue;
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001356 if (nocommit)
1357 break;
Trond Myklebustd2ccddf2006-05-31 01:13:38 -04001358 pages = nfs_scan_commit(inode, &head, idx_start, npages);
Trond Myklebust724c4392007-04-17 17:22:13 -04001359 if (pages == 0)
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001360 break;
Trond Myklebustd2ccddf2006-05-31 01:13:38 -04001361 if (how & FLUSH_INVALIDATE) {
Trond Myklebust587142f2007-07-02 09:57:54 -04001362 spin_unlock(&inode->i_lock);
Trond Myklebust83715ad2006-07-05 13:17:12 -04001363 nfs_cancel_commit_list(&head);
Trond Myklebuste8e058e2006-11-15 17:31:56 -05001364 ret = pages;
Trond Myklebust587142f2007-07-02 09:57:54 -04001365 spin_lock(&inode->i_lock);
Trond Myklebustd2ccddf2006-05-31 01:13:38 -04001366 continue;
1367 }
1368 pages += nfs_scan_commit(inode, &head, 0, 0);
Trond Myklebust587142f2007-07-02 09:57:54 -04001369 spin_unlock(&inode->i_lock);
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001370 ret = nfs_commit_list(inode, &head, how);
Trond Myklebust587142f2007-07-02 09:57:54 -04001371 spin_lock(&inode->i_lock);
1372
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001373 } while (ret >= 0);
Trond Myklebust587142f2007-07-02 09:57:54 -04001374 spin_unlock(&inode->i_lock);
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001375 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376}
1377
Trond Myklebust34901f72007-07-25 14:09:54 -04001378static int __nfs_write_mapping(struct address_space *mapping, struct writeback_control *wbc, int how)
Trond Myklebust1c759502006-10-09 16:18:38 -04001379{
Trond Myklebust1c759502006-10-09 16:18:38 -04001380 int ret;
1381
Trond Myklebust34901f72007-07-25 14:09:54 -04001382 ret = nfs_writepages(mapping, wbc);
Trond Myklebust61822ab2006-12-05 00:35:42 -05001383 if (ret < 0)
1384 goto out;
Trond Myklebust34901f72007-07-25 14:09:54 -04001385 ret = nfs_sync_mapping_wait(mapping, wbc, how);
Trond Myklebusted90ef52007-07-20 13:13:28 -04001386 if (ret < 0)
1387 goto out;
1388 return 0;
Trond Myklebust61822ab2006-12-05 00:35:42 -05001389out:
Trond Myklebuste507d9e2006-12-05 00:35:42 -05001390 __mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
Trond Myklebust1c759502006-10-09 16:18:38 -04001391 return ret;
1392}
1393
Trond Myklebust34901f72007-07-25 14:09:54 -04001394/* Two pass sync: first using WB_SYNC_NONE, then WB_SYNC_ALL */
1395static int nfs_write_mapping(struct address_space *mapping, int how)
1396{
1397 struct writeback_control wbc = {
1398 .bdi = mapping->backing_dev_info,
1399 .sync_mode = WB_SYNC_NONE,
1400 .nr_to_write = LONG_MAX,
1401 .for_writepages = 1,
1402 .range_cyclic = 1,
1403 };
1404 int ret;
1405
1406 ret = __nfs_write_mapping(mapping, &wbc, how);
1407 if (ret < 0)
1408 return ret;
1409 wbc.sync_mode = WB_SYNC_ALL;
1410 return __nfs_write_mapping(mapping, &wbc, how);
1411}
1412
Trond Myklebusted90ef52007-07-20 13:13:28 -04001413/*
1414 * flush the inode to disk.
1415 */
1416int nfs_wb_all(struct inode *inode)
Trond Myklebust1c759502006-10-09 16:18:38 -04001417{
Trond Myklebusted90ef52007-07-20 13:13:28 -04001418 return nfs_write_mapping(inode->i_mapping, 0);
1419}
Trond Myklebust1c759502006-10-09 16:18:38 -04001420
Trond Myklebusted90ef52007-07-20 13:13:28 -04001421int nfs_wb_nocommit(struct inode *inode)
1422{
1423 return nfs_write_mapping(inode->i_mapping, FLUSH_NOCOMMIT);
Trond Myklebust1c759502006-10-09 16:18:38 -04001424}
1425
Trond Myklebust1b3b4a12007-08-28 10:29:36 -04001426int nfs_wb_page_cancel(struct inode *inode, struct page *page)
1427{
1428 struct nfs_page *req;
1429 loff_t range_start = page_offset(page);
1430 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
1431 struct writeback_control wbc = {
1432 .bdi = page->mapping->backing_dev_info,
1433 .sync_mode = WB_SYNC_ALL,
1434 .nr_to_write = LONG_MAX,
1435 .range_start = range_start,
1436 .range_end = range_end,
1437 };
1438 int ret = 0;
1439
1440 BUG_ON(!PageLocked(page));
1441 for (;;) {
1442 req = nfs_page_find_request(page);
1443 if (req == NULL)
1444 goto out;
1445 if (test_bit(PG_NEED_COMMIT, &req->wb_flags)) {
1446 nfs_release_request(req);
1447 break;
1448 }
1449 if (nfs_lock_request_dontget(req)) {
1450 nfs_inode_remove_request(req);
1451 /*
1452 * In case nfs_inode_remove_request has marked the
1453 * page as being dirty
1454 */
1455 cancel_dirty_page(page, PAGE_CACHE_SIZE);
1456 nfs_unlock_request(req);
1457 break;
1458 }
1459 ret = nfs_wait_on_request(req);
1460 if (ret < 0)
1461 goto out;
1462 }
1463 if (!PagePrivate(page))
1464 return 0;
1465 ret = nfs_sync_mapping_wait(page->mapping, &wbc, FLUSH_INVALIDATE);
1466out:
1467 return ret;
1468}
1469
Adrian Bunk5334eb12007-11-21 15:04:31 -08001470static int nfs_wb_page_priority(struct inode *inode, struct page *page,
1471 int how)
Trond Myklebust1c759502006-10-09 16:18:38 -04001472{
1473 loff_t range_start = page_offset(page);
1474 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
Trond Myklebust4d770cc2006-12-05 00:35:41 -05001475 struct writeback_control wbc = {
1476 .bdi = page->mapping->backing_dev_info,
1477 .sync_mode = WB_SYNC_ALL,
1478 .nr_to_write = LONG_MAX,
1479 .range_start = range_start,
1480 .range_end = range_end,
1481 };
1482 int ret;
Trond Myklebust1c759502006-10-09 16:18:38 -04001483
Trond Myklebust4d770cc2006-12-05 00:35:41 -05001484 BUG_ON(!PageLocked(page));
Trond Myklebustc63c7b02007-04-02 19:29:52 -04001485 if (clear_page_dirty_for_io(page)) {
Trond Myklebust4d770cc2006-12-05 00:35:41 -05001486 ret = nfs_writepage_locked(page, &wbc);
1487 if (ret < 0)
1488 goto out;
1489 }
Trond Myklebustf40313a2007-01-13 02:28:08 -05001490 if (!PagePrivate(page))
1491 return 0;
Trond Myklebust4d770cc2006-12-05 00:35:41 -05001492 ret = nfs_sync_mapping_wait(page->mapping, &wbc, how);
1493 if (ret >= 0)
1494 return 0;
1495out:
Trond Myklebuste507d9e2006-12-05 00:35:42 -05001496 __mark_inode_dirty(inode, I_DIRTY_PAGES);
Trond Myklebust4d770cc2006-12-05 00:35:41 -05001497 return ret;
Trond Myklebust1c759502006-10-09 16:18:38 -04001498}
1499
1500/*
1501 * Write back all requests on one page - we do this before reading it.
1502 */
1503int nfs_wb_page(struct inode *inode, struct page* page)
1504{
Trond Myklebust4d770cc2006-12-05 00:35:41 -05001505 return nfs_wb_page_priority(inode, page, FLUSH_STABLE);
Trond Myklebust1c759502006-10-09 16:18:38 -04001506}
1507
David Howellsf7b422b2006-06-09 09:34:33 -04001508int __init nfs_init_writepagecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509{
1510 nfs_wdata_cachep = kmem_cache_create("nfs_write_data",
1511 sizeof(struct nfs_write_data),
1512 0, SLAB_HWCACHE_ALIGN,
Paul Mundt20c2df82007-07-20 10:11:58 +09001513 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 if (nfs_wdata_cachep == NULL)
1515 return -ENOMEM;
1516
Matthew Dobson93d23412006-03-26 01:37:50 -08001517 nfs_wdata_mempool = mempool_create_slab_pool(MIN_POOL_WRITE,
1518 nfs_wdata_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 if (nfs_wdata_mempool == NULL)
1520 return -ENOMEM;
1521
Matthew Dobson93d23412006-03-26 01:37:50 -08001522 nfs_commit_mempool = mempool_create_slab_pool(MIN_POOL_COMMIT,
1523 nfs_wdata_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524 if (nfs_commit_mempool == NULL)
1525 return -ENOMEM;
1526
Peter Zijlstra89a09142007-03-16 13:38:26 -08001527 /*
1528 * NFS congestion size, scale with available memory.
1529 *
1530 * 64MB: 8192k
1531 * 128MB: 11585k
1532 * 256MB: 16384k
1533 * 512MB: 23170k
1534 * 1GB: 32768k
1535 * 2GB: 46340k
1536 * 4GB: 65536k
1537 * 8GB: 92681k
1538 * 16GB: 131072k
1539 *
1540 * This allows larger machines to have larger/more transfers.
1541 * Limit the default to 256M
1542 */
1543 nfs_congestion_kb = (16*int_sqrt(totalram_pages)) << (PAGE_SHIFT-10);
1544 if (nfs_congestion_kb > 256*1024)
1545 nfs_congestion_kb = 256*1024;
1546
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 return 0;
1548}
1549
David Brownell266bee82006-06-27 12:59:15 -07001550void nfs_destroy_writepagecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551{
1552 mempool_destroy(nfs_commit_mempool);
1553 mempool_destroy(nfs_wdata_mempool);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001554 kmem_cache_destroy(nfs_wdata_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555}
1556