dir.c 70.5 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
L
Linus Torvalds 已提交
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 *  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
 */

21
#include <linux/module.h>
L
Linus Torvalds 已提交
22 23 24 25 26 27 28 29 30 31 32 33
#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>
34
#include <linux/pagevec.h>
L
Linus Torvalds 已提交
35
#include <linux/namei.h>
36
#include <linux/mount.h>
37
#include <linux/swap.h>
38
#include <linux/sched.h>
39
#include <linux/kmemleak.h>
40
#include <linux/xattr.h>
L
Linus Torvalds 已提交
41 42

#include "delegation.h"
43
#include "iostat.h"
44
#include "internal.h"
45
#include "fscache.h"
L
Linus Torvalds 已提交
46

47 48
#include "nfstrace.h"

L
Linus Torvalds 已提交
49 50 51
/* #define NFS_DEBUG_VERBOSE 1 */

static int nfs_opendir(struct inode *, struct file *);
52
static int nfs_closedir(struct inode *, struct file *);
A
Al Viro 已提交
53
static int nfs_readdir(struct file *, struct dir_context *);
54
static int nfs_fsync_dir(struct file *, loff_t, loff_t, int);
55
static loff_t nfs_llseek_dir(struct file *, loff_t, int);
56
static void nfs_readdir_clear_array(struct page*);
L
Linus Torvalds 已提交
57

58
const struct file_operations nfs_dir_operations = {
59
	.llseek		= nfs_llseek_dir,
L
Linus Torvalds 已提交
60
	.read		= generic_read_dir,
61
	.iterate_shared	= nfs_readdir,
L
Linus Torvalds 已提交
62
	.open		= nfs_opendir,
63
	.release	= nfs_closedir,
L
Linus Torvalds 已提交
64 65 66
	.fsync		= nfs_fsync_dir,
};

67 68
const struct address_space_operations nfs_dir_aops = {
	.freepage = nfs_readdir_clear_array,
69 70
};

71
static struct nfs_open_dir_context *alloc_nfs_open_dir_context(struct inode *dir, const struct cred *cred)
72
{
73
	struct nfs_inode *nfsi = NFS_I(dir);
74 75 76
	struct nfs_open_dir_context *ctx;
	ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
	if (ctx != NULL) {
77
		ctx->duped = 0;
78
		ctx->attr_gencount = nfsi->attr_gencount;
79
		ctx->dir_cookie = 0;
80
		ctx->dup_cookie = 0;
81
		ctx->cred = get_cred(cred);
82
		spin_lock(&dir->i_lock);
83 84 85 86
		if (list_empty(&nfsi->open_files) &&
		    (nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER))
			nfsi->cache_validity |= NFS_INO_INVALID_DATA |
				NFS_INO_REVAL_FORCED;
87 88
		list_add(&ctx->list, &nfsi->open_files);
		spin_unlock(&dir->i_lock);
89 90 91
		return ctx;
	}
	return  ERR_PTR(-ENOMEM);
92 93
}

94
static void put_nfs_open_dir_context(struct inode *dir, struct nfs_open_dir_context *ctx)
95
{
96 97 98
	spin_lock(&dir->i_lock);
	list_del(&ctx->list);
	spin_unlock(&dir->i_lock);
99
	put_cred(ctx->cred);
100 101 102
	kfree(ctx);
}

L
Linus Torvalds 已提交
103 104 105 106 107 108
/*
 * Open file
 */
static int
nfs_opendir(struct inode *inode, struct file *filp)
{
109 110
	int res = 0;
	struct nfs_open_dir_context *ctx;
L
Linus Torvalds 已提交
111

112
	dfprintk(FILE, "NFS: open dir(%pD2)\n", filp);
113 114

	nfs_inc_stats(inode, NFSIOS_VFSOPEN);
115

116
	ctx = alloc_nfs_open_dir_context(inode, current_cred());
117 118 119 120 121 122
	if (IS_ERR(ctx)) {
		res = PTR_ERR(ctx);
		goto out;
	}
	filp->private_data = ctx;
out:
L
Linus Torvalds 已提交
123 124 125
	return res;
}

126 127 128
static int
nfs_closedir(struct inode *inode, struct file *filp)
{
A
Al Viro 已提交
129
	put_nfs_open_dir_context(file_inode(filp), filp->private_data);
130 131 132
	return 0;
}

133 134 135 136
struct nfs_cache_array_entry {
	u64 cookie;
	u64 ino;
	struct qstr string;
137
	unsigned char d_type;
138 139 140
};

struct nfs_cache_array {
141
	int size;
142 143 144 145 146
	int eof_index;
	u64 last_cookie;
	struct nfs_cache_array_entry array[0];
};

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;
155
	loff_t		prev_index;
156

157
	unsigned long	dir_verifier;
158
	unsigned long	timestamp;
159
	unsigned long	gencount;
160
	unsigned int	cache_entry_index;
161 162
	bool plus;
	bool eof;
L
Linus Torvalds 已提交
163 164
} nfs_readdir_descriptor_t;

165 166 167 168 169 170 171 172 173 174 175
static
void nfs_readdir_init_array(struct page *page)
{
	struct nfs_cache_array *array;

	array = kmap_atomic(page);
	memset(array, 0, sizeof(struct nfs_cache_array));
	array->eof_index = -1;
	kunmap_atomic(array);
}

176 177 178 179
/*
 * we are freeing strings created by nfs_add_to_readdir_array()
 */
static
180
void nfs_readdir_clear_array(struct page *page)
181
{
182
	struct nfs_cache_array *array;
183
	int i;
184

185
	array = kmap_atomic(page);
186 187
	for (i = 0; i < array->size; i++)
		kfree(array->array[i].string.name);
188
	array->size = 0;
189
	kunmap_atomic(array);
190 191 192 193 194 195 196 197
}

/*
 * 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
198
int nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int len)
199 200
{
	string->len = len;
201
	string->name = kmemdup_nul(name, len, GFP_KERNEL);
202 203
	if (string->name == NULL)
		return -ENOMEM;
204 205 206 207 208
	/*
	 * 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);
209
	string->hash = full_name_hash(NULL, name, len);
210
	return 0;
211 212 213 214 215
}

static
int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page)
{
216
	struct nfs_cache_array *array = kmap(page);
217 218 219
	struct nfs_cache_array_entry *cache_entry;
	int ret;

220 221 222
	cache_entry = &array->array[array->size];

	/* Check that this entry lies within the page bounds */
223
	ret = -ENOSPC;
224
	if ((char *)&cache_entry[1] - (char *)page_address(page) > PAGE_SIZE)
225
		goto out;
226

227 228
	cache_entry->cookie = entry->prev_cookie;
	cache_entry->ino = entry->ino;
229
	cache_entry->d_type = entry->d_type;
230 231 232
	ret = nfs_readdir_make_qstr(&cache_entry->string, entry->name, entry->len);
	if (ret)
		goto out;
233
	array->last_cookie = entry->cookie;
234
	array->size++;
T
Trond Myklebust 已提交
235
	if (entry->eof != 0)
236
		array->eof_index = array->size;
237
out:
238
	kunmap(page);
239
	return ret;
240 241
}

242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260
static inline
int is_32bit_api(void)
{
#ifdef CONFIG_COMPAT
	return in_compat_syscall();
#else
	return (BITS_PER_LONG == 32);
#endif
}

static
bool nfs_readdir_use_cookie(const struct file *filp)
{
	if ((filp->f_mode & FMODE_32BITHASH) ||
	    (!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
		return false;
	return true;
}

261 262 263
static
int nfs_readdir_search_for_pos(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
{
A
Al Viro 已提交
264
	loff_t diff = desc->ctx->pos - desc->current_index;
265 266 267 268 269
	unsigned int index;

	if (diff < 0)
		goto out_eof;
	if (diff >= array->size) {
270
		if (array->eof_index >= 0)
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:
280
	desc->eof = true;
281 282 283
	return -EBADCOOKIE;
}

284 285 286 287 288 289 290 291 292
static bool
nfs_readdir_inode_mapping_valid(struct nfs_inode *nfsi)
{
	if (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA))
		return false;
	smp_rmb();
	return !test_bit(NFS_INO_INVALIDATING, &nfsi->flags);
}

293 294 295 296
static
int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
{
	int i;
297
	loff_t new_pos;
298 299 300 301
	int status = -EAGAIN;

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

305
			new_pos = desc->current_index + i;
306 307
			if (ctx->attr_gencount != nfsi->attr_gencount ||
			    !nfs_readdir_inode_mapping_valid(nfsi)) {
308 309
				ctx->duped = 0;
				ctx->attr_gencount = nfsi->attr_gencount;
310
			} else if (new_pos < desc->prev_index) {
311 312 313
				if (ctx->duped > 0
				    && ctx->dup_cookie == *desc->dir_cookie) {
					if (printk_ratelimit()) {
314
						pr_notice("NFS: directory %pD2 contains a readdir loop."
315
								"Please contact your server vendor.  "
316 317 318
								"The file: %.*s has duplicate cookie %llu\n",
								desc->file, array->array[i].string.len,
								array->array[i].string.name, *desc->dir_cookie);
319 320 321 322
					}
					status = -ELOOP;
					goto out;
				}
323
				ctx->dup_cookie = *desc->dir_cookie;
324
				ctx->duped = -1;
325
			}
326 327 328 329 330
			if (nfs_readdir_use_cookie(desc->file))
				desc->ctx->pos = *desc->dir_cookie;
			else
				desc->ctx->pos = new_pos;
			desc->prev_index = new_pos;
331
			desc->cache_entry_index = i;
T
Trond Myklebust 已提交
332
			return 0;
333 334
		}
	}
T
Trond Myklebust 已提交
335
	if (array->eof_index >= 0) {
336
		status = -EBADCOOKIE;
337
		if (*desc->dir_cookie == array->last_cookie)
338
			desc->eof = true;
339
	}
340
out:
341 342 343 344 345 346 347
	return status;
}

static
int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc)
{
	struct nfs_cache_array *array;
T
Trond Myklebust 已提交
348
	int status;
349

350
	array = kmap(desc->page);
351 352 353 354 355 356

	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 已提交
357
	if (status == -EAGAIN) {
358
		desc->last_cookie = array->last_cookie;
359
		desc->current_index += array->size;
T
Trond Myklebust 已提交
360 361
		desc->page_index++;
	}
362
	kunmap(desc->page);
363 364 365 366 367
	return status;
}

/* Fill a page with xdr information before transferring to the cache page */
static
368
int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc,
369
			struct nfs_entry *entry, struct file *file, struct inode *inode)
L
Linus Torvalds 已提交
370
{
371
	struct nfs_open_dir_context *ctx = file->private_data;
372
	const struct cred *cred = ctx->cred;
373
	unsigned long	timestamp, gencount;
L
Linus Torvalds 已提交
374 375 376 377
	int		error;

 again:
	timestamp = jiffies;
378
	gencount = nfs_inc_attr_generation_counter();
379
	desc->dir_verifier = nfs_save_change_attribute(inode);
M
Miklos Szeredi 已提交
380
	error = NFS_PROTO(inode)->readdir(file_dentry(file), cred, entry->cookie, pages,
L
Linus Torvalds 已提交
381 382 383 384 385
					  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;
386
			clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
387
			desc->plus = false;
L
Linus Torvalds 已提交
388 389 390 391
			goto again;
		}
		goto error;
	}
392
	desc->timestamp = timestamp;
393
	desc->gencount = gencount;
394 395
error:
	return error;
L
Linus Torvalds 已提交
396 397
}

398 399
static int xdr_decode(nfs_readdir_descriptor_t *desc,
		      struct nfs_entry *entry, struct xdr_stream *xdr)
L
Linus Torvalds 已提交
400
{
401
	struct inode *inode = file_inode(desc->file);
402
	int error;
L
Linus Torvalds 已提交
403

404
	error = NFS_PROTO(inode)->decode_dirent(xdr, entry, desc->plus);
405 406
	if (error)
		return error;
407 408 409
	entry->fattr->time_start = desc->timestamp;
	entry->fattr->gencount = desc->gencount;
	return 0;
L
Linus Torvalds 已提交
410 411
}

412 413 414
/* Match file and dirent using either filehandle or fileid
 * Note: caller is responsible for checking the fsid
 */
415 416 417
static
int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry)
{
418
	struct inode *inode;
419 420
	struct nfs_inode *nfsi;

421 422
	if (d_really_is_negative(dentry))
		return 0;
423

424 425 426 427 428
	inode = d_inode(dentry);
	if (is_bad_inode(inode) || NFS_STALE(inode))
		return 0;

	nfsi = NFS_I(inode);
429 430 431 432 433
	if (entry->fattr->fileid != nfsi->fileid)
		return 0;
	if (entry->fh->size && nfs_compare_fh(entry->fh, &nfsi->fh) != 0)
		return 0;
	return 1;
434 435
}

436
static
A
Al Viro 已提交
437
bool nfs_use_readdirplus(struct inode *dir, struct dir_context *ctx)
438 439 440 441 442
{
	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 已提交
443
	if (ctx->pos == 0)
444 445 446 447 448
		return true;
	return false;
}

/*
449 450
 * This function is called by the lookup and getattr code to request the
 * use of readdirplus to accelerate any future lookups in the same
451 452 453 454
 * directory.
 */
void nfs_advise_use_readdirplus(struct inode *dir)
{
455 456 457 458 459
	struct nfs_inode *nfsi = NFS_I(dir);

	if (nfs_server_capable(dir, NFS_CAP_READDIRPLUS) &&
	    !list_empty(&nfsi->open_files))
		set_bit(NFS_INO_ADVISE_RDPLUS, &nfsi->flags);
460 461
}

462 463 464 465 466 467 468 469 470 471
/*
 * This function is mainly for use by nfs_getattr().
 *
 * If this is an 'ls -l', we want to force use of readdirplus.
 * Do this by checking if there is an active file descriptor
 * and calling nfs_advise_use_readdirplus, then forcing a
 * cache flush.
 */
void nfs_force_use_readdirplus(struct inode *dir)
{
472 473 474 475 476
	struct nfs_inode *nfsi = NFS_I(dir);

	if (nfs_server_capable(dir, NFS_CAP_READDIRPLUS) &&
	    !list_empty(&nfsi->open_files)) {
		set_bit(NFS_INO_ADVISE_RDPLUS, &nfsi->flags);
477 478
		invalidate_mapping_pages(dir->i_mapping,
			nfsi->page_index + 1, -1);
479 480 481
	}
}

482
static
483 484
void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry,
		unsigned long dir_verifier)
485
{
486
	struct qstr filename = QSTR_INIT(entry->name, entry->len);
487
	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
488 489
	struct dentry *dentry;
	struct dentry *alias;
490
	struct inode *inode;
491
	int status;
492

493 494
	if (!(entry->fattr->valid & NFS_ATTR_FATTR_FILEID))
		return;
495 496
	if (!(entry->fattr->valid & NFS_ATTR_FATTR_FSID))
		return;
497 498 499 500 501 502 503 504
	if (filename.len == 0)
		return;
	/* Validate that the name doesn't contain any illegal '\0' */
	if (strnlen(filename.name, filename.len) != filename.len)
		return;
	/* ...or '/' */
	if (strnchr(filename.name, filename.len, '/'))
		return;
505 506 507 508 509 510
	if (filename.name[0] == '.') {
		if (filename.len == 1)
			return;
		if (filename.len == 2 && filename.name[1] == '.')
			return;
	}
511
	filename.hash = full_name_hash(parent, filename.name, filename.len);
512

513
	dentry = d_lookup(parent, &filename);
514 515 516 517 518 519 520
again:
	if (!dentry) {
		dentry = d_alloc_parallel(parent, &filename, &wq);
		if (IS_ERR(dentry))
			return;
	}
	if (!d_in_lookup(dentry)) {
521 522 523 524
		/* Is there a mountpoint here? If so, just exit */
		if (!nfs_fsid_equal(&NFS_SB(dentry->d_sb)->fsid,
					&entry->fattr->fsid))
			goto out;
525
		if (nfs_same_file(dentry, entry)) {
526 527
			if (!entry->fh->size)
				goto out;
528
			nfs_set_verifier(dentry, dir_verifier);
529
			status = nfs_refresh_inode(d_inode(dentry), entry->fattr);
530
			if (!status)
531
				nfs_setsecurity(d_inode(dentry), entry->fattr, entry->label);
532 533
			goto out;
		} else {
534
			d_invalidate(dentry);
535
			dput(dentry);
536 537
			dentry = NULL;
			goto again;
538 539
		}
	}
540 541 542 543
	if (!entry->fh->size) {
		d_lookup_done(dentry);
		goto out;
	}
544

545
	inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr, entry->label);
546
	alias = d_splice_alias(inode, dentry);
547 548 549 550 551 552 553
	d_lookup_done(dentry);
	if (alias) {
		if (IS_ERR(alias))
			goto out;
		dput(dentry);
		dentry = alias;
	}
554
	nfs_set_verifier(dentry, dir_verifier);
555 556 557 558
out:
	dput(dentry);
}

559 560
/* Perform conversion from xdr to cache array */
static
561
int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry,
562
				struct page **xdr_pages, struct page *page, unsigned int buflen)
L
Linus Torvalds 已提交
563
{
564
	struct xdr_stream stream;
565
	struct xdr_buf buf;
566
	struct page *scratch;
567
	struct nfs_cache_array *array;
568 569
	unsigned int count = 0;
	int status;
570

571 572 573
	scratch = alloc_page(GFP_KERNEL);
	if (scratch == NULL)
		return -ENOMEM;
574

575 576 577
	if (buflen == 0)
		goto out_nopages;

578
	xdr_init_decode_pages(&stream, &buf, xdr_pages, buflen);
579
	xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
580 581 582

	do {
		status = xdr_decode(desc, entry, &stream);
583 584 585
		if (status != 0) {
			if (status == -EAGAIN)
				status = 0;
586
			break;
587
		}
588

589 590
		count++;

591
		if (desc->plus)
592 593
			nfs_prime_dcache(file_dentry(desc->file), entry,
					desc->dir_verifier);
594

595
		status = nfs_readdir_add_to_array(entry, page);
596 597
		if (status != 0)
			break;
598 599
	} while (!entry->eof);

600
out_nopages:
T
Trond Myklebust 已提交
601
	if (count == 0 || (status == -EBADCOOKIE && entry->eof != 0)) {
602
		array = kmap(page);
603 604
		array->eof_index = array->size;
		status = 0;
605
		kunmap(page);
L
Linus Torvalds 已提交
606
	}
607 608

	put_page(scratch);
609
	return status;
610 611 612
}

static
613
void nfs_readdir_free_pages(struct page **pages, unsigned int npages)
614 615 616 617 618 619 620
{
	unsigned int i;
	for (i = 0; i < npages; i++)
		put_page(pages[i]);
}

/*
621 622
 * nfs_readdir_alloc_pages() will allocate pages that must be freed with a call
 * to nfs_readdir_free_pages()
623 624
 */
static
625
int nfs_readdir_alloc_pages(struct page **pages, unsigned int npages)
626 627 628 629 630 631 632 633 634
{
	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;
	}
635
	return 0;
636 637

out_freepages:
638
	nfs_readdir_free_pages(pages, i);
639
	return -ENOMEM;
L
Linus Torvalds 已提交
640 641
}

642 643
static
int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode)
644
{
645
	struct page *pages[NFS_MAX_READDIR_PAGES];
646 647 648
	struct nfs_entry entry;
	struct file	*file = desc->file;
	struct nfs_cache_array *array;
649
	int status = -ENOMEM;
650
	unsigned int array_size = ARRAY_SIZE(pages);
651

652 653
	nfs_readdir_init_array(page);

654
	entry.prev_cookie = 0;
655
	entry.cookie = desc->last_cookie;
656 657 658
	entry.eof = 0;
	entry.fh = nfs_alloc_fhandle();
	entry.fattr = nfs_alloc_fattr();
659
	entry.server = NFS_SERVER(inode);
660 661
	if (entry.fh == NULL || entry.fattr == NULL)
		goto out;
662

663 664 665 666 667 668
	entry.label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT);
	if (IS_ERR(entry.label)) {
		status = PTR_ERR(entry.label);
		goto out;
	}

669
	array = kmap(page);
670

671
	status = nfs_readdir_alloc_pages(pages, array_size);
672
	if (status < 0)
673 674
		goto out_release_array;
	do {
675
		unsigned int pglen;
676
		status = nfs_readdir_xdr_filler(pages, desc, &entry, file, inode);
677

678
		if (status < 0)
679
			break;
680
		pglen = status;
681
		status = nfs_readdir_page_filler(desc, &entry, pages, page, pglen);
682 683 684 685 686 687
		if (status < 0) {
			if (status == -ENOSPC)
				status = 0;
			break;
		}
	} while (array->eof_index < 0);
688

689
	nfs_readdir_free_pages(pages, array_size);
690
out_release_array:
691
	kunmap(page);
692
	nfs4_label_free(entry.label);
693 694 695
out:
	nfs_free_fattr(entry.fattr);
	nfs_free_fhandle(entry.fh);
696 697 698 699
	return status;
}

/*
700 701 702 703
 * 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 已提交
704
 */
705
static
706
int nfs_readdir_filler(void *data, struct page* page)
L
Linus Torvalds 已提交
707
{
708
	nfs_readdir_descriptor_t *desc = data;
A
Al Viro 已提交
709
	struct inode	*inode = file_inode(desc->file);
710
	int ret;
L
Linus Torvalds 已提交
711

712 713 714
	ret = nfs_readdir_xdr_to_array(desc, page, inode);
	if (ret < 0)
		goto error;
715
	SetPageUptodate(page);
L
Linus Torvalds 已提交
716

717 718 719
	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 已提交
720
	}
721 722 723
	unlock_page(page);
	return 0;
 error:
724
	nfs_readdir_clear_array(page);
725
	unlock_page(page);
726
	return ret;
727
}
L
Linus Torvalds 已提交
728

729 730 731
static
void cache_page_release(nfs_readdir_descriptor_t *desc)
{
732
	put_page(desc->page);
733 734 735 736 737 738
	desc->page = NULL;
}

static
struct page *get_cache_page(nfs_readdir_descriptor_t *desc)
{
739 740
	return read_cache_page(desc->file->f_mapping, desc->page_index,
			nfs_readdir_filler, desc);
L
Linus Torvalds 已提交
741 742 743
}

/*
744
 * Returns 0 if desc->dir_cookie was found on page desc->page_index
745
 * and locks the page to prevent removal from the page cache.
L
Linus Torvalds 已提交
746
 */
747
static
748
int find_and_lock_cache_page(nfs_readdir_descriptor_t *desc)
749
{
750 751
	struct inode *inode = file_inode(desc->file);
	struct nfs_inode *nfsi = NFS_I(inode);
752 753 754 755 756
	int res;

	desc->page = get_cache_page(desc);
	if (IS_ERR(desc->page))
		return PTR_ERR(desc->page);
757
	res = lock_page_killable(desc->page);
T
Trond Myklebust 已提交
758
	if (res != 0)
759 760 761 762
		goto error;
	res = -EAGAIN;
	if (desc->page->mapping != NULL) {
		res = nfs_readdir_search_array(desc);
763 764
		if (res == 0) {
			nfsi->page_index = desc->page_index;
765
			return 0;
766
		}
767 768 769 770
	}
	unlock_page(desc->page);
error:
	cache_page_release(desc);
771 772 773 774
	return res;
}

/* Search for desc->dir_cookie from the beginning of the page cache */
L
Linus Torvalds 已提交
775 776 777
static inline
int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)
{
778
	int res;
779

780
	if (desc->page_index == 0) {
781
		desc->current_index = 0;
782
		desc->prev_index = 0;
783 784
		desc->last_cookie = 0;
	}
T
Trond Myklebust 已提交
785
	do {
786
		res = find_and_lock_cache_page(desc);
T
Trond Myklebust 已提交
787
	} while (res == -EAGAIN);
L
Linus Torvalds 已提交
788 789 790 791 792 793 794
	return res;
}

/*
 * Once we've found the start of the dirent within a page: fill 'er up...
 */
static 
A
Al Viro 已提交
795
int nfs_do_filldir(nfs_readdir_descriptor_t *desc)
L
Linus Torvalds 已提交
796 797
{
	struct file	*file = desc->file;
798 799 800
	int i = 0;
	int res = 0;
	struct nfs_cache_array *array = NULL;
801 802
	struct nfs_open_dir_context *ctx = file->private_data;

803
	array = kmap(desc->page);
804
	for (i = desc->cache_entry_index; i < array->size; i++) {
805
		struct nfs_cache_array_entry *ent;
L
Linus Torvalds 已提交
806

807
		ent = &array->array[i];
A
Al Viro 已提交
808 809
		if (!dir_emit(desc->ctx, ent->string.name, ent->string.len,
		    nfs_compat_user_ino64(ent->ino), ent->d_type)) {
810
			desc->eof = true;
L
Linus Torvalds 已提交
811
			break;
812
		}
813 814 815 816
		if (i < (array->size-1))
			*desc->dir_cookie = array->array[i+1].cookie;
		else
			*desc->dir_cookie = array->last_cookie;
817 818 819 820
		if (nfs_readdir_use_cookie(file))
			desc->ctx->pos = *desc->dir_cookie;
		else
			desc->ctx->pos++;
821 822
		if (ctx->duped != 0)
			ctx->duped = 1;
L
Linus Torvalds 已提交
823
	}
T
Trond Myklebust 已提交
824
	if (array->eof_index >= 0)
825
		desc->eof = true;
826

827
	kunmap(desc->page);
828 829
	dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n",
			(unsigned long long)*desc->dir_cookie, res);
L
Linus Torvalds 已提交
830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845
	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 已提交
846
int uncached_readdir(nfs_readdir_descriptor_t *desc)
L
Linus Torvalds 已提交
847 848 849
{
	struct page	*page = NULL;
	int		status;
A
Al Viro 已提交
850
	struct inode *inode = file_inode(desc->file);
851
	struct nfs_open_dir_context *ctx = desc->file->private_data;
L
Linus Torvalds 已提交
852

853 854
	dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n",
			(unsigned long long)*desc->dir_cookie);
L
Linus Torvalds 已提交
855 856 857 858 859 860

	page = alloc_page(GFP_HIGHUSER);
	if (!page) {
		status = -ENOMEM;
		goto out;
	}
861

862
	desc->page_index = 0;
863
	desc->last_cookie = *desc->dir_cookie;
864
	desc->page = page;
865
	ctx->duped = 0;
866

867 868
	status = nfs_readdir_xdr_to_array(desc, page, inode);
	if (status < 0)
L
Linus Torvalds 已提交
869 870
		goto out_release;

A
Al Viro 已提交
871
	status = nfs_do_filldir(desc);
L
Linus Torvalds 已提交
872

873 874 875
 out_release:
	nfs_readdir_clear_array(desc->page);
	cache_page_release(desc);
L
Linus Torvalds 已提交
876
 out:
877
	dfprintk(DIRCACHE, "NFS: %s: returns %d\n",
878
			__func__, status);
L
Linus Torvalds 已提交
879 880 881
	return status;
}

882 883 884
/* 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 已提交
885
 */
A
Al Viro 已提交
886
static int nfs_readdir(struct file *file, struct dir_context *ctx)
L
Linus Torvalds 已提交
887
{
M
Miklos Szeredi 已提交
888
	struct dentry	*dentry = file_dentry(file);
889
	struct inode	*inode = d_inode(dentry);
A
Al Viro 已提交
890
	struct nfs_open_dir_context *dir_ctx = file->private_data;
891 892 893 894 895 896 897
	nfs_readdir_descriptor_t my_desc = {
		.file = file,
		.ctx = ctx,
		.dir_cookie = &dir_ctx->dir_cookie,
		.plus = nfs_use_readdirplus(inode, ctx),
	},
			*desc = &my_desc;
898
	int res = 0;
L
Linus Torvalds 已提交
899

900 901
	dfprintk(FILE, "NFS: readdir(%pD2) starting at cookie %llu\n",
			file, (long long)ctx->pos);
902 903
	nfs_inc_stats(inode, NFSIOS_VFSGETDENTS);

L
Linus Torvalds 已提交
904
	/*
A
Al Viro 已提交
905
	 * ctx->pos points to the dirent entry number.
906
	 * *desc->dir_cookie has the cookie for the next entry. We have
907 908
	 * to either find the entry with the appropriate number or
	 * revalidate the cookie.
L
Linus Torvalds 已提交
909
	 */
910
	if (ctx->pos == 0 || nfs_attribute_cache_expired(inode))
911
		res = nfs_revalidate_mapping(inode, file->f_mapping);
912 913 914
	if (res < 0)
		goto out;

T
Trond Myklebust 已提交
915
	do {
L
Linus Torvalds 已提交
916
		res = readdir_search_pagecache(desc);
917

L
Linus Torvalds 已提交
918
		if (res == -EBADCOOKIE) {
919
			res = 0;
L
Linus Torvalds 已提交
920
			/* This means either end of directory */
921
			if (*desc->dir_cookie && !desc->eof) {
L
Linus Torvalds 已提交
922
				/* Or that the server has 'lost' a cookie */
A
Al Viro 已提交
923
				res = uncached_readdir(desc);
924
				if (res == 0)
L
Linus Torvalds 已提交
925 926 927 928 929
					continue;
			}
			break;
		}
		if (res == -ETOOSMALL && desc->plus) {
930
			clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
L
Linus Torvalds 已提交
931
			nfs_zap_caches(inode);
932
			desc->page_index = 0;
933 934
			desc->plus = false;
			desc->eof = false;
L
Linus Torvalds 已提交
935 936 937 938 939
			continue;
		}
		if (res < 0)
			break;

A
Al Viro 已提交
940
		res = nfs_do_filldir(desc);
941 942
		unlock_page(desc->page);
		cache_page_release(desc);
943
		if (res < 0)
L
Linus Torvalds 已提交
944
			break;
T
Trond Myklebust 已提交
945
	} while (!desc->eof);
946
out:
947 948
	if (res > 0)
		res = 0;
949
	dfprintk(FILE, "NFS: readdir(%pD2) returns %d\n", file, res);
950
	return res;
L
Linus Torvalds 已提交
951 952
}

953
static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int whence)
954
{
955
	struct inode *inode = file_inode(filp);
956
	struct nfs_open_dir_context *dir_ctx = filp->private_data;
957

958 959
	dfprintk(FILE, "NFS: llseek dir(%pD2, %lld, %d)\n",
			filp, offset, whence);
960

961
	switch (whence) {
962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977
	default:
		return -EINVAL;
	case SEEK_SET:
		if (offset < 0)
			return -EINVAL;
		inode_lock(inode);
		break;
	case SEEK_CUR:
		if (offset == 0)
			return filp->f_pos;
		inode_lock(inode);
		offset += filp->f_pos;
		if (offset < 0) {
			inode_unlock(inode);
			return -EINVAL;
		}
978 979 980
	}
	if (offset != filp->f_pos) {
		filp->f_pos = offset;
981 982 983 984
		if (nfs_readdir_use_cookie(filp))
			dir_ctx->dir_cookie = offset;
		else
			dir_ctx->dir_cookie = 0;
985
		dir_ctx->duped = 0;
986
	}
987
	inode_unlock(inode);
988 989 990
	return offset;
}

L
Linus Torvalds 已提交
991 992 993 994
/*
 * All directory operations under NFS are synchronous, so fsync()
 * is a dummy operation.
 */
995 996
static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end,
			 int datasync)
L
Linus Torvalds 已提交
997
{
998
	struct inode *inode = file_inode(filp);
999

1000
	dfprintk(FILE, "NFS: fsync dir(%pD2) datasync %d\n", filp, datasync);
1001

A
Al Viro 已提交
1002
	inode_lock(inode);
1003
	nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
A
Al Viro 已提交
1004
	inode_unlock(inode);
L
Linus Torvalds 已提交
1005 1006 1007
	return 0;
}

1008 1009
/**
 * nfs_force_lookup_revalidate - Mark the directory as having changed
1010
 * @dir: pointer to directory inode
1011 1012 1013 1014 1015
 *
 * 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.
 *
1016 1017 1018
 * Note that we reserve bit '0' as a tag to let us know when a dentry
 * was revalidated while holding a delegation on its inode.
 *
1019 1020 1021 1022
 * The caller should be holding dir->i_lock
 */
void nfs_force_lookup_revalidate(struct inode *dir)
{
1023
	NFS_I(dir)->cache_change_attribute += 2;
1024
}
1025
EXPORT_SYMBOL_GPL(nfs_force_lookup_revalidate);
1026

1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122
/**
 * nfs_verify_change_attribute - Detects NFS remote directory changes
 * @dir: pointer to parent directory inode
 * @verf: previously saved change attribute
 *
 * Return "false" if the verifiers doesn't match the change attribute.
 * This would usually indicate that the directory contents have changed on
 * the server, and that any dentries need revalidating.
 */
static bool nfs_verify_change_attribute(struct inode *dir, unsigned long verf)
{
	return (verf & ~1UL) == nfs_save_change_attribute(dir);
}

static void nfs_set_verifier_delegated(unsigned long *verf)
{
	*verf |= 1UL;
}

#if IS_ENABLED(CONFIG_NFS_V4)
static void nfs_unset_verifier_delegated(unsigned long *verf)
{
	*verf &= ~1UL;
}
#endif /* IS_ENABLED(CONFIG_NFS_V4) */

static bool nfs_test_verifier_delegated(unsigned long verf)
{
	return verf & 1;
}

static bool nfs_verifier_is_delegated(struct dentry *dentry)
{
	return nfs_test_verifier_delegated(dentry->d_time);
}

static void nfs_set_verifier_locked(struct dentry *dentry, unsigned long verf)
{
	struct inode *inode = d_inode(dentry);

	if (!nfs_verifier_is_delegated(dentry) &&
	    !nfs_verify_change_attribute(d_inode(dentry->d_parent), verf))
		goto out;
	if (inode && NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
		nfs_set_verifier_delegated(&verf);
out:
	dentry->d_time = verf;
}

/**
 * nfs_set_verifier - save a parent directory verifier in the dentry
 * @dentry: pointer to dentry
 * @verf: verifier to save
 *
 * Saves the parent directory verifier in @dentry. If the inode has
 * a delegation, we also tag the dentry as having been revalidated
 * while holding a delegation so that we know we don't have to
 * look it up again after a directory change.
 */
void nfs_set_verifier(struct dentry *dentry, unsigned long verf)
{

	spin_lock(&dentry->d_lock);
	nfs_set_verifier_locked(dentry, verf);
	spin_unlock(&dentry->d_lock);
}
EXPORT_SYMBOL_GPL(nfs_set_verifier);

#if IS_ENABLED(CONFIG_NFS_V4)
/**
 * nfs_clear_verifier_delegated - clear the dir verifier delegation tag
 * @inode: pointer to inode
 *
 * Iterates through the dentries in the inode alias list and clears
 * the tag used to indicate that the dentry has been revalidated
 * while holding a delegation.
 * This function is intended for use when the delegation is being
 * returned or revoked.
 */
void nfs_clear_verifier_delegated(struct inode *inode)
{
	struct dentry *alias;

	if (!inode)
		return;
	spin_lock(&inode->i_lock);
	hlist_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
		spin_lock(&alias->d_lock);
		nfs_unset_verifier_delegated(&alias->d_time);
		spin_unlock(&alias->d_lock);
	}
	spin_unlock(&inode->i_lock);
}
EXPORT_SYMBOL_GPL(nfs_clear_verifier_delegated);
#endif /* IS_ENABLED(CONFIG_NFS_V4) */

L
Linus Torvalds 已提交
1123 1124 1125 1126
/*
 * 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.
1127
 * If rcu_walk prevents us from performing a full check, return 0.
L
Linus Torvalds 已提交
1128
 */
1129 1130
static int nfs_check_verifier(struct inode *dir, struct dentry *dentry,
			      int rcu_walk)
L
Linus Torvalds 已提交
1131 1132 1133
{
	if (IS_ROOT(dentry))
		return 1;
1134 1135
	if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
		return 0;
1136 1137 1138
	if (!nfs_verify_change_attribute(dir, dentry->d_time))
		return 0;
	/* Revalidate nfsi->cache_change_attribute before we declare a match */
1139 1140 1141 1142 1143 1144
	if (nfs_mapping_need_revalidate_inode(dir)) {
		if (rcu_walk)
			return 0;
		if (__nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0)
			return 0;
	}
1145 1146 1147
	if (!nfs_verify_change_attribute(dir, dentry->d_time))
		return 0;
	return 1;
L
Linus Torvalds 已提交
1148 1149
}

1150 1151 1152 1153
/*
 * Use intent information to check whether or not we're going to do
 * an O_EXCL create using this path component.
 */
1154
static int nfs_is_exclusive_create(struct inode *dir, unsigned int flags)
1155 1156 1157
{
	if (NFS_PROTO(dir)->version == 2)
		return 0;
1158
	return flags & LOOKUP_EXCL;
1159 1160
}

1161 1162 1163 1164 1165 1166 1167 1168
/*
 * 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.
 *
 */
1169
static
1170
int nfs_lookup_verify_inode(struct inode *inode, unsigned int flags)
L
Linus Torvalds 已提交
1171 1172
{
	struct nfs_server *server = NFS_SERVER(inode);
1173
	int ret;
L
Linus Torvalds 已提交
1174

1175
	if (IS_AUTOMOUNT(inode))
1176
		return 0;
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192

	if (flags & LOOKUP_OPEN) {
		switch (inode->i_mode & S_IFMT) {
		case S_IFREG:
			/* A NFSv4 OPEN will revalidate later */
			if (server->caps & NFS_CAP_ATOMIC_OPEN)
				goto out;
			/* Fallthrough */
		case S_IFDIR:
			if (server->flags & NFS_MOUNT_NOCTO)
				break;
			/* NFS close-to-open cache consistency validation */
			goto out_force;
		}
	}

1193
	/* VFS wants an on-the-wire revalidation */
1194
	if (flags & LOOKUP_REVAL)
1195
		goto out_force;
1196
out:
1197
	return (inode->i_nlink == 0) ? -ESTALE : 0;
L
Linus Torvalds 已提交
1198
out_force:
1199 1200
	if (flags & LOOKUP_RCU)
		return -ECHILD;
1201 1202 1203 1204
	ret = __nfs_revalidate_inode(server, inode);
	if (ret != 0)
		return ret;
	goto out;
L
Linus Torvalds 已提交
1205 1206 1207 1208 1209 1210 1211 1212
}

/*
 * 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.
1213 1214 1215
 *
 * If LOOKUP_RCU prevents us from performing a full check, return 1
 * suggesting a reval is needed.
1216 1217 1218
 *
 * Note that when creating a new file, or looking up a rename target,
 * then it shouldn't be necessary to revalidate a negative dentry.
L
Linus Torvalds 已提交
1219 1220 1221
 */
static inline
int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry,
1222
		       unsigned int flags)
L
Linus Torvalds 已提交
1223
{
1224
	if (flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
L
Linus Torvalds 已提交
1225
		return 0;
1226 1227
	if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG)
		return 1;
1228
	return !nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU);
L
Linus Torvalds 已提交
1229 1230
}

1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290
static int
nfs_lookup_revalidate_done(struct inode *dir, struct dentry *dentry,
			   struct inode *inode, int error)
{
	switch (error) {
	case 1:
		dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is valid\n",
			__func__, dentry);
		return 1;
	case 0:
		nfs_mark_for_revalidate(dir);
		if (inode && S_ISDIR(inode->i_mode)) {
			/* Purge readdir caches. */
			nfs_zap_caches(inode);
			/*
			 * We can't d_drop the root of a disconnected tree:
			 * its d_hash is on the s_anon list and d_drop() would hide
			 * it from shrink_dcache_for_unmount(), leading to busy
			 * inodes on unmount and further oopses.
			 */
			if (IS_ROOT(dentry))
				return 1;
		}
		dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is invalid\n",
				__func__, dentry);
		return 0;
	}
	dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) lookup returned error %d\n",
				__func__, dentry, error);
	return error;
}

static int
nfs_lookup_revalidate_negative(struct inode *dir, struct dentry *dentry,
			       unsigned int flags)
{
	int ret = 1;
	if (nfs_neg_need_reval(dir, dentry, flags)) {
		if (flags & LOOKUP_RCU)
			return -ECHILD;
		ret = 0;
	}
	return nfs_lookup_revalidate_done(dir, dentry, NULL, ret);
}

static int
nfs_lookup_revalidate_delegated(struct inode *dir, struct dentry *dentry,
				struct inode *inode)
{
	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
	return nfs_lookup_revalidate_done(dir, dentry, inode, 1);
}

static int
nfs_lookup_revalidate_dentry(struct inode *dir, struct dentry *dentry,
			     struct inode *inode)
{
	struct nfs_fh *fhandle;
	struct nfs_fattr *fattr;
	struct nfs4_label *label;
1291
	unsigned long dir_verifier;
1292 1293 1294 1295 1296 1297 1298 1299 1300
	int ret;

	ret = -ENOMEM;
	fhandle = nfs_alloc_fhandle();
	fattr = nfs_alloc_fattr();
	label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
	if (fhandle == NULL || fattr == NULL || IS_ERR(label))
		goto out;

1301
	dir_verifier = nfs_save_change_attribute(dir);
1302
	ret = NFS_PROTO(dir)->lookup(dir, dentry, fhandle, fattr, label);
1303
	if (ret < 0) {
1304 1305 1306
		switch (ret) {
		case -ESTALE:
		case -ENOENT:
1307
			ret = 0;
1308 1309 1310 1311 1312
			break;
		case -ETIMEDOUT:
			if (NFS_SERVER(inode)->flags & NFS_MOUNT_SOFTREVAL)
				ret = 1;
		}
1313 1314 1315 1316 1317 1318 1319 1320 1321
		goto out;
	}
	ret = 0;
	if (nfs_compare_fh(NFS_FH(inode), fhandle))
		goto out;
	if (nfs_refresh_inode(inode, fattr) < 0)
		goto out;

	nfs_setsecurity(inode, fattr, label);
1322
	nfs_set_verifier(dentry, dir_verifier);
1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333

	/* set a readdirplus hint that we had a cache miss */
	nfs_force_use_readdirplus(dir);
	ret = 1;
out:
	nfs_free_fattr(fattr);
	nfs_free_fhandle(fhandle);
	nfs4_label_free(label);
	return nfs_lookup_revalidate_done(dir, dentry, inode, ret);
}

L
Linus Torvalds 已提交
1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344
/*
 * 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.
 */
1345 1346 1347
static int
nfs_do_lookup_revalidate(struct inode *dir, struct dentry *dentry,
			 unsigned int flags)
L
Linus Torvalds 已提交
1348 1349 1350 1351
{
	struct inode *inode;
	int error;

1352
	nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE);
1353
	inode = d_inode(dentry);
L
Linus Torvalds 已提交
1354

1355 1356
	if (!inode)
		return nfs_lookup_revalidate_negative(dir, dentry, flags);
L
Linus Torvalds 已提交
1357 1358

	if (is_bad_inode(inode)) {
1359 1360
		dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode\n",
				__func__, dentry);
L
Linus Torvalds 已提交
1361 1362 1363
		goto out_bad;
	}

1364
	if (nfs_verifier_is_delegated(dentry))
1365
		return nfs_lookup_revalidate_delegated(dir, dentry, inode);
1366

L
Linus Torvalds 已提交
1367
	/* Force a full look up iff the parent directory has changed */
1368
	if (!(flags & (LOOKUP_EXCL | LOOKUP_REVAL)) &&
1369
	    nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU)) {
1370 1371 1372
		error = nfs_lookup_verify_inode(inode, flags);
		if (error) {
			if (error == -ESTALE)
1373 1374
				nfs_zap_caches(dir);
			goto out_bad;
1375
		}
1376
		nfs_advise_use_readdirplus(dir);
L
Linus Torvalds 已提交
1377 1378 1379
		goto out_valid;
	}

1380 1381 1382
	if (flags & LOOKUP_RCU)
		return -ECHILD;

L
Linus Torvalds 已提交
1383 1384 1385
	if (NFS_STALE(inode))
		goto out_bad;

1386
	trace_nfs_lookup_revalidate_enter(dir, dentry, flags);
1387
	error = nfs_lookup_revalidate_dentry(dir, dentry, inode);
1388
	trace_nfs_lookup_revalidate_exit(dir, dentry, flags, error);
1389 1390 1391 1392 1393 1394 1395 1396
	return error;
out_valid:
	return nfs_lookup_revalidate_done(dir, dentry, inode, 1);
out_bad:
	if (flags & LOOKUP_RCU)
		return -ECHILD;
	return nfs_lookup_revalidate_done(dir, dentry, inode, 0);
}
1397

1398
static int
1399 1400
__nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags,
			int (*reval)(struct inode *, struct dentry *, unsigned int))
1401 1402 1403 1404
{
	struct dentry *parent;
	struct inode *dir;
	int ret;
1405

1406
	if (flags & LOOKUP_RCU) {
1407 1408 1409 1410
		parent = READ_ONCE(dentry->d_parent);
		dir = d_inode_rcu(parent);
		if (!dir)
			return -ECHILD;
1411
		ret = reval(dir, dentry, flags);
1412
		if (parent != READ_ONCE(dentry->d_parent))
1413
			return -ECHILD;
1414 1415
	} else {
		parent = dget_parent(dentry);
1416
		ret = reval(d_inode(parent), dentry, flags);
1417
		dput(parent);
L
Linus Torvalds 已提交
1418
	}
1419
	return ret;
L
Linus Torvalds 已提交
1420 1421
}

1422 1423 1424 1425 1426
static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
{
	return __nfs_lookup_revalidate(dentry, flags, nfs_do_lookup_revalidate);
}

1427
/*
1428
 * A weaker form of d_revalidate for revalidating just the d_inode(dentry)
1429 1430 1431 1432 1433 1434 1435 1436 1437
 * 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)
{
1438
	struct inode *inode = d_inode(dentry);
1439
	int error = 0;
1440 1441 1442 1443 1444 1445 1446

	/*
	 * 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) {
1447 1448
		dfprintk(LOOKUPCACHE, "%s: %pd2 has negative inode\n",
				__func__, dentry);
1449 1450 1451 1452
		return 1;
	}

	if (is_bad_inode(inode)) {
1453 1454
		dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode\n",
				__func__, dentry);
1455 1456 1457
		return 0;
	}

1458
	error = nfs_lookup_verify_inode(inode, flags);
1459 1460 1461 1462 1463
	dfprintk(LOOKUPCACHE, "NFS: %s: inode %lu is %s\n",
			__func__, inode->i_ino, error ? "invalid" : "valid");
	return !error;
}

L
Linus Torvalds 已提交
1464 1465 1466
/*
 * This is called from dput() when d_count is going to 0.
 */
1467
static int nfs_dentry_delete(const struct dentry *dentry)
L
Linus Torvalds 已提交
1468
{
1469 1470
	dfprintk(VFS, "NFS: dentry_delete(%pd2, %x)\n",
		dentry, dentry->d_flags);
L
Linus Torvalds 已提交
1471

1472
	/* Unhash any dentry with a stale inode */
1473
	if (d_really_is_positive(dentry) && NFS_STALE(d_inode(dentry)))
1474 1475
		return 1;

L
Linus Torvalds 已提交
1476 1477 1478 1479
	if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
		/* Unhash it, so that ->d_iput() would be called */
		return 1;
	}
1480
	if (!(dentry->d_sb->s_flags & SB_ACTIVE)) {
L
Linus Torvalds 已提交
1481 1482 1483 1484 1485 1486 1487 1488
		/* Unhash it, so that ancestors of killed async unlink
		 * files will be cleaned up during umount */
		return 1;
	}
	return 0;

}

1489
/* Ensure that we revalidate inode->i_nlink */
1490 1491 1492
static void nfs_drop_nlink(struct inode *inode)
{
	spin_lock(&inode->i_lock);
1493
	/* drop the inode if we're reasonably sure this is the last link */
1494 1495 1496
	if (inode->i_nlink > 0)
		drop_nlink(inode);
	NFS_I(inode)->attr_gencount = nfs_inc_attr_generation_counter();
1497 1498
	NFS_I(inode)->cache_validity |= NFS_INO_INVALID_CHANGE
		| NFS_INO_INVALID_CTIME
1499 1500
		| NFS_INO_INVALID_OTHER
		| NFS_INO_REVAL_FORCED;
1501 1502 1503
	spin_unlock(&inode->i_lock);
}

L
Linus Torvalds 已提交
1504 1505 1506 1507 1508 1509
/*
 * 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)
{
1510 1511 1512 1513
	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 已提交
1514
	if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1515
		nfs_complete_unlink(dentry, inode);
1516
		nfs_drop_nlink(inode);
L
Linus Torvalds 已提交
1517 1518 1519 1520
	}
	iput(inode);
}

1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531
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 已提交
1532
const struct dentry_operations nfs_dentry_operations = {
L
Linus Torvalds 已提交
1533
	.d_revalidate	= nfs_lookup_revalidate,
1534
	.d_weak_revalidate	= nfs_weak_revalidate,
L
Linus Torvalds 已提交
1535 1536
	.d_delete	= nfs_dentry_delete,
	.d_iput		= nfs_dentry_iput,
1537
	.d_automount	= nfs_d_automount,
1538
	.d_release	= nfs_d_release,
L
Linus Torvalds 已提交
1539
};
1540
EXPORT_SYMBOL_GPL(nfs_dentry_operations);
L
Linus Torvalds 已提交
1541

1542
struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
L
Linus Torvalds 已提交
1543 1544 1545
{
	struct dentry *res;
	struct inode *inode = NULL;
1546 1547
	struct nfs_fh *fhandle = NULL;
	struct nfs_fattr *fattr = NULL;
1548
	struct nfs4_label *label = NULL;
1549
	unsigned long dir_verifier;
L
Linus Torvalds 已提交
1550 1551
	int error;

1552
	dfprintk(VFS, "NFS: lookup(%pd2)\n", dentry);
1553
	nfs_inc_stats(dir, NFSIOS_VFSLOOKUP);
L
Linus Torvalds 已提交
1554

1555 1556
	if (unlikely(dentry->d_name.len > NFS_SERVER(dir)->namelen))
		return ERR_PTR(-ENAMETOOLONG);
L
Linus Torvalds 已提交
1557

1558 1559 1560 1561
	/*
	 * If we're doing an exclusive create, optimize away the lookup
	 * but don't hash the dentry.
	 */
1562
	if (nfs_is_exclusive_create(dir, flags) || flags & LOOKUP_RENAME_TARGET)
1563
		return NULL;
L
Linus Torvalds 已提交
1564

1565 1566 1567 1568 1569 1570
	res = ERR_PTR(-ENOMEM);
	fhandle = nfs_alloc_fhandle();
	fattr = nfs_alloc_fattr();
	if (fhandle == NULL || fattr == NULL)
		goto out;

1571 1572 1573 1574
	label = nfs4_label_alloc(NFS_SERVER(dir), GFP_NOWAIT);
	if (IS_ERR(label))
		goto out;

1575
	dir_verifier = nfs_save_change_attribute(dir);
1576
	trace_nfs_lookup_enter(dir, dentry, flags);
1577
	error = NFS_PROTO(dir)->lookup(dir, dentry, fhandle, fattr, label);
L
Linus Torvalds 已提交
1578 1579 1580 1581
	if (error == -ENOENT)
		goto no_entry;
	if (error < 0) {
		res = ERR_PTR(error);
1582
		goto out_label;
L
Linus Torvalds 已提交
1583
	}
1584
	inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label);
N
Namhyung Kim 已提交
1585
	res = ERR_CAST(inode);
1586
	if (IS_ERR(res))
1587
		goto out_label;
1588

1589 1590
	/* Notify readdir to use READDIRPLUS */
	nfs_force_use_readdirplus(dir);
1591

L
Linus Torvalds 已提交
1592
no_entry:
1593
	res = d_splice_alias(inode, dentry);
1594 1595
	if (res != NULL) {
		if (IS_ERR(res))
1596
			goto out_label;
L
Linus Torvalds 已提交
1597
		dentry = res;
1598
	}
1599
	nfs_set_verifier(dentry, dir_verifier);
1600
out_label:
1601
	trace_nfs_lookup_exit(dir, dentry, flags, error);
1602
	nfs4_label_free(label);
L
Linus Torvalds 已提交
1603
out:
1604 1605
	nfs_free_fattr(fattr);
	nfs_free_fhandle(fhandle);
L
Linus Torvalds 已提交
1606 1607
	return res;
}
1608
EXPORT_SYMBOL_GPL(nfs_lookup);
L
Linus Torvalds 已提交
1609

1610
#if IS_ENABLED(CONFIG_NFS_V4)
1611
static int nfs4_lookup_revalidate(struct dentry *, unsigned int);
L
Linus Torvalds 已提交
1612

A
Al Viro 已提交
1613
const struct dentry_operations nfs4_dentry_operations = {
1614
	.d_revalidate	= nfs4_lookup_revalidate,
1615
	.d_weak_revalidate	= nfs_weak_revalidate,
L
Linus Torvalds 已提交
1616 1617
	.d_delete	= nfs_dentry_delete,
	.d_iput		= nfs_dentry_iput,
1618
	.d_automount	= nfs_d_automount,
1619
	.d_release	= nfs_d_release,
L
Linus Torvalds 已提交
1620
};
1621
EXPORT_SYMBOL_GPL(nfs4_dentry_operations);
L
Linus Torvalds 已提交
1622

1623 1624 1625 1626 1627 1628 1629 1630 1631 1632
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;
}

1633
static struct nfs_open_context *create_nfs_open_context(struct dentry *dentry, int open_flags, struct file *filp)
1634
{
1635
	return alloc_nfs_open_context(dentry, flags_to_mode(open_flags), filp);
1636 1637 1638 1639
}

static int do_open(struct inode *inode, struct file *filp)
{
1640
	nfs_fscache_open_file(inode, filp);
1641 1642 1643
	return 0;
}

A
Al Viro 已提交
1644 1645
static int nfs_finish_open(struct nfs_open_context *ctx,
			   struct dentry *dentry,
1646
			   struct file *file, unsigned open_flags)
1647
{
1648 1649
	int err;

1650
	err = finish_open(file, dentry, do_open);
A
Al Viro 已提交
1651
	if (err)
A
Al Viro 已提交
1652
		goto out;
1653 1654 1655
	if (S_ISREG(file->f_path.dentry->d_inode->i_mode))
		nfs_file_set_open_context(file, ctx);
	else
1656
		err = -EOPENSTALE;
1657
out:
A
Al Viro 已提交
1658
	return err;
1659 1660
}

1661 1662
int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
		    struct file *file, unsigned open_flags,
1663
		    umode_t mode)
L
Linus Torvalds 已提交
1664
{
1665
	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
1666
	struct nfs_open_context *ctx;
1667 1668
	struct dentry *res;
	struct iattr attr = { .ia_valid = ATTR_OPEN };
1669
	struct inode *inode;
1670
	unsigned int lookup_flags = 0;
1671
	bool switched = false;
1672
	int created = 0;
1673
	int err;
L
Linus Torvalds 已提交
1674

1675
	/* Expect a negative dentry */
1676
	BUG_ON(d_inode(dentry));
1677

1678
	dfprintk(VFS, "NFS: atomic_open(%s/%lu), %pd\n",
1679
			dir->i_sb->s_id, dir->i_ino, dentry);
1680

1681 1682 1683 1684
	err = nfs_check_flags(open_flags);
	if (err)
		return err;

1685 1686
	/* NFS only supports OPEN on regular files */
	if ((open_flags & O_DIRECTORY)) {
1687
		if (!d_in_lookup(dentry)) {
1688 1689 1690 1691 1692
			/*
			 * Hashed negative dentry with O_DIRECTORY: dentry was
			 * revalidated and is fine, no need to perform lookup
			 * again
			 */
A
Al Viro 已提交
1693
			return -ENOENT;
1694
		}
1695
		lookup_flags = LOOKUP_OPEN|LOOKUP_DIRECTORY;
L
Linus Torvalds 已提交
1696
		goto no_open;
1697
	}
L
Linus Torvalds 已提交
1698

1699
	if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
A
Al Viro 已提交
1700
		return -ENAMETOOLONG;
1701

1702
	if (open_flags & O_CREAT) {
1703 1704 1705 1706 1707
		struct nfs_server *server = NFS_SERVER(dir);

		if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
			mode &= ~current_umask();

1708
		attr.ia_valid |= ATTR_MODE;
1709
		attr.ia_mode = mode;
1710
	}
1711 1712 1713
	if (open_flags & O_TRUNC) {
		attr.ia_valid |= ATTR_SIZE;
		attr.ia_size = 0;
1714 1715
	}

1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726
	if (!(open_flags & O_CREAT) && !d_in_lookup(dentry)) {
		d_drop(dentry);
		switched = true;
		dentry = d_alloc_parallel(dentry->d_parent,
					  &dentry->d_name, &wq);
		if (IS_ERR(dentry))
			return PTR_ERR(dentry);
		if (unlikely(!d_in_lookup(dentry)))
			return finish_no_open(file, dentry);
	}

1727
	ctx = create_nfs_open_context(dentry, open_flags, file);
1728 1729
	err = PTR_ERR(ctx);
	if (IS_ERR(ctx))
A
Al Viro 已提交
1730
		goto out;
1731

1732
	trace_nfs_atomic_open_enter(dir, ctx, open_flags);
1733 1734 1735
	inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr, &created);
	if (created)
		file->f_mode |= FMODE_CREATED;
1736
	if (IS_ERR(inode)) {
1737
		err = PTR_ERR(inode);
1738
		trace_nfs_atomic_open_exit(dir, ctx, open_flags, err);
1739
		put_nfs_open_context(ctx);
1740
		d_drop(dentry);
1741 1742
		switch (err) {
		case -ENOENT:
1743
			d_splice_alias(NULL, dentry);
1744
			nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1745 1746 1747 1748 1749 1750
			break;
		case -EISDIR:
		case -ENOTDIR:
			goto no_open;
		case -ELOOP:
			if (!(open_flags & O_NOFOLLOW))
1751
				goto no_open;
1752
			break;
L
Linus Torvalds 已提交
1753
			/* case -EINVAL: */
1754 1755
		default:
			break;
L
Linus Torvalds 已提交
1756
		}
A
Al Viro 已提交
1757
		goto out;
1758
	}
1759

1760
	err = nfs_finish_open(ctx, ctx->dentry, file, open_flags);
1761
	trace_nfs_atomic_open_exit(dir, ctx, open_flags, err);
1762
	put_nfs_open_context(ctx);
A
Al Viro 已提交
1763
out:
1764 1765 1766 1767
	if (unlikely(switched)) {
		d_lookup_done(dentry);
		dput(dentry);
	}
A
Al Viro 已提交
1768
	return err;
1769

L
Linus Torvalds 已提交
1770
no_open:
1771
	res = nfs_lookup(dir, dentry, lookup_flags);
1772 1773 1774 1775 1776 1777 1778
	if (switched) {
		d_lookup_done(dentry);
		if (!res)
			res = dentry;
		else
			dput(dentry);
	}
1779
	if (IS_ERR(res))
1780
		return PTR_ERR(res);
1781
	return finish_no_open(file, res);
L
Linus Torvalds 已提交
1782
}
1783
EXPORT_SYMBOL_GPL(nfs_atomic_open);
L
Linus Torvalds 已提交
1784

1785 1786 1787
static int
nfs4_do_lookup_revalidate(struct inode *dir, struct dentry *dentry,
			  unsigned int flags)
L
Linus Torvalds 已提交
1788
{
1789
	struct inode *inode;
L
Linus Torvalds 已提交
1790

1791
	if (!(flags & LOOKUP_OPEN) || (flags & LOOKUP_DIRECTORY))
1792
		goto full_reval;
1793
	if (d_mountpoint(dentry))
1794
		goto full_reval;
1795

1796
	inode = d_inode(dentry);
1797

L
Linus Torvalds 已提交
1798 1799 1800
	/* We can't create new files in nfs_open_revalidate(), so we
	 * optimize away revalidation of negative dentries.
	 */
1801 1802 1803
	if (inode == NULL)
		goto full_reval;

1804
	if (nfs_verifier_is_delegated(dentry))
1805
		return nfs_lookup_revalidate_delegated(dir, dentry, inode);
1806

L
Linus Torvalds 已提交
1807 1808
	/* NFS only supports OPEN on regular files */
	if (!S_ISREG(inode->i_mode))
1809 1810
		goto full_reval;

L
Linus Torvalds 已提交
1811
	/* We cannot do exclusive creation on a positive dentry */
1812 1813 1814 1815 1816 1817
	if (flags & (LOOKUP_EXCL | LOOKUP_REVAL))
		goto reval_dentry;

	/* Check if the directory changed */
	if (!nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU))
		goto reval_dentry;
L
Linus Torvalds 已提交
1818

1819
	/* Let f_op->open() actually open (and revalidate) the file */
1820 1821 1822 1823
	return 1;
reval_dentry:
	if (flags & LOOKUP_RCU)
		return -ECHILD;
1824
	return nfs_lookup_revalidate_dentry(dir, dentry, inode);
1825

1826 1827 1828
full_reval:
	return nfs_do_lookup_revalidate(dir, dentry, flags);
}
1829

1830 1831 1832 1833
static int nfs4_lookup_revalidate(struct dentry *dentry, unsigned int flags)
{
	return __nfs_lookup_revalidate(dentry, flags,
			nfs4_do_lookup_revalidate);
1834 1835
}

L
Linus Torvalds 已提交
1836 1837
#endif /* CONFIG_NFSV4 */

1838 1839
struct dentry *
nfs_add_or_obtain(struct dentry *dentry, struct nfs_fh *fhandle,
1840 1841
				struct nfs_fattr *fattr,
				struct nfs4_label *label)
L
Linus Torvalds 已提交
1842
{
1843
	struct dentry *parent = dget_parent(dentry);
1844
	struct inode *dir = d_inode(parent);
L
Linus Torvalds 已提交
1845
	struct inode *inode;
1846
	struct dentry *d;
1847
	int error;
L
Linus Torvalds 已提交
1848

1849 1850
	d_drop(dentry);

L
Linus Torvalds 已提交
1851
	if (fhandle->size == 0) {
1852
		error = NFS_PROTO(dir)->lookup(dir, dentry, fhandle, fattr, NULL);
L
Linus Torvalds 已提交
1853
		if (error)
1854
			goto out_error;
L
Linus Torvalds 已提交
1855
	}
1856
	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
L
Linus Torvalds 已提交
1857 1858
	if (!(fattr->valid & NFS_ATTR_FATTR)) {
		struct nfs_server *server = NFS_SB(dentry->d_sb);
1859 1860
		error = server->nfs_client->rpc_ops->getattr(server, fhandle,
				fattr, NULL, NULL);
L
Linus Torvalds 已提交
1861
		if (error < 0)
1862
			goto out_error;
L
Linus Torvalds 已提交
1863
	}
1864
	inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label);
1865
	d = d_splice_alias(inode, dentry);
1866 1867
out:
	dput(parent);
1868
	return d;
1869 1870
out_error:
	nfs_mark_for_revalidate(dir);
1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891
	d = ERR_PTR(error);
	goto out;
}
EXPORT_SYMBOL_GPL(nfs_add_or_obtain);

/*
 * Code common to create, mkdir, and mknod.
 */
int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
				struct nfs_fattr *fattr,
				struct nfs4_label *label)
{
	struct dentry *d;

	d = nfs_add_or_obtain(dentry, fhandle, fattr, label);
	if (IS_ERR(d))
		return PTR_ERR(d);

	/* Callers don't care */
	dput(d);
	return 0;
L
Linus Torvalds 已提交
1892
}
1893
EXPORT_SYMBOL_GPL(nfs_instantiate);
L
Linus Torvalds 已提交
1894 1895 1896 1897 1898 1899 1900

/*
 * 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.
 */
1901
int nfs_create(struct inode *dir, struct dentry *dentry,
1902
		umode_t mode, bool excl)
L
Linus Torvalds 已提交
1903 1904
{
	struct iattr attr;
1905
	int open_flags = excl ? O_CREAT | O_EXCL : O_CREAT;
L
Linus Torvalds 已提交
1906 1907
	int error;

1908
	dfprintk(VFS, "NFS: create(%s/%lu), %pd\n",
1909
			dir->i_sb->s_id, dir->i_ino, dentry);
L
Linus Torvalds 已提交
1910 1911 1912 1913

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

1914
	trace_nfs_create_enter(dir, dentry, open_flags);
1915
	error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags);
1916
	trace_nfs_create_exit(dir, dentry, open_flags, error);
L
Linus Torvalds 已提交
1917 1918 1919 1920 1921 1922 1923
	if (error != 0)
		goto out_err;
	return 0;
out_err:
	d_drop(dentry);
	return error;
}
1924
EXPORT_SYMBOL_GPL(nfs_create);
L
Linus Torvalds 已提交
1925 1926 1927 1928

/*
 * See comments for nfs_proc_create regarding failed operations.
 */
1929
int
A
Al Viro 已提交
1930
nfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
L
Linus Torvalds 已提交
1931 1932 1933 1934
{
	struct iattr attr;
	int status;

1935
	dfprintk(VFS, "NFS: mknod(%s/%lu), %pd\n",
1936
			dir->i_sb->s_id, dir->i_ino, dentry);
L
Linus Torvalds 已提交
1937 1938 1939 1940

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

1941
	trace_nfs_mknod_enter(dir, dentry);
L
Linus Torvalds 已提交
1942
	status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev);
1943
	trace_nfs_mknod_exit(dir, dentry, status);
L
Linus Torvalds 已提交
1944 1945 1946 1947 1948 1949 1950
	if (status != 0)
		goto out_err;
	return 0;
out_err:
	d_drop(dentry);
	return status;
}
1951
EXPORT_SYMBOL_GPL(nfs_mknod);
L
Linus Torvalds 已提交
1952 1953 1954 1955

/*
 * See comments for nfs_proc_create regarding failed operations.
 */
1956
int nfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
L
Linus Torvalds 已提交
1957 1958 1959 1960
{
	struct iattr attr;
	int error;

1961
	dfprintk(VFS, "NFS: mkdir(%s/%lu), %pd\n",
1962
			dir->i_sb->s_id, dir->i_ino, dentry);
L
Linus Torvalds 已提交
1963 1964 1965 1966

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

1967
	trace_nfs_mkdir_enter(dir, dentry);
L
Linus Torvalds 已提交
1968
	error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr);
1969
	trace_nfs_mkdir_exit(dir, dentry, error);
L
Linus Torvalds 已提交
1970 1971 1972 1973 1974 1975 1976
	if (error != 0)
		goto out_err;
	return 0;
out_err:
	d_drop(dentry);
	return error;
}
1977
EXPORT_SYMBOL_GPL(nfs_mkdir);
L
Linus Torvalds 已提交
1978

1979 1980
static void nfs_dentry_handle_enoent(struct dentry *dentry)
{
A
Al Viro 已提交
1981
	if (simple_positive(dentry))
1982 1983 1984
		d_delete(dentry);
}

1985
int nfs_rmdir(struct inode *dir, struct dentry *dentry)
L
Linus Torvalds 已提交
1986 1987 1988
{
	int error;

1989
	dfprintk(VFS, "NFS: rmdir(%s/%lu), %pd\n",
1990
			dir->i_sb->s_id, dir->i_ino, dentry);
L
Linus Torvalds 已提交
1991

1992
	trace_nfs_rmdir_enter(dir, dentry);
1993
	if (d_really_is_positive(dentry)) {
1994
		down_write(&NFS_I(d_inode(dentry))->rmdir_sem);
1995 1996 1997 1998
		error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
		/* Ensure the VFS deletes this inode */
		switch (error) {
		case 0:
1999
			clear_nlink(d_inode(dentry));
2000 2001 2002 2003
			break;
		case -ENOENT:
			nfs_dentry_handle_enoent(dentry);
		}
2004
		up_write(&NFS_I(d_inode(dentry))->rmdir_sem);
2005 2006
	} else
		error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
2007
	trace_nfs_rmdir_exit(dir, dentry, error);
L
Linus Torvalds 已提交
2008 2009 2010

	return error;
}
2011
EXPORT_SYMBOL_GPL(nfs_rmdir);
L
Linus Torvalds 已提交
2012 2013 2014 2015 2016 2017 2018 2019 2020 2021

/*
 * 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)
{
2022 2023
	struct inode *dir = d_inode(dentry->d_parent);
	struct inode *inode = d_inode(dentry);
L
Linus Torvalds 已提交
2024 2025
	int error = -EBUSY;
		
2026
	dfprintk(VFS, "NFS: safe_remove(%pd2)\n", dentry);
L
Linus Torvalds 已提交
2027 2028 2029 2030 2031 2032 2033

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

2034
	trace_nfs_remove_enter(dir, dentry);
L
Linus Torvalds 已提交
2035
	if (inode != NULL) {
2036
		error = NFS_PROTO(dir)->remove(dir, dentry);
L
Linus Torvalds 已提交
2037
		if (error == 0)
2038
			nfs_drop_nlink(inode);
L
Linus Torvalds 已提交
2039
	} else
2040
		error = NFS_PROTO(dir)->remove(dir, dentry);
2041 2042
	if (error == -ENOENT)
		nfs_dentry_handle_enoent(dentry);
2043
	trace_nfs_remove_exit(dir, dentry, error);
L
Linus Torvalds 已提交
2044 2045 2046 2047 2048 2049 2050 2051 2052
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.
 */
2053
int nfs_unlink(struct inode *dir, struct dentry *dentry)
L
Linus Torvalds 已提交
2054 2055 2056 2057
{
	int error;
	int need_rehash = 0;

2058
	dfprintk(VFS, "NFS: unlink(%s/%lu, %pd)\n", dir->i_sb->s_id,
2059
		dir->i_ino, dentry);
L
Linus Torvalds 已提交
2060

2061
	trace_nfs_unlink_enter(dir, dentry);
L
Linus Torvalds 已提交
2062
	spin_lock(&dentry->d_lock);
A
Al Viro 已提交
2063
	if (d_count(dentry) > 1) {
L
Linus Torvalds 已提交
2064
		spin_unlock(&dentry->d_lock);
T
Trond Myklebust 已提交
2065
		/* Start asynchronous writeout of the inode */
2066
		write_inode_now(d_inode(dentry), 0);
L
Linus Torvalds 已提交
2067
		error = nfs_sillyrename(dir, dentry);
2068
		goto out;
L
Linus Torvalds 已提交
2069 2070 2071 2072 2073 2074 2075
	}
	if (!d_unhashed(dentry)) {
		__d_drop(dentry);
		need_rehash = 1;
	}
	spin_unlock(&dentry->d_lock);
	error = nfs_safe_remove(dentry);
2076
	if (!error || error == -ENOENT) {
L
Linus Torvalds 已提交
2077 2078 2079
		nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
	} else if (need_rehash)
		d_rehash(dentry);
2080 2081
out:
	trace_nfs_unlink_exit(dir, dentry, error);
L
Linus Torvalds 已提交
2082 2083
	return error;
}
2084
EXPORT_SYMBOL_GPL(nfs_unlink);
L
Linus Torvalds 已提交
2085

2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100
/*
 * 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.
 */
2101
int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
L
Linus Torvalds 已提交
2102
{
2103 2104
	struct page *page;
	char *kaddr;
L
Linus Torvalds 已提交
2105
	struct iattr attr;
2106
	unsigned int pathlen = strlen(symname);
L
Linus Torvalds 已提交
2107 2108
	int error;

2109
	dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s)\n", dir->i_sb->s_id,
2110
		dir->i_ino, dentry, symname);
L
Linus Torvalds 已提交
2111

2112 2113
	if (pathlen > PAGE_SIZE)
		return -ENAMETOOLONG;
L
Linus Torvalds 已提交
2114

2115 2116
	attr.ia_mode = S_IFLNK | S_IRWXUGO;
	attr.ia_valid = ATTR_MODE;
L
Linus Torvalds 已提交
2117

2118
	page = alloc_page(GFP_USER);
2119
	if (!page)
2120 2121
		return -ENOMEM;

2122
	kaddr = page_address(page);
2123 2124 2125 2126
	memcpy(kaddr, symname, pathlen);
	if (pathlen < PAGE_SIZE)
		memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen);

2127
	trace_nfs_symlink_enter(dir, dentry);
2128
	error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr);
2129
	trace_nfs_symlink_exit(dir, dentry, error);
2130
	if (error != 0) {
2131
		dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s) error %d\n",
2132
			dir->i_sb->s_id, dir->i_ino,
2133
			dentry, symname, error);
L
Linus Torvalds 已提交
2134
		d_drop(dentry);
2135 2136 2137 2138 2139 2140 2141 2142
		__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.
	 */
2143
	if (!add_to_page_cache_lru(page, d_inode(dentry)->i_mapping, 0,
2144 2145 2146
							GFP_KERNEL)) {
		SetPageUptodate(page);
		unlock_page(page);
2147 2148 2149 2150
		/*
		 * add_to_page_cache_lru() grabs an extra page refcount.
		 * Drop it here to avoid leaking this page later.
		 */
2151
		put_page(page);
2152 2153 2154 2155
	} else
		__free_page(page);

	return 0;
L
Linus Torvalds 已提交
2156
}
2157
EXPORT_SYMBOL_GPL(nfs_symlink);
L
Linus Torvalds 已提交
2158

2159
int
L
Linus Torvalds 已提交
2160 2161
nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
{
2162
	struct inode *inode = d_inode(old_dentry);
L
Linus Torvalds 已提交
2163 2164
	int error;

2165 2166
	dfprintk(VFS, "NFS: link(%pd2 -> %pd2)\n",
		old_dentry, dentry);
L
Linus Torvalds 已提交
2167

2168
	trace_nfs_link_enter(inode, dir, dentry);
2169
	d_drop(dentry);
L
Linus Torvalds 已提交
2170
	error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name);
2171
	if (error == 0) {
A
Al Viro 已提交
2172
		ihold(inode);
2173
		d_add(dentry, inode);
2174
	}
2175
	trace_nfs_link_exit(inode, dir, dentry, error);
L
Linus Torvalds 已提交
2176 2177
	return error;
}
2178
EXPORT_SYMBOL_GPL(nfs_link);
L
Linus Torvalds 已提交
2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203

/*
 * 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.
 */
2204
int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
2205 2206
	       struct inode *new_dir, struct dentry *new_dentry,
	       unsigned int flags)
L
Linus Torvalds 已提交
2207
{
2208 2209
	struct inode *old_inode = d_inode(old_dentry);
	struct inode *new_inode = d_inode(new_dentry);
2210
	struct dentry *dentry = NULL, *rehash = NULL;
2211
	struct rpc_task *task;
L
Linus Torvalds 已提交
2212 2213
	int error = -EBUSY;

2214 2215 2216
	if (flags)
		return -EINVAL;

2217 2218
	dfprintk(VFS, "NFS: rename(%pd2 -> %pd2, ct=%d)\n",
		 old_dentry, new_dentry,
A
Al Viro 已提交
2219
		 d_count(new_dentry));
L
Linus Torvalds 已提交
2220

2221
	trace_nfs_rename_enter(old_dir, old_dentry, new_dir, new_dentry);
L
Linus Torvalds 已提交
2222
	/*
2223 2224 2225 2226
	 * 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 已提交
2227
	 */
2228 2229 2230 2231 2232
	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.
		 */
2233
		if (!d_unhashed(new_dentry)) {
2234
			d_drop(new_dentry);
2235 2236
			rehash = new_dentry;
		}
L
Linus Torvalds 已提交
2237

A
Al Viro 已提交
2238
		if (d_count(new_dentry) > 2) {
2239 2240 2241 2242 2243 2244 2245 2246 2247 2248
			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);
2249
			if (err)
2250
				goto out;
2251 2252

			new_dentry = dentry;
2253
			rehash = NULL;
2254
			new_inode = NULL;
2255
		}
2256
	}
L
Linus Torvalds 已提交
2257

2258
	task = nfs_async_rename(old_dir, new_dir, old_dentry, new_dentry, NULL);
2259 2260 2261 2262 2263 2264
	if (IS_ERR(task)) {
		error = PTR_ERR(task);
		goto out;
	}

	error = rpc_wait_for_completion_task(task);
2265 2266 2267 2268 2269
	if (error != 0) {
		((struct nfs_renamedata *)task->tk_calldata)->cancelled = 1;
		/* Paired with the atomic_dec_and_test() barrier in rpc_do_put_task() */
		smp_wmb();
	} else
2270 2271
		error = task->tk_status;
	rpc_put_task(task);
2272 2273 2274 2275 2276 2277 2278 2279 2280
	/* Ensure the inode attributes are revalidated */
	if (error == 0) {
		spin_lock(&old_inode->i_lock);
		NFS_I(old_inode)->attr_gencount = nfs_inc_attr_generation_counter();
		NFS_I(old_inode)->cache_validity |= NFS_INO_INVALID_CHANGE
			| NFS_INO_INVALID_CTIME
			| NFS_INO_REVAL_FORCED;
		spin_unlock(&old_inode->i_lock);
	}
L
Linus Torvalds 已提交
2281
out:
2282 2283
	if (rehash)
		d_rehash(rehash);
2284 2285
	trace_nfs_rename_exit(old_dir, old_dentry,
			new_dir, new_dentry, error);
2286 2287 2288 2289 2290 2291 2292 2293 2294 2295
	if (!error) {
		if (new_inode != NULL)
			nfs_drop_nlink(new_inode);
		/*
		 * The d_move() should be here instead of in an async RPC completion
		 * handler because we need the proper locks to move the dentry.  If
		 * we're interrupted by a signal, the async RPC completion handler
		 * should mark the directories for revalidation.
		 */
		d_move(old_dentry, new_dentry);
2296
		nfs_set_verifier(old_dentry,
2297 2298 2299 2300
					nfs_save_change_attribute(new_dir));
	} else if (error == -ENOENT)
		nfs_dentry_handle_enoent(old_dentry);

L
Linus Torvalds 已提交
2301 2302 2303 2304 2305
	/* new dentry created? */
	if (dentry)
		dput(dentry);
	return error;
}
2306
EXPORT_SYMBOL_GPL(nfs_rename);
L
Linus Torvalds 已提交
2307

2308 2309 2310 2311
static DEFINE_SPINLOCK(nfs_access_lru_lock);
static LIST_HEAD(nfs_access_lru_list);
static atomic_long_t nfs_access_nr_entries;

2312 2313 2314 2315
static unsigned long nfs_access_max_cachesize = ULONG_MAX;
module_param(nfs_access_max_cachesize, ulong, 0644);
MODULE_PARM_DESC(nfs_access_max_cachesize, "NFS access maximum total cache length");

2316 2317
static void nfs_access_free_entry(struct nfs_access_entry *entry)
{
2318
	put_cred(entry->cred);
2319
	kfree_rcu(entry, rcu_head);
2320
	smp_mb__before_atomic();
2321
	atomic_long_dec(&nfs_access_nr_entries);
2322
	smp_mb__after_atomic();
2323 2324
}

2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335
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);
	}
}

2336 2337
static unsigned long
nfs_do_access_cache_scan(unsigned int nr_to_scan)
2338 2339
{
	LIST_HEAD(head);
2340
	struct nfs_inode *nfsi, *next;
2341
	struct nfs_access_entry *cache;
2342
	long freed = 0;
2343

2344
	spin_lock(&nfs_access_lru_lock);
2345
	list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) {
2346 2347 2348 2349
		struct inode *inode;

		if (nr_to_scan-- == 0)
			break;
2350
		inode = &nfsi->vfs_inode;
2351 2352 2353 2354 2355 2356 2357
		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);
2358
		freed++;
2359 2360 2361 2362 2363 2364
		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);
2365
			smp_mb__before_atomic();
2366
			clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags);
2367
			smp_mb__after_atomic();
2368
		}
2369
		spin_unlock(&inode->i_lock);
2370 2371
	}
	spin_unlock(&nfs_access_lru_lock);
2372
	nfs_access_free_list(&head);
2373 2374 2375
	return freed;
}

2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387
unsigned long
nfs_access_cache_scan(struct shrinker *shrink, struct shrink_control *sc)
{
	int nr_to_scan = sc->nr_to_scan;
	gfp_t gfp_mask = sc->gfp_mask;

	if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL)
		return SHRINK_STOP;
	return nfs_do_access_cache_scan(nr_to_scan);
}


2388 2389 2390
unsigned long
nfs_access_cache_count(struct shrinker *shrink, struct shrink_control *sc)
{
2391
	return vfs_pressure_ratio(atomic_long_read(&nfs_access_nr_entries));
2392 2393
}

2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409
static void
nfs_access_cache_enforce_limit(void)
{
	long nr_entries = atomic_long_read(&nfs_access_nr_entries);
	unsigned long diff;
	unsigned int nr_to_scan;

	if (nr_entries < 0 || nr_entries <= nfs_access_max_cachesize)
		return;
	nr_to_scan = 100;
	diff = nr_entries - nfs_access_max_cachesize;
	if (diff < nr_to_scan)
		nr_to_scan = diff;
	nfs_do_access_cache_scan(nr_to_scan);
}

2410
static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head)
L
Linus Torvalds 已提交
2411
{
2412
	struct rb_root *root_node = &nfsi->access_cache;
2413
	struct rb_node *n;
2414 2415 2416 2417 2418 2419
	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);
2420
		list_move(&entry->lru, head);
2421 2422
	}
	nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS;
L
Linus Torvalds 已提交
2423 2424
}

2425
void nfs_access_zap_cache(struct inode *inode)
L
Linus Torvalds 已提交
2426
{
2427 2428 2429 2430
	LIST_HEAD(head);

	if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0)
		return;
2431
	/* Remove from global LRU init */
2432 2433
	spin_lock(&nfs_access_lru_lock);
	if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
2434 2435
		list_del_init(&NFS_I(inode)->access_cache_inode_lru);

2436
	spin_lock(&inode->i_lock);
2437 2438 2439 2440
	__nfs_access_zap_cache(NFS_I(inode), &head);
	spin_unlock(&inode->i_lock);
	spin_unlock(&nfs_access_lru_lock);
	nfs_access_free_list(&head);
2441
}
2442
EXPORT_SYMBOL_GPL(nfs_access_zap_cache);
L
Linus Torvalds 已提交
2443

2444
static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, const struct cred *cred)
2445 2446 2447 2448
{
	struct rb_node *n = NFS_I(inode)->access_cache.rb_node;

	while (n != NULL) {
2449 2450 2451
		struct nfs_access_entry *entry =
			rb_entry(n, struct nfs_access_entry, rb_node);
		int cmp = cred_fscmp(cred, entry->cred);
2452

2453
		if (cmp < 0)
2454
			n = n->rb_left;
2455
		else if (cmp > 0)
2456 2457 2458
			n = n->rb_right;
		else
			return entry;
L
Linus Torvalds 已提交
2459
	}
2460 2461 2462
	return NULL;
}

2463
static int nfs_access_get_cached(struct inode *inode, const struct cred *cred, struct nfs_access_entry *res, bool may_block)
2464 2465 2466
{
	struct nfs_inode *nfsi = NFS_I(inode);
	struct nfs_access_entry *cache;
2467 2468
	bool retry = true;
	int err;
2469

2470
	spin_lock(&inode->i_lock);
2471 2472 2473 2474 2475 2476 2477 2478
	for(;;) {
		if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)
			goto out_zap;
		cache = nfs_access_search_rbtree(inode, cred);
		err = -ENOENT;
		if (cache == NULL)
			goto out;
		/* Found an entry, is our attribute cache valid? */
2479
		if (!nfs_check_cache_invalid(inode, NFS_INO_INVALID_ACCESS))
2480
			break;
2481 2482
		if (!retry)
			break;
2483 2484 2485 2486 2487 2488 2489 2490 2491 2492
		err = -ECHILD;
		if (!may_block)
			goto out;
		spin_unlock(&inode->i_lock);
		err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
		if (err)
			return err;
		spin_lock(&inode->i_lock);
		retry = false;
	}
2493 2494
	res->cred = cache->cred;
	res->mask = cache->mask;
2495
	list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru);
2496 2497 2498 2499 2500
	err = 0;
out:
	spin_unlock(&inode->i_lock);
	return err;
out_zap:
2501 2502
	spin_unlock(&inode->i_lock);
	nfs_access_zap_cache(inode);
2503 2504 2505
	return -ENOENT;
}

2506
static int nfs_access_get_cached_rcu(struct inode *inode, const struct cred *cred, struct nfs_access_entry *res)
2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521
{
	/* Only check the most recently returned cache entry,
	 * but do it without locking.
	 */
	struct nfs_inode *nfsi = NFS_I(inode);
	struct nfs_access_entry *cache;
	int err = -ECHILD;
	struct list_head *lh;

	rcu_read_lock();
	if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)
		goto out;
	lh = rcu_dereference(nfsi->access_cache_entry_lru.prev);
	cache = list_entry(lh, struct nfs_access_entry, lru);
	if (lh == &nfsi->access_cache_entry_lru ||
2522
	    cred_fscmp(cred, cache->cred) != 0)
2523 2524 2525
		cache = NULL;
	if (cache == NULL)
		goto out;
2526
	if (nfs_check_cache_invalid(inode, NFS_INO_INVALID_ACCESS))
2527 2528 2529
		goto out;
	res->cred = cache->cred;
	res->mask = cache->mask;
2530
	err = 0;
2531 2532 2533 2534 2535
out:
	rcu_read_unlock();
	return err;
}

2536 2537
static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set)
{
2538 2539
	struct nfs_inode *nfsi = NFS_I(inode);
	struct rb_root *root_node = &nfsi->access_cache;
2540 2541 2542
	struct rb_node **p = &root_node->rb_node;
	struct rb_node *parent = NULL;
	struct nfs_access_entry *entry;
2543
	int cmp;
2544 2545 2546 2547 2548

	spin_lock(&inode->i_lock);
	while (*p != NULL) {
		parent = *p;
		entry = rb_entry(parent, struct nfs_access_entry, rb_node);
2549
		cmp = cred_fscmp(set->cred, entry->cred);
2550

2551
		if (cmp < 0)
2552
			p = &parent->rb_left;
2553
		else if (cmp > 0)
2554 2555 2556 2557 2558 2559
			p = &parent->rb_right;
		else
			goto found;
	}
	rb_link_node(&set->rb_node, parent, p);
	rb_insert_color(&set->rb_node, root_node);
2560
	list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
2561
	spin_unlock(&inode->i_lock);
2562 2563 2564
	return;
found:
	rb_replace_node(parent, &set->rb_node, root_node);
2565 2566
	list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
	list_del(&entry->lru);
2567 2568 2569 2570
	spin_unlock(&inode->i_lock);
	nfs_access_free_entry(entry);
}

2571
void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set)
2572 2573 2574 2575 2576
{
	struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL);
	if (cache == NULL)
		return;
	RB_CLEAR_NODE(&cache->rb_node);
2577
	cache->cred = get_cred(set->cred);
L
Linus Torvalds 已提交
2578
	cache->mask = set->mask;
2579

2580 2581 2582 2583 2584
	/* The above field assignments must be visible
	 * before this item appears on the lru.  We cannot easily
	 * use rcu_assign_pointer, so just force the memory barrier.
	 */
	smp_wmb();
2585
	nfs_access_add_rbtree(inode, cache);
2586 2587

	/* Update accounting */
2588
	smp_mb__before_atomic();
2589
	atomic_long_inc(&nfs_access_nr_entries);
2590
	smp_mb__after_atomic();
2591 2592

	/* Add inode to global LRU list */
2593
	if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) {
2594
		spin_lock(&nfs_access_lru_lock);
2595 2596 2597
		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);
2598 2599
		spin_unlock(&nfs_access_lru_lock);
	}
2600
	nfs_access_cache_enforce_limit();
L
Linus Torvalds 已提交
2601
}
2602 2603
EXPORT_SYMBOL_GPL(nfs_access_add_cache);

2604 2605 2606 2607 2608 2609
#define NFS_MAY_READ (NFS_ACCESS_READ)
#define NFS_MAY_WRITE (NFS_ACCESS_MODIFY | \
		NFS_ACCESS_EXTEND | \
		NFS_ACCESS_DELETE)
#define NFS_FILE_MAY_WRITE (NFS_ACCESS_MODIFY | \
		NFS_ACCESS_EXTEND)
2610
#define NFS_DIR_MAY_WRITE NFS_MAY_WRITE
2611 2612
#define NFS_MAY_LOOKUP (NFS_ACCESS_LOOKUP)
#define NFS_MAY_EXECUTE (NFS_ACCESS_EXECUTE)
2613
static int
2614
nfs_access_calc_mask(u32 access_result, umode_t umode)
2615 2616 2617 2618 2619
{
	int mask = 0;

	if (access_result & NFS_MAY_READ)
		mask |= MAY_READ;
2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631
	if (S_ISDIR(umode)) {
		if ((access_result & NFS_DIR_MAY_WRITE) == NFS_DIR_MAY_WRITE)
			mask |= MAY_WRITE;
		if ((access_result & NFS_MAY_LOOKUP) == NFS_MAY_LOOKUP)
			mask |= MAY_EXEC;
	} else if (S_ISREG(umode)) {
		if ((access_result & NFS_FILE_MAY_WRITE) == NFS_FILE_MAY_WRITE)
			mask |= MAY_WRITE;
		if ((access_result & NFS_MAY_EXECUTE) == NFS_MAY_EXECUTE)
			mask |= MAY_EXEC;
	} else if (access_result & NFS_MAY_WRITE)
			mask |= MAY_WRITE;
2632 2633 2634
	return mask;
}

2635 2636
void nfs_access_set_mask(struct nfs_access_entry *entry, u32 access_result)
{
2637
	entry->mask = access_result;
2638 2639
}
EXPORT_SYMBOL_GPL(nfs_access_set_mask);
L
Linus Torvalds 已提交
2640

2641
static int nfs_do_access(struct inode *inode, const struct cred *cred, int mask)
L
Linus Torvalds 已提交
2642 2643
{
	struct nfs_access_entry cache;
2644
	bool may_block = (mask & MAY_NOT_BLOCK) == 0;
2645
	int cache_mask = -1;
L
Linus Torvalds 已提交
2646 2647
	int status;

2648 2649
	trace_nfs_access_enter(inode);

2650 2651
	status = nfs_access_get_cached_rcu(inode, cred, &cache);
	if (status != 0)
2652
		status = nfs_access_get_cached(inode, cred, &cache, may_block);
L
Linus Torvalds 已提交
2653
	if (status == 0)
2654
		goto out_cached;
L
Linus Torvalds 已提交
2655

2656
	status = -ECHILD;
2657
	if (!may_block)
2658 2659
		goto out;

2660 2661 2662 2663 2664 2665 2666 2667
	/*
	 * Determine which access bits we want to ask for...
	 */
	cache.mask = NFS_ACCESS_READ | NFS_ACCESS_MODIFY | NFS_ACCESS_EXTEND;
	if (S_ISDIR(inode->i_mode))
		cache.mask |= NFS_ACCESS_DELETE | NFS_ACCESS_LOOKUP;
	else
		cache.mask |= NFS_ACCESS_EXECUTE;
L
Linus Torvalds 已提交
2668 2669
	cache.cred = cred;
	status = NFS_PROTO(inode)->access(inode, &cache);
2670 2671 2672 2673 2674 2675
	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);
		}
2676
		goto out;
2677
	}
L
Linus Torvalds 已提交
2678
	nfs_access_add_cache(inode, &cache);
2679
out_cached:
2680
	cache_mask = nfs_access_calc_mask(cache.mask, inode->i_mode);
2681
	if ((mask & ~cache_mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) != 0)
2682
		status = -EACCES;
L
Linus Torvalds 已提交
2683
out:
2684
	trace_nfs_access_exit(inode, mask, cache_mask, status);
2685
	return status;
L
Linus Torvalds 已提交
2686 2687
}

2688 2689 2690 2691
static int nfs_open_permission_mask(int openflags)
{
	int mask = 0;

2692 2693 2694 2695 2696 2697 2698 2699 2700 2701
	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;
	}

2702 2703 2704
	return mask;
}

2705
int nfs_may_open(struct inode *inode, const struct cred *cred, int openflags)
2706 2707 2708
{
	return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags));
}
2709
EXPORT_SYMBOL_GPL(nfs_may_open);
2710

2711 2712 2713
static int nfs_execute_ok(struct inode *inode, int mask)
{
	struct nfs_server *server = NFS_SERVER(inode);
2714
	int ret = 0;
2715

2716 2717
	if (S_ISDIR(inode->i_mode))
		return 0;
2718
	if (nfs_check_cache_invalid(inode, NFS_INO_INVALID_OTHER)) {
2719 2720 2721 2722
		if (mask & MAY_NOT_BLOCK)
			return -ECHILD;
		ret = __nfs_revalidate_inode(server, inode);
	}
2723 2724 2725 2726 2727
	if (ret == 0 && !execute_ok(inode))
		ret = -EACCES;
	return ret;
}

2728
int nfs_permission(struct inode *inode, int mask)
L
Linus Torvalds 已提交
2729
{
2730
	const struct cred *cred = current_cred();
L
Linus Torvalds 已提交
2731 2732
	int res = 0;

2733 2734
	nfs_inc_stats(inode, NFSIOS_VFSACCESS);

2735
	if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
L
Linus Torvalds 已提交
2736 2737
		goto out;
	/* Is this sys_access() ? */
E
Eric Paris 已提交
2738
	if (mask & (MAY_ACCESS | MAY_CHDIR))
L
Linus Torvalds 已提交
2739 2740 2741 2742 2743 2744
		goto force_lookup;

	switch (inode->i_mode & S_IFMT) {
		case S_IFLNK:
			goto out;
		case S_IFREG:
2745 2746 2747
			if ((mask & MAY_OPEN) &&
			   nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN))
				return 0;
L
Linus Torvalds 已提交
2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761
			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;

2762 2763
	/* Always try fast lookups first */
	rcu_read_lock();
2764
	res = nfs_do_access(inode, cred, mask|MAY_NOT_BLOCK);
2765 2766 2767
	rcu_read_unlock();
	if (res == -ECHILD && !(mask & MAY_NOT_BLOCK)) {
		/* Fast lookup failed, try the slow way */
2768
		res = nfs_do_access(inode, cred, mask);
2769
	}
L
Linus Torvalds 已提交
2770
out:
2771 2772
	if (!res && (mask & MAY_EXEC))
		res = nfs_execute_ok(inode, mask);
2773

2774
	dfprintk(VFS, "NFS: permission(%s/%lu), mask=0x%x, res=%d\n",
2775
		inode->i_sb->s_id, inode->i_ino, mask, res);
L
Linus Torvalds 已提交
2776 2777
	return res;
out_notsup:
2778 2779 2780
	if (mask & MAY_NOT_BLOCK)
		return -ECHILD;

L
Linus Torvalds 已提交
2781 2782
	res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
	if (res == 0)
2783
		res = generic_permission(inode, mask);
2784
	goto out;
L
Linus Torvalds 已提交
2785
}
2786
EXPORT_SYMBOL_GPL(nfs_permission);
L
Linus Torvalds 已提交
2787 2788 2789 2790 2791 2792 2793

/*
 * Local variables:
 *  version-control: t
 *  kept-new-versions: 5
 * End:
 */
反馈
建议
客服 返回
顶部