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

  #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/swap.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"

  #include "nfstrace.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 *, struct dir_context *);

  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,

  	.iterate_shared	= nfs_readdir,

  	.open		= nfs_opendir,

  	.release	= nfs_closedir,

  	.fsync		= nfs_fsync_dir,
  };

  const struct address_space_operations nfs_dir_aops = {
  	.freepage = nfs_readdir_clear_array,

  };

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

  {

  	struct nfs_inode *nfsi = NFS_I(dir);

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

  		ctx->duped = 0;

  		ctx->attr_gencount = nfsi->attr_gencount;

  		ctx->dir_cookie = 0;

  		ctx->dup_cookie = 0;

  		ctx->cred = get_rpccred(cred);

  		spin_lock(&dir->i_lock);
  		list_add(&ctx->list, &nfsi->open_files);
  		spin_unlock(&dir->i_lock);

  		return ctx;
  	}
  	return  ERR_PTR(-ENOMEM);

  }

  static void put_nfs_open_dir_context(struct inode *dir, struct nfs_open_dir_context *ctx)

  {

  	spin_lock(&dir->i_lock);
  	list_del(&ctx->list);
  	spin_unlock(&dir->i_lock);

  	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(%pD2)
  ", filp);

  
  	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(file_inode(filp), 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 {

  	atomic_t refcount;

  	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;

  	struct dir_context *ctx;

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

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

  	kunmap_atomic(array);

  }

  static bool grab_page(struct page *page)
  {
  	struct nfs_cache_array *array = kmap_atomic(page);
  	bool res = atomic_inc_not_zero(&array->refcount);
  	kunmap_atomic(array);
  	return res;
  }

  /*
   * 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(NULL, 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->ctx->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 bool
  nfs_readdir_inode_mapping_valid(struct nfs_inode *nfsi)
  {
  	if (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA))
  		return false;
  	smp_rmb();
  	return !test_bit(NFS_INO_INVALIDATING, &nfsi->flags);
  }

  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(file_inode(desc->file));

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

  			new_pos = desc->current_index + i;

  			if (ctx->attr_gencount != nfsi->attr_gencount ||
  			    !nfs_readdir_inode_mapping_valid(nfsi)) {

  				ctx->duped = 0;
  				ctx->attr_gencount = nfsi->attr_gencount;

  			} else if (new_pos < desc->ctx->pos) {

  				if (ctx->duped > 0
  				    && ctx->dup_cookie == *desc->dir_cookie) {
  					if (printk_ratelimit()) {

  						pr_notice("NFS: directory %pD2 contains a readdir loop."

  								"Please contact your server vendor.  "

  								"The file: %.*s has duplicate cookie %llu
  ",
  								desc->file, array->array[i].string.len,
  								array->array[i].string.name, *desc->dir_cookie);

  					}
  					status = -ELOOP;
  					goto out;
  				}

  				ctx->dup_cookie = *desc->dir_cookie;

  				ctx->duped = -1;

  			}

  			desc->ctx->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_dentry(file), 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;

  }

  /* Match file and dirent using either filehandle or fileid
   * Note: caller is responsible for checking the fsid
   */

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

  	struct inode *inode;

  	struct nfs_inode *nfsi;

  	if (d_really_is_negative(dentry))
  		return 0;

  	inode = d_inode(dentry);
  	if (is_bad_inode(inode) || NFS_STALE(inode))
  		return 0;
  
  	nfsi = NFS_I(inode);

  	if (entry->fattr->fileid != nfsi->fileid)
  		return 0;
  	if (entry->fh->size && nfs_compare_fh(entry->fh, &nfsi->fh) != 0)
  		return 0;
  	return 1;

  }
  
  static

  bool nfs_use_readdirplus(struct inode *dir, struct dir_context *ctx)

  {
  	if (!nfs_server_capable(dir, NFS_CAP_READDIRPLUS))
  		return false;
  	if (test_and_clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(dir)->flags))
  		return true;

  	if (ctx->pos == 0)

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

  /*
   * This function is mainly for use by nfs_getattr().
   *
   * If this is an 'ls -l', we want to force use of readdirplus.
   * Do this by checking if there is an active file descriptor
   * and calling nfs_advise_use_readdirplus, then forcing a
   * cache flush.
   */
  void nfs_force_use_readdirplus(struct inode *dir)
  {
  	if (!list_empty(&NFS_I(dir)->open_files)) {
  		nfs_advise_use_readdirplus(dir);

  		invalidate_mapping_pages(dir->i_mapping, 0, -1);

  	}
  }

  static

  void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
  {

  	struct qstr filename = QSTR_INIT(entry->name, entry->len);

  	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);

  	struct dentry *dentry;
  	struct dentry *alias;

  	struct inode *dir = d_inode(parent);

  	struct inode *inode;

  	int status;

  	if (!(entry->fattr->valid & NFS_ATTR_FATTR_FILEID))
  		return;

  	if (!(entry->fattr->valid & NFS_ATTR_FATTR_FSID))
  		return;

  	if (filename.len == 0)
  		return;
  	/* Validate that the name doesn't contain any illegal '\0' */
  	if (strnlen(filename.name, filename.len) != filename.len)
  		return;
  	/* ...or '/' */
  	if (strnchr(filename.name, filename.len, '/'))
  		return;

  	if (filename.name[0] == '.') {
  		if (filename.len == 1)
  			return;
  		if (filename.len == 2 && filename.name[1] == '.')
  			return;
  	}

  	filename.hash = full_name_hash(parent, filename.name, filename.len);

  	dentry = d_lookup(parent, &filename);

  again:
  	if (!dentry) {
  		dentry = d_alloc_parallel(parent, &filename, &wq);
  		if (IS_ERR(dentry))
  			return;
  	}
  	if (!d_in_lookup(dentry)) {

  		/* Is there a mountpoint here? If so, just exit */
  		if (!nfs_fsid_equal(&NFS_SB(dentry->d_sb)->fsid,
  					&entry->fattr->fsid))
  			goto out;

  		if (nfs_same_file(dentry, entry)) {

  			if (!entry->fh->size)
  				goto out;

  			nfs_set_verifier(dentry, nfs_save_change_attribute(dir));

  			status = nfs_refresh_inode(d_inode(dentry), entry->fattr);

  			if (!status)

  				nfs_setsecurity(d_inode(dentry), entry->fattr, entry->label);

  			goto out;
  		} else {

  			d_invalidate(dentry);

  			dput(dentry);

  			dentry = NULL;
  			goto again;

  		}
  	}

  	if (!entry->fh->size) {
  		d_lookup_done(dentry);
  		goto out;
  	}

  	inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr, entry->label);

  	alias = d_splice_alias(inode, dentry);

  	d_lookup_done(dentry);
  	if (alias) {
  		if (IS_ERR(alias))
  			goto out;
  		dput(dentry);
  		dentry = alias;
  	}
  	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;

  	if (buflen == 0)
  		goto out_nopages;

  	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(file_dentry(desc->file), entry);

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

  	} while (!entry->eof);

  out_nopages:

  	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_pages(struct page **pages, unsigned int npages)

  {
  	unsigned int i;
  	for (i = 0; i < npages; i++)
  		put_page(pages[i]);
  }

  /*
   * nfs_readdir_large_page will allocate pages that must be freed with a call

   * to nfs_readdir_free_pagearray

   */
  static

  int nfs_readdir_alloc_pages(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_pages(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];

  	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;

  	entry.label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT);
  	if (IS_ERR(entry.label)) {
  		status = PTR_ERR(entry.label);
  		goto out;
  	}

  	array = nfs_readdir_get_array(page);

  	if (IS_ERR(array)) {
  		status = PTR_ERR(array);

  		goto out_label_free;

  	}

  	memset(array, 0, sizeof(struct nfs_cache_array));

  	atomic_set(&array->refcount, 1);

  	array->eof_index = -1;

  	status = nfs_readdir_alloc_pages(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_pages(pages, array_size);

  out_release_array:
  	nfs_readdir_release_array(page);

  out_label_free:
  	nfs4_label_free(entry.label);

  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 = file_inode(desc->file);

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

  	nfs_readdir_clear_array(desc->page);

  	put_page(desc->page);

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

  	struct page *page;
  
  	for (;;) {

  		page = read_cache_page(desc->file->f_mapping,

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

  		if (IS_ERR(page) || grab_page(page))
  			break;
  		put_page(page);
  	}
  	return page;

  }
  
  /*

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

  {
  	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 (!dir_emit(desc->ctx, ent->string.name, ent->string.len,
  		    nfs_compat_user_ino64(ent->ino), ent->d_type)) {

  			desc->eof = 1;

  			break;

  		}

  		desc->ctx->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)

  {

  	struct page	*page = NULL;
  	int		status;

  	struct inode *inode = file_inode(desc->file);

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

   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 *file, struct dir_context *ctx)

  {

  	struct dentry	*dentry = file_dentry(file);

  	struct inode	*inode = d_inode(dentry);

  	nfs_readdir_descriptor_t my_desc,
  			*desc = &my_desc;

  	struct nfs_open_dir_context *dir_ctx = file->private_data;

  	int res = 0;

  	dfprintk(FILE, "NFS: readdir(%pD2) starting at cookie %llu
  ",
  			file, (long long)ctx->pos);

  	nfs_inc_stats(inode, NFSIOS_VFSGETDENTS);

  	/*

  	 * ctx->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 = file;
  	desc->ctx = ctx;

  	desc->dir_cookie = &dir_ctx->dir_cookie;

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

  	desc->plus = nfs_use_readdirplus(inode, ctx) ? 1 : 0;

  	if (ctx->pos == 0 || nfs_attribute_cache_expired(inode))

  		res = nfs_revalidate_mapping(inode, file->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);

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

  		if (res < 0)

  			break;

  	} while (!desc->eof);

  out:

  	if (res > 0)
  		res = 0;

  	dfprintk(FILE, "NFS: readdir(%pD2) returns %d
  ", file, res);

  	return res;

  }

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

  {

  	struct nfs_open_dir_context *dir_ctx = filp->private_data;

  	dfprintk(FILE, "NFS: llseek dir(%pD2, %lld, %d)
  ",
  			filp, offset, whence);

  	switch (whence) {

  		case 1:
  			offset += filp->f_pos;
  		case 0:
  			if (offset >= 0)
  				break;
  		default:

  			return -EINVAL;

  	}
  	if (offset != filp->f_pos) {
  		filp->f_pos = offset;

  		dir_ctx->dir_cookie = 0;

  		dir_ctx->duped = 0;

  	}

  	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 inode *inode = file_inode(filp);

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

  	inode_lock(inode);

  	nfs_inc_stats(inode, NFSIOS_VFSFSYNC);

  	inode_unlock(inode);

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

  }

  EXPORT_SYMBOL_GPL(nfs_force_lookup_revalidate);

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

   * If rcu_walk prevents us from performing a full check, return 0.

   */

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

  {

  	int ret;

  	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 (rcu_walk)
  		ret = nfs_revalidate_inode_rcu(NFS_SERVER(dir), dir);
  	else
  		ret = nfs_revalidate_inode(NFS_SERVER(dir), dir);
  	if (ret < 0)

  		return 0;
  	if (!nfs_verify_change_attribute(dir, dentry->d_time))
  		return 0;
  	return 1;

  }

  /*

   * 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, unsigned int flags)

  {
  	if (NFS_PROTO(dir)->version == 2)
  		return 0;

  	return flags & 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

  int nfs_lookup_verify_inode(struct inode *inode, unsigned int flags)

  {
  	struct nfs_server *server = NFS_SERVER(inode);

  	int ret;

  	if (IS_AUTOMOUNT(inode))

  		return 0;

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

  	if (flags & LOOKUP_REVAL)

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

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

  		goto out_force;

  out:
  	return (inode->i_nlink == 0) ? -ENOENT : 0;

  out_force:

  	if (flags & LOOKUP_RCU)
  		return -ECHILD;

  	ret = __nfs_revalidate_inode(server, inode);
  	if (ret != 0)
  		return ret;
  	goto out;

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

   *
   * If LOOKUP_RCU prevents us from performing a full check, return 1
   * suggesting a reval is needed.

   */
  static inline
  int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry,

  		       unsigned int flags)

  {

  	/* Don't revalidate a negative dentry if we're creating a new file */

  	if (flags & LOOKUP_CREATE)

  		return 0;

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

  	return !nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU);

  }
  
  /*
   * 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, unsigned int flags)

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

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

  	struct nfs4_label *label = NULL;

  	int error;

  	if (flags & LOOKUP_RCU) {

  		parent = ACCESS_ONCE(dentry->d_parent);

  		dir = d_inode_rcu(parent);

  		if (!dir)
  			return -ECHILD;
  	} else {
  		parent = dget_parent(dentry);

  		dir = d_inode(parent);

  	}

  	nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE);

  	inode = d_inode(dentry);

  
  	if (!inode) {

  		if (nfs_neg_need_reval(dir, dentry, flags)) {
  			if (flags & LOOKUP_RCU)
  				return -ECHILD;

  			goto out_bad;

  		}

  		goto out_valid_noent;

  	}
  
  	if (is_bad_inode(inode)) {

  		if (flags & LOOKUP_RCU)
  			return -ECHILD;

  		dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode
  ",
  				__func__, dentry);

  		goto out_bad;
  	}

  	if (NFS_PROTO(dir)->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, flags) &&
  	    nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU)) {

  		if (nfs_lookup_verify_inode(inode, flags)) {
  			if (flags & LOOKUP_RCU)
  				return -ECHILD;

  			goto out_zap_parent;

  		}

  		goto out_valid;
  	}

  	if (flags & LOOKUP_RCU)
  		return -ECHILD;

  	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;

  	label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT);
  	if (IS_ERR(label))
  		goto out_error;

  	trace_nfs_lookup_revalidate_enter(dir, dentry, flags);

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

  	trace_nfs_lookup_revalidate_exit(dir, dentry, flags, error);

  	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_setsecurity(inode, fattr, label);

  	nfs_free_fattr(fattr);
  	nfs_free_fhandle(fhandle);

  	nfs4_label_free(label);

  out_set_verifier:

  	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));

   out_valid:

  	/* Success: notify readdir to use READDIRPLUS */
  	nfs_advise_use_readdirplus(dir);
   out_valid_noent:

  	if (flags & LOOKUP_RCU) {

  		if (parent != ACCESS_ONCE(dentry->d_parent))

  			return -ECHILD;
  	} else
  		dput(parent);

  	dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is valid
  ",
  			__func__, dentry);

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

  	WARN_ON(flags & LOOKUP_RCU);

  	nfs_free_fattr(fattr);
  	nfs_free_fhandle(fhandle);

  	nfs4_label_free(label);

  	nfs_mark_for_revalidate(dir);

  	if (inode && S_ISDIR(inode->i_mode)) {
  		/* Purge readdir caches. */
  		nfs_zap_caches(inode);

  		/*
  		 * We can't d_drop the root of a disconnected tree:
  		 * its d_hash is on the s_anon list and d_drop() would hide
  		 * it from shrink_dcache_for_unmount(), leading to busy
  		 * inodes on unmount and further oopses.
  		 */
  		if (IS_ROOT(dentry))

  			goto out_valid;

  	}

  	dput(parent);

  	dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is invalid
  ",
  			__func__, dentry);

  	return 0;

  out_error:

  	WARN_ON(flags & LOOKUP_RCU);

  	nfs_free_fattr(fattr);
  	nfs_free_fhandle(fhandle);

  	nfs4_label_free(label);

  	dput(parent);

  	dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) lookup returned error %d
  ",
  			__func__, dentry, error);

  	return error;

  }
  
  /*

   * A weaker form of d_revalidate for revalidating just the d_inode(dentry)

   * when we don't really care about the dentry name. This is called when a
   * pathwalk ends on a dentry that was not found via a normal lookup in the
   * parent dir (e.g.: ".", "..", procfs symlinks or mountpoint traversals).
   *
   * In this situation, we just want to verify that the inode itself is OK
   * since the dentry might have changed on the server.
   */
  static int nfs_weak_revalidate(struct dentry *dentry, unsigned int flags)
  {
  	int error;

  	struct inode *inode = d_inode(dentry);

  
  	/*
  	 * I believe we can only get a negative dentry here in the case of a
  	 * procfs-style symlink. Just assume it's correct for now, but we may
  	 * eventually need to do something more here.
  	 */
  	if (!inode) {

  		dfprintk(LOOKUPCACHE, "%s: %pd2 has negative inode
  ",
  				__func__, dentry);

  		return 1;
  	}
  
  	if (is_bad_inode(inode)) {

  		dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode
  ",
  				__func__, dentry);

  		return 0;
  	}
  
  	error = nfs_revalidate_inode(NFS_SERVER(inode), inode);
  	dfprintk(LOOKUPCACHE, "NFS: %s: inode %lu is %s
  ",
  			__func__, inode->i_ino, error ? "invalid" : "valid");
  	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(%pd2, %x)
  ",
  		dentry, dentry->d_flags);

  	/* Unhash any dentry with a stale inode */

  	if (d_really_is_positive(dentry) && NFS_STALE(d_inode(dentry)))

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

  /* Ensure that we revalidate inode->i_nlink */

  static void nfs_drop_nlink(struct inode *inode)
  {
  	spin_lock(&inode->i_lock);

  	/* drop the inode if we're reasonably sure this is the last link */
  	if (inode->i_nlink == 1)
  		clear_nlink(inode);
  	NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;

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

  		nfs_complete_unlink(dentry, inode);

  		nfs_drop_nlink(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_weak_revalidate	= nfs_weak_revalidate,

  	.d_delete	= nfs_dentry_delete,
  	.d_iput		= nfs_dentry_iput,

  	.d_automount	= nfs_d_automount,

  	.d_release	= nfs_d_release,

  };

  EXPORT_SYMBOL_GPL(nfs_dentry_operations);

  struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)

  {
  	struct dentry *res;
  	struct inode *inode = NULL;

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

  	struct nfs4_label *label = NULL;

  	int error;