/*
* 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;
struct nfs_entry *entry = desc->entry;
unsigned long fileid;
int loop_count = 0,
res;
dfprintk(VFS, "NFS: nfs_do_filldir() filling starting @ cookie %Lu\n", (long long)desc->target);
for(;;) {
/* Note: entry->prev_cookie contains the cookie for
* retrieving the current dirent on the server */
fileid = nfs_fileid_to_ino_t(entry->ino);
res = filldir(dirent, entry->name, entry->len,
entry->prev_cookie, fileid, DT_UNKNOWN);
if (res < 0)
break;
file->f_pos = desc->target = entry->cookie;
if (dir_decode(desc) != 0) {
desc->page_index ++;
break;
}
if (loop_count++ > 200) {
loop_count = 0;
schedule();
}
}
dir_page_release(desc);
dfprintk(VFS, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n", (long long)desc->target, res);
return res;
}
/*
* Find the given page, and call find_dirent() in order to try to
* return the next entry.
*/
static inline
int find_dirent_page(nfs_readdir_descriptor_t *desc)
{
struct inode *inode = desc->file->f_dentry->d_inode;
struct page *page;
int status;
dfprintk(VFS, "NFS: find_dirent_page() searching directory page %ld\n", desc->page_index);
desc->plus = NFS_USE_READDIRPLUS(inode);
page = read_cache_page(&inode->i_data, desc->page_index,
(filler_t *)nfs_readdir_filler, desc);
if (IS_ERR(page)) {
status = PTR_ERR(page);
goto out;
}
if (!Page_Uptodate(page))
goto read_error;
/* NOTE: Someone else may have changed the READDIRPLUS flag */
desc->page = page;
desc->ptr = kmap(page);
status = find_dirent(desc, page);
if (status < 0)
dir_page_release(desc);
out:
dfprintk(VFS, "NFS: find_dirent_page() returns %d\n", status);
return status;
read_error:
page_cache_release(page);
return -EIO;
}
/*
* 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 file *file = desc->file;
struct inode *inode = file->f_dentry->d_inode;
struct rpc_cred *cred = nfs_file_cred(file);
struct page *page = NULL;
int status;
dfprintk(VFS, "NFS: uncached_readdir() searching for cookie %Lu\n", (long long)desc->target);
page = alloc_page(GFP_HIGHUSER);
if (!page) {
status = -ENOMEM;
goto out;
}
desc->error = NFS_PROTO(inode)->readdir(file->f_dentry, cred, desc->target,
page,
NFS_SERVER(inode)->dtsize,
desc->plus);
NFS_FLAGS(inode) |= NFS_INO_INVALID_ATIME;
desc->page = page;
desc->ptr = kmap(page); /* matching kunmap in nfs_do_filldir */
if (desc->error >= 0) {
if ((status = dir_decode(desc)) == 0)
desc->entry->prev_cookie = desc->target;
} else
status = -EIO;
if (status < 0)
goto out_release;
status = nfs_do_filldir(desc, dirent, filldir);
/* Reset read descriptor so it searches the page cache from
* the start upon the next call to readdir_search_pagecache() */
desc->page_index = 0;
desc->entry->cookie = desc->entry->prev_cookie = 0;
desc->entry->eof = 0;
out:
dfprintk(VFS, "NFS: uncached_readdir() returns %d\n", status);
return status;
out_release:
dir_page_release(desc);
goto out;
}
/* vsnfs_do_filldir :- Main routine that reads the dirents from the page returned
* by server and fills them in the client.
*/
static
int vsnfs_do_filldir(vsnfs_readdir_descriptor_t *desc, void *dirent,
filldir_t filldir)
{
struct file *file = desc->file;
struct vsnfs_entry *entry = desc->entry;
unsigned long fileid;
unsigned int d_type;
int res, status;
vsnfs_trace(KERN_ERR, "VSNFS: vsnfs_do_filldir() filling starting @ cookie %Lu\n", (long long)desc->target);
for(;;) {
status = dir_decode(desc);
if (status < 0) {
res = status;
goto out;
}
fileid = entry->ino;
d_type = entry->fh->type;
res = filldir(dirent, entry->name, entry->len, entry->offset, fileid, d_type);
if (res < 0) {
vsnfs_trace(KERN_ERR, "Filldir failed\n");
goto out;
}
if (entry->eof == 1) {
file->f_pos = 4096;
break;
}
}
dir_page_release(desc);
out:
return res;
}
