]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blame - fs/nfs/read.c
nfs: rename members of nfs_pgio_data
[mirror_ubuntu-hirsute-kernel.git] / fs / nfs / read.c
CommitLineData
1da177e4
LT
1/*
2 * linux/fs/nfs/read.c
3 *
4 * Block I/O for NFS
5 *
6 * Partial copy of Linus' read cache modifications to fs/nfs/file.c
7 * modified for async RPC by okir@monad.swb.de
1da177e4
LT
8 */
9
1da177e4
LT
10#include <linux/time.h>
11#include <linux/kernel.h>
12#include <linux/errno.h>
13#include <linux/fcntl.h>
14#include <linux/stat.h>
15#include <linux/mm.h>
16#include <linux/slab.h>
17#include <linux/pagemap.h>
18#include <linux/sunrpc/clnt.h>
19#include <linux/nfs_fs.h>
20#include <linux/nfs_page.h>
64419a9b 21#include <linux/module.h>
1da177e4 22
f11c88af 23#include "nfs4_fs.h"
49a70f27 24#include "internal.h"
91d5b470 25#include "iostat.h"
9a9fc1c0 26#include "fscache.h"
fab5fc25 27#include "pnfs.h"
91d5b470 28
1da177e4
LT
29#define NFSDBG_FACILITY NFSDBG_PAGECACHE
30
061ae2ed 31static const struct nfs_pgio_completion_ops nfs_async_read_completion_ops;
4a0de55c 32static const struct nfs_rw_ops nfs_rw_read_ops;
1da177e4 33
e18b890b 34static struct kmem_cache *nfs_rdata_cachep;
1da177e4 35
1e7f3a48 36static struct nfs_pgio_header *nfs_readhdr_alloc(void)
3feb2d49 37{
4a0de55c 38 return kmem_cache_zalloc(nfs_rdata_cachep, GFP_KERNEL);
4db6e0b7
FI
39}
40
1e7f3a48 41static void nfs_readhdr_free(struct nfs_pgio_header *rhdr)
3feb2d49 42{
cd841605 43 kmem_cache_free(nfs_rdata_cachep, rhdr);
3feb2d49
TM
44}
45
1da177e4
LT
46static
47int nfs_return_empty_page(struct page *page)
48{
eebd2aa3 49 zero_user(page, 0, PAGE_CACHE_SIZE);
1da177e4
LT
50 SetPageUptodate(page);
51 unlock_page(page);
52 return 0;
53}
54
1abb5088 55void nfs_pageio_init_read(struct nfs_pageio_descriptor *pgio,
fab5fc25 56 struct inode *inode, bool force_mds,
061ae2ed 57 const struct nfs_pgio_completion_ops *compl_ops)
1751c363 58{
fab5fc25 59 struct nfs_server *server = NFS_SERVER(inode);
41d8d5b7 60 const struct nfs_pageio_ops *pg_ops = &nfs_pgio_rw_ops;
fab5fc25
CH
61
62#ifdef CONFIG_NFS_V4_1
63 if (server->pnfs_curr_ld && !force_mds)
64 pg_ops = server->pnfs_curr_ld->pg_read_ops;
65#endif
4a0de55c
AS
66 nfs_pageio_init(pgio, inode, pg_ops, compl_ops, &nfs_rw_read_ops,
67 server->rsize, 0);
1751c363 68}
ddda8e0a 69EXPORT_SYMBOL_GPL(nfs_pageio_init_read);
1751c363 70
493292dd
TM
71void nfs_pageio_reset_read_mds(struct nfs_pageio_descriptor *pgio)
72{
41d8d5b7 73 pgio->pg_ops = &nfs_pgio_rw_ops;
493292dd
TM
74 pgio->pg_bsize = NFS_SERVER(pgio->pg_inode)->rsize;
75}
1f945357 76EXPORT_SYMBOL_GPL(nfs_pageio_reset_read_mds);
493292dd 77
f42b293d
DH
78int nfs_readpage_async(struct nfs_open_context *ctx, struct inode *inode,
79 struct page *page)
1da177e4 80{
1da177e4
LT
81 struct nfs_page *new;
82 unsigned int len;
c76069bd 83 struct nfs_pageio_descriptor pgio;
1da177e4 84
49a70f27 85 len = nfs_page_length(page);
1da177e4
LT
86 if (len == 0)
87 return nfs_return_empty_page(page);
2bfc6e56 88 new = nfs_create_request(ctx, page, NULL, 0, len);
1da177e4
LT
89 if (IS_ERR(new)) {
90 unlock_page(page);
91 return PTR_ERR(new);
92 }
93 if (len < PAGE_CACHE_SIZE)
eebd2aa3 94 zero_user_segment(page, len, PAGE_CACHE_SIZE);
1da177e4 95
fab5fc25
CH
96 nfs_pageio_init_read(&pgio, inode, false,
97 &nfs_async_read_completion_ops);
d8007d4d 98 nfs_pageio_add_request(&pgio, new);
1751c363 99 nfs_pageio_complete(&pgio);
2701d086 100 NFS_I(inode)->read_io += pgio.pg_bytes_written;
1da177e4
LT
101 return 0;
102}
103
104static void nfs_readpage_release(struct nfs_page *req)
105{
3d4ff43d 106 struct inode *d_inode = req->wb_context->dentry->d_inode;
7f8e05f6 107
67d0338e
WAA
108 dprintk("NFS: read done (%s/%llu %d@%lld)\n", d_inode->i_sb->s_id,
109 (unsigned long long)NFS_FILEID(d_inode), req->wb_bytes,
110 (long long)req_offset(req));
7f8e05f6 111
67d0338e
WAA
112 if (nfs_page_group_sync_on_bit(req, PG_UNLOCKPAGE)) {
113 if (PageUptodate(req->wb_page))
114 nfs_readpage_to_fscache(d_inode, req->wb_page, 0);
115
116 unlock_page(req->wb_page);
117 }
1da177e4 118
1e8968c5 119 dprintk("NFS: read done (%s/%Lu %d@%Ld)\n",
3d4ff43d 120 req->wb_context->dentry->d_inode->i_sb->s_id,
1e8968c5 121 (unsigned long long)NFS_FILEID(req->wb_context->dentry->d_inode),
1da177e4
LT
122 req->wb_bytes,
123 (long long)req_offset(req));
10d2c46f 124 nfs_release_request(req);
1da177e4
LT
125}
126
67d0338e
WAA
127static void nfs_page_group_set_uptodate(struct nfs_page *req)
128{
129 if (nfs_page_group_sync_on_bit(req, PG_UPTODATE))
130 SetPageUptodate(req->wb_page);
131}
132
061ae2ed 133static void nfs_read_completion(struct nfs_pgio_header *hdr)
4db6e0b7
FI
134{
135 unsigned long bytes = 0;
136
137 if (test_bit(NFS_IOHDR_REDO, &hdr->flags))
138 goto out;
4bd8b010
TM
139 while (!list_empty(&hdr->pages)) {
140 struct nfs_page *req = nfs_list_entry(hdr->pages.next);
141 struct page *page = req->wb_page;
68072992
WAA
142 unsigned long start = req->wb_pgbase;
143 unsigned long end = req->wb_pgbase + req->wb_bytes;
4bd8b010
TM
144
145 if (test_bit(NFS_IOHDR_EOF, &hdr->flags)) {
68072992
WAA
146 /* note: regions of the page not covered by a
147 * request are zeroed in nfs_readpage_async /
148 * readpage_async_filler */
149 if (bytes > hdr->good_bytes) {
150 /* nothing in this request was good, so zero
151 * the full extent of the request */
152 zero_user_segment(page, start, end);
153
154 } else if (hdr->good_bytes - bytes < req->wb_bytes) {
155 /* part of this request has good bytes, but
156 * not all. zero the bad bytes */
157 start += hdr->good_bytes - bytes;
158 WARN_ON(start < req->wb_pgbase);
159 zero_user_segment(page, start, end);
160 }
4db6e0b7 161 }
4bd8b010
TM
162 bytes += req->wb_bytes;
163 if (test_bit(NFS_IOHDR_ERROR, &hdr->flags)) {
4db6e0b7 164 if (bytes <= hdr->good_bytes)
67d0338e 165 nfs_page_group_set_uptodate(req);
4bd8b010 166 } else
67d0338e 167 nfs_page_group_set_uptodate(req);
4bd8b010
TM
168 nfs_list_remove_request(req);
169 nfs_readpage_release(req);
4db6e0b7
FI
170 }
171out:
172 hdr->release(hdr);
173}
174
1ed26f33
AS
175static void nfs_initiate_read(struct nfs_pgio_data *data, struct rpc_message *msg,
176 struct rpc_task_setup *task_setup_data, int how)
1da177e4 177{
cd841605 178 struct inode *inode = data->header->inode;
84115e1c 179 int swap_flags = IS_SWAPFILE(inode) ? NFS_RPC_SWAPFLAGS : 0;
1da177e4 180
1ed26f33
AS
181 task_setup_data->flags |= swap_flags;
182 NFS_PROTO(inode)->read_setup(data, msg);
64419a9b
AA
183}
184
061ae2ed 185static void
1da177e4
LT
186nfs_async_read_error(struct list_head *head)
187{
188 struct nfs_page *req;
189
190 while (!list_empty(head)) {
191 req = nfs_list_entry(head->next);
192 nfs_list_remove_request(req);
1da177e4
LT
193 nfs_readpage_release(req);
194 }
195}
196
061ae2ed
FI
197static const struct nfs_pgio_completion_ops nfs_async_read_completion_ops = {
198 .error_cleanup = nfs_async_read_error,
199 .completion = nfs_read_completion,
200};
201
0b671301
TM
202/*
203 * This is the callback from RPC telling us whether a reply was
204 * received or some error occurred (timeout or socket shutdown).
205 */
0eecb214
AS
206static int nfs_readpage_done(struct rpc_task *task, struct nfs_pgio_data *data,
207 struct inode *inode)
0b671301 208{
0eecb214 209 int status = NFS_PROTO(inode)->read_done(task, data);
0b671301
TM
210 if (status != 0)
211 return status;
212
cd841605 213 nfs_add_stats(inode, NFSIOS_SERVERREADBYTES, data->res.count);
0b671301
TM
214
215 if (task->tk_status == -ESTALE) {
cd841605
FI
216 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
217 nfs_mark_for_revalidate(inode);
0b671301 218 }
0b671301
TM
219 return 0;
220}
221
9c7e1b3d 222static void nfs_readpage_retry(struct rpc_task *task, struct nfs_pgio_data *data)
0b671301 223{
3c6b899c 224 struct nfs_pgio_args *argp = &data->args;
9137bdf3 225 struct nfs_pgio_res *resp = &data->res;
0b671301 226
0b671301 227 /* This is a short read! */
cd841605 228 nfs_inc_stats(data->header->inode, NFSIOS_SHORTREAD);
0b671301 229 /* Has the server at least made some progress? */
4db6e0b7
FI
230 if (resp->count == 0) {
231 nfs_set_pgio_error(data->header, -EIO, argp->offset);
d61e612a 232 return;
4db6e0b7 233 }
0b671301 234 /* Yes, so retry the read at the end of the data */
cbdabc7f 235 data->mds_offset += resp->count;
0b671301
TM
236 argp->offset += resp->count;
237 argp->pgbase += resp->count;
238 argp->count -= resp->count;
d00c5d43 239 rpc_restart_call_prepare(task);
0b671301
TM
240}
241
0eecb214 242static void nfs_readpage_result(struct rpc_task *task, struct nfs_pgio_data *data)
1da177e4 243{
4db6e0b7
FI
244 struct nfs_pgio_header *hdr = data->header;
245
0eecb214 246 if (data->res.eof) {
4db6e0b7
FI
247 loff_t bound;
248
249 bound = data->args.offset + data->res.count;
250 spin_lock(&hdr->lock);
251 if (bound < hdr->io_start + hdr->good_bytes) {
252 set_bit(NFS_IOHDR_EOF, &hdr->flags);
253 clear_bit(NFS_IOHDR_ERROR, &hdr->flags);
254 hdr->good_bytes = bound - hdr->io_start;
255 }
256 spin_unlock(&hdr->lock);
257 } else if (data->res.count != data->args.count)
258 nfs_readpage_retry(task, data);
fdd1e74c
TM
259}
260
1da177e4
LT
261/*
262 * Read a page over NFS.
263 * We read the page synchronously in the following case:
264 * - The error flag is set for this page. This happens only when a
265 * previous async read operation failed.
266 */
267int nfs_readpage(struct file *file, struct page *page)
268{
269 struct nfs_open_context *ctx;
d56b4ddf 270 struct inode *inode = page_file_mapping(page)->host;
1da177e4
LT
271 int error;
272
273 dprintk("NFS: nfs_readpage (%p %ld@%lu)\n",
d56b4ddf 274 page, PAGE_CACHE_SIZE, page_file_index(page));
91d5b470
CL
275 nfs_inc_stats(inode, NFSIOS_VFSREADPAGE);
276 nfs_add_stats(inode, NFSIOS_READPAGES, 1);
277
1da177e4
LT
278 /*
279 * Try to flush any pending writes to the file..
280 *
281 * NOTE! Because we own the page lock, there cannot
282 * be any new pending writes generated at this point
283 * for this page (other pages can be written to).
284 */
285 error = nfs_wb_page(inode, page);
286 if (error)
de05a0cc
TM
287 goto out_unlock;
288 if (PageUptodate(page))
289 goto out_unlock;
1da177e4 290
5f004cf2
TM
291 error = -ESTALE;
292 if (NFS_STALE(inode))
de05a0cc 293 goto out_unlock;
5f004cf2 294
1da177e4 295 if (file == NULL) {
cf1308ff 296 error = -EBADF;
d530838b 297 ctx = nfs_find_open_context(inode, NULL, FMODE_READ);
1da177e4 298 if (ctx == NULL)
de05a0cc 299 goto out_unlock;
1da177e4 300 } else
cd3758e3 301 ctx = get_nfs_open_context(nfs_file_open_context(file));
1da177e4 302
9a9fc1c0
DH
303 if (!IS_SYNC(inode)) {
304 error = nfs_readpage_from_fscache(ctx, inode, page);
305 if (error == 0)
306 goto out;
307 }
308
8e0969f0
TM
309 error = nfs_readpage_async(ctx, inode, page);
310
9a9fc1c0 311out:
1da177e4
LT
312 put_nfs_open_context(ctx);
313 return error;
de05a0cc 314out_unlock:
1da177e4
LT
315 unlock_page(page);
316 return error;
317}
318
319struct nfs_readdesc {
8b09bee3 320 struct nfs_pageio_descriptor *pgio;
1da177e4
LT
321 struct nfs_open_context *ctx;
322};
323
324static int
325readpage_async_filler(void *data, struct page *page)
326{
327 struct nfs_readdesc *desc = (struct nfs_readdesc *)data;
1da177e4
LT
328 struct nfs_page *new;
329 unsigned int len;
de05a0cc
TM
330 int error;
331
49a70f27 332 len = nfs_page_length(page);
1da177e4
LT
333 if (len == 0)
334 return nfs_return_empty_page(page);
de05a0cc 335
2bfc6e56 336 new = nfs_create_request(desc->ctx, page, NULL, 0, len);
de05a0cc
TM
337 if (IS_ERR(new))
338 goto out_error;
339
1da177e4 340 if (len < PAGE_CACHE_SIZE)
eebd2aa3 341 zero_user_segment(page, len, PAGE_CACHE_SIZE);
f8512ad0
FI
342 if (!nfs_pageio_add_request(desc->pgio, new)) {
343 error = desc->pgio->pg_error;
344 goto out_unlock;
345 }
1da177e4 346 return 0;
de05a0cc
TM
347out_error:
348 error = PTR_ERR(new);
de05a0cc
TM
349out_unlock:
350 unlock_page(page);
351 return error;
1da177e4
LT
352}
353
354int nfs_readpages(struct file *filp, struct address_space *mapping,
355 struct list_head *pages, unsigned nr_pages)
356{
8b09bee3 357 struct nfs_pageio_descriptor pgio;
1da177e4 358 struct nfs_readdesc desc = {
8b09bee3 359 .pgio = &pgio,
1da177e4
LT
360 };
361 struct inode *inode = mapping->host;
8b09bee3 362 unsigned long npages;
5f004cf2 363 int ret = -ESTALE;
1da177e4 364
1e8968c5 365 dprintk("NFS: nfs_readpages (%s/%Lu %d)\n",
1da177e4 366 inode->i_sb->s_id,
1e8968c5 367 (unsigned long long)NFS_FILEID(inode),
1da177e4 368 nr_pages);
91d5b470 369 nfs_inc_stats(inode, NFSIOS_VFSREADPAGES);
1da177e4 370
5f004cf2
TM
371 if (NFS_STALE(inode))
372 goto out;
373
1da177e4 374 if (filp == NULL) {
d530838b 375 desc.ctx = nfs_find_open_context(inode, NULL, FMODE_READ);
1da177e4
LT
376 if (desc.ctx == NULL)
377 return -EBADF;
378 } else
cd3758e3 379 desc.ctx = get_nfs_open_context(nfs_file_open_context(filp));
9a9fc1c0
DH
380
381 /* attempt to read as many of the pages as possible from the cache
382 * - this returns -ENOBUFS immediately if the cookie is negative
383 */
384 ret = nfs_readpages_from_fscache(desc.ctx, inode, mapping,
385 pages, &nr_pages);
386 if (ret == 0)
387 goto read_complete; /* all pages were read */
388
fab5fc25
CH
389 nfs_pageio_init_read(&pgio, inode, false,
390 &nfs_async_read_completion_ops);
8b09bee3 391
1da177e4 392 ret = read_cache_pages(mapping, pages, readpage_async_filler, &desc);
8b09bee3
TM
393
394 nfs_pageio_complete(&pgio);
2701d086 395 NFS_I(inode)->read_io += pgio.pg_bytes_written;
8b09bee3
TM
396 npages = (pgio.pg_bytes_written + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
397 nfs_add_stats(inode, NFSIOS_READPAGES, npages);
9a9fc1c0 398read_complete:
1da177e4 399 put_nfs_open_context(desc.ctx);
5f004cf2 400out:
1da177e4
LT
401 return ret;
402}
403
f7b422b1 404int __init nfs_init_readpagecache(void)
1da177e4
LT
405{
406 nfs_rdata_cachep = kmem_cache_create("nfs_read_data",
1e7f3a48 407 sizeof(struct nfs_pgio_header),
1da177e4 408 0, SLAB_HWCACHE_ALIGN,
20c2df83 409 NULL);
1da177e4
LT
410 if (nfs_rdata_cachep == NULL)
411 return -ENOMEM;
412
1da177e4
LT
413 return 0;
414}
415
266bee88 416void nfs_destroy_readpagecache(void)
1da177e4 417{
1a1d92c1 418 kmem_cache_destroy(nfs_rdata_cachep);
1da177e4 419}
4a0de55c
AS
420
421static const struct nfs_rw_ops nfs_rw_read_ops = {
a4cdda59 422 .rw_mode = FMODE_READ,
4a0de55c
AS
423 .rw_alloc_header = nfs_readhdr_alloc,
424 .rw_free_header = nfs_readhdr_free,
0eecb214
AS
425 .rw_done = nfs_readpage_done,
426 .rw_result = nfs_readpage_result,
1ed26f33 427 .rw_initiate = nfs_initiate_read,
4a0de55c 428};