dir.c 57.1 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
/*
 *  linux/fs/nfs/dir.c
 *
 *  Copyright (C) 1992  Rick Sladkey
 *
 *  nfs directory handling functions
 *
 * 10 Apr 1996	Added silly rename for unlink	--okir
 * 28 Sep 1996	Improved directory cache --okir
 * 23 Aug 1997  Claus Heine claus@momo.math.rwth-aachen.de 
 *              Re-implemented silly rename for unlink, newly implemented
 *              silly rename for nfs_rename() following the suggestions
 *              of Olaf Kirch (okir) found in this file.
 *              Following Linus comments on my original hack, this version
 *              depends only on the dcache stuff and doesn't touch the inode
 *              layer (iput() and friends).
 *  6 Jun 1999	Cache readdir lookups in the page cache. -DaveM
 */

B
Bryan Schumaker 已提交
20
#include <linux/module.h>
L
Linus Torvalds 已提交
21 22 23 24 25 26 27 28 29 30 31 32
#include <linux/time.h>
#include <linux/errno.h>
#include <linux/stat.h>
#include <linux/fcntl.h>
#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/sunrpc/clnt.h>
#include <linux/nfs_fs.h>
#include <linux/nfs_mount.h>
#include <linux/pagemap.h>
33
#include <linux/pagevec.h>
L
Linus Torvalds 已提交
34
#include <linux/namei.h>
35
#include <linux/mount.h>
A
Alexey Dobriyan 已提交
36
#include <linux/sched.h>
37
#include <linux/kmemleak.h>
38
#include <linux/xattr.h>
L
Linus Torvalds 已提交
39 40

#include "delegation.h"
C
Chuck Lever 已提交
41
#include "iostat.h"
42
#include "internal.h"
43
#include "fscache.h"
L
Linus Torvalds 已提交
44 45 46 47

/* #define NFS_DEBUG_VERBOSE 1 */

static int nfs_opendir(struct inode *, struct file *);
48
static int nfs_closedir(struct inode *, struct file *);
A
Al Viro 已提交
49
static int nfs_readdir(struct file *, struct dir_context *);
50
static int nfs_fsync_dir(struct file *, loff_t, loff_t, int);
51
static loff_t nfs_llseek_dir(struct file *, loff_t, int);
52
static void nfs_readdir_clear_array(struct page*);
L
Linus Torvalds 已提交
53

54
const struct file_operations nfs_dir_operations = {
55
	.llseek		= nfs_llseek_dir,
L
Linus Torvalds 已提交
56
	.read		= generic_read_dir,
A
Al Viro 已提交
57
	.iterate	= nfs_readdir,
L
Linus Torvalds 已提交
58
	.open		= nfs_opendir,
59
	.release	= nfs_closedir,
L
Linus Torvalds 已提交
60 61 62
	.fsync		= nfs_fsync_dir,
};

63 64
const struct address_space_operations nfs_dir_aops = {
	.freepage = nfs_readdir_clear_array,
B
Bryan Schumaker 已提交
65 66
};

67
static struct nfs_open_dir_context *alloc_nfs_open_dir_context(struct inode *dir, struct rpc_cred *cred)
68 69 70 71
{
	struct nfs_open_dir_context *ctx;
	ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
	if (ctx != NULL) {
72
		ctx->duped = 0;
73
		ctx->attr_gencount = NFS_I(dir)->attr_gencount;
74
		ctx->dir_cookie = 0;
75
		ctx->dup_cookie = 0;
76
		ctx->cred = get_rpccred(cred);
77 78 79
		return ctx;
	}
	return  ERR_PTR(-ENOMEM);
80 81 82 83 84 85 86 87
}

static void put_nfs_open_dir_context(struct nfs_open_dir_context *ctx)
{
	put_rpccred(ctx->cred);
	kfree(ctx);
}

L
Linus Torvalds 已提交
88 89 90 91 92 93
/*
 * Open file
 */
static int
nfs_opendir(struct inode *inode, struct file *filp)
{
94 95 96
	int res = 0;
	struct nfs_open_dir_context *ctx;
	struct rpc_cred *cred;
L
Linus Torvalds 已提交
97

C
Chuck Lever 已提交
98
	dfprintk(FILE, "NFS: open dir(%s/%s)\n",
99 100 101 102
			filp->f_path.dentry->d_parent->d_name.name,
			filp->f_path.dentry->d_name.name);

	nfs_inc_stats(inode, NFSIOS_VFSOPEN);
C
Chuck Lever 已提交
103

104 105 106
	cred = rpc_lookup_cred();
	if (IS_ERR(cred))
		return PTR_ERR(cred);
107
	ctx = alloc_nfs_open_dir_context(inode, cred);
108 109 110 111 112
	if (IS_ERR(ctx)) {
		res = PTR_ERR(ctx);
		goto out;
	}
	filp->private_data = ctx;
113 114 115 116 117 118 119
	if (filp->f_path.dentry == filp->f_path.mnt->mnt_root) {
		/* This is a mountpoint, so d_revalidate will never
		 * have been called, so we need to refresh the
		 * inode (for close-open consistency) ourselves.
		 */
		__nfs_revalidate_inode(NFS_SERVER(inode), inode);
	}
120 121
out:
	put_rpccred(cred);
L
Linus Torvalds 已提交
122 123 124
	return res;
}

125 126 127 128 129 130 131
static int
nfs_closedir(struct inode *inode, struct file *filp)
{
	put_nfs_open_dir_context(filp->private_data);
	return 0;
}

B
Bryan Schumaker 已提交
132 133 134 135
struct nfs_cache_array_entry {
	u64 cookie;
	u64 ino;
	struct qstr string;
136
	unsigned char d_type;
B
Bryan Schumaker 已提交
137 138 139
};

struct nfs_cache_array {
140
	int size;
B
Bryan Schumaker 已提交
141 142 143 144 145
	int eof_index;
	u64 last_cookie;
	struct nfs_cache_array_entry array[0];
};

146
typedef int (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, int);
L
Linus Torvalds 已提交
147 148 149
typedef struct {
	struct file	*file;
	struct page	*page;
A
Al Viro 已提交
150
	struct dir_context *ctx;
L
Linus Torvalds 已提交
151
	unsigned long	page_index;
152
	u64		*dir_cookie;
153
	u64		last_cookie;
154
	loff_t		current_index;
L
Linus Torvalds 已提交
155
	decode_dirent_t	decode;
B
Bryan Schumaker 已提交
156

157
	unsigned long	timestamp;
158
	unsigned long	gencount;
B
Bryan Schumaker 已提交
159 160 161
	unsigned int	cache_entry_index;
	unsigned int	plus:1;
	unsigned int	eof:1;
L
Linus Torvalds 已提交
162 163
} nfs_readdir_descriptor_t;

B
Bryan Schumaker 已提交
164 165
/*
 * The caller is responsible for calling nfs_readdir_release_array(page)
L
Linus Torvalds 已提交
166 167
 */
static
B
Bryan Schumaker 已提交
168 169
struct nfs_cache_array *nfs_readdir_get_array(struct page *page)
{
170
	void *ptr;
B
Bryan Schumaker 已提交
171 172
	if (page == NULL)
		return ERR_PTR(-EIO);
173 174 175 176
	ptr = kmap(page);
	if (ptr == NULL)
		return ERR_PTR(-ENOMEM);
	return ptr;
B
Bryan Schumaker 已提交
177 178 179 180 181 182 183 184 185 186 187 188
}

static
void nfs_readdir_release_array(struct page *page)
{
	kunmap(page);
}

/*
 * we are freeing strings created by nfs_add_to_readdir_array()
 */
static
189
void nfs_readdir_clear_array(struct page *page)
B
Bryan Schumaker 已提交
190
{
191
	struct nfs_cache_array *array;
B
Bryan Schumaker 已提交
192
	int i;
193

194
	array = kmap_atomic(page);
B
Bryan Schumaker 已提交
195 196
	for (i = 0; i < array->size; i++)
		kfree(array->array[i].string.name);
197
	kunmap_atomic(array);
B
Bryan Schumaker 已提交
198 199 200 201 202 203 204 205
}

/*
 * the caller is responsible for freeing qstr.name
 * when called by nfs_readdir_add_to_array, the strings will be freed in
 * nfs_clear_readdir_array()
 */
static
206
int nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int len)
B
Bryan Schumaker 已提交
207 208 209
{
	string->len = len;
	string->name = kmemdup(name, len, GFP_KERNEL);
210 211
	if (string->name == NULL)
		return -ENOMEM;
212 213 214 215 216
	/*
	 * Avoid a kmemleak false positive. The pointer to the name is stored
	 * in a page cache page which kmemleak does not scan.
	 */
	kmemleak_not_leak(string->name);
217 218
	string->hash = full_name_hash(name, len);
	return 0;
B
Bryan Schumaker 已提交
219 220 221 222 223 224
}

static
int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page)
{
	struct nfs_cache_array *array = nfs_readdir_get_array(page);
225 226 227
	struct nfs_cache_array_entry *cache_entry;
	int ret;

B
Bryan Schumaker 已提交
228 229
	if (IS_ERR(array))
		return PTR_ERR(array);
230 231 232 233

	cache_entry = &array->array[array->size];

	/* Check that this entry lies within the page bounds */
234
	ret = -ENOSPC;
235
	if ((char *)&cache_entry[1] - (char *)page_address(page) > PAGE_SIZE)
236
		goto out;
B
Bryan Schumaker 已提交
237

238 239
	cache_entry->cookie = entry->prev_cookie;
	cache_entry->ino = entry->ino;
240
	cache_entry->d_type = entry->d_type;
241 242 243
	ret = nfs_readdir_make_qstr(&cache_entry->string, entry->name, entry->len);
	if (ret)
		goto out;
B
Bryan Schumaker 已提交
244
	array->last_cookie = entry->cookie;
245
	array->size++;
T
Trond Myklebust 已提交
246
	if (entry->eof != 0)
B
Bryan Schumaker 已提交
247
		array->eof_index = array->size;
248
out:
B
Bryan Schumaker 已提交
249
	nfs_readdir_release_array(page);
250
	return ret;
B
Bryan Schumaker 已提交
251 252 253 254 255
}

static
int nfs_readdir_search_for_pos(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
{
A
Al Viro 已提交
256
	loff_t diff = desc->ctx->pos - desc->current_index;
B
Bryan Schumaker 已提交
257 258 259 260 261
	unsigned int index;

	if (diff < 0)
		goto out_eof;
	if (diff >= array->size) {
262
		if (array->eof_index >= 0)
B
Bryan Schumaker 已提交
263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
			goto out_eof;
		return -EAGAIN;
	}

	index = (unsigned int)diff;
	*desc->dir_cookie = array->array[index].cookie;
	desc->cache_entry_index = index;
	return 0;
out_eof:
	desc->eof = 1;
	return -EBADCOOKIE;
}

static
int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
{
	int i;
280
	loff_t new_pos;
B
Bryan Schumaker 已提交
281 282 283 284
	int status = -EAGAIN;

	for (i = 0; i < array->size; i++) {
		if (array->array[i].cookie == *desc->dir_cookie) {
A
Al Viro 已提交
285
			struct nfs_inode *nfsi = NFS_I(file_inode(desc->file));
286 287
			struct nfs_open_dir_context *ctx = desc->file->private_data;

288
			new_pos = desc->current_index + i;
289 290 291 292
			if (ctx->attr_gencount != nfsi->attr_gencount
			    || (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA))) {
				ctx->duped = 0;
				ctx->attr_gencount = nfsi->attr_gencount;
A
Al Viro 已提交
293
			} else if (new_pos < desc->ctx->pos) {
294 295 296 297 298
				if (ctx->duped > 0
				    && ctx->dup_cookie == *desc->dir_cookie) {
					if (printk_ratelimit()) {
						pr_notice("NFS: directory %s/%s contains a readdir loop."
								"Please contact your server vendor.  "
299
								"The file: %s has duplicate cookie %llu\n",
300 301
								desc->file->f_dentry->d_parent->d_name.name,
								desc->file->f_dentry->d_name.name,
302
								array->array[i].string.name,
303 304 305 306 307
								*desc->dir_cookie);
					}
					status = -ELOOP;
					goto out;
				}
308
				ctx->dup_cookie = *desc->dir_cookie;
309
				ctx->duped = -1;
310
			}
A
Al Viro 已提交
311
			desc->ctx->pos = new_pos;
B
Bryan Schumaker 已提交
312
			desc->cache_entry_index = i;
T
Trond Myklebust 已提交
313
			return 0;
B
Bryan Schumaker 已提交
314 315
		}
	}
T
Trond Myklebust 已提交
316
	if (array->eof_index >= 0) {
317
		status = -EBADCOOKIE;
318 319
		if (*desc->dir_cookie == array->last_cookie)
			desc->eof = 1;
320
	}
321
out:
B
Bryan Schumaker 已提交
322 323 324 325 326 327 328
	return status;
}

static
int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc)
{
	struct nfs_cache_array *array;
T
Trond Myklebust 已提交
329
	int status;
B
Bryan Schumaker 已提交
330 331 332 333 334 335 336 337 338 339 340 341

	array = nfs_readdir_get_array(desc->page);
	if (IS_ERR(array)) {
		status = PTR_ERR(array);
		goto out;
	}

	if (*desc->dir_cookie == 0)
		status = nfs_readdir_search_for_pos(array, desc);
	else
		status = nfs_readdir_search_for_cookie(array, desc);

T
Trond Myklebust 已提交
342
	if (status == -EAGAIN) {
343
		desc->last_cookie = array->last_cookie;
344
		desc->current_index += array->size;
T
Trond Myklebust 已提交
345 346
		desc->page_index++;
	}
B
Bryan Schumaker 已提交
347 348 349 350 351 352 353
	nfs_readdir_release_array(desc->page);
out:
	return status;
}

/* Fill a page with xdr information before transferring to the cache page */
static
B
Bryan Schumaker 已提交
354
int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc,
B
Bryan Schumaker 已提交
355
			struct nfs_entry *entry, struct file *file, struct inode *inode)
L
Linus Torvalds 已提交
356
{
357 358
	struct nfs_open_dir_context *ctx = file->private_data;
	struct rpc_cred	*cred = ctx->cred;
359
	unsigned long	timestamp, gencount;
L
Linus Torvalds 已提交
360 361 362 363
	int		error;

 again:
	timestamp = jiffies;
364
	gencount = nfs_inc_attr_generation_counter();
B
Bryan Schumaker 已提交
365
	error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, entry->cookie, pages,
L
Linus Torvalds 已提交
366 367 368 369 370
					  NFS_SERVER(inode)->dtsize, desc->plus);
	if (error < 0) {
		/* We requested READDIRPLUS, but the server doesn't grok it */
		if (error == -ENOTSUPP && desc->plus) {
			NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS;
B
Benny Halevy 已提交
371
			clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
L
Linus Torvalds 已提交
372 373 374 375 376
			desc->plus = 0;
			goto again;
		}
		goto error;
	}
377
	desc->timestamp = timestamp;
378
	desc->gencount = gencount;
B
Bryan Schumaker 已提交
379 380
error:
	return error;
L
Linus Torvalds 已提交
381 382
}

383 384
static int xdr_decode(nfs_readdir_descriptor_t *desc,
		      struct nfs_entry *entry, struct xdr_stream *xdr)
L
Linus Torvalds 已提交
385
{
386
	int error;
L
Linus Torvalds 已提交
387

388 389 390
	error = desc->decode(xdr, entry, desc->plus);
	if (error)
		return error;
B
Bryan Schumaker 已提交
391 392 393
	entry->fattr->time_start = desc->timestamp;
	entry->fattr->gencount = desc->gencount;
	return 0;
L
Linus Torvalds 已提交
394 395
}

B
Bryan Schumaker 已提交
396 397 398 399 400
static
int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry)
{
	if (dentry->d_inode == NULL)
		goto different;
T
Trond Myklebust 已提交
401
	if (nfs_compare_fh(entry->fh, NFS_FH(dentry->d_inode)) != 0)
B
Bryan Schumaker 已提交
402 403 404 405 406 407
		goto different;
	return 1;
different:
	return 0;
}

408
static
A
Al Viro 已提交
409
bool nfs_use_readdirplus(struct inode *dir, struct dir_context *ctx)
410 411 412 413 414
{
	if (!nfs_server_capable(dir, NFS_CAP_READDIRPLUS))
		return false;
	if (test_and_clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(dir)->flags))
		return true;
A
Al Viro 已提交
415
	if (ctx->pos == 0)
416 417 418 419 420 421 422 423 424 425 426 427 428 429 430
		return true;
	return false;
}

/*
 * This function is called by the lookup code to request the use of
 * readdirplus to accelerate any future lookups in the same
 * directory.
 */
static
void nfs_advise_use_readdirplus(struct inode *dir)
{
	set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(dir)->flags);
}

B
Bryan Schumaker 已提交
431 432 433
static
void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
{
434
	struct qstr filename = QSTR_INIT(entry->name, entry->len);
435 436
	struct dentry *dentry;
	struct dentry *alias;
B
Bryan Schumaker 已提交
437 438 439
	struct inode *dir = parent->d_inode;
	struct inode *inode;

440 441 442 443 444 445 446
	if (filename.name[0] == '.') {
		if (filename.len == 1)
			return;
		if (filename.len == 2 && filename.name[1] == '.')
			return;
	}
	filename.hash = full_name_hash(filename.name, filename.len);
B
Bryan Schumaker 已提交
447

448
	dentry = d_lookup(parent, &filename);
B
Bryan Schumaker 已提交
449 450 451 452 453
	if (dentry != NULL) {
		if (nfs_same_file(dentry, entry)) {
			nfs_refresh_inode(dentry->d_inode, entry->fattr);
			goto out;
		} else {
454 455
			if (d_invalidate(dentry) != 0)
				goto out;
B
Bryan Schumaker 已提交
456 457 458 459 460
			dput(dentry);
		}
	}

	dentry = d_alloc(parent, &filename);
461 462 463
	if (dentry == NULL)
		return;

B
Bryan Schumaker 已提交
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480
	inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr);
	if (IS_ERR(inode))
		goto out;

	alias = d_materialise_unique(dentry, inode);
	if (IS_ERR(alias))
		goto out;
	else if (alias) {
		nfs_set_verifier(alias, nfs_save_change_attribute(dir));
		dput(alias);
	} else
		nfs_set_verifier(dentry, nfs_save_change_attribute(dir));

out:
	dput(dentry);
}

B
Bryan Schumaker 已提交
481 482
/* Perform conversion from xdr to cache array */
static
483
int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry,
484
				struct page **xdr_pages, struct page *page, unsigned int buflen)
L
Linus Torvalds 已提交
485
{
486
	struct xdr_stream stream;
487
	struct xdr_buf buf;
488
	struct page *scratch;
B
Bryan Schumaker 已提交
489
	struct nfs_cache_array *array;
490 491
	unsigned int count = 0;
	int status;
492

493 494 495
	scratch = alloc_page(GFP_KERNEL);
	if (scratch == NULL)
		return -ENOMEM;
496

497
	xdr_init_decode_pages(&stream, &buf, xdr_pages, buflen);
498
	xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
B
Bryan Schumaker 已提交
499 500 501

	do {
		status = xdr_decode(desc, entry, &stream);
502 503 504
		if (status != 0) {
			if (status == -EAGAIN)
				status = 0;
B
Bryan Schumaker 已提交
505
			break;
506
		}
B
Bryan Schumaker 已提交
507

508 509
		count++;

T
Trond Myklebust 已提交
510
		if (desc->plus != 0)
B
Bryan Schumaker 已提交
511
			nfs_prime_dcache(desc->file->f_path.dentry, entry);
512 513 514 515

		status = nfs_readdir_add_to_array(entry, page);
		if (status != 0)
			break;
B
Bryan Schumaker 已提交
516 517
	} while (!entry->eof);

T
Trond Myklebust 已提交
518
	if (count == 0 || (status == -EBADCOOKIE && entry->eof != 0)) {
B
Bryan Schumaker 已提交
519
		array = nfs_readdir_get_array(page);
520 521 522 523
		if (!IS_ERR(array)) {
			array->eof_index = array->size;
			status = 0;
			nfs_readdir_release_array(page);
524 525
		} else
			status = PTR_ERR(array);
L
Linus Torvalds 已提交
526
	}
527 528

	put_page(scratch);
529
	return status;
B
Bryan Schumaker 已提交
530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
}

static
void nfs_readdir_free_pagearray(struct page **pages, unsigned int npages)
{
	unsigned int i;
	for (i = 0; i < npages; i++)
		put_page(pages[i]);
}

static
void nfs_readdir_free_large_page(void *ptr, struct page **pages,
		unsigned int npages)
{
	nfs_readdir_free_pagearray(pages, npages);
}

/*
 * nfs_readdir_large_page will allocate pages that must be freed with a call
 * to nfs_readdir_free_large_page
 */
static
552
int nfs_readdir_large_page(struct page **pages, unsigned int npages)
B
Bryan Schumaker 已提交
553 554 555 556 557 558 559 560 561
{
	unsigned int i;

	for (i = 0; i < npages; i++) {
		struct page *page = alloc_page(GFP_KERNEL);
		if (page == NULL)
			goto out_freepages;
		pages[i] = page;
	}
562
	return 0;
B
Bryan Schumaker 已提交
563 564 565

out_freepages:
	nfs_readdir_free_pagearray(pages, i);
566
	return -ENOMEM;
L
Linus Torvalds 已提交
567 568
}

B
Bryan Schumaker 已提交
569 570
static
int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode)
571
{
B
Bryan Schumaker 已提交
572 573
	struct page *pages[NFS_MAX_READDIR_PAGES];
	void *pages_ptr = NULL;
B
Bryan Schumaker 已提交
574 575 576
	struct nfs_entry entry;
	struct file	*file = desc->file;
	struct nfs_cache_array *array;
577
	int status = -ENOMEM;
B
Bryan Schumaker 已提交
578
	unsigned int array_size = ARRAY_SIZE(pages);
B
Bryan Schumaker 已提交
579 580

	entry.prev_cookie = 0;
581
	entry.cookie = desc->last_cookie;
B
Bryan Schumaker 已提交
582 583 584
	entry.eof = 0;
	entry.fh = nfs_alloc_fhandle();
	entry.fattr = nfs_alloc_fattr();
585
	entry.server = NFS_SERVER(inode);
B
Bryan Schumaker 已提交
586 587
	if (entry.fh == NULL || entry.fattr == NULL)
		goto out;
588

B
Bryan Schumaker 已提交
589
	array = nfs_readdir_get_array(page);
590 591 592 593
	if (IS_ERR(array)) {
		status = PTR_ERR(array);
		goto out;
	}
B
Bryan Schumaker 已提交
594 595
	memset(array, 0, sizeof(struct nfs_cache_array));
	array->eof_index = -1;
596

597 598
	status = nfs_readdir_large_page(pages, array_size);
	if (status < 0)
B
Bryan Schumaker 已提交
599 600
		goto out_release_array;
	do {
601
		unsigned int pglen;
B
Bryan Schumaker 已提交
602
		status = nfs_readdir_xdr_filler(pages, desc, &entry, file, inode);
603

B
Bryan Schumaker 已提交
604
		if (status < 0)
605
			break;
606
		pglen = status;
607
		status = nfs_readdir_page_filler(desc, &entry, pages, page, pglen);
608 609 610 611 612 613
		if (status < 0) {
			if (status == -ENOSPC)
				status = 0;
			break;
		}
	} while (array->eof_index < 0);
B
Bryan Schumaker 已提交
614

B
Bryan Schumaker 已提交
615
	nfs_readdir_free_large_page(pages_ptr, pages, array_size);
B
Bryan Schumaker 已提交
616 617 618 619 620
out_release_array:
	nfs_readdir_release_array(page);
out:
	nfs_free_fattr(entry.fattr);
	nfs_free_fhandle(entry.fh);
621 622 623 624
	return status;
}

/*
B
Bryan Schumaker 已提交
625 626 627 628
 * Now we cache directories properly, by converting xdr information
 * to an array that can be used for lookups later.  This results in
 * fewer cache pages, since we can store more information on each page.
 * We only need to convert from xdr once so future lookups are much simpler
L
Linus Torvalds 已提交
629
 */
B
Bryan Schumaker 已提交
630 631
static
int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page* page)
L
Linus Torvalds 已提交
632
{
A
Al Viro 已提交
633
	struct inode	*inode = file_inode(desc->file);
634
	int ret;
L
Linus Torvalds 已提交
635

636 637
	ret = nfs_readdir_xdr_to_array(desc, page, inode);
	if (ret < 0)
B
Bryan Schumaker 已提交
638 639
		goto error;
	SetPageUptodate(page);
L
Linus Torvalds 已提交
640

B
Bryan Schumaker 已提交
641 642 643
	if (invalidate_inode_pages2_range(inode->i_mapping, page->index + 1, -1) < 0) {
		/* Should never happen */
		nfs_zap_mapping(inode, inode->i_mapping);
L
Linus Torvalds 已提交
644
	}
B
Bryan Schumaker 已提交
645 646 647 648
	unlock_page(page);
	return 0;
 error:
	unlock_page(page);
649
	return ret;
B
Bryan Schumaker 已提交
650
}
L
Linus Torvalds 已提交
651

B
Bryan Schumaker 已提交
652 653 654
static
void cache_page_release(nfs_readdir_descriptor_t *desc)
{
655 656
	if (!desc->page->mapping)
		nfs_readdir_clear_array(desc->page);
B
Bryan Schumaker 已提交
657 658 659 660 661 662 663
	page_cache_release(desc->page);
	desc->page = NULL;
}

static
struct page *get_cache_page(nfs_readdir_descriptor_t *desc)
{
A
Al Viro 已提交
664
	return read_cache_page(file_inode(desc->file)->i_mapping,
B
Bryan Schumaker 已提交
665
			desc->page_index, (filler_t *)nfs_readdir_filler, desc);
L
Linus Torvalds 已提交
666 667 668
}

/*
B
Bryan Schumaker 已提交
669
 * Returns 0 if desc->dir_cookie was found on page desc->page_index
L
Linus Torvalds 已提交
670
 */
B
Bryan Schumaker 已提交
671 672 673 674 675 676 677 678 679 680
static
int find_cache_page(nfs_readdir_descriptor_t *desc)
{
	int res;

	desc->page = get_cache_page(desc);
	if (IS_ERR(desc->page))
		return PTR_ERR(desc->page);

	res = nfs_readdir_search_array(desc);
T
Trond Myklebust 已提交
681 682
	if (res != 0)
		cache_page_release(desc);
B
Bryan Schumaker 已提交
683 684 685 686
	return res;
}

/* Search for desc->dir_cookie from the beginning of the page cache */
L
Linus Torvalds 已提交
687 688 689
static inline
int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)
{
690
	int res;
B
Bryan Schumaker 已提交
691

692
	if (desc->page_index == 0) {
693
		desc->current_index = 0;
694 695
		desc->last_cookie = 0;
	}
T
Trond Myklebust 已提交
696
	do {
B
Bryan Schumaker 已提交
697
		res = find_cache_page(desc);
T
Trond Myklebust 已提交
698
	} while (res == -EAGAIN);
L
Linus Torvalds 已提交
699 700 701 702 703 704 705
	return res;
}

/*
 * Once we've found the start of the dirent within a page: fill 'er up...
 */
static 
A
Al Viro 已提交
706
int nfs_do_filldir(nfs_readdir_descriptor_t *desc)
L
Linus Torvalds 已提交
707 708
{
	struct file	*file = desc->file;
B
Bryan Schumaker 已提交
709 710 711
	int i = 0;
	int res = 0;
	struct nfs_cache_array *array = NULL;
712 713
	struct nfs_open_dir_context *ctx = file->private_data;

B
Bryan Schumaker 已提交
714
	array = nfs_readdir_get_array(desc->page);
715 716 717 718
	if (IS_ERR(array)) {
		res = PTR_ERR(array);
		goto out;
	}
B
Bryan Schumaker 已提交
719 720

	for (i = desc->cache_entry_index; i < array->size; i++) {
721
		struct nfs_cache_array_entry *ent;
L
Linus Torvalds 已提交
722

723
		ent = &array->array[i];
A
Al Viro 已提交
724 725
		if (!dir_emit(desc->ctx, ent->string.name, ent->string.len,
		    nfs_compat_user_ino64(ent->ino), ent->d_type)) {
726
			desc->eof = 1;
L
Linus Torvalds 已提交
727
			break;
728
		}
A
Al Viro 已提交
729
		desc->ctx->pos++;
B
Bryan Schumaker 已提交
730 731 732 733
		if (i < (array->size-1))
			*desc->dir_cookie = array->array[i+1].cookie;
		else
			*desc->dir_cookie = array->last_cookie;
734 735
		if (ctx->duped != 0)
			ctx->duped = 1;
L
Linus Torvalds 已提交
736
	}
T
Trond Myklebust 已提交
737
	if (array->eof_index >= 0)
738
		desc->eof = 1;
B
Bryan Schumaker 已提交
739 740

	nfs_readdir_release_array(desc->page);
741
out:
B
Bryan Schumaker 已提交
742
	cache_page_release(desc);
C
Chuck Lever 已提交
743 744
	dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n",
			(unsigned long long)*desc->dir_cookie, res);
L
Linus Torvalds 已提交
745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760
	return res;
}

/*
 * If we cannot find a cookie in our cache, we suspect that this is
 * because it points to a deleted file, so we ask the server to return
 * whatever it thinks is the next entry. We then feed this to filldir.
 * If all goes well, we should then be able to find our way round the
 * cache on the next call to readdir_search_pagecache();
 *
 * NOTE: we cannot add the anonymous page to the pagecache because
 *	 the data it contains might not be page aligned. Besides,
 *	 we should already have a complete representation of the
 *	 directory in the page cache by the time we get here.
 */
static inline
A
Al Viro 已提交
761
int uncached_readdir(nfs_readdir_descriptor_t *desc)
L
Linus Torvalds 已提交
762 763 764
{
	struct page	*page = NULL;
	int		status;
A
Al Viro 已提交
765
	struct inode *inode = file_inode(desc->file);
766
	struct nfs_open_dir_context *ctx = desc->file->private_data;
L
Linus Torvalds 已提交
767

C
Chuck Lever 已提交
768 769
	dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n",
			(unsigned long long)*desc->dir_cookie);
L
Linus Torvalds 已提交
770 771 772 773 774 775

	page = alloc_page(GFP_HIGHUSER);
	if (!page) {
		status = -ENOMEM;
		goto out;
	}
B
Bryan Schumaker 已提交
776

777
	desc->page_index = 0;
778
	desc->last_cookie = *desc->dir_cookie;
779
	desc->page = page;
780
	ctx->duped = 0;
781

782 783
	status = nfs_readdir_xdr_to_array(desc, page, inode);
	if (status < 0)
L
Linus Torvalds 已提交
784 785
		goto out_release;

A
Al Viro 已提交
786
	status = nfs_do_filldir(desc);
L
Linus Torvalds 已提交
787 788

 out:
C
Chuck Lever 已提交
789
	dfprintk(DIRCACHE, "NFS: %s: returns %d\n",
790
			__func__, status);
L
Linus Torvalds 已提交
791 792
	return status;
 out_release:
B
Bryan Schumaker 已提交
793
	cache_page_release(desc);
L
Linus Torvalds 已提交
794 795 796
	goto out;
}

797 798 799
/* The file offset position represents the dirent entry number.  A
   last cookie cache takes care of the common case of reading the
   whole directory.
L
Linus Torvalds 已提交
800
 */
A
Al Viro 已提交
801
static int nfs_readdir(struct file *file, struct dir_context *ctx)
L
Linus Torvalds 已提交
802
{
A
Al Viro 已提交
803
	struct dentry	*dentry = file->f_path.dentry;
L
Linus Torvalds 已提交
804 805 806
	struct inode	*inode = dentry->d_inode;
	nfs_readdir_descriptor_t my_desc,
			*desc = &my_desc;
A
Al Viro 已提交
807
	struct nfs_open_dir_context *dir_ctx = file->private_data;
T
Trond Myklebust 已提交
808
	int res;
L
Linus Torvalds 已提交
809

C
Chuck Lever 已提交
810
	dfprintk(FILE, "NFS: readdir(%s/%s) starting at cookie %llu\n",
C
Chuck Lever 已提交
811
			dentry->d_parent->d_name.name, dentry->d_name.name,
A
Al Viro 已提交
812
			(long long)ctx->pos);
C
Chuck Lever 已提交
813 814
	nfs_inc_stats(inode, NFSIOS_VFSGETDENTS);

L
Linus Torvalds 已提交
815
	/*
A
Al Viro 已提交
816
	 * ctx->pos points to the dirent entry number.
817
	 * *desc->dir_cookie has the cookie for the next entry. We have
818 819
	 * to either find the entry with the appropriate number or
	 * revalidate the cookie.
L
Linus Torvalds 已提交
820 821 822
	 */
	memset(desc, 0, sizeof(*desc));

A
Al Viro 已提交
823 824
	desc->file = file;
	desc->ctx = ctx;
825
	desc->dir_cookie = &dir_ctx->dir_cookie;
L
Linus Torvalds 已提交
826
	desc->decode = NFS_PROTO(inode)->decode_dirent;
A
Al Viro 已提交
827
	desc->plus = nfs_use_readdirplus(inode, ctx) ? 1 : 0;
L
Linus Torvalds 已提交
828

T
Trond Myklebust 已提交
829
	nfs_block_sillyrename(dentry);
A
Al Viro 已提交
830
	res = nfs_revalidate_mapping(inode, file->f_mapping);
T
Trond Myklebust 已提交
831 832 833
	if (res < 0)
		goto out;

T
Trond Myklebust 已提交
834
	do {
L
Linus Torvalds 已提交
835
		res = readdir_search_pagecache(desc);
836

L
Linus Torvalds 已提交
837
		if (res == -EBADCOOKIE) {
838
			res = 0;
L
Linus Torvalds 已提交
839
			/* This means either end of directory */
B
Bryan Schumaker 已提交
840
			if (*desc->dir_cookie && desc->eof == 0) {
L
Linus Torvalds 已提交
841
				/* Or that the server has 'lost' a cookie */
A
Al Viro 已提交
842
				res = uncached_readdir(desc);
843
				if (res == 0)
L
Linus Torvalds 已提交
844 845 846 847 848
					continue;
			}
			break;
		}
		if (res == -ETOOSMALL && desc->plus) {
B
Benny Halevy 已提交
849
			clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
L
Linus Torvalds 已提交
850
			nfs_zap_caches(inode);
851
			desc->page_index = 0;
L
Linus Torvalds 已提交
852
			desc->plus = 0;
B
Bryan Schumaker 已提交
853
			desc->eof = 0;
L
Linus Torvalds 已提交
854 855 856 857 858
			continue;
		}
		if (res < 0)
			break;

A
Al Viro 已提交
859
		res = nfs_do_filldir(desc);
860
		if (res < 0)
L
Linus Torvalds 已提交
861
			break;
T
Trond Myklebust 已提交
862
	} while (!desc->eof);
T
Trond Myklebust 已提交
863
out:
T
Trond Myklebust 已提交
864
	nfs_unblock_sillyrename(dentry);
C
Chuck Lever 已提交
865 866
	if (res > 0)
		res = 0;
867
	dfprintk(FILE, "NFS: readdir(%s/%s) returns %d\n",
C
Chuck Lever 已提交
868 869 870
			dentry->d_parent->d_name.name, dentry->d_name.name,
			res);
	return res;
L
Linus Torvalds 已提交
871 872
}

873
static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int whence)
874
{
875 876
	struct dentry *dentry = filp->f_path.dentry;
	struct inode *inode = dentry->d_inode;
877
	struct nfs_open_dir_context *dir_ctx = filp->private_data;
878

C
Chuck Lever 已提交
879
	dfprintk(FILE, "NFS: llseek dir(%s/%s, %lld, %d)\n",
880 881
			dentry->d_parent->d_name.name,
			dentry->d_name.name,
882
			offset, whence);
883 884

	mutex_lock(&inode->i_mutex);
885
	switch (whence) {
886 887 888 889 890 891 892 893 894 895 896
		case 1:
			offset += filp->f_pos;
		case 0:
			if (offset >= 0)
				break;
		default:
			offset = -EINVAL;
			goto out;
	}
	if (offset != filp->f_pos) {
		filp->f_pos = offset;
897
		dir_ctx->dir_cookie = 0;
898
		dir_ctx->duped = 0;
899 900
	}
out:
901
	mutex_unlock(&inode->i_mutex);
902 903 904
	return offset;
}

L
Linus Torvalds 已提交
905 906 907 908
/*
 * All directory operations under NFS are synchronous, so fsync()
 * is a dummy operation.
 */
909 910
static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end,
			 int datasync)
L
Linus Torvalds 已提交
911
{
912
	struct dentry *dentry = filp->f_path.dentry;
913
	struct inode *inode = dentry->d_inode;
914

C
Chuck Lever 已提交
915
	dfprintk(FILE, "NFS: fsync dir(%s/%s) datasync %d\n",
C
Chuck Lever 已提交
916 917 918
			dentry->d_parent->d_name.name, dentry->d_name.name,
			datasync);

919
	mutex_lock(&inode->i_mutex);
920
	nfs_inc_stats(dentry->d_inode, NFSIOS_VFSFSYNC);
921
	mutex_unlock(&inode->i_mutex);
L
Linus Torvalds 已提交
922 923 924
	return 0;
}

925 926 927 928 929 930 931 932 933 934 935 936
/**
 * nfs_force_lookup_revalidate - Mark the directory as having changed
 * @dir - pointer to directory inode
 *
 * This forces the revalidation code in nfs_lookup_revalidate() to do a
 * full lookup on all child dentries of 'dir' whenever a change occurs
 * on the server that might have invalidated our dcache.
 *
 * The caller should be holding dir->i_lock
 */
void nfs_force_lookup_revalidate(struct inode *dir)
{
937
	NFS_I(dir)->cache_change_attribute++;
938
}
B
Bryan Schumaker 已提交
939
EXPORT_SYMBOL_GPL(nfs_force_lookup_revalidate);
940

L
Linus Torvalds 已提交
941 942 943 944 945
/*
 * A check for whether or not the parent directory has changed.
 * In the case it has, we assume that the dentries are untrustworthy
 * and may need to be looked up again.
 */
946
static int nfs_check_verifier(struct inode *dir, struct dentry *dentry)
L
Linus Torvalds 已提交
947 948 949
{
	if (IS_ROOT(dentry))
		return 1;
950 951
	if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
		return 0;
952 953 954 955 956 957 958 959
	if (!nfs_verify_change_attribute(dir, dentry->d_time))
		return 0;
	/* Revalidate nfsi->cache_change_attribute before we declare a match */
	if (nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0)
		return 0;
	if (!nfs_verify_change_attribute(dir, dentry->d_time))
		return 0;
	return 1;
L
Linus Torvalds 已提交
960 961
}

962 963 964 965
/*
 * Use intent information to check whether or not we're going to do
 * an O_EXCL create using this path component.
 */
966
static int nfs_is_exclusive_create(struct inode *dir, unsigned int flags)
967 968 969
{
	if (NFS_PROTO(dir)->version == 2)
		return 0;
970
	return flags & LOOKUP_EXCL;
971 972
}

973 974 975 976 977 978 979 980
/*
 * Inode and filehandle revalidation for lookups.
 *
 * We force revalidation in the cases where the VFS sets LOOKUP_REVAL,
 * or if the intent information indicates that we're about to open this
 * particular file and the "nocto" mount flag is not set.
 *
 */
981
static
982
int nfs_lookup_verify_inode(struct inode *inode, unsigned int flags)
L
Linus Torvalds 已提交
983 984
{
	struct nfs_server *server = NFS_SERVER(inode);
985
	int ret;
L
Linus Torvalds 已提交
986

987
	if (IS_AUTOMOUNT(inode))
988
		return 0;
989
	/* VFS wants an on-the-wire revalidation */
990
	if (flags & LOOKUP_REVAL)
991 992
		goto out_force;
	/* This is an open(2) */
993 994
	if ((flags & LOOKUP_OPEN) && !(server->flags & NFS_MOUNT_NOCTO) &&
	    (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)))
995
		goto out_force;
996 997
out:
	return (inode->i_nlink == 0) ? -ENOENT : 0;
L
Linus Torvalds 已提交
998
out_force:
999 1000 1001 1002
	ret = __nfs_revalidate_inode(server, inode);
	if (ret != 0)
		return ret;
	goto out;
L
Linus Torvalds 已提交
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
}

/*
 * We judge how long we want to trust negative
 * dentries by looking at the parent inode mtime.
 *
 * If parent mtime has changed, we revalidate, else we wait for a
 * period corresponding to the parent's attribute cache timeout value.
 */
static inline
int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry,
1014
		       unsigned int flags)
L
Linus Torvalds 已提交
1015 1016
{
	/* Don't revalidate a negative dentry if we're creating a new file */
1017
	if (flags & LOOKUP_CREATE)
L
Linus Torvalds 已提交
1018
		return 0;
1019 1020
	if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG)
		return 1;
L
Linus Torvalds 已提交
1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034
	return !nfs_check_verifier(dir, dentry);
}

/*
 * This is called every time the dcache has a lookup hit,
 * and we should check whether we can really trust that
 * lookup.
 *
 * NOTE! The hit can be a negative hit too, don't assume
 * we have an inode!
 *
 * If the parent directory is seen to have changed, we throw out the
 * cached dentry and do a new lookup.
 */
1035
static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
L
Linus Torvalds 已提交
1036 1037 1038 1039
{
	struct inode *dir;
	struct inode *inode;
	struct dentry *parent;
1040 1041
	struct nfs_fh *fhandle = NULL;
	struct nfs_fattr *fattr = NULL;
L
Linus Torvalds 已提交
1042 1043
	int error;

1044
	if (flags & LOOKUP_RCU)
1045 1046
		return -ECHILD;

L
Linus Torvalds 已提交
1047 1048
	parent = dget_parent(dentry);
	dir = parent->d_inode;
C
Chuck Lever 已提交
1049
	nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE);
L
Linus Torvalds 已提交
1050 1051 1052
	inode = dentry->d_inode;

	if (!inode) {
1053
		if (nfs_neg_need_reval(dir, dentry, flags))
L
Linus Torvalds 已提交
1054
			goto out_bad;
1055
		goto out_valid_noent;
L
Linus Torvalds 已提交
1056 1057 1058
	}

	if (is_bad_inode(inode)) {
C
Chuck Lever 已提交
1059
		dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n",
1060
				__func__, dentry->d_parent->d_name.name,
C
Chuck Lever 已提交
1061
				dentry->d_name.name);
L
Linus Torvalds 已提交
1062 1063 1064
		goto out_bad;
	}

1065
	if (NFS_PROTO(dir)->have_delegation(inode, FMODE_READ))
1066 1067
		goto out_set_verifier;

L
Linus Torvalds 已提交
1068
	/* Force a full look up iff the parent directory has changed */
1069 1070
	if (!nfs_is_exclusive_create(dir, flags) && nfs_check_verifier(dir, dentry)) {
		if (nfs_lookup_verify_inode(inode, flags))
L
Linus Torvalds 已提交
1071 1072 1073 1074 1075 1076 1077
			goto out_zap_parent;
		goto out_valid;
	}

	if (NFS_STALE(inode))
		goto out_bad;

1078 1079 1080 1081 1082 1083
	error = -ENOMEM;
	fhandle = nfs_alloc_fhandle();
	fattr = nfs_alloc_fattr();
	if (fhandle == NULL || fattr == NULL)
		goto out_error;

1084
	error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
L
Linus Torvalds 已提交
1085 1086
	if (error)
		goto out_bad;
1087
	if (nfs_compare_fh(NFS_FH(inode), fhandle))
L
Linus Torvalds 已提交
1088
		goto out_bad;
1089
	if ((error = nfs_refresh_inode(inode, fattr)) != 0)
L
Linus Torvalds 已提交
1090 1091
		goto out_bad;

1092 1093
	nfs_free_fattr(fattr);
	nfs_free_fhandle(fhandle);
1094
out_set_verifier:
1095
	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
L
Linus Torvalds 已提交
1096
 out_valid:
1097 1098 1099
	/* Success: notify readdir to use READDIRPLUS */
	nfs_advise_use_readdirplus(dir);
 out_valid_noent:
L
Linus Torvalds 已提交
1100
	dput(parent);
C
Chuck Lever 已提交
1101
	dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is valid\n",
1102
			__func__, dentry->d_parent->d_name.name,
C
Chuck Lever 已提交
1103
			dentry->d_name.name);
L
Linus Torvalds 已提交
1104 1105 1106 1107
	return 1;
out_zap_parent:
	nfs_zap_caches(dir);
 out_bad:
A
Al Viro 已提交
1108 1109
	nfs_free_fattr(fattr);
	nfs_free_fhandle(fhandle);
1110
	nfs_mark_for_revalidate(dir);
L
Linus Torvalds 已提交
1111 1112 1113 1114 1115 1116
	if (inode && S_ISDIR(inode->i_mode)) {
		/* Purge readdir caches. */
		nfs_zap_caches(inode);
		/* If we have submounts, don't unhash ! */
		if (have_submounts(dentry))
			goto out_valid;
1117 1118
		if (dentry->d_flags & DCACHE_DISCONNECTED)
			goto out_valid;
L
Linus Torvalds 已提交
1119 1120 1121 1122
		shrink_dcache_parent(dentry);
	}
	d_drop(dentry);
	dput(parent);
C
Chuck Lever 已提交
1123
	dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n",
1124
			__func__, dentry->d_parent->d_name.name,
C
Chuck Lever 已提交
1125
			dentry->d_name.name);
L
Linus Torvalds 已提交
1126
	return 0;
1127 1128 1129 1130 1131 1132 1133 1134
out_error:
	nfs_free_fattr(fattr);
	nfs_free_fhandle(fhandle);
	dput(parent);
	dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) lookup returned error %d\n",
			__func__, dentry->d_parent->d_name.name,
			dentry->d_name.name, error);
	return error;
L
Linus Torvalds 已提交
1135 1136
}

1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175
/*
 * A weaker form of d_revalidate for revalidating just the dentry->d_inode
 * when we don't really care about the dentry name. This is called when a
 * pathwalk ends on a dentry that was not found via a normal lookup in the
 * parent dir (e.g.: ".", "..", procfs symlinks or mountpoint traversals).
 *
 * In this situation, we just want to verify that the inode itself is OK
 * since the dentry might have changed on the server.
 */
static int nfs_weak_revalidate(struct dentry *dentry, unsigned int flags)
{
	int error;
	struct inode *inode = dentry->d_inode;

	/*
	 * I believe we can only get a negative dentry here in the case of a
	 * procfs-style symlink. Just assume it's correct for now, but we may
	 * eventually need to do something more here.
	 */
	if (!inode) {
		dfprintk(LOOKUPCACHE, "%s: %s/%s has negative inode\n",
				__func__, dentry->d_parent->d_name.name,
				dentry->d_name.name);
		return 1;
	}

	if (is_bad_inode(inode)) {
		dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n",
				__func__, dentry->d_parent->d_name.name,
				dentry->d_name.name);
		return 0;
	}

	error = nfs_revalidate_inode(NFS_SERVER(inode), inode);
	dfprintk(LOOKUPCACHE, "NFS: %s: inode %lu is %s\n",
			__func__, inode->i_ino, error ? "invalid" : "valid");
	return !error;
}

L
Linus Torvalds 已提交
1176 1177 1178
/*
 * This is called from dput() when d_count is going to 0.
 */
N
Nick Piggin 已提交
1179
static int nfs_dentry_delete(const struct dentry *dentry)
L
Linus Torvalds 已提交
1180 1181 1182 1183 1184
{
	dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)\n",
		dentry->d_parent->d_name.name, dentry->d_name.name,
		dentry->d_flags);

1185 1186 1187 1188
	/* Unhash any dentry with a stale inode */
	if (dentry->d_inode != NULL && NFS_STALE(dentry->d_inode))
		return 1;

L
Linus Torvalds 已提交
1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201
	if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
		/* Unhash it, so that ->d_iput() would be called */
		return 1;
	}
	if (!(dentry->d_sb->s_flags & MS_ACTIVE)) {
		/* Unhash it, so that ancestors of killed async unlink
		 * files will be cleaned up during umount */
		return 1;
	}
	return 0;

}

T
Trond Myklebust 已提交
1202
/* Ensure that we revalidate inode->i_nlink */
1203 1204 1205
static void nfs_drop_nlink(struct inode *inode)
{
	spin_lock(&inode->i_lock);
T
Trond Myklebust 已提交
1206 1207 1208 1209
	/* drop the inode if we're reasonably sure this is the last link */
	if (inode->i_nlink == 1)
		clear_nlink(inode);
	NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;
1210 1211 1212
	spin_unlock(&inode->i_lock);
}

L
Linus Torvalds 已提交
1213 1214 1215 1216 1217 1218
/*
 * Called when the dentry loses inode.
 * We use it to clean up silly-renamed files.
 */
static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode)
{
1219 1220 1221 1222
	if (S_ISDIR(inode->i_mode))
		/* drop any readdir cache as it could easily be old */
		NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;

L
Linus Torvalds 已提交
1223
	if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1224
		nfs_complete_unlink(dentry, inode);
T
Trond Myklebust 已提交
1225
		nfs_drop_nlink(inode);
L
Linus Torvalds 已提交
1226 1227 1228 1229
	}
	iput(inode);
}

1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240
static void nfs_d_release(struct dentry *dentry)
{
	/* free cached devname value, if it survived that far */
	if (unlikely(dentry->d_fsdata)) {
		if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
			WARN_ON(1);
		else
			kfree(dentry->d_fsdata);
	}
}

A
Al Viro 已提交
1241
const struct dentry_operations nfs_dentry_operations = {
L
Linus Torvalds 已提交
1242
	.d_revalidate	= nfs_lookup_revalidate,
1243
	.d_weak_revalidate	= nfs_weak_revalidate,
L
Linus Torvalds 已提交
1244 1245
	.d_delete	= nfs_dentry_delete,
	.d_iput		= nfs_dentry_iput,
1246
	.d_automount	= nfs_d_automount,
1247
	.d_release	= nfs_d_release,
L
Linus Torvalds 已提交
1248
};
B
Bryan Schumaker 已提交
1249
EXPORT_SYMBOL_GPL(nfs_dentry_operations);
L
Linus Torvalds 已提交
1250

1251
struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
L
Linus Torvalds 已提交
1252 1253
{
	struct dentry *res;
T
Trond Myklebust 已提交
1254
	struct dentry *parent;
L
Linus Torvalds 已提交
1255
	struct inode *inode = NULL;
1256 1257
	struct nfs_fh *fhandle = NULL;
	struct nfs_fattr *fattr = NULL;
L
Linus Torvalds 已提交
1258 1259 1260 1261
	int error;

	dfprintk(VFS, "NFS: lookup(%s/%s)\n",
		dentry->d_parent->d_name.name, dentry->d_name.name);
C
Chuck Lever 已提交
1262
	nfs_inc_stats(dir, NFSIOS_VFSLOOKUP);
L
Linus Torvalds 已提交
1263 1264 1265 1266 1267

	res = ERR_PTR(-ENAMETOOLONG);
	if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
		goto out;

1268 1269 1270 1271
	/*
	 * If we're doing an exclusive create, optimize away the lookup
	 * but don't hash the dentry.
	 */
A
Al Viro 已提交
1272
	if (nfs_is_exclusive_create(dir, flags)) {
1273 1274
		d_instantiate(dentry, NULL);
		res = NULL;
1275
		goto out;
1276
	}
L
Linus Torvalds 已提交
1277

1278 1279 1280 1281 1282 1283
	res = ERR_PTR(-ENOMEM);
	fhandle = nfs_alloc_fhandle();
	fattr = nfs_alloc_fattr();
	if (fhandle == NULL || fattr == NULL)
		goto out;

T
Trond Myklebust 已提交
1284 1285 1286
	parent = dentry->d_parent;
	/* Protect against concurrent sillydeletes */
	nfs_block_sillyrename(parent);
1287
	error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
L
Linus Torvalds 已提交
1288 1289 1290 1291
	if (error == -ENOENT)
		goto no_entry;
	if (error < 0) {
		res = ERR_PTR(error);
T
Trond Myklebust 已提交
1292
		goto out_unblock_sillyrename;
L
Linus Torvalds 已提交
1293
	}
1294
	inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
N
Namhyung Kim 已提交
1295
	res = ERR_CAST(inode);
1296
	if (IS_ERR(res))
T
Trond Myklebust 已提交
1297
		goto out_unblock_sillyrename;
1298

1299 1300 1301
	/* Success: notify readdir to use READDIRPLUS */
	nfs_advise_use_readdirplus(dir);

L
Linus Torvalds 已提交
1302
no_entry:
1303
	res = d_materialise_unique(dentry, inode);
1304 1305
	if (res != NULL) {
		if (IS_ERR(res))
T
Trond Myklebust 已提交
1306
			goto out_unblock_sillyrename;
L
Linus Torvalds 已提交
1307
		dentry = res;
1308
	}
L
Linus Torvalds 已提交
1309
	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
T
Trond Myklebust 已提交
1310 1311
out_unblock_sillyrename:
	nfs_unblock_sillyrename(parent);
L
Linus Torvalds 已提交
1312
out:
1313 1314
	nfs_free_fattr(fattr);
	nfs_free_fhandle(fhandle);
L
Linus Torvalds 已提交
1315 1316
	return res;
}
B
Bryan Schumaker 已提交
1317
EXPORT_SYMBOL_GPL(nfs_lookup);
L
Linus Torvalds 已提交
1318

B
Bryan Schumaker 已提交
1319
#if IS_ENABLED(CONFIG_NFS_V4)
1320
static int nfs4_lookup_revalidate(struct dentry *, unsigned int);
L
Linus Torvalds 已提交
1321

A
Al Viro 已提交
1322
const struct dentry_operations nfs4_dentry_operations = {
1323
	.d_revalidate	= nfs4_lookup_revalidate,
L
Linus Torvalds 已提交
1324 1325
	.d_delete	= nfs_dentry_delete,
	.d_iput		= nfs_dentry_iput,
1326
	.d_automount	= nfs_d_automount,
1327
	.d_release	= nfs_d_release,
L
Linus Torvalds 已提交
1328
};
B
Bryan Schumaker 已提交
1329
EXPORT_SYMBOL_GPL(nfs4_dentry_operations);
L
Linus Torvalds 已提交
1330

1331 1332 1333 1334 1335 1336 1337 1338 1339 1340
static fmode_t flags_to_mode(int flags)
{
	fmode_t res = (__force fmode_t)flags & FMODE_EXEC;
	if ((flags & O_ACCMODE) != O_WRONLY)
		res |= FMODE_READ;
	if ((flags & O_ACCMODE) != O_RDONLY)
		res |= FMODE_WRITE;
	return res;
}

1341
static struct nfs_open_context *create_nfs_open_context(struct dentry *dentry, int open_flags)
1342
{
1343
	return alloc_nfs_open_context(dentry, flags_to_mode(open_flags));
1344 1345 1346 1347 1348 1349 1350 1351
}

static int do_open(struct inode *inode, struct file *filp)
{
	nfs_fscache_set_inode_cookie(inode, filp);
	return 0;
}

A
Al Viro 已提交
1352 1353
static int nfs_finish_open(struct nfs_open_context *ctx,
			   struct dentry *dentry,
A
Al Viro 已提交
1354
			   struct file *file, unsigned open_flags,
A
Al Viro 已提交
1355
			   int *opened)
1356
{
1357 1358 1359 1360 1361 1362
	int err;

	if (ctx->dentry != dentry) {
		dput(ctx->dentry);
		ctx->dentry = dget(dentry);
	}
1363 1364 1365

	/* If the open_intent is for execute, we have an extra check to make */
	if (ctx->mode & FMODE_EXEC) {
1366
		err = nfs_may_open(dentry->d_inode, ctx->cred, open_flags);
A
Al Viro 已提交
1367
		if (err < 0)
1368 1369
			goto out;
	}
1370

A
Al Viro 已提交
1371 1372
	err = finish_open(file, dentry, do_open, opened);
	if (err)
A
Al Viro 已提交
1373
		goto out;
A
Al Viro 已提交
1374
	nfs_file_set_open_context(file, ctx);
1375

1376 1377
out:
	put_nfs_open_context(ctx);
A
Al Viro 已提交
1378
	return err;
1379 1380
}

1381 1382 1383
int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
		    struct file *file, unsigned open_flags,
		    umode_t mode, int *opened)
L
Linus Torvalds 已提交
1384
{
1385
	struct nfs_open_context *ctx;
1386 1387
	struct dentry *res;
	struct iattr attr = { .ia_valid = ATTR_OPEN };
1388
	struct inode *inode;
1389
	int err;
L
Linus Torvalds 已提交
1390

1391 1392 1393 1394
	/* Expect a negative dentry */
	BUG_ON(dentry->d_inode);

	dfprintk(VFS, "NFS: atomic_open(%s/%ld), %s\n",
C
Chuck Lever 已提交
1395 1396
			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);

1397 1398 1399 1400 1401 1402 1403 1404
	/* NFS only supports OPEN on regular files */
	if ((open_flags & O_DIRECTORY)) {
		if (!d_unhashed(dentry)) {
			/*
			 * Hashed negative dentry with O_DIRECTORY: dentry was
			 * revalidated and is fine, no need to perform lookup
			 * again
			 */
A
Al Viro 已提交
1405
			return -ENOENT;
1406
		}
L
Linus Torvalds 已提交
1407
		goto no_open;
1408
	}
L
Linus Torvalds 已提交
1409

1410
	if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
A
Al Viro 已提交
1411
		return -ENAMETOOLONG;
1412

1413
	if (open_flags & O_CREAT) {
1414
		attr.ia_valid |= ATTR_MODE;
1415 1416
		attr.ia_mode = mode & ~current_umask();
	}
1417 1418 1419
	if (open_flags & O_TRUNC) {
		attr.ia_valid |= ATTR_SIZE;
		attr.ia_size = 0;
1420 1421
	}

1422 1423 1424
	ctx = create_nfs_open_context(dentry, open_flags);
	err = PTR_ERR(ctx);
	if (IS_ERR(ctx))
A
Al Viro 已提交
1425
		goto out;
1426

1427
	nfs_block_sillyrename(dentry->d_parent);
1428
	inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr);
1429
	d_drop(dentry);
1430 1431
	if (IS_ERR(inode)) {
		nfs_unblock_sillyrename(dentry->d_parent);
1432
		put_nfs_open_context(ctx);
1433 1434 1435 1436 1437 1438 1439 1440 1441 1442
		err = PTR_ERR(inode);
		switch (err) {
		case -ENOENT:
			d_add(dentry, NULL);
			break;
		case -EISDIR:
		case -ENOTDIR:
			goto no_open;
		case -ELOOP:
			if (!(open_flags & O_NOFOLLOW))
1443
				goto no_open;
1444
			break;
L
Linus Torvalds 已提交
1445
			/* case -EINVAL: */
1446 1447
		default:
			break;
L
Linus Torvalds 已提交
1448
		}
A
Al Viro 已提交
1449
		goto out;
1450
	}
1451
	res = d_add_unique(dentry, inode);
1452
	if (res != NULL)
L
Linus Torvalds 已提交
1453
		dentry = res;
1454 1455

	nfs_unblock_sillyrename(dentry->d_parent);
1456
	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1457

A
Al Viro 已提交
1458
	err = nfs_finish_open(ctx, dentry, file, open_flags, opened);
1459 1460

	dput(res);
A
Al Viro 已提交
1461 1462
out:
	return err;
1463

L
Linus Torvalds 已提交
1464
no_open:
A
Al Viro 已提交
1465
	res = nfs_lookup(dir, dentry, 0);
1466 1467
	err = PTR_ERR(res);
	if (IS_ERR(res))
A
Al Viro 已提交
1468
		goto out;
1469

A
Al Viro 已提交
1470
	return finish_no_open(file, res);
L
Linus Torvalds 已提交
1471
}
B
Bryan Schumaker 已提交
1472
EXPORT_SYMBOL_GPL(nfs_atomic_open);
L
Linus Torvalds 已提交
1473

1474
static int nfs4_lookup_revalidate(struct dentry *dentry, unsigned int flags)
L
Linus Torvalds 已提交
1475 1476
{
	struct dentry *parent = NULL;
N
Nick Piggin 已提交
1477
	struct inode *inode;
L
Linus Torvalds 已提交
1478
	struct inode *dir;
1479
	int ret = 0;
L
Linus Torvalds 已提交
1480

1481
	if (flags & LOOKUP_RCU)
N
Nick Piggin 已提交
1482 1483
		return -ECHILD;

1484
	if (!(flags & LOOKUP_OPEN) || (flags & LOOKUP_DIRECTORY))
1485 1486
		goto no_open;
	if (d_mountpoint(dentry))
T
Trond Myklebust 已提交
1487
		goto no_open;
1488 1489
	if (NFS_SB(dentry->d_sb)->caps & NFS_CAP_ATOMIC_OPEN_V1)
		goto no_open;
1490

1491
	inode = dentry->d_inode;
L
Linus Torvalds 已提交
1492 1493
	parent = dget_parent(dentry);
	dir = parent->d_inode;
1494

L
Linus Torvalds 已提交
1495 1496 1497
	/* We can't create new files in nfs_open_revalidate(), so we
	 * optimize away revalidation of negative dentries.
	 */
1498
	if (inode == NULL) {
1499
		if (!nfs_neg_need_reval(dir, dentry, flags))
1500
			ret = 1;
L
Linus Torvalds 已提交
1501
		goto out;
1502 1503
	}

L
Linus Torvalds 已提交
1504 1505
	/* NFS only supports OPEN on regular files */
	if (!S_ISREG(inode->i_mode))
T
Trond Myklebust 已提交
1506
		goto no_open_dput;
L
Linus Torvalds 已提交
1507
	/* We cannot do exclusive creation on a positive dentry */
1508
	if (flags & LOOKUP_EXCL)
T
Trond Myklebust 已提交
1509
		goto no_open_dput;
L
Linus Torvalds 已提交
1510

1511 1512
	/* Let f_op->open() actually open (and revalidate) the file */
	ret = 1;
1513

L
Linus Torvalds 已提交
1514 1515 1516
out:
	dput(parent);
	return ret;
1517

T
Trond Myklebust 已提交
1518
no_open_dput:
L
Linus Torvalds 已提交
1519
	dput(parent);
T
Trond Myklebust 已提交
1520
no_open:
1521
	return nfs_lookup_revalidate(dentry, flags);
1522 1523
}

L
Linus Torvalds 已提交
1524 1525 1526 1527 1528 1529 1530 1531
#endif /* CONFIG_NFSV4 */

/*
 * Code common to create, mkdir, and mknod.
 */
int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
				struct nfs_fattr *fattr)
{
1532 1533
	struct dentry *parent = dget_parent(dentry);
	struct inode *dir = parent->d_inode;
L
Linus Torvalds 已提交
1534 1535 1536
	struct inode *inode;
	int error = -EACCES;

1537 1538
	d_drop(dentry);

L
Linus Torvalds 已提交
1539 1540
	/* We may have been initialized further down */
	if (dentry->d_inode)
1541
		goto out;
L
Linus Torvalds 已提交
1542
	if (fhandle->size == 0) {
1543
		error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
L
Linus Torvalds 已提交
1544
		if (error)
1545
			goto out_error;
L
Linus Torvalds 已提交
1546
	}
1547
	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
L
Linus Torvalds 已提交
1548 1549
	if (!(fattr->valid & NFS_ATTR_FATTR)) {
		struct nfs_server *server = NFS_SB(dentry->d_sb);
1550
		error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr);
L
Linus Torvalds 已提交
1551
		if (error < 0)
1552
			goto out_error;
L
Linus Torvalds 已提交
1553 1554
	}
	inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
1555 1556
	error = PTR_ERR(inode);
	if (IS_ERR(inode))
1557 1558 1559 1560
		goto out_error;
	d_add(dentry, inode);
out:
	dput(parent);
L
Linus Torvalds 已提交
1561
	return 0;
1562 1563 1564 1565
out_error:
	nfs_mark_for_revalidate(dir);
	dput(parent);
	return error;
L
Linus Torvalds 已提交
1566
}
B
Bryan Schumaker 已提交
1567
EXPORT_SYMBOL_GPL(nfs_instantiate);
L
Linus Torvalds 已提交
1568 1569 1570 1571 1572 1573 1574

/*
 * Following a failed create operation, we drop the dentry rather
 * than retain a negative dentry. This avoids a problem in the event
 * that the operation succeeded on the server, but an error in the
 * reply path made it appear to have failed.
 */
1575
int nfs_create(struct inode *dir, struct dentry *dentry,
A
Al Viro 已提交
1576
		umode_t mode, bool excl)
L
Linus Torvalds 已提交
1577 1578
{
	struct iattr attr;
A
Al Viro 已提交
1579
	int open_flags = excl ? O_CREAT | O_EXCL : O_CREAT;
L
Linus Torvalds 已提交
1580 1581
	int error;

C
Chuck Lever 已提交
1582 1583
	dfprintk(VFS, "NFS: create(%s/%ld), %s\n",
			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
L
Linus Torvalds 已提交
1584 1585 1586 1587

	attr.ia_mode = mode;
	attr.ia_valid = ATTR_MODE;

1588
	error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags);
L
Linus Torvalds 已提交
1589 1590 1591 1592 1593 1594 1595
	if (error != 0)
		goto out_err;
	return 0;
out_err:
	d_drop(dentry);
	return error;
}
B
Bryan Schumaker 已提交
1596
EXPORT_SYMBOL_GPL(nfs_create);
L
Linus Torvalds 已提交
1597 1598 1599 1600

/*
 * See comments for nfs_proc_create regarding failed operations.
 */
1601
int
A
Al Viro 已提交
1602
nfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
L
Linus Torvalds 已提交
1603 1604 1605 1606
{
	struct iattr attr;
	int status;

C
Chuck Lever 已提交
1607 1608
	dfprintk(VFS, "NFS: mknod(%s/%ld), %s\n",
			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
L
Linus Torvalds 已提交
1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623

	if (!new_valid_dev(rdev))
		return -EINVAL;

	attr.ia_mode = mode;
	attr.ia_valid = ATTR_MODE;

	status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev);
	if (status != 0)
		goto out_err;
	return 0;
out_err:
	d_drop(dentry);
	return status;
}
B
Bryan Schumaker 已提交
1624
EXPORT_SYMBOL_GPL(nfs_mknod);
L
Linus Torvalds 已提交
1625 1626 1627 1628

/*
 * See comments for nfs_proc_create regarding failed operations.
 */
1629
int nfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
L
Linus Torvalds 已提交
1630 1631 1632 1633
{
	struct iattr attr;
	int error;

C
Chuck Lever 已提交
1634 1635
	dfprintk(VFS, "NFS: mkdir(%s/%ld), %s\n",
			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
L
Linus Torvalds 已提交
1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647

	attr.ia_valid = ATTR_MODE;
	attr.ia_mode = mode | S_IFDIR;

	error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr);
	if (error != 0)
		goto out_err;
	return 0;
out_err:
	d_drop(dentry);
	return error;
}
B
Bryan Schumaker 已提交
1648
EXPORT_SYMBOL_GPL(nfs_mkdir);
L
Linus Torvalds 已提交
1649

1650 1651 1652 1653 1654 1655
static void nfs_dentry_handle_enoent(struct dentry *dentry)
{
	if (dentry->d_inode != NULL && !d_unhashed(dentry))
		d_delete(dentry);
}

1656
int nfs_rmdir(struct inode *dir, struct dentry *dentry)
L
Linus Torvalds 已提交
1657 1658 1659
{
	int error;

C
Chuck Lever 已提交
1660 1661
	dfprintk(VFS, "NFS: rmdir(%s/%ld), %s\n",
			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
L
Linus Torvalds 已提交
1662 1663 1664 1665

	error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
	/* Ensure the VFS deletes this inode */
	if (error == 0 && dentry->d_inode != NULL)
1666
		clear_nlink(dentry->d_inode);
1667 1668
	else if (error == -ENOENT)
		nfs_dentry_handle_enoent(dentry);
L
Linus Torvalds 已提交
1669 1670 1671

	return error;
}
B
Bryan Schumaker 已提交
1672
EXPORT_SYMBOL_GPL(nfs_rmdir);
L
Linus Torvalds 已提交
1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696

/*
 * Remove a file after making sure there are no pending writes,
 * and after checking that the file has only one user. 
 *
 * We invalidate the attribute cache and free the inode prior to the operation
 * to avoid possible races if the server reuses the inode.
 */
static int nfs_safe_remove(struct dentry *dentry)
{
	struct inode *dir = dentry->d_parent->d_inode;
	struct inode *inode = dentry->d_inode;
	int error = -EBUSY;
		
	dfprintk(VFS, "NFS: safe_remove(%s/%s)\n",
		dentry->d_parent->d_name.name, dentry->d_name.name);

	/* If the dentry was sillyrenamed, we simply call d_delete() */
	if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
		error = 0;
		goto out;
	}

	if (inode != NULL) {
1697
		NFS_PROTO(inode)->return_delegation(inode);
L
Linus Torvalds 已提交
1698 1699
		error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
		if (error == 0)
1700
			nfs_drop_nlink(inode);
L
Linus Torvalds 已提交
1701 1702
	} else
		error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
1703 1704
	if (error == -ENOENT)
		nfs_dentry_handle_enoent(dentry);
L
Linus Torvalds 已提交
1705 1706 1707 1708 1709 1710 1711 1712 1713
out:
	return error;
}

/*  We do silly rename. In case sillyrename() returns -EBUSY, the inode
 *  belongs to an active ".nfs..." file and we return -EBUSY.
 *
 *  If sillyrename() returns 0, we do nothing, otherwise we unlink.
 */
1714
int nfs_unlink(struct inode *dir, struct dentry *dentry)
L
Linus Torvalds 已提交
1715 1716 1717 1718 1719 1720 1721 1722
{
	int error;
	int need_rehash = 0;

	dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id,
		dir->i_ino, dentry->d_name.name);

	spin_lock(&dentry->d_lock);
N
Nick Piggin 已提交
1723
	if (dentry->d_count > 1) {
L
Linus Torvalds 已提交
1724
		spin_unlock(&dentry->d_lock);
T
Trond Myklebust 已提交
1725 1726
		/* Start asynchronous writeout of the inode */
		write_inode_now(dentry->d_inode, 0);
L
Linus Torvalds 已提交
1727 1728 1729 1730 1731 1732 1733 1734 1735
		error = nfs_sillyrename(dir, dentry);
		return error;
	}
	if (!d_unhashed(dentry)) {
		__d_drop(dentry);
		need_rehash = 1;
	}
	spin_unlock(&dentry->d_lock);
	error = nfs_safe_remove(dentry);
1736
	if (!error || error == -ENOENT) {
L
Linus Torvalds 已提交
1737 1738 1739 1740 1741
		nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
	} else if (need_rehash)
		d_rehash(dentry);
	return error;
}
B
Bryan Schumaker 已提交
1742
EXPORT_SYMBOL_GPL(nfs_unlink);
L
Linus Torvalds 已提交
1743

1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758
/*
 * To create a symbolic link, most file systems instantiate a new inode,
 * add a page to it containing the path, then write it out to the disk
 * using prepare_write/commit_write.
 *
 * Unfortunately the NFS client can't create the in-core inode first
 * because it needs a file handle to create an in-core inode (see
 * fs/nfs/inode.c:nfs_fhget).  We only have a file handle *after* the
 * symlink request has completed on the server.
 *
 * So instead we allocate a raw page, copy the symname into it, then do
 * the SYMLINK request with the page as the buffer.  If it succeeds, we
 * now have a new file handle and can instantiate an in-core NFS inode
 * and move the raw page into its mapping.
 */
1759
int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
L
Linus Torvalds 已提交
1760
{
1761 1762 1763
	struct pagevec lru_pvec;
	struct page *page;
	char *kaddr;
L
Linus Torvalds 已提交
1764
	struct iattr attr;
1765
	unsigned int pathlen = strlen(symname);
L
Linus Torvalds 已提交
1766 1767 1768 1769 1770
	int error;

	dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id,
		dir->i_ino, dentry->d_name.name, symname);

1771 1772
	if (pathlen > PAGE_SIZE)
		return -ENAMETOOLONG;
L
Linus Torvalds 已提交
1773

1774 1775
	attr.ia_mode = S_IFLNK | S_IRWXUGO;
	attr.ia_valid = ATTR_MODE;
L
Linus Torvalds 已提交
1776

1777
	page = alloc_page(GFP_HIGHUSER);
1778
	if (!page)
1779 1780
		return -ENOMEM;

1781
	kaddr = kmap_atomic(page);
1782 1783 1784
	memcpy(kaddr, symname, pathlen);
	if (pathlen < PAGE_SIZE)
		memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen);
1785
	kunmap_atomic(kaddr);
1786

1787
	error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr);
1788 1789 1790 1791
	if (error != 0) {
		dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s) error %d\n",
			dir->i_sb->s_id, dir->i_ino,
			dentry->d_name.name, symname, error);
L
Linus Torvalds 已提交
1792
		d_drop(dentry);
1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803
		__free_page(page);
		return error;
	}

	/*
	 * No big deal if we can't add this page to the page cache here.
	 * READLINK will get the missing page from the server if needed.
	 */
	pagevec_init(&lru_pvec, 0);
	if (!add_to_page_cache(page, dentry->d_inode->i_mapping, 0,
							GFP_KERNEL)) {
1804
		pagevec_add(&lru_pvec, page);
1805
		pagevec_lru_add_file(&lru_pvec);
1806 1807 1808 1809 1810 1811
		SetPageUptodate(page);
		unlock_page(page);
	} else
		__free_page(page);

	return 0;
L
Linus Torvalds 已提交
1812
}
B
Bryan Schumaker 已提交
1813
EXPORT_SYMBOL_GPL(nfs_symlink);
L
Linus Torvalds 已提交
1814

1815
int
L
Linus Torvalds 已提交
1816 1817 1818 1819 1820 1821 1822 1823 1824
nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
{
	struct inode *inode = old_dentry->d_inode;
	int error;

	dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n",
		old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
		dentry->d_parent->d_name.name, dentry->d_name.name);

1825
	NFS_PROTO(inode)->return_delegation(inode);
1826

1827
	d_drop(dentry);
L
Linus Torvalds 已提交
1828
	error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name);
1829
	if (error == 0) {
A
Al Viro 已提交
1830
		ihold(inode);
1831
		d_add(dentry, inode);
1832
	}
L
Linus Torvalds 已提交
1833 1834
	return error;
}
B
Bryan Schumaker 已提交
1835
EXPORT_SYMBOL_GPL(nfs_link);
L
Linus Torvalds 已提交
1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860

/*
 * RENAME
 * FIXME: Some nfsds, like the Linux user space nfsd, may generate a
 * different file handle for the same inode after a rename (e.g. when
 * moving to a different directory). A fail-safe method to do so would
 * be to look up old_dir/old_name, create a link to new_dir/new_name and
 * rename the old file using the sillyrename stuff. This way, the original
 * file in old_dir will go away when the last process iput()s the inode.
 *
 * FIXED.
 * 
 * It actually works quite well. One needs to have the possibility for
 * at least one ".nfs..." file in each directory the file ever gets
 * moved or linked to which happens automagically with the new
 * implementation that only depends on the dcache stuff instead of
 * using the inode layer
 *
 * Unfortunately, things are a little more complicated than indicated
 * above. For a cross-directory move, we want to make sure we can get
 * rid of the old inode after the operation.  This means there must be
 * no pending writes (if it's a file), and the use count must be 1.
 * If these conditions are met, we can drop the dentries before doing
 * the rename.
 */
1861
int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
L
Linus Torvalds 已提交
1862 1863 1864 1865 1866 1867 1868 1869 1870 1871
		      struct inode *new_dir, struct dentry *new_dentry)
{
	struct inode *old_inode = old_dentry->d_inode;
	struct inode *new_inode = new_dentry->d_inode;
	struct dentry *dentry = NULL, *rehash = NULL;
	int error = -EBUSY;

	dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n",
		 old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
		 new_dentry->d_parent->d_name.name, new_dentry->d_name.name,
N
Nick Piggin 已提交
1872
		 new_dentry->d_count);
L
Linus Torvalds 已提交
1873 1874

	/*
M
Miklos Szeredi 已提交
1875 1876 1877 1878
	 * For non-directories, check whether the target is busy and if so,
	 * make a copy of the dentry and then do a silly-rename. If the
	 * silly-rename succeeds, the copied dentry is hashed and becomes
	 * the new target.
L
Linus Torvalds 已提交
1879
	 */
1880 1881 1882 1883 1884 1885 1886 1887 1888
	if (new_inode && !S_ISDIR(new_inode->i_mode)) {
		/*
		 * To prevent any new references to the target during the
		 * rename, we unhash the dentry in advance.
		 */
		if (!d_unhashed(new_dentry)) {
			d_drop(new_dentry);
			rehash = new_dentry;
		}
L
Linus Torvalds 已提交
1889

N
Nick Piggin 已提交
1890
		if (new_dentry->d_count > 2) {
1891 1892 1893 1894 1895 1896 1897 1898 1899 1900
			int err;

			/* copy the target dentry's name */
			dentry = d_alloc(new_dentry->d_parent,
					 &new_dentry->d_name);
			if (!dentry)
				goto out;

			/* silly-rename the existing target ... */
			err = nfs_sillyrename(new_dir, new_dentry);
1901
			if (err)
1902
				goto out;
1903 1904

			new_dentry = dentry;
O
OGAWA Hirofumi 已提交
1905
			rehash = NULL;
1906
			new_inode = NULL;
1907
		}
1908
	}
L
Linus Torvalds 已提交
1909

1910
	NFS_PROTO(old_inode)->return_delegation(old_inode);
1911
	if (new_inode != NULL)
1912
		NFS_PROTO(new_inode)->return_delegation(new_inode);
L
Linus Torvalds 已提交
1913 1914 1915

	error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name,
					   new_dir, &new_dentry->d_name);
1916
	nfs_mark_for_revalidate(old_inode);
L
Linus Torvalds 已提交
1917 1918 1919 1920
out:
	if (rehash)
		d_rehash(rehash);
	if (!error) {
1921 1922
		if (new_inode != NULL)
			nfs_drop_nlink(new_inode);
1923
		d_move(old_dentry, new_dentry);
1924 1925
		nfs_set_verifier(new_dentry,
					nfs_save_change_attribute(new_dir));
1926 1927
	} else if (error == -ENOENT)
		nfs_dentry_handle_enoent(old_dentry);
L
Linus Torvalds 已提交
1928 1929 1930 1931 1932 1933

	/* new dentry created? */
	if (dentry)
		dput(dentry);
	return error;
}
B
Bryan Schumaker 已提交
1934
EXPORT_SYMBOL_GPL(nfs_rename);
L
Linus Torvalds 已提交
1935

1936 1937 1938 1939
static DEFINE_SPINLOCK(nfs_access_lru_lock);
static LIST_HEAD(nfs_access_lru_list);
static atomic_long_t nfs_access_nr_entries;

1940 1941 1942 1943
static void nfs_access_free_entry(struct nfs_access_entry *entry)
{
	put_rpccred(entry->cred);
	kfree(entry);
1944 1945 1946
	smp_mb__before_atomic_dec();
	atomic_long_dec(&nfs_access_nr_entries);
	smp_mb__after_atomic_dec();
1947 1948
}

1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959
static void nfs_access_free_list(struct list_head *head)
{
	struct nfs_access_entry *cache;

	while (!list_empty(head)) {
		cache = list_entry(head->next, struct nfs_access_entry, lru);
		list_del(&cache->lru);
		nfs_access_free_entry(cache);
	}
}

1960 1961
int nfs_access_cache_shrinker(struct shrinker *shrink,
			      struct shrink_control *sc)
1962 1963
{
	LIST_HEAD(head);
1964
	struct nfs_inode *nfsi, *next;
1965
	struct nfs_access_entry *cache;
1966 1967
	int nr_to_scan = sc->nr_to_scan;
	gfp_t gfp_mask = sc->gfp_mask;
1968

1969 1970
	if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL)
		return (nr_to_scan == 0) ? 0 : -1;
1971

1972
	spin_lock(&nfs_access_lru_lock);
1973
	list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) {
1974 1975 1976 1977
		struct inode *inode;

		if (nr_to_scan-- == 0)
			break;
1978
		inode = &nfsi->vfs_inode;
1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991
		spin_lock(&inode->i_lock);
		if (list_empty(&nfsi->access_cache_entry_lru))
			goto remove_lru_entry;
		cache = list_entry(nfsi->access_cache_entry_lru.next,
				struct nfs_access_entry, lru);
		list_move(&cache->lru, &head);
		rb_erase(&cache->rb_node, &nfsi->access_cache);
		if (!list_empty(&nfsi->access_cache_entry_lru))
			list_move_tail(&nfsi->access_cache_inode_lru,
					&nfs_access_lru_list);
		else {
remove_lru_entry:
			list_del_init(&nfsi->access_cache_inode_lru);
1992
			smp_mb__before_clear_bit();
1993
			clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags);
1994
			smp_mb__after_clear_bit();
1995
		}
1996
		spin_unlock(&inode->i_lock);
1997 1998
	}
	spin_unlock(&nfs_access_lru_lock);
1999
	nfs_access_free_list(&head);
2000 2001 2002
	return (atomic_long_read(&nfs_access_nr_entries) / 100) * sysctl_vfs_cache_pressure;
}

2003
static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head)
L
Linus Torvalds 已提交
2004
{
2005
	struct rb_root *root_node = &nfsi->access_cache;
2006
	struct rb_node *n;
2007 2008 2009 2010 2011 2012
	struct nfs_access_entry *entry;

	/* Unhook entries from the cache */
	while ((n = rb_first(root_node)) != NULL) {
		entry = rb_entry(n, struct nfs_access_entry, rb_node);
		rb_erase(n, root_node);
2013
		list_move(&entry->lru, head);
2014 2015
	}
	nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS;
L
Linus Torvalds 已提交
2016 2017
}

2018
void nfs_access_zap_cache(struct inode *inode)
L
Linus Torvalds 已提交
2019
{
2020 2021 2022 2023
	LIST_HEAD(head);

	if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0)
		return;
2024
	/* Remove from global LRU init */
2025 2026
	spin_lock(&nfs_access_lru_lock);
	if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
2027 2028
		list_del_init(&NFS_I(inode)->access_cache_inode_lru);

2029
	spin_lock(&inode->i_lock);
2030 2031 2032 2033
	__nfs_access_zap_cache(NFS_I(inode), &head);
	spin_unlock(&inode->i_lock);
	spin_unlock(&nfs_access_lru_lock);
	nfs_access_free_list(&head);
2034
}
B
Bryan Schumaker 已提交
2035
EXPORT_SYMBOL_GPL(nfs_access_zap_cache);
L
Linus Torvalds 已提交
2036

2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050
static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, struct rpc_cred *cred)
{
	struct rb_node *n = NFS_I(inode)->access_cache.rb_node;
	struct nfs_access_entry *entry;

	while (n != NULL) {
		entry = rb_entry(n, struct nfs_access_entry, rb_node);

		if (cred < entry->cred)
			n = n->rb_left;
		else if (cred > entry->cred)
			n = n->rb_right;
		else
			return entry;
L
Linus Torvalds 已提交
2051
	}
2052 2053 2054
	return NULL;
}

2055
static int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res)
2056 2057 2058 2059 2060
{
	struct nfs_inode *nfsi = NFS_I(inode);
	struct nfs_access_entry *cache;
	int err = -ENOENT;

2061
	spin_lock(&inode->i_lock);
2062 2063 2064 2065 2066
	if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)
		goto out_zap;
	cache = nfs_access_search_rbtree(inode, cred);
	if (cache == NULL)
		goto out;
2067
	if (!nfs_have_delegated_attributes(inode) &&
2068
	    !time_in_range_open(jiffies, cache->jiffies, cache->jiffies + nfsi->attrtimeo))
2069 2070 2071 2072
		goto out_stale;
	res->jiffies = cache->jiffies;
	res->cred = cache->cred;
	res->mask = cache->mask;
2073
	list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru);
2074 2075 2076 2077 2078 2079
	err = 0;
out:
	spin_unlock(&inode->i_lock);
	return err;
out_stale:
	rb_erase(&cache->rb_node, &nfsi->access_cache);
2080
	list_del(&cache->lru);
2081 2082 2083 2084
	spin_unlock(&inode->i_lock);
	nfs_access_free_entry(cache);
	return -ENOENT;
out_zap:
2085 2086
	spin_unlock(&inode->i_lock);
	nfs_access_zap_cache(inode);
2087 2088 2089 2090 2091
	return -ENOENT;
}

static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set)
{
2092 2093
	struct nfs_inode *nfsi = NFS_I(inode);
	struct rb_root *root_node = &nfsi->access_cache;
2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111
	struct rb_node **p = &root_node->rb_node;
	struct rb_node *parent = NULL;
	struct nfs_access_entry *entry;

	spin_lock(&inode->i_lock);
	while (*p != NULL) {
		parent = *p;
		entry = rb_entry(parent, struct nfs_access_entry, rb_node);

		if (set->cred < entry->cred)
			p = &parent->rb_left;
		else if (set->cred > entry->cred)
			p = &parent->rb_right;
		else
			goto found;
	}
	rb_link_node(&set->rb_node, parent, p);
	rb_insert_color(&set->rb_node, root_node);
2112
	list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
2113
	spin_unlock(&inode->i_lock);
2114 2115 2116
	return;
found:
	rb_replace_node(parent, &set->rb_node, root_node);
2117 2118
	list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
	list_del(&entry->lru);
2119 2120 2121 2122
	spin_unlock(&inode->i_lock);
	nfs_access_free_entry(entry);
}

2123
void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set)
2124 2125 2126 2127 2128
{
	struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL);
	if (cache == NULL)
		return;
	RB_CLEAR_NODE(&cache->rb_node);
L
Linus Torvalds 已提交
2129
	cache->jiffies = set->jiffies;
2130
	cache->cred = get_rpccred(set->cred);
L
Linus Torvalds 已提交
2131
	cache->mask = set->mask;
2132 2133

	nfs_access_add_rbtree(inode, cache);
2134 2135 2136 2137 2138 2139 2140

	/* Update accounting */
	smp_mb__before_atomic_inc();
	atomic_long_inc(&nfs_access_nr_entries);
	smp_mb__after_atomic_inc();

	/* Add inode to global LRU list */
2141
	if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) {
2142
		spin_lock(&nfs_access_lru_lock);
2143 2144 2145
		if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
			list_add_tail(&NFS_I(inode)->access_cache_inode_lru,
					&nfs_access_lru_list);
2146 2147
		spin_unlock(&nfs_access_lru_lock);
	}
L
Linus Torvalds 已提交
2148
}
2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162
EXPORT_SYMBOL_GPL(nfs_access_add_cache);

void nfs_access_set_mask(struct nfs_access_entry *entry, u32 access_result)
{
	entry->mask = 0;
	if (access_result & NFS4_ACCESS_READ)
		entry->mask |= MAY_READ;
	if (access_result &
	    (NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE))
		entry->mask |= MAY_WRITE;
	if (access_result & (NFS4_ACCESS_LOOKUP|NFS4_ACCESS_EXECUTE))
		entry->mask |= MAY_EXEC;
}
EXPORT_SYMBOL_GPL(nfs_access_set_mask);
L
Linus Torvalds 已提交
2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177

static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask)
{
	struct nfs_access_entry cache;
	int status;

	status = nfs_access_get_cached(inode, cred, &cache);
	if (status == 0)
		goto out;

	/* Be clever: ask server to check for all possible rights */
	cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ;
	cache.cred = cred;
	cache.jiffies = jiffies;
	status = NFS_PROTO(inode)->access(inode, &cache);
2178 2179 2180 2181 2182 2183
	if (status != 0) {
		if (status == -ESTALE) {
			nfs_zap_caches(inode);
			if (!S_ISDIR(inode->i_mode))
				set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
		}
L
Linus Torvalds 已提交
2184
		return status;
2185
	}
L
Linus Torvalds 已提交
2186 2187
	nfs_access_add_cache(inode, &cache);
out:
2188
	if ((mask & ~cache.mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
L
Linus Torvalds 已提交
2189 2190 2191 2192
		return 0;
	return -EACCES;
}

2193 2194 2195 2196
static int nfs_open_permission_mask(int openflags)
{
	int mask = 0;

2197 2198 2199 2200 2201 2202 2203 2204 2205 2206
	if (openflags & __FMODE_EXEC) {
		/* ONLY check exec rights */
		mask = MAY_EXEC;
	} else {
		if ((openflags & O_ACCMODE) != O_WRONLY)
			mask |= MAY_READ;
		if ((openflags & O_ACCMODE) != O_RDONLY)
			mask |= MAY_WRITE;
	}

2207 2208 2209 2210 2211 2212 2213
	return mask;
}

int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags)
{
	return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags));
}
B
Bryan Schumaker 已提交
2214
EXPORT_SYMBOL_GPL(nfs_may_open);
2215

2216
int nfs_permission(struct inode *inode, int mask)
L
Linus Torvalds 已提交
2217 2218 2219 2220
{
	struct rpc_cred *cred;
	int res = 0;

2221
	if (mask & MAY_NOT_BLOCK)
2222 2223
		return -ECHILD;

C
Chuck Lever 已提交
2224 2225
	nfs_inc_stats(inode, NFSIOS_VFSACCESS);

2226
	if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
L
Linus Torvalds 已提交
2227 2228
		goto out;
	/* Is this sys_access() ? */
E
Eric Paris 已提交
2229
	if (mask & (MAY_ACCESS | MAY_CHDIR))
L
Linus Torvalds 已提交
2230 2231 2232 2233 2234 2235 2236 2237
		goto force_lookup;

	switch (inode->i_mode & S_IFMT) {
		case S_IFLNK:
			goto out;
		case S_IFREG:
			/* NFSv4 has atomic_open... */
			if (nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN)
2238 2239
					&& (mask & MAY_OPEN)
					&& !(mask & MAY_EXEC))
L
Linus Torvalds 已提交
2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254
				goto out;
			break;
		case S_IFDIR:
			/*
			 * Optimize away all write operations, since the server
			 * will check permissions when we perform the op.
			 */
			if ((mask & MAY_WRITE) && !(mask & MAY_READ))
				goto out;
	}

force_lookup:
	if (!NFS_PROTO(inode)->access)
		goto out_notsup;

2255
	cred = rpc_lookup_cred();
L
Linus Torvalds 已提交
2256 2257 2258 2259 2260 2261
	if (!IS_ERR(cred)) {
		res = nfs_do_access(inode, cred, mask);
		put_rpccred(cred);
	} else
		res = PTR_ERR(cred);
out:
2262 2263 2264
	if (!res && (mask & MAY_EXEC) && !execute_ok(inode))
		res = -EACCES;

C
Chuck Lever 已提交
2265 2266
	dfprintk(VFS, "NFS: permission(%s/%ld), mask=0x%x, res=%d\n",
		inode->i_sb->s_id, inode->i_ino, mask, res);
L
Linus Torvalds 已提交
2267 2268 2269 2270
	return res;
out_notsup:
	res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
	if (res == 0)
2271
		res = generic_permission(inode, mask);
C
Chuck Lever 已提交
2272
	goto out;
L
Linus Torvalds 已提交
2273
}
B
Bryan Schumaker 已提交
2274
EXPORT_SYMBOL_GPL(nfs_permission);
L
Linus Torvalds 已提交
2275 2276 2277 2278 2279 2280 2281

/*
 * Local variables:
 *  version-control: t
 *  kept-new-versions: 5
 * End:
 */