fat: mark fs as dirty on mount and clean on umount

[~andy/linux] / fs / fat / inode.c

diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index 4b4d4ef910f39692425381f945d483fa487a3e8e..780e2080634644763b7020382de7ec807b3ee69e 100644 (file)
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -488,10 +488,59 @@ static void fat_evict_inode(struct inode *inode)
        fat_detach(inode);
 }
 
+static void fat_set_state(struct super_block *sb,
+                       unsigned int set, unsigned int force)
+{
+       struct buffer_head *bh;
+       struct fat_boot_sector *b;
+       struct msdos_sb_info *sbi = sb->s_fs_info;
+
+       /* do not change any thing if mounted read only */
+       if ((sb->s_flags & MS_RDONLY) && !force)
+               return;
+
+       /* do not change state if fs was dirty */
+       if (sbi->dirty) {
+               /* warn only on set (mount). */
+               if (set)
+                       fat_msg(sb, KERN_WARNING, "Volume was not properly "
+                               "unmounted. Some data may be corrupt. "
+                               "Please run fsck.");
+               return;
+       }
+
+       bh = sb_bread(sb, 0);
+       if (bh == NULL) {
+               fat_msg(sb, KERN_ERR, "unable to read boot sector "
+                       "to mark fs as dirty");
+               return;
+       }
+
+       b = (struct fat_boot_sector *) bh->b_data;
+
+       if (sbi->fat_bits == 32) {
+               if (set)
+                       b->fat32.state |= FAT_STATE_DIRTY;
+               else
+                       b->fat32.state &= ~FAT_STATE_DIRTY;
+       } else /* fat 16 and 12 */ {
+               if (set)
+                       b->fat16.state |= FAT_STATE_DIRTY;
+               else
+                       b->fat16.state &= ~FAT_STATE_DIRTY;
+       }
+
+       mark_buffer_dirty(bh);
+       sync_dirty_buffer(bh);
+       brelse(bh);
+}
+
 static void fat_put_super(struct super_block *sb)
 {
        struct msdos_sb_info *sbi = MSDOS_SB(sb);
 
+       fat_set_state(sb, 0, 0);
+
        iput(sbi->fsinfo_inode);
        iput(sbi->fat_inode);
 
@@ -566,8 +615,18 @@ static void __exit fat_destroy_inodecache(void)
 
 static int fat_remount(struct super_block *sb, int *flags, char *data)
 {
+       int new_rdonly;
        struct msdos_sb_info *sbi = MSDOS_SB(sb);
        *flags |= MS_NODIRATIME | (sbi->options.isvfat ? 0 : MS_NOATIME);
+
+       /* make sure we update state on remount. */
+       new_rdonly = *flags & MS_RDONLY;
+       if (new_rdonly != (sb->s_flags & MS_RDONLY)) {
+               if (new_rdonly)
+                       fat_set_state(sb, 0, 0);
+               else
+                       fat_set_state(sb, 1, 1);
+       }
        return 0;
 }
 
@@ -1362,6 +1421,12 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
        if (sbi->fat_bits != 32)
                sbi->fat_bits = (total_clusters > MAX_FAT12) ? 16 : 12;
 
+       /* some OSes set FAT_STATE_DIRTY and clean it on unmount. */
+       if (sbi->fat_bits == 32)
+               sbi->dirty = b->fat32.state & FAT_STATE_DIRTY;
+       else /* fat 16 or 12 */
+               sbi->dirty = b->fat16.state & FAT_STATE_DIRTY;
+
        /* check that FAT table does not overflow */
        fat_clusters = sbi->fat_length * sb->s_blocksize * 8 / sbi->fat_bits;
        total_clusters = min(total_clusters, fat_clusters - FAT_START_ENT);
@@ -1456,6 +1521,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
                                        "the device does not support discard");
        }
 
+       fat_set_state(sb, 1, 0);
        return 0;
 
 out_invalid: