read.c 15.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 21 22 23 24
/*
 * 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 <linux/smp_lock.h>

#include <asm/system.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;
49 50
		if (pagecount <= ARRAY_SIZE(p->page_array))
			p->pagevec = p->page_array;
51
		else {
52 53
			p->pagevec = kcalloc(pagecount, sizeof(struct page *), GFP_NOFS);
			if (!p->pagevec) {
54 55 56 57 58 59 60 61
				mempool_free(p, nfs_rdata_mempool);
				p = NULL;
			}
		}
	}
	return p;
}

62
static void nfs_readdata_free(struct nfs_read_data *p)
63 64 65 66 67 68
{
	if (p && (p->pagevec != &p->page_array[0]))
		kfree(p->pagevec);
	mempool_free(p, nfs_rdata_mempool);
}

69
void nfs_readdata_release(void *data)
L
Linus Torvalds 已提交
70
{
71 72 73 74
	struct nfs_read_data *rdata = data;

	put_nfs_open_context(rdata->args.context);
	nfs_readdata_free(rdata);
L
Linus Torvalds 已提交
75 76 77 78 79
}

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

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

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

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

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

static void nfs_readpage_release(struct nfs_page *req)
{
143 144 145 146 147
	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 已提交
148 149 150
	unlock_page(req->wb_page);

	dprintk("NFS: read done (%s/%Ld %d@%Ld)\n",
151 152
			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 已提交
153 154
			req->wb_bytes,
			(long long)req_offset(req));
155 156
	nfs_clear_request(req);
	nfs_release_request(req);
L
Linus Torvalds 已提交
157 158 159 160 161
}

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

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

	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;
193
	data->args.context = get_nfs_open_context(req->wb_context);
L
Linus Torvalds 已提交
194 195 196 197

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

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

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

210
	task = rpc_run_task(&task_setup_data);
211 212 213 214
	if (IS_ERR(task))
		return PTR_ERR(task);
	rpc_put_task(task);
	return 0;
L
Linus Torvalds 已提交
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 242
}

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

	nfs_list_remove_request(req);

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

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

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

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

		data->pagevec[0] = page;

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

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

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

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

310
	data = nfs_readdata_alloc(npages);
L
Linus Torvalds 已提交
311 312 313 314 315 316 317 318 319 320 321 322 323
	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);

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

330 331 332 333 334 335 336 337
/*
 * 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;

338
	dprintk("NFS: %s: %5u, (status %d)\n", __func__, task->tk_pid,
339 340 341 342 343 344 345 346 347
			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 已提交
348
		set_bit(NFS_INO_STALE, &NFS_I(data->inode)->flags);
349 350 351 352 353
		nfs_mark_for_revalidate(data->inode);
	}
	return 0;
}

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

	if (resp->eof || resp->count == argp->count)
360
		return;
361 362 363 364 365

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

	/* Yes, so retry the read at the end of the data */
	argp->offset += resp->count;
	argp->pgbase += resp->count;
	argp->count -= resp->count;
	rpc_restart_call(task);
}

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

387 388 389 390 391 392 393 394 395 396 397 398
	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)
399
		SetPageError(page);
400

L
Linus Torvalds 已提交
401 402 403 404 405
	if (atomic_dec_and_test(&req->wb_complete)) {
		if (!PageError(page))
			SetPageUptodate(page);
		nfs_readpage_release(req);
	}
406
	nfs_readdata_release(calldata);
L
Linus Torvalds 已提交
407 408
}

T
Trond Myklebust 已提交
409 410
static const struct rpc_call_ops nfs_read_partial_ops = {
	.rpc_call_done = nfs_readpage_result_partial,
411
	.rpc_release = nfs_readpage_release_partial,
T
Trond Myklebust 已提交
412 413
};

414 415 416 417 418 419
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;

420 421
	if (data->res.eof)
		count = data->args.count;
422 423 424 425 426 427 428
	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);
429 430 431 432
	if (count == 0)
		return;
	/* Was this a short read? */
	if (data->res.eof || data->res.count == data->args.count)
433 434 435
		SetPageUptodate(*pages);
}

L
Linus Torvalds 已提交
436 437 438 439
/*
 * This is the callback from RPC telling us whether a reply was
 * received or some error occurred (timeout or socket shutdown).
 */
T
Trond Myklebust 已提交
440
static void nfs_readpage_result_full(struct rpc_task *task, void *calldata)
L
Linus Torvalds 已提交
441
{
T
Trond Myklebust 已提交
442
	struct nfs_read_data *data = calldata;
L
Linus Torvalds 已提交
443

444 445
	if (nfs_readpage_result(task, data) != 0)
		return;
446 447
	if (task->tk_status < 0)
		return;
448
	/*
449
	 * Note: nfs_readpage_retry may change the values of
450
	 * data->args. In the multi-page case, we therefore need
451 452
	 * to ensure that we call nfs_readpage_set_pages_uptodate()
	 * first.
453
	 */
454 455 456 457 458 459 460 461 462
	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 已提交
463 464 465
	while (!list_empty(&data->pages)) {
		struct nfs_page *req = nfs_list_entry(data->pages.next);

466
		nfs_list_remove_request(req);
L
Linus Torvalds 已提交
467 468
		nfs_readpage_release(req);
	}
469
	nfs_readdata_release(calldata);
L
Linus Torvalds 已提交
470 471
}

T
Trond Myklebust 已提交
472 473
static const struct rpc_call_ops nfs_read_full_ops = {
	.rpc_call_done = nfs_readpage_result_full,
474
	.rpc_release = nfs_readpage_release_full,
T
Trond Myklebust 已提交
475 476
};

L
Linus Torvalds 已提交
477 478 479 480 481 482 483 484 485 486 487 488 489 490
/*
 * 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 已提交
491 492 493
	nfs_inc_stats(inode, NFSIOS_VFSREADPAGE);
	nfs_add_stats(inode, NFSIOS_READPAGES, 1);

L
Linus Torvalds 已提交
494 495 496 497 498 499 500 501 502
	/*
	 * 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)
503 504 505
		goto out_unlock;
	if (PageUptodate(page))
		goto out_unlock;
L
Linus Torvalds 已提交
506

507 508
	error = -ESTALE;
	if (NFS_STALE(inode))
509
		goto out_unlock;
510

L
Linus Torvalds 已提交
511
	if (file == NULL) {
512
		error = -EBADF;
513
		ctx = nfs_find_open_context(inode, NULL, FMODE_READ);
L
Linus Torvalds 已提交
514
		if (ctx == NULL)
515
			goto out_unlock;
L
Linus Torvalds 已提交
516
	} else
517
		ctx = get_nfs_open_context(nfs_file_open_context(file));
L
Linus Torvalds 已提交
518

519 520 521 522 523 524
	if (!IS_SYNC(inode)) {
		error = nfs_readpage_from_fscache(ctx, inode, page);
		if (error == 0)
			goto out;
	}

525 526
	error = nfs_readpage_async(ctx, inode, page);

527
out:
L
Linus Torvalds 已提交
528 529
	put_nfs_open_context(ctx);
	return error;
530
out_unlock:
L
Linus Torvalds 已提交
531 532 533 534 535
	unlock_page(page);
	return error;
}

struct nfs_readdesc {
536
	struct nfs_pageio_descriptor *pgio;
L
Linus Torvalds 已提交
537 538 539 540 541 542 543 544 545 546
	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;
547 548
	int error;

549
	len = nfs_page_length(page);
L
Linus Torvalds 已提交
550 551
	if (len == 0)
		return nfs_return_empty_page(page);
552

L
Linus Torvalds 已提交
553
	new = nfs_create_request(desc->ctx, inode, page, 0, len);
554 555 556
	if (IS_ERR(new))
		goto out_error;

L
Linus Torvalds 已提交
557
	if (len < PAGE_CACHE_SIZE)
558
		zero_user_segment(page, len, PAGE_CACHE_SIZE);
559 560 561 562
	if (!nfs_pageio_add_request(desc->pgio, new)) {
		error = desc->pgio->pg_error;
		goto out_unlock;
	}
L
Linus Torvalds 已提交
563
	return 0;
564 565 566 567 568 569
out_error:
	error = PTR_ERR(new);
	SetPageError(page);
out_unlock:
	unlock_page(page);
	return error;
L
Linus Torvalds 已提交
570 571 572 573 574
}

int nfs_readpages(struct file *filp, struct address_space *mapping,
		struct list_head *pages, unsigned nr_pages)
{
575
	struct nfs_pageio_descriptor pgio;
L
Linus Torvalds 已提交
576
	struct nfs_readdesc desc = {
577
		.pgio = &pgio,
L
Linus Torvalds 已提交
578 579 580
	};
	struct inode *inode = mapping->host;
	struct nfs_server *server = NFS_SERVER(inode);
581 582
	size_t rsize = server->rsize;
	unsigned long npages;
583
	int ret = -ESTALE;
L
Linus Torvalds 已提交
584 585 586 587 588

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

591 592 593
	if (NFS_STALE(inode))
		goto out;

L
Linus Torvalds 已提交
594
	if (filp == NULL) {
595
		desc.ctx = nfs_find_open_context(inode, NULL, FMODE_READ);
L
Linus Torvalds 已提交
596 597 598
		if (desc.ctx == NULL)
			return -EBADF;
	} else
599
		desc.ctx = get_nfs_open_context(nfs_file_open_context(filp));
600 601 602 603 604 605 606 607 608

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

609 610 611 612 613
	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 已提交
614
	ret = read_cache_pages(mapping, pages, readpage_async_filler, &desc);
615 616 617 618

	nfs_pageio_complete(&pgio);
	npages = (pgio.pg_bytes_written + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
	nfs_add_stats(inode, NFSIOS_READPAGES, npages);
619
read_complete:
L
Linus Torvalds 已提交
620
	put_nfs_open_context(desc.ctx);
621
out:
L
Linus Torvalds 已提交
622 623 624
	return ret;
}

D
David Howells 已提交
625
int __init nfs_init_readpagecache(void)
L
Linus Torvalds 已提交
626 627 628 629
{
	nfs_rdata_cachep = kmem_cache_create("nfs_read_data",
					     sizeof(struct nfs_read_data),
					     0, SLAB_HWCACHE_ALIGN,
630
					     NULL);
L
Linus Torvalds 已提交
631 632 633
	if (nfs_rdata_cachep == NULL)
		return -ENOMEM;

634 635
	nfs_rdata_mempool = mempool_create_slab_pool(MIN_POOL_READ,
						     nfs_rdata_cachep);
L
Linus Torvalds 已提交
636 637 638 639 640 641
	if (nfs_rdata_mempool == NULL)
		return -ENOMEM;

	return 0;
}

642
void nfs_destroy_readpagecache(void)
L
Linus Torvalds 已提交
643 644
{
	mempool_destroy(nfs_rdata_mempool);
645
	kmem_cache_destroy(nfs_rdata_cachep);
L
Linus Torvalds 已提交
646
}