read.c 17.9 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 <asm/system.h>
24
#include "pnfs.h"
L
Linus Torvalds 已提交
25

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

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

F
Fred Isaman 已提交
33 34
static int nfs_pagein_multi(struct nfs_pageio_descriptor *desc);
static int nfs_pagein_one(struct nfs_pageio_descriptor *desc);
35
static const struct nfs_pageio_ops nfs_pageio_read_ops;
T
Trond Myklebust 已提交
36 37
static const struct rpc_call_ops nfs_read_partial_ops;
static const struct rpc_call_ops nfs_read_full_ops;
L
Linus Torvalds 已提交
38

39
static struct kmem_cache *nfs_rdata_cachep;
40
static mempool_t *nfs_rdata_mempool;
L
Linus Torvalds 已提交
41 42 43

#define MIN_POOL_READ	(32)

44
struct nfs_read_data *nfs_readdata_alloc(unsigned int pagecount)
45
{
46
	struct nfs_read_data *p = mempool_alloc(nfs_rdata_mempool, GFP_KERNEL);
47 48 49 50

	if (p) {
		memset(p, 0, sizeof(*p));
		INIT_LIST_HEAD(&p->pages);
51
		p->npages = pagecount;
52 53
		if (pagecount <= ARRAY_SIZE(p->page_array))
			p->pagevec = p->page_array;
54
		else {
55
			p->pagevec = kcalloc(pagecount, sizeof(struct page *), GFP_KERNEL);
56
			if (!p->pagevec) {
57 58 59 60 61 62 63 64
				mempool_free(p, nfs_rdata_mempool);
				p = NULL;
			}
		}
	}
	return p;
}

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

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

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

88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
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;
104 105
	for (;;) {
		if (remainder <= pglen) {
106
			zero_user(*pages, base, remainder);
107 108
			break;
		}
109
		zero_user(*pages, base, pglen);
110 111 112 113 114
		pages++;
		remainder -= pglen;
		pglen = PAGE_CACHE_SIZE;
		base = 0;
	}
115 116
}

117
void nfs_pageio_init_read_mds(struct nfs_pageio_descriptor *pgio,
118 119 120 121 122
		struct inode *inode)
{
	nfs_pageio_init(pgio, inode, &nfs_pageio_read_ops,
			NFS_SERVER(inode)->rsize, 0);
}
123
EXPORT_SYMBOL_GPL(nfs_pageio_init_read_mds);
124 125 126 127 128 129 130 131

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);
}

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

139
	len = nfs_page_length(page);
L
Linus Torvalds 已提交
140 141 142 143 144 145 146 147
	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)
148
		zero_user_segment(page, len, PAGE_CACHE_SIZE);
L
Linus Torvalds 已提交
149

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

static void nfs_readpage_release(struct nfs_page *req)
{
158 159 160 161 162
	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 已提交
163 164 165
	unlock_page(req->wb_page);

	dprintk("NFS: read done (%s/%Ld %d@%Ld)\n",
166 167
			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 已提交
168 169
			req->wb_bytes,
			(long long)req_offset(req));
170
	nfs_release_request(req);
L
Linus Torvalds 已提交
171 172
}

A
Andy Adamson 已提交
173
int nfs_initiate_read(struct nfs_read_data *data, struct rpc_clnt *clnt,
A
Andy Adamson 已提交
174
		      const struct rpc_call_ops *call_ops)
L
Linus Torvalds 已提交
175
{
A
Andy Adamson 已提交
176
	struct inode *inode = data->inode;
177
	int swap_flags = IS_SWAPFILE(inode) ? NFS_RPC_SWAPFLAGS : 0;
178
	struct rpc_task *task;
179 180 181
	struct rpc_message msg = {
		.rpc_argp = &data->args,
		.rpc_resp = &data->res,
A
Andy Adamson 已提交
182
		.rpc_cred = data->cred,
183
	};
184
	struct rpc_task_setup task_setup_data = {
185
		.task = &data->task,
A
Andy Adamson 已提交
186
		.rpc_client = clnt,
187
		.rpc_message = &msg,
188 189
		.callback_ops = call_ops,
		.callback_data = data,
190
		.workqueue = nfsiod_workqueue,
191 192
		.flags = RPC_TASK_ASYNC | swap_flags,
	};
L
Linus Torvalds 已提交
193

A
Andy Adamson 已提交
194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
	/* 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 已提交
211
EXPORT_SYMBOL_GPL(nfs_initiate_read);
A
Andy Adamson 已提交
212 213 214 215

/*
 * Set up the NFS read request struct
 */
216 217
static void nfs_read_rpcsetup(struct nfs_page *req, struct nfs_read_data *data,
		unsigned int count, unsigned int offset)
A
Andy Adamson 已提交
218 219 220
{
	struct inode *inode = req->wb_context->path.dentry->d_inode;

L
Linus Torvalds 已提交
221
	data->req	  = req;
222
	data->inode	  = inode;
A
Andy Adamson 已提交
223
	data->cred	  = req->wb_context->cred;
L
Linus Torvalds 已提交
224 225 226 227 228 229

	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;
230
	data->args.context = get_nfs_open_context(req->wb_context);
231
	data->args.lock_context = req->wb_lock_context;
L
Linus Torvalds 已提交
232 233 234 235

	data->res.fattr   = &data->fattr;
	data->res.count   = count;
	data->res.eof     = 0;
236
	nfs_fattr_init(&data->fattr);
237
}
L
Linus Torvalds 已提交
238

239 240 241 242 243 244 245 246 247 248 249 250 251
static int nfs_do_read(struct nfs_read_data *data,
		const struct rpc_call_ops *call_ops,
		struct pnfs_layout_segment *lseg)
{
	struct inode *inode = data->args.context->path.dentry->d_inode;

	if (lseg) {
		data->lseg = get_lseg(lseg);
		if (pnfs_try_to_read_data(data, call_ops) == PNFS_ATTEMPTED)
			return 0;
		put_lseg(data->lseg);
		data->lseg = NULL;
	}
252

A
Andy Adamson 已提交
253
	return nfs_initiate_read(data, NFS_CLIENT(inode), call_ops);
L
Linus Torvalds 已提交
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
}

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.
 */
F
Fred Isaman 已提交
282
static int nfs_pagein_multi(struct nfs_pageio_descriptor *desc)
L
Linus Torvalds 已提交
283
{
F
Fred Isaman 已提交
284
	struct nfs_page *req = nfs_list_entry(desc->pg_list.next);
L
Linus Torvalds 已提交
285 286
	struct page *page = req->wb_page;
	struct nfs_read_data *data;
F
Fred Isaman 已提交
287
	size_t rsize = NFS_SERVER(desc->pg_inode)->rsize, nbytes;
288
	unsigned int offset;
L
Linus Torvalds 已提交
289
	int requests = 0;
290
	int ret = 0;
291
	struct pnfs_layout_segment *lseg = desc->pg_lseg;
L
Linus Torvalds 已提交
292 293 294 295
	LIST_HEAD(list);

	nfs_list_remove_request(req);

F
Fred Isaman 已提交
296
	nbytes = desc->pg_count;
297 298 299
	do {
		size_t len = min(nbytes,rsize);

300
		data = nfs_readdata_alloc(1);
L
Linus Torvalds 已提交
301 302
		if (!data)
			goto out_bad;
303
		list_add(&data->list, &list);
L
Linus Torvalds 已提交
304
		requests++;
305 306
		nbytes -= len;
	} while(nbytes != 0);
L
Linus Torvalds 已提交
307 308 309 310
	atomic_set(&req->wb_complete, requests);

	ClearPageError(page);
	offset = 0;
F
Fred Isaman 已提交
311
	nbytes = desc->pg_count;
L
Linus Torvalds 已提交
312
	do {
313 314
		int ret2;

315 316
		data = list_entry(list.next, struct nfs_read_data, list);
		list_del_init(&data->list);
L
Linus Torvalds 已提交
317 318 319

		data->pagevec[0] = page;

320 321
		if (nbytes < rsize)
			rsize = nbytes;
322 323
		nfs_read_rpcsetup(req, data, rsize, offset);
		ret2 = nfs_do_read(data, &nfs_read_partial_ops, lseg);
324 325
		if (ret == 0)
			ret = ret2;
326 327
		offset += rsize;
		nbytes -= rsize;
L
Linus Torvalds 已提交
328
	} while (nbytes != 0);
329
	put_lseg(lseg);
330
	desc->pg_lseg = NULL;
L
Linus Torvalds 已提交
331

332
	return ret;
L
Linus Torvalds 已提交
333 334 335

out_bad:
	while (!list_empty(&list)) {
336 337
		data = list_entry(list.next, struct nfs_read_data, list);
		list_del(&data->list);
L
Linus Torvalds 已提交
338 339 340 341
		nfs_readdata_free(data);
	}
	SetPageError(page);
	nfs_readpage_release(req);
342 343
	put_lseg(lseg);
	desc->pg_lseg = NULL;
L
Linus Torvalds 已提交
344 345 346
	return -ENOMEM;
}

F
Fred Isaman 已提交
347
static int nfs_pagein_one(struct nfs_pageio_descriptor *desc)
L
Linus Torvalds 已提交
348 349 350 351
{
	struct nfs_page		*req;
	struct page		**pages;
	struct nfs_read_data	*data;
F
Fred Isaman 已提交
352 353
	struct list_head *head = &desc->pg_list;
	struct pnfs_layout_segment *lseg = desc->pg_lseg;
354
	int ret = 0;
L
Linus Torvalds 已提交
355

F
Fred Isaman 已提交
356 357
	data = nfs_readdata_alloc(nfs_page_array_len(desc->pg_base,
						     desc->pg_count));
358 359
	if (!data) {
		nfs_async_read_error(head);
360
		ret = -ENOMEM;
361 362
		goto out;
	}
L
Linus Torvalds 已提交
363 364 365 366 367 368 369 370 371 372 373

	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);

374 375
	nfs_read_rpcsetup(req, data, desc->pg_count, 0);
	ret = nfs_do_read(data, &nfs_read_full_ops, lseg);
376 377
out:
	put_lseg(lseg);
378
	desc->pg_lseg = NULL;
379
	return ret;
L
Linus Torvalds 已提交
380 381
}

382 383 384 385 386 387 388 389 390 391 392 393 394 395
int nfs_generic_pg_readpages(struct nfs_pageio_descriptor *desc)
{
	if (desc->pg_bsize < PAGE_CACHE_SIZE)
		return nfs_pagein_multi(desc);
	return nfs_pagein_one(desc);
}
EXPORT_SYMBOL_GPL(nfs_generic_pg_readpages);


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

396 397 398 399 400 401 402 403
/*
 * 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;

404
	dprintk("NFS: %s: %5u, (status %d)\n", __func__, task->tk_pid,
405 406 407 408 409 410 411 412 413
			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 已提交
414
		set_bit(NFS_INO_STALE, &NFS_I(data->inode)->flags);
415 416 417 418 419
		nfs_mark_for_revalidate(data->inode);
	}
	return 0;
}

420
static void nfs_readpage_retry(struct rpc_task *task, struct nfs_read_data *data)
421 422 423 424 425
{
	struct nfs_readargs *argp = &data->args;
	struct nfs_readres *resp = &data->res;

	if (resp->eof || resp->count == argp->count)
426
		return;
427 428 429 430 431

	/* This is a short read! */
	nfs_inc_stats(data->inode, NFSIOS_SHORTREAD);
	/* Has the server at least made some progress? */
	if (resp->count == 0)
432
		return;
433 434

	/* Yes, so retry the read at the end of the data */
435
	data->mds_offset += resp->count;
436 437 438
	argp->offset += resp->count;
	argp->pgbase += resp->count;
	argp->count -= resp->count;
439
	nfs_restart_rpc(task, NFS_SERVER(data->inode)->nfs_client);
440 441
}

L
Linus Torvalds 已提交
442 443 444
/*
 * Handle a read reply that fills part of a page.
 */
T
Trond Myklebust 已提交
445
static void nfs_readpage_result_partial(struct rpc_task *task, void *calldata)
L
Linus Torvalds 已提交
446
{
T
Trond Myklebust 已提交
447
	struct nfs_read_data *data = calldata;
L
Linus Torvalds 已提交
448
 
T
Trond Myklebust 已提交
449 450
	if (nfs_readpage_result(task, data) != 0)
		return;
451 452
	if (task->tk_status < 0)
		return;
453

454 455 456 457 458 459 460 461 462 463 464 465
	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)
466
		SetPageError(page);
467

L
Linus Torvalds 已提交
468 469 470 471 472
	if (atomic_dec_and_test(&req->wb_complete)) {
		if (!PageError(page))
			SetPageUptodate(page);
		nfs_readpage_release(req);
	}
473
	nfs_readdata_release(calldata);
L
Linus Torvalds 已提交
474 475
}

476 477 478 479 480
#if defined(CONFIG_NFS_V4_1)
void nfs_read_prepare(struct rpc_task *task, void *calldata)
{
	struct nfs_read_data *data = calldata;

481
	if (nfs4_setup_sequence(NFS_SERVER(data->inode),
482 483 484 485 486 487 488
				&data->args.seq_args, &data->res.seq_res,
				0, task))
		return;
	rpc_call_start(task);
}
#endif /* CONFIG_NFS_V4_1 */

T
Trond Myklebust 已提交
489
static const struct rpc_call_ops nfs_read_partial_ops = {
490 491 492
#if defined(CONFIG_NFS_V4_1)
	.rpc_call_prepare = nfs_read_prepare,
#endif /* CONFIG_NFS_V4_1 */
T
Trond Myklebust 已提交
493
	.rpc_call_done = nfs_readpage_result_partial,
494
	.rpc_release = nfs_readpage_release_partial,
T
Trond Myklebust 已提交
495 496
};

497 498 499 500 501 502
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;

503 504
	if (data->res.eof)
		count = data->args.count;
505 506 507 508 509 510 511
	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);
512 513 514 515
	if (count == 0)
		return;
	/* Was this a short read? */
	if (data->res.eof || data->res.count == data->args.count)
516 517 518
		SetPageUptodate(*pages);
}

L
Linus Torvalds 已提交
519 520 521 522
/*
 * This is the callback from RPC telling us whether a reply was
 * received or some error occurred (timeout or socket shutdown).
 */
T
Trond Myklebust 已提交
523
static void nfs_readpage_result_full(struct rpc_task *task, void *calldata)
L
Linus Torvalds 已提交
524
{
T
Trond Myklebust 已提交
525
	struct nfs_read_data *data = calldata;
L
Linus Torvalds 已提交
526

527 528
	if (nfs_readpage_result(task, data) != 0)
		return;
529 530
	if (task->tk_status < 0)
		return;
531
	/*
532
	 * Note: nfs_readpage_retry may change the values of
533
	 * data->args. In the multi-page case, we therefore need
534 535
	 * to ensure that we call nfs_readpage_set_pages_uptodate()
	 * first.
536
	 */
537 538 539 540 541 542 543 544 545
	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 已提交
546 547 548
	while (!list_empty(&data->pages)) {
		struct nfs_page *req = nfs_list_entry(data->pages.next);

549
		nfs_list_remove_request(req);
L
Linus Torvalds 已提交
550 551
		nfs_readpage_release(req);
	}
552
	nfs_readdata_release(calldata);
L
Linus Torvalds 已提交
553 554
}

T
Trond Myklebust 已提交
555
static const struct rpc_call_ops nfs_read_full_ops = {
556 557 558
#if defined(CONFIG_NFS_V4_1)
	.rpc_call_prepare = nfs_read_prepare,
#endif /* CONFIG_NFS_V4_1 */
T
Trond Myklebust 已提交
559
	.rpc_call_done = nfs_readpage_result_full,
560
	.rpc_release = nfs_readpage_release_full,
T
Trond Myklebust 已提交
561 562
};

L
Linus Torvalds 已提交
563 564 565 566 567 568 569 570 571 572 573 574 575 576
/*
 * 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 已提交
577 578 579
	nfs_inc_stats(inode, NFSIOS_VFSREADPAGE);
	nfs_add_stats(inode, NFSIOS_READPAGES, 1);

L
Linus Torvalds 已提交
580 581 582 583 584 585 586 587 588
	/*
	 * 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)
589 590 591
		goto out_unlock;
	if (PageUptodate(page))
		goto out_unlock;
L
Linus Torvalds 已提交
592

593 594
	error = -ESTALE;
	if (NFS_STALE(inode))
595
		goto out_unlock;
596

L
Linus Torvalds 已提交
597
	if (file == NULL) {
598
		error = -EBADF;
599
		ctx = nfs_find_open_context(inode, NULL, FMODE_READ);
L
Linus Torvalds 已提交
600
		if (ctx == NULL)
601
			goto out_unlock;
L
Linus Torvalds 已提交
602
	} else
603
		ctx = get_nfs_open_context(nfs_file_open_context(file));
L
Linus Torvalds 已提交
604

605 606 607 608 609 610
	if (!IS_SYNC(inode)) {
		error = nfs_readpage_from_fscache(ctx, inode, page);
		if (error == 0)
			goto out;
	}

611 612
	error = nfs_readpage_async(ctx, inode, page);

613
out:
L
Linus Torvalds 已提交
614 615
	put_nfs_open_context(ctx);
	return error;
616
out_unlock:
L
Linus Torvalds 已提交
617 618 619 620 621
	unlock_page(page);
	return error;
}

struct nfs_readdesc {
622
	struct nfs_pageio_descriptor *pgio;
L
Linus Torvalds 已提交
623 624 625 626 627 628 629 630 631 632
	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;
633 634
	int error;

635
	len = nfs_page_length(page);
L
Linus Torvalds 已提交
636 637
	if (len == 0)
		return nfs_return_empty_page(page);
638

L
Linus Torvalds 已提交
639
	new = nfs_create_request(desc->ctx, inode, page, 0, len);
640 641 642
	if (IS_ERR(new))
		goto out_error;

L
Linus Torvalds 已提交
643
	if (len < PAGE_CACHE_SIZE)
644
		zero_user_segment(page, len, PAGE_CACHE_SIZE);
645 646 647 648
	if (!nfs_pageio_add_request(desc->pgio, new)) {
		error = desc->pgio->pg_error;
		goto out_unlock;
	}
L
Linus Torvalds 已提交
649
	return 0;
650 651 652 653 654 655
out_error:
	error = PTR_ERR(new);
	SetPageError(page);
out_unlock:
	unlock_page(page);
	return error;
L
Linus Torvalds 已提交
656 657 658 659 660
}

int nfs_readpages(struct file *filp, struct address_space *mapping,
		struct list_head *pages, unsigned nr_pages)
{
661
	struct nfs_pageio_descriptor pgio;
L
Linus Torvalds 已提交
662
	struct nfs_readdesc desc = {
663
		.pgio = &pgio,
L
Linus Torvalds 已提交
664 665
	};
	struct inode *inode = mapping->host;
666
	unsigned long npages;
667
	int ret = -ESTALE;
L
Linus Torvalds 已提交
668 669 670 671 672

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

675 676 677
	if (NFS_STALE(inode))
		goto out;

L
Linus Torvalds 已提交
678
	if (filp == NULL) {
679
		desc.ctx = nfs_find_open_context(inode, NULL, FMODE_READ);
L
Linus Torvalds 已提交
680 681 682
		if (desc.ctx == NULL)
			return -EBADF;
	} else
683
		desc.ctx = get_nfs_open_context(nfs_file_open_context(filp));
684 685 686 687 688 689 690 691 692

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

693
	nfs_pageio_init_read(&pgio, inode);
694

L
Linus Torvalds 已提交
695
	ret = read_cache_pages(mapping, pages, readpage_async_filler, &desc);
696 697 698 699

	nfs_pageio_complete(&pgio);
	npages = (pgio.pg_bytes_written + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
	nfs_add_stats(inode, NFSIOS_READPAGES, npages);
700
read_complete:
L
Linus Torvalds 已提交
701
	put_nfs_open_context(desc.ctx);
702
out:
L
Linus Torvalds 已提交
703 704 705
	return ret;
}

D
David Howells 已提交
706
int __init nfs_init_readpagecache(void)
L
Linus Torvalds 已提交
707 708 709 710
{
	nfs_rdata_cachep = kmem_cache_create("nfs_read_data",
					     sizeof(struct nfs_read_data),
					     0, SLAB_HWCACHE_ALIGN,
711
					     NULL);
L
Linus Torvalds 已提交
712 713 714
	if (nfs_rdata_cachep == NULL)
		return -ENOMEM;

715 716
	nfs_rdata_mempool = mempool_create_slab_pool(MIN_POOL_READ,
						     nfs_rdata_cachep);
L
Linus Torvalds 已提交
717 718 719 720 721 722
	if (nfs_rdata_mempool == NULL)
		return -ENOMEM;

	return 0;
}

723
void nfs_destroy_readpagecache(void)
L
Linus Torvalds 已提交
724 725
{
	mempool_destroy(nfs_rdata_mempool);
726
	kmem_cache_destroy(nfs_rdata_cachep);
L
Linus Torvalds 已提交
727
}