1 files changed, 45 insertions, 27 deletions

diff --git a/fs/fat/file.c b/fs/fat/file.c
index e8c159de236b..7257752b6d5d 100644
--- a/fs/fat/file.c
+++ b/fs/fat/file.c
@@ -8,6 +8,7 @@
 
 #include <linux/capability.h>
 #include <linux/module.h>
+#include <linux/compat.h>
 #include <linux/mount.h>
 #include <linux/time.h>
 #include <linux/buffer_head.h>
@@ -114,9 +115,9 @@ out:
         return err;
 }
 
-int fat_generic_ioctl(struct inode *inode, struct file *filp,
-                      unsigned int cmd, unsigned long arg)
+long fat_generic_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
+        struct inode *inode = filp->f_path.dentry->d_inode;
         u32 __user *user_attr = (u32 __user *)arg;
 
         switch (cmd) {
@@ -129,6 +130,15 @@ int fat_generic_ioctl(struct inode *inode, struct file *filp,
         }
 }
 
+#ifdef CONFIG_COMPAT
+static long fat_generic_compat_ioctl(struct file *filp, unsigned int cmd,
+                                      unsigned long arg)
+
+{
+        return fat_generic_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
+}
+#endif
+
 static int fat_file_release(struct inode *inode, struct file *filp)
 {
         if ((filp->f_mode & FMODE_WRITE) &&
@@ -139,12 +149,12 @@ static int fat_file_release(struct inode *inode, struct file *filp)
         return 0;
 }
 
-int fat_file_fsync(struct file *filp, struct dentry *dentry, int datasync)
+int fat_file_fsync(struct file *filp, int datasync)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = filp->f_mapping->host;
         int res, err;
 
-        res = simple_fsync(filp, dentry, datasync);
+        res = generic_file_fsync(filp, datasync);
         err = sync_mapping_buffers(MSDOS_SB(inode->i_sb)->fat_inode->i_mapping);
 
         return res ? res : err;
@@ -159,7 +169,10 @@ const struct file_operations fat_file_operations = {
         .aio_write      = generic_file_aio_write,
         .mmap           = generic_file_mmap,
         .release        = fat_file_release,
-        .ioctl          = fat_generic_ioctl,
+        .unlocked_ioctl = fat_generic_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl   = fat_generic_compat_ioctl,
+#endif
         .fsync          = fat_file_fsync,
         .splice_read    = generic_file_splice_read,
 };
@@ -270,7 +283,7 @@ static int fat_free(struct inode *inode, int skip)
         return fat_free_clusters(inode, free_start);
 }
 
-void fat_truncate(struct inode *inode)
+void fat_truncate_blocks(struct inode *inode, loff_t offset)
 {
         struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
         const unsigned int cluster_size = sbi->cluster_size;
@@ -280,10 +293,10 @@ void fat_truncate(struct inode *inode)
          * This protects against truncating a file bigger than it was then
          * trying to write into the hole.
          */
-        if (MSDOS_I(inode)->mmu_private > inode->i_size)
-                MSDOS_I(inode)->mmu_private = inode->i_size;
+        if (MSDOS_I(inode)->mmu_private > offset)
+                MSDOS_I(inode)->mmu_private = offset;
 
-        nr_clusters = (inode->i_size + (cluster_size - 1)) >> sbi->cluster_bits;
+        nr_clusters = (offset + (cluster_size - 1)) >> sbi->cluster_bits;
 
         fat_free(inode, nr_clusters);
         fat_flush_inodes(inode->i_sb, inode, NULL);
@@ -362,20 +375,6 @@ int fat_setattr(struct dentry *dentry, struct iattr *attr)
         unsigned int ia_valid;
         int error;
 
-        /*
-         * Expand the file. Since inode_setattr() updates ->i_size
-         * before calling the ->truncate(), but FAT needs to fill the
-         * hole before it.
-         */
-        if (attr->ia_valid & ATTR_SIZE) {
-                if (attr->ia_size > inode->i_size) {
-                        error = fat_cont_expand(inode, attr->ia_size);
-                        if (error || attr->ia_valid == ATTR_SIZE)
-                                goto out;
-                        attr->ia_valid &= ~ATTR_SIZE;
-                }
-        }
-
         /* Check for setting the inode time. */
         ia_valid = attr->ia_valid;
         if (ia_valid & TIMES_SET_FLAGS) {
@@ -391,6 +390,21 @@ int fat_setattr(struct dentry *dentry, struct iattr *attr)
                 goto out;
         }
 
+        /*
+         * Expand the file. Since inode_setattr() updates ->i_size
+         * before calling the ->truncate(), but FAT needs to fill the
+         * hole before it. XXX: this is no longer true with new truncate
+         * sequence.
+         */
+        if (attr->ia_valid & ATTR_SIZE) {
+                if (attr->ia_size > inode->i_size) {
+                        error = fat_cont_expand(inode, attr->ia_size);
+                        if (error || attr->ia_valid == ATTR_SIZE)
+                                goto out;
+                        attr->ia_valid &= ~ATTR_SIZE;
+                }
+        }
+
         if (((attr->ia_valid & ATTR_UID) &&
              (attr->ia_uid != sbi->options.fs_uid)) ||
             ((attr->ia_valid & ATTR_GID) &&
@@ -414,15 +428,19 @@ int fat_setattr(struct dentry *dentry, struct iattr *attr)
                         attr->ia_valid &= ~ATTR_MODE;
         }
 
-        if (attr->ia_valid)
-                error = inode_setattr(inode, attr);
+        if (attr->ia_valid & ATTR_SIZE) {
+                truncate_setsize(inode, attr->ia_size);
+                fat_truncate_blocks(inode, attr->ia_size);
+        }
+
+        setattr_copy(inode, attr);
+        mark_inode_dirty(inode);
 out:
         return error;
 }
 EXPORT_SYMBOL_GPL(fat_setattr);
 
 const struct inode_operations fat_file_inode_operations = {
-        .truncate       = fat_truncate,
         .setattr        = fat_setattr,
         .getattr        = fat_getattr,
 };