read.c 16.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 * linux/fs/nfs/read.c
 *
 * Block I/O for NFS
 *
 * Partial copy of Linus' read cache modifications to fs/nfs/file.c
 * modified for async RPC by okir@monad.swb.de
 */

#include <linux/time.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/fcntl.h>
#include <linux/stat.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/pagemap.h>
#include <linux/sunrpc/clnt.h>
#include <linux/nfs_fs.h>
#include <linux/nfs_page.h>
A
Andy Adamson 已提交
21
#include <linux/module.h>
L
Linus Torvalds 已提交
22

23
#include "pnfs.h"
L
Linus Torvalds 已提交
24

25
#include "nfs4_fs.h"
26
#include "internal.h"
C
Chuck Lever 已提交
27
#include "iostat.h"
28
#include "fscache.h"
C
Chuck Lever 已提交
29

L
Linus Torvalds 已提交
30 31
#define NFSDBG_FACILITY		NFSDBG_PAGECACHE

32
static const struct nfs_pageio_ops nfs_pageio_read_ops;
33
static const struct rpc_call_ops nfs_read_common_ops;
L
Linus Torvalds 已提交
34

35
static struct kmem_cache *nfs_rdata_cachep;
L
Linus Torvalds 已提交
36

37
struct nfs_read_header *nfs_readhdr_alloc()
38
{
39
	struct nfs_read_header *rhdr;
40

41 42 43
	rhdr = kmem_cache_zalloc(nfs_rdata_cachep, GFP_KERNEL);
	if (rhdr) {
		struct nfs_pgio_header *hdr = &rhdr->header;
44 45

		INIT_LIST_HEAD(&hdr->pages);
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
		INIT_LIST_HEAD(&hdr->rpc_list);
		spin_lock_init(&hdr->lock);
		atomic_set(&hdr->refcnt, 0);
	}
	return rhdr;
}

struct nfs_read_data *nfs_readdata_alloc(struct nfs_pgio_header *hdr,
					 unsigned int pagecount)
{
	struct nfs_read_data *data, *prealloc;

	prealloc = &container_of(hdr, struct nfs_read_header, header)->rpc_data;
	if (prealloc->header == NULL)
		data = prealloc;
	else
		data = kzalloc(sizeof(*data), GFP_KERNEL);
	if (!data)
		goto out;

	if (nfs_pgarray_set(&data->pages, pagecount)) {
67
		data->header = hdr;
68 69 70 71 72
		atomic_inc(&hdr->refcnt);
	} else {
		if (data != prealloc)
			kfree(data);
		data = NULL;
73
	}
74 75
out:
	return data;
76 77
}

78
void nfs_readhdr_free(struct nfs_pgio_header *hdr)
79
{
80 81 82
	struct nfs_read_header *rhdr = container_of(hdr, struct nfs_read_header, header);

	kmem_cache_free(nfs_rdata_cachep, rhdr);
83 84
}

85
void nfs_readdata_release(struct nfs_read_data *rdata)
L
Linus Torvalds 已提交
86
{
87 88 89
	struct nfs_pgio_header *hdr = rdata->header;
	struct nfs_read_header *read_header = container_of(hdr, struct nfs_read_header, header);

90
	put_nfs_open_context(rdata->args.context);
F
Fred Isaman 已提交
91 92
	if (rdata->pages.pagevec != rdata->pages.page_array)
		kfree(rdata->pages.pagevec);
93 94 95 96 97 98
	if (rdata != &read_header->rpc_data)
		kfree(rdata);
	else
		rdata->header = NULL;
	if (atomic_dec_and_test(&hdr->refcnt))
		nfs_read_completion(hdr);
L
Linus Torvalds 已提交
99 100 101 102 103
}

static
int nfs_return_empty_page(struct page *page)
{
104
	zero_user(page, 0, PAGE_CACHE_SIZE);
L
Linus Torvalds 已提交
105 106 107 108 109
	SetPageUptodate(page);
	unlock_page(page);
	return 0;
}

110
void nfs_pageio_init_read_mds(struct nfs_pageio_descriptor *pgio,
111 112 113 114 115 116
		struct inode *inode)
{
	nfs_pageio_init(pgio, inode, &nfs_pageio_read_ops,
			NFS_SERVER(inode)->rsize, 0);
}

117 118 119 120 121
void nfs_pageio_reset_read_mds(struct nfs_pageio_descriptor *pgio)
{
	pgio->pg_ops = &nfs_pageio_read_ops;
	pgio->pg_bsize = NFS_SERVER(pgio->pg_inode)->rsize;
}
122
EXPORT_SYMBOL_GPL(nfs_pageio_reset_read_mds);
123

124 125 126 127 128 129 130
static void nfs_pageio_init_read(struct nfs_pageio_descriptor *pgio,
		struct inode *inode)
{
	if (!pnfs_pageio_init_read(pgio, inode))
		nfs_pageio_init_read_mds(pgio, inode);
}

131 132
int nfs_readpage_async(struct nfs_open_context *ctx, struct inode *inode,
		       struct page *page)
L
Linus Torvalds 已提交
133 134 135
{
	struct nfs_page	*new;
	unsigned int len;
F
Fred Isaman 已提交
136
	struct nfs_pageio_descriptor pgio;
L
Linus Torvalds 已提交
137

138
	len = nfs_page_length(page);
L
Linus Torvalds 已提交
139 140 141 142 143 144 145 146
	if (len == 0)
		return nfs_return_empty_page(page);
	new = nfs_create_request(ctx, inode, page, 0, len);
	if (IS_ERR(new)) {
		unlock_page(page);
		return PTR_ERR(new);
	}
	if (len < PAGE_CACHE_SIZE)
147
		zero_user_segment(page, len, PAGE_CACHE_SIZE);
L
Linus Torvalds 已提交
148

149
	nfs_pageio_init_read(&pgio, inode);
150
	nfs_pageio_add_request(&pgio, new);
151
	nfs_pageio_complete(&pgio);
L
Linus Torvalds 已提交
152 153 154 155 156
	return 0;
}

static void nfs_readpage_release(struct nfs_page *req)
{
157
	struct inode *d_inode = req->wb_context->dentry->d_inode;
158 159 160 161

	if (PageUptodate(req->wb_page))
		nfs_readpage_to_fscache(d_inode, req->wb_page, 0);

L
Linus Torvalds 已提交
162 163 164
	unlock_page(req->wb_page);

	dprintk("NFS: read done (%s/%Ld %d@%Ld)\n",
165 166
			req->wb_context->dentry->d_inode->i_sb->s_id,
			(long long)NFS_FILEID(req->wb_context->dentry->d_inode),
L
Linus Torvalds 已提交
167 168
			req->wb_bytes,
			(long long)req_offset(req));
169
	nfs_release_request(req);
L
Linus Torvalds 已提交
170 171
}

172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211
/* Note io was page aligned */
void nfs_read_completion(struct nfs_pgio_header *hdr)
{
	unsigned long bytes = 0;

	if (test_bit(NFS_IOHDR_REDO, &hdr->flags))
		goto out;
	if (!test_bit(NFS_IOHDR_ERROR, &hdr->flags)) {
		while (!list_empty(&hdr->pages)) {
			struct nfs_page *req = nfs_list_entry(hdr->pages.next);
			struct page *page = req->wb_page;

			if (test_bit(NFS_IOHDR_EOF, &hdr->flags)) {
				if (bytes > hdr->good_bytes)
					zero_user(page, 0, PAGE_SIZE);
				else if (hdr->good_bytes - bytes < PAGE_SIZE)
					zero_user_segment(page,
						hdr->good_bytes & ~PAGE_MASK,
						PAGE_SIZE);
			}
			SetPageUptodate(page);
			nfs_list_remove_request(req);
			nfs_readpage_release(req);
			bytes += PAGE_SIZE;
		}
	} else {
		while (!list_empty(&hdr->pages)) {
			struct nfs_page *req = nfs_list_entry(hdr->pages.next);

			bytes += req->wb_bytes;
			if (bytes <= hdr->good_bytes)
				SetPageUptodate(req->wb_page);
			nfs_list_remove_request(req);
			nfs_readpage_release(req);
		}
	}
out:
	hdr->release(hdr);
}

212 213
int nfs_initiate_read(struct rpc_clnt *clnt,
		      struct nfs_read_data *data,
A
Andy Adamson 已提交
214
		      const struct rpc_call_ops *call_ops)
L
Linus Torvalds 已提交
215
{
216
	struct inode *inode = data->header->inode;
217
	int swap_flags = IS_SWAPFILE(inode) ? NFS_RPC_SWAPFLAGS : 0;
218
	struct rpc_task *task;
219 220 221
	struct rpc_message msg = {
		.rpc_argp = &data->args,
		.rpc_resp = &data->res,
222
		.rpc_cred = data->header->cred,
223
	};
224
	struct rpc_task_setup task_setup_data = {
225
		.task = &data->task,
A
Andy Adamson 已提交
226
		.rpc_client = clnt,
227
		.rpc_message = &msg,
228 229
		.callback_ops = call_ops,
		.callback_data = data,
230
		.workqueue = nfsiod_workqueue,
231 232
		.flags = RPC_TASK_ASYNC | swap_flags,
	};
L
Linus Torvalds 已提交
233

A
Andy Adamson 已提交
234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250
	/* Set up the initial task struct. */
	NFS_PROTO(inode)->read_setup(data, &msg);

	dprintk("NFS: %5u initiated read call (req %s/%lld, %u bytes @ "
			"offset %llu)\n",
			data->task.tk_pid,
			inode->i_sb->s_id,
			(long long)NFS_FILEID(inode),
			data->args.count,
			(unsigned long long)data->args.offset);

	task = rpc_run_task(&task_setup_data);
	if (IS_ERR(task))
		return PTR_ERR(task);
	rpc_put_task(task);
	return 0;
}
A
Andy Adamson 已提交
251
EXPORT_SYMBOL_GPL(nfs_initiate_read);
A
Andy Adamson 已提交
252 253 254 255

/*
 * Set up the NFS read request struct
 */
256
static void nfs_read_rpcsetup(struct nfs_read_data *data,
257
		unsigned int count, unsigned int offset)
A
Andy Adamson 已提交
258
{
259
	struct nfs_page *req = data->header->req;
L
Linus Torvalds 已提交
260

261
	data->args.fh     = NFS_FH(data->header->inode);
L
Linus Torvalds 已提交
262 263
	data->args.offset = req_offset(req) + offset;
	data->args.pgbase = req->wb_pgbase + offset;
F
Fred Isaman 已提交
264
	data->args.pages  = data->pages.pagevec;
L
Linus Torvalds 已提交
265
	data->args.count  = count;
266
	data->args.context = get_nfs_open_context(req->wb_context);
267
	data->args.lock_context = req->wb_lock_context;
L
Linus Torvalds 已提交
268 269 270 271

	data->res.fattr   = &data->fattr;
	data->res.count   = count;
	data->res.eof     = 0;
272
	nfs_fattr_init(&data->fattr);
273
}
L
Linus Torvalds 已提交
274

275
static int nfs_do_read(struct nfs_read_data *data,
276
		const struct rpc_call_ops *call_ops)
277
{
278
	struct inode *inode = data->header->inode;
279

280
	return nfs_initiate_read(NFS_CLIENT(inode), data, call_ops);
L
Linus Torvalds 已提交
281 282
}

283 284
static int
nfs_do_multiple_reads(struct list_head *head,
285
		const struct rpc_call_ops *call_ops)
286 287 288 289 290 291 292
{
	struct nfs_read_data *data;
	int ret = 0;

	while (!list_empty(head)) {
		int ret2;

293
		data = list_first_entry(head, struct nfs_read_data, list);
294 295
		list_del_init(&data->list);

296
		ret2 = nfs_do_read(data, call_ops);
297 298 299 300 301 302
		if (ret == 0)
			ret = ret2;
	}
	return ret;
}

303
void
L
Linus Torvalds 已提交
304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
nfs_async_read_error(struct list_head *head)
{
	struct nfs_page	*req;

	while (!list_empty(head)) {
		req = nfs_list_entry(head->next);
		nfs_list_remove_request(req);
		nfs_readpage_release(req);
	}
}

/*
 * Generate multiple requests to fill a single page.
 *
 * We optimize to reduce the number of read operations on the wire.  If we
 * detect that we're reading a page, or an area of a page, that is past the
 * end of file, we do not generate NFS read operations but just clear the
 * parts of the page that would have come back zero from the server anyway.
 *
 * We rely on the cached value of i_size to make this determination; another
 * client can fill pages on the server past our cached end-of-file, but we
 * won't see the new data until our attribute cache is updated.  This is more
 * or less conventional NFS client behavior.
 */
328 329
static int nfs_pagein_multi(struct nfs_pageio_descriptor *desc,
			    struct nfs_pgio_header *hdr)
L
Linus Torvalds 已提交
330
{
331
	struct nfs_page *req = hdr->req;
L
Linus Torvalds 已提交
332 333
	struct page *page = req->wb_page;
	struct nfs_read_data *data;
334
	size_t rsize = desc->pg_bsize, nbytes;
335
	unsigned int offset;
L
Linus Torvalds 已提交
336
	int requests = 0;
337
	int ret = 0;
L
Linus Torvalds 已提交
338 339

	nfs_list_remove_request(req);
340
	nfs_list_add_request(req, &hdr->pages);
L
Linus Torvalds 已提交
341

342
	offset = 0;
F
Fred Isaman 已提交
343
	nbytes = desc->pg_count;
344 345 346
	do {
		size_t len = min(nbytes,rsize);

347 348
		data = nfs_readdata_alloc(hdr, 1);
		if (!data)
L
Linus Torvalds 已提交
349
			goto out_bad;
F
Fred Isaman 已提交
350
		data->pages.pagevec[0] = page;
351 352
		nfs_read_rpcsetup(data, len, offset);
		list_add(&data->list, &hdr->rpc_list);
L
Linus Torvalds 已提交
353
		requests++;
354
		nbytes -= len;
355
		offset += len;
356
	} while(nbytes != 0);
357
	desc->pg_rpc_callops = &nfs_read_common_ops;
358
	return ret;
L
Linus Torvalds 已提交
359
out_bad:
360 361
	while (!list_empty(&hdr->rpc_list)) {
		data = list_first_entry(&hdr->rpc_list, struct nfs_read_data, list);
362
		list_del(&data->list);
363
		nfs_readdata_release(data);
L
Linus Torvalds 已提交
364
	}
365
	nfs_async_read_error(&hdr->pages);
L
Linus Torvalds 已提交
366 367 368
	return -ENOMEM;
}

369 370
static int nfs_pagein_one(struct nfs_pageio_descriptor *desc,
			  struct nfs_pgio_header *hdr)
L
Linus Torvalds 已提交
371 372 373
{
	struct nfs_page		*req;
	struct page		**pages;
374
	struct nfs_read_data    *data;
F
Fred Isaman 已提交
375
	struct list_head *head = &desc->pg_list;
376
	int ret = 0;
L
Linus Torvalds 已提交
377

378 379 380
	data = nfs_readdata_alloc(hdr, nfs_page_array_len(desc->pg_base,
							  desc->pg_count));
	if (!data) {
381
		nfs_async_read_error(head);
382
		ret = -ENOMEM;
383 384
		goto out;
	}
L
Linus Torvalds 已提交
385

F
Fred Isaman 已提交
386
	pages = data->pages.pagevec;
L
Linus Torvalds 已提交
387 388 389
	while (!list_empty(head)) {
		req = nfs_list_entry(head->next);
		nfs_list_remove_request(req);
390
		nfs_list_add_request(req, &hdr->pages);
L
Linus Torvalds 已提交
391 392 393
		*pages++ = req->wb_page;
	}

394 395 396
	nfs_read_rpcsetup(data, desc->pg_count, 0);
	list_add(&data->list, &hdr->rpc_list);
	desc->pg_rpc_callops = &nfs_read_common_ops;
397
out:
398
	return ret;
L
Linus Torvalds 已提交
399 400
}

401 402
int nfs_generic_pagein(struct nfs_pageio_descriptor *desc,
		       struct nfs_pgio_header *hdr)
403 404
{
	if (desc->pg_bsize < PAGE_CACHE_SIZE)
405 406
		return nfs_pagein_multi(desc, hdr);
	return nfs_pagein_one(desc, hdr);
407 408 409
}

static int nfs_generic_pg_readpages(struct nfs_pageio_descriptor *desc)
410
{
411 412
	struct nfs_read_header *rhdr;
	struct nfs_pgio_header *hdr;
413 414
	int ret;

415 416 417 418 419 420 421 422 423
	rhdr = nfs_readhdr_alloc();
	if (!rhdr) {
		nfs_async_read_error(&desc->pg_list);
		return -ENOMEM;
	}
	hdr = &rhdr->header;
	nfs_pgheader_init(desc, hdr, nfs_readhdr_free);
	atomic_inc(&hdr->refcnt);
	ret = nfs_generic_pagein(desc, hdr);
424
	if (ret == 0)
425 426 427 428 429 430
		ret = nfs_do_multiple_reads(&hdr->rpc_list,
					    desc->pg_rpc_callops);
	else
		set_bit(NFS_IOHDR_REDO, &hdr->flags);
	if (atomic_dec_and_test(&hdr->refcnt))
		nfs_read_completion(hdr);
431
	return ret;
432 433 434 435 436 437 438
}

static const struct nfs_pageio_ops nfs_pageio_read_ops = {
	.pg_test = nfs_generic_pg_test,
	.pg_doio = nfs_generic_pg_readpages,
};

439 440 441 442 443 444
/*
 * This is the callback from RPC telling us whether a reply was
 * received or some error occurred (timeout or socket shutdown).
 */
int nfs_readpage_result(struct rpc_task *task, struct nfs_read_data *data)
{
445
	struct inode *inode = data->header->inode;
446 447
	int status;

448
	dprintk("NFS: %s: %5u, (status %d)\n", __func__, task->tk_pid,
449 450
			task->tk_status);

451
	status = NFS_PROTO(inode)->read_done(task, data);
452 453 454
	if (status != 0)
		return status;

455
	nfs_add_stats(inode, NFSIOS_SERVERREADBYTES, data->res.count);
456 457

	if (task->tk_status == -ESTALE) {
458 459
		set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
		nfs_mark_for_revalidate(inode);
460 461 462 463
	}
	return 0;
}

464
static void nfs_readpage_retry(struct rpc_task *task, struct nfs_read_data *data)
465 466 467 468 469
{
	struct nfs_readargs *argp = &data->args;
	struct nfs_readres *resp = &data->res;

	/* This is a short read! */
470
	nfs_inc_stats(data->header->inode, NFSIOS_SHORTREAD);
471
	/* Has the server at least made some progress? */
472 473
	if (resp->count == 0) {
		nfs_set_pgio_error(data->header, -EIO, argp->offset);
474
		return;
475
	}
476
	/* Yes, so retry the read at the end of the data */
477
	data->mds_offset += resp->count;
478 479 480
	argp->offset += resp->count;
	argp->pgbase += resp->count;
	argp->count -= resp->count;
481
	rpc_restart_call_prepare(task);
482 483
}

484
static void nfs_readpage_result_common(struct rpc_task *task, void *calldata)
L
Linus Torvalds 已提交
485
{
T
Trond Myklebust 已提交
486
	struct nfs_read_data *data = calldata;
487 488 489
	struct nfs_pgio_header *hdr = data->header;

	/* Note the only returns of nfs_readpage_result are 0 and -EAGAIN */
T
Trond Myklebust 已提交
490 491
	if (nfs_readpage_result(task, data) != 0)
		return;
492
	if (task->tk_status < 0)
493 494 495 496 497 498 499 500 501 502 503 504 505 506
		nfs_set_pgio_error(hdr, task->tk_status, data->args.offset);
	else if (data->res.eof) {
		loff_t bound;

		bound = data->args.offset + data->res.count;
		spin_lock(&hdr->lock);
		if (bound < hdr->io_start + hdr->good_bytes) {
			set_bit(NFS_IOHDR_EOF, &hdr->flags);
			clear_bit(NFS_IOHDR_ERROR, &hdr->flags);
			hdr->good_bytes = bound - hdr->io_start;
		}
		spin_unlock(&hdr->lock);
	} else if (data->res.count != data->args.count)
		nfs_readpage_retry(task, data);
507 508
}

509
static void nfs_readpage_release_common(void *calldata)
510
{
511
	nfs_readdata_release(calldata);
L
Linus Torvalds 已提交
512 513
}

514 515 516
void nfs_read_prepare(struct rpc_task *task, void *calldata)
{
	struct nfs_read_data *data = calldata;
517
	NFS_PROTO(data->header->inode)->read_rpc_prepare(task, data);
518 519
}

520
static const struct rpc_call_ops nfs_read_common_ops = {
521
	.rpc_call_prepare = nfs_read_prepare,
522 523
	.rpc_call_done = nfs_readpage_result_common,
	.rpc_release = nfs_readpage_release_common,
T
Trond Myklebust 已提交
524 525
};

L
Linus Torvalds 已提交
526 527 528 529 530 531 532 533 534 535 536 537 538 539
/*
 * Read a page over NFS.
 * We read the page synchronously in the following case:
 *  -	The error flag is set for this page. This happens only when a
 *	previous async read operation failed.
 */
int nfs_readpage(struct file *file, struct page *page)
{
	struct nfs_open_context *ctx;
	struct inode *inode = page->mapping->host;
	int		error;

	dprintk("NFS: nfs_readpage (%p %ld@%lu)\n",
		page, PAGE_CACHE_SIZE, page->index);
C
Chuck Lever 已提交
540 541 542
	nfs_inc_stats(inode, NFSIOS_VFSREADPAGE);
	nfs_add_stats(inode, NFSIOS_READPAGES, 1);

L
Linus Torvalds 已提交
543 544 545 546 547 548 549 550 551
	/*
	 * Try to flush any pending writes to the file..
	 *
	 * NOTE! Because we own the page lock, there cannot
	 * be any new pending writes generated at this point
	 * for this page (other pages can be written to).
	 */
	error = nfs_wb_page(inode, page);
	if (error)
552 553 554
		goto out_unlock;
	if (PageUptodate(page))
		goto out_unlock;
L
Linus Torvalds 已提交
555

556 557
	error = -ESTALE;
	if (NFS_STALE(inode))
558
		goto out_unlock;
559

L
Linus Torvalds 已提交
560
	if (file == NULL) {
561
		error = -EBADF;
562
		ctx = nfs_find_open_context(inode, NULL, FMODE_READ);
L
Linus Torvalds 已提交
563
		if (ctx == NULL)
564
			goto out_unlock;
L
Linus Torvalds 已提交
565
	} else
566
		ctx = get_nfs_open_context(nfs_file_open_context(file));
L
Linus Torvalds 已提交
567

568 569 570 571 572 573
	if (!IS_SYNC(inode)) {
		error = nfs_readpage_from_fscache(ctx, inode, page);
		if (error == 0)
			goto out;
	}

574 575
	error = nfs_readpage_async(ctx, inode, page);

576
out:
L
Linus Torvalds 已提交
577 578
	put_nfs_open_context(ctx);
	return error;
579
out_unlock:
L
Linus Torvalds 已提交
580 581 582 583 584
	unlock_page(page);
	return error;
}

struct nfs_readdesc {
585
	struct nfs_pageio_descriptor *pgio;
L
Linus Torvalds 已提交
586 587 588 589 590 591 592 593 594 595
	struct nfs_open_context *ctx;
};

static int
readpage_async_filler(void *data, struct page *page)
{
	struct nfs_readdesc *desc = (struct nfs_readdesc *)data;
	struct inode *inode = page->mapping->host;
	struct nfs_page *new;
	unsigned int len;
596 597
	int error;

598
	len = nfs_page_length(page);
L
Linus Torvalds 已提交
599 600
	if (len == 0)
		return nfs_return_empty_page(page);
601

L
Linus Torvalds 已提交
602
	new = nfs_create_request(desc->ctx, inode, page, 0, len);
603 604 605
	if (IS_ERR(new))
		goto out_error;

L
Linus Torvalds 已提交
606
	if (len < PAGE_CACHE_SIZE)
607
		zero_user_segment(page, len, PAGE_CACHE_SIZE);
608 609 610 611
	if (!nfs_pageio_add_request(desc->pgio, new)) {
		error = desc->pgio->pg_error;
		goto out_unlock;
	}
L
Linus Torvalds 已提交
612
	return 0;
613 614 615 616 617
out_error:
	error = PTR_ERR(new);
out_unlock:
	unlock_page(page);
	return error;
L
Linus Torvalds 已提交
618 619 620 621 622
}

int nfs_readpages(struct file *filp, struct address_space *mapping,
		struct list_head *pages, unsigned nr_pages)
{
623
	struct nfs_pageio_descriptor pgio;
L
Linus Torvalds 已提交
624
	struct nfs_readdesc desc = {
625
		.pgio = &pgio,
L
Linus Torvalds 已提交
626 627
	};
	struct inode *inode = mapping->host;
628
	unsigned long npages;
629
	int ret = -ESTALE;
L
Linus Torvalds 已提交
630 631 632 633 634

	dprintk("NFS: nfs_readpages (%s/%Ld %d)\n",
			inode->i_sb->s_id,
			(long long)NFS_FILEID(inode),
			nr_pages);
C
Chuck Lever 已提交
635
	nfs_inc_stats(inode, NFSIOS_VFSREADPAGES);
L
Linus Torvalds 已提交
636

637 638 639
	if (NFS_STALE(inode))
		goto out;

L
Linus Torvalds 已提交
640
	if (filp == NULL) {
641
		desc.ctx = nfs_find_open_context(inode, NULL, FMODE_READ);
L
Linus Torvalds 已提交
642 643 644
		if (desc.ctx == NULL)
			return -EBADF;
	} else
645
		desc.ctx = get_nfs_open_context(nfs_file_open_context(filp));
646 647 648 649 650 651 652 653 654

	/* attempt to read as many of the pages as possible from the cache
	 * - this returns -ENOBUFS immediately if the cookie is negative
	 */
	ret = nfs_readpages_from_fscache(desc.ctx, inode, mapping,
					 pages, &nr_pages);
	if (ret == 0)
		goto read_complete; /* all pages were read */

655
	nfs_pageio_init_read(&pgio, inode);
656

L
Linus Torvalds 已提交
657
	ret = read_cache_pages(mapping, pages, readpage_async_filler, &desc);
658 659 660 661

	nfs_pageio_complete(&pgio);
	npages = (pgio.pg_bytes_written + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
	nfs_add_stats(inode, NFSIOS_READPAGES, npages);
662
read_complete:
L
Linus Torvalds 已提交
663
	put_nfs_open_context(desc.ctx);
664
out:
L
Linus Torvalds 已提交
665 666 667
	return ret;
}

D
David Howells 已提交
668
int __init nfs_init_readpagecache(void)
L
Linus Torvalds 已提交
669 670
{
	nfs_rdata_cachep = kmem_cache_create("nfs_read_data",
671
					     sizeof(struct nfs_read_header),
L
Linus Torvalds 已提交
672
					     0, SLAB_HWCACHE_ALIGN,
673
					     NULL);
L
Linus Torvalds 已提交
674 675 676 677 678 679
	if (nfs_rdata_cachep == NULL)
		return -ENOMEM;

	return 0;
}

680
void nfs_destroy_readpagecache(void)
L
Linus Torvalds 已提交
681
{
682
	kmem_cache_destroy(nfs_rdata_cachep);
L
Linus Torvalds 已提交
683
}