dir.c 58.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
/*
 *  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
 */

#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>
32
#include <linux/pagevec.h>
L
Linus Torvalds 已提交
33
#include <linux/namei.h>
34
#include <linux/mount.h>
A
Alexey Dobriyan 已提交
35
#include <linux/sched.h>
36
#include <linux/kmemleak.h>
37
#include <linux/xattr.h>
L
Linus Torvalds 已提交
38 39

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

/* #define NFS_DEBUG_VERBOSE 1 */

static int nfs_opendir(struct inode *, struct file *);
47
static int nfs_closedir(struct inode *, struct file *);
L
Linus Torvalds 已提交
48 49 50 51 52 53 54 55 56 57 58
static int nfs_readdir(struct file *, void *, filldir_t);
static struct dentry *nfs_lookup(struct inode *, struct dentry *, struct nameidata *);
static int nfs_create(struct inode *, struct dentry *, int, struct nameidata *);
static int nfs_mkdir(struct inode *, struct dentry *, int);
static int nfs_rmdir(struct inode *, struct dentry *);
static int nfs_unlink(struct inode *, struct dentry *);
static int nfs_symlink(struct inode *, struct dentry *, const char *);
static int nfs_link(struct dentry *, struct inode *, struct dentry *);
static int nfs_mknod(struct inode *, struct dentry *, int, dev_t);
static int nfs_rename(struct inode *, struct dentry *,
		      struct inode *, struct dentry *);
59
static int nfs_fsync_dir(struct file *, loff_t, loff_t, int);
60
static loff_t nfs_llseek_dir(struct file *, loff_t, int);
61
static void nfs_readdir_clear_array(struct page*);
L
Linus Torvalds 已提交
62

63
const struct file_operations nfs_dir_operations = {
64
	.llseek		= nfs_llseek_dir,
L
Linus Torvalds 已提交
65 66 67
	.read		= generic_read_dir,
	.readdir	= nfs_readdir,
	.open		= nfs_opendir,
68
	.release	= nfs_closedir,
L
Linus Torvalds 已提交
69 70 71
	.fsync		= nfs_fsync_dir,
};

72
const struct inode_operations nfs_dir_inode_operations = {
L
Linus Torvalds 已提交
73 74 75 76 77 78 79 80 81 82 83 84 85 86
	.create		= nfs_create,
	.lookup		= nfs_lookup,
	.link		= nfs_link,
	.unlink		= nfs_unlink,
	.symlink	= nfs_symlink,
	.mkdir		= nfs_mkdir,
	.rmdir		= nfs_rmdir,
	.mknod		= nfs_mknod,
	.rename		= nfs_rename,
	.permission	= nfs_permission,
	.getattr	= nfs_getattr,
	.setattr	= nfs_setattr,
};

87 88
const struct address_space_operations nfs_dir_aops = {
	.freepage = nfs_readdir_clear_array,
B
Bryan Schumaker 已提交
89 90
};

91
#ifdef CONFIG_NFS_V3
92
const struct inode_operations nfs3_dir_inode_operations = {
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
	.create		= nfs_create,
	.lookup		= nfs_lookup,
	.link		= nfs_link,
	.unlink		= nfs_unlink,
	.symlink	= nfs_symlink,
	.mkdir		= nfs_mkdir,
	.rmdir		= nfs_rmdir,
	.mknod		= nfs_mknod,
	.rename		= nfs_rename,
	.permission	= nfs_permission,
	.getattr	= nfs_getattr,
	.setattr	= nfs_setattr,
	.listxattr	= nfs3_listxattr,
	.getxattr	= nfs3_getxattr,
	.setxattr	= nfs3_setxattr,
	.removexattr	= nfs3_removexattr,
};
#endif  /* CONFIG_NFS_V3 */

L
Linus Torvalds 已提交
112 113 114
#ifdef CONFIG_NFS_V4

static struct dentry *nfs_atomic_lookup(struct inode *, struct dentry *, struct nameidata *);
115
static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd);
116
const struct inode_operations nfs4_dir_inode_operations = {
117
	.create		= nfs_open_create,
L
Linus Torvalds 已提交
118 119 120 121 122 123 124 125 126 127 128
	.lookup		= nfs_atomic_lookup,
	.link		= nfs_link,
	.unlink		= nfs_unlink,
	.symlink	= nfs_symlink,
	.mkdir		= nfs_mkdir,
	.rmdir		= nfs_rmdir,
	.mknod		= nfs_mknod,
	.rename		= nfs_rename,
	.permission	= nfs_permission,
	.getattr	= nfs_getattr,
	.setattr	= nfs_setattr,
129 130 131 132
	.getxattr	= generic_getxattr,
	.setxattr	= generic_setxattr,
	.listxattr	= generic_listxattr,
	.removexattr	= generic_removexattr,
L
Linus Torvalds 已提交
133 134 135 136
};

#endif /* CONFIG_NFS_V4 */

137 138 139 140 141
static struct nfs_open_dir_context *alloc_nfs_open_dir_context(struct rpc_cred *cred)
{
	struct nfs_open_dir_context *ctx;
	ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
	if (ctx != NULL) {
142
		ctx->duped = 0;
143
		ctx->dir_cookie = 0;
144
		ctx->dup_cookie = 0;
145 146 147 148 149 150 151 152 153 154 155 156
		ctx->cred = get_rpccred(cred);
	} else
		ctx = ERR_PTR(-ENOMEM);
	return ctx;
}

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

L
Linus Torvalds 已提交
157 158 159 160 161 162
/*
 * Open file
 */
static int
nfs_opendir(struct inode *inode, struct file *filp)
{
163 164 165
	int res = 0;
	struct nfs_open_dir_context *ctx;
	struct rpc_cred *cred;
L
Linus Torvalds 已提交
166

C
Chuck Lever 已提交
167
	dfprintk(FILE, "NFS: open dir(%s/%s)\n",
168 169 170 171
			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 已提交
172

173 174 175 176 177 178 179 180 181
	cred = rpc_lookup_cred();
	if (IS_ERR(cred))
		return PTR_ERR(cred);
	ctx = alloc_nfs_open_dir_context(cred);
	if (IS_ERR(ctx)) {
		res = PTR_ERR(ctx);
		goto out;
	}
	filp->private_data = ctx;
182 183 184 185 186 187 188
	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);
	}
189 190
out:
	put_rpccred(cred);
L
Linus Torvalds 已提交
191 192 193
	return res;
}

194 195 196 197 198 199 200
static int
nfs_closedir(struct inode *inode, struct file *filp)
{
	put_nfs_open_dir_context(filp->private_data);
	return 0;
}

B
Bryan Schumaker 已提交
201 202 203 204
struct nfs_cache_array_entry {
	u64 cookie;
	u64 ino;
	struct qstr string;
205
	unsigned char d_type;
B
Bryan Schumaker 已提交
206 207 208 209 210 211 212 213 214
};

struct nfs_cache_array {
	unsigned int size;
	int eof_index;
	u64 last_cookie;
	struct nfs_cache_array_entry array[0];
};

215
typedef int (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, int);
L
Linus Torvalds 已提交
216 217 218 219
typedef struct {
	struct file	*file;
	struct page	*page;
	unsigned long	page_index;
220
	u64		*dir_cookie;
221
	u64		last_cookie;
222
	loff_t		current_index;
L
Linus Torvalds 已提交
223
	decode_dirent_t	decode;
B
Bryan Schumaker 已提交
224

225
	unsigned long	timestamp;
226
	unsigned long	gencount;
B
Bryan Schumaker 已提交
227 228 229
	unsigned int	cache_entry_index;
	unsigned int	plus:1;
	unsigned int	eof:1;
L
Linus Torvalds 已提交
230 231
} nfs_readdir_descriptor_t;

B
Bryan Schumaker 已提交
232 233
/*
 * The caller is responsible for calling nfs_readdir_release_array(page)
L
Linus Torvalds 已提交
234 235
 */
static
B
Bryan Schumaker 已提交
236 237
struct nfs_cache_array *nfs_readdir_get_array(struct page *page)
{
238
	void *ptr;
B
Bryan Schumaker 已提交
239 240
	if (page == NULL)
		return ERR_PTR(-EIO);
241 242 243 244
	ptr = kmap(page);
	if (ptr == NULL)
		return ERR_PTR(-ENOMEM);
	return ptr;
B
Bryan Schumaker 已提交
245 246 247 248 249 250 251 252 253 254 255 256
}

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

/*
 * we are freeing strings created by nfs_add_to_readdir_array()
 */
static
257
void nfs_readdir_clear_array(struct page *page)
B
Bryan Schumaker 已提交
258
{
259
	struct nfs_cache_array *array;
B
Bryan Schumaker 已提交
260
	int i;
261

262
	array = kmap_atomic(page, KM_USER0);
B
Bryan Schumaker 已提交
263 264
	for (i = 0; i < array->size; i++)
		kfree(array->array[i].string.name);
265
	kunmap_atomic(array, KM_USER0);
B
Bryan Schumaker 已提交
266 267 268 269 270 271 272 273
}

/*
 * 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
274
int nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int len)
B
Bryan Schumaker 已提交
275 276 277
{
	string->len = len;
	string->name = kmemdup(name, len, GFP_KERNEL);
278 279
	if (string->name == NULL)
		return -ENOMEM;
280 281 282 283 284
	/*
	 * 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);
285 286
	string->hash = full_name_hash(name, len);
	return 0;
B
Bryan Schumaker 已提交
287 288 289 290 291 292
}

static
int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page)
{
	struct nfs_cache_array *array = nfs_readdir_get_array(page);
293 294 295
	struct nfs_cache_array_entry *cache_entry;
	int ret;

B
Bryan Schumaker 已提交
296 297
	if (IS_ERR(array))
		return PTR_ERR(array);
298 299 300 301

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

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

306 307
	cache_entry->cookie = entry->prev_cookie;
	cache_entry->ino = entry->ino;
308
	cache_entry->d_type = entry->d_type;
309 310 311
	ret = nfs_readdir_make_qstr(&cache_entry->string, entry->name, entry->len);
	if (ret)
		goto out;
B
Bryan Schumaker 已提交
312
	array->last_cookie = entry->cookie;
313
	array->size++;
T
Trond Myklebust 已提交
314
	if (entry->eof != 0)
B
Bryan Schumaker 已提交
315
		array->eof_index = array->size;
316
out:
B
Bryan Schumaker 已提交
317
	nfs_readdir_release_array(page);
318
	return ret;
B
Bryan Schumaker 已提交
319 320 321 322 323 324 325
}

static
int nfs_readdir_search_for_pos(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
{
	loff_t diff = desc->file->f_pos - desc->current_index;
	unsigned int index;
326
	struct nfs_open_dir_context *ctx = desc->file->private_data;
B
Bryan Schumaker 已提交
327 328 329 330

	if (diff < 0)
		goto out_eof;
	if (diff >= array->size) {
331
		if (array->eof_index >= 0)
B
Bryan Schumaker 已提交
332 333 334 335 336 337 338
			goto out_eof;
		return -EAGAIN;
	}

	index = (unsigned int)diff;
	*desc->dir_cookie = array->array[index].cookie;
	desc->cache_entry_index = index;
339
	ctx->duped = 0;
B
Bryan Schumaker 已提交
340 341 342 343 344 345 346 347 348 349
	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;
350
	loff_t new_pos;
B
Bryan Schumaker 已提交
351
	int status = -EAGAIN;
352
	struct nfs_open_dir_context *ctx = desc->file->private_data;
B
Bryan Schumaker 已提交
353 354 355

	for (i = 0; i < array->size; i++) {
		if (array->array[i].cookie == *desc->dir_cookie) {
356 357 358 359 360 361
			new_pos = desc->current_index + i;
			if (new_pos < desc->file->f_pos) {
				ctx->dup_cookie = *desc->dir_cookie;
				ctx->duped = 1;
			}
			desc->file->f_pos = new_pos;
B
Bryan Schumaker 已提交
362
			desc->cache_entry_index = i;
T
Trond Myklebust 已提交
363
			return 0;
B
Bryan Schumaker 已提交
364 365
		}
	}
T
Trond Myklebust 已提交
366
	if (array->eof_index >= 0) {
367
		status = -EBADCOOKIE;
368 369
		if (*desc->dir_cookie == array->last_cookie)
			desc->eof = 1;
370
	}
B
Bryan Schumaker 已提交
371 372 373 374 375 376 377
	return status;
}

static
int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc)
{
	struct nfs_cache_array *array;
T
Trond Myklebust 已提交
378
	int status;
B
Bryan Schumaker 已提交
379 380 381 382 383 384 385 386 387 388 389 390

	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 已提交
391
	if (status == -EAGAIN) {
392
		desc->last_cookie = array->last_cookie;
393
		desc->current_index += array->size;
T
Trond Myklebust 已提交
394 395
		desc->page_index++;
	}
B
Bryan Schumaker 已提交
396 397 398 399 400 401 402
	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 已提交
403
int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc,
B
Bryan Schumaker 已提交
404
			struct nfs_entry *entry, struct file *file, struct inode *inode)
L
Linus Torvalds 已提交
405
{
406 407
	struct nfs_open_dir_context *ctx = file->private_data;
	struct rpc_cred	*cred = ctx->cred;
408
	unsigned long	timestamp, gencount;
L
Linus Torvalds 已提交
409 410 411 412
	int		error;

 again:
	timestamp = jiffies;
413
	gencount = nfs_inc_attr_generation_counter();
B
Bryan Schumaker 已提交
414
	error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, entry->cookie, pages,
L
Linus Torvalds 已提交
415 416 417 418 419
					  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 已提交
420
			clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
L
Linus Torvalds 已提交
421 422 423 424 425
			desc->plus = 0;
			goto again;
		}
		goto error;
	}
426
	desc->timestamp = timestamp;
427
	desc->gencount = gencount;
B
Bryan Schumaker 已提交
428 429
error:
	return error;
L
Linus Torvalds 已提交
430 431
}

432 433
static int xdr_decode(nfs_readdir_descriptor_t *desc,
		      struct nfs_entry *entry, struct xdr_stream *xdr)
L
Linus Torvalds 已提交
434
{
435
	int error;
L
Linus Torvalds 已提交
436

437 438 439
	error = desc->decode(xdr, entry, desc->plus);
	if (error)
		return error;
B
Bryan Schumaker 已提交
440 441 442
	entry->fattr->time_start = desc->timestamp;
	entry->fattr->gencount = desc->gencount;
	return 0;
L
Linus Torvalds 已提交
443 444
}

B
Bryan Schumaker 已提交
445 446 447 448 449
static
int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry)
{
	if (dentry->d_inode == NULL)
		goto different;
T
Trond Myklebust 已提交
450
	if (nfs_compare_fh(entry->fh, NFS_FH(dentry->d_inode)) != 0)
B
Bryan Schumaker 已提交
451 452 453 454 455 456 457 458 459
		goto different;
	return 1;
different:
	return 0;
}

static
void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
{
460 461 462 463 464 465
	struct qstr filename = {
		.len = entry->len,
		.name = entry->name,
	};
	struct dentry *dentry;
	struct dentry *alias;
B
Bryan Schumaker 已提交
466 467 468
	struct inode *dir = parent->d_inode;
	struct inode *inode;

469 470 471 472 473 474 475
	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 已提交
476

477
	dentry = d_lookup(parent, &filename);
B
Bryan Schumaker 已提交
478 479 480 481 482 483 484 485 486 487 488
	if (dentry != NULL) {
		if (nfs_same_file(dentry, entry)) {
			nfs_refresh_inode(dentry->d_inode, entry->fattr);
			goto out;
		} else {
			d_drop(dentry);
			dput(dentry);
		}
	}

	dentry = d_alloc(parent, &filename);
489 490 491
	if (dentry == NULL)
		return;

B
Bryan Schumaker 已提交
492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
	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 已提交
509 510
/* Perform conversion from xdr to cache array */
static
511
int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry,
512
				struct page **xdr_pages, struct page *page, unsigned int buflen)
L
Linus Torvalds 已提交
513
{
514
	struct xdr_stream stream;
515
	struct xdr_buf buf;
516
	struct page *scratch;
B
Bryan Schumaker 已提交
517
	struct nfs_cache_array *array;
518 519
	unsigned int count = 0;
	int status;
520

521 522 523
	scratch = alloc_page(GFP_KERNEL);
	if (scratch == NULL)
		return -ENOMEM;
524

525
	xdr_init_decode_pages(&stream, &buf, xdr_pages, buflen);
526
	xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
B
Bryan Schumaker 已提交
527 528 529

	do {
		status = xdr_decode(desc, entry, &stream);
530 531 532
		if (status != 0) {
			if (status == -EAGAIN)
				status = 0;
B
Bryan Schumaker 已提交
533
			break;
534
		}
B
Bryan Schumaker 已提交
535

536 537
		count++;

T
Trond Myklebust 已提交
538
		if (desc->plus != 0)
B
Bryan Schumaker 已提交
539
			nfs_prime_dcache(desc->file->f_path.dentry, entry);
540 541 542 543

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

T
Trond Myklebust 已提交
546
	if (count == 0 || (status == -EBADCOOKIE && entry->eof != 0)) {
B
Bryan Schumaker 已提交
547
		array = nfs_readdir_get_array(page);
548 549 550 551
		if (!IS_ERR(array)) {
			array->eof_index = array->size;
			status = 0;
			nfs_readdir_release_array(page);
552 553
		} else
			status = PTR_ERR(array);
L
Linus Torvalds 已提交
554
	}
555 556

	put_page(scratch);
557
	return status;
B
Bryan Schumaker 已提交
558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579
}

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
580
int nfs_readdir_large_page(struct page **pages, unsigned int npages)
B
Bryan Schumaker 已提交
581 582 583 584 585 586 587 588 589
{
	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;
	}
590
	return 0;
B
Bryan Schumaker 已提交
591 592 593

out_freepages:
	nfs_readdir_free_pagearray(pages, i);
594
	return -ENOMEM;
L
Linus Torvalds 已提交
595 596
}

B
Bryan Schumaker 已提交
597 598
static
int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode)
599
{
B
Bryan Schumaker 已提交
600 601
	struct page *pages[NFS_MAX_READDIR_PAGES];
	void *pages_ptr = NULL;
B
Bryan Schumaker 已提交
602 603 604
	struct nfs_entry entry;
	struct file	*file = desc->file;
	struct nfs_cache_array *array;
605
	int status = -ENOMEM;
B
Bryan Schumaker 已提交
606
	unsigned int array_size = ARRAY_SIZE(pages);
B
Bryan Schumaker 已提交
607 608

	entry.prev_cookie = 0;
609
	entry.cookie = desc->last_cookie;
B
Bryan Schumaker 已提交
610 611 612
	entry.eof = 0;
	entry.fh = nfs_alloc_fhandle();
	entry.fattr = nfs_alloc_fattr();
613
	entry.server = NFS_SERVER(inode);
B
Bryan Schumaker 已提交
614 615
	if (entry.fh == NULL || entry.fattr == NULL)
		goto out;
616

B
Bryan Schumaker 已提交
617
	array = nfs_readdir_get_array(page);
618 619 620 621
	if (IS_ERR(array)) {
		status = PTR_ERR(array);
		goto out;
	}
B
Bryan Schumaker 已提交
622 623
	memset(array, 0, sizeof(struct nfs_cache_array));
	array->eof_index = -1;
624

625 626
	status = nfs_readdir_large_page(pages, array_size);
	if (status < 0)
B
Bryan Schumaker 已提交
627 628
		goto out_release_array;
	do {
629
		unsigned int pglen;
B
Bryan Schumaker 已提交
630
		status = nfs_readdir_xdr_filler(pages, desc, &entry, file, inode);
631

B
Bryan Schumaker 已提交
632
		if (status < 0)
633
			break;
634
		pglen = status;
635
		status = nfs_readdir_page_filler(desc, &entry, pages, page, pglen);
636 637 638 639 640 641
		if (status < 0) {
			if (status == -ENOSPC)
				status = 0;
			break;
		}
	} while (array->eof_index < 0);
B
Bryan Schumaker 已提交
642

B
Bryan Schumaker 已提交
643
	nfs_readdir_free_large_page(pages_ptr, pages, array_size);
B
Bryan Schumaker 已提交
644 645 646 647 648
out_release_array:
	nfs_readdir_release_array(page);
out:
	nfs_free_fattr(entry.fattr);
	nfs_free_fhandle(entry.fh);
649 650 651 652
	return status;
}

/*
B
Bryan Schumaker 已提交
653 654 655 656
 * 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 已提交
657
 */
B
Bryan Schumaker 已提交
658 659
static
int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page* page)
L
Linus Torvalds 已提交
660
{
661
	struct inode	*inode = desc->file->f_path.dentry->d_inode;
662
	int ret;
L
Linus Torvalds 已提交
663

664 665
	ret = nfs_readdir_xdr_to_array(desc, page, inode);
	if (ret < 0)
B
Bryan Schumaker 已提交
666 667
		goto error;
	SetPageUptodate(page);
L
Linus Torvalds 已提交
668

B
Bryan Schumaker 已提交
669 670 671
	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 已提交
672
	}
B
Bryan Schumaker 已提交
673 674 675 676
	unlock_page(page);
	return 0;
 error:
	unlock_page(page);
677
	return ret;
B
Bryan Schumaker 已提交
678
}
L
Linus Torvalds 已提交
679

B
Bryan Schumaker 已提交
680 681 682
static
void cache_page_release(nfs_readdir_descriptor_t *desc)
{
683 684
	if (!desc->page->mapping)
		nfs_readdir_clear_array(desc->page);
B
Bryan Schumaker 已提交
685 686 687 688 689 690 691
	page_cache_release(desc->page);
	desc->page = NULL;
}

static
struct page *get_cache_page(nfs_readdir_descriptor_t *desc)
{
692
	return read_cache_page(desc->file->f_path.dentry->d_inode->i_mapping,
B
Bryan Schumaker 已提交
693
			desc->page_index, (filler_t *)nfs_readdir_filler, desc);
L
Linus Torvalds 已提交
694 695 696
}

/*
B
Bryan Schumaker 已提交
697
 * Returns 0 if desc->dir_cookie was found on page desc->page_index
L
Linus Torvalds 已提交
698
 */
B
Bryan Schumaker 已提交
699 700 701 702 703 704 705 706 707 708
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 已提交
709 710
	if (res != 0)
		cache_page_release(desc);
B
Bryan Schumaker 已提交
711 712 713 714
	return res;
}

/* Search for desc->dir_cookie from the beginning of the page cache */
L
Linus Torvalds 已提交
715 716 717
static inline
int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)
{
718
	int res;
B
Bryan Schumaker 已提交
719

720
	if (desc->page_index == 0) {
721
		desc->current_index = 0;
722 723
		desc->last_cookie = 0;
	}
T
Trond Myklebust 已提交
724
	do {
B
Bryan Schumaker 已提交
725
		res = find_cache_page(desc);
T
Trond Myklebust 已提交
726
	} while (res == -EAGAIN);
L
Linus Torvalds 已提交
727 728 729 730 731 732 733 734 735 736 737
	return res;
}

/*
 * Once we've found the start of the dirent within a page: fill 'er up...
 */
static 
int nfs_do_filldir(nfs_readdir_descriptor_t *desc, void *dirent,
		   filldir_t filldir)
{
	struct file	*file = desc->file;
B
Bryan Schumaker 已提交
738 739 740
	int i = 0;
	int res = 0;
	struct nfs_cache_array *array = NULL;
741 742 743 744 745 746 747 748 749 750 751 752 753 754
	struct nfs_open_dir_context *ctx = file->private_data;

	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.  "
				"Offending cookie: %llu\n",
				file->f_dentry->d_parent->d_name.name,
				file->f_dentry->d_name.name,
				*desc->dir_cookie);
		}
		res = -ELOOP;
		goto out;
	}
B
Bryan Schumaker 已提交
755 756

	array = nfs_readdir_get_array(desc->page);
757 758 759 760
	if (IS_ERR(array)) {
		res = PTR_ERR(array);
		goto out;
	}
B
Bryan Schumaker 已提交
761 762

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

765 766
		ent = &array->array[i];
		if (filldir(dirent, ent->string.name, ent->string.len,
767 768
		    file->f_pos, nfs_compat_user_ino64(ent->ino),
		    ent->d_type) < 0) {
769
			desc->eof = 1;
L
Linus Torvalds 已提交
770
			break;
771
		}
772
		file->f_pos++;
B
Bryan Schumaker 已提交
773 774 775 776
		if (i < (array->size-1))
			*desc->dir_cookie = array->array[i+1].cookie;
		else
			*desc->dir_cookie = array->last_cookie;
L
Linus Torvalds 已提交
777
	}
T
Trond Myklebust 已提交
778
	if (array->eof_index >= 0)
779
		desc->eof = 1;
B
Bryan Schumaker 已提交
780 781

	nfs_readdir_release_array(desc->page);
782
out:
B
Bryan Schumaker 已提交
783
	cache_page_release(desc);
C
Chuck Lever 已提交
784 785
	dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n",
			(unsigned long long)*desc->dir_cookie, res);
L
Linus Torvalds 已提交
786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806
	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
int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
		     filldir_t filldir)
{
	struct page	*page = NULL;
	int		status;
B
Bryan Schumaker 已提交
807
	struct inode *inode = desc->file->f_path.dentry->d_inode;
L
Linus Torvalds 已提交
808

C
Chuck Lever 已提交
809 810
	dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n",
			(unsigned long long)*desc->dir_cookie);
L
Linus Torvalds 已提交
811 812 813 814 815 816

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

818
	desc->page_index = 0;
819
	desc->last_cookie = *desc->dir_cookie;
820 821
	desc->page = page;

822 823
	status = nfs_readdir_xdr_to_array(desc, page, inode);
	if (status < 0)
L
Linus Torvalds 已提交
824 825 826 827 828
		goto out_release;

	status = nfs_do_filldir(desc, dirent, filldir);

 out:
C
Chuck Lever 已提交
829
	dfprintk(DIRCACHE, "NFS: %s: returns %d\n",
830
			__func__, status);
L
Linus Torvalds 已提交
831 832
	return status;
 out_release:
B
Bryan Schumaker 已提交
833
	cache_page_release(desc);
L
Linus Torvalds 已提交
834 835 836
	goto out;
}

837 838 839
/* 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 已提交
840 841 842
 */
static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
{
843
	struct dentry	*dentry = filp->f_path.dentry;
L
Linus Torvalds 已提交
844 845 846
	struct inode	*inode = dentry->d_inode;
	nfs_readdir_descriptor_t my_desc,
			*desc = &my_desc;
847
	struct nfs_open_dir_context *dir_ctx = filp->private_data;
T
Trond Myklebust 已提交
848
	int res;
L
Linus Torvalds 已提交
849

C
Chuck Lever 已提交
850
	dfprintk(FILE, "NFS: readdir(%s/%s) starting at cookie %llu\n",
C
Chuck Lever 已提交
851 852
			dentry->d_parent->d_name.name, dentry->d_name.name,
			(long long)filp->f_pos);
C
Chuck Lever 已提交
853 854
	nfs_inc_stats(inode, NFSIOS_VFSGETDENTS);

L
Linus Torvalds 已提交
855
	/*
856
	 * filp->f_pos points to the dirent entry number.
857
	 * *desc->dir_cookie has the cookie for the next entry. We have
858 859
	 * to either find the entry with the appropriate number or
	 * revalidate the cookie.
L
Linus Torvalds 已提交
860 861 862 863
	 */
	memset(desc, 0, sizeof(*desc));

	desc->file = filp;
864
	desc->dir_cookie = &dir_ctx->dir_cookie;
L
Linus Torvalds 已提交
865 866 867
	desc->decode = NFS_PROTO(inode)->decode_dirent;
	desc->plus = NFS_USE_READDIRPLUS(inode);

T
Trond Myklebust 已提交
868
	nfs_block_sillyrename(dentry);
869
	res = nfs_revalidate_mapping(inode, filp->f_mapping);
T
Trond Myklebust 已提交
870 871 872
	if (res < 0)
		goto out;

T
Trond Myklebust 已提交
873
	do {
L
Linus Torvalds 已提交
874
		res = readdir_search_pagecache(desc);
875

L
Linus Torvalds 已提交
876
		if (res == -EBADCOOKIE) {
877
			res = 0;
L
Linus Torvalds 已提交
878
			/* This means either end of directory */
B
Bryan Schumaker 已提交
879
			if (*desc->dir_cookie && desc->eof == 0) {
L
Linus Torvalds 已提交
880 881
				/* Or that the server has 'lost' a cookie */
				res = uncached_readdir(desc, dirent, filldir);
882
				if (res == 0)
L
Linus Torvalds 已提交
883 884 885 886 887
					continue;
			}
			break;
		}
		if (res == -ETOOSMALL && desc->plus) {
B
Benny Halevy 已提交
888
			clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
L
Linus Torvalds 已提交
889
			nfs_zap_caches(inode);
890
			desc->page_index = 0;
L
Linus Torvalds 已提交
891
			desc->plus = 0;
B
Bryan Schumaker 已提交
892
			desc->eof = 0;
L
Linus Torvalds 已提交
893 894 895 896 897 898
			continue;
		}
		if (res < 0)
			break;

		res = nfs_do_filldir(desc, dirent, filldir);
899
		if (res < 0)
L
Linus Torvalds 已提交
900
			break;
T
Trond Myklebust 已提交
901
	} while (!desc->eof);
T
Trond Myklebust 已提交
902
out:
T
Trond Myklebust 已提交
903
	nfs_unblock_sillyrename(dentry);
C
Chuck Lever 已提交
904 905
	if (res > 0)
		res = 0;
906
	dfprintk(FILE, "NFS: readdir(%s/%s) returns %d\n",
C
Chuck Lever 已提交
907 908 909
			dentry->d_parent->d_name.name, dentry->d_name.name,
			res);
	return res;
L
Linus Torvalds 已提交
910 911
}

912
static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)
913
{
914 915
	struct dentry *dentry = filp->f_path.dentry;
	struct inode *inode = dentry->d_inode;
916
	struct nfs_open_dir_context *dir_ctx = filp->private_data;
917

C
Chuck Lever 已提交
918
	dfprintk(FILE, "NFS: llseek dir(%s/%s, %lld, %d)\n",
919 920 921 922 923
			dentry->d_parent->d_name.name,
			dentry->d_name.name,
			offset, origin);

	mutex_lock(&inode->i_mutex);
924 925 926 927 928 929 930 931 932 933 934 935
	switch (origin) {
		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;
936
		dir_ctx->dir_cookie = 0;
937
		dir_ctx->duped = 0;
938 939
	}
out:
940
	mutex_unlock(&inode->i_mutex);
941 942 943
	return offset;
}

L
Linus Torvalds 已提交
944 945 946 947
/*
 * All directory operations under NFS are synchronous, so fsync()
 * is a dummy operation.
 */
948 949
static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end,
			 int datasync)
L
Linus Torvalds 已提交
950
{
951
	struct dentry *dentry = filp->f_path.dentry;
952
	struct inode *inode = dentry->d_inode;
953

C
Chuck Lever 已提交
954
	dfprintk(FILE, "NFS: fsync dir(%s/%s) datasync %d\n",
C
Chuck Lever 已提交
955 956 957
			dentry->d_parent->d_name.name, dentry->d_name.name,
			datasync);

958
	mutex_lock(&inode->i_mutex);
959
	nfs_inc_stats(dentry->d_inode, NFSIOS_VFSFSYNC);
960
	mutex_unlock(&inode->i_mutex);
L
Linus Torvalds 已提交
961 962 963
	return 0;
}

964 965 966 967 968 969 970 971 972 973 974 975
/**
 * 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)
{
976
	NFS_I(dir)->cache_change_attribute++;
977 978
}

L
Linus Torvalds 已提交
979 980 981 982 983
/*
 * 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.
 */
984
static int nfs_check_verifier(struct inode *dir, struct dentry *dentry)
L
Linus Torvalds 已提交
985 986 987
{
	if (IS_ROOT(dentry))
		return 1;
988 989
	if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
		return 0;
990 991 992 993 994 995 996 997
	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 已提交
998 999
}

1000 1001 1002 1003
/*
 * Return the intent data that applies to this particular path component
 *
 * Note that the current set of intents only apply to the very last
1004 1005
 * component of the path and none of them is set before that last
 * component.
1006
 */
1007 1008
static inline unsigned int nfs_lookup_check_intent(struct nameidata *nd,
						unsigned int mask)
1009 1010 1011 1012
{
	return nd->flags & mask;
}

1013 1014 1015 1016 1017 1018 1019 1020
/*
 * Use intent information to check whether or not we're going to do
 * an O_EXCL create using this path component.
 */
static int nfs_is_exclusive_create(struct inode *dir, struct nameidata *nd)
{
	if (NFS_PROTO(dir)->version == 2)
		return 0;
1021
	return nd && nfs_lookup_check_intent(nd, LOOKUP_EXCL);
1022 1023
}

1024 1025 1026 1027 1028 1029 1030 1031
/*
 * 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.
 *
 */
L
Linus Torvalds 已提交
1032 1033 1034 1035 1036
static inline
int nfs_lookup_verify_inode(struct inode *inode, struct nameidata *nd)
{
	struct nfs_server *server = NFS_SERVER(inode);

1037
	if (IS_AUTOMOUNT(inode))
1038
		return 0;
L
Linus Torvalds 已提交
1039 1040
	if (nd != NULL) {
		/* VFS wants an on-the-wire revalidation */
1041
		if (nd->flags & LOOKUP_REVAL)
L
Linus Torvalds 已提交
1042 1043
			goto out_force;
		/* This is an open(2) */
1044
		if (nfs_lookup_check_intent(nd, LOOKUP_OPEN) != 0 &&
1045 1046 1047
				!(server->flags & NFS_MOUNT_NOCTO) &&
				(S_ISREG(inode->i_mode) ||
				 S_ISDIR(inode->i_mode)))
L
Linus Torvalds 已提交
1048
			goto out_force;
1049
		return 0;
L
Linus Torvalds 已提交
1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067
	}
	return nfs_revalidate_inode(server, inode);
out_force:
	return __nfs_revalidate_inode(server, inode);
}

/*
 * 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,
		       struct nameidata *nd)
{
	/* Don't revalidate a negative dentry if we're creating a new file */
1068
	if (nd != NULL && nfs_lookup_check_intent(nd, LOOKUP_CREATE) != 0)
L
Linus Torvalds 已提交
1069
		return 0;
1070 1071
	if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG)
		return 1;
L
Linus Torvalds 已提交
1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085
	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.
 */
1086
static int nfs_lookup_revalidate(struct dentry *dentry, struct nameidata *nd)
L
Linus Torvalds 已提交
1087 1088 1089 1090
{
	struct inode *dir;
	struct inode *inode;
	struct dentry *parent;
1091 1092
	struct nfs_fh *fhandle = NULL;
	struct nfs_fattr *fattr = NULL;
L
Linus Torvalds 已提交
1093 1094
	int error;

1095 1096 1097
	if (nd->flags & LOOKUP_RCU)
		return -ECHILD;

L
Linus Torvalds 已提交
1098 1099
	parent = dget_parent(dentry);
	dir = parent->d_inode;
C
Chuck Lever 已提交
1100
	nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE);
L
Linus Torvalds 已提交
1101 1102 1103 1104 1105 1106 1107 1108 1109
	inode = dentry->d_inode;

	if (!inode) {
		if (nfs_neg_need_reval(dir, dentry, nd))
			goto out_bad;
		goto out_valid;
	}

	if (is_bad_inode(inode)) {
C
Chuck Lever 已提交
1110
		dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n",
1111
				__func__, dentry->d_parent->d_name.name,
C
Chuck Lever 已提交
1112
				dentry->d_name.name);
L
Linus Torvalds 已提交
1113 1114 1115
		goto out_bad;
	}

1116 1117 1118
	if (nfs_have_delegation(inode, FMODE_READ))
		goto out_set_verifier;

L
Linus Torvalds 已提交
1119
	/* Force a full look up iff the parent directory has changed */
1120
	if (!nfs_is_exclusive_create(dir, nd) && nfs_check_verifier(dir, dentry)) {
L
Linus Torvalds 已提交
1121 1122 1123 1124 1125 1126 1127 1128
		if (nfs_lookup_verify_inode(inode, nd))
			goto out_zap_parent;
		goto out_valid;
	}

	if (NFS_STALE(inode))
		goto out_bad;

1129 1130 1131 1132 1133 1134
	error = -ENOMEM;
	fhandle = nfs_alloc_fhandle();
	fattr = nfs_alloc_fattr();
	if (fhandle == NULL || fattr == NULL)
		goto out_error;

1135
	error = NFS_PROTO(dir)->lookup(NFS_SERVER(dir)->client, dir, &dentry->d_name, fhandle, fattr);
L
Linus Torvalds 已提交
1136 1137
	if (error)
		goto out_bad;
1138
	if (nfs_compare_fh(NFS_FH(inode), fhandle))
L
Linus Torvalds 已提交
1139
		goto out_bad;
1140
	if ((error = nfs_refresh_inode(inode, fattr)) != 0)
L
Linus Torvalds 已提交
1141 1142
		goto out_bad;

1143 1144
	nfs_free_fattr(fattr);
	nfs_free_fhandle(fhandle);
1145
out_set_verifier:
1146
	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
L
Linus Torvalds 已提交
1147 1148
 out_valid:
	dput(parent);
C
Chuck Lever 已提交
1149
	dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is valid\n",
1150
			__func__, dentry->d_parent->d_name.name,
C
Chuck Lever 已提交
1151
			dentry->d_name.name);
L
Linus Torvalds 已提交
1152 1153 1154 1155
	return 1;
out_zap_parent:
	nfs_zap_caches(dir);
 out_bad:
1156
	nfs_mark_for_revalidate(dir);
L
Linus Torvalds 已提交
1157 1158 1159 1160 1161 1162
	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;
1163 1164
		if (dentry->d_flags & DCACHE_DISCONNECTED)
			goto out_valid;
L
Linus Torvalds 已提交
1165 1166 1167
		shrink_dcache_parent(dentry);
	}
	d_drop(dentry);
1168 1169
	nfs_free_fattr(fattr);
	nfs_free_fhandle(fhandle);
L
Linus Torvalds 已提交
1170
	dput(parent);
C
Chuck Lever 已提交
1171
	dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n",
1172
			__func__, dentry->d_parent->d_name.name,
C
Chuck Lever 已提交
1173
			dentry->d_name.name);
L
Linus Torvalds 已提交
1174
	return 0;
1175 1176 1177 1178 1179 1180 1181 1182
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 已提交
1183 1184 1185 1186 1187
}

/*
 * This is called from dput() when d_count is going to 0.
 */
N
Nick Piggin 已提交
1188
static int nfs_dentry_delete(const struct dentry *dentry)
L
Linus Torvalds 已提交
1189 1190 1191 1192 1193
{
	dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)\n",
		dentry->d_parent->d_name.name, dentry->d_name.name,
		dentry->d_flags);

1194 1195 1196 1197
	/* Unhash any dentry with a stale inode */
	if (dentry->d_inode != NULL && NFS_STALE(dentry->d_inode))
		return 1;

L
Linus Torvalds 已提交
1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210
	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;

}

1211 1212 1213 1214 1215 1216 1217 1218
static void nfs_drop_nlink(struct inode *inode)
{
	spin_lock(&inode->i_lock);
	if (inode->i_nlink > 0)
		drop_nlink(inode);
	spin_unlock(&inode->i_lock);
}

L
Linus Torvalds 已提交
1219 1220 1221 1222 1223 1224
/*
 * 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)
{
1225 1226 1227 1228
	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 已提交
1229
	if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1230
		drop_nlink(inode);
1231
		nfs_complete_unlink(dentry, inode);
L
Linus Torvalds 已提交
1232 1233 1234 1235
	}
	iput(inode);
}

1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246
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 已提交
1247
const struct dentry_operations nfs_dentry_operations = {
L
Linus Torvalds 已提交
1248 1249 1250
	.d_revalidate	= nfs_lookup_revalidate,
	.d_delete	= nfs_dentry_delete,
	.d_iput		= nfs_dentry_iput,
1251
	.d_automount	= nfs_d_automount,
1252
	.d_release	= nfs_d_release,
L
Linus Torvalds 已提交
1253 1254 1255 1256 1257
};

static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
{
	struct dentry *res;
T
Trond Myklebust 已提交
1258
	struct dentry *parent;
L
Linus Torvalds 已提交
1259
	struct inode *inode = NULL;
1260 1261
	struct nfs_fh *fhandle = NULL;
	struct nfs_fattr *fattr = NULL;
L
Linus Torvalds 已提交
1262 1263 1264 1265
	int error;

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

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

1272 1273 1274 1275 1276 1277 1278
	/*
	 * If we're doing an exclusive create, optimize away the lookup
	 * but don't hash the dentry.
	 */
	if (nfs_is_exclusive_create(dir, nd)) {
		d_instantiate(dentry, NULL);
		res = NULL;
1279
		goto out;
1280
	}
L
Linus Torvalds 已提交
1281

1282 1283 1284 1285 1286 1287
	res = ERR_PTR(-ENOMEM);
	fhandle = nfs_alloc_fhandle();
	fattr = nfs_alloc_fattr();
	if (fhandle == NULL || fattr == NULL)
		goto out;

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

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

#ifdef CONFIG_NFS_V4
static int nfs_open_revalidate(struct dentry *, struct nameidata *);

A
Al Viro 已提交
1322
const struct dentry_operations nfs4_dentry_operations = {
L
Linus Torvalds 已提交
1323 1324 1325
	.d_revalidate	= nfs_open_revalidate,
	.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 1329
};

1330 1331 1332 1333
/*
 * Use intent information to determine whether we need to substitute
 * the NFSv4-style stateful OPEN for the LOOKUP call
 */
T
Trond Myklebust 已提交
1334
static int is_atomic_open(struct nameidata *nd)
L
Linus Torvalds 已提交
1335
{
1336
	if (nd == NULL || nfs_lookup_check_intent(nd, LOOKUP_OPEN) == 0)
L
Linus Torvalds 已提交
1337 1338 1339 1340 1341
		return 0;
	/* NFS does not (yet) have a stateful open for directories */
	if (nd->flags & LOOKUP_DIRECTORY)
		return 0;
	/* Are we trying to write to a read only partition? */
1342
	if (__mnt_is_readonly(nd->path.mnt) &&
1343
	    (nd->intent.open.flags & (O_CREAT|O_TRUNC|O_ACCMODE)))
L
Linus Torvalds 已提交
1344 1345 1346 1347
		return 0;
	return 1;
}

1348 1349 1350 1351 1352 1353 1354 1355 1356 1357
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;
}

1358
static struct nfs_open_context *create_nfs_open_context(struct dentry *dentry, int open_flags)
1359 1360 1361
{
	struct nfs_open_context *ctx;
	struct rpc_cred *cred;
1362
	fmode_t fmode = flags_to_mode(open_flags);
1363 1364 1365 1366

	cred = rpc_lookup_cred();
	if (IS_ERR(cred))
		return ERR_CAST(cred);
1367
	ctx = alloc_nfs_open_context(dentry, cred, fmode);
1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386
	put_rpccred(cred);
	if (ctx == NULL)
		return ERR_PTR(-ENOMEM);
	return ctx;
}

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

static int nfs_intent_set_file(struct nameidata *nd, struct nfs_open_context *ctx)
{
	struct file *filp;
	int ret = 0;

	/* If the open_intent is for execute, we have an extra check to make */
	if (ctx->mode & FMODE_EXEC) {
1387
		ret = nfs_may_open(ctx->dentry->d_inode,
1388 1389 1390 1391 1392
				ctx->cred,
				nd->intent.open.flags);
		if (ret < 0)
			goto out;
	}
1393
	filp = lookup_instantiate_filp(nd, ctx->dentry, do_open);
1394 1395 1396 1397 1398 1399 1400 1401 1402
	if (IS_ERR(filp))
		ret = PTR_ERR(filp);
	else
		nfs_file_set_open_context(filp, ctx);
out:
	put_nfs_open_context(ctx);
	return ret;
}

L
Linus Torvalds 已提交
1403 1404
static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
{
1405 1406
	struct nfs_open_context *ctx;
	struct iattr attr;
L
Linus Torvalds 已提交
1407
	struct dentry *res = NULL;
1408
	struct inode *inode;
1409
	int open_flags;
1410
	int err;
L
Linus Torvalds 已提交
1411

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

L
Linus Torvalds 已提交
1415
	/* Check that we are indeed trying to open this file */
T
Trond Myklebust 已提交
1416
	if (!is_atomic_open(nd))
L
Linus Torvalds 已提交
1417 1418 1419 1420 1421 1422 1423
		goto no_open;

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

1424 1425
	/* Let vfs_create() deal with O_EXCL. Instantiate, but don't hash
	 * the dentry. */
1426
	if (nd->flags & LOOKUP_EXCL) {
1427
		d_instantiate(dentry, NULL);
1428 1429
		goto out;
	}
L
Linus Torvalds 已提交
1430

1431 1432 1433
	open_flags = nd->intent.open.flags;

	ctx = create_nfs_open_context(dentry, open_flags);
1434 1435 1436 1437 1438 1439 1440
	res = ERR_CAST(ctx);
	if (IS_ERR(ctx))
		goto out;

	if (nd->flags & LOOKUP_CREATE) {
		attr.ia_mode = nd->intent.open.create_mode;
		attr.ia_valid = ATTR_MODE;
A
Aneesh Kumar K.V 已提交
1441
		attr.ia_mode &= ~current_umask();
1442
	} else {
1443
		open_flags &= ~(O_EXCL | O_CREAT);
1444 1445 1446
		attr.ia_valid = 0;
	}

L
Linus Torvalds 已提交
1447
	/* Open the file on the server */
1448
	nfs_block_sillyrename(dentry->d_parent);
1449
	inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr);
1450 1451
	if (IS_ERR(inode)) {
		nfs_unblock_sillyrename(dentry->d_parent);
1452
		put_nfs_open_context(ctx);
1453
		switch (PTR_ERR(inode)) {
L
Linus Torvalds 已提交
1454 1455
			/* Make a negative dentry */
			case -ENOENT:
1456
				d_add(dentry, NULL);
1457 1458
				res = NULL;
				goto out;
L
Linus Torvalds 已提交
1459
			/* This turned out not to be a regular file */
1460 1461
			case -ENOTDIR:
				goto no_open;
L
Linus Torvalds 已提交
1462 1463 1464
			case -ELOOP:
				if (!(nd->intent.open.flags & O_NOFOLLOW))
					goto no_open;
1465
			/* case -EISDIR: */
L
Linus Torvalds 已提交
1466 1467
			/* case -EINVAL: */
			default:
1468
				res = ERR_CAST(inode);
L
Linus Torvalds 已提交
1469 1470
				goto out;
		}
1471
	}
1472
	res = d_add_unique(dentry, inode);
1473
	nfs_unblock_sillyrename(dentry->d_parent);
1474
	if (res != NULL) {
1475 1476
		dput(ctx->dentry);
		ctx->dentry = dget(res);
L
Linus Torvalds 已提交
1477
		dentry = res;
1478
	}
1479 1480 1481 1482 1483 1484
	err = nfs_intent_set_file(nd, ctx);
	if (err < 0) {
		if (res != NULL)
			dput(res);
		return ERR_PTR(err);
	}
L
Linus Torvalds 已提交
1485
out:
1486
	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
L
Linus Torvalds 已提交
1487 1488 1489 1490 1491 1492 1493 1494
	return res;
no_open:
	return nfs_lookup(dir, dentry, nd);
}

static int nfs_open_revalidate(struct dentry *dentry, struct nameidata *nd)
{
	struct dentry *parent = NULL;
N
Nick Piggin 已提交
1495
	struct inode *inode;
L
Linus Torvalds 已提交
1496
	struct inode *dir;
1497
	struct nfs_open_context *ctx;
L
Linus Torvalds 已提交
1498 1499
	int openflags, ret = 0;

N
Nick Piggin 已提交
1500 1501 1502 1503
	if (nd->flags & LOOKUP_RCU)
		return -ECHILD;

	inode = dentry->d_inode;
1504
	if (!is_atomic_open(nd) || d_mountpoint(dentry))
T
Trond Myklebust 已提交
1505
		goto no_open;
1506

L
Linus Torvalds 已提交
1507 1508
	parent = dget_parent(dentry);
	dir = parent->d_inode;
1509

L
Linus Torvalds 已提交
1510 1511 1512
	/* We can't create new files in nfs_open_revalidate(), so we
	 * optimize away revalidation of negative dentries.
	 */
1513 1514 1515
	if (inode == NULL) {
		if (!nfs_neg_need_reval(dir, dentry, nd))
			ret = 1;
L
Linus Torvalds 已提交
1516
		goto out;
1517 1518
	}

L
Linus Torvalds 已提交
1519 1520
	/* NFS only supports OPEN on regular files */
	if (!S_ISREG(inode->i_mode))
T
Trond Myklebust 已提交
1521
		goto no_open_dput;
L
Linus Torvalds 已提交
1522 1523 1524
	openflags = nd->intent.open.flags;
	/* We cannot do exclusive creation on a positive dentry */
	if ((openflags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL))
T
Trond Myklebust 已提交
1525
		goto no_open_dput;
L
Linus Torvalds 已提交
1526
	/* We can't create new files, or truncate existing ones here */
1527
	openflags &= ~(O_CREAT|O_EXCL|O_TRUNC);
L
Linus Torvalds 已提交
1528

1529
	ctx = create_nfs_open_context(dentry, openflags);
1530 1531 1532
	ret = PTR_ERR(ctx);
	if (IS_ERR(ctx))
		goto out;
L
Linus Torvalds 已提交
1533
	/*
1534
	 * Note: we're not holding inode->i_mutex and so may be racing with
L
Linus Torvalds 已提交
1535 1536 1537
	 * operations that change the directory. We therefore save the
	 * change attribute *before* we do the RPC call.
	 */
1538
	inode = NFS_PROTO(dir)->open_context(dir, ctx, openflags, NULL);
1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552
	if (IS_ERR(inode)) {
		ret = PTR_ERR(inode);
		switch (ret) {
		case -EPERM:
		case -EACCES:
		case -EDQUOT:
		case -ENOSPC:
		case -EROFS:
			goto out_put_ctx;
		default:
			goto out_drop;
		}
	}
	iput(inode);
1553
	if (inode != dentry->d_inode)
1554
		goto out_drop;
1555 1556 1557 1558 1559

	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
	ret = nfs_intent_set_file(nd, ctx);
	if (ret >= 0)
		ret = 1;
L
Linus Torvalds 已提交
1560 1561 1562
out:
	dput(parent);
	return ret;
1563 1564 1565 1566 1567 1568 1569
out_drop:
	d_drop(dentry);
	ret = 0;
out_put_ctx:
	put_nfs_open_context(ctx);
	goto out;

T
Trond Myklebust 已提交
1570
no_open_dput:
L
Linus Torvalds 已提交
1571
	dput(parent);
T
Trond Myklebust 已提交
1572
no_open:
L
Linus Torvalds 已提交
1573 1574
	return nfs_lookup_revalidate(dentry, nd);
}
1575 1576 1577 1578 1579 1580 1581

static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode,
		struct nameidata *nd)
{
	struct nfs_open_context *ctx = NULL;
	struct iattr attr;
	int error;
1582
	int open_flags = O_CREAT|O_EXCL;
1583 1584 1585 1586 1587 1588 1589

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

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

1590
	if (nd)
1591 1592
		open_flags = nd->intent.open.flags;

A
Al Viro 已提交
1593 1594 1595 1596
	ctx = create_nfs_open_context(dentry, open_flags);
	error = PTR_ERR(ctx);
	if (IS_ERR(ctx))
		goto out_err_drop;
1597 1598 1599 1600

	error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, ctx);
	if (error != 0)
		goto out_put_ctx;
1601
	if (nd) {
1602 1603 1604
		error = nfs_intent_set_file(nd, ctx);
		if (error < 0)
			goto out_err;
A
Al Viro 已提交
1605 1606
	} else {
		put_nfs_open_context(ctx);
1607
	}
1608 1609
	return 0;
out_put_ctx:
A
Al Viro 已提交
1610
	put_nfs_open_context(ctx);
1611
out_err_drop:
1612
	d_drop(dentry);
1613
out_err:
1614 1615 1616
	return error;
}

L
Linus Torvalds 已提交
1617 1618 1619 1620 1621 1622 1623 1624
#endif /* CONFIG_NFSV4 */

/*
 * Code common to create, mkdir, and mknod.
 */
int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
				struct nfs_fattr *fattr)
{
1625 1626
	struct dentry *parent = dget_parent(dentry);
	struct inode *dir = parent->d_inode;
L
Linus Torvalds 已提交
1627 1628 1629
	struct inode *inode;
	int error = -EACCES;

1630 1631
	d_drop(dentry);

L
Linus Torvalds 已提交
1632 1633
	/* We may have been initialized further down */
	if (dentry->d_inode)
1634
		goto out;
L
Linus Torvalds 已提交
1635
	if (fhandle->size == 0) {
1636
		error = NFS_PROTO(dir)->lookup(NFS_SERVER(dir)->client, dir, &dentry->d_name, fhandle, fattr);
L
Linus Torvalds 已提交
1637
		if (error)
1638
			goto out_error;
L
Linus Torvalds 已提交
1639
	}
1640
	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
L
Linus Torvalds 已提交
1641 1642
	if (!(fattr->valid & NFS_ATTR_FATTR)) {
		struct nfs_server *server = NFS_SB(dentry->d_sb);
1643
		error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr);
L
Linus Torvalds 已提交
1644
		if (error < 0)
1645
			goto out_error;
L
Linus Torvalds 已提交
1646 1647
	}
	inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
1648 1649
	error = PTR_ERR(inode);
	if (IS_ERR(inode))
1650 1651 1652 1653
		goto out_error;
	d_add(dentry, inode);
out:
	dput(parent);
L
Linus Torvalds 已提交
1654
	return 0;
1655 1656 1657 1658
out_error:
	nfs_mark_for_revalidate(dir);
	dput(parent);
	return error;
L
Linus Torvalds 已提交
1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671
}

/*
 * 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.
 */
static int nfs_create(struct inode *dir, struct dentry *dentry, int mode,
		struct nameidata *nd)
{
	struct iattr attr;
	int error;
1672
	int open_flags = O_CREAT|O_EXCL;
L
Linus Torvalds 已提交
1673

C
Chuck Lever 已提交
1674 1675
	dfprintk(VFS, "NFS: create(%s/%ld), %s\n",
			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
L
Linus Torvalds 已提交
1676 1677 1678 1679

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

1680
	if (nd)
1681 1682 1683
		open_flags = nd->intent.open.flags;

	error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, NULL);
L
Linus Torvalds 已提交
1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700
	if (error != 0)
		goto out_err;
	return 0;
out_err:
	d_drop(dentry);
	return error;
}

/*
 * See comments for nfs_proc_create regarding failed operations.
 */
static int
nfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
{
	struct iattr attr;
	int status;

C
Chuck Lever 已提交
1701 1702
	dfprintk(VFS, "NFS: mknod(%s/%ld), %s\n",
			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
L
Linus Torvalds 已提交
1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726

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

/*
 * See comments for nfs_proc_create regarding failed operations.
 */
static int nfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
{
	struct iattr attr;
	int error;

C
Chuck Lever 已提交
1727 1728
	dfprintk(VFS, "NFS: mkdir(%s/%ld), %s\n",
			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
L
Linus Torvalds 已提交
1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741

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

1742 1743 1744 1745 1746 1747
static void nfs_dentry_handle_enoent(struct dentry *dentry)
{
	if (dentry->d_inode != NULL && !d_unhashed(dentry))
		d_delete(dentry);
}

L
Linus Torvalds 已提交
1748 1749 1750 1751
static int nfs_rmdir(struct inode *dir, struct dentry *dentry)
{
	int error;

C
Chuck Lever 已提交
1752 1753
	dfprintk(VFS, "NFS: rmdir(%s/%ld), %s\n",
			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
L
Linus Torvalds 已提交
1754 1755 1756 1757

	error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
	/* Ensure the VFS deletes this inode */
	if (error == 0 && dentry->d_inode != NULL)
1758
		clear_nlink(dentry->d_inode);
1759 1760
	else if (error == -ENOENT)
		nfs_dentry_handle_enoent(dentry);
L
Linus Torvalds 已提交
1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787

	return error;
}

/*
 * 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) {
1788
		nfs_inode_return_delegation(inode);
L
Linus Torvalds 已提交
1789 1790 1791
		error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
		/* The VFS may want to delete this inode */
		if (error == 0)
1792
			nfs_drop_nlink(inode);
1793
		nfs_mark_for_revalidate(inode);
L
Linus Torvalds 已提交
1794 1795
	} else
		error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
1796 1797
	if (error == -ENOENT)
		nfs_dentry_handle_enoent(dentry);
L
Linus Torvalds 已提交
1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815
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.
 */
static int nfs_unlink(struct inode *dir, struct dentry *dentry)
{
	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 已提交
1816
	if (dentry->d_count > 1) {
L
Linus Torvalds 已提交
1817
		spin_unlock(&dentry->d_lock);
T
Trond Myklebust 已提交
1818 1819
		/* Start asynchronous writeout of the inode */
		write_inode_now(dentry->d_inode, 0);
L
Linus Torvalds 已提交
1820 1821 1822 1823 1824 1825 1826 1827 1828
		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);
1829
	if (!error || error == -ENOENT) {
L
Linus Torvalds 已提交
1830 1831 1832 1833 1834 1835
		nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
	} else if (need_rehash)
		d_rehash(dentry);
	return error;
}

1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851
/*
 * 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.
 */
static int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
L
Linus Torvalds 已提交
1852
{
1853 1854 1855
	struct pagevec lru_pvec;
	struct page *page;
	char *kaddr;
L
Linus Torvalds 已提交
1856
	struct iattr attr;
1857
	unsigned int pathlen = strlen(symname);
L
Linus Torvalds 已提交
1858 1859 1860 1861 1862
	int error;

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

1863 1864
	if (pathlen > PAGE_SIZE)
		return -ENAMETOOLONG;
L
Linus Torvalds 已提交
1865

1866 1867
	attr.ia_mode = S_IFLNK | S_IRWXUGO;
	attr.ia_valid = ATTR_MODE;
L
Linus Torvalds 已提交
1868

1869
	page = alloc_page(GFP_HIGHUSER);
1870
	if (!page)
1871 1872 1873 1874 1875 1876 1877 1878
		return -ENOMEM;

	kaddr = kmap_atomic(page, KM_USER0);
	memcpy(kaddr, symname, pathlen);
	if (pathlen < PAGE_SIZE)
		memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen);
	kunmap_atomic(kaddr, KM_USER0);

1879
	error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr);
1880 1881 1882 1883
	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 已提交
1884
		d_drop(dentry);
1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895
		__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)) {
1896
		pagevec_add(&lru_pvec, page);
1897
		pagevec_lru_add_file(&lru_pvec);
1898 1899 1900 1901 1902 1903
		SetPageUptodate(page);
		unlock_page(page);
	} else
		__free_page(page);

	return 0;
L
Linus Torvalds 已提交
1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915
}

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

1916 1917
	nfs_inode_return_delegation(inode);

1918
	d_drop(dentry);
L
Linus Torvalds 已提交
1919
	error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name);
1920
	if (error == 0) {
A
Al Viro 已提交
1921
		ihold(inode);
1922
		d_add(dentry, inode);
1923
	}
L
Linus Torvalds 已提交
1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961
	return error;
}

/*
 * 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.
 */
static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
		      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 已提交
1962
		 new_dentry->d_count);
L
Linus Torvalds 已提交
1963 1964

	/*
M
Miklos Szeredi 已提交
1965 1966 1967 1968
	 * 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 已提交
1969
	 */
1970 1971 1972 1973 1974 1975 1976 1977 1978
	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 已提交
1979

N
Nick Piggin 已提交
1980
		if (new_dentry->d_count > 2) {
1981 1982 1983 1984 1985 1986 1987 1988 1989 1990
			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);
1991
			if (err)
1992
				goto out;
1993 1994

			new_dentry = dentry;
O
OGAWA Hirofumi 已提交
1995
			rehash = NULL;
1996
			new_inode = NULL;
1997
		}
1998
	}
L
Linus Torvalds 已提交
1999

2000
	nfs_inode_return_delegation(old_inode);
2001
	if (new_inode != NULL)
2002
		nfs_inode_return_delegation(new_inode);
L
Linus Torvalds 已提交
2003 2004 2005

	error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name,
					   new_dir, &new_dentry->d_name);
2006
	nfs_mark_for_revalidate(old_inode);
L
Linus Torvalds 已提交
2007 2008 2009 2010
out:
	if (rehash)
		d_rehash(rehash);
	if (!error) {
2011 2012
		if (new_inode != NULL)
			nfs_drop_nlink(new_inode);
2013
		d_move(old_dentry, new_dentry);
2014 2015
		nfs_set_verifier(new_dentry,
					nfs_save_change_attribute(new_dir));
2016 2017
	} else if (error == -ENOENT)
		nfs_dentry_handle_enoent(old_dentry);
L
Linus Torvalds 已提交
2018 2019 2020 2021 2022 2023 2024

	/* new dentry created? */
	if (dentry)
		dput(dentry);
	return error;
}

2025 2026 2027 2028
static DEFINE_SPINLOCK(nfs_access_lru_lock);
static LIST_HEAD(nfs_access_lru_list);
static atomic_long_t nfs_access_nr_entries;

2029 2030 2031 2032
static void nfs_access_free_entry(struct nfs_access_entry *entry)
{
	put_rpccred(entry->cred);
	kfree(entry);
2033 2034 2035
	smp_mb__before_atomic_dec();
	atomic_long_dec(&nfs_access_nr_entries);
	smp_mb__after_atomic_dec();
2036 2037
}

2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048
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);
	}
}

2049 2050
int nfs_access_cache_shrinker(struct shrinker *shrink,
			      struct shrink_control *sc)
2051 2052
{
	LIST_HEAD(head);
2053
	struct nfs_inode *nfsi, *next;
2054
	struct nfs_access_entry *cache;
2055 2056
	int nr_to_scan = sc->nr_to_scan;
	gfp_t gfp_mask = sc->gfp_mask;
2057

2058 2059
	if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL)
		return (nr_to_scan == 0) ? 0 : -1;
2060

2061
	spin_lock(&nfs_access_lru_lock);
2062
	list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) {
2063 2064 2065 2066
		struct inode *inode;

		if (nr_to_scan-- == 0)
			break;
2067
		inode = &nfsi->vfs_inode;
2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080
		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);
2081
			smp_mb__before_clear_bit();
2082
			clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags);
2083
			smp_mb__after_clear_bit();
2084
		}
2085
		spin_unlock(&inode->i_lock);
2086 2087
	}
	spin_unlock(&nfs_access_lru_lock);
2088
	nfs_access_free_list(&head);
2089 2090 2091
	return (atomic_long_read(&nfs_access_nr_entries) / 100) * sysctl_vfs_cache_pressure;
}

2092
static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head)
L
Linus Torvalds 已提交
2093
{
2094
	struct rb_root *root_node = &nfsi->access_cache;
2095
	struct rb_node *n;
2096 2097 2098 2099 2100 2101
	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);
2102
		list_move(&entry->lru, head);
2103 2104
	}
	nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS;
L
Linus Torvalds 已提交
2105 2106
}

2107
void nfs_access_zap_cache(struct inode *inode)
L
Linus Torvalds 已提交
2108
{
2109 2110 2111 2112
	LIST_HEAD(head);

	if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0)
		return;
2113
	/* Remove from global LRU init */
2114 2115
	spin_lock(&nfs_access_lru_lock);
	if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
2116 2117
		list_del_init(&NFS_I(inode)->access_cache_inode_lru);

2118
	spin_lock(&inode->i_lock);
2119 2120 2121 2122
	__nfs_access_zap_cache(NFS_I(inode), &head);
	spin_unlock(&inode->i_lock);
	spin_unlock(&nfs_access_lru_lock);
	nfs_access_free_list(&head);
2123
}
L
Linus Torvalds 已提交
2124

2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138
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 已提交
2139
	}
2140 2141 2142
	return NULL;
}

2143
static int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res)
2144 2145 2146 2147 2148
{
	struct nfs_inode *nfsi = NFS_I(inode);
	struct nfs_access_entry *cache;
	int err = -ENOENT;

2149
	spin_lock(&inode->i_lock);
2150 2151 2152 2153 2154
	if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)
		goto out_zap;
	cache = nfs_access_search_rbtree(inode, cred);
	if (cache == NULL)
		goto out;
2155
	if (!nfs_have_delegated_attributes(inode) &&
2156
	    !time_in_range_open(jiffies, cache->jiffies, cache->jiffies + nfsi->attrtimeo))
2157 2158 2159 2160
		goto out_stale;
	res->jiffies = cache->jiffies;
	res->cred = cache->cred;
	res->mask = cache->mask;
2161
	list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru);
2162 2163 2164 2165 2166 2167
	err = 0;
out:
	spin_unlock(&inode->i_lock);
	return err;
out_stale:
	rb_erase(&cache->rb_node, &nfsi->access_cache);
2168
	list_del(&cache->lru);
2169 2170 2171 2172
	spin_unlock(&inode->i_lock);
	nfs_access_free_entry(cache);
	return -ENOENT;
out_zap:
2173 2174
	spin_unlock(&inode->i_lock);
	nfs_access_zap_cache(inode);
2175 2176 2177 2178 2179
	return -ENOENT;
}

static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set)
{
2180 2181
	struct nfs_inode *nfsi = NFS_I(inode);
	struct rb_root *root_node = &nfsi->access_cache;
2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199
	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);
2200
	list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
2201
	spin_unlock(&inode->i_lock);
2202 2203 2204
	return;
found:
	rb_replace_node(parent, &set->rb_node, root_node);
2205 2206
	list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
	list_del(&entry->lru);
2207 2208 2209 2210
	spin_unlock(&inode->i_lock);
	nfs_access_free_entry(entry);
}

2211
static void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set)
2212 2213 2214 2215 2216
{
	struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL);
	if (cache == NULL)
		return;
	RB_CLEAR_NODE(&cache->rb_node);
L
Linus Torvalds 已提交
2217
	cache->jiffies = set->jiffies;
2218
	cache->cred = get_rpccred(set->cred);
L
Linus Torvalds 已提交
2219
	cache->mask = set->mask;
2220 2221

	nfs_access_add_rbtree(inode, cache);
2222 2223 2224 2225 2226 2227 2228

	/* 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 */
2229
	if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) {
2230
		spin_lock(&nfs_access_lru_lock);
2231 2232 2233
		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);
2234 2235
		spin_unlock(&nfs_access_lru_lock);
	}
L
Linus Torvalds 已提交
2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251
}

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);
2252 2253 2254 2255 2256 2257
	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 已提交
2258
		return status;
2259
	}
L
Linus Torvalds 已提交
2260 2261
	nfs_access_add_cache(inode, &cache);
out:
2262
	if ((mask & ~cache.mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
L
Linus Torvalds 已提交
2263 2264 2265 2266
		return 0;
	return -EACCES;
}

2267 2268 2269 2270
static int nfs_open_permission_mask(int openflags)
{
	int mask = 0;

2271
	if ((openflags & O_ACCMODE) != O_WRONLY)
2272
		mask |= MAY_READ;
2273
	if ((openflags & O_ACCMODE) != O_RDONLY)
2274
		mask |= MAY_WRITE;
2275
	if (openflags & __FMODE_EXEC)
2276 2277 2278 2279 2280 2281 2282 2283 2284
		mask |= MAY_EXEC;
	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));
}

2285
int nfs_permission(struct inode *inode, int mask)
L
Linus Torvalds 已提交
2286 2287 2288 2289
{
	struct rpc_cred *cred;
	int res = 0;

2290
	if (mask & MAY_NOT_BLOCK)
2291 2292
		return -ECHILD;

C
Chuck Lever 已提交
2293 2294
	nfs_inc_stats(inode, NFSIOS_VFSACCESS);

2295
	if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
L
Linus Torvalds 已提交
2296 2297
		goto out;
	/* Is this sys_access() ? */
E
Eric Paris 已提交
2298
	if (mask & (MAY_ACCESS | MAY_CHDIR))
L
Linus Torvalds 已提交
2299 2300 2301 2302 2303 2304 2305 2306
		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)
2307 2308
					&& (mask & MAY_OPEN)
					&& !(mask & MAY_EXEC))
L
Linus Torvalds 已提交
2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323
				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;

2324
	cred = rpc_lookup_cred();
L
Linus Torvalds 已提交
2325 2326 2327 2328 2329 2330
	if (!IS_ERR(cred)) {
		res = nfs_do_access(inode, cred, mask);
		put_rpccred(cred);
	} else
		res = PTR_ERR(cred);
out:
2331 2332 2333
	if (!res && (mask & MAY_EXEC) && !execute_ok(inode))
		res = -EACCES;

C
Chuck Lever 已提交
2334 2335
	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 已提交
2336 2337 2338 2339
	return res;
out_notsup:
	res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
	if (res == 0)
2340
		res = generic_permission(inode, mask);
C
Chuck Lever 已提交
2341
	goto out;
L
Linus Torvalds 已提交
2342 2343 2344 2345 2346 2347 2348 2349
}

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