[XFS] use filldir internally

Currently xfs has a rather complicated internal scheme to allow for
different directory formats in IRIX. This patch rips all code related to
this out and pushes useage of the Linux filldir callback into the lowlevel
directory code. This does not make the code any less portable because
filldir can be used to create dirents of all possible variations
(including the IRIX ones as proved by the IRIX binary emulation code under
arch/mips/).

This patch get rid of an unessecary copy in the readdir path, about 400
lines of code and one of the last two users of the uio structure.

This version is updated to deal with dmapi aswell which greatly simplifies
the get_dirattrs code. The dmapi part has been tested using the
get_dirattrs tools from the xfstest dmapi suite1 with various small and
large directories.

SGI-PV: 968563
SGI-Modid: xfs-linux-melb:xfs-kern:29478a

Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Tim Shimmin <tes@sgi.com>

1 files changed, 23 insertions, 67 deletions

diff --git a/fs/xfs/linux-2.6/xfs_file.c b/fs/xfs/linux-2.6/xfs_file.c
index 4fc0f58edacf..3678f6912d04 100644
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -233,74 +233,30 @@ xfs_file_readdir(
         void            *dirent,
         filldir_t       filldir)
 {
-        int             error = 0;
-        bhv_vnode_t     *vp = vn_from_inode(filp->f_path.dentry->d_inode);
-        uio_t           uio;
-        iovec_t         iov;
-        int             eof = 0;
-        caddr_t         read_buf;
-        int             namelen, size = 0;
-        size_t          rlen = PAGE_CACHE_SIZE;
-        xfs_off_t       start_offset, curr_offset;
-        xfs_dirent_t    *dbp = NULL;
-
-        /* Try fairly hard to get memory */
-        do {
-                if ((read_buf = kmalloc(rlen, GFP_KERNEL)))
-                        break;
-                rlen >>= 1;
-        } while (rlen >= 1024);
-
-        if (read_buf == NULL)
-                return -ENOMEM;
-
-        uio.uio_iov = &iov;
-        uio.uio_segflg = UIO_SYSSPACE;
-        curr_offset = filp->f_pos;
-        if (filp->f_pos != 0x7fffffff)
-                uio.uio_offset = filp->f_pos;
-        else
-                uio.uio_offset = 0xffffffff;
-
-        while (!eof) {
-                uio.uio_resid = iov.iov_len = rlen;
-                iov.iov_base = read_buf;
-                uio.uio_iovcnt = 1;
-
-                start_offset = uio.uio_offset;
-
-                error = bhv_vop_readdir(vp, &uio, NULL, &eof);
-                if ((uio.uio_offset == start_offset) || error) {
-                        size = 0;
-                        break;
-                }
-
-                size = rlen - uio.uio_resid;
-                dbp = (xfs_dirent_t *)read_buf;
-                while (size > 0) {
-                        namelen = strlen(dbp->d_name);
-
-                        if (filldir(dirent, dbp->d_name, namelen,
-                                        (loff_t) curr_offset & 0x7fffffff,
-                                        (ino_t) dbp->d_ino,
-                                        DT_UNKNOWN)) {
-                                goto done;
-                        }
-                        size -= dbp->d_reclen;
-                        curr_offset = (loff_t)dbp->d_off /* & 0x7fffffff */;
-                        dbp = (xfs_dirent_t *)((char *)dbp + dbp->d_reclen);
-                }
-        }
-done:
-        if (!error) {
-                if (size == 0)
-                        filp->f_pos = uio.uio_offset & 0x7fffffff;
-                else if (dbp)
-                        filp->f_pos = curr_offset;
-        }
+        struct inode    *inode = filp->f_path.dentry->d_inode;
+        bhv_vnode_t     *vp = vn_from_inode(inode);
+        int             error;
+        size_t          bufsize;
+
+        /*
+         * The Linux API doesn't pass down the total size of the buffer
+         * we read into down to the filesystem.  With the filldir concept
+         * it's not needed for correct information, but the XFS dir2 leaf
+         * code wants an estimate of the buffer size to calculate it's
+         * readahead window and size the buffers used for mapping to
+         * physical blocks.
+         *
+         * Try to give it an estimate that's good enough, maybe at some
+         * point we can change the ->readdir prototype to include the
+         * buffer size.
+         */
+        bufsize = (size_t)min_t(loff_t, PAGE_SIZE, inode->i_size);
 
-        kfree(read_buf);
-        return -error;
+        error = bhv_vop_readdir(vp, dirent, bufsize,
+                                (xfs_off_t *)&filp->f_pos, filldir);
+        if (error)
+                return -error;
+        return 0;
 }
 
 STATIC int