fat (exportfs): fix dentry reconnection

Maintain an index of directory inodes by starting cluster, so that
fat_get_parent() can return the proper cached inode rather than inventing
one that cannot be traced back to the filesystem root.

Add a new msdos/vfat binary mount option "nfs" so that FAT filesystems
that are _not_ exported via NFS are not saddled with maintenance of an
index they will never use.

Finally, simplify NFS file handle generation and lookups.  An
ext2-congruent implementation is adequate for FAT needs.

Signed-off-by: Steven J. Magnani <steve@digidescorp.com>
Acked-by: OGAWA Hirofumi <hirofumi@mail.parknet.co.jp>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 50 insertions, 100 deletions

diff --git a/fs/fat/nfs.c b/fs/fat/nfs.c
index 21609a1e9355..ef4b5faba87b 100644
--- a/fs/fat/nfs.c
+++ b/fs/fat/nfs.c
@@ -14,47 +14,46 @@
 #include <linux/exportfs.h>
 #include "fat.h"
 
-/*
- * a FAT file handle with fhtype 3 is
- *  0/  i_ino - for fast, reliable lookup if still in the cache
- *  1/  i_generation - to see if i_ino is still valid
- *          bit 0 == 0 iff directory
- *  2/  i_pos(8-39) - if ino has changed, but still in cache
- *  3/  i_pos(4-7)|i_logstart - to semi-verify inode found at i_pos
- *  4/  i_pos(0-3)|parent->i_logstart - maybe used to hunt for the file on disc
- *
- * Hack for NFSv2: Maximum FAT entry number is 28bits and maximum
- * i_pos is 40bits (blocknr(32) + dir offset(8)), so two 4bits
- * of i_logstart is used to store the directory entry offset.
+/**
+ * Look up a directory inode given its starting cluster.
  */
-
-int
-fat_encode_fh(struct inode *inode, __u32 *fh, int *lenp, struct inode *parent)
+static struct inode *fat_dget(struct super_block *sb, int i_logstart)
 {
-        int len = *lenp;
-        struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
-        loff_t i_pos;
+        struct msdos_sb_info *sbi = MSDOS_SB(sb);
+        struct hlist_head *head;
+        struct hlist_node *_p;
+        struct msdos_inode_info *i;
+        struct inode *inode = NULL;
 
-        if (len < 5) {
-                *lenp = 5;
-                return 255; /* no room */
+        head = sbi->dir_hashtable + fat_dir_hash(i_logstart);
+        spin_lock(&sbi->dir_hash_lock);
+        hlist_for_each_entry(i, _p, head, i_dir_hash) {
+                BUG_ON(i->vfs_inode.i_sb != sb);
+                if (i->i_logstart != i_logstart)
+                        continue;
+                inode = igrab(&i->vfs_inode);
+                if (inode)
+                        break;
         }
-
-        i_pos = fat_i_pos_read(sbi, inode);
-        *lenp = 5;
-        fh[0] = inode->i_ino;
-        fh[1] = inode->i_generation;
-        fh[2] = i_pos >> 8;
-        fh[3] = ((i_pos & 0xf0) << 24) | MSDOS_I(inode)->i_logstart;
-        fh[4] = (i_pos & 0x0f) << 28;
-        if (parent)
-                fh[4] |= MSDOS_I(parent)->i_logstart;
-        return 3;
+        spin_unlock(&sbi->dir_hash_lock);
+        return inode;
 }
 
-static int fat_is_valid_fh(int fh_len, int fh_type)
+static struct inode *fat_nfs_get_inode(struct super_block *sb,
+                                       u64 ino, u32 generation)
 {
-        return ((fh_len >= 5) && (fh_type == 3));
+        struct inode *inode;
+
+        if ((ino < MSDOS_ROOT_INO) || (ino == MSDOS_FSINFO_INO))
+                return NULL;
+
+        inode = ilookup(sb, ino);
+        if (inode && generation && (inode->i_generation != generation)) {
+                iput(inode);
+                inode = NULL;
+        }
+
+        return inode;
 }
 
 /**
@@ -64,57 +63,19 @@ static int fat_is_valid_fh(int fh_len, int fh_type)
 struct dentry *fat_fh_to_dentry(struct super_block *sb, struct fid *fid,
                                 int fh_len, int fh_type)
 {
-        struct inode *inode = NULL;
-        u32 *fh = fid->raw;
-        loff_t i_pos;
-        unsigned long i_ino;
-        __u32 i_generation;
-        int i_logstart;
-
-        if (!fat_is_valid_fh(fh_len, fh_type))
-                return NULL;
-
-        i_ino = fh[0];
-        i_generation = fh[1];
-        i_logstart = fh[3] & 0x0fffffff;
-
-        /* Try i_ino lookup first - fastest and most reliable */
-        inode = ilookup(sb, i_ino);
-        if (inode && (inode->i_generation != i_generation)) {
-                iput(inode);
-                inode = NULL;
-        }
-        if (!inode) {
-                i_pos = (loff_t)fh[2] << 8;
-                i_pos |= ((fh[3] >> 24) & 0xf0) | (fh[4] >> 28);
-
-                /* try 2 - see if i_pos is in F-d-c
-                 * require i_logstart to be the same
-                 * Will fail if you truncate and then re-write
-                 */
-
-                inode = fat_iget(sb, i_pos);
-                if (inode && MSDOS_I(inode)->i_logstart != i_logstart) {
-                        iput(inode);
-                        inode = NULL;
-                }
-        }
+        return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
+                                    fat_nfs_get_inode);
+}
 
-        /*
-         * For now, do nothing if the inode is not found.
-         *
-         * What we could do is:
-         *
-         *      - follow the file starting at fh[4], and record the ".." entry,
-         *        and the name of the fh[2] entry.
-         *      - then follow the ".." file finding the next step up.
-         *
-         * This way we build a path to the root of the tree. If this works, we
-         * lookup the path and so get this inode into the cache.  Finally try
-         * the fat_iget lookup again.  If that fails, then we are totally out
-         * of luck.  But all that is for another day
-         */
-        return d_obtain_alias(inode);
+/*
+ * Find the parent for a file specified by NFS handle.
+ * This requires that the handle contain the i_ino of the parent.
+ */
+struct dentry *fat_fh_to_parent(struct super_block *sb, struct fid *fid,
+                                int fh_len, int fh_type)
+{
+        return generic_fh_to_parent(sb, fid, fh_len, fh_type,
+                                    fat_nfs_get_inode);
 }
 
 /*
@@ -128,24 +89,13 @@ struct dentry *fat_get_parent(struct dentry *child_dir)
         struct super_block *sb = child_dir->d_sb;
         struct buffer_head *bh = NULL;
         struct msdos_dir_entry *de;
-        loff_t i_pos;
-        struct dentry *parent;
-        struct inode *inode;
-        int err;
+        struct inode *parent_inode = NULL;
 
-        lock_super(sb);
-
-        err = fat_get_dotdot_entry(child_dir->d_inode, &bh, &de, &i_pos);
-        if (err) {
-                parent = ERR_PTR(err);
-                goto out;
+        if (!fat_get_dotdot_entry(child_dir->d_inode, &bh, &de)) {
+                int parent_logstart = fat_get_start(MSDOS_SB(sb), de);
+                parent_inode = fat_dget(sb, parent_logstart);
         }
-        inode = fat_build_inode(sb, de, i_pos);
-
-        parent = d_obtain_alias(inode);
-out:
         brelse(bh);
-        unlock_super(sb);
 
-        return parent;
+        return d_obtain_alias(parent_inode);
 }