1/*
   2 *  linux/fs/nfs/dir.c
   3 *
   4 *  Copyright (C) 1992  Rick Sladkey
   5 *
   6 *  nfs directory handling functions
   7 *
   8 * 10 Apr 1996	Added silly rename for unlink	--okir
   9 * 28 Sep 1996	Improved directory cache --okir
  10 * 23 Aug 1997  Claus Heine claus@momo.math.rwth-aachen.de 
  11 *              Re-implemented silly rename for unlink, newly implemented
  12 *              silly rename for nfs_rename() following the suggestions
  13 *              of Olaf Kirch (okir) found in this file.
  14 *              Following Linus comments on my original hack, this version
  15 *              depends only on the dcache stuff and doesn't touch the inode
  16 *              layer (iput() and friends).
  17 *  6 Jun 1999	Cache readdir lookups in the page cache. -DaveM
  18 */
  19
  20#include <linux/time.h>
  21#include <linux/errno.h>
  22#include <linux/stat.h>
  23#include <linux/fcntl.h>
  24#include <linux/string.h>
  25#include <linux/kernel.h>
  26#include <linux/slab.h>
  27#include <linux/mm.h>
  28#include <linux/sunrpc/clnt.h>
  29#include <linux/nfs_fs.h>
  30#include <linux/nfs_mount.h>
  31#include <linux/pagemap.h>
  32#include <linux/pagevec.h>
  33#include <linux/namei.h>
  34#include <linux/mount.h>
  35#include <linux/sched.h>
  36#include <linux/kmemleak.h>
  37#include <linux/xattr.h>
  38
  39#include "delegation.h"
  40#include "iostat.h"
  41#include "internal.h"
  42#include "fscache.h"
  43
  44/* #define NFS_DEBUG_VERBOSE 1 */
  45
  46static int nfs_opendir(struct inode *, struct file *);
  47static int nfs_closedir(struct inode *, struct file *);
  48static int nfs_readdir(struct file *, void *, filldir_t);
  49static struct dentry *nfs_lookup(struct inode *, struct dentry *, struct nameidata *);
  50static int nfs_create(struct inode *, struct dentry *, int, struct nameidata *);
  51static int nfs_mkdir(struct inode *, struct dentry *, int);
  52static int nfs_rmdir(struct inode *, struct dentry *);
  53static int nfs_unlink(struct inode *, struct dentry *);
  54static int nfs_symlink(struct inode *, struct dentry *, const char *);
  55static int nfs_link(struct dentry *, struct inode *, struct dentry *);
  56static int nfs_mknod(struct inode *, struct dentry *, int, dev_t);
  57static int nfs_rename(struct inode *, struct dentry *,
  58		      struct inode *, struct dentry *);
  59static int nfs_fsync_dir(struct file *, loff_t, loff_t, int);
  60static loff_t nfs_llseek_dir(struct file *, loff_t, int);
  61static void nfs_readdir_clear_array(struct page*);
  62
  63const struct file_operations nfs_dir_operations = {
  64	.llseek		= nfs_llseek_dir,
  65	.read		= generic_read_dir,
  66	.readdir	= nfs_readdir,
  67	.open		= nfs_opendir,
  68	.release	= nfs_closedir,
  69	.fsync		= nfs_fsync_dir,
  70};
  71
  72const struct inode_operations nfs_dir_inode_operations = {
  73	.create		= nfs_create,
  74	.lookup		= nfs_lookup,
  75	.link		= nfs_link,
  76	.unlink		= nfs_unlink,
  77	.symlink	= nfs_symlink,
  78	.mkdir		= nfs_mkdir,
  79	.rmdir		= nfs_rmdir,
  80	.mknod		= nfs_mknod,
  81	.rename		= nfs_rename,
  82	.permission	= nfs_permission,
  83	.getattr	= nfs_getattr,
  84	.setattr	= nfs_setattr,
  85};
  86
  87const struct address_space_operations nfs_dir_aops = {
  88	.freepage = nfs_readdir_clear_array,
  89};
  90
  91#ifdef CONFIG_NFS_V3
  92const struct inode_operations nfs3_dir_inode_operations = {
  93	.create		= nfs_create,
  94	.lookup		= nfs_lookup,
  95	.link		= nfs_link,
  96	.unlink		= nfs_unlink,
  97	.symlink	= nfs_symlink,
  98	.mkdir		= nfs_mkdir,
  99	.rmdir		= nfs_rmdir,
 100	.mknod		= nfs_mknod,
 101	.rename		= nfs_rename,
 102	.permission	= nfs_permission,
 103	.getattr	= nfs_getattr,
 104	.setattr	= nfs_setattr,
 105	.listxattr	= nfs3_listxattr,
 106	.getxattr	= nfs3_getxattr,
 107	.setxattr	= nfs3_setxattr,
 108	.removexattr	= nfs3_removexattr,
 109};
 110#endif  /* CONFIG_NFS_V3 */
 111
 112#ifdef CONFIG_NFS_V4
 113
 114static struct dentry *nfs_atomic_lookup(struct inode *, struct dentry *, struct nameidata *);
 115static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd);
 116const struct inode_operations nfs4_dir_inode_operations = {
 117	.create		= nfs_open_create,
 118	.lookup		= nfs_atomic_lookup,
 119	.link		= nfs_link,
 120	.unlink		= nfs_unlink,
 121	.symlink	= nfs_symlink,
 122	.mkdir		= nfs_mkdir,
 123	.rmdir		= nfs_rmdir,
 124	.mknod		= nfs_mknod,
 125	.rename		= nfs_rename,
 126	.permission	= nfs_permission,
 127	.getattr	= nfs_getattr,
 128	.setattr	= nfs_setattr,
 129	.getxattr	= generic_getxattr,
 130	.setxattr	= generic_setxattr,
 131	.listxattr	= generic_listxattr,
 132	.removexattr	= generic_removexattr,
 133};
 134
 135#endif /* CONFIG_NFS_V4 */
 136
 137static struct nfs_open_dir_context *alloc_nfs_open_dir_context(struct inode *dir, struct rpc_cred *cred)
 138{
 139	struct nfs_open_dir_context *ctx;
 140	ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
 141	if (ctx != NULL) {
 142		ctx->duped = 0;
 143		ctx->attr_gencount = NFS_I(dir)->attr_gencount;
 144		ctx->dir_cookie = 0;
 145		ctx->dup_cookie = 0;
 146		ctx->cred = get_rpccred(cred);
 147		return ctx;
 148	}
 149	return  ERR_PTR(-ENOMEM);
 150}
 151
 152static void put_nfs_open_dir_context(struct nfs_open_dir_context *ctx)
 153{
 154	put_rpccred(ctx->cred);
 155	kfree(ctx);
 156}
 157
 158/*
 159 * Open file
 160 */
 161static int
 162nfs_opendir(struct inode *inode, struct file *filp)
 163{
 164	int res = 0;
 165	struct nfs_open_dir_context *ctx;
 166	struct rpc_cred *cred;
 167
 168	dfprintk(FILE, "NFS: open dir(%s/%s)\n",
 169			filp->f_path.dentry->d_parent->d_name.name,
 170			filp->f_path.dentry->d_name.name);
 171
 172	nfs_inc_stats(inode, NFSIOS_VFSOPEN);
 173
 174	cred = rpc_lookup_cred();
 175	if (IS_ERR(cred))
 176		return PTR_ERR(cred);
 177	ctx = alloc_nfs_open_dir_context(inode, cred);
 178	if (IS_ERR(ctx)) {
 179		res = PTR_ERR(ctx);
 180		goto out;
 181	}
 182	filp->private_data = ctx;
 183	if (filp->f_path.dentry == filp->f_path.mnt->mnt_root) {
 184		/* This is a mountpoint, so d_revalidate will never
 185		 * have been called, so we need to refresh the
 186		 * inode (for close-open consistency) ourselves.
 187		 */
 188		__nfs_revalidate_inode(NFS_SERVER(inode), inode);
 189	}
 190out:
 191	put_rpccred(cred);
 192	return res;
 193}
 194
 195static int
 196nfs_closedir(struct inode *inode, struct file *filp)
 197{
 198	put_nfs_open_dir_context(filp->private_data);
 199	return 0;
 200}
 201
 202struct nfs_cache_array_entry {
 203	u64 cookie;
 204	u64 ino;
 205	struct qstr string;
 206	unsigned char d_type;
 207};
 208
 209struct nfs_cache_array {
 210	unsigned int size;
 211	int eof_index;
 212	u64 last_cookie;
 213	struct nfs_cache_array_entry array[0];
 214};
 215
 216typedef int (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, int);
 217typedef struct {
 218	struct file	*file;
 219	struct page	*page;
 220	unsigned long	page_index;
 221	u64		*dir_cookie;
 222	u64		last_cookie;
 223	loff_t		current_index;
 224	decode_dirent_t	decode;
 225
 226	unsigned long	timestamp;
 227	unsigned long	gencount;
 228	unsigned int	cache_entry_index;
 229	unsigned int	plus:1;
 230	unsigned int	eof:1;
 231} nfs_readdir_descriptor_t;
 232
 233/*
 234 * The caller is responsible for calling nfs_readdir_release_array(page)
 235 */
 236static
 237struct nfs_cache_array *nfs_readdir_get_array(struct page *page)
 238{
 239	void *ptr;
 240	if (page == NULL)
 241		return ERR_PTR(-EIO);
 242	ptr = kmap(page);
 243	if (ptr == NULL)
 244		return ERR_PTR(-ENOMEM);
 245	return ptr;
 246}
 247
 248static
 249void nfs_readdir_release_array(struct page *page)
 250{
 251	kunmap(page);
 252}
 253
 254/*
 255 * we are freeing strings created by nfs_add_to_readdir_array()
 256 */
 257static
 258void nfs_readdir_clear_array(struct page *page)
 259{
 260	struct nfs_cache_array *array;
 261	int i;
 262
 263	array = kmap_atomic(page, KM_USER0);
 264	for (i = 0; i < array->size; i++)
 265		kfree(array->array[i].string.name);
 266	kunmap_atomic(array, KM_USER0);
 267}
 268
 269/*
 270 * the caller is responsible for freeing qstr.name
 271 * when called by nfs_readdir_add_to_array, the strings will be freed in
 272 * nfs_clear_readdir_array()
 273 */
 274static
 275int nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int len)
 276{
 277	string->len = len;
 278	string->name = kmemdup(name, len, GFP_KERNEL);
 279	if (string->name == NULL)
 280		return -ENOMEM;
 281	/*
 282	 * Avoid a kmemleak false positive. The pointer to the name is stored
 283	 * in a page cache page which kmemleak does not scan.
 284	 */
 285	kmemleak_not_leak(string->name);
 286	string->hash = full_name_hash(name, len);
 287	return 0;
 288}
 289
 290static
 291int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page)
 292{
 293	struct nfs_cache_array *array = nfs_readdir_get_array(page);
 294	struct nfs_cache_array_entry *cache_entry;
 295	int ret;
 296
 297	if (IS_ERR(array))
 298		return PTR_ERR(array);
 299
 300	cache_entry = &array->array[array->size];
 301
 302	/* Check that this entry lies within the page bounds */
 303	ret = -ENOSPC;
 304	if ((char *)&cache_entry[1] - (char *)page_address(page) > PAGE_SIZE)
 305		goto out;
 306
 307	cache_entry->cookie = entry->prev_cookie;
 308	cache_entry->ino = entry->ino;
 309	cache_entry->d_type = entry->d_type;
 310	ret = nfs_readdir_make_qstr(&cache_entry->string, entry->name, entry->len);
 311	if (ret)
 312		goto out;
 313	array->last_cookie = entry->cookie;
 314	array->size++;
 315	if (entry->eof != 0)
 316		array->eof_index = array->size;
 317out:
 318	nfs_readdir_release_array(page);
 319	return ret;
 320}
 321
 322static
 323int nfs_readdir_search_for_pos(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
 324{
 325	loff_t diff = desc->file->f_pos - desc->current_index;
 326	unsigned int index;
 327
 328	if (diff < 0)
 329		goto out_eof;
 330	if (diff >= array->size) {
 331		if (array->eof_index >= 0)
 332			goto out_eof;
 333		return -EAGAIN;
 334	}
 335
 336	index = (unsigned int)diff;
 337	*desc->dir_cookie = array->array[index].cookie;
 338	desc->cache_entry_index = index;
 339	return 0;
 340out_eof:
 341	desc->eof = 1;
 342	return -EBADCOOKIE;
 343}
 344
 345static
 346int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
 347{
 348	int i;
 349	loff_t new_pos;
 350	int status = -EAGAIN;
 351
 352	for (i = 0; i < array->size; i++) {
 353		if (array->array[i].cookie == *desc->dir_cookie) {
 354			struct nfs_inode *nfsi = NFS_I(desc->file->f_path.dentry->d_inode);
 355			struct nfs_open_dir_context *ctx = desc->file->private_data;
 356
 357			new_pos = desc->current_index + i;
 358			if (ctx->attr_gencount != nfsi->attr_gencount
 359			    || (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA))) {
 360				ctx->duped = 0;
 361				ctx->attr_gencount = nfsi->attr_gencount;
 362			} else if (new_pos < desc->file->f_pos) {
 363				if (ctx->duped > 0
 364				    && ctx->dup_cookie == *desc->dir_cookie) {
 365					if (printk_ratelimit()) {
 366						pr_notice("NFS: directory %s/%s contains a readdir loop."
 367								"Please contact your server vendor.  "
 368								"The file: %s has duplicate cookie %llu\n",
 369								desc->file->f_dentry->d_parent->d_name.name,
 370								desc->file->f_dentry->d_name.name,
 371								array->array[i].string.name,
 372								*desc->dir_cookie);
 373					}
 374					status = -ELOOP;
 375					goto out;
 376				}
 377				ctx->dup_cookie = *desc->dir_cookie;
 378				ctx->duped = -1;
 379			}
 380			desc->file->f_pos = new_pos;
 381			desc->cache_entry_index = i;
 382			return 0;
 383		}
 384	}
 385	if (array->eof_index >= 0) {
 386		status = -EBADCOOKIE;
 387		if (*desc->dir_cookie == array->last_cookie)
 388			desc->eof = 1;
 389	}
 390out:
 391	return status;
 392}
 393
 394static
 395int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc)
 396{
 397	struct nfs_cache_array *array;
 398	int status;
 399
 400	array = nfs_readdir_get_array(desc->page);
 401	if (IS_ERR(array)) {
 402		status = PTR_ERR(array);
 403		goto out;
 404	}
 405
 406	if (*desc->dir_cookie == 0)
 407		status = nfs_readdir_search_for_pos(array, desc);
 408	else
 409		status = nfs_readdir_search_for_cookie(array, desc);
 410
 411	if (status == -EAGAIN) {
 412		desc->last_cookie = array->last_cookie;
 413		desc->current_index += array->size;
 414		desc->page_index++;
 415	}
 416	nfs_readdir_release_array(desc->page);
 417out:
 418	return status;
 419}
 420
 421/* Fill a page with xdr information before transferring to the cache page */
 422static
 423int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc,
 424			struct nfs_entry *entry, struct file *file, struct inode *inode)
 425{
 426	struct nfs_open_dir_context *ctx = file->private_data;
 427	struct rpc_cred	*cred = ctx->cred;
 428	unsigned long	timestamp, gencount;
 429	int		error;
 430
 431 again:
 432	timestamp = jiffies;
 433	gencount = nfs_inc_attr_generation_counter();
 434	error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, entry->cookie, pages,
 435					  NFS_SERVER(inode)->dtsize, desc->plus);
 436	if (error < 0) {
 437		/* We requested READDIRPLUS, but the server doesn't grok it */
 438		if (error == -ENOTSUPP && desc->plus) {
 439			NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS;
 440			clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
 441			desc->plus = 0;
 442			goto again;
 443		}
 444		goto error;
 445	}
 446	desc->timestamp = timestamp;
 447	desc->gencount = gencount;
 448error:
 449	return error;
 450}
 451
 452static int xdr_decode(nfs_readdir_descriptor_t *desc,
 453		      struct nfs_entry *entry, struct xdr_stream *xdr)
 454{
 455	int error;
 456
 457	error = desc->decode(xdr, entry, desc->plus);
 458	if (error)
 459		return error;
 460	entry->fattr->time_start = desc->timestamp;
 461	entry->fattr->gencount = desc->gencount;
 462	return 0;
 463}
 464
 465static
 466int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry)
 467{
 468	if (dentry->d_inode == NULL)
 469		goto different;
 470	if (nfs_compare_fh(entry->fh, NFS_FH(dentry->d_inode)) != 0)
 471		goto different;
 472	return 1;
 473different:
 474	return 0;
 475}
 476
 477static
 478void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
 479{
 480	struct qstr filename = {
 481		.len = entry->len,
 482		.name = entry->name,
 483	};
 484	struct dentry *dentry;
 485	struct dentry *alias;
 486	struct inode *dir = parent->d_inode;
 487	struct inode *inode;
 488
 489	if (filename.name[0] == '.') {
 490		if (filename.len == 1)
 491			return;
 492		if (filename.len == 2 && filename.name[1] == '.')
 493			return;
 494	}
 495	filename.hash = full_name_hash(filename.name, filename.len);
 496
 497	dentry = d_lookup(parent, &filename);
 498	if (dentry != NULL) {
 499		if (nfs_same_file(dentry, entry)) {
 500			nfs_refresh_inode(dentry->d_inode, entry->fattr);
 501			goto out;
 502		} else {
 503			d_drop(dentry);
 504			dput(dentry);
 505		}
 506	}
 507
 508	dentry = d_alloc(parent, &filename);
 509	if (dentry == NULL)
 510		return;
 511
 512	inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr);
 513	if (IS_ERR(inode))
 514		goto out;
 515
 516	alias = d_materialise_unique(dentry, inode);
 517	if (IS_ERR(alias))
 518		goto out;
 519	else if (alias) {
 520		nfs_set_verifier(alias, nfs_save_change_attribute(dir));
 521		dput(alias);
 522	} else
 523		nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
 524
 525out:
 526	dput(dentry);
 527}
 528
 529/* Perform conversion from xdr to cache array */
 530static
 531int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry,
 532				struct page **xdr_pages, struct page *page, unsigned int buflen)
 533{
 534	struct xdr_stream stream;
 535	struct xdr_buf buf;
 536	struct page *scratch;
 537	struct nfs_cache_array *array;
 538	unsigned int count = 0;
 539	int status;
 540
 541	scratch = alloc_page(GFP_KERNEL);
 542	if (scratch == NULL)
 543		return -ENOMEM;
 544
 545	xdr_init_decode_pages(&stream, &buf, xdr_pages, buflen);
 546	xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
 547
 548	do {
 549		status = xdr_decode(desc, entry, &stream);
 550		if (status != 0) {
 551			if (status == -EAGAIN)
 552				status = 0;
 553			break;
 554		}
 555
 556		count++;
 557
 558		if (desc->plus != 0)
 559			nfs_prime_dcache(desc->file->f_path.dentry, entry);
 560
 561		status = nfs_readdir_add_to_array(entry, page);
 562		if (status != 0)
 563			break;
 564	} while (!entry->eof);
 565
 566	if (count == 0 || (status == -EBADCOOKIE && entry->eof != 0)) {
 567		array = nfs_readdir_get_array(page);
 568		if (!IS_ERR(array)) {
 569			array->eof_index = array->size;
 570			status = 0;
 571			nfs_readdir_release_array(page);
 572		} else
 573			status = PTR_ERR(array);
 574	}
 575
 576	put_page(scratch);
 577	return status;
 578}
 579
 580static
 581void nfs_readdir_free_pagearray(struct page **pages, unsigned int npages)
 582{
 583	unsigned int i;
 584	for (i = 0; i < npages; i++)
 585		put_page(pages[i]);
 586}
 587
 588static
 589void nfs_readdir_free_large_page(void *ptr, struct page **pages,
 590		unsigned int npages)
 591{
 592	nfs_readdir_free_pagearray(pages, npages);
 593}
 594
 595/*
 596 * nfs_readdir_large_page will allocate pages that must be freed with a call
 597 * to nfs_readdir_free_large_page
 598 */
 599static
 600int nfs_readdir_large_page(struct page **pages, unsigned int npages)
 601{
 602	unsigned int i;
 603
 604	for (i = 0; i < npages; i++) {
 605		struct page *page = alloc_page(GFP_KERNEL);
 606		if (page == NULL)
 607			goto out_freepages;
 608		pages[i] = page;
 609	}
 610	return 0;
 611
 612out_freepages:
 613	nfs_readdir_free_pagearray(pages, i);
 614	return -ENOMEM;
 615}
 616
 617static
 618int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode)
 619{
 620	struct page *pages[NFS_MAX_READDIR_PAGES];
 621	void *pages_ptr = NULL;
 622	struct nfs_entry entry;
 623	struct file	*file = desc->file;
 624	struct nfs_cache_array *array;
 625	int status = -ENOMEM;
 626	unsigned int array_size = ARRAY_SIZE(pages);
 627
 628	entry.prev_cookie = 0;
 629	entry.cookie = desc->last_cookie;
 630	entry.eof = 0;
 631	entry.fh = nfs_alloc_fhandle();
 632	entry.fattr = nfs_alloc_fattr();
 633	entry.server = NFS_SERVER(inode);
 634	if (entry.fh == NULL || entry.fattr == NULL)
 635		goto out;
 636
 637	array = nfs_readdir_get_array(page);
 638	if (IS_ERR(array)) {
 639		status = PTR_ERR(array);
 640		goto out;
 641	}
 642	memset(array, 0, sizeof(struct nfs_cache_array));
 643	array->eof_index = -1;
 644
 645	status = nfs_readdir_large_page(pages, array_size);
 646	if (status < 0)
 647		goto out_release_array;
 648	do {
 649		unsigned int pglen;
 650		status = nfs_readdir_xdr_filler(pages, desc, &entry, file, inode);
 651
 652		if (status < 0)
 653			break;
 654		pglen = status;
 655		status = nfs_readdir_page_filler(desc, &entry, pages, page, pglen);
 656		if (status < 0) {
 657			if (status == -ENOSPC)
 658				status = 0;
 659			break;
 660		}
 661	} while (array->eof_index < 0);
 662
 663	nfs_readdir_free_large_page(pages_ptr, pages, array_size);
 664out_release_array:
 665	nfs_readdir_release_array(page);
 666out:
 667	nfs_free_fattr(entry.fattr);
 668	nfs_free_fhandle(entry.fh);
 669	return status;
 670}
 671
 672/*
 673 * Now we cache directories properly, by converting xdr information
 674 * to an array that can be used for lookups later.  This results in
 675 * fewer cache pages, since we can store more information on each page.
 676 * We only need to convert from xdr once so future lookups are much simpler
 677 */
 678static
 679int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page* page)
 680{
 681	struct inode	*inode = desc->file->f_path.dentry->d_inode;
 682	int ret;
 683
 684	ret = nfs_readdir_xdr_to_array(desc, page, inode);
 685	if (ret < 0)
 686		goto error;
 687	SetPageUptodate(page);
 688
 689	if (invalidate_inode_pages2_range(inode->i_mapping, page->index + 1, -1) < 0) {
 690		/* Should never happen */
 691		nfs_zap_mapping(inode, inode->i_mapping);
 692	}
 693	unlock_page(page);
 694	return 0;
 695 error:
 696	unlock_page(page);
 697	return ret;
 698}
 699
 700static
 701void cache_page_release(nfs_readdir_descriptor_t *desc)
 702{
 703	if (!desc->page->mapping)
 704		nfs_readdir_clear_array(desc->page);
 705	page_cache_release(desc->page);
 706	desc->page = NULL;
 707}
 708
 709static
 710struct page *get_cache_page(nfs_readdir_descriptor_t *desc)
 711{
 712	return read_cache_page(desc->file->f_path.dentry->d_inode->i_mapping,
 713			desc->page_index, (filler_t *)nfs_readdir_filler, desc);
 714}
 715
 716/*
 717 * Returns 0 if desc->dir_cookie was found on page desc->page_index
 718 */
 719static
 720int find_cache_page(nfs_readdir_descriptor_t *desc)
 721{
 722	int res;
 723
 724	desc->page = get_cache_page(desc);
 725	if (IS_ERR(desc->page))
 726		return PTR_ERR(desc->page);
 727
 728	res = nfs_readdir_search_array(desc);
 729	if (res != 0)
 730		cache_page_release(desc);
 731	return res;
 732}
 733
 734/* Search for desc->dir_cookie from the beginning of the page cache */
 735static inline
 736int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)
 737{
 738	int res;
 739
 740	if (desc->page_index == 0) {
 741		desc->current_index = 0;
 742		desc->last_cookie = 0;
 743	}
 744	do {
 745		res = find_cache_page(desc);
 746	} while (res == -EAGAIN);
 747	return res;
 748}
 749
 750/*
 751 * Once we've found the start of the dirent within a page: fill 'er up...
 752 */
 753static 
 754int nfs_do_filldir(nfs_readdir_descriptor_t *desc, void *dirent,
 755		   filldir_t filldir)
 756{
 757	struct file	*file = desc->file;
 758	int i = 0;
 759	int res = 0;
 760	struct nfs_cache_array *array = NULL;
 761	struct nfs_open_dir_context *ctx = file->private_data;
 762
 763	array = nfs_readdir_get_array(desc->page);
 764	if (IS_ERR(array)) {
 765		res = PTR_ERR(array);
 766		goto out;
 767	}
 768
 769	for (i = desc->cache_entry_index; i < array->size; i++) {
 770		struct nfs_cache_array_entry *ent;
 771
 772		ent = &array->array[i];
 773		if (filldir(dirent, ent->string.name, ent->string.len,
 774		    file->f_pos, nfs_compat_user_ino64(ent->ino),
 775		    ent->d_type) < 0) {
 776			desc->eof = 1;
 777			break;
 778		}
 779		file->f_pos++;
 780		if (i < (array->size-1))
 781			*desc->dir_cookie = array->array[i+1].cookie;
 782		else
 783			*desc->dir_cookie = array->last_cookie;
 784		if (ctx->duped != 0)
 785			ctx->duped = 1;
 786	}
 787	if (array->eof_index >= 0)
 788		desc->eof = 1;
 789
 790	nfs_readdir_release_array(desc->page);
 791out:
 792	cache_page_release(desc);
 793	dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n",
 794			(unsigned long long)*desc->dir_cookie, res);
 795	return res;
 796}
 797
 798/*
 799 * If we cannot find a cookie in our cache, we suspect that this is
 800 * because it points to a deleted file, so we ask the server to return
 801 * whatever it thinks is the next entry. We then feed this to filldir.
 802 * If all goes well, we should then be able to find our way round the
 803 * cache on the next call to readdir_search_pagecache();
 804 *
 805 * NOTE: we cannot add the anonymous page to the pagecache because
 806 *	 the data it contains might not be page aligned. Besides,
 807 *	 we should already have a complete representation of the
 808 *	 directory in the page cache by the time we get here.
 809 */
 810static inline
 811int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
 812		     filldir_t filldir)
 813{
 814	struct page	*page = NULL;
 815	int		status;
 816	struct inode *inode = desc->file->f_path.dentry->d_inode;
 817	struct nfs_open_dir_context *ctx = desc->file->private_data;
 818
 819	dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n",
 820			(unsigned long long)*desc->dir_cookie);
 821
 822	page = alloc_page(GFP_HIGHUSER);
 823	if (!page) {
 824		status = -ENOMEM;
 825		goto out;
 826	}
 827
 828	desc->page_index = 0;
 829	desc->last_cookie = *desc->dir_cookie;
 830	desc->page = page;
 831	ctx->duped = 0;
 832
 833	status = nfs_readdir_xdr_to_array(desc, page, inode);
 834	if (status < 0)
 835		goto out_release;
 836
 837	status = nfs_do_filldir(desc, dirent, filldir);
 838
 839 out:
 840	dfprintk(DIRCACHE, "NFS: %s: returns %d\n",
 841			__func__, status);
 842	return status;
 843 out_release:
 844	cache_page_release(desc);
 845	goto out;
 846}
 847
 848/* The file offset position represents the dirent entry number.  A
 849   last cookie cache takes care of the common case of reading the
 850   whole directory.
 851 */
 852static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 853{
 854	struct dentry	*dentry = filp->f_path.dentry;
 855	struct inode	*inode = dentry->d_inode;
 856	nfs_readdir_descriptor_t my_desc,
 857			*desc = &my_desc;
 858	struct nfs_open_dir_context *dir_ctx = filp->private_data;
 859	int res;
 860
 861	dfprintk(FILE, "NFS: readdir(%s/%s) starting at cookie %llu\n",
 862			dentry->d_parent->d_name.name, dentry->d_name.name,
 863			(long long)filp->f_pos);
 864	nfs_inc_stats(inode, NFSIOS_VFSGETDENTS);
 865
 866	/*
 867	 * filp->f_pos points to the dirent entry number.
 868	 * *desc->dir_cookie has the cookie for the next entry. We have
 869	 * to either find the entry with the appropriate number or
 870	 * revalidate the cookie.
 871	 */
 872	memset(desc, 0, sizeof(*desc));
 873
 874	desc->file = filp;
 875	desc->dir_cookie = &dir_ctx->dir_cookie;
 876	desc->decode = NFS_PROTO(inode)->decode_dirent;
 877	desc->plus = NFS_USE_READDIRPLUS(inode);
 878
 879	nfs_block_sillyrename(dentry);
 880	res = nfs_revalidate_mapping(inode, filp->f_mapping);
 881	if (res < 0)
 882		goto out;
 883
 884	do {
 885		res = readdir_search_pagecache(desc);
 886
 887		if (res == -EBADCOOKIE) {
 888			res = 0;
 889			/* This means either end of directory */
 890			if (*desc->dir_cookie && desc->eof == 0) {
 891				/* Or that the server has 'lost' a cookie */
 892				res = uncached_readdir(desc, dirent, filldir);
 893				if (res == 0)
 894					continue;
 895			}
 896			break;
 897		}
 898		if (res == -ETOOSMALL && desc->plus) {
 899			clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
 900			nfs_zap_caches(inode);
 901			desc->page_index = 0;
 902			desc->plus = 0;
 903			desc->eof = 0;
 904			continue;
 905		}
 906		if (res < 0)
 907			break;
 908
 909		res = nfs_do_filldir(desc, dirent, filldir);
 910		if (res < 0)
 911			break;
 912	} while (!desc->eof);
 913out:
 914	nfs_unblock_sillyrename(dentry);
 915	if (res > 0)
 916		res = 0;
 917	dfprintk(FILE, "NFS: readdir(%s/%s) returns %d\n",
 918			dentry->d_parent->d_name.name, dentry->d_name.name,
 919			res);
 920	return res;
 921}
 922
 923static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)
 924{
 925	struct dentry *dentry = filp->f_path.dentry;
 926	struct inode *inode = dentry->d_inode;
 927	struct nfs_open_dir_context *dir_ctx = filp->private_data;
 928
 929	dfprintk(FILE, "NFS: llseek dir(%s/%s, %lld, %d)\n",
 930			dentry->d_parent->d_name.name,
 931			dentry->d_name.name,
 932			offset, origin);
 933
 934	mutex_lock(&inode->i_mutex);
 935	switch (origin) {
 936		case 1:
 937			offset += filp->f_pos;
 938		case 0:
 939			if (offset >= 0)
 940				break;
 941		default:
 942			offset = -EINVAL;
 943			goto out;
 944	}
 945	if (offset != filp->f_pos) {
 946		filp->f_pos = offset;
 947		dir_ctx->dir_cookie = 0;
 948		dir_ctx->duped = 0;
 949	}
 950out:
 951	mutex_unlock(&inode->i_mutex);
 952	return offset;
 953}
 954
 955/*
 956 * All directory operations under NFS are synchronous, so fsync()
 957 * is a dummy operation.
 958 */
 959static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end,
 960			 int datasync)
 961{
 962	struct dentry *dentry = filp->f_path.dentry;
 963	struct inode *inode = dentry->d_inode;
 964
 965	dfprintk(FILE, "NFS: fsync dir(%s/%s) datasync %d\n",
 966			dentry->d_parent->d_name.name, dentry->d_name.name,
 967			datasync);
 968
 969	mutex_lock(&inode->i_mutex);
 970	nfs_inc_stats(dentry->d_inode, NFSIOS_VFSFSYNC);
 971	mutex_unlock(&inode->i_mutex);
 972	return 0;
 973}
 974
 975/**
 976 * nfs_force_lookup_revalidate - Mark the directory as having changed
 977 * @dir - pointer to directory inode
 978 *
 979 * This forces the revalidation code in nfs_lookup_revalidate() to do a
 980 * full lookup on all child dentries of 'dir' whenever a change occurs
 981 * on the server that might have invalidated our dcache.
 982 *
 983 * The caller should be holding dir->i_lock
 984 */
 985void nfs_force_lookup_revalidate(struct inode *dir)
 986{
 987	NFS_I(dir)->cache_change_attribute++;
 988}
 989
 990/*
 991 * A check for whether or not the parent directory has changed.
 992 * In the case it has, we assume that the dentries are untrustworthy
 993 * and may need to be looked up again.
 994 */
 995static int nfs_check_verifier(struct inode *dir, struct dentry *dentry)
 996{
 997	if (IS_ROOT(dentry))
 998		return 1;
 999	if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
1000		return 0;
1001	if (!nfs_verify_change_attribute(dir, dentry->d_time))
1002		return 0;
1003	/* Revalidate nfsi->cache_change_attribute before we declare a match */
1004	if (nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0)
1005		return 0;
1006	if (!nfs_verify_change_attribute(dir, dentry->d_time))
1007		return 0;
1008	return 1;
1009}
1010
1011/*
1012 * Return the intent data that applies to this particular path component
1013 *
1014 * Note that the current set of intents only apply to the very last
1015 * component of the path and none of them is set before that last
1016 * component.
1017 */
1018static inline unsigned int nfs_lookup_check_intent(struct nameidata *nd,
1019						unsigned int mask)
1020{
1021	return nd->flags & mask;
1022}
1023
1024/*
1025 * Use intent information to check whether or not we're going to do
1026 * an O_EXCL create using this path component.
1027 */
1028static int nfs_is_exclusive_create(struct inode *dir, struct nameidata *nd)
1029{
1030	if (NFS_PROTO(dir)->version == 2)
1031		return 0;
1032	return nd && nfs_lookup_check_intent(nd, LOOKUP_EXCL);
1033}
1034
1035/*
1036 * Inode and filehandle revalidation for lookups.
1037 *
1038 * We force revalidation in the cases where the VFS sets LOOKUP_REVAL,
1039 * or if the intent information indicates that we're about to open this
1040 * particular file and the "nocto" mount flag is not set.
1041 *
1042 */
1043static inline
1044int nfs_lookup_verify_inode(struct inode *inode, struct nameidata *nd)
1045{
1046	struct nfs_server *server = NFS_SERVER(inode);
1047
1048	if (IS_AUTOMOUNT(inode))
1049		return 0;
1050	if (nd != NULL) {
1051		/* VFS wants an on-the-wire revalidation */
1052		if (nd->flags & LOOKUP_REVAL)
1053			goto out_force;
1054		/* This is an open(2) */
1055		if (nfs_lookup_check_intent(nd, LOOKUP_OPEN) != 0 &&
1056				!(server->flags & NFS_MOUNT_NOCTO) &&
1057				(S_ISREG(inode->i_mode) ||
1058				 S_ISDIR(inode->i_mode)))
1059			goto out_force;
1060		return 0;
1061	}
1062	return nfs_revalidate_inode(server, inode);
1063out_force:
1064	return __nfs_revalidate_inode(server, inode);
1065}
1066
1067/*
1068 * We judge how long we want to trust negative
1069 * dentries by looking at the parent inode mtime.
1070 *
1071 * If parent mtime has changed, we revalidate, else we wait for a
1072 * period corresponding to the parent's attribute cache timeout value.
1073 */
1074static inline
1075int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry,
1076		       struct nameidata *nd)
1077{
1078	/* Don't revalidate a negative dentry if we're creating a new file */
1079	if (nd != NULL && nfs_lookup_check_intent(nd, LOOKUP_CREATE) != 0)
1080		return 0;
1081	if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG)
1082		return 1;
1083	return !nfs_check_verifier(dir, dentry);
1084}
1085
1086/*
1087 * This is called every time the dcache has a lookup hit,
1088 * and we should check whether we can really trust that
1089 * lookup.
1090 *
1091 * NOTE! The hit can be a negative hit too, don't assume
1092 * we have an inode!
1093 *
1094 * If the parent directory is seen to have changed, we throw out the
1095 * cached dentry and do a new lookup.
1096 */
1097static int nfs_lookup_revalidate(struct dentry *dentry, struct nameidata *nd)
1098{
1099	struct inode *dir;
1100	struct inode *inode;
1101	struct dentry *parent;
1102	struct nfs_fh *fhandle = NULL;
1103	struct nfs_fattr *fattr = NULL;
1104	int error;
1105
1106	if (nd->flags & LOOKUP_RCU)
1107		return -ECHILD;
1108
1109	parent = dget_parent(dentry);
1110	dir = parent->d_inode;
1111	nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE);
1112	inode = dentry->d_inode;
1113
1114	if (!inode) {
1115		if (nfs_neg_need_reval(dir, dentry, nd))
1116			goto out_bad;
1117		goto out_valid;
1118	}
1119
1120	if (is_bad_inode(inode)) {
1121		dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n",
1122				__func__, dentry->d_parent->d_name.name,
1123				dentry->d_name.name);
1124		goto out_bad;
1125	}
1126
1127	if (nfs_have_delegation(inode, FMODE_READ))
1128		goto out_set_verifier;
1129
1130	/* Force a full look up iff the parent directory has changed */
1131	if (!nfs_is_exclusive_create(dir, nd) && nfs_check_verifier(dir, dentry)) {
1132		if (nfs_lookup_verify_inode(inode, nd))
1133			goto out_zap_parent;
1134		goto out_valid;
1135	}
1136
1137	if (NFS_STALE(inode))
1138		goto out_bad;
1139
1140	error = -ENOMEM;
1141	fhandle = nfs_alloc_fhandle();
1142	fattr = nfs_alloc_fattr();
1143	if (fhandle == NULL || fattr == NULL)
1144		goto out_error;
1145
1146	error = NFS_PROTO(dir)->lookup(NFS_SERVER(dir)->client, dir, &dentry->d_name, fhandle, fattr);
1147	if (error)
1148		goto out_bad;
1149	if (nfs_compare_fh(NFS_FH(inode), fhandle))
1150		goto out_bad;
1151	if ((error = nfs_refresh_inode(inode, fattr)) != 0)
1152		goto out_bad;
1153
1154	nfs_free_fattr(fattr);
1155	nfs_free_fhandle(fhandle);
1156out_set_verifier:
1157	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1158 out_valid:
1159	dput(parent);
1160	dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is valid\n",
1161			__func__, dentry->d_parent->d_name.name,
1162			dentry->d_name.name);
1163	return 1;
1164out_zap_parent:
1165	nfs_zap_caches(dir);
1166 out_bad:
1167	nfs_mark_for_revalidate(dir);
1168	if (inode && S_ISDIR(inode->i_mode)) {
1169		/* Purge readdir caches. */
1170		nfs_zap_caches(inode);
1171		/* If we have submounts, don't unhash ! */
1172		if (have_submounts(dentry))
1173			goto out_valid;
1174		if (dentry->d_flags & DCACHE_DISCONNECTED)
1175			goto out_valid;
1176		shrink_dcache_parent(dentry);
1177	}
1178	d_drop(dentry);
1179	nfs_free_fattr(fattr);
1180	nfs_free_fhandle(fhandle);
1181	dput(parent);
1182	dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n",
1183			__func__, dentry->d_parent->d_name.name,
1184			dentry->d_name.name);
1185	return 0;
1186out_error:
1187	nfs_free_fattr(fattr);
1188	nfs_free_fhandle(fhandle);
1189	dput(parent);
1190	dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) lookup returned error %d\n",
1191			__func__, dentry->d_parent->d_name.name,
1192			dentry->d_name.name, error);
1193	return error;
1194}
1195
1196/*
1197 * This is called from dput() when d_count is going to 0.
1198 */
1199static int nfs_dentry_delete(const struct dentry *dentry)
1200{
1201	dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)\n",
1202		dentry->d_parent->d_name.name, dentry->d_name.name,
1203		dentry->d_flags);
1204
1205	/* Unhash any dentry with a stale inode */
1206	if (dentry->d_inode != NULL && NFS_STALE(dentry->d_inode))
1207		return 1;
1208
1209	if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1210		/* Unhash it, so that ->d_iput() would be called */
1211		return 1;
1212	}
1213	if (!(dentry->d_sb->s_flags & MS_ACTIVE)) {
1214		/* Unhash it, so that ancestors of killed async unlink
1215		 * files will be cleaned up during umount */
1216		return 1;
1217	}
1218	return 0;
1219
1220}
1221
1222static void nfs_drop_nlink(struct inode *inode)
1223{
1224	spin_lock(&inode->i_lock);
1225	if (inode->i_nlink > 0)
1226		drop_nlink(inode);
1227	spin_unlock(&inode->i_lock);
1228}
1229
1230/*
1231 * Called when the dentry loses inode.
1232 * We use it to clean up silly-renamed files.
1233 */
1234static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode)
1235{
1236	if (S_ISDIR(inode->i_mode))
1237		/* drop any readdir cache as it could easily be old */
1238		NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
1239
1240	if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1241		drop_nlink(inode);
1242		nfs_complete_unlink(dentry, inode);
1243	}
1244	iput(inode);
1245}
1246
1247static void nfs_d_release(struct dentry *dentry)
1248{
1249	/* free cached devname value, if it survived that far */
1250	if (unlikely(dentry->d_fsdata)) {
1251		if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
1252			WARN_ON(1);
1253		else
1254			kfree(dentry->d_fsdata);
1255	}
1256}
1257
1258const struct dentry_operations nfs_dentry_operations = {
1259	.d_revalidate	= nfs_lookup_revalidate,
1260	.d_delete	= nfs_dentry_delete,
1261	.d_iput		= nfs_dentry_iput,
1262	.d_automount	= nfs_d_automount,
1263	.d_release	= nfs_d_release,
1264};
1265
1266static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
1267{
1268	struct dentry *res;
1269	struct dentry *parent;
1270	struct inode *inode = NULL;
1271	struct nfs_fh *fhandle = NULL;
1272	struct nfs_fattr *fattr = NULL;
1273	int error;
1274
1275	dfprintk(VFS, "NFS: lookup(%s/%s)\n",
1276		dentry->d_parent->d_name.name, dentry->d_name.name);
1277	nfs_inc_stats(dir, NFSIOS_VFSLOOKUP);
1278
1279	res = ERR_PTR(-ENAMETOOLONG);
1280	if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
1281		goto out;
1282
1283	/*
1284	 * If we're doing an exclusive create, optimize away the lookup
1285	 * but don't hash the dentry.
1286	 */
1287	if (nfs_is_exclusive_create(dir, nd)) {
1288		d_instantiate(dentry, NULL);
1289		res = NULL;
1290		goto out;
1291	}
1292
1293	res = ERR_PTR(-ENOMEM);
1294	fhandle = nfs_alloc_fhandle();
1295	fattr = nfs_alloc_fattr();
1296	if (fhandle == NULL || fattr == NULL)
1297		goto out;
1298
1299	parent = dentry->d_parent;
1300	/* Protect against concurrent sillydeletes */
1301	nfs_block_sillyrename(parent);
1302	error = NFS_PROTO(dir)->lookup(NFS_SERVER(dir)->client, dir, &dentry->d_name, fhandle, fattr);
1303	if (error == -ENOENT)
1304		goto no_entry;
1305	if (error < 0) {
1306		res = ERR_PTR(error);
1307		goto out_unblock_sillyrename;
1308	}
1309	inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
1310	res = ERR_CAST(inode);
1311	if (IS_ERR(res))
1312		goto out_unblock_sillyrename;
1313
1314no_entry:
1315	res = d_materialise_unique(dentry, inode);
1316	if (res != NULL) {
1317		if (IS_ERR(res))
1318			goto out_unblock_sillyrename;
1319		dentry = res;
1320	}
1321	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1322out_unblock_sillyrename:
1323	nfs_unblock_sillyrename(parent);
1324out:
1325	nfs_free_fattr(fattr);
1326	nfs_free_fhandle(fhandle);
1327	return res;
1328}
1329
1330#ifdef CONFIG_NFS_V4
1331static int nfs_open_revalidate(struct dentry *, struct nameidata *);
1332
1333const struct dentry_operations nfs4_dentry_operations = {
1334	.d_revalidate	= nfs_open_revalidate,
1335	.d_delete	= nfs_dentry_delete,
1336	.d_iput		= nfs_dentry_iput,
1337	.d_automount	= nfs_d_automount,
1338	.d_release	= nfs_d_release,
1339};
1340
1341/*
1342 * Use intent information to determine whether we need to substitute
1343 * the NFSv4-style stateful OPEN for the LOOKUP call
1344 */
1345static int is_atomic_open(struct nameidata *nd)
1346{
1347	if (nd == NULL || nfs_lookup_check_intent(nd, LOOKUP_OPEN) == 0)
1348		return 0;
1349	/* NFS does not (yet) have a stateful open for directories */
1350	if (nd->flags & LOOKUP_DIRECTORY)
1351		return 0;
1352	/* Are we trying to write to a read only partition? */
1353	if (__mnt_is_readonly(nd->path.mnt) &&
1354	    (nd->intent.open.flags & (O_CREAT|O_TRUNC|O_ACCMODE)))
1355		return 0;
1356	return 1;
1357}
1358
1359static fmode_t flags_to_mode(int flags)
1360{
1361	fmode_t res = (__force fmode_t)flags & FMODE_EXEC;
1362	if ((flags & O_ACCMODE) != O_WRONLY)
1363		res |= FMODE_READ;
1364	if ((flags & O_ACCMODE) != O_RDONLY)
1365		res |= FMODE_WRITE;
1366	return res;
1367}
1368
1369static struct nfs_open_context *create_nfs_open_context(struct dentry *dentry, int open_flags)
1370{
1371	struct nfs_open_context *ctx;
1372	struct rpc_cred *cred;
1373	fmode_t fmode = flags_to_mode(open_flags);
1374
1375	cred = rpc_lookup_cred();
1376	if (IS_ERR(cred))
1377		return ERR_CAST(cred);
1378	ctx = alloc_nfs_open_context(dentry, cred, fmode);
1379	put_rpccred(cred);
1380	if (ctx == NULL)
1381		return ERR_PTR(-ENOMEM);
1382	return ctx;
1383}
1384
1385static int do_open(struct inode *inode, struct file *filp)
1386{
1387	nfs_fscache_set_inode_cookie(inode, filp);
1388	return 0;
1389}
1390
1391static int nfs_intent_set_file(struct nameidata *nd, struct nfs_open_context *ctx)
1392{
1393	struct file *filp;
1394	int ret = 0;
1395
1396	/* If the open_intent is for execute, we have an extra check to make */
1397	if (ctx->mode & FMODE_EXEC) {
1398		ret = nfs_may_open(ctx->dentry->d_inode,
1399				ctx->cred,
1400				nd->intent.open.flags);
1401		if (ret < 0)
1402			goto out;
1403	}
1404	filp = lookup_instantiate_filp(nd, ctx->dentry, do_open);
1405	if (IS_ERR(filp))
1406		ret = PTR_ERR(filp);
1407	else
1408		nfs_file_set_open_context(filp, ctx);
1409out:
1410	put_nfs_open_context(ctx);
1411	return ret;
1412}
1413
1414static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
1415{
1416	struct nfs_open_context *ctx;
1417	struct iattr attr;
1418	struct dentry *res = NULL;
1419	struct inode *inode;
1420	int open_flags;
1421	int err;
1422
1423	dfprintk(VFS, "NFS: atomic_lookup(%s/%ld), %s\n",
1424			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1425
1426	/* Check that we are indeed trying to open this file */
1427	if (!is_atomic_open(nd))
1428		goto no_open;
1429
1430	if (dentry->d_name.len > NFS_SERVER(dir)->namelen) {
1431		res = ERR_PTR(-ENAMETOOLONG);
1432		goto out;
1433	}
1434
1435	/* Let vfs_create() deal with O_EXCL. Instantiate, but don't hash
1436	 * the dentry. */
1437	if (nd->flags & LOOKUP_EXCL) {
1438		d_instantiate(dentry, NULL);
1439		goto out;
1440	}
1441
1442	open_flags = nd->intent.open.flags;
1443
1444	ctx = create_nfs_open_context(dentry, open_flags);
1445	res = ERR_CAST(ctx);
1446	if (IS_ERR(ctx))
1447		goto out;
1448
1449	if (nd->flags & LOOKUP_CREATE) {
1450		attr.ia_mode = nd->intent.open.create_mode;
1451		attr.ia_valid = ATTR_MODE;
1452		attr.ia_mode &= ~current_umask();
1453	} else {
1454		open_flags &= ~(O_EXCL | O_CREAT);
1455		attr.ia_valid = 0;
1456	}
1457
1458	/* Open the file on the server */
1459	nfs_block_sillyrename(dentry->d_parent);
1460	inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr);
1461	if (IS_ERR(inode)) {
1462		nfs_unblock_sillyrename(dentry->d_parent);
1463		put_nfs_open_context(ctx);
1464		switch (PTR_ERR(inode)) {
1465			/* Make a negative dentry */
1466			case -ENOENT:
1467				d_add(dentry, NULL);
1468				res = NULL;
1469				goto out;
1470			/* This turned out not to be a regular file */
1471			case -ENOTDIR:
1472				goto no_open;
1473			case -ELOOP:
1474				if (!(nd->intent.open.flags & O_NOFOLLOW))
1475					goto no_open;
1476			/* case -EISDIR: */
1477			/* case -EINVAL: */
1478			default:
1479				res = ERR_CAST(inode);
1480				goto out;
1481		}
1482	}
1483	res = d_add_unique(dentry, inode);
1484	nfs_unblock_sillyrename(dentry->d_parent);
1485	if (res != NULL) {
1486		dput(ctx->dentry);
1487		ctx->dentry = dget(res);
1488		dentry = res;
1489	}
1490	err = nfs_intent_set_file(nd, ctx);
1491	if (err < 0) {
1492		if (res != NULL)
1493			dput(res);
1494		return ERR_PTR(err);
1495	}
1496out:
1497	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1498	return res;
1499no_open:
1500	return nfs_lookup(dir, dentry, nd);
1501}
1502
1503static int nfs_open_revalidate(struct dentry *dentry, struct nameidata *nd)
1504{
1505	struct dentry *parent = NULL;
1506	struct inode *inode;
1507	struct inode *dir;
1508	struct nfs_open_context *ctx;
1509	int openflags, ret = 0;
1510
1511	if (nd->flags & LOOKUP_RCU)
1512		return -ECHILD;
1513
1514	inode = dentry->d_inode;
1515	if (!is_atomic_open(nd) || d_mountpoint(dentry))
1516		goto no_open;
1517
1518	parent = dget_parent(dentry);
1519	dir = parent->d_inode;
1520
1521	/* We can't create new files in nfs_open_revalidate(), so we
1522	 * optimize away revalidation of negative dentries.
1523	 */
1524	if (inode == NULL) {
1525		if (!nfs_neg_need_reval(dir, dentry, nd))
1526			ret = 1;
1527		goto out;
1528	}
1529
1530	/* NFS only supports OPEN on regular files */
1531	if (!S_ISREG(inode->i_mode))
1532		goto no_open_dput;
1533	openflags = nd->intent.open.flags;
1534	/* We cannot do exclusive creation on a positive dentry */
1535	if ((openflags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL))
1536		goto no_open_dput;
1537	/* We can't create new files, or truncate existing ones here */
1538	openflags &= ~(O_CREAT|O_EXCL|O_TRUNC);
1539
1540	ctx = create_nfs_open_context(dentry, openflags);
1541	ret = PTR_ERR(ctx);
1542	if (IS_ERR(ctx))
1543		goto out;
1544	/*
1545	 * Note: we're not holding inode->i_mutex and so may be racing with
1546	 * operations that change the directory. We therefore save the
1547	 * change attribute *before* we do the RPC call.
1548	 */
1549	inode = NFS_PROTO(dir)->open_context(dir, ctx, openflags, NULL);
1550	if (IS_ERR(inode)) {
1551		ret = PTR_ERR(inode);
1552		switch (ret) {
1553		case -EPERM:
1554		case -EACCES:
1555		case -EDQUOT:
1556		case -ENOSPC:
1557		case -EROFS:
1558			goto out_put_ctx;
1559		default:
1560			goto out_drop;
1561		}
1562	}
1563	iput(inode);
1564	if (inode != dentry->d_inode)
1565		goto out_drop;
1566
1567	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1568	ret = nfs_intent_set_file(nd, ctx);
1569	if (ret >= 0)
1570		ret = 1;
1571out:
1572	dput(parent);
1573	return ret;
1574out_drop:
1575	d_drop(dentry);
1576	ret = 0;
1577out_put_ctx:
1578	put_nfs_open_context(ctx);
1579	goto out;
1580
1581no_open_dput:
1582	dput(parent);
1583no_open:
1584	return nfs_lookup_revalidate(dentry, nd);
1585}
1586
1587static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode,
1588		struct nameidata *nd)
1589{
1590	struct nfs_open_context *ctx = NULL;
1591	struct iattr attr;
1592	int error;
1593	int open_flags = O_CREAT|O_EXCL;
1594
1595	dfprintk(VFS, "NFS: create(%s/%ld), %s\n",
1596			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1597
1598	attr.ia_mode = mode;
1599	attr.ia_valid = ATTR_MODE;
1600
1601	if (nd)
1602		open_flags = nd->intent.open.flags;
1603
1604	ctx = create_nfs_open_context(dentry, open_flags);
1605	error = PTR_ERR(ctx);
1606	if (IS_ERR(ctx))
1607		goto out_err_drop;
1608
1609	error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, ctx);
1610	if (error != 0)
1611		goto out_put_ctx;
1612	if (nd) {
1613		error = nfs_intent_set_file(nd, ctx);
1614		if (error < 0)
1615			goto out_err;
1616	} else {
1617		put_nfs_open_context(ctx);
1618	}
1619	return 0;
1620out_put_ctx:
1621	put_nfs_open_context(ctx);
1622out_err_drop:
1623	d_drop(dentry);
1624out_err:
1625	return error;
1626}
1627
1628#endif /* CONFIG_NFSV4 */
1629
1630/*
1631 * Code common to create, mkdir, and mknod.
1632 */
1633int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
1634				struct nfs_fattr *fattr)
1635{
1636	struct dentry *parent = dget_parent(dentry);
1637	struct inode *dir = parent->d_inode;
1638	struct inode *inode;
1639	int error = -EACCES;
1640
1641	d_drop(dentry);
1642
1643	/* We may have been initialized further down */
1644	if (dentry->d_inode)
1645		goto out;
1646	if (fhandle->size == 0) {
1647		error = NFS_PROTO(dir)->lookup(NFS_SERVER(dir)->client, dir, &dentry->d_name, fhandle, fattr);
1648		if (error)
1649			goto out_error;
1650	}
1651	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1652	if (!(fattr->valid & NFS_ATTR_FATTR)) {
1653		struct nfs_server *server = NFS_SB(dentry->d_sb);
1654		error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr);
1655		if (error < 0)
1656			goto out_error;
1657	}
1658	inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
1659	error = PTR_ERR(inode);
1660	if (IS_ERR(inode))
1661		goto out_error;
1662	d_add(dentry, inode);
1663out:
1664	dput(parent);
1665	return 0;
1666out_error:
1667	nfs_mark_for_revalidate(dir);
1668	dput(parent);
1669	return error;
1670}
1671
1672/*
1673 * Following a failed create operation, we drop the dentry rather
1674 * than retain a negative dentry. This avoids a problem in the event
1675 * that the operation succeeded on the server, but an error in the
1676 * reply path made it appear to have failed.
1677 */
1678static int nfs_create(struct inode *dir, struct dentry *dentry, int mode,
1679		struct nameidata *nd)
1680{
1681	struct iattr attr;
1682	int error;
1683	int open_flags = O_CREAT|O_EXCL;
1684
1685	dfprintk(VFS, "NFS: create(%s/%ld), %s\n",
1686			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1687
1688	attr.ia_mode = mode;
1689	attr.ia_valid = ATTR_MODE;
1690
1691	if (nd)
1692		open_flags = nd->intent.open.flags;
1693
1694	error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, NULL);
1695	if (error != 0)
1696		goto out_err;
1697	return 0;
1698out_err:
1699	d_drop(dentry);
1700	return error;
1701}
1702
1703/*
1704 * See comments for nfs_proc_create regarding failed operations.
1705 */
1706static int
1707nfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
1708{
1709	struct iattr attr;
1710	int status;
1711
1712	dfprintk(VFS, "NFS: mknod(%s/%ld), %s\n",
1713			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1714
1715	if (!new_valid_dev(rdev))
1716		return -EINVAL;
1717
1718	attr.ia_mode = mode;
1719	attr.ia_valid = ATTR_MODE;
1720
1721	status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev);
1722	if (status != 0)
1723		goto out_err;
1724	return 0;
1725out_err:
1726	d_drop(dentry);
1727	return status;
1728}
1729
1730/*
1731 * See comments for nfs_proc_create regarding failed operations.
1732 */
1733static int nfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
1734{
1735	struct iattr attr;
1736	int error;
1737
1738	dfprintk(VFS, "NFS: mkdir(%s/%ld), %s\n",
1739			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1740
1741	attr.ia_valid = ATTR_MODE;
1742	attr.ia_mode = mode | S_IFDIR;
1743
1744	error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr);
1745	if (error != 0)
1746		goto out_err;
1747	return 0;
1748out_err:
1749	d_drop(dentry);
1750	return error;
1751}
1752
1753static void nfs_dentry_handle_enoent(struct dentry *dentry)
1754{
1755	if (dentry->d_inode != NULL && !d_unhashed(dentry))
1756		d_delete(dentry);
1757}
1758
1759static int nfs_rmdir(struct inode *dir, struct dentry *dentry)
1760{
1761	int error;
1762
1763	dfprintk(VFS, "NFS: rmdir(%s/%ld), %s\n",
1764			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1765
1766	error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
1767	/* Ensure the VFS deletes this inode */
1768	if (error == 0 && dentry->d_inode != NULL)
1769		clear_nlink(dentry->d_inode);
1770	else if (error == -ENOENT)
1771		nfs_dentry_handle_enoent(dentry);
1772
1773	return error;
1774}
1775
1776/*
1777 * Remove a file after making sure there are no pending writes,
1778 * and after checking that the file has only one user. 
1779 *
1780 * We invalidate the attribute cache and free the inode prior to the operation
1781 * to avoid possible races if the server reuses the inode.
1782 */
1783static int nfs_safe_remove(struct dentry *dentry)
1784{
1785	struct inode *dir = dentry->d_parent->d_inode;
1786	struct inode *inode = dentry->d_inode;
1787	int error = -EBUSY;
1788		
1789	dfprintk(VFS, "NFS: safe_remove(%s/%s)\n",
1790		dentry->d_parent->d_name.name, dentry->d_name.name);
1791
1792	/* If the dentry was sillyrenamed, we simply call d_delete() */
1793	if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1794		error = 0;
1795		goto out;
1796	}
1797
1798	if (inode != NULL) {
1799		nfs_inode_return_delegation(inode);
1800		error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
1801		/* The VFS may want to delete this inode */
1802		if (error == 0)
1803			nfs_drop_nlink(inode);
1804		nfs_mark_for_revalidate(inode);
1805	} else
1806		error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
1807	if (error == -ENOENT)
1808		nfs_dentry_handle_enoent(dentry);
1809out:
1810	return error;
1811}
1812
1813/*  We do silly rename. In case sillyrename() returns -EBUSY, the inode
1814 *  belongs to an active ".nfs..." file and we return -EBUSY.
1815 *
1816 *  If sillyrename() returns 0, we do nothing, otherwise we unlink.
1817 */
1818static int nfs_unlink(struct inode *dir, struct dentry *dentry)
1819{
1820	int error;
1821	int need_rehash = 0;
1822
1823	dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id,
1824		dir->i_ino, dentry->d_name.name);
1825
1826	spin_lock(&dentry->d_lock);
1827	if (dentry->d_count > 1) {
1828		spin_unlock(&dentry->d_lock);
1829		/* Start asynchronous writeout of the inode */
1830		write_inode_now(dentry->d_inode, 0);
1831		error = nfs_sillyrename(dir, dentry);
1832		return error;
1833	}
1834	if (!d_unhashed(dentry)) {
1835		__d_drop(dentry);
1836		need_rehash = 1;
1837	}
1838	spin_unlock(&dentry->d_lock);
1839	error = nfs_safe_remove(dentry);
1840	if (!error || error == -ENOENT) {
1841		nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1842	} else if (need_rehash)
1843		d_rehash(dentry);
1844	return error;
1845}
1846
1847/*
1848 * To create a symbolic link, most file systems instantiate a new inode,
1849 * add a page to it containing the path, then write it out to the disk
1850 * using prepare_write/commit_write.
1851 *
1852 * Unfortunately the NFS client can't create the in-core inode first
1853 * because it needs a file handle to create an in-core inode (see
1854 * fs/nfs/inode.c:nfs_fhget).  We only have a file handle *after* the
1855 * symlink request has completed on the server.
1856 *
1857 * So instead we allocate a raw page, copy the symname into it, then do
1858 * the SYMLINK request with the page as the buffer.  If it succeeds, we
1859 * now have a new file handle and can instantiate an in-core NFS inode
1860 * and move the raw page into its mapping.
1861 */
1862static int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1863{
1864	struct pagevec lru_pvec;
1865	struct page *page;
1866	char *kaddr;
1867	struct iattr attr;
1868	unsigned int pathlen = strlen(symname);
1869	int error;
1870
1871	dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id,
1872		dir->i_ino, dentry->d_name.name, symname);
1873
1874	if (pathlen > PAGE_SIZE)
1875		return -ENAMETOOLONG;
1876
1877	attr.ia_mode = S_IFLNK | S_IRWXUGO;
1878	attr.ia_valid = ATTR_MODE;
1879
1880	page = alloc_page(GFP_HIGHUSER);
1881	if (!page)
1882		return -ENOMEM;
1883
1884	kaddr = kmap_atomic(page, KM_USER0);
1885	memcpy(kaddr, symname, pathlen);
1886	if (pathlen < PAGE_SIZE)
1887		memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen);
1888	kunmap_atomic(kaddr, KM_USER0);
1889
1890	error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr);
1891	if (error != 0) {
1892		dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s) error %d\n",
1893			dir->i_sb->s_id, dir->i_ino,
1894			dentry->d_name.name, symname, error);
1895		d_drop(dentry);
1896		__free_page(page);
1897		return error;
1898	}
1899
1900	/*
1901	 * No big deal if we can't add this page to the page cache here.
1902	 * READLINK will get the missing page from the server if needed.
1903	 */
1904	pagevec_init(&lru_pvec, 0);
1905	if (!add_to_page_cache(page, dentry->d_inode->i_mapping, 0,
1906							GFP_KERNEL)) {
1907		pagevec_add(&lru_pvec, page);
1908		pagevec_lru_add_file(&lru_pvec);
1909		SetPageUptodate(page);
1910		unlock_page(page);
1911	} else
1912		__free_page(page);
1913
1914	return 0;
1915}
1916
1917static int 
1918nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
1919{
1920	struct inode *inode = old_dentry->d_inode;
1921	int error;
1922
1923	dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n",
1924		old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
1925		dentry->d_parent->d_name.name, dentry->d_name.name);
1926
1927	nfs_inode_return_delegation(inode);
1928
1929	d_drop(dentry);
1930	error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name);
1931	if (error == 0) {
1932		ihold(inode);
1933		d_add(dentry, inode);
1934	}
1935	return error;
1936}
1937
1938/*
1939 * RENAME
1940 * FIXME: Some nfsds, like the Linux user space nfsd, may generate a
1941 * different file handle for the same inode after a rename (e.g. when
1942 * moving to a different directory). A fail-safe method to do so would
1943 * be to look up old_dir/old_name, create a link to new_dir/new_name and
1944 * rename the old file using the sillyrename stuff. This way, the original
1945 * file in old_dir will go away when the last process iput()s the inode.
1946 *
1947 * FIXED.
1948 * 
1949 * It actually works quite well. One needs to have the possibility for
1950 * at least one ".nfs..." file in each directory the file ever gets
1951 * moved or linked to which happens automagically with the new
1952 * implementation that only depends on the dcache stuff instead of
1953 * using the inode layer
1954 *
1955 * Unfortunately, things are a little more complicated than indicated
1956 * above. For a cross-directory move, we want to make sure we can get
1957 * rid of the old inode after the operation.  This means there must be
1958 * no pending writes (if it's a file), and the use count must be 1.
1959 * If these conditions are met, we can drop the dentries before doing
1960 * the rename.
1961 */
1962static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1963		      struct inode *new_dir, struct dentry *new_dentry)
1964{
1965	struct inode *old_inode = old_dentry->d_inode;
1966	struct inode *new_inode = new_dentry->d_inode;
1967	struct dentry *dentry = NULL, *rehash = NULL;
1968	int error = -EBUSY;
1969
1970	dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n",
1971		 old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
1972		 new_dentry->d_parent->d_name.name, new_dentry->d_name.name,
1973		 new_dentry->d_count);
1974
1975	/*
1976	 * For non-directories, check whether the target is busy and if so,
1977	 * make a copy of the dentry and then do a silly-rename. If the
1978	 * silly-rename succeeds, the copied dentry is hashed and becomes
1979	 * the new target.
1980	 */
1981	if (new_inode && !S_ISDIR(new_inode->i_mode)) {
1982		/*
1983		 * To prevent any new references to the target during the
1984		 * rename, we unhash the dentry in advance.
1985		 */
1986		if (!d_unhashed(new_dentry)) {
1987			d_drop(new_dentry);
1988			rehash = new_dentry;
1989		}
1990
1991		if (new_dentry->d_count > 2) {
1992			int err;
1993
1994			/* copy the target dentry's name */
1995			dentry = d_alloc(new_dentry->d_parent,
1996					 &new_dentry->d_name);
1997			if (!dentry)
1998				goto out;
1999
2000			/* silly-rename the existing target ... */
2001			err = nfs_sillyrename(new_dir, new_dentry);
2002			if (err)
2003				goto out;
2004
2005			new_dentry = dentry;
2006			rehash = NULL;
2007			new_inode = NULL;
2008		}
2009	}
2010
2011	nfs_inode_return_delegation(old_inode);
2012	if (new_inode != NULL)
2013		nfs_inode_return_delegation(new_inode);
2014
2015	error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name,
2016					   new_dir, &new_dentry->d_name);
2017	nfs_mark_for_revalidate(old_inode);
2018out:
2019	if (rehash)
2020		d_rehash(rehash);
2021	if (!error) {
2022		if (new_inode != NULL)
2023			nfs_drop_nlink(new_inode);
2024		d_move(old_dentry, new_dentry);
2025		nfs_set_verifier(new_dentry,
2026					nfs_save_change_attribute(new_dir));
2027	} else if (error == -ENOENT)
2028		nfs_dentry_handle_enoent(old_dentry);
2029
2030	/* new dentry created? */
2031	if (dentry)
2032		dput(dentry);
2033	return error;
2034}
2035
2036static DEFINE_SPINLOCK(nfs_access_lru_lock);
2037static LIST_HEAD(nfs_access_lru_list);
2038static atomic_long_t nfs_access_nr_entries;
2039
2040static void nfs_access_free_entry(struct nfs_access_entry *entry)
2041{
2042	put_rpccred(entry->cred);
2043	kfree(entry);
2044	smp_mb__before_atomic_dec();
2045	atomic_long_dec(&nfs_access_nr_entries);
2046	smp_mb__after_atomic_dec();
2047}
2048
2049static void nfs_access_free_list(struct list_head *head)
2050{
2051	struct nfs_access_entry *cache;
2052
2053	while (!list_empty(head)) {
2054		cache = list_entry(head->next, struct nfs_access_entry, lru);
2055		list_del(&cache->lru);
2056		nfs_access_free_entry(cache);
2057	}
2058}
2059
2060int nfs_access_cache_shrinker(struct shrinker *shrink,
2061			      struct shrink_control *sc)
2062{
2063	LIST_HEAD(head);
2064	struct nfs_inode *nfsi, *next;
2065	struct nfs_access_entry *cache;
2066	int nr_to_scan = sc->nr_to_scan;
2067	gfp_t gfp_mask = sc->gfp_mask;
2068
2069	if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL)
2070		return (nr_to_scan == 0) ? 0 : -1;
2071
2072	spin_lock(&nfs_access_lru_lock);
2073	list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) {
2074		struct inode *inode;
2075
2076		if (nr_to_scan-- == 0)
2077			break;
2078		inode = &nfsi->vfs_inode;
2079		spin_lock(&inode->i_lock);
2080		if (list_empty(&nfsi->access_cache_entry_lru))
2081			goto remove_lru_entry;
2082		cache = list_entry(nfsi->access_cache_entry_lru.next,
2083				struct nfs_access_entry, lru);
2084		list_move(&cache->lru, &head);
2085		rb_erase(&cache->rb_node, &nfsi->access_cache);
2086		if (!list_empty(&nfsi->access_cache_entry_lru))
2087			list_move_tail(&nfsi->access_cache_inode_lru,
2088					&nfs_access_lru_list);
2089		else {
2090remove_lru_entry:
2091			list_del_init(&nfsi->access_cache_inode_lru);
2092			smp_mb__before_clear_bit();
2093			clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags);
2094			smp_mb__after_clear_bit();
2095		}
2096		spin_unlock(&inode->i_lock);
2097	}
2098	spin_unlock(&nfs_access_lru_lock);
2099	nfs_access_free_list(&head);
2100	return (atomic_long_read(&nfs_access_nr_entries) / 100) * sysctl_vfs_cache_pressure;
2101}
2102
2103static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head)
2104{
2105	struct rb_root *root_node = &nfsi->access_cache;
2106	struct rb_node *n;
2107	struct nfs_access_entry *entry;
2108
2109	/* Unhook entries from the cache */
2110	while ((n = rb_first(root_node)) != NULL) {
2111		entry = rb_entry(n, struct nfs_access_entry, rb_node);
2112		rb_erase(n, root_node);
2113		list_move(&entry->lru, head);
2114	}
2115	nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS;
2116}
2117
2118void nfs_access_zap_cache(struct inode *inode)
2119{
2120	LIST_HEAD(head);
2121
2122	if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0)
2123		return;
2124	/* Remove from global LRU init */
2125	spin_lock(&nfs_access_lru_lock);
2126	if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
2127		list_del_init(&NFS_I(inode)->access_cache_inode_lru);
2128
2129	spin_lock(&inode->i_lock);
2130	__nfs_access_zap_cache(NFS_I(inode), &head);
2131	spin_unlock(&inode->i_lock);
2132	spin_unlock(&nfs_access_lru_lock);
2133	nfs_access_free_list(&head);
2134}
2135
2136static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, struct rpc_cred *cred)
2137{
2138	struct rb_node *n = NFS_I(inode)->access_cache.rb_node;
2139	struct nfs_access_entry *entry;
2140
2141	while (n != NULL) {
2142		entry = rb_entry(n, struct nfs_access_entry, rb_node);
2143
2144		if (cred < entry->cred)
2145			n = n->rb_left;
2146		else if (cred > entry->cred)
2147			n = n->rb_right;
2148		else
2149			return entry;
2150	}
2151	return NULL;
2152}
2153
2154static int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res)
2155{
2156	struct nfs_inode *nfsi = NFS_I(inode);
2157	struct nfs_access_entry *cache;
2158	int err = -ENOENT;
2159
2160	spin_lock(&inode->i_lock);
2161	if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)
2162		goto out_zap;
2163	cache = nfs_access_search_rbtree(inode, cred);
2164	if (cache == NULL)
2165		goto out;
2166	if (!nfs_have_delegated_attributes(inode) &&
2167	    !time_in_range_open(jiffies, cache->jiffies, cache->jiffies + nfsi->attrtimeo))
2168		goto out_stale;
2169	res->jiffies = cache->jiffies;
2170	res->cred = cache->cred;
2171	res->mask = cache->mask;
2172	list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru);
2173	err = 0;
2174out:
2175	spin_unlock(&inode->i_lock);
2176	return err;
2177out_stale:
2178	rb_erase(&cache->rb_node, &nfsi->access_cache);
2179	list_del(&cache->lru);
2180	spin_unlock(&inode->i_lock);
2181	nfs_access_free_entry(cache);
2182	return -ENOENT;
2183out_zap:
2184	spin_unlock(&inode->i_lock);
2185	nfs_access_zap_cache(inode);
2186	return -ENOENT;
2187}
2188
2189static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set)
2190{
2191	struct nfs_inode *nfsi = NFS_I(inode);
2192	struct rb_root *root_node = &nfsi->access_cache;
2193	struct rb_node **p = &root_node->rb_node;
2194	struct rb_node *parent = NULL;
2195	struct nfs_access_entry *entry;
2196
2197	spin_lock(&inode->i_lock);
2198	while (*p != NULL) {
2199		parent = *p;
2200		entry = rb_entry(parent, struct nfs_access_entry, rb_node);
2201
2202		if (set->cred < entry->cred)
2203			p = &parent->rb_left;
2204		else if (set->cred > entry->cred)
2205			p = &parent->rb_right;
2206		else
2207			goto found;
2208	}
2209	rb_link_node(&set->rb_node, parent, p);
2210	rb_insert_color(&set->rb_node, root_node);
2211	list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
2212	spin_unlock(&inode->i_lock);
2213	return;
2214found:
2215	rb_replace_node(parent, &set->rb_node, root_node);
2216	list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
2217	list_del(&entry->lru);
2218	spin_unlock(&inode->i_lock);
2219	nfs_access_free_entry(entry);
2220}
2221
2222static void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set)
2223{
2224	struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL);
2225	if (cache == NULL)
2226		return;
2227	RB_CLEAR_NODE(&cache->rb_node);
2228	cache->jiffies = set->jiffies;
2229	cache->cred = get_rpccred(set->cred);
2230	cache->mask = set->mask;
2231
2232	nfs_access_add_rbtree(inode, cache);
2233
2234	/* Update accounting */
2235	smp_mb__before_atomic_inc();
2236	atomic_long_inc(&nfs_access_nr_entries);
2237	smp_mb__after_atomic_inc();
2238
2239	/* Add inode to global LRU list */
2240	if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) {
2241		spin_lock(&nfs_access_lru_lock);
2242		if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
2243			list_add_tail(&NFS_I(inode)->access_cache_inode_lru,
2244					&nfs_access_lru_list);
2245		spin_unlock(&nfs_access_lru_lock);
2246	}
2247}
2248
2249static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask)
2250{
2251	struct nfs_access_entry cache;
2252	int status;
2253
2254	status = nfs_access_get_cached(inode, cred, &cache);
2255	if (status == 0)
2256		goto out;
2257
2258	/* Be clever: ask server to check for all possible rights */
2259	cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ;
2260	cache.cred = cred;
2261	cache.jiffies = jiffies;
2262	status = NFS_PROTO(inode)->access(inode, &cache);
2263	if (status != 0) {
2264		if (status == -ESTALE) {
2265			nfs_zap_caches(inode);
2266			if (!S_ISDIR(inode->i_mode))
2267				set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
2268		}
2269		return status;
2270	}
2271	nfs_access_add_cache(inode, &cache);
2272out:
2273	if ((mask & ~cache.mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
2274		return 0;
2275	return -EACCES;
2276}
2277
2278static int nfs_open_permission_mask(int openflags)
2279{
2280	int mask = 0;
2281
2282	if ((openflags & O_ACCMODE) != O_WRONLY)
2283		mask |= MAY_READ;
2284	if ((openflags & O_ACCMODE) != O_RDONLY)
2285		mask |= MAY_WRITE;
2286	if (openflags & __FMODE_EXEC)
2287		mask |= MAY_EXEC;
2288	return mask;
2289}
2290
2291int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags)
2292{
2293	return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags));
2294}
2295
2296int nfs_permission(struct inode *inode, int mask)
2297{
2298	struct rpc_cred *cred;
2299	int res = 0;
2300
2301	if (mask & MAY_NOT_BLOCK)
2302		return -ECHILD;
2303
2304	nfs_inc_stats(inode, NFSIOS_VFSACCESS);
2305
2306	if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
2307		goto out;
2308	/* Is this sys_access() ? */
2309	if (mask & (MAY_ACCESS | MAY_CHDIR))
2310		goto force_lookup;
2311
2312	switch (inode->i_mode & S_IFMT) {
2313		case S_IFLNK:
2314			goto out;
2315		case S_IFREG:
2316			/* NFSv4 has atomic_open... */
2317			if (nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN)
2318					&& (mask & MAY_OPEN)
2319					&& !(mask & MAY_EXEC))
2320				goto out;
2321			break;
2322		case S_IFDIR:
2323			/*
2324			 * Optimize away all write operations, since the server
2325			 * will check permissions when we perform the op.
2326			 */
2327			if ((mask & MAY_WRITE) && !(mask & MAY_READ))
2328				goto out;
2329	}
2330
2331force_lookup:
2332	if (!NFS_PROTO(inode)->access)
2333		goto out_notsup;
2334
2335	cred = rpc_lookup_cred();
2336	if (!IS_ERR(cred)) {
2337		res = nfs_do_access(inode, cred, mask);
2338		put_rpccred(cred);
2339	} else
2340		res = PTR_ERR(cred);
2341out:
2342	if (!res && (mask & MAY_EXEC) && !execute_ok(inode))
2343		res = -EACCES;
2344
2345	dfprintk(VFS, "NFS: permission(%s/%ld), mask=0x%x, res=%d\n",
2346		inode->i_sb->s_id, inode->i_ino, mask, res);
2347	return res;
2348out_notsup:
2349	res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
2350	if (res == 0)
2351		res = generic_permission(inode, mask);
2352	goto out;
2353}
2354
2355/*
2356 * Local variables:
2357 *  version-control: t
2358 *  kept-new-versions: 5
2359 * End:
2360 */