Patched in Tegra support.

1 files changed, 225 insertions, 161 deletions

diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index f8f491677a4..b2eae577b91 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -26,7 +26,6 @@
 #include <linux/writeback.h>
 #include <linux/log2.h>
 #include <linux/hash.h>
-#include <linux/blkdev.h>
 #include <asm/unaligned.h>
 #include "fat.h"
 
@@ -282,42 +281,15 @@ 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);
 
-        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);
-        }
+        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);
 }
 EXPORT_SYMBOL_GPL(fat_attach);
 
@@ -328,12 +300,6 @@ 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);
 
@@ -403,20 +369,25 @@ static int fat_fill_inode(struct inode *inode, struct msdos_dir_entry *de)
                 inode->i_op = sbi->dir_ops;
                 inode->i_fop = &fat_dir_operations;
 
-                MSDOS_I(inode)->i_start = fat_get_start(sbi, de);
+                MSDOS_I(inode)->i_start = le16_to_cpu(de->start);
+                if (sbi->fat_bits == 32)
+                        MSDOS_I(inode)->i_start |= (le16_to_cpu(de->starthi) << 16);
+
                 MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start;
                 error = fat_calc_dir_size(inode);
                 if (error < 0)
                         return error;
                 MSDOS_I(inode)->mmu_private = inode->i_size;
 
-                set_nlink(inode, fat_subdirs(inode));
+                inode->i_nlink = fat_subdirs(inode);
         } else { /* not a directory */
                 inode->i_generation |= 1;
                 inode->i_mode = fat_make_mode(sbi, de->attr,
                         ((sbi->options.showexec && !is_exec(de->name + 8))
                          ? S_IRUGO|S_IWUGO : S_IRWXUGO));
-                MSDOS_I(inode)->i_start = fat_get_start(sbi, de);
+                MSDOS_I(inode)->i_start = le16_to_cpu(de->start);
+                if (sbi->fat_bits == 32)
+                        MSDOS_I(inode)->i_start |= (le16_to_cpu(de->starthi) << 16);
 
                 MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start;
                 inode->i_size = le32_to_cpu(de->size);
@@ -483,16 +454,42 @@ static void fat_evict_inode(struct inode *inode)
                 fat_truncate_blocks(inode, 0);
         }
         invalidate_inode_buffers(inode);
-        clear_inode(inode);
+        end_writeback(inode);
         fat_cache_inval_inode(inode);
         fat_detach(inode);
 }
 
+static void fat_write_super(struct super_block *sb)
+{
+        lock_super(sb);
+        sb->s_dirt = 0;
+
+        if (!(sb->s_flags & MS_RDONLY))
+                fat_clusters_flush(sb);
+        unlock_super(sb);
+}
+
+static int fat_sync_fs(struct super_block *sb, int wait)
+{
+        int err = 0;
+
+        if (sb->s_dirt) {
+                lock_super(sb);
+                sb->s_dirt = 0;
+                err = fat_clusters_flush(sb);
+                unlock_super(sb);
+        }
+
+        return err;
+}
+
 static void fat_put_super(struct super_block *sb)
 {
         struct msdos_sb_info *sbi = MSDOS_SB(sb);
 
-        iput(sbi->fsinfo_inode);
+        if (sb->s_dirt)
+                fat_write_super(sb);
+
         iput(sbi->fat_inode);
 
         unload_nls(sbi->nls_disk);
@@ -521,6 +518,7 @@ static struct inode *fat_alloc_inode(struct super_block *sb)
 static void fat_i_callback(struct rcu_head *head)
 {
         struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(fat_inode_cachep, MSDOS_I(inode));
 }
 
@@ -538,7 +536,6 @@ 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);
 }
 
@@ -556,11 +553,6 @@ static int __init fat_init_inodecache(void)
 
 static void __exit fat_destroy_inodecache(void)
 {
-        /*
-         * Make sure all delayed rcu free inodes are flushed before we
-         * destroy cache.
-         */
-        rcu_barrier();
         kmem_cache_destroy(fat_inode_cachep);
 }
 
@@ -648,7 +640,8 @@ retry:
         else
                 raw_entry->size = cpu_to_le32(inode->i_size);
         raw_entry->attr = fat_make_attrs(inode);
-        fat_set_start(raw_entry, MSDOS_I(inode)->i_logstart);
+        raw_entry->start = cpu_to_le16(MSDOS_I(inode)->i_logstart);
+        raw_entry->starthi = cpu_to_le16(MSDOS_I(inode)->i_logstart >> 16);
         fat_time_unix2fat(sbi, &inode->i_mtime, &raw_entry->time,
                           &raw_entry->date, NULL);
         if (sbi->options.isvfat) {
@@ -669,18 +662,7 @@ retry:
 
 static int fat_write_inode(struct inode *inode, struct writeback_control *wbc)
 {
-        int err;
-
-        if (inode->i_ino == MSDOS_FSINFO_INO) {
-                struct super_block *sb = inode->i_sb;
-
-                mutex_lock(&MSDOS_SB(sb)->s_lock);
-                err = fat_clusters_flush(sb);
-                mutex_unlock(&MSDOS_SB(sb)->s_lock);
-        } else
-                err = __fat_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
-
-        return err;
+        return __fat_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
 }
 
 int fat_sync_inode(struct inode *inode)
@@ -690,44 +672,161 @@ int fat_sync_inode(struct inode *inode)
 
 EXPORT_SYMBOL_GPL(fat_sync_inode);
 
-static int fat_show_options(struct seq_file *m, struct dentry *root);
+static int fat_show_options(struct seq_file *m, struct vfsmount *mnt);
 static const struct super_operations fat_sops = {
         .alloc_inode    = fat_alloc_inode,
         .destroy_inode  = fat_destroy_inode,
         .write_inode    = fat_write_inode,
         .evict_inode    = fat_evict_inode,
         .put_super      = fat_put_super,
+        .write_super    = fat_write_super,
+        .sync_fs        = fat_sync_fs,
         .statfs         = fat_statfs,
         .remount_fs     = fat_remount,
 
         .show_options   = fat_show_options,
 };
 
+/*
+ * 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.
+ */
+
+static 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;
+
+        if (fh_len < 5 || fh_type != 3)
+                return NULL;
+
+        inode = ilookup(sb, fh[0]);
+        if (!inode || inode->i_generation != fh[1]) {
+                if (inode)
+                        iput(inode);
+                inode = NULL;
+        }
+        if (!inode) {
+                loff_t i_pos;
+                int i_logstart = fh[3] & 0x0fffffff;
+
+                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;
+                }
+        }
+
+        /*
+         * 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);
+}
+
+static int
+fat_encode_fh(struct dentry *de, __u32 *fh, int *lenp, int connectable)
+{
+        int len = *lenp;
+        struct inode *inode =  de->d_inode;
+        u32 ipos_h, ipos_m, ipos_l;
+
+        if (len < 5) {
+                *lenp = 5;
+                return 255; /* no room */
+        }
+
+        ipos_h = MSDOS_I(inode)->i_pos >> 8;
+        ipos_m = (MSDOS_I(inode)->i_pos & 0xf0) << 24;
+        ipos_l = (MSDOS_I(inode)->i_pos & 0x0f) << 28;
+        *lenp = 5;
+        fh[0] = inode->i_ino;
+        fh[1] = inode->i_generation;
+        fh[2] = ipos_h;
+        fh[3] = ipos_m | MSDOS_I(inode)->i_logstart;
+        spin_lock(&de->d_lock);
+        fh[4] = ipos_l | MSDOS_I(de->d_parent->d_inode)->i_logstart;
+        spin_unlock(&de->d_lock);
+        return 3;
+}
+
+static struct dentry *fat_get_parent(struct dentry *child)
+{
+        struct super_block *sb = child->d_sb;
+        struct buffer_head *bh;
+        struct msdos_dir_entry *de;
+        loff_t i_pos;
+        struct dentry *parent;
+        struct inode *inode;
+        int err;
+
+        lock_super(sb);
+
+        err = fat_get_dotdot_entry(child->d_inode, &bh, &de, &i_pos);
+        if (err) {
+                parent = ERR_PTR(err);
+                goto out;
+        }
+        inode = fat_build_inode(sb, de, i_pos);
+        brelse(bh);
+
+        parent = d_obtain_alias(inode);
+out:
+        unlock_super(sb);
+
+        return parent;
+}
+
 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,
 };
 
-static int fat_show_options(struct seq_file *m, struct dentry *root)
+static int fat_show_options(struct seq_file *m, struct vfsmount *mnt)
 {
-        struct msdos_sb_info *sbi = MSDOS_SB(root->d_sb);
+        struct msdos_sb_info *sbi = MSDOS_SB(mnt->mnt_sb);
         struct fat_mount_options *opts = &sbi->options;
         int isvfat = opts->isvfat;
 
-        if (!uid_eq(opts->fs_uid, GLOBAL_ROOT_UID))
-                seq_printf(m, ",uid=%u",
-                                from_kuid_munged(&init_user_ns, opts->fs_uid));
-        if (!gid_eq(opts->fs_gid, GLOBAL_ROOT_GID))
-                seq_printf(m, ",gid=%u",
-                                from_kgid_munged(&init_user_ns, opts->fs_gid));
+        if (opts->fs_uid != 0)
+                seq_printf(m, ",uid=%u", opts->fs_uid);
+        if (opts->fs_gid != 0)
+                seq_printf(m, ",gid=%u", opts->fs_gid);
         seq_printf(m, ",fmask=%04o", opts->fs_fmask);
         seq_printf(m, ",dmask=%04o", opts->fs_dmask);
         if (opts->allow_utime)
                 seq_printf(m, ",allow_utime=%04o", opts->allow_utime);
         if (sbi->nls_disk)
-                /* strip "cp" prefix from displayed option */
-                seq_printf(m, ",codepage=%s", &sbi->nls_disk->charset[2]);
+                seq_printf(m, ",codepage=%s", sbi->nls_disk->charset);
         if (isvfat) {
                 if (sbi->nls_io)
                         seq_printf(m, ",iocharset=%s", sbi->nls_io->charset);
@@ -756,8 +855,6 @@ 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)
@@ -779,12 +876,8 @@ static int fat_show_options(struct seq_file *m, struct dentry *root)
         }
         if (opts->flush)
                 seq_puts(m, ",flush");
-        if (opts->tz_set) {
-                if (opts->time_offset)
-                        seq_printf(m, ",time_offset=%d", opts->time_offset);
-                else
-                        seq_puts(m, ",tz=UTC");
-        }
+        if (opts->tz_utc)
+                seq_puts(m, ",tz=UTC");
         if (opts->errors == FAT_ERRORS_CONT)
                 seq_puts(m, ",errors=continue");
         else if (opts->errors == FAT_ERRORS_PANIC)
@@ -805,9 +898,8 @@ enum {
         Opt_charset, Opt_shortname_lower, Opt_shortname_win95,
         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_nfs, Opt_time_offset,
-        Opt_err,
+        Opt_obsolate, Opt_flush, Opt_tz_utc, Opt_rodir, Opt_err_cont,
+        Opt_err_panic, Opt_err_ro, Opt_discard, Opt_err,
 };
 
 static const match_table_t fat_tokens = {
@@ -832,23 +924,21 @@ static const match_table_t fat_tokens = {
         {Opt_immutable, "sys_immutable"},
         {Opt_flush, "flush"},
         {Opt_tz_utc, "tz=UTC"},
-        {Opt_time_offset, "time_offset=%d"},
         {Opt_err_cont, "errors=continue"},
         {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"},
-        {Opt_obsolete, "conv=b"},
-        {Opt_obsolete, "conv=t"},
-        {Opt_obsolete, "conv=a"},
-        {Opt_obsolete, "fat=%u"},
-        {Opt_obsolete, "blocksize=%u"},
-        {Opt_obsolete, "cvf_format=%20s"},
-        {Opt_obsolete, "cvf_options=%100s"},
-        {Opt_obsolete, "posix"},
+        {Opt_obsolate, "conv=binary"},
+        {Opt_obsolate, "conv=text"},
+        {Opt_obsolate, "conv=auto"},
+        {Opt_obsolate, "conv=b"},
+        {Opt_obsolate, "conv=t"},
+        {Opt_obsolate, "conv=a"},
+        {Opt_obsolate, "fat=%u"},
+        {Opt_obsolate, "blocksize=%u"},
+        {Opt_obsolate, "cvf_format=%20s"},
+        {Opt_obsolate, "cvf_options=%100s"},
+        {Opt_obsolate, "posix"},
         {Opt_err, NULL},
 };
 static const match_table_t msdos_tokens = {
@@ -917,8 +1007,7 @@ static int parse_options(struct super_block *sb, char *options, int is_vfat,
         opts->utf8 = opts->unicode_xlate = 0;
         opts->numtail = 1;
         opts->usefree = opts->nocase = 0;
-        opts->tz_set = 0;
-        opts->nfs = 0;
+        opts->tz_utc = 0;
         opts->errors = FAT_ERRORS_RO;
         *debug = 0;
 
@@ -973,57 +1062,44 @@ static int parse_options(struct super_block *sb, char *options, int is_vfat,
                         break;
                 case Opt_uid:
                         if (match_int(&args[0], &option))
-                                return -EINVAL;
-                        opts->fs_uid = make_kuid(current_user_ns(), option);
-                        if (!uid_valid(opts->fs_uid))
-                                return -EINVAL;
+                                return 0;
+                        opts->fs_uid = option;
                         break;
                 case Opt_gid:
                         if (match_int(&args[0], &option))
-                                return -EINVAL;
-                        opts->fs_gid = make_kgid(current_user_ns(), option);
-                        if (!gid_valid(opts->fs_gid))
-                                return -EINVAL;
+                                return 0;
+                        opts->fs_gid = option;
                         break;
                 case Opt_umask:
                         if (match_octal(&args[0], &option))
-                                return -EINVAL;
+                                return 0;
                         opts->fs_fmask = opts->fs_dmask = option;
                         break;
                 case Opt_dmask:
                         if (match_octal(&args[0], &option))
-                                return -EINVAL;
+                                return 0;
                         opts->fs_dmask = option;
                         break;
                 case Opt_fmask:
                         if (match_octal(&args[0], &option))
-                                return -EINVAL;
+                                return 0;
                         opts->fs_fmask = option;
                         break;
                 case Opt_allow_utime:
                         if (match_octal(&args[0], &option))
-                                return -EINVAL;
+                                return 0;
                         opts->allow_utime = option & (S_IWGRP | S_IWOTH);
                         break;
                 case Opt_codepage:
                         if (match_int(&args[0], &option))
-                                return -EINVAL;
+                                return 0;
                         opts->codepage = option;
                         break;
                 case Opt_flush:
                         opts->flush = 1;
                         break;
-                case Opt_time_offset:
-                        if (match_int(&args[0], &option))
-                                return -EINVAL;
-                        if (option < -12 * 60 || option > 12 * 60)
-                                return -EINVAL;
-                        opts->tz_set = 1;
-                        opts->time_offset = option;
-                        break;
                 case Opt_tz_utc:
-                        opts->tz_set = 1;
-                        opts->time_offset = 0;
+                        opts->tz_utc = 1;
                         break;
                 case Opt_err_cont:
                         opts->errors = FAT_ERRORS_CONT;
@@ -1092,12 +1168,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:
+                case Opt_obsolate:
                         fat_msg(sb, KERN_INFO, "\"%s\" option is obsolete, "
                                "not supported now", p);
                         break;
@@ -1160,7 +1233,7 @@ static int fat_read_root(struct inode *inode)
         fat_save_attrs(inode, ATTR_DIR);
         inode->i_mtime.tv_sec = inode->i_atime.tv_sec = inode->i_ctime.tv_sec = 0;
         inode->i_mtime.tv_nsec = inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = 0;
-        set_nlink(inode, fat_subdirs(inode)+2);
+        inode->i_nlink = fat_subdirs(inode)+2;
 
         return 0;
 }
@@ -1172,9 +1245,9 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
                    void (*setup)(struct super_block *))
 {
         struct inode *root_inode = NULL, *fat_inode = NULL;
-        struct inode *fsinfo_inode = NULL;
         struct buffer_head *bh;
         struct fat_boot_sector *b;
+        struct fat_boot_bsx *bsx;
         struct msdos_sb_info *sbi;
         u16 logical_sector_size;
         u32 total_sectors, total_clusters, fat_clusters, rootdir_sectors;
@@ -1285,7 +1358,6 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
                 b = (struct fat_boot_sector *) bh->b_data;
         }
 
-        mutex_init(&sbi->s_lock);
         sbi->cluster_size = sb->s_blocksize * sbi->sec_per_clus;
         sbi->cluster_bits = ffs(sbi->cluster_size) - 1;
         sbi->fats = b->fats;
@@ -1320,6 +1392,8 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
                         goto out_fail;
                 }
 
+                bsx = (struct fat_boot_bsx *)(bh->b_data + FAT32_BSX_OFFSET);
+
                 fsinfo = (struct fat_boot_fsinfo *)fsinfo_bh->b_data;
                 if (!IS_FSINFO(fsinfo)) {
                         fat_msg(sb, KERN_WARNING, "Invalid FSINFO signature: "
@@ -1335,8 +1409,14 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
                 }
 
                 brelse(fsinfo_bh);
+        } else {
+                bsx = (struct fat_boot_bsx *)(bh->b_data + FAT16_BSX_OFFSET);
         }
 
+        /* interpret volume ID as a little endian 32 bit integer */
+        sbi->vol_id = (((u32)bsx->vol_id[0]) | ((u32)bsx->vol_id[1] << 8) |
+                ((u32)bsx->vol_id[2] << 16) | ((u32)bsx->vol_id[3] << 24));
+
         sbi->dir_per_block = sb->s_blocksize / sizeof(struct msdos_dir_entry);
         sbi->dir_per_block_bits = ffs(sbi->dir_per_block) - 1;
 
@@ -1344,7 +1424,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
         sbi->dir_entries = get_unaligned_le16(&b->dir_entries);
         if (sbi->dir_entries & (sbi->dir_per_block - 1)) {
                 if (!silent)
-                        fat_msg(sb, KERN_ERR, "bogus directory-entries per block"
+                        fat_msg(sb, KERN_ERR, "bogus directroy-entries per block"
                                " (%u)", sbi->dir_entries);
                 brelse(bh);
                 goto out_invalid;
@@ -1386,7 +1466,6 @@ 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);
 
         /*
@@ -1421,41 +1500,22 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
                 goto out_fail;
         MSDOS_I(fat_inode)->i_pos = 0;
         sbi->fat_inode = fat_inode;
-
-        fsinfo_inode = new_inode(sb);
-        if (!fsinfo_inode)
-                goto out_fail;
-        fsinfo_inode->i_ino = MSDOS_FSINFO_INO;
-        sbi->fsinfo_inode = fsinfo_inode;
-        insert_inode_hash(fsinfo_inode);
-
         root_inode = new_inode(sb);
         if (!root_inode)
                 goto out_fail;
         root_inode->i_ino = MSDOS_ROOT_INO;
         root_inode->i_version = 1;
         error = fat_read_root(root_inode);
-        if (error < 0) {
-                iput(root_inode);
+        if (error < 0)
                 goto out_fail;
-        }
         error = -ENOMEM;
         insert_inode_hash(root_inode);
-        fat_attach(root_inode, 0);
-        sb->s_root = d_make_root(root_inode);
+        sb->s_root = d_alloc_root(root_inode);
         if (!sb->s_root) {
                 fat_msg(sb, KERN_ERR, "get root inode failed");
                 goto out_fail;
         }
 
-        if (sbi->options.discard) {
-                struct request_queue *q = bdev_get_queue(sb->s_bdev);
-                if (!blk_queue_discard(q))
-                        fat_msg(sb, KERN_WARNING,
-                                        "mounting with \"discard\" option, but "
-                                        "the device does not support discard");
-        }
-
         return 0;
 
 out_invalid:
@@ -1464,10 +1524,10 @@ out_invalid:
                 fat_msg(sb, KERN_INFO, "Can't find a valid FAT filesystem");
 
 out_fail:
-        if (fsinfo_inode)
-                iput(fsinfo_inode);
         if (fat_inode)
                 iput(fat_inode);
+        if (root_inode)
+                iput(root_inode);
         unload_nls(sbi->nls_io);
         unload_nls(sbi->nls_disk);
         if (sbi->options.iocharset != fat_default_iocharset)
@@ -1489,14 +1549,18 @@ static int writeback_inode(struct inode *inode)
 {
 
         int ret;
-
-        /* if we used wait=1, sync_inode_metadata waits for the io for the
-        * inode to finish.  So wait=0 is sent down to sync_inode_metadata
+        struct address_space *mapping = inode->i_mapping;
+        struct writeback_control wbc = {
+               .sync_mode = WB_SYNC_NONE,
+              .nr_to_write = 0,
+        };
+        /* if we used WB_SYNC_ALL, sync_inode waits for the io for the
+        * inode to finish.  So WB_SYNC_NONE is sent down to sync_inode
         * and filemap_fdatawrite is used for the data blocks
         */
-        ret = sync_inode_metadata(inode, 0);
+        ret = sync_inode(inode, &wbc);
         if (!ret)
-                ret = filemap_fdatawrite(inode->i_mapping);
+               ret = filemap_fdatawrite(mapping);
         return ret;
 }