/*
   *  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>

  #include <linux/pagevec.h>

  #include <linux/namei.h>

  #include <linux/mount.h>

  #include <linux/sched.h>

  #include <linux/kmemleak.h>

  #include <linux/xattr.h>

  
  #include "delegation.h"

  #include "iostat.h"

  #include "internal.h"

  #include "fscache.h"

  /* #define NFS_DEBUG_VERBOSE 1 */
  
  static int nfs_opendir(struct inode *, struct file *);

  static int nfs_closedir(struct inode *, struct file *);

  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 *, umode_t, struct nameidata *);

  static int nfs_mkdir(struct inode *, struct dentry *, umode_t);

  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 *, umode_t, dev_t);

  static int nfs_rename(struct inode *, struct dentry *,
  		      struct inode *, struct dentry *);

  static int nfs_fsync_dir(struct file *, loff_t, loff_t, int);

  static loff_t nfs_llseek_dir(struct file *, loff_t, int);

  static void nfs_readdir_clear_array(struct page*);

  const struct file_operations nfs_dir_operations = {

  	.llseek		= nfs_llseek_dir,

  	.read		= generic_read_dir,
  	.readdir	= nfs_readdir,
  	.open		= nfs_opendir,

  	.release	= nfs_closedir,

  	.fsync		= nfs_fsync_dir,
  };

  const struct inode_operations nfs_dir_inode_operations = {

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

  const struct address_space_operations nfs_dir_aops = {
  	.freepage = nfs_readdir_clear_array,

  };

  #ifdef CONFIG_NFS_V3

  const struct inode_operations nfs3_dir_inode_operations = {

  	.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 */

  #ifdef CONFIG_NFS_V4
  
  static struct dentry *nfs_atomic_lookup(struct inode *, struct dentry *, struct nameidata *);

  static int nfs_open_create(struct inode *dir, struct dentry *dentry, umode_t mode, struct nameidata *nd);

  const struct inode_operations nfs4_dir_inode_operations = {

  	.create		= nfs_open_create,

  	.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,

  	.getxattr	= generic_getxattr,
  	.setxattr	= generic_setxattr,
  	.listxattr	= generic_listxattr,
  	.removexattr	= generic_removexattr,

  };
  
  #endif /* CONFIG_NFS_V4 */

  static struct nfs_open_dir_context *alloc_nfs_open_dir_context(struct inode *dir, struct rpc_cred *cred)

  {
  	struct nfs_open_dir_context *ctx;
  	ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
  	if (ctx != NULL) {

  		ctx->duped = 0;

  		ctx->attr_gencount = NFS_I(dir)->attr_gencount;

  		ctx->dir_cookie = 0;

  		ctx->dup_cookie = 0;

  		ctx->cred = get_rpccred(cred);

  		return ctx;
  	}
  	return  ERR_PTR(-ENOMEM);

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

  /*
   * Open file
   */
  static int
  nfs_opendir(struct inode *inode, struct file *filp)
  {

  	int res = 0;
  	struct nfs_open_dir_context *ctx;
  	struct rpc_cred *cred;

  	dfprintk(FILE, "NFS: open dir(%s/%s)
  ",

  			filp->f_path.dentry->d_parent->d_name.name,
  			filp->f_path.dentry->d_name.name);
  
  	nfs_inc_stats(inode, NFSIOS_VFSOPEN);

  	cred = rpc_lookup_cred();
  	if (IS_ERR(cred))
  		return PTR_ERR(cred);

  	ctx = alloc_nfs_open_dir_context(inode, cred);

  	if (IS_ERR(ctx)) {
  		res = PTR_ERR(ctx);
  		goto out;
  	}
  	filp->private_data = ctx;

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

  out:
  	put_rpccred(cred);

  	return res;
  }

  static int
  nfs_closedir(struct inode *inode, struct file *filp)
  {
  	put_nfs_open_dir_context(filp->private_data);
  	return 0;
  }

  struct nfs_cache_array_entry {
  	u64 cookie;
  	u64 ino;
  	struct qstr string;

  	unsigned char d_type;

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

  typedef int (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, int);

  typedef struct {
  	struct file	*file;
  	struct page	*page;
  	unsigned long	page_index;

  	u64		*dir_cookie;

  	u64		last_cookie;

  	loff_t		current_index;

  	decode_dirent_t	decode;

  	unsigned long	timestamp;

  	unsigned long	gencount;

  	unsigned int	cache_entry_index;
  	unsigned int	plus:1;
  	unsigned int	eof:1;

  } nfs_readdir_descriptor_t;

  /*
   * The caller is responsible for calling nfs_readdir_release_array(page)

   */
  static

  struct nfs_cache_array *nfs_readdir_get_array(struct page *page)
  {

  	void *ptr;

  	if (page == NULL)
  		return ERR_PTR(-EIO);

  	ptr = kmap(page);
  	if (ptr == NULL)
  		return ERR_PTR(-ENOMEM);
  	return ptr;

  }
  
  static
  void nfs_readdir_release_array(struct page *page)
  {
  	kunmap(page);
  }
  
  /*
   * we are freeing strings created by nfs_add_to_readdir_array()
   */
  static

  void nfs_readdir_clear_array(struct page *page)

  {

  	struct nfs_cache_array *array;

  	int i;

  	array = kmap_atomic(page, KM_USER0);

  	for (i = 0; i < array->size; i++)
  		kfree(array->array[i].string.name);

  	kunmap_atomic(array, KM_USER0);

  }
  
  /*
   * 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

  int nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int len)

  {
  	string->len = len;
  	string->name = kmemdup(name, len, GFP_KERNEL);

  	if (string->name == NULL)
  		return -ENOMEM;

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

  	string->hash = full_name_hash(name, len);
  	return 0;

  }
  
  static
  int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page)
  {
  	struct nfs_cache_array *array = nfs_readdir_get_array(page);

  	struct nfs_cache_array_entry *cache_entry;
  	int ret;

  	if (IS_ERR(array))
  		return PTR_ERR(array);

  
  	cache_entry = &array->array[array->size];
  
  	/* Check that this entry lies within the page bounds */

  	ret = -ENOSPC;

  	if ((char *)&cache_entry[1] - (char *)page_address(page) > PAGE_SIZE)

  		goto out;

  	cache_entry->cookie = entry->prev_cookie;
  	cache_entry->ino = entry->ino;

  	cache_entry->d_type = entry->d_type;

  	ret = nfs_readdir_make_qstr(&cache_entry->string, entry->name, entry->len);
  	if (ret)
  		goto out;

  	array->last_cookie = entry->cookie;

  	array->size++;

  	if (entry->eof != 0)

  		array->eof_index = array->size;

  out:

  	nfs_readdir_release_array(page);

  	return ret;

  }
  
  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;
  
  	if (diff < 0)
  		goto out_eof;
  	if (diff >= array->size) {

  		if (array->eof_index >= 0)

  			goto out_eof;

  		return -EAGAIN;
  	}
  
  	index = (unsigned int)diff;
  	*desc->dir_cookie = array->array[index].cookie;
  	desc->cache_entry_index = index;

  	return 0;
  out_eof:
  	desc->eof = 1;
  	return -EBADCOOKIE;
  }
  
  static
  int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
  {
  	int i;

  	loff_t new_pos;

  	int status = -EAGAIN;
  
  	for (i = 0; i < array->size; i++) {

  		if (array->array[i].cookie == *desc->dir_cookie) {

  			struct nfs_inode *nfsi = NFS_I(desc->file->f_path.dentry->d_inode);
  			struct nfs_open_dir_context *ctx = desc->file->private_data;

  			new_pos = desc->current_index + i;

  			if (ctx->attr_gencount != nfsi->attr_gencount
  			    || (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA))) {
  				ctx->duped = 0;
  				ctx->attr_gencount = nfsi->attr_gencount;
  			} else if (new_pos < desc->file->f_pos) {
  				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.  "

  								"The file: %s has duplicate cookie %llu
  ",

  								desc->file->f_dentry->d_parent->d_name.name,
  								desc->file->f_dentry->d_name.name,

  								array->array[i].string.name,

  								*desc->dir_cookie);
  					}
  					status = -ELOOP;
  					goto out;
  				}

  				ctx->dup_cookie = *desc->dir_cookie;

  				ctx->duped = -1;

  			}
  			desc->file->f_pos = new_pos;

  			desc->cache_entry_index = i;

  			return 0;

  		}
  	}

  	if (array->eof_index >= 0) {

  		status = -EBADCOOKIE;

  		if (*desc->dir_cookie == array->last_cookie)
  			desc->eof = 1;

  	}

  out:

  	return status;
  }
  
  static
  int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc)
  {
  	struct nfs_cache_array *array;

  	int status;

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

  	if (status == -EAGAIN) {

  		desc->last_cookie = array->last_cookie;

  		desc->current_index += array->size;

  		desc->page_index++;
  	}

  	nfs_readdir_release_array(desc->page);
  out:
  	return status;
  }
  
  /* Fill a page with xdr information before transferring to the cache page */
  static

  int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc,

  			struct nfs_entry *entry, struct file *file, struct inode *inode)

  {

  	struct nfs_open_dir_context *ctx = file->private_data;
  	struct rpc_cred	*cred = ctx->cred;

  	unsigned long	timestamp, gencount;

  	int		error;

   again:
  	timestamp = jiffies;

  	gencount = nfs_inc_attr_generation_counter();

  	error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, entry->cookie, pages,

  					  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;

  			clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);

  			desc->plus = 0;
  			goto again;
  		}
  		goto error;
  	}

  	desc->timestamp = timestamp;

  	desc->gencount = gencount;

  error:
  	return error;

  }

  static int xdr_decode(nfs_readdir_descriptor_t *desc,
  		      struct nfs_entry *entry, struct xdr_stream *xdr)

  {

  	int error;

  	error = desc->decode(xdr, entry, desc->plus);
  	if (error)
  		return error;

  	entry->fattr->time_start = desc->timestamp;
  	entry->fattr->gencount = desc->gencount;
  	return 0;

  }

  static
  int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry)
  {

  	if (dentry->d_inode == NULL)
  		goto different;

  	if (nfs_compare_fh(entry->fh, NFS_FH(dentry->d_inode)) != 0)

  		goto different;
  	return 1;
  different:
  	return 0;
  }
  
  static
  void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
  {

  	struct qstr filename = {
  		.len = entry->len,
  		.name = entry->name,
  	};
  	struct dentry *dentry;
  	struct dentry *alias;

  	struct inode *dir = parent->d_inode;
  	struct inode *inode;

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

  	dentry = d_lookup(parent, &filename);

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

  	if (dentry == NULL)
  		return;

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

  }

  /* Perform conversion from xdr to cache array */
  static

  int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry,

  				struct page **xdr_pages, struct page *page, unsigned int buflen)

  {

  	struct xdr_stream stream;

  	struct xdr_buf buf;

  	struct page *scratch;

  	struct nfs_cache_array *array;

  	unsigned int count = 0;
  	int status;

  	scratch = alloc_page(GFP_KERNEL);
  	if (scratch == NULL)
  		return -ENOMEM;

  	xdr_init_decode_pages(&stream, &buf, xdr_pages, buflen);

  	xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);

  
  	do {
  		status = xdr_decode(desc, entry, &stream);

  		if (status != 0) {
  			if (status == -EAGAIN)
  				status = 0;

  			break;

  		}

  		count++;

  		if (desc->plus != 0)

  			nfs_prime_dcache(desc->file->f_path.dentry, entry);

  
  		status = nfs_readdir_add_to_array(entry, page);
  		if (status != 0)
  			break;

  	} while (!entry->eof);

  	if (count == 0 || (status == -EBADCOOKIE && entry->eof != 0)) {

  		array = nfs_readdir_get_array(page);

  		if (!IS_ERR(array)) {
  			array->eof_index = array->size;
  			status = 0;
  			nfs_readdir_release_array(page);

  		} else
  			status = PTR_ERR(array);

  	}

  
  	put_page(scratch);

  	return status;

  }
  
  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

  int nfs_readdir_large_page(struct page **pages, unsigned int npages)

  {

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

  	return 0;

  out_freepages:
  	nfs_readdir_free_pagearray(pages, i);

  	return -ENOMEM;

  }

  static
  int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode)

  {

  	struct page *pages[NFS_MAX_READDIR_PAGES];
  	void *pages_ptr = NULL;

  	struct nfs_entry entry;
  	struct file	*file = desc->file;
  	struct nfs_cache_array *array;

  	int status = -ENOMEM;

  	unsigned int array_size = ARRAY_SIZE(pages);

  
  	entry.prev_cookie = 0;

  	entry.cookie = desc->last_cookie;

  	entry.eof = 0;
  	entry.fh = nfs_alloc_fhandle();
  	entry.fattr = nfs_alloc_fattr();

  	entry.server = NFS_SERVER(inode);

  	if (entry.fh == NULL || entry.fattr == NULL)
  		goto out;

  	array = nfs_readdir_get_array(page);

  	if (IS_ERR(array)) {
  		status = PTR_ERR(array);
  		goto out;
  	}

  	memset(array, 0, sizeof(struct nfs_cache_array));
  	array->eof_index = -1;

  	status = nfs_readdir_large_page(pages, array_size);
  	if (status < 0)

  		goto out_release_array;
  	do {

  		unsigned int pglen;

  		status = nfs_readdir_xdr_filler(pages, desc, &entry, file, inode);

  		if (status < 0)

  			break;

  		pglen = status;

  		status = nfs_readdir_page_filler(desc, &entry, pages, page, pglen);

  		if (status < 0) {
  			if (status == -ENOSPC)
  				status = 0;
  			break;
  		}
  	} while (array->eof_index < 0);

  	nfs_readdir_free_large_page(pages_ptr, pages, array_size);

  out_release_array:
  	nfs_readdir_release_array(page);
  out:
  	nfs_free_fattr(entry.fattr);
  	nfs_free_fhandle(entry.fh);

  	return status;
  }
  
  /*

   * 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

   */

  static
  int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page* page)

  {

  	struct inode	*inode = desc->file->f_path.dentry->d_inode;

  	int ret;

  	ret = nfs_readdir_xdr_to_array(desc, page, inode);
  	if (ret < 0)

  		goto error;
  	SetPageUptodate(page);

  	if (invalidate_inode_pages2_range(inode->i_mapping, page->index + 1, -1) < 0) {
  		/* Should never happen */
  		nfs_zap_mapping(inode, inode->i_mapping);

  	}

  	unlock_page(page);
  	return 0;
   error:
  	unlock_page(page);

  	return ret;

  }

  static
  void cache_page_release(nfs_readdir_descriptor_t *desc)
  {

  	if (!desc->page->mapping)
  		nfs_readdir_clear_array(desc->page);

  	page_cache_release(desc->page);
  	desc->page = NULL;
  }
  
  static
  struct page *get_cache_page(nfs_readdir_descriptor_t *desc)
  {

  	return read_cache_page(desc->file->f_path.dentry->d_inode->i_mapping,

  			desc->page_index, (filler_t *)nfs_readdir_filler, desc);

  }
  
  /*

   * Returns 0 if desc->dir_cookie was found on page desc->page_index

   */

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

  	if (res != 0)
  		cache_page_release(desc);

  	return res;
  }
  
  /* Search for desc->dir_cookie from the beginning of the page cache */

  static inline
  int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)
  {

  	int res;

  	if (desc->page_index == 0) {

  		desc->current_index = 0;

  		desc->last_cookie = 0;
  	}

  	do {

  		res = find_cache_page(desc);

  	} while (res == -EAGAIN);

  	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;

  	int i = 0;
  	int res = 0;
  	struct nfs_cache_array *array = NULL;

  	struct nfs_open_dir_context *ctx = file->private_data;

  	array = nfs_readdir_get_array(desc->page);

  	if (IS_ERR(array)) {
  		res = PTR_ERR(array);
  		goto out;
  	}

  
  	for (i = desc->cache_entry_index; i < array->size; i++) {

  		struct nfs_cache_array_entry *ent;

  		ent = &array->array[i];
  		if (filldir(dirent, ent->string.name, ent->string.len,

  		    file->f_pos, nfs_compat_user_ino64(ent->ino),
  		    ent->d_type) < 0) {

  			desc->eof = 1;

  			break;

  		}

  		file->f_pos++;

  		if (i < (array->size-1))
  			*desc->dir_cookie = array->array[i+1].cookie;
  		else
  			*desc->dir_cookie = array->last_cookie;

  		if (ctx->duped != 0)
  			ctx->duped = 1;

  	}

  	if (array->eof_index >= 0)

  		desc->eof = 1;

  
  	nfs_readdir_release_array(desc->page);

  out:

  	cache_page_release(desc);

  	dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d
  ",
  			(unsigned long long)*desc->dir_cookie, res);

  	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;

  	struct inode *inode = desc->file->f_path.dentry->d_inode;

  	struct nfs_open_dir_context *ctx = desc->file->private_data;

  	dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu
  ",
  			(unsigned long long)*desc->dir_cookie);

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

  	desc->page_index = 0;

  	desc->last_cookie = *desc->dir_cookie;

  	desc->page = page;

  	ctx->duped = 0;

  	status = nfs_readdir_xdr_to_array(desc, page, inode);
  	if (status < 0)

  		goto out_release;
  
  	status = nfs_do_filldir(desc, dirent, filldir);

   out:

  	dfprintk(DIRCACHE, "NFS: %s: returns %d
  ",

  			__func__, status);

  	return status;
   out_release:

  	cache_page_release(desc);

  	goto out;
  }

  /* The file offset position represents the dirent entry number.  A
     last cookie cache takes care of the common case of reading the
     whole directory.

   */
  static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
  {

  	struct dentry	*dentry = filp->f_path.dentry;

  	struct inode	*inode = dentry->d_inode;
  	nfs_readdir_descriptor_t my_desc,
  			*desc = &my_desc;

  	struct nfs_open_dir_context *dir_ctx = filp->private_data;

  	int res;

  	dfprintk(FILE, "NFS: readdir(%s/%s) starting at cookie %llu
  ",

  			dentry->d_parent->d_name.name, dentry->d_name.name,
  			(long long)filp->f_pos);

  	nfs_inc_stats(inode, NFSIOS_VFSGETDENTS);

  	/*

  	 * filp->f_pos points to the dirent entry number.

  	 * *desc->dir_cookie has the cookie for the next entry. We have

  	 * to either find the entry with the appropriate number or
  	 * revalidate the cookie.

  	 */
  	memset(desc, 0, sizeof(*desc));
  
  	desc->file = filp;

  	desc->dir_cookie = &dir_ctx->dir_cookie;

  	desc->decode = NFS_PROTO(inode)->decode_dirent;
  	desc->plus = NFS_USE_READDIRPLUS(inode);

  	nfs_block_sillyrename(dentry);

  	res = nfs_revalidate_mapping(inode, filp->f_mapping);

  	if (res < 0)
  		goto out;

  	do {

  		res = readdir_search_pagecache(desc);

  		if (res == -EBADCOOKIE) {

  			res = 0;

  			/* This means either end of directory */

  			if (*desc->dir_cookie && desc->eof == 0) {

  				/* Or that the server has 'lost' a cookie */
  				res = uncached_readdir(desc, dirent, filldir);

  				if (res == 0)

  					continue;
  			}

  			break;
  		}
  		if (res == -ETOOSMALL && desc->plus) {

  			clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);

  			nfs_zap_caches(inode);

  			desc->page_index = 0;

  			desc->plus = 0;

  			desc->eof = 0;

  			continue;
  		}
  		if (res < 0)
  			break;
  
  		res = nfs_do_filldir(desc, dirent, filldir);

  		if (res < 0)

  			break;

  	} while (!desc->eof);

  out:

  	nfs_unblock_sillyrename(dentry);

  	if (res > 0)
  		res = 0;

  	dfprintk(FILE, "NFS: readdir(%s/%s) returns %d
  ",

  			dentry->d_parent->d_name.name, dentry->d_name.name,
  			res);
  	return res;

  }

  static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)

  {

  	struct dentry *dentry = filp->f_path.dentry;
  	struct inode *inode = dentry->d_inode;

  	struct nfs_open_dir_context *dir_ctx = filp->private_data;

  	dfprintk(FILE, "NFS: llseek dir(%s/%s, %lld, %d)
  ",

  			dentry->d_parent->d_name.name,
  			dentry->d_name.name,
  			offset, origin);
  
  	mutex_lock(&inode->i_mutex);

  	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;

  		dir_ctx->dir_cookie = 0;

  		dir_ctx->duped = 0;

  	}
  out:

  	mutex_unlock(&inode->i_mutex);

  	return offset;
  }

  /*
   * All directory operations under NFS are synchronous, so fsync()
   * is a dummy operation.
   */

  static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end,
  			 int datasync)

  {

  	struct dentry *dentry = filp->f_path.dentry;

  	struct inode *inode = dentry->d_inode;

  	dfprintk(FILE, "NFS: fsync dir(%s/%s) datasync %d
  ",

  			dentry->d_parent->d_name.name, dentry->d_name.name,
  			datasync);

  	mutex_lock(&inode->i_mutex);

  	nfs_inc_stats(dentry->d_inode, NFSIOS_VFSFSYNC);

  	mutex_unlock(&inode->i_mutex);

  	return 0;
  }

  /**
   * 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)
  {

  	NFS_I(dir)->cache_change_attribute++;

  }

  /*
   * 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.
   */

  static int nfs_check_verifier(struct inode *dir, struct dentry *dentry)

  {
  	if (IS_ROOT(dentry))
  		return 1;

  	if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
  		return 0;

  	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;

  }

  /*

   * Return the intent data that applies to this particular path component
   *
   * Note that the current set of intents only apply to the very last

   * component of the path and none of them is set before that last
   * component.

   */

  static inline unsigned int nfs_lookup_check_intent(struct nameidata *nd,
  						unsigned int mask)

  {

  	return nd->flags & mask;
  }
  
  /*

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

  	return nd && nfs_lookup_check_intent(nd, LOOKUP_EXCL);

  }
  
  /*

   * 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.
   *
   */

  static inline
  int nfs_lookup_verify_inode(struct inode *inode, struct nameidata *nd)
  {
  	struct nfs_server *server = NFS_SERVER(inode);

  	if (IS_AUTOMOUNT(inode))

  		return 0;

  	if (nd != NULL) {

  		/* VFS wants an on-the-wire revalidation */

  		if (nd->flags & LOOKUP_REVAL)

  			goto out_force;
  		/* This is an open(2) */

  		if (nfs_lookup_check_intent(nd, LOOKUP_OPEN) != 0 &&

  				!(server->flags & NFS_MOUNT_NOCTO) &&
  				(S_ISREG(inode->i_mode) ||
  				 S_ISDIR(inode->i_mode)))

  			goto out_force;

  		return 0;

  	}
  	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 */

  	if (nd != NULL && nfs_lookup_check_intent(nd, LOOKUP_CREATE) != 0)

  		return 0;

  	if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG)
  		return 1;

  	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.
   */

  static int nfs_lookup_revalidate(struct dentry *dentry, struct nameidata *nd)

  {
  	struct inode *dir;
  	struct inode *inode;
  	struct dentry *parent;

  	struct nfs_fh *fhandle = NULL;
  	struct nfs_fattr *fattr = NULL;

  	int error;

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

  	parent = dget_parent(dentry);

  	dir = parent->d_inode;

  	nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE);

  	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)) {

  		dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode
  ",

  				__func__, dentry->d_parent->d_name.name,

  				dentry->d_name.name);

  		goto out_bad;
  	}

  	if (nfs_have_delegation(inode, FMODE_READ))
  		goto out_set_verifier;

  	/* Force a full look up iff the parent directory has changed */

  	if (!nfs_is_exclusive_create(dir, nd) && nfs_check_verifier(dir, dentry)) {

  		if (nfs_lookup_verify_inode(inode, nd))
  			goto out_zap_parent;
  		goto out_valid;
  	}
  
  	if (NFS_STALE(inode))
  		goto out_bad;

  	error = -ENOMEM;
  	fhandle = nfs_alloc_fhandle();
  	fattr = nfs_alloc_fattr();
  	if (fhandle == NULL || fattr == NULL)
  		goto out_error;

  	error = NFS_PROTO(dir)->lookup(NFS_SERVER(dir)->client, dir, &dentry->d_name, fhandle, fattr);

  	if (error)
  		goto out_bad;

  	if (nfs_compare_fh(NFS_FH(inode), fhandle))

  		goto out_bad;

  	if ((error = nfs_refresh_inode(inode, fattr)) != 0)

  		goto out_bad;

  	nfs_free_fattr(fattr);
  	nfs_free_fhandle(fhandle);

  out_set_verifier:

  	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));

   out_valid:

  	dput(parent);

  	dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is valid
  ",

  			__func__, dentry->d_parent->d_name.name,

  			dentry->d_name.name);

  	return 1;
  out_zap_parent:
  	nfs_zap_caches(dir);
   out_bad:

  	nfs_mark_for_revalidate(dir);

  	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;

  		if (dentry->d_flags & DCACHE_DISCONNECTED)
  			goto out_valid;

  		shrink_dcache_parent(dentry);
  	}
  	d_drop(dentry);

  	nfs_free_fattr(fattr);
  	nfs_free_fhandle(fhandle);

  	dput(parent);

  	dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid
  ",

  			__func__, dentry->d_parent->d_name.name,

  			dentry->d_name.name);

  	return 0;

  out_error:
  	nfs_free_fattr(fattr);
  	nfs_free_fhandle(fhandle);
  	dput(parent);
  	dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) lookup returned error %d
  ",
  			__func__, dentry->d_parent->d_name.name,
  			dentry->d_name.name, error);
  	return error;

  }
  
  /*
   * This is called from dput() when d_count is going to 0.
   */

  static int nfs_dentry_delete(const struct dentry *dentry)

  {
  	dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)
  ",
  		dentry->d_parent->d_name.name, dentry->d_name.name,
  		dentry->d_flags);

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

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

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

  /*
   * 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)
  {

  	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;

  	if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {

  		drop_nlink(inode);

  		nfs_complete_unlink(dentry, inode);

  	}

  	iput(inode);
  }

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

  const struct dentry_operations nfs_dentry_operations = {

  	.d_revalidate	= nfs_lookup_revalidate,
  	.d_delete	= nfs_dentry_delete,
  	.d_iput		= nfs_dentry_iput,

  	.d_automount	= nfs_d_automount,

  	.d_release	= nfs_d_release,

  };

  static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
  {
  	struct dentry *res;

  	struct dentry *parent;

  	struct inode *inode = NULL;

  	struct nfs_fh *fhandle = NULL;
  	struct nfs_fattr *fattr = NULL;

  	int error;

  
  	dfprintk(VFS, "NFS: lookup(%s/%s)
  ",
  		dentry->d_parent->d_name.name, dentry->d_name.name);

  	nfs_inc_stats(dir, NFSIOS_VFSLOOKUP);

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

  	/*
  	 * 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;

  		goto out;

  	}

  	res = ERR_PTR(-ENOMEM);
  	fhandle = nfs_alloc_fhandle();
  	fattr = nfs_alloc_fattr();
  	if (fhandle == NULL || fattr == NULL)
  		goto out;

  	parent = dentry->d_parent;
  	/* Protect against concurrent sillydeletes */
  	nfs_block_sillyrename(parent);

  	error = NFS_PROTO(dir)->lookup(NFS_SERVER(dir)->client, dir, &dentry->d_name, fhandle, fattr);

  	if (error == -ENOENT)
  		goto no_entry;
  	if (error < 0) {
  		res = ERR_PTR(error);

  		goto out_unblock_sillyrename;

  	}

  	inode = nfs_fhget(dentry->d_sb, fhandle, fattr);

  	res = ERR_CAST(inode);

  	if (IS_ERR(res))

  		goto out_unblock_sillyrename;

  no_entry:

  	res = d_materialise_unique(dentry, inode);

  	if (res != NULL) {
  		if (IS_ERR(res))

  			goto out_unblock_sillyrename;

  		dentry = res;

  	}

  	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));

  out_unblock_sillyrename:
  	nfs_unblock_sillyrename(parent);

  out:

  	nfs_free_fattr(fattr);
  	nfs_free_fhandle(fhandle);

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

  const struct dentry_operations nfs4_dentry_operations = {

  	.d_revalidate	= nfs_open_revalidate,
  	.d_delete	= nfs_dentry_delete,
  	.d_iput		= nfs_dentry_iput,

  	.d_automount	= nfs_d_automount,

  	.d_release	= nfs_d_release,

  };

  /*
   * Use intent information to determine whether we need to substitute
   * the NFSv4-style stateful OPEN for the LOOKUP call
   */

  static int is_atomic_open(struct nameidata *nd)

  {

  	if (nd == NULL || nfs_lookup_check_intent(nd, LOOKUP_OPEN) == 0)

  		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? */

  	if (__mnt_is_readonly(nd->path.mnt) &&

  	    (nd->intent.open.flags & (O_CREAT|O_TRUNC|O_ACCMODE)))

  		return 0;
  	return 1;
  }

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

  static struct nfs_open_context *create_nfs_open_context(struct dentry *dentry, int open_flags)

  {

  	return alloc_nfs_open_context(dentry, flags_to_mode(open_flags));

  }
  
  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) {

  		ret = nfs_may_open(ctx->dentry->d_inode,

  				ctx->cred,
  				nd->intent.open.flags);
  		if (ret < 0)
  			goto out;
  	}

  	filp = lookup_instantiate_filp(nd, ctx->dentry, do_open);

  	if (IS_ERR(filp))
  		ret = PTR_ERR(filp);
  	else
  		nfs_file_set_open_context(filp, ctx);
  out:
  	put_nfs_open_context(ctx);
  	return ret;
  }

  static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
  {

  	struct nfs_open_context *ctx;
  	struct iattr attr;

  	struct dentry *res = NULL;

  	struct inode *inode;

  	int open_flags;

  	int err;

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

  	/* Check that we are indeed trying to open this file */

  	if (!is_atomic_open(nd))

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

  	/* Let vfs_create() deal with O_EXCL. Instantiate, but don't hash
  	 * the dentry. */

  	if (nd->flags & LOOKUP_EXCL) {

  		d_instantiate(dentry, NULL);

  		goto out;
  	}

  	open_flags = nd->intent.open.flags;
  
  	ctx = create_nfs_open_context(dentry, open_flags);

  	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;

  		attr.ia_mode &= ~current_umask();

  	} else {

  		open_flags &= ~(O_EXCL | O_CREAT);

  		attr.ia_valid = 0;

  	}

  	/* Open the file on the server */

  	nfs_block_sillyrename(dentry->d_parent);

  	inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr);

  	if (IS_ERR(inode)) {
  		nfs_unblock_sillyrename(dentry->d_parent);

  		put_nfs_open_context(ctx);

  		switch (PTR_ERR(inode)) {

  			/* Make a negative dentry */
  			case -ENOENT:

  				d_add(dentry, NULL);

  				res = NULL;
  				goto out;

  			/* This turned out not to be a regular file */

  			case -EISDIR:

  			case -ENOTDIR:
  				goto no_open;

  			case -ELOOP:
  				if (!(nd->intent.open.flags & O_NOFOLLOW))
  					goto no_open;

  			/* case -EINVAL: */
  			default:

  				res = ERR_CAST(inode);

  				goto out;
  		}

  	}

  	res = d_add_unique(dentry, inode);

  	nfs_unblock_sillyrename(dentry->d_parent);

  	if (res != NULL) {

  		dput(ctx->dentry);
  		ctx->dentry = dget(res);

  		dentry = res;

  	}

  	err = nfs_intent_set_file(nd, ctx);
  	if (err < 0) {
  		if (res != NULL)
  			dput(res);
  		return ERR_PTR(err);
  	}

  out:

  	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));

  	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;

  	struct inode *inode;

  	struct inode *dir;

  	struct nfs_open_context *ctx;

  	int openflags, ret = 0;

  	if (nd->flags & LOOKUP_RCU)
  		return -ECHILD;
  
  	inode = dentry->d_inode;

  	if (!is_atomic_open(nd) || d_mountpoint(dentry))

  		goto no_open;

  	parent = dget_parent(dentry);
  	dir = parent->d_inode;

  	/* We can't create new files in nfs_open_revalidate(), so we
  	 * optimize away revalidation of negative dentries.
  	 */

  	if (inode == NULL) {
  		if (!nfs_neg_need_reval(dir, dentry, nd))
  			ret = 1;

  		goto out;

  	}

  	/* NFS only supports OPEN on regular files */
  	if (!S_ISREG(inode->i_mode))

  		goto no_open_dput;

  	openflags = nd->intent.open.flags;
  	/* We cannot do exclusive creation on a positive dentry */
  	if ((openflags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL))

  		goto no_open_dput;

  	/* We can't create new files, or truncate existing ones here */

  	openflags &= ~(O_CREAT|O_EXCL|O_TRUNC);

  	ctx = create_nfs_open_context(dentry, openflags);

  	ret = PTR_ERR(ctx);
  	if (IS_ERR(ctx))
  		goto out;

  	/*

  	 * Note: we're not holding inode->i_mutex and so may be racing with

  	 * operations that change the directory. We therefore save the
  	 * change attribute *before* we do the RPC call.
  	 */

  	inode = NFS_PROTO(dir)->open_context(dir, ctx, openflags, NULL);

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

  	if (inode != dentry->d_inode)

  		goto out_drop;

  
  	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
  	ret = nfs_intent_set_file(nd, ctx);
  	if (ret >= 0)
  		ret = 1;

  out:
  	dput(parent);

  	return ret;

  out_drop:
  	d_drop(dentry);
  	ret = 0;
  out_put_ctx:
  	put_nfs_open_context(ctx);
  	goto out;

  no_open_dput:

  	dput(parent);

  no_open:

  	return nfs_lookup_revalidate(dentry, nd);
  }

  static int nfs_open_create(struct inode *dir, struct dentry *dentry,
  		umode_t mode, struct nameidata *nd)

  {
  	struct nfs_open_context *ctx = NULL;
  	struct iattr attr;
  	int error;

  	int open_flags = O_CREAT|O_EXCL;

  
  	dfprintk(VFS, "NFS: create(%s/%ld), %s
  ",
  			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
  
  	attr.ia_mode = mode;
  	attr.ia_valid = ATTR_MODE;