read.c 15.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
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"
26 27
#include "iostat.h"

Linus Torvalds's avatar
Linus Torvalds committed
28 29
#define NFSDBG_FACILITY		NFSDBG_PAGECACHE

30 31
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);
32 33
static const struct rpc_call_ops nfs_read_partial_ops;
static const struct rpc_call_ops nfs_read_full_ops;
Linus Torvalds's avatar
Linus Torvalds committed
34

35
static struct kmem_cache *nfs_rdata_cachep;
36
static mempool_t *nfs_rdata_mempool;
Linus Torvalds's avatar
Linus Torvalds committed
37 38 39

#define MIN_POOL_READ	(32)

40
struct nfs_read_data *nfs_readdata_alloc(unsigned int pagecount)
41
{
42
	struct nfs_read_data *p = mempool_alloc(nfs_rdata_mempool, GFP_NOFS);
43 44 45 46

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

61
static void nfs_readdata_rcu_free(struct rcu_head *head)
62
{
63
	struct nfs_read_data *p = container_of(head, struct nfs_read_data, task.u.tk_rcu);
64 65 66 67 68
	if (p && (p->pagevec != &p->page_array[0]))
		kfree(p->pagevec);
	mempool_free(p, nfs_rdata_mempool);
}

69 70 71 72 73
static void nfs_readdata_free(struct nfs_read_data *rdata)
{
	call_rcu_bh(&rdata->task.u.tk_rcu, nfs_readdata_rcu_free);
}

74
void nfs_readdata_release(void *data)
Linus Torvalds's avatar
Linus Torvalds committed
75 76 77 78 79 80 81
{
        nfs_readdata_free(data);
}

static
int nfs_return_empty_page(struct page *page)
{
82
	zero_user(page, 0, PAGE_CACHE_SIZE);
Linus Torvalds's avatar
Linus Torvalds committed
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
}

Linus Torvalds's avatar
Linus Torvalds committed
117 118 119 120 121 122 123
static int nfs_readpage_async(struct nfs_open_context *ctx, struct inode *inode,
		struct page *page)
{
	LIST_HEAD(one_request);
	struct nfs_page	*new;
	unsigned int len;

124
	len = nfs_page_length(page);
Linus Torvalds's avatar
Linus Torvalds committed
125 126 127 128 129 130 131 132
	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)
133
		zero_user_segment(page, len, PAGE_CACHE_SIZE);
Linus Torvalds's avatar
Linus Torvalds committed
134 135

	nfs_list_add_request(new, &one_request);
136
	if (NFS_SERVER(inode)->rsize < PAGE_CACHE_SIZE)
137
		nfs_pagein_multi(inode, &one_request, 1, len, 0);
138
	else
139
		nfs_pagein_one(inode, &one_request, 1, len, 0);
Linus Torvalds's avatar
Linus Torvalds committed
140 141 142 143 144 145 146 147
	return 0;
}

static void nfs_readpage_release(struct nfs_page *req)
{
	unlock_page(req->wb_page);

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

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

	data->req	  = req;
181
	data->inode	  = inode;
182
	data->cred	  = msg.rpc_cred;
Linus Torvalds's avatar
Linus Torvalds committed
183 184 185 186 187 188 189 190 191 192 193

	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;
	data->args.context = req->wb_context;

	data->res.fattr   = &data->fattr;
	data->res.count   = count;
	data->res.eof     = 0;
194
	nfs_fattr_init(&data->fattr);
Linus Torvalds's avatar
Linus Torvalds committed
195

196
	/* Set up the initial task struct. */
197
	NFS_PROTO(inode)->read_setup(data, &msg);
Linus Torvalds's avatar
Linus Torvalds committed
198

Chuck Lever's avatar
Chuck Lever committed
199
	dprintk("NFS: %5u initiated read call (req %s/%Ld, %u bytes @ offset %Lu)\n",
Linus Torvalds's avatar
Linus Torvalds committed
200 201 202 203 204
			data->task.tk_pid,
			inode->i_sb->s_id,
			(long long)NFS_FILEID(inode),
			count,
			(unsigned long long)data->args.offset);
205

206 207 208
	task = rpc_run_task(&task_setup_data);
	if (!IS_ERR(task))
		rpc_put_task(task);
Linus Torvalds's avatar
Linus Torvalds committed
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
}

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.
 */
237
static int nfs_pagein_multi(struct inode *inode, struct list_head *head, unsigned int npages, size_t count, int flags)
Linus Torvalds's avatar
Linus Torvalds committed
238 239 240 241
{
	struct nfs_page *req = nfs_list_entry(head->next);
	struct page *page = req->wb_page;
	struct nfs_read_data *data;
242 243
	size_t rsize = NFS_SERVER(inode)->rsize, nbytes;
	unsigned int offset;
Linus Torvalds's avatar
Linus Torvalds committed
244 245 246 247 248
	int requests = 0;
	LIST_HEAD(list);

	nfs_list_remove_request(req);

249
	nbytes = count;
250 251 252
	do {
		size_t len = min(nbytes,rsize);

253
		data = nfs_readdata_alloc(1);
Linus Torvalds's avatar
Linus Torvalds committed
254 255 256 257 258
		if (!data)
			goto out_bad;
		INIT_LIST_HEAD(&data->pages);
		list_add(&data->pages, &list);
		requests++;
259 260
		nbytes -= len;
	} while(nbytes != 0);
Linus Torvalds's avatar
Linus Torvalds committed
261 262 263 264
	atomic_set(&req->wb_complete, requests);

	ClearPageError(page);
	offset = 0;
265
	nbytes = count;
Linus Torvalds's avatar
Linus Torvalds committed
266 267 268 269 270 271
	do {
		data = list_entry(list.next, struct nfs_read_data, pages);
		list_del_init(&data->pages);

		data->pagevec[0] = page;

272 273 274 275 276 277
		if (nbytes < rsize)
			rsize = nbytes;
		nfs_read_rpcsetup(req, data, &nfs_read_partial_ops,
				  rsize, offset);
		offset += rsize;
		nbytes -= rsize;
Linus Torvalds's avatar
Linus Torvalds committed
278 279 280 281 282 283 284 285 286 287 288 289 290 291 292
	} while (nbytes != 0);

	return 0;

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

293
static int nfs_pagein_one(struct inode *inode, struct list_head *head, unsigned int npages, size_t count, int flags)
Linus Torvalds's avatar
Linus Torvalds committed
294 295 296 297 298
{
	struct nfs_page		*req;
	struct page		**pages;
	struct nfs_read_data	*data;

299
	data = nfs_readdata_alloc(npages);
Linus Torvalds's avatar
Linus Torvalds committed
300 301 302 303 304 305 306 307 308 309 310 311 312 313
	if (!data)
		goto out_bad;

	INIT_LIST_HEAD(&data->pages);
	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);

314
	nfs_read_rpcsetup(req, data, &nfs_read_full_ops, count, 0);
Linus Torvalds's avatar
Linus Torvalds committed
315 316 317 318 319 320
	return 0;
out_bad:
	nfs_async_read_error(head);
	return -ENOMEM;
}

321 322 323 324 325 326 327 328
/*
 * 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;

Chuck Lever's avatar
Chuck Lever committed
329
	dprintk("NFS: %s: %5u, (status %d)\n", __FUNCTION__, task->tk_pid,
330 331 332 333 334 335 336 337 338
			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) {
Benny Halevy's avatar
Benny Halevy committed
339
		set_bit(NFS_INO_STALE, &NFS_I(data->inode)->flags);
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
		nfs_mark_for_revalidate(data->inode);
	}
	return 0;
}

static int nfs_readpage_retry(struct rpc_task *task, struct nfs_read_data *data)
{
	struct nfs_readargs *argp = &data->args;
	struct nfs_readres *resp = &data->res;

	if (resp->eof || resp->count == argp->count)
		return 0;

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

	/* 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);
	return -EAGAIN;
}

Linus Torvalds's avatar
Linus Torvalds committed
367 368 369
/*
 * Handle a read reply that fills part of a page.
 */
370
static void nfs_readpage_result_partial(struct rpc_task *task, void *calldata)
Linus Torvalds's avatar
Linus Torvalds committed
371
{
372
	struct nfs_read_data *data = calldata;
Linus Torvalds's avatar
Linus Torvalds committed
373 374 375
	struct nfs_page *req = data->req;
	struct page *page = req->wb_page;
 
376 377
	if (nfs_readpage_result(task, data) != 0)
		return;
378 379 380 381 382 383 384 385

	if (likely(task->tk_status >= 0)) {
		nfs_readpage_truncate_uninitialised_page(data);
		if (nfs_readpage_retry(task, data) != 0)
			return;
	}
	if (unlikely(task->tk_status < 0))
		SetPageError(page);
Linus Torvalds's avatar
Linus Torvalds committed
386 387 388 389 390 391 392
	if (atomic_dec_and_test(&req->wb_complete)) {
		if (!PageError(page))
			SetPageUptodate(page);
		nfs_readpage_release(req);
	}
}

393 394 395 396 397
static const struct rpc_call_ops nfs_read_partial_ops = {
	.rpc_call_done = nfs_readpage_result_partial,
	.rpc_release = nfs_readdata_release,
};

398 399 400 401 402 403
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;

404 405
	if (data->res.eof)
		count = data->args.count;
406 407 408 409 410 411 412
	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);
413 414 415 416
	if (count == 0)
		return;
	/* Was this a short read? */
	if (data->res.eof || data->res.count == data->args.count)
417 418 419
		SetPageUptodate(*pages);
}

Linus Torvalds's avatar
Linus Torvalds committed
420 421 422 423
/*
 * This is the callback from RPC telling us whether a reply was
 * received or some error occurred (timeout or socket shutdown).
 */
424
static void nfs_readpage_result_full(struct rpc_task *task, void *calldata)
Linus Torvalds's avatar
Linus Torvalds committed
425
{
426
	struct nfs_read_data *data = calldata;
Linus Torvalds's avatar
Linus Torvalds committed
427

428 429
	if (nfs_readpage_result(task, data) != 0)
		return;
430
	/*
431
	 * Note: nfs_readpage_retry may change the values of
432
	 * data->args. In the multi-page case, we therefore need
433 434
	 * to ensure that we call nfs_readpage_set_pages_uptodate()
	 * first.
435 436 437 438
	 */
	if (likely(task->tk_status >= 0)) {
		nfs_readpage_truncate_uninitialised_page(data);
		nfs_readpage_set_pages_uptodate(data);
439 440 441
		if (nfs_readpage_retry(task, data) != 0)
			return;
	}
Linus Torvalds's avatar
Linus Torvalds committed
442 443 444
	while (!list_empty(&data->pages)) {
		struct nfs_page *req = nfs_list_entry(data->pages.next);

445
		nfs_list_remove_request(req);
Linus Torvalds's avatar
Linus Torvalds committed
446 447 448 449
		nfs_readpage_release(req);
	}
}

450 451 452 453 454
static const struct rpc_call_ops nfs_read_full_ops = {
	.rpc_call_done = nfs_readpage_result_full,
	.rpc_release = nfs_readdata_release,
};

Linus Torvalds's avatar
Linus Torvalds committed
455 456 457 458 459 460 461 462 463 464 465 466 467 468
/*
 * 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);
469 470 471
	nfs_inc_stats(inode, NFSIOS_VFSREADPAGE);
	nfs_add_stats(inode, NFSIOS_READPAGES, 1);

Linus Torvalds's avatar
Linus Torvalds committed
472 473 474 475 476 477 478 479 480
	/*
	 * 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)
481 482 483
		goto out_unlock;
	if (PageUptodate(page))
		goto out_unlock;
Linus Torvalds's avatar
Linus Torvalds committed
484

485 486
	error = -ESTALE;
	if (NFS_STALE(inode))
487
		goto out_unlock;
488

Linus Torvalds's avatar
Linus Torvalds committed
489
	if (file == NULL) {
490
		error = -EBADF;
491
		ctx = nfs_find_open_context(inode, NULL, FMODE_READ);
Linus Torvalds's avatar
Linus Torvalds committed
492
		if (ctx == NULL)
493
			goto out_unlock;
Linus Torvalds's avatar
Linus Torvalds committed
494
	} else
495
		ctx = get_nfs_open_context(nfs_file_open_context(file));
Linus Torvalds's avatar
Linus Torvalds committed
496

497 498
	error = nfs_readpage_async(ctx, inode, page);

Linus Torvalds's avatar
Linus Torvalds committed
499 500
	put_nfs_open_context(ctx);
	return error;
501
out_unlock:
Linus Torvalds's avatar
Linus Torvalds committed
502 503 504 505 506
	unlock_page(page);
	return error;
}

struct nfs_readdesc {
507
	struct nfs_pageio_descriptor *pgio;
Linus Torvalds's avatar
Linus Torvalds committed
508 509 510 511 512 513 514 515 516 517
	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;
518 519 520 521 522 523 524
	int error;

	error = nfs_wb_page(inode, page);
	if (error)
		goto out_unlock;
	if (PageUptodate(page))
		goto out_unlock;
Linus Torvalds's avatar
Linus Torvalds committed
525

526
	len = nfs_page_length(page);
Linus Torvalds's avatar
Linus Torvalds committed
527 528
	if (len == 0)
		return nfs_return_empty_page(page);
529

Linus Torvalds's avatar
Linus Torvalds committed
530
	new = nfs_create_request(desc->ctx, inode, page, 0, len);
531 532 533
	if (IS_ERR(new))
		goto out_error;

Linus Torvalds's avatar
Linus Torvalds committed
534
	if (len < PAGE_CACHE_SIZE)
535
		zero_user_segment(page, len, PAGE_CACHE_SIZE);
536
	nfs_pageio_add_request(desc->pgio, new);
Linus Torvalds's avatar
Linus Torvalds committed
537
	return 0;
538 539 540 541 542 543
out_error:
	error = PTR_ERR(new);
	SetPageError(page);
out_unlock:
	unlock_page(page);
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
544 545 546 547 548
}

int nfs_readpages(struct file *filp, struct address_space *mapping,
		struct list_head *pages, unsigned nr_pages)
{
549
	struct nfs_pageio_descriptor pgio;
Linus Torvalds's avatar
Linus Torvalds committed
550
	struct nfs_readdesc desc = {
551
		.pgio = &pgio,
Linus Torvalds's avatar
Linus Torvalds committed
552 553 554
	};
	struct inode *inode = mapping->host;
	struct nfs_server *server = NFS_SERVER(inode);
555 556
	size_t rsize = server->rsize;
	unsigned long npages;
557
	int ret = -ESTALE;
Linus Torvalds's avatar
Linus Torvalds committed
558 559 560 561 562

	dprintk("NFS: nfs_readpages (%s/%Ld %d)\n",
			inode->i_sb->s_id,
			(long long)NFS_FILEID(inode),
			nr_pages);
563
	nfs_inc_stats(inode, NFSIOS_VFSREADPAGES);
Linus Torvalds's avatar
Linus Torvalds committed
564

565 566 567
	if (NFS_STALE(inode))
		goto out;

Linus Torvalds's avatar
Linus Torvalds committed
568
	if (filp == NULL) {
569
		desc.ctx = nfs_find_open_context(inode, NULL, FMODE_READ);
Linus Torvalds's avatar
Linus Torvalds committed
570 571 572
		if (desc.ctx == NULL)
			return -EBADF;
	} else
573
		desc.ctx = get_nfs_open_context(nfs_file_open_context(filp));
574 575 576 577 578
	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);

Linus Torvalds's avatar
Linus Torvalds committed
579
	ret = read_cache_pages(mapping, pages, readpage_async_filler, &desc);
580 581 582 583

	nfs_pageio_complete(&pgio);
	npages = (pgio.pg_bytes_written + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
	nfs_add_stats(inode, NFSIOS_READPAGES, npages);
Linus Torvalds's avatar
Linus Torvalds committed
584
	put_nfs_open_context(desc.ctx);
585
out:
Linus Torvalds's avatar
Linus Torvalds committed
586 587 588
	return ret;
}

David Howells's avatar
David Howells committed
589
int __init nfs_init_readpagecache(void)
Linus Torvalds's avatar
Linus Torvalds committed
590 591 592 593
{
	nfs_rdata_cachep = kmem_cache_create("nfs_read_data",
					     sizeof(struct nfs_read_data),
					     0, SLAB_HWCACHE_ALIGN,
594
					     NULL);
Linus Torvalds's avatar
Linus Torvalds committed
595 596 597
	if (nfs_rdata_cachep == NULL)
		return -ENOMEM;

598 599
	nfs_rdata_mempool = mempool_create_slab_pool(MIN_POOL_READ,
						     nfs_rdata_cachep);
Linus Torvalds's avatar
Linus Torvalds committed
600 601 602 603 604 605
	if (nfs_rdata_mempool == NULL)
		return -ENOMEM;

	return 0;
}

606
void nfs_destroy_readpagecache(void)
Linus Torvalds's avatar
Linus Torvalds committed
607 608
{
	mempool_destroy(nfs_rdata_mempool);
609
	kmem_cache_destroy(nfs_rdata_cachep);
Linus Torvalds's avatar
Linus Torvalds committed
610
}