read.c 16.6 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 21 22 23
/*
 * 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>

#include <asm/system.h>

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

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

31 32
static int nfs_pagein_multi(struct inode *, struct list_head *, unsigned int, size_t, int);
static int nfs_pagein_one(struct inode *, struct list_head *, unsigned int, size_t, int);
T
Trond Myklebust 已提交
33 34
static const struct rpc_call_ops nfs_read_partial_ops;
static const struct rpc_call_ops nfs_read_full_ops;
L
Linus Torvalds 已提交
35

36
static struct kmem_cache *nfs_rdata_cachep;
37
static mempool_t *nfs_rdata_mempool;
L
Linus Torvalds 已提交
38 39 40

#define MIN_POOL_READ	(32)

41
struct nfs_read_data *nfs_readdata_alloc(unsigned int pagecount)
42
{
C
Christoph Lameter 已提交
43
	struct nfs_read_data *p = mempool_alloc(nfs_rdata_mempool, GFP_NOFS);
44 45 46 47

	if (p) {
		memset(p, 0, sizeof(*p));
		INIT_LIST_HEAD(&p->pages);
48
		p->npages = pagecount;
A
Andy Adamson 已提交
49
		p->res.seq_res.sr_slotid = NFS4_MAX_SLOT_TABLE;
50 51
		if (pagecount <= ARRAY_SIZE(p->page_array))
			p->pagevec = p->page_array;
52
		else {
53 54
			p->pagevec = kcalloc(pagecount, sizeof(struct page *), GFP_NOFS);
			if (!p->pagevec) {
55 56 57 58 59 60 61 62
				mempool_free(p, nfs_rdata_mempool);
				p = NULL;
			}
		}
	}
	return p;
}

T
Trond Myklebust 已提交
63
void nfs_readdata_free(struct nfs_read_data *p)
64 65 66 67 68 69
{
	if (p && (p->pagevec != &p->page_array[0]))
		kfree(p->pagevec);
	mempool_free(p, nfs_rdata_mempool);
}

T
Trond Myklebust 已提交
70
static void nfs_readdata_release(struct nfs_read_data *rdata)
L
Linus Torvalds 已提交
71
{
72 73
	put_nfs_open_context(rdata->args.context);
	nfs_readdata_free(rdata);
L
Linus Torvalds 已提交
74 75 76 77 78
}

static
int nfs_return_empty_page(struct page *page)
{
79
	zero_user(page, 0, PAGE_CACHE_SIZE);
L
Linus Torvalds 已提交
80 81 82 83 84
	SetPageUptodate(page);
	unlock_page(page);
	return 0;
}

85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
static void nfs_readpage_truncate_uninitialised_page(struct nfs_read_data *data)
{
	unsigned int remainder = data->args.count - data->res.count;
	unsigned int base = data->args.pgbase + data->res.count;
	unsigned int pglen;
	struct page **pages;

	if (data->res.eof == 0 || remainder == 0)
		return;
	/*
	 * Note: "remainder" can never be negative, since we check for
	 * 	this in the XDR code.
	 */
	pages = &data->args.pages[base >> PAGE_CACHE_SHIFT];
	base &= ~PAGE_CACHE_MASK;
	pglen = PAGE_CACHE_SIZE - base;
101 102
	for (;;) {
		if (remainder <= pglen) {
103
			zero_user(*pages, base, remainder);
104 105
			break;
		}
106
		zero_user(*pages, base, pglen);
107 108 109 110 111
		pages++;
		remainder -= pglen;
		pglen = PAGE_CACHE_SIZE;
		base = 0;
	}
112 113
}

114 115
int nfs_readpage_async(struct nfs_open_context *ctx, struct inode *inode,
		       struct page *page)
L
Linus Torvalds 已提交
116 117 118 119 120
{
	LIST_HEAD(one_request);
	struct nfs_page	*new;
	unsigned int len;

121
	len = nfs_page_length(page);
L
Linus Torvalds 已提交
122 123 124 125 126 127 128 129
	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)
130
		zero_user_segment(page, len, PAGE_CACHE_SIZE);
L
Linus Torvalds 已提交
131 132

	nfs_list_add_request(new, &one_request);
133
	if (NFS_SERVER(inode)->rsize < PAGE_CACHE_SIZE)
134
		nfs_pagein_multi(inode, &one_request, 1, len, 0);
135
	else
136
		nfs_pagein_one(inode, &one_request, 1, len, 0);
L
Linus Torvalds 已提交
137 138 139 140 141
	return 0;
}

static void nfs_readpage_release(struct nfs_page *req)
{
142 143 144 145 146
	struct inode *d_inode = req->wb_context->path.dentry->d_inode;

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

L
Linus Torvalds 已提交
147 148 149
	unlock_page(req->wb_page);

	dprintk("NFS: read done (%s/%Ld %d@%Ld)\n",
150 151
			req->wb_context->path.dentry->d_inode->i_sb->s_id,
			(long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
L
Linus Torvalds 已提交
152 153
			req->wb_bytes,
			(long long)req_offset(req));
154 155
	nfs_clear_request(req);
	nfs_release_request(req);
L
Linus Torvalds 已提交
156 157 158 159 160
}

/*
 * Set up the NFS read request struct
 */
161
static int nfs_read_rpcsetup(struct nfs_page *req, struct nfs_read_data *data,
T
Trond Myklebust 已提交
162
		const struct rpc_call_ops *call_ops,
L
Linus Torvalds 已提交
163 164
		unsigned int count, unsigned int offset)
{
165 166
	struct inode *inode = req->wb_context->path.dentry->d_inode;
	int swap_flags = IS_SWAPFILE(inode) ? NFS_RPC_SWAPFLAGS : 0;
167
	struct rpc_task *task;
168 169 170 171 172
	struct rpc_message msg = {
		.rpc_argp = &data->args,
		.rpc_resp = &data->res,
		.rpc_cred = req->wb_context->cred,
	};
173
	struct rpc_task_setup task_setup_data = {
174
		.task = &data->task,
175
		.rpc_client = NFS_CLIENT(inode),
176
		.rpc_message = &msg,
177 178
		.callback_ops = call_ops,
		.callback_data = data,
179
		.workqueue = nfsiod_workqueue,
180 181
		.flags = RPC_TASK_ASYNC | swap_flags,
	};
L
Linus Torvalds 已提交
182 183

	data->req	  = req;
184
	data->inode	  = inode;
185
	data->cred	  = msg.rpc_cred;
L
Linus Torvalds 已提交
186 187 188 189 190 191

	data->args.fh     = NFS_FH(inode);
	data->args.offset = req_offset(req) + offset;
	data->args.pgbase = req->wb_pgbase + offset;
	data->args.pages  = data->pagevec;
	data->args.count  = count;
192
	data->args.context = get_nfs_open_context(req->wb_context);
L
Linus Torvalds 已提交
193 194 195 196

	data->res.fattr   = &data->fattr;
	data->res.count   = count;
	data->res.eof     = 0;
197
	nfs_fattr_init(&data->fattr);
L
Linus Torvalds 已提交
198

T
Trond Myklebust 已提交
199
	/* Set up the initial task struct. */
200
	NFS_PROTO(inode)->read_setup(data, &msg);
L
Linus Torvalds 已提交
201

C
Chuck Lever 已提交
202
	dprintk("NFS: %5u initiated read call (req %s/%Ld, %u bytes @ offset %Lu)\n",
L
Linus Torvalds 已提交
203 204 205 206 207
			data->task.tk_pid,
			inode->i_sb->s_id,
			(long long)NFS_FILEID(inode),
			count,
			(unsigned long long)data->args.offset);
208

209
	task = rpc_run_task(&task_setup_data);
210 211 212 213
	if (IS_ERR(task))
		return PTR_ERR(task);
	rpc_put_task(task);
	return 0;
L
Linus Torvalds 已提交
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241
}

static void
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);
		SetPageError(req->wb_page);
		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.
 */
242
static int nfs_pagein_multi(struct inode *inode, struct list_head *head, unsigned int npages, size_t count, int flags)
L
Linus Torvalds 已提交
243 244 245 246
{
	struct nfs_page *req = nfs_list_entry(head->next);
	struct page *page = req->wb_page;
	struct nfs_read_data *data;
247 248
	size_t rsize = NFS_SERVER(inode)->rsize, nbytes;
	unsigned int offset;
L
Linus Torvalds 已提交
249
	int requests = 0;
250
	int ret = 0;
L
Linus Torvalds 已提交
251 252 253 254
	LIST_HEAD(list);

	nfs_list_remove_request(req);

255
	nbytes = count;
256 257 258
	do {
		size_t len = min(nbytes,rsize);

259
		data = nfs_readdata_alloc(1);
L
Linus Torvalds 已提交
260 261 262 263
		if (!data)
			goto out_bad;
		list_add(&data->pages, &list);
		requests++;
264 265
		nbytes -= len;
	} while(nbytes != 0);
L
Linus Torvalds 已提交
266 267 268 269
	atomic_set(&req->wb_complete, requests);

	ClearPageError(page);
	offset = 0;
270
	nbytes = count;
L
Linus Torvalds 已提交
271
	do {
272 273
		int ret2;

L
Linus Torvalds 已提交
274 275 276 277 278
		data = list_entry(list.next, struct nfs_read_data, pages);
		list_del_init(&data->pages);

		data->pagevec[0] = page;

279 280
		if (nbytes < rsize)
			rsize = nbytes;
281
		ret2 = nfs_read_rpcsetup(req, data, &nfs_read_partial_ops,
282
				  rsize, offset);
283 284
		if (ret == 0)
			ret = ret2;
285 286
		offset += rsize;
		nbytes -= rsize;
L
Linus Torvalds 已提交
287 288
	} while (nbytes != 0);

289
	return ret;
L
Linus Torvalds 已提交
290 291 292 293 294 295 296 297 298 299 300 301

out_bad:
	while (!list_empty(&list)) {
		data = list_entry(list.next, struct nfs_read_data, pages);
		list_del(&data->pages);
		nfs_readdata_free(data);
	}
	SetPageError(page);
	nfs_readpage_release(req);
	return -ENOMEM;
}

302
static int nfs_pagein_one(struct inode *inode, struct list_head *head, unsigned int npages, size_t count, int flags)
L
Linus Torvalds 已提交
303 304 305 306
{
	struct nfs_page		*req;
	struct page		**pages;
	struct nfs_read_data	*data;
307
	int ret = -ENOMEM;
L
Linus Torvalds 已提交
308

309
	data = nfs_readdata_alloc(npages);
L
Linus Torvalds 已提交
310 311 312 313 314 315 316 317 318 319 320 321 322
	if (!data)
		goto out_bad;

	pages = data->pagevec;
	while (!list_empty(head)) {
		req = nfs_list_entry(head->next);
		nfs_list_remove_request(req);
		nfs_list_add_request(req, &data->pages);
		ClearPageError(req->wb_page);
		*pages++ = req->wb_page;
	}
	req = nfs_list_entry(data->pages.next);

323
	return nfs_read_rpcsetup(req, data, &nfs_read_full_ops, count, 0);
L
Linus Torvalds 已提交
324 325
out_bad:
	nfs_async_read_error(head);
326
	return ret;
L
Linus Torvalds 已提交
327 328
}

329 330 331 332 333 334 335 336
/*
 * 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)
{
	int status;

337
	dprintk("NFS: %s: %5u, (status %d)\n", __func__, task->tk_pid,
338 339 340 341 342 343 344 345 346
			task->tk_status);

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

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

	if (task->tk_status == -ESTALE) {
B
Benny Halevy 已提交
347
		set_bit(NFS_INO_STALE, &NFS_I(data->inode)->flags);
348 349 350 351 352
		nfs_mark_for_revalidate(data->inode);
	}
	return 0;
}

353
static void nfs_readpage_retry(struct rpc_task *task, struct nfs_read_data *data)
354 355 356 357 358
{
	struct nfs_readargs *argp = &data->args;
	struct nfs_readres *resp = &data->res;

	if (resp->eof || resp->count == argp->count)
359
		goto out;
360 361 362 363 364

	/* This is a short read! */
	nfs_inc_stats(data->inode, NFSIOS_SHORTREAD);
	/* Has the server at least made some progress? */
	if (resp->count == 0)
365
		goto out;
366 367 368 369 370

	/* Yes, so retry the read at the end of the data */
	argp->offset += resp->count;
	argp->pgbase += resp->count;
	argp->count -= resp->count;
371 372
	nfs4_restart_rpc(task, NFS_SERVER(data->inode)->nfs_client,
			 &data->res.seq_res);
373 374 375 376 377 378
	return;
out:
	nfs4_sequence_free_slot(NFS_SERVER(data->inode)->nfs_client,
				&data->res.seq_res);
	return;

379 380
}

L
Linus Torvalds 已提交
381 382 383
/*
 * Handle a read reply that fills part of a page.
 */
T
Trond Myklebust 已提交
384
static void nfs_readpage_result_partial(struct rpc_task *task, void *calldata)
L
Linus Torvalds 已提交
385
{
T
Trond Myklebust 已提交
386
	struct nfs_read_data *data = calldata;
L
Linus Torvalds 已提交
387
 
T
Trond Myklebust 已提交
388 389
	if (nfs_readpage_result(task, data) != 0)
		return;
390 391
	if (task->tk_status < 0)
		return;
392

393 394 395 396 397 398 399 400 401 402 403 404
	nfs_readpage_truncate_uninitialised_page(data);
	nfs_readpage_retry(task, data);
}

static void nfs_readpage_release_partial(void *calldata)
{
	struct nfs_read_data *data = calldata;
	struct nfs_page *req = data->req;
	struct page *page = req->wb_page;
	int status = data->task.tk_status;

	if (status < 0)
405
		SetPageError(page);
406

L
Linus Torvalds 已提交
407 408 409 410 411
	if (atomic_dec_and_test(&req->wb_complete)) {
		if (!PageError(page))
			SetPageUptodate(page);
		nfs_readpage_release(req);
	}
412
	nfs_readdata_release(calldata);
L
Linus Torvalds 已提交
413 414
}

415 416 417 418 419 420 421 422 423 424 425 426 427
#if defined(CONFIG_NFS_V4_1)
void nfs_read_prepare(struct rpc_task *task, void *calldata)
{
	struct nfs_read_data *data = calldata;

	if (nfs4_setup_sequence(NFS_SERVER(data->inode)->nfs_client,
				&data->args.seq_args, &data->res.seq_res,
				0, task))
		return;
	rpc_call_start(task);
}
#endif /* CONFIG_NFS_V4_1 */

T
Trond Myklebust 已提交
428
static const struct rpc_call_ops nfs_read_partial_ops = {
429 430 431
#if defined(CONFIG_NFS_V4_1)
	.rpc_call_prepare = nfs_read_prepare,
#endif /* CONFIG_NFS_V4_1 */
T
Trond Myklebust 已提交
432
	.rpc_call_done = nfs_readpage_result_partial,
433
	.rpc_release = nfs_readpage_release_partial,
T
Trond Myklebust 已提交
434 435
};

436 437 438 439 440 441
static void nfs_readpage_set_pages_uptodate(struct nfs_read_data *data)
{
	unsigned int count = data->res.count;
	unsigned int base = data->args.pgbase;
	struct page **pages;

442 443
	if (data->res.eof)
		count = data->args.count;
444 445 446 447 448 449 450
	if (unlikely(count == 0))
		return;
	pages = &data->args.pages[base >> PAGE_CACHE_SHIFT];
	base &= ~PAGE_CACHE_MASK;
	count += base;
	for (;count >= PAGE_CACHE_SIZE; count -= PAGE_CACHE_SIZE, pages++)
		SetPageUptodate(*pages);
451 452 453 454
	if (count == 0)
		return;
	/* Was this a short read? */
	if (data->res.eof || data->res.count == data->args.count)
455 456 457
		SetPageUptodate(*pages);
}

L
Linus Torvalds 已提交
458 459 460 461
/*
 * This is the callback from RPC telling us whether a reply was
 * received or some error occurred (timeout or socket shutdown).
 */
T
Trond Myklebust 已提交
462
static void nfs_readpage_result_full(struct rpc_task *task, void *calldata)
L
Linus Torvalds 已提交
463
{
T
Trond Myklebust 已提交
464
	struct nfs_read_data *data = calldata;
L
Linus Torvalds 已提交
465

466 467
	if (nfs_readpage_result(task, data) != 0)
		return;
468 469
	if (task->tk_status < 0)
		return;
470
	/*
471
	 * Note: nfs_readpage_retry may change the values of
472
	 * data->args. In the multi-page case, we therefore need
473 474
	 * to ensure that we call nfs_readpage_set_pages_uptodate()
	 * first.
475
	 */
476 477 478 479 480 481 482 483 484
	nfs_readpage_truncate_uninitialised_page(data);
	nfs_readpage_set_pages_uptodate(data);
	nfs_readpage_retry(task, data);
}

static void nfs_readpage_release_full(void *calldata)
{
	struct nfs_read_data *data = calldata;

L
Linus Torvalds 已提交
485 486 487
	while (!list_empty(&data->pages)) {
		struct nfs_page *req = nfs_list_entry(data->pages.next);

488
		nfs_list_remove_request(req);
L
Linus Torvalds 已提交
489 490
		nfs_readpage_release(req);
	}
491
	nfs_readdata_release(calldata);
L
Linus Torvalds 已提交
492 493
}

T
Trond Myklebust 已提交
494
static const struct rpc_call_ops nfs_read_full_ops = {
495 496 497
#if defined(CONFIG_NFS_V4_1)
	.rpc_call_prepare = nfs_read_prepare,
#endif /* CONFIG_NFS_V4_1 */
T
Trond Myklebust 已提交
498
	.rpc_call_done = nfs_readpage_result_full,
499
	.rpc_release = nfs_readpage_release_full,
T
Trond Myklebust 已提交
500 501
};

L
Linus Torvalds 已提交
502 503 504 505 506 507 508 509 510 511 512 513 514 515
/*
 * 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 已提交
516 517 518
	nfs_inc_stats(inode, NFSIOS_VFSREADPAGE);
	nfs_add_stats(inode, NFSIOS_READPAGES, 1);

L
Linus Torvalds 已提交
519 520 521 522 523 524 525 526 527
	/*
	 * 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)
528 529 530
		goto out_unlock;
	if (PageUptodate(page))
		goto out_unlock;
L
Linus Torvalds 已提交
531

532 533
	error = -ESTALE;
	if (NFS_STALE(inode))
534
		goto out_unlock;
535

L
Linus Torvalds 已提交
536
	if (file == NULL) {
537
		error = -EBADF;
538
		ctx = nfs_find_open_context(inode, NULL, FMODE_READ);
L
Linus Torvalds 已提交
539
		if (ctx == NULL)
540
			goto out_unlock;
L
Linus Torvalds 已提交
541
	} else
542
		ctx = get_nfs_open_context(nfs_file_open_context(file));
L
Linus Torvalds 已提交
543

544 545 546 547 548 549
	if (!IS_SYNC(inode)) {
		error = nfs_readpage_from_fscache(ctx, inode, page);
		if (error == 0)
			goto out;
	}

550 551
	error = nfs_readpage_async(ctx, inode, page);

552
out:
L
Linus Torvalds 已提交
553 554
	put_nfs_open_context(ctx);
	return error;
555
out_unlock:
L
Linus Torvalds 已提交
556 557 558 559 560
	unlock_page(page);
	return error;
}

struct nfs_readdesc {
561
	struct nfs_pageio_descriptor *pgio;
L
Linus Torvalds 已提交
562 563 564 565 566 567 568 569 570 571
	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;
572 573
	int error;

574
	len = nfs_page_length(page);
L
Linus Torvalds 已提交
575 576
	if (len == 0)
		return nfs_return_empty_page(page);
577

L
Linus Torvalds 已提交
578
	new = nfs_create_request(desc->ctx, inode, page, 0, len);
579 580 581
	if (IS_ERR(new))
		goto out_error;

L
Linus Torvalds 已提交
582
	if (len < PAGE_CACHE_SIZE)
583
		zero_user_segment(page, len, PAGE_CACHE_SIZE);
584 585 586 587
	if (!nfs_pageio_add_request(desc->pgio, new)) {
		error = desc->pgio->pg_error;
		goto out_unlock;
	}
L
Linus Torvalds 已提交
588
	return 0;
589 590 591 592 593 594
out_error:
	error = PTR_ERR(new);
	SetPageError(page);
out_unlock:
	unlock_page(page);
	return error;
L
Linus Torvalds 已提交
595 596 597 598 599
}

int nfs_readpages(struct file *filp, struct address_space *mapping,
		struct list_head *pages, unsigned nr_pages)
{
600
	struct nfs_pageio_descriptor pgio;
L
Linus Torvalds 已提交
601
	struct nfs_readdesc desc = {
602
		.pgio = &pgio,
L
Linus Torvalds 已提交
603 604 605
	};
	struct inode *inode = mapping->host;
	struct nfs_server *server = NFS_SERVER(inode);
606 607
	size_t rsize = server->rsize;
	unsigned long npages;
608
	int ret = -ESTALE;
L
Linus Torvalds 已提交
609 610 611 612 613

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

616 617 618
	if (NFS_STALE(inode))
		goto out;

L
Linus Torvalds 已提交
619
	if (filp == NULL) {
620
		desc.ctx = nfs_find_open_context(inode, NULL, FMODE_READ);
L
Linus Torvalds 已提交
621 622 623
		if (desc.ctx == NULL)
			return -EBADF;
	} else
624
		desc.ctx = get_nfs_open_context(nfs_file_open_context(filp));
625 626 627 628 629 630 631 632 633

	/* 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 */

634 635 636 637 638
	if (rsize < PAGE_CACHE_SIZE)
		nfs_pageio_init(&pgio, inode, nfs_pagein_multi, rsize, 0);
	else
		nfs_pageio_init(&pgio, inode, nfs_pagein_one, rsize, 0);

L
Linus Torvalds 已提交
639
	ret = read_cache_pages(mapping, pages, readpage_async_filler, &desc);
640 641 642 643

	nfs_pageio_complete(&pgio);
	npages = (pgio.pg_bytes_written + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
	nfs_add_stats(inode, NFSIOS_READPAGES, npages);
644
read_complete:
L
Linus Torvalds 已提交
645
	put_nfs_open_context(desc.ctx);
646
out:
L
Linus Torvalds 已提交
647 648 649
	return ret;
}

D
David Howells 已提交
650
int __init nfs_init_readpagecache(void)
L
Linus Torvalds 已提交
651 652 653 654
{
	nfs_rdata_cachep = kmem_cache_create("nfs_read_data",
					     sizeof(struct nfs_read_data),
					     0, SLAB_HWCACHE_ALIGN,
655
					     NULL);
L
Linus Torvalds 已提交
656 657 658
	if (nfs_rdata_cachep == NULL)
		return -ENOMEM;

659 660
	nfs_rdata_mempool = mempool_create_slab_pool(MIN_POOL_READ,
						     nfs_rdata_cachep);
L
Linus Torvalds 已提交
661 662 663 664 665 666
	if (nfs_rdata_mempool == NULL)
		return -ENOMEM;

	return 0;
}

667
void nfs_destroy_readpagecache(void)
L
Linus Torvalds 已提交
668 669
{
	mempool_destroy(nfs_rdata_mempool);
670
	kmem_cache_destroy(nfs_rdata_cachep);
L
Linus Torvalds 已提交
671
}