fat (exportfs): fix dentry reconnection
authorSteven J. Magnani <steve@digidescorp.com>
Fri, 5 Oct 2012 00:14:45 +0000 (17:14 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Fri, 5 Oct 2012 18:05:09 +0000 (03:05 +0900)
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>
fs/fat/dir.c
fs/fat/fat.h
fs/fat/inode.c
fs/fat/namei_msdos.c
fs/fat/namei_vfat.c
fs/fat/nfs.c

index d70d8f31f704e50cbc2e25e6b0a5bd8e2c0960c1..55e088cc061320f5ca93c55aa321ae848beb4e8a 100644 (file)
@@ -872,21 +872,23 @@ static int fat_get_short_entry(struct inode *dir, loff_t *pos,
 }
 
 /*
- * The ".." entry can not provide the "struct fat_slot_info" informations
- * for inode. So, this function provide the some informations only.
+ * The ".." entry can not provide the "struct fat_slot_info" information
+ * for inode, nor a usable i_pos. So, this function provides some information
+ * only.
+ *
+ * Since this function walks through the on-disk inodes within a directory,
+ * callers are responsible for taking any locks necessary to prevent the
+ * directory from changing.
  */
 int fat_get_dotdot_entry(struct inode *dir, struct buffer_head **bh,
-                        struct msdos_dir_entry **de, loff_t *i_pos)
+                        struct msdos_dir_entry **de)
 {
-       loff_t offset;
+       loff_t offset = 0;
 
-       offset = 0;
-       *bh = NULL;
+       *de = NULL;
        while (fat_get_short_entry(dir, &offset, bh, de) >= 0) {
-               if (!strncmp((*de)->name, MSDOS_DOTDOT, MSDOS_NAME)) {
-                       *i_pos = fat_make_i_pos(dir->i_sb, *bh, *de);
+               if (!strncmp((*de)->name, MSDOS_DOTDOT, MSDOS_NAME))
                        return 0;
-               }
        }
        return -ENOENT;
 }
index fb95939ff870f6dd2e3c6ad5cbfe039f243e575d..ec54c3a7f2f7fbf08541daf1d64dd831e5041739 100644 (file)
@@ -5,6 +5,7 @@
 #include <linux/string.h>
 #include <linux/nls.h>
 #include <linux/fs.h>
+#include <linux/hash.h>
 #include <linux/mutex.h>
 #include <linux/ratelimit.h>
 #include <linux/msdos_fs.h>
@@ -46,7 +47,8 @@ struct fat_mount_options {
                 usefree:1,       /* Use free_clusters for FAT32 */
                 tz_utc:1,        /* Filesystem timestamps are in UTC */
                 rodir:1,         /* allow ATTR_RO for directory */
-                discard:1;       /* Issue discard requests on deletions */
+                discard:1,       /* Issue discard requests on deletions */
+                nfs:1;           /* Do extra work needed for NFS export */
 };
 
 #define FAT_HASH_BITS  8
@@ -88,6 +90,9 @@ struct msdos_sb_info {
 
        spinlock_t inode_hash_lock;
        struct hlist_head inode_hashtable[FAT_HASH_SIZE];
+
+       spinlock_t dir_hash_lock;
+       struct hlist_head dir_hashtable[FAT_HASH_SIZE];
 };
 
 #define FAT_CACHE_VALID        0       /* special case for valid cache */
@@ -110,6 +115,7 @@ struct msdos_inode_info {
        int i_attrs;            /* unused attribute bits */
        loff_t i_pos;           /* on-disk position of directory entry or 0 */
        struct hlist_node i_fat_hash;   /* hash by i_location */
+       struct hlist_node i_dir_hash;   /* hash by i_logstart */
        struct rw_semaphore truncate_lock; /* protect bmap against truncate */
        struct inode vfs_inode;
 };
@@ -262,7 +268,7 @@ extern int fat_subdirs(struct inode *dir);
 extern int fat_scan(struct inode *dir, const unsigned char *name,
                    struct fat_slot_info *sinfo);
 extern int fat_get_dotdot_entry(struct inode *dir, struct buffer_head **bh,
-                               struct msdos_dir_entry **de, loff_t *i_pos);
+                               struct msdos_dir_entry **de);
 extern int fat_alloc_new_dir(struct inode *dir, struct timespec *ts);
 extern int fat_add_entries(struct inode *dir, void *slots, int nr_slots,
                           struct fat_slot_info *sinfo);
@@ -341,18 +347,9 @@ extern int fat_fill_super(struct super_block *sb, void *data, int silent,
 
 extern int fat_flush_inodes(struct super_block *sb, struct inode *i1,
                            struct inode *i2);
-static inline loff_t fat_i_pos_read(struct msdos_sb_info *sbi,
-                                   struct inode *inode)
+static inline unsigned long fat_dir_hash(int logstart)
 {
-       loff_t i_pos;
-#if BITS_PER_LONG == 32
-       spin_lock(&sbi->inode_hash_lock);
-#endif
-       i_pos = MSDOS_I(inode)->i_pos;
-#if BITS_PER_LONG == 32
-       spin_unlock(&sbi->inode_hash_lock);
-#endif
-       return i_pos;
+       return hash_32(logstart, FAT_HASH_BITS);
 }
 
 /* fat/misc.c */
@@ -382,10 +379,10 @@ void fat_cache_destroy(void);
 
 /* fat/nfs.c */
 struct fid;
-extern int fat_encode_fh(struct inode *inode, __u32 *fh, int *lenp,
-                        struct inode *parent);
 extern struct dentry *fat_fh_to_dentry(struct super_block *sb, struct fid *fid,
                                       int fh_len, int fh_type);
+extern struct dentry *fat_fh_to_parent(struct super_block *sb, struct fid *fid,
+                                      int fh_len, int fh_type);
 extern struct dentry *fat_get_parent(struct dentry *child_dir);
 
 /* helper for printk */
index 169f6ebddf96bc7f71befe452d86427b4c2be032..5741b11650f15ae6ab1377ee32bf4cb60bd03aa2 100644 (file)
@@ -281,15 +281,42 @@ static inline unsigned long fat_hash(loff_t i_pos)
        return hash_32(i_pos, FAT_HASH_BITS);
 }
 
+static void dir_hash_init(struct super_block *sb)
+{
+       struct msdos_sb_info *sbi = MSDOS_SB(sb);
+       int i;
+
+       spin_lock_init(&sbi->dir_hash_lock);
+       for (i = 0; i < FAT_HASH_SIZE; i++)
+               INIT_HLIST_HEAD(&sbi->dir_hashtable[i]);
+}
+
 void fat_attach(struct inode *inode, loff_t i_pos)
 {
        struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
-       struct hlist_head *head = sbi->inode_hashtable + fat_hash(i_pos);
 
-       spin_lock(&sbi->inode_hash_lock);
-       MSDOS_I(inode)->i_pos = i_pos;
-       hlist_add_head(&MSDOS_I(inode)->i_fat_hash, head);
-       spin_unlock(&sbi->inode_hash_lock);
+       if (inode->i_ino != MSDOS_ROOT_INO) {
+               struct hlist_head *head =   sbi->inode_hashtable
+                                         + fat_hash(i_pos);
+
+               spin_lock(&sbi->inode_hash_lock);
+               MSDOS_I(inode)->i_pos = i_pos;
+               hlist_add_head(&MSDOS_I(inode)->i_fat_hash, head);
+               spin_unlock(&sbi->inode_hash_lock);
+       }
+
+       /* If NFS support is enabled, cache the mapping of start cluster
+        * to directory inode. This is used during reconnection of
+        * dentries to the filesystem root.
+        */
+       if (S_ISDIR(inode->i_mode) && sbi->options.nfs) {
+               struct hlist_head *d_head = sbi->dir_hashtable;
+               d_head += fat_dir_hash(MSDOS_I(inode)->i_logstart);
+
+               spin_lock(&sbi->dir_hash_lock);
+               hlist_add_head(&MSDOS_I(inode)->i_dir_hash, d_head);
+               spin_unlock(&sbi->dir_hash_lock);
+       }
 }
 EXPORT_SYMBOL_GPL(fat_attach);
 
@@ -300,6 +327,12 @@ void fat_detach(struct inode *inode)
        MSDOS_I(inode)->i_pos = 0;
        hlist_del_init(&MSDOS_I(inode)->i_fat_hash);
        spin_unlock(&sbi->inode_hash_lock);
+
+       if (S_ISDIR(inode->i_mode) && sbi->options.nfs) {
+               spin_lock(&sbi->dir_hash_lock);
+               hlist_del_init(&MSDOS_I(inode)->i_dir_hash);
+               spin_unlock(&sbi->dir_hash_lock);
+       }
 }
 EXPORT_SYMBOL_GPL(fat_detach);
 
@@ -504,6 +537,7 @@ static void init_once(void *foo)
        ei->cache_valid_id = FAT_CACHE_VALID + 1;
        INIT_LIST_HEAD(&ei->cache_lru);
        INIT_HLIST_NODE(&ei->i_fat_hash);
+       INIT_HLIST_NODE(&ei->i_dir_hash);
        inode_init_once(&ei->vfs_inode);
 }
 
@@ -562,6 +596,20 @@ static int fat_statfs(struct dentry *dentry, struct kstatfs *buf)
        return 0;
 }
 
+static inline loff_t fat_i_pos_read(struct msdos_sb_info *sbi,
+                                   struct inode *inode)
+{
+       loff_t i_pos;
+#if BITS_PER_LONG == 32
+       spin_lock(&sbi->inode_hash_lock);
+#endif
+       i_pos = MSDOS_I(inode)->i_pos;
+#if BITS_PER_LONG == 32
+       spin_unlock(&sbi->inode_hash_lock);
+#endif
+       return i_pos;
+}
+
 static int __fat_write_inode(struct inode *inode, int wait)
 {
        struct super_block *sb = inode->i_sb;
@@ -655,8 +703,8 @@ static const struct super_operations fat_sops = {
 };
 
 static const struct export_operations fat_export_ops = {
-       .encode_fh      = fat_encode_fh,
        .fh_to_dentry   = fat_fh_to_dentry,
+       .fh_to_parent   = fat_fh_to_parent,
        .get_parent     = fat_get_parent,
 };
 
@@ -706,6 +754,8 @@ static int fat_show_options(struct seq_file *m, struct dentry *root)
                seq_puts(m, ",usefree");
        if (opts->quiet)
                seq_puts(m, ",quiet");
+       if (opts->nfs)
+               seq_puts(m, ",nfs");
        if (opts->showexec)
                seq_puts(m, ",showexec");
        if (opts->sys_immutable)
@@ -750,7 +800,7 @@ enum {
        Opt_shortname_winnt, Opt_shortname_mixed, Opt_utf8_no, Opt_utf8_yes,
        Opt_uni_xl_no, Opt_uni_xl_yes, Opt_nonumtail_no, Opt_nonumtail_yes,
        Opt_obsolete, Opt_flush, Opt_tz_utc, Opt_rodir, Opt_err_cont,
-       Opt_err_panic, Opt_err_ro, Opt_discard, Opt_err,
+       Opt_err_panic, Opt_err_ro, Opt_discard, Opt_nfs, Opt_err,
 };
 
 static const match_table_t fat_tokens = {
@@ -779,6 +829,7 @@ static const match_table_t fat_tokens = {
        {Opt_err_panic, "errors=panic"},
        {Opt_err_ro, "errors=remount-ro"},
        {Opt_discard, "discard"},
+       {Opt_nfs, "nfs"},
        {Opt_obsolete, "conv=binary"},
        {Opt_obsolete, "conv=text"},
        {Opt_obsolete, "conv=auto"},
@@ -859,6 +910,7 @@ static int parse_options(struct super_block *sb, char *options, int is_vfat,
        opts->numtail = 1;
        opts->usefree = opts->nocase = 0;
        opts->tz_utc = 0;
+       opts->nfs = 0;
        opts->errors = FAT_ERRORS_RO;
        *debug = 0;
 
@@ -1023,6 +1075,9 @@ static int parse_options(struct super_block *sb, char *options, int is_vfat,
                case Opt_discard:
                        opts->discard = 1;
                        break;
+               case Opt_nfs:
+                       opts->nfs = 1;
+                       break;
 
                /* obsolete mount options */
                case Opt_obsolete:
@@ -1313,6 +1368,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
 
        /* set up enough so that it can read an inode */
        fat_hash_init(sb);
+       dir_hash_init(sb);
        fat_ent_access_init(sb);
 
        /*
@@ -1367,6 +1423,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
        }
        error = -ENOMEM;
        insert_inode_hash(root_inode);
+       fat_attach(root_inode, 0);
        sb->s_root = d_make_root(root_inode);
        if (!sb->s_root) {
                fat_msg(sb, KERN_ERR, "get root inode failed");
index b0e12bf9f4a1c0fc32dc42facffaf84ff75fe880..c27c630202929b2101ac6254ef7952fab58cd3d5 100644 (file)
@@ -440,7 +440,7 @@ static int do_msdos_rename(struct inode *old_dir, unsigned char *old_name,
        struct inode *old_inode, *new_inode;
        struct fat_slot_info old_sinfo, sinfo;
        struct timespec ts;
-       loff_t dotdot_i_pos, new_i_pos;
+       loff_t new_i_pos;
        int err, old_attrs, is_dir, update_dotdot, corrupt = 0;
 
        old_sinfo.bh = sinfo.bh = dotdot_bh = NULL;
@@ -456,8 +456,7 @@ static int do_msdos_rename(struct inode *old_dir, unsigned char *old_name,
        is_dir = S_ISDIR(old_inode->i_mode);
        update_dotdot = (is_dir && old_dir != new_dir);
        if (update_dotdot) {
-               if (fat_get_dotdot_entry(old_inode, &dotdot_bh, &dotdot_de,
-                                        &dotdot_i_pos) < 0) {
+               if (fat_get_dotdot_entry(old_inode, &dotdot_bh, &dotdot_de)) {
                        err = -EIO;
                        goto out;
                }
index 6a6d8c0715a1c16daf2b1ac53e8d461eb2253810..e535dd75b986779f8910831c8bafba44ab2a5e71 100644 (file)
@@ -914,7 +914,7 @@ static int vfat_rename(struct inode *old_dir, struct dentry *old_dentry,
        struct inode *old_inode, *new_inode;
        struct fat_slot_info old_sinfo, sinfo;
        struct timespec ts;
-       loff_t dotdot_i_pos, new_i_pos;
+       loff_t new_i_pos;
        int err, is_dir, update_dotdot, corrupt = 0;
        struct super_block *sb = old_dir->i_sb;
 
@@ -929,8 +929,7 @@ static int vfat_rename(struct inode *old_dir, struct dentry *old_dentry,
        is_dir = S_ISDIR(old_inode->i_mode);
        update_dotdot = (is_dir && old_dir != new_dir);
        if (update_dotdot) {
-               if (fat_get_dotdot_entry(old_inode, &dotdot_bh, &dotdot_de,
-                                        &dotdot_i_pos) < 0) {
+               if (fat_get_dotdot_entry(old_inode, &dotdot_bh, &dotdot_de)) {
                        err = -EIO;
                        goto out;
                }
index 21609a1e9355cca8d1bb6a8cd31d626d4a3008ab..ef4b5faba87b20f3c8620d222fb33b79b7e80434 100644 (file)
 #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);
 }