6 files changed, 169 insertions, 48 deletions

diff --git a/fs/fat/cache.c b/fs/fat/cache.c
index 77c24fcf712..1acc941245f 100644
--- a/fs/fat/cache.c
+++ b/fs/fat/cache.c
@@ -295,7 +295,8 @@ static int fat_bmap_cluster(struct inode *inode, int cluster)
         return dclus;
 }
 
-int fat_bmap(struct inode *inode, sector_t sector, sector_t *phys)
+int fat_bmap(struct inode *inode, sector_t sector, sector_t *phys,
+             unsigned long *mapped_blocks)
 {
         struct super_block *sb = inode->i_sb;
         struct msdos_sb_info *sbi = MSDOS_SB(sb);
@@ -303,9 +304,12 @@ int fat_bmap(struct inode *inode, sector_t sector, sector_t *phys)
         int cluster, offset;
 
         *phys = 0;
+        *mapped_blocks = 0;
         if ((sbi->fat_bits != 32) && (inode->i_ino == MSDOS_ROOT_INO)) {
-                if (sector < (sbi->dir_entries >> sbi->dir_per_block_bits))
+                if (sector < (sbi->dir_entries >> sbi->dir_per_block_bits)) {
                         *phys = sector + sbi->dir_start;
+                        *mapped_blocks = 1;
+                }
                 return 0;
         }
         last_block = (MSDOS_I(inode)->mmu_private + (sb->s_blocksize - 1))
@@ -318,7 +322,11 @@ int fat_bmap(struct inode *inode, sector_t sector, sector_t *phys)
         cluster = fat_bmap_cluster(inode, cluster);
         if (cluster < 0)
                 return cluster;
-        else if (cluster)
+        else if (cluster) {
                 *phys = fat_clus_to_blknr(sbi, cluster) + offset;
+                *mapped_blocks = sbi->sec_per_clus - offset;
+                if (*mapped_blocks > last_block - sector)
+                        *mapped_blocks = last_block - sector;
+        }
         return 0;
 }
diff --git a/fs/fat/dir.c b/fs/fat/dir.c
index ba824964b9b..db0de5c621c 100644
--- a/fs/fat/dir.c
+++ b/fs/fat/dir.c
@@ -45,8 +45,8 @@ static inline void fat_dir_readahead(struct inode *dir, sector_t iblock,
         if ((sbi->fat_bits != 32) && (dir->i_ino == MSDOS_ROOT_INO))
                 return;
 
-        bh = sb_getblk(sb, phys);
-        if (bh && !buffer_uptodate(bh)) {
+        bh = sb_find_get_block(sb, phys);
+        if (bh == NULL || !buffer_uptodate(bh)) {
                 for (sec = 0; sec < sbi->sec_per_clus; sec++)
                         sb_breadahead(sb, phys + sec);
         }
@@ -68,8 +68,8 @@ static int fat__get_entry(struct inode *dir, loff_t *pos,
 {
         struct super_block *sb = dir->i_sb;
         sector_t phys, iblock;
-        int offset;
-        int err;
+        unsigned long mapped_blocks;
+        int err, offset;
 
 next:
         if (*bh)
@@ -77,7 +77,7 @@ next:
 
         *bh = NULL;
         iblock = *pos >> sb->s_blocksize_bits;
-        err = fat_bmap(dir, iblock, &phys);
+        err = fat_bmap(dir, iblock, &phys, &mapped_blocks);
         if (err || !phys)
                 return -1;      /* beyond EOF or error */
 
@@ -418,7 +418,7 @@ EODir:
         return err;
 }
 
-EXPORT_SYMBOL(fat_search_long);
+EXPORT_SYMBOL_GPL(fat_search_long);
 
 struct fat_ioctl_filldir_callback {
         struct dirent __user *dirent;
@@ -729,13 +729,13 @@ static int fat_dir_ioctl(struct inode * inode, struct file * filp,
 
         buf.dirent = d1;
         buf.result = 0;
-        down(&inode->i_sem);
+        mutex_lock(&inode->i_mutex);
         ret = -ENOENT;
         if (!IS_DEADDIR(inode)) {
                 ret = __fat_readdir(inode, filp, &buf, fat_ioctl_filldir,
                                     short_only, both);
         }
-        up(&inode->i_sem);
+        mutex_unlock(&inode->i_mutex);
         if (ret >= 0)
                 ret = buf.result;
         return ret;
@@ -780,7 +780,7 @@ int fat_get_dotdot_entry(struct inode *dir, struct buffer_head **bh,
         return -ENOENT;
 }
 
-EXPORT_SYMBOL(fat_get_dotdot_entry);
+EXPORT_SYMBOL_GPL(fat_get_dotdot_entry);
 
 /* See if directory is empty */
 int fat_dir_empty(struct inode *dir)
@@ -803,7 +803,7 @@ int fat_dir_empty(struct inode *dir)
         return result;
 }
 
-EXPORT_SYMBOL(fat_dir_empty);
+EXPORT_SYMBOL_GPL(fat_dir_empty);
 
 /*
  * fat_subdirs counts the number of sub-directories of dir. It can be run
@@ -849,7 +849,7 @@ int fat_scan(struct inode *dir, const unsigned char *name,
         return -ENOENT;
 }
 
-EXPORT_SYMBOL(fat_scan);
+EXPORT_SYMBOL_GPL(fat_scan);
 
 static int __fat_remove_entries(struct inode *dir, loff_t pos, int nr_slots)
 {
@@ -936,7 +936,7 @@ int fat_remove_entries(struct inode *dir, struct fat_slot_info *sinfo)
         return 0;
 }
 
-EXPORT_SYMBOL(fat_remove_entries);
+EXPORT_SYMBOL_GPL(fat_remove_entries);
 
 static int fat_zeroed_cluster(struct inode *dir, sector_t blknr, int nr_used,
                               struct buffer_head **bhs, int nr_bhs)
@@ -1048,7 +1048,7 @@ error:
         return err;
 }
 
-EXPORT_SYMBOL(fat_alloc_new_dir);
+EXPORT_SYMBOL_GPL(fat_alloc_new_dir);
 
 static int fat_add_new_entries(struct inode *dir, void *slots, int nr_slots,
                                int *nr_cluster, struct msdos_dir_entry **de,
@@ -1264,4 +1264,4 @@ error_remove:
         return err;
 }
 
-EXPORT_SYMBOL(fat_add_entries);
+EXPORT_SYMBOL_GPL(fat_add_entries);
diff --git a/fs/fat/fatent.c b/fs/fat/fatent.c
index 4164cd54c4d..a1a9e045121 100644
--- a/fs/fat/fatent.c
+++ b/fs/fat/fatent.c
@@ -476,6 +476,7 @@ int fat_alloc_clusters(struct inode *inode, int *cluster, int nr_cluster)
                                 sbi->prev_free = entry;
                                 if (sbi->free_clusters != -1)
                                         sbi->free_clusters--;
+                                sb->s_dirt = 1;
 
                                 cluster[idx_clus] = entry;
                                 idx_clus++;
@@ -496,6 +497,7 @@ int fat_alloc_clusters(struct inode *inode, int *cluster, int nr_cluster)
 
         /* Couldn't allocate the free entries */
         sbi->free_clusters = 0;
+        sb->s_dirt = 1;
         err = -ENOSPC;
 
 out:
@@ -509,7 +511,6 @@ out:
         }
         for (i = 0; i < nr_bhs; i++)
                 brelse(bhs[i]);
-        fat_clusters_flush(sb);
 
         if (err && idx_clus)
                 fat_free_clusters(inode, cluster[0]);
@@ -542,8 +543,10 @@ int fat_free_clusters(struct inode *inode, int cluster)
                 }
 
                 ops->ent_put(&fatent, FAT_ENT_FREE);
-                if (sbi->free_clusters != -1)
+                if (sbi->free_clusters != -1) {
                         sbi->free_clusters++;
+                        sb->s_dirt = 1;
+                }
 
                 if (nr_bhs + fatent.nr_bhs > MAX_BUF_PER_PAGE) {
                         if (sb->s_flags & MS_SYNCHRONOUS) {
@@ -578,7 +581,7 @@ error:
         return err;
 }
 
-EXPORT_SYMBOL(fat_free_clusters);
+EXPORT_SYMBOL_GPL(fat_free_clusters);
 
 int fat_count_free_clusters(struct super_block *sb)
 {
@@ -605,6 +608,7 @@ int fat_count_free_clusters(struct super_block *sb)
                 } while (fat_ent_next(sbi, &fatent));
         }
         sbi->free_clusters = free;
+        sb->s_dirt = 1;
         fatent_brelse(&fatent);
 out:
         unlock_fat(sbi);
diff --git a/fs/fat/file.c b/fs/fat/file.c
index 7134403d5be..e99c5a73b39 100644
--- a/fs/fat/file.c
+++ b/fs/fat/file.c
@@ -6,11 +6,13 @@
  *  regular file handling primitives for fat-based filesystems
  */
 
+#include <linux/capability.h>
 #include <linux/module.h>
 #include <linux/time.h>
 #include <linux/msdos_fs.h>
 #include <linux/smp_lock.h>
 #include <linux/buffer_head.h>
+#include <linux/writeback.h>
 
 int fat_generic_ioctl(struct inode *inode, struct file *filp,
                       unsigned int cmd, unsigned long arg)
@@ -40,7 +42,7 @@ int fat_generic_ioctl(struct inode *inode, struct file *filp,
                 if (err)
                         return err;
 
-                down(&inode->i_sem);
+                mutex_lock(&inode->i_mutex);
 
                 if (IS_RDONLY(inode)) {
                         err = -EROFS;
@@ -102,7 +104,7 @@ int fat_generic_ioctl(struct inode *inode, struct file *filp,
                 MSDOS_I(inode)->i_attrs = attr & ATTR_UNUSED;
                 mark_inode_dirty(inode);
         up:
-                up(&inode->i_sem);
+                mutex_unlock(&inode->i_mutex);
                 return err;
         }
         default:
@@ -124,6 +126,24 @@ struct file_operations fat_file_operations = {
         .sendfile       = generic_file_sendfile,
 };
 
+static int fat_cont_expand(struct inode *inode, loff_t size)
+{
+        struct address_space *mapping = inode->i_mapping;
+        loff_t start = inode->i_size, count = size - inode->i_size;
+        int err;
+
+        err = generic_cont_expand_simple(inode, size);
+        if (err)
+                goto out;
+
+        inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
+        mark_inode_dirty(inode);
+        if (IS_SYNC(inode))
+                err = sync_page_range_nolock(inode, mapping, start, count);
+out:
+        return err;
+}
+
 int fat_notify_change(struct dentry *dentry, struct iattr *attr)
 {
         struct msdos_sb_info *sbi = MSDOS_SB(dentry->d_sb);
@@ -132,11 +152,17 @@ int fat_notify_change(struct dentry *dentry, struct iattr *attr)
 
         lock_kernel();
 
-        /* FAT cannot truncate to a longer file */
+        /*
+         * 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 = -EPERM;
-                        goto out;
+                        error = fat_cont_expand(inode, attr->ia_size);
+                        if (error || attr->ia_valid == ATTR_SIZE)
+                                goto out;
+                        attr->ia_valid &= ~ATTR_SIZE;
                 }
         }
 
@@ -173,7 +199,7 @@ out:
         return error;
 }
 
-EXPORT_SYMBOL(fat_notify_change);
+EXPORT_SYMBOL_GPL(fat_notify_change);
 
 /* Free all clusters after the skip'th cluster. */
 static int fat_free(struct inode *inode, int skip)
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index a0f9b9fe130..e7f4aa7fc68 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -18,10 +18,12 @@
 #include <linux/seq_file.h>
 #include <linux/msdos_fs.h>
 #include <linux/pagemap.h>
+#include <linux/mpage.h>
 #include <linux/buffer_head.h>
 #include <linux/mount.h>
 #include <linux/vfs.h>
 #include <linux/parser.h>
+#include <linux/uio.h>
 #include <asm/unaligned.h>
 
 #ifndef CONFIG_FAT_DEFAULT_IOCHARSET
@@ -48,51 +50,97 @@ static int fat_add_cluster(struct inode *inode)
         return err;
 }
 
-static int fat_get_block(struct inode *inode, sector_t iblock,
-                         struct buffer_head *bh_result, int create)
+static int __fat_get_blocks(struct inode *inode, sector_t iblock,
+                            unsigned long *max_blocks,
+                            struct buffer_head *bh_result, int create)
 {
         struct super_block *sb = inode->i_sb;
+        struct msdos_sb_info *sbi = MSDOS_SB(sb);
         sector_t phys;
-        int err;
+        unsigned long mapped_blocks;
+        int err, offset;
 
-        err = fat_bmap(inode, iblock, &phys);
+        err = fat_bmap(inode, iblock, &phys, &mapped_blocks);
         if (err)
                 return err;
         if (phys) {
                 map_bh(bh_result, sb, phys);
+                *max_blocks = min(mapped_blocks, *max_blocks);
                 return 0;
         }
         if (!create)
                 return 0;
+
         if (iblock != MSDOS_I(inode)->mmu_private >> sb->s_blocksize_bits) {
                 fat_fs_panic(sb, "corrupted file size (i_pos %lld, %lld)",
                              MSDOS_I(inode)->i_pos, MSDOS_I(inode)->mmu_private);
                 return -EIO;
         }
-        if (!((unsigned long)iblock & (MSDOS_SB(sb)->sec_per_clus - 1))) {
+
+        offset = (unsigned long)iblock & (sbi->sec_per_clus - 1);
+        if (!offset) {
+                /* TODO: multiple cluster allocation would be desirable. */
                 err = fat_add_cluster(inode);
                 if (err)
                         return err;
         }
-        MSDOS_I(inode)->mmu_private += sb->s_blocksize;
-        err = fat_bmap(inode, iblock, &phys);
+        /* available blocks on this cluster */
+        mapped_blocks = sbi->sec_per_clus - offset;
+
+        *max_blocks = min(mapped_blocks, *max_blocks);
+        MSDOS_I(inode)->mmu_private += *max_blocks << sb->s_blocksize_bits;
+
+        err = fat_bmap(inode, iblock, &phys, &mapped_blocks);
         if (err)
                 return err;
-        if (!phys)
-                BUG();
+        BUG_ON(!phys);
+        BUG_ON(*max_blocks != mapped_blocks);
         set_buffer_new(bh_result);
         map_bh(bh_result, sb, phys);
         return 0;
 }
 
+static int fat_get_blocks(struct inode *inode, sector_t iblock,
+                          unsigned long max_blocks,
+                          struct buffer_head *bh_result, int create)
+{
+        struct super_block *sb = inode->i_sb;
+        int err;
+
+        err = __fat_get_blocks(inode, iblock, &max_blocks, bh_result, create);
+        if (err)
+                return err;
+        bh_result->b_size = max_blocks << sb->s_blocksize_bits;
+        return 0;
+}
+
+static int fat_get_block(struct inode *inode, sector_t iblock,
+                         struct buffer_head *bh_result, int create)
+{
+        unsigned long max_blocks = 1;
+        return __fat_get_blocks(inode, iblock, &max_blocks, bh_result, create);
+}
+
 static int fat_writepage(struct page *page, struct writeback_control *wbc)
 {
         return block_write_full_page(page, fat_get_block, wbc);
 }
 
+static int fat_writepages(struct address_space *mapping,
+                          struct writeback_control *wbc)
+{
+        return mpage_writepages(mapping, wbc, fat_get_block);
+}
+
 static int fat_readpage(struct file *file, struct page *page)
 {
-        return block_read_full_page(page, fat_get_block);
+        return mpage_readpage(page, fat_get_block);
+}
+
+static int fat_readpages(struct file *file, struct address_space *mapping,
+                         struct list_head *pages, unsigned nr_pages)
+{
+        return mpage_readpages(mapping, pages, nr_pages, fat_get_block);
 }
 
 static int fat_prepare_write(struct file *file, struct page *page,
@@ -115,6 +163,34 @@ static int fat_commit_write(struct file *file, struct page *page,
         return err;
 }
 
+static ssize_t fat_direct_IO(int rw, struct kiocb *iocb,
+                             const struct iovec *iov,
+                             loff_t offset, unsigned long nr_segs)
+{
+        struct file *file = iocb->ki_filp;
+        struct inode *inode = file->f_mapping->host;
+
+        if (rw == WRITE) {
+                /*
+                 * FIXME: blockdev_direct_IO() doesn't use ->prepare_write(),
+                 * so we need to update the ->mmu_private to block boundary.
+                 *
+                 * But we must fill the remaining area or hole by nul for
+                 * updating ->mmu_private.
+                 */
+                loff_t size = offset + iov_length(iov, nr_segs);
+                if (MSDOS_I(inode)->mmu_private < size)
+                        return -EINVAL;
+        }
+
+        /*
+         * FAT need to use the DIO_LOCKING for avoiding the race
+         * condition of fat_get_block() and ->truncate().
+         */
+        return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
+                                  offset, nr_segs, fat_get_blocks, NULL);
+}
+
 static sector_t _fat_bmap(struct address_space *mapping, sector_t block)
 {
         return generic_block_bmap(mapping, block, fat_get_block);
@@ -122,10 +198,13 @@ static sector_t _fat_bmap(struct address_space *mapping, sector_t block)
 
 static struct address_space_operations fat_aops = {
         .readpage       = fat_readpage,
+        .readpages      = fat_readpages,
         .writepage      = fat_writepage,
+        .writepages     = fat_writepages,
         .sync_page      = block_sync_page,
         .prepare_write  = fat_prepare_write,
         .commit_write   = fat_commit_write,
+        .direct_IO      = fat_direct_IO,
         .bmap           = _fat_bmap
 };
 
@@ -182,7 +261,7 @@ void fat_attach(struct inode *inode, loff_t i_pos)
         spin_unlock(&sbi->inode_hash_lock);
 }
 
-EXPORT_SYMBOL(fat_attach);
+EXPORT_SYMBOL_GPL(fat_attach);
 
 void fat_detach(struct inode *inode)
 {
@@ -193,7 +272,7 @@ void fat_detach(struct inode *inode)
         spin_unlock(&sbi->inode_hash_lock);
 }
 
-EXPORT_SYMBOL(fat_detach);
+EXPORT_SYMBOL_GPL(fat_detach);
 
 struct inode *fat_iget(struct super_block *sb, loff_t i_pos)
 {
@@ -347,7 +426,7 @@ out:
         return inode;
 }
 
-EXPORT_SYMBOL(fat_build_inode);
+EXPORT_SYMBOL_GPL(fat_build_inode);
 
 static void fat_delete_inode(struct inode *inode)
 {
@@ -374,12 +453,17 @@ static void fat_clear_inode(struct inode *inode)
         unlock_kernel();
 }
 
-static void fat_put_super(struct super_block *sb)
+static void fat_write_super(struct super_block *sb)
 {
-        struct msdos_sb_info *sbi = MSDOS_SB(sb);
+        sb->s_dirt = 0;
 
         if (!(sb->s_flags & MS_RDONLY))
                 fat_clusters_flush(sb);
+}
+
+static void fat_put_super(struct super_block *sb)
+{
+        struct msdos_sb_info *sbi = MSDOS_SB(sb);
 
         if (sbi->nls_disk) {
                 unload_nls(sbi->nls_disk);
@@ -537,7 +621,7 @@ int fat_sync_inode(struct inode *inode)
         return fat_write_inode(inode, 1);
 }
 
-EXPORT_SYMBOL(fat_sync_inode);
+EXPORT_SYMBOL_GPL(fat_sync_inode);
 
 static int fat_show_options(struct seq_file *m, struct vfsmount *mnt);
 static struct super_operations fat_sops = {
@@ -546,6 +630,7 @@ static struct super_operations fat_sops = {
         .write_inode    = fat_write_inode,
         .delete_inode   = fat_delete_inode,
         .put_super      = fat_put_super,
+        .write_super    = fat_write_super,
         .statfs         = fat_statfs,
         .clear_inode    = fat_clear_inode,
         .remount_fs     = fat_remount,
@@ -1347,7 +1432,7 @@ out_fail:
         return error;
 }
 
-EXPORT_SYMBOL(fat_fill_super);
+EXPORT_SYMBOL_GPL(fat_fill_super);
 
 int __init fat_cache_init(void);
 void fat_cache_destroy(void);
diff --git a/fs/fat/misc.c b/fs/fat/misc.c
index 2a0df2122f5..32fb0a3f1da 100644
--- a/fs/fat/misc.c
+++ b/fs/fat/misc.c
@@ -33,7 +33,7 @@ void fat_fs_panic(struct super_block *s, const char *fmt, ...)
         }
 }
 
-EXPORT_SYMBOL(fat_fs_panic);
+EXPORT_SYMBOL_GPL(fat_fs_panic);
 
 /* Flushes the number of free clusters on FAT32 */
 /* XXX: Need to write one per FSINFO block.  Currently only writes 1 */
@@ -67,8 +67,6 @@ void fat_clusters_flush(struct super_block *sb)
                 if (sbi->prev_free != -1)
                         fsinfo->next_cluster = cpu_to_le32(sbi->prev_free);
                 mark_buffer_dirty(bh);
-                if (sb->s_flags & MS_SYNCHRONOUS)
-                        sync_dirty_buffer(bh);
         }
         brelse(bh);
 }
@@ -194,7 +192,7 @@ void fat_date_unix2dos(int unix_date, __le16 *time, __le16 *date)
         *date = cpu_to_le16(nl_day-day_n[month-1]+1+(month << 5)+(year << 9));
 }
 
-EXPORT_SYMBOL(fat_date_unix2dos);
+EXPORT_SYMBOL_GPL(fat_date_unix2dos);
 
 int fat_sync_bhs(struct buffer_head **bhs, int nr_bhs)
 {
@@ -222,4 +220,4 @@ int fat_sync_bhs(struct buffer_head **bhs, int nr_bhs)
         return err;
 }
 
-EXPORT_SYMBOL(fat_sync_bhs);
+EXPORT_SYMBOL_GPL(fat_sync_bhs);