Removed lock/unlock super. Added a new private s_lock mutex.
Signed-off-by: Marco Stornelli <marco.stornelli@gmail.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
        int short_len = 0, fill_len = 0;
        int ret = 0;
 
-       lock_super(sb);
+       mutex_lock(&sbi->s_lock);
 
        cpos = filp->f_pos;
        /* Fake . and .. for the root directory. */
        if (unicode)
                __putname(unicode);
 out:
-       unlock_super(sb);
+       mutex_unlock(&sbi->s_lock);
        return ret;
 }
 
 
        unsigned long root_cluster;   /* first cluster of the root directory */
        unsigned long fsinfo_sector;  /* sector number of FAT32 fsinfo */
        struct mutex fat_lock;
-       unsigned int prev_free;       /* previously allocated cluster number */
-       unsigned int free_clusters;   /* -1 if undefined */
+       struct mutex s_lock;
+       unsigned int prev_free;      /* previously allocated cluster number */
+       unsigned int free_clusters;  /* -1 if undefined */
        unsigned int free_clus_valid; /* is free_clusters valid? */
        struct fat_mount_options options;
        struct nls_table *nls_disk;   /* Codepage used on disk */
 
        if (inode->i_ino == MSDOS_FSINFO_INO) {
                struct super_block *sb = inode->i_sb;
 
-               lock_super(sb);
+               mutex_lock(&MSDOS_SB(sb)->s_lock);
                err = fat_clusters_flush(sb);
-               unlock_super(sb);
+               mutex_unlock(&MSDOS_SB(sb)->s_lock);
        } else
                err = __fat_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
 
                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;
 
        struct inode *inode;
        int err;
 
-       lock_super(sb);
+       mutex_lock(&MSDOS_SB(sb)->s_lock);
        err = msdos_find(dir, dentry->d_name.name, dentry->d_name.len, &sinfo);
        switch (err) {
        case -ENOENT:
        default:
                inode = ERR_PTR(err);
        }
-       unlock_super(sb);
+       mutex_unlock(&MSDOS_SB(sb)->s_lock);
        return d_splice_alias(inode, dentry);
 }
 
        unsigned char msdos_name[MSDOS_NAME];
        int err, is_hid;
 
-       lock_super(sb);
+       mutex_lock(&MSDOS_SB(sb)->s_lock);
 
        err = msdos_format_name(dentry->d_name.name, dentry->d_name.len,
                                msdos_name, &MSDOS_SB(sb)->options);
 
        d_instantiate(dentry, inode);
 out:
-       unlock_super(sb);
+       mutex_unlock(&MSDOS_SB(sb)->s_lock);
        if (!err)
                err = fat_flush_inodes(sb, dir, inode);
        return err;
        struct fat_slot_info sinfo;
        int err;
 
-       lock_super(sb);
+       mutex_lock(&MSDOS_SB(sb)->s_lock);
        /*
         * Check whether the directory is not in use, then check
         * whether it is empty.
        inode->i_ctime = CURRENT_TIME_SEC;
        fat_detach(inode);
 out:
-       unlock_super(sb);
+       mutex_unlock(&MSDOS_SB(sb)->s_lock);
        if (!err)
                err = fat_flush_inodes(sb, dir, inode);
 
        struct timespec ts;
        int err, is_hid, cluster;
 
-       lock_super(sb);
+       mutex_lock(&MSDOS_SB(sb)->s_lock);
 
        err = msdos_format_name(dentry->d_name.name, dentry->d_name.len,
                                msdos_name, &MSDOS_SB(sb)->options);
 
        d_instantiate(dentry, inode);
 
-       unlock_super(sb);
+       mutex_unlock(&MSDOS_SB(sb)->s_lock);
        fat_flush_inodes(sb, dir, inode);
        return 0;
 
 out_free:
        fat_free_clusters(dir, cluster);
 out:
-       unlock_super(sb);
+       mutex_unlock(&MSDOS_SB(sb)->s_lock);
        return err;
 }
 
        struct fat_slot_info sinfo;
        int err;
 
-       lock_super(sb);
+       mutex_lock(&MSDOS_SB(sb)->s_lock);
        err = msdos_find(dir, dentry->d_name.name, dentry->d_name.len, &sinfo);
        if (err)
                goto out;
        inode->i_ctime = CURRENT_TIME_SEC;
        fat_detach(inode);
 out:
-       unlock_super(sb);
+       mutex_unlock(&MSDOS_SB(sb)->s_lock);
        if (!err)
                err = fat_flush_inodes(sb, dir, inode);
 
        unsigned char old_msdos_name[MSDOS_NAME], new_msdos_name[MSDOS_NAME];
        int err, is_hid;
 
-       lock_super(sb);
+       mutex_lock(&MSDOS_SB(sb)->s_lock);
 
        err = msdos_format_name(old_dentry->d_name.name,
                                old_dentry->d_name.len, old_msdos_name,
        err = do_msdos_rename(old_dir, old_msdos_name, old_dentry,
                              new_dir, new_msdos_name, new_dentry, is_hid);
 out:
-       unlock_super(sb);
+       mutex_unlock(&MSDOS_SB(sb)->s_lock);
        if (!err)
                err = fat_flush_inodes(sb, old_dir, new_dir);
        return err;
 
        struct dentry *alias;
        int err;
 
-       lock_super(sb);
+       mutex_lock(&MSDOS_SB(sb)->s_lock);
 
        err = vfat_find(dir, &dentry->d_name, &sinfo);
        if (err) {
                if (!S_ISDIR(inode->i_mode))
                        d_move(alias, dentry);
                iput(inode);
-               unlock_super(sb);
+               mutex_unlock(&MSDOS_SB(sb)->s_lock);
                return alias;
        } else
                dput(alias);
 
 out:
-       unlock_super(sb);
+       mutex_unlock(&MSDOS_SB(sb)->s_lock);
        dentry->d_time = dentry->d_parent->d_inode->i_version;
        dentry = d_splice_alias(inode, dentry);
        if (dentry)
        return dentry;
 
 error:
-       unlock_super(sb);
+       mutex_unlock(&MSDOS_SB(sb)->s_lock);
        return ERR_PTR(err);
 }
 
        struct timespec ts;
        int err;
 
-       lock_super(sb);
+       mutex_lock(&MSDOS_SB(sb)->s_lock);
 
        ts = CURRENT_TIME_SEC;
        err = vfat_add_entry(dir, &dentry->d_name, 0, 0, &ts, &sinfo);
        dentry->d_time = dentry->d_parent->d_inode->i_version;
        d_instantiate(dentry, inode);
 out:
-       unlock_super(sb);
+       mutex_unlock(&MSDOS_SB(sb)->s_lock);
        return err;
 }
 
        struct fat_slot_info sinfo;
        int err;
 
-       lock_super(sb);
+       mutex_lock(&MSDOS_SB(sb)->s_lock);
 
        err = fat_dir_empty(inode);
        if (err)
        inode->i_mtime = inode->i_atime = CURRENT_TIME_SEC;
        fat_detach(inode);
 out:
-       unlock_super(sb);
+       mutex_unlock(&MSDOS_SB(sb)->s_lock);
 
        return err;
 }
        struct fat_slot_info sinfo;
        int err;
 
-       lock_super(sb);
+       mutex_lock(&MSDOS_SB(sb)->s_lock);
 
        err = vfat_find(dir, &dentry->d_name, &sinfo);
        if (err)
        inode->i_mtime = inode->i_atime = CURRENT_TIME_SEC;
        fat_detach(inode);
 out:
-       unlock_super(sb);
+       mutex_unlock(&MSDOS_SB(sb)->s_lock);
 
        return err;
 }
        struct timespec ts;
        int err, cluster;
 
-       lock_super(sb);
+       mutex_lock(&MSDOS_SB(sb)->s_lock);
 
        ts = CURRENT_TIME_SEC;
        cluster = fat_alloc_new_dir(dir, &ts);
        dentry->d_time = dentry->d_parent->d_inode->i_version;
        d_instantiate(dentry, inode);
 
-       unlock_super(sb);
+       mutex_unlock(&MSDOS_SB(sb)->s_lock);
        return 0;
 
 out_free:
        fat_free_clusters(dir, cluster);
 out:
-       unlock_super(sb);
+       mutex_unlock(&MSDOS_SB(sb)->s_lock);
        return err;
 }
 
        old_sinfo.bh = sinfo.bh = dotdot_bh = NULL;
        old_inode = old_dentry->d_inode;
        new_inode = new_dentry->d_inode;
-       lock_super(sb);
+       mutex_lock(&MSDOS_SB(sb)->s_lock);
        err = vfat_find(old_dir, &old_dentry->d_name, &old_sinfo);
        if (err)
                goto out;
        brelse(sinfo.bh);
        brelse(dotdot_bh);
        brelse(old_sinfo.bh);
-       unlock_super(sb);
+       mutex_unlock(&MSDOS_SB(sb)->s_lock);
 
        return err;