NFS: add readdir cache array

		      struct inode *, struct dentry *);

static int nfs_fsync_dir(struct file *, int);

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

static int nfs_readdir_clear_array(struct page*, gfp_t);

const struct file_operations nfs_dir_operations = {

	.llseek		= nfs_llseek_dir,

	.setattr	= nfs_setattr,

};

const struct address_space_operations nfs_dir_addr_space_ops = {

	.releasepage = nfs_readdir_clear_array,

};

#ifdef CONFIG_NFS_V3

const struct inode_operations nfs3_dir_inode_operations = {

	.create		= nfs_create,

	return res;

}

struct nfs_cache_array_entry {

	u64 cookie;

	u64 ino;

	struct qstr string;

};

struct nfs_cache_array {

	unsigned int size;

	int eof_index;

	u64 last_cookie;

	struct nfs_cache_array_entry array[0];

};

#define MAX_READDIR_ARRAY ((PAGE_SIZE - sizeof(struct nfs_cache_array)) / sizeof(struct nfs_cache_array_entry))

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

typedef struct {

	struct file	*file;

	struct page	*page;

	unsigned long	page_index;

	__be32		*ptr;

	u64		*dir_cookie;

	loff_t		current_index;

	struct nfs_entry *entry;

	decode_dirent_t	decode;

	int		plus;

	unsigned long	timestamp;

	unsigned long	gencount;

	int		timestamp_valid;

	unsigned int	cache_entry_index;

	unsigned int	plus:1;

	unsigned int	eof:1;

} nfs_readdir_descriptor_t;

/* Now we cache directories properly, by stuffing the dirent

 * data directly in the page cache.

 *

 * Inode invalidation due to refresh etc. takes care of

 * _everything_, no sloppy entry flushing logic, no extraneous

 * copying, network direct to page cache, the way it was meant

 * to be.

 *

 * NOTE: Dirent information verification is done always by the

 *	 page-in of the RPC reply, nowhere else, this simplies

 *	 things substantially.

/*

 * The caller is responsible for calling nfs_readdir_release_array(page)

 */

static

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

struct nfs_cache_array *nfs_readdir_get_array(struct page *page)

{

	if (page == NULL)

		return ERR_PTR(-EIO);

	return (struct nfs_cache_array *)kmap(page);

}

static

void nfs_readdir_release_array(struct page *page)

{

	kunmap(page);

}

/*

 * we are freeing strings created by nfs_add_to_readdir_array()

 */

static

int nfs_readdir_clear_array(struct page *page, gfp_t mask)

{

	struct nfs_cache_array *array = nfs_readdir_get_array(page);

	int i;

	for (i = 0; i < array->size; i++)

		kfree(array->array[i].string.name);

	nfs_readdir_release_array(page);

	return 0;

}

/*

 * 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

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

{

	string->len = len;

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

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

}

static

int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page)

{

	struct nfs_cache_array *array = nfs_readdir_get_array(page);

	if (IS_ERR(array))

		return PTR_ERR(array);

	if (array->size >= MAX_READDIR_ARRAY) {

		nfs_readdir_release_array(page);

		return -EIO;

	}

	array->array[array->size].cookie = entry->prev_cookie;

	array->last_cookie = entry->cookie;

	array->array[array->size].ino = entry->ino;

	nfs_readdir_make_qstr(&array->array[array->size].string, entry->name, entry->len);

	if (entry->eof == 1)

		array->eof_index = array->size;

	array->size++;

	nfs_readdir_release_array(page);

	return 0;

}

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;

		desc->current_index += array->size;

		return -EAGAIN;

	}

	index = (unsigned int)diff;

	*desc->dir_cookie = array->array[index].cookie;

	desc->cache_entry_index = index;

	if (index == array->eof_index)

		desc->eof = 1;

	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;

	int status = -EAGAIN;

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

		if (i == array->eof_index) {

			desc->eof = 1;

			status = -EBADCOOKIE;

		}

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

			desc->cache_entry_index = i;

			status = 0;

			break;

		}

	}

	return status;

}

static

int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc)

{

	struct nfs_cache_array *array;

	int status = -EBADCOOKIE;

	if (desc->dir_cookie == NULL)

		goto out;

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

	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 *xdr_page, nfs_readdir_descriptor_t *desc,

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

{

	struct file	*file = desc->file;

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

	struct rpc_cred	*cred = nfs_file_cred(file);

	unsigned long	timestamp, gencount;

	int		error;

	dfprintk(DIRCACHE, "NFS: %s: reading cookie %Lu into page %lu\n",

			__func__, (long long)desc->entry->cookie,

			page->index);

 again:

	timestamp = jiffies;

	gencount = nfs_inc_attr_generation_counter();

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

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

					  NFS_SERVER(inode)->dtsize, desc->plus);

	if (error < 0) {

		/* We requested READDIRPLUS, but the server doesn't grok it */

	}

	desc->timestamp = timestamp;

	desc->gencount = gencount;

	desc->timestamp_valid = 1;

	SetPageUptodate(page);

	/* Ensure consistent page alignment of the data.

	 * Note: assumes we have exclusive access to this mapping either

	 *	 through inode->i_mutex or some other mechanism.

	 */

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

	return error;

}

static inline

int dir_decode(nfs_readdir_descriptor_t *desc)

/* Fill in an entry based on the xdr code stored in desc->page */

static

int xdr_decode(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry, __be32 **ptr)

{

	__be32	*p = desc->ptr;

	p = desc->decode(p, desc->entry, desc->plus);

	__be32	*p = *ptr;

	p = desc->decode(p, entry, desc->plus);

	if (IS_ERR(p))

		return PTR_ERR(p);

	desc->ptr = p;

	if (desc->timestamp_valid) {

		desc->entry->fattr->time_start = desc->timestamp;

		desc->entry->fattr->gencount = desc->gencount;

	} else

		desc->entry->fattr->valid &= ~NFS_ATTR_FATTR;

	*ptr = p;

	entry->fattr->time_start = desc->timestamp;

	entry->fattr->gencount = desc->gencount;

	return 0;

}

static inline

void dir_page_release(nfs_readdir_descriptor_t *desc)

/* Perform conversion from xdr to cache array */

static

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

				struct page *xdr_page, struct page *page)

{

	kunmap(desc->page);

	page_cache_release(desc->page);

	desc->page = NULL;

	desc->ptr = NULL;

	__be32 *ptr = kmap(xdr_page);

	while (xdr_decode(desc, entry, &ptr) == 0) {

		if (nfs_readdir_add_to_array(entry, page) == -1)

			break;

	}

	kunmap(xdr_page);

}

/*

 * Given a pointer to a buffer that has already been filled by a call

 * to readdir, find the next entry with cookie '*desc->dir_cookie'.

 *

 * If the end of the buffer has been reached, return -EAGAIN, if not,

 * return the offset within the buffer of the next entry to be

 * read.

 */

static inline

int find_dirent(nfs_readdir_descriptor_t *desc)

static

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

{

	struct nfs_entry *entry = desc->entry;

	int		loop_count = 0,

			status;

	struct page *xdr_page;

	struct nfs_entry entry;

	struct file	*file = desc->file;

	struct nfs_cache_array *array;

	int status = 0;

	entry.prev_cookie = 0;

	entry.cookie = *desc->dir_cookie;

	entry.eof = 0;

	entry.fh = nfs_alloc_fhandle();

	entry.fattr = nfs_alloc_fattr();

	if (entry.fh == NULL || entry.fattr == NULL)

		goto out;

	while((status = dir_decode(desc)) == 0) {

		dfprintk(DIRCACHE, "NFS: %s: examining cookie %Lu\n",

				__func__, (unsigned long long)entry->cookie);

		if (entry->prev_cookie == *desc->dir_cookie)

	array = nfs_readdir_get_array(page);

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

	array->eof_index = -1;

	xdr_page = alloc_page(GFP_KERNEL);

	if (!xdr_page)

		goto out_release_array;

	do {

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

		if (status < 0)

			break;

		if (loop_count++ > 200) {

			loop_count = 0;

			schedule();

		}

	}

		nfs_readdir_page_filler(desc, &entry, xdr_page, page);

	} while (array->eof_index < 0 && array->size < MAX_READDIR_ARRAY);

	put_page(xdr_page);

out_release_array:

	nfs_readdir_release_array(page);

out:

	nfs_free_fattr(entry.fattr);

	nfs_free_fhandle(entry.fh);

	return status;

}

/*

 * Given a pointer to a buffer that has already been filled by a call

 * to readdir, find the entry at offset 'desc->file->f_pos'.

 *

 * If the end of the buffer has been reached, return -EAGAIN, if not,

 * return the offset within the buffer of the next entry to be

 * read.

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

int find_dirent_index(nfs_readdir_descriptor_t *desc)

static

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

{

	struct nfs_entry *entry = desc->entry;

	int		loop_count = 0,

			status;

	for(;;) {

		status = dir_decode(desc);

		if (status)

			break;

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

		dfprintk(DIRCACHE, "NFS: found cookie %Lu at index %Ld\n",

				(unsigned long long)entry->cookie, desc->current_index);

	if (nfs_readdir_xdr_to_array(desc, page, inode) == -1)

		goto error;

	SetPageUptodate(page);

		if (desc->file->f_pos == desc->current_index) {

			*desc->dir_cookie = entry->cookie;

			break;

	if (invalidate_inode_pages2_range(inode->i_mapping, page->index + 1, -1) < 0) {

		/* Should never happen */

		nfs_zap_mapping(inode, inode->i_mapping);

	}

		desc->current_index++;

		if (loop_count++ > 200) {

			loop_count = 0;

			schedule();

	unlock_page(page);

	return 0;

 error:

	unlock_page(page);

	return -EIO;

}

static

void cache_page_release(nfs_readdir_descriptor_t *desc)

{

	page_cache_release(desc->page);

	desc->page = NULL;

}

	return status;

static

struct page *get_cache_page(nfs_readdir_descriptor_t *desc)

{

	struct page *page;

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

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

	if (IS_ERR(page))

		desc->eof = 1;

	return page;

}

/*

 * Find the given page, and call find_dirent() or find_dirent_index in

 * order to try to return the next entry.

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

 */

static inline

int find_dirent_page(nfs_readdir_descriptor_t *desc)

static

int find_cache_page(nfs_readdir_descriptor_t *desc)

{

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

	struct page	*page;

	int		status;

	dfprintk(DIRCACHE, "NFS: %s: searching page %ld for target %Lu\n",

			__func__, desc->page_index,

			(long long) *desc->dir_cookie);

	int res;

	/* If we find the page in the page_cache, we cannot be sure

	 * how fresh the data is, so we will ignore readdir_plus attributes.

	 */

	desc->timestamp_valid = 0;

	page = read_cache_page(inode->i_mapping, desc->page_index,

			       (filler_t *)nfs_readdir_filler, desc);

	if (IS_ERR(page)) {

		status = PTR_ERR(page);

		goto out;

	}

	desc->page = get_cache_page(desc);

	if (IS_ERR(desc->page))

		return PTR_ERR(desc->page);

	/* NOTE: Someone else may have changed the READDIRPLUS flag */

	desc->page = page;

	desc->ptr = kmap(page);		/* matching kunmap in nfs_do_filldir */

	if (*desc->dir_cookie != 0)

		status = find_dirent(desc);

	else

		status = find_dirent_index(desc);

	if (status < 0)

		dir_page_release(desc);

 out:

	dfprintk(DIRCACHE, "NFS: %s: returns %d\n", __func__, status);

	return status;

	res = nfs_readdir_search_array(desc);

	if (res == 0)

		return 0;

	cache_page_release(desc);

	return res;

}

/*

 * Recurse through the page cache pages, and return a

 * filled nfs_entry structure of the next directory entry if possible.

 *

 * The target for the search is '*desc->dir_cookie' if non-0,

 * 'desc->file->f_pos' otherwise

 */

/* Search for desc->dir_cookie from the beginning of the page cache */

static inline

int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)

{

	int		loop_count = 0;

	int		res;

	/* Always search-by-index from the beginning of the cache */

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

		dfprintk(DIRCACHE, "NFS: readdir_search_pagecache() searching for offset %Ld\n",

				(long long)desc->file->f_pos);

	int res = -EAGAIN;

	desc->page_index = 0;

		desc->entry->cookie = desc->entry->prev_cookie = 0;

		desc->entry->eof = 0;

		desc->current_index = 0;

	} else

		dfprintk(DIRCACHE, "NFS: readdir_search_pagecache() searching for cookie %Lu\n",

				(unsigned long long)*desc->dir_cookie);

	for (;;) {

		res = find_dirent_page(desc);

	if (*desc->dir_cookie == 0)

		desc->cache_entry_index = 0;

	while (1) {

		res = find_cache_page(desc);

		if (res != -EAGAIN)

			break;

		/* Align to beginning of next page */

		desc->page_index++;

		if (loop_count++ > 200) {

			loop_count = 0;

			schedule();

		}

	}

	dfprintk(DIRCACHE, "NFS: %s: returns %d\n", __func__, res);

	return res;

}

	return (inode->i_mode >> 12) & 15;

}

static struct dentry *nfs_readdir_lookup(nfs_readdir_descriptor_t *desc);

/*

 * Once we've found the start of the dirent within a page: fill 'er up...

 */

		   filldir_t filldir)

{

	struct file	*file = desc->file;

	struct nfs_entry *entry = desc->entry;

	int i = 0;

	int res = 0;

	struct nfs_cache_array *array = NULL;

	unsigned int d_type = DT_UNKNOWN;

	struct dentry *dentry = NULL;

	u64		fileid;

	int		loop_count = 0,

			res;

	dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling starting @ cookie %Lu\n",

			(unsigned long long)entry->cookie);

	array = nfs_readdir_get_array(desc->page);

	for(;;) {

		unsigned d_type = DT_UNKNOWN;

		/* Note: entry->prev_cookie contains the cookie for

		 *	 retrieving the current dirent on the server */

		fileid = entry->ino;

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

		d_type = DT_UNKNOWN;

		/* Get a dentry if we have one */

		if (dentry != NULL)

			dput(dentry);

		dentry = nfs_readdir_lookup(desc);

		/* Use readdirplus info */

		if (dentry != NULL && dentry->d_inode != NULL) {

			d_type = dt_type(dentry->d_inode);

			fileid = NFS_FILEID(dentry->d_inode);

		}

		res = filldir(dirent, entry->name, entry->len, 

			      file->f_pos, nfs_compat_user_ino64(fileid),

			      d_type);

		res = filldir(dirent, array->array[i].string.name,

			array->array[i].string.len, file->f_pos,

			nfs_compat_user_ino64(array->array[i].ino), d_type);

		if (res < 0)

			break;

		file->f_pos++;

		*desc->dir_cookie = entry->cookie;

		if (dir_decode(desc) != 0) {

			desc->page_index ++;

		desc->cache_entry_index = i;

		if (i < (array->size-1))

			*desc->dir_cookie = array->array[i+1].cookie;

		else

			*desc->dir_cookie = array->last_cookie;

		if (i == array->eof_index) {

			desc->eof = 1;

			break;

		}

		if (loop_count++ > 200) {

			loop_count = 0;

			schedule();

	}

	}

	dir_page_release(desc);

	nfs_readdir_release_array(desc->page);

	cache_page_release(desc);

	if (dentry != NULL)

		dput(dentry);

	dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n",

int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,

		     filldir_t filldir)

{

	struct file	*file = desc->file;

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

	struct rpc_cred	*cred = nfs_file_cred(file);

	struct page	*page = NULL;

	int		status;

	unsigned long	timestamp, gencount;

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

	dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n",

			(unsigned long long)*desc->dir_cookie);

		status = -ENOMEM;

		goto out;

	}

	timestamp = jiffies;

	gencount = nfs_inc_attr_generation_counter();

	status = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred,

						*desc->dir_cookie, page,

						NFS_SERVER(inode)->dtsize,

						desc->plus);

	desc->page = page;

	desc->ptr = kmap(page);		/* matching kunmap in nfs_do_filldir */

	if (status >= 0) {

		desc->timestamp = timestamp;

		desc->gencount = gencount;

		desc->timestamp_valid = 1;

		if ((status = dir_decode(desc)) == 0)

			desc->entry->prev_cookie = *desc->dir_cookie;

	} else

	if (nfs_readdir_xdr_to_array(desc, page, inode) == -1) {

		status = -EIO;

	if (status < 0)

		goto out_release;

	}

	desc->page = page;