11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * linux/fs/fat/inode.c 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Written 1992,1993 by Werner Almesberger 51da177e4SLinus Torvalds * VFAT extensions by Gordon Chaffee, merged with msdos fs by Henrik Storner 61da177e4SLinus Torvalds * Rewritten for the constant inumbers support by Al Viro 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * Fixes: 91da177e4SLinus Torvalds * 101da177e4SLinus Torvalds * Max Cohan: Fixed invalid FSINFO offset when info_sector is 0 111da177e4SLinus Torvalds */ 121da177e4SLinus Torvalds 131da177e4SLinus Torvalds #include <linux/module.h> 141da177e4SLinus Torvalds #include <linux/init.h> 151da177e4SLinus Torvalds #include <linux/time.h> 161da177e4SLinus Torvalds #include <linux/slab.h> 171da177e4SLinus Torvalds #include <linux/seq_file.h> 181da177e4SLinus Torvalds #include <linux/pagemap.h> 19a5425d29SOGAWA Hirofumi #include <linux/mpage.h> 201da177e4SLinus Torvalds #include <linux/buffer_head.h> 211da177e4SLinus Torvalds #include <linux/mount.h> 22a27bb332SKent Overstreet #include <linux/aio.h> 231da177e4SLinus Torvalds #include <linux/vfs.h> 241da177e4SLinus Torvalds #include <linux/parser.h> 25e5174baaSOGAWA Hirofumi #include <linux/uio.h> 26ae78bf9cSChris Mason #include <linux/writeback.h> 27e7d709c0SVignesh Babu BM #include <linux/log2.h> 28d3dfa822SOGAWA Hirofumi #include <linux/hash.h> 29f562146aSNamjae Jeon #include <linux/blkdev.h> 301da177e4SLinus Torvalds #include <asm/unaligned.h> 319e975daeSOGAWA Hirofumi #include "fat.h" 321da177e4SLinus Torvalds 331da177e4SLinus Torvalds #ifndef CONFIG_FAT_DEFAULT_IOCHARSET 341da177e4SLinus Torvalds /* if user don't select VFAT, this is undefined. */ 351da177e4SLinus Torvalds #define CONFIG_FAT_DEFAULT_IOCHARSET "" 361da177e4SLinus Torvalds #endif 371da177e4SLinus Torvalds 38*190a8843SConrad Meyer #define KB_IN_SECTORS 2 39*190a8843SConrad Meyer 40*190a8843SConrad Meyer /* 41*190a8843SConrad Meyer * A deserialized copy of the on-disk structure laid out in struct 42*190a8843SConrad Meyer * fat_boot_sector. 43*190a8843SConrad Meyer */ 44*190a8843SConrad Meyer struct fat_bios_param_block { 45*190a8843SConrad Meyer u16 fat_sector_size; 46*190a8843SConrad Meyer u8 fat_sec_per_clus; 47*190a8843SConrad Meyer u16 fat_reserved; 48*190a8843SConrad Meyer u8 fat_fats; 49*190a8843SConrad Meyer u16 fat_dir_entries; 50*190a8843SConrad Meyer u16 fat_sectors; 51*190a8843SConrad Meyer u16 fat_fat_length; 52*190a8843SConrad Meyer u32 fat_total_sect; 53*190a8843SConrad Meyer 54*190a8843SConrad Meyer u8 fat16_state; 55*190a8843SConrad Meyer u32 fat16_vol_id; 56*190a8843SConrad Meyer 57*190a8843SConrad Meyer u32 fat32_length; 58*190a8843SConrad Meyer u32 fat32_root_cluster; 59*190a8843SConrad Meyer u16 fat32_info_sector; 60*190a8843SConrad Meyer u8 fat32_state; 61*190a8843SConrad Meyer u32 fat32_vol_id; 62*190a8843SConrad Meyer }; 63*190a8843SConrad Meyer 641da177e4SLinus Torvalds static int fat_default_codepage = CONFIG_FAT_DEFAULT_CODEPAGE; 651da177e4SLinus Torvalds static char fat_default_iocharset[] = CONFIG_FAT_DEFAULT_IOCHARSET; 661da177e4SLinus Torvalds 67*190a8843SConrad Meyer static struct fat_floppy_defaults { 68*190a8843SConrad Meyer unsigned nr_sectors; 69*190a8843SConrad Meyer unsigned sec_per_clus; 70*190a8843SConrad Meyer unsigned dir_entries; 71*190a8843SConrad Meyer unsigned media; 72*190a8843SConrad Meyer unsigned fat_length; 73*190a8843SConrad Meyer } floppy_defaults[] = { 74*190a8843SConrad Meyer { 75*190a8843SConrad Meyer .nr_sectors = 160 * KB_IN_SECTORS, 76*190a8843SConrad Meyer .sec_per_clus = 1, 77*190a8843SConrad Meyer .dir_entries = 64, 78*190a8843SConrad Meyer .media = 0xFE, 79*190a8843SConrad Meyer .fat_length = 1, 80*190a8843SConrad Meyer }, 81*190a8843SConrad Meyer { 82*190a8843SConrad Meyer .nr_sectors = 180 * KB_IN_SECTORS, 83*190a8843SConrad Meyer .sec_per_clus = 1, 84*190a8843SConrad Meyer .dir_entries = 64, 85*190a8843SConrad Meyer .media = 0xFC, 86*190a8843SConrad Meyer .fat_length = 2, 87*190a8843SConrad Meyer }, 88*190a8843SConrad Meyer { 89*190a8843SConrad Meyer .nr_sectors = 320 * KB_IN_SECTORS, 90*190a8843SConrad Meyer .sec_per_clus = 2, 91*190a8843SConrad Meyer .dir_entries = 112, 92*190a8843SConrad Meyer .media = 0xFF, 93*190a8843SConrad Meyer .fat_length = 1, 94*190a8843SConrad Meyer }, 95*190a8843SConrad Meyer { 96*190a8843SConrad Meyer .nr_sectors = 360 * KB_IN_SECTORS, 97*190a8843SConrad Meyer .sec_per_clus = 2, 98*190a8843SConrad Meyer .dir_entries = 112, 99*190a8843SConrad Meyer .media = 0xFD, 100*190a8843SConrad Meyer .fat_length = 2, 101*190a8843SConrad Meyer }, 102*190a8843SConrad Meyer }; 1031da177e4SLinus Torvalds 1041da177e4SLinus Torvalds static int fat_add_cluster(struct inode *inode) 1051da177e4SLinus Torvalds { 1061da177e4SLinus Torvalds int err, cluster; 1071da177e4SLinus Torvalds 1081da177e4SLinus Torvalds err = fat_alloc_clusters(inode, &cluster, 1); 1091da177e4SLinus Torvalds if (err) 1101da177e4SLinus Torvalds return err; 1111da177e4SLinus Torvalds /* FIXME: this cluster should be added after data of this 1121da177e4SLinus Torvalds * cluster is writed */ 1131da177e4SLinus Torvalds err = fat_chain_add(inode, cluster, 1); 1141da177e4SLinus Torvalds if (err) 1151da177e4SLinus Torvalds fat_free_clusters(inode, cluster); 1161da177e4SLinus Torvalds return err; 1171da177e4SLinus Torvalds } 1181da177e4SLinus Torvalds 1196a1d9805SOGAWA Hirofumi static inline int __fat_get_block(struct inode *inode, sector_t iblock, 120e5174baaSOGAWA Hirofumi unsigned long *max_blocks, 1211da177e4SLinus Torvalds struct buffer_head *bh_result, int create) 1221da177e4SLinus Torvalds { 1231da177e4SLinus Torvalds struct super_block *sb = inode->i_sb; 124e5174baaSOGAWA Hirofumi struct msdos_sb_info *sbi = MSDOS_SB(sb); 125e5174baaSOGAWA Hirofumi unsigned long mapped_blocks; 1266a1d9805SOGAWA Hirofumi sector_t phys; 127e5174baaSOGAWA Hirofumi int err, offset; 1281da177e4SLinus Torvalds 1292bdf67ebSOGAWA Hirofumi err = fat_bmap(inode, iblock, &phys, &mapped_blocks, create); 1301da177e4SLinus Torvalds if (err) 1311da177e4SLinus Torvalds return err; 1321da177e4SLinus Torvalds if (phys) { 1331da177e4SLinus Torvalds map_bh(bh_result, sb, phys); 134e5174baaSOGAWA Hirofumi *max_blocks = min(mapped_blocks, *max_blocks); 1351da177e4SLinus Torvalds return 0; 1361da177e4SLinus Torvalds } 1371da177e4SLinus Torvalds if (!create) 1381da177e4SLinus Torvalds return 0; 139e5174baaSOGAWA Hirofumi 1401da177e4SLinus Torvalds if (iblock != MSDOS_I(inode)->mmu_private >> sb->s_blocksize_bits) { 14185c78591SDenis Karpov fat_fs_error(sb, "corrupted file size (i_pos %lld, %lld)", 1421da177e4SLinus Torvalds MSDOS_I(inode)->i_pos, MSDOS_I(inode)->mmu_private); 1431da177e4SLinus Torvalds return -EIO; 1441da177e4SLinus Torvalds } 145e5174baaSOGAWA Hirofumi 146e5174baaSOGAWA Hirofumi offset = (unsigned long)iblock & (sbi->sec_per_clus - 1); 147e5174baaSOGAWA Hirofumi if (!offset) { 148e5174baaSOGAWA Hirofumi /* TODO: multiple cluster allocation would be desirable. */ 1491da177e4SLinus Torvalds err = fat_add_cluster(inode); 1501da177e4SLinus Torvalds if (err) 1511da177e4SLinus Torvalds return err; 1521da177e4SLinus Torvalds } 153e5174baaSOGAWA Hirofumi /* available blocks on this cluster */ 154e5174baaSOGAWA Hirofumi mapped_blocks = sbi->sec_per_clus - offset; 155e5174baaSOGAWA Hirofumi 156e5174baaSOGAWA Hirofumi *max_blocks = min(mapped_blocks, *max_blocks); 157e5174baaSOGAWA Hirofumi MSDOS_I(inode)->mmu_private += *max_blocks << sb->s_blocksize_bits; 158e5174baaSOGAWA Hirofumi 1592bdf67ebSOGAWA Hirofumi err = fat_bmap(inode, iblock, &phys, &mapped_blocks, create); 1601da177e4SLinus Torvalds if (err) 1611da177e4SLinus Torvalds return err; 1626a1d9805SOGAWA Hirofumi 163e5174baaSOGAWA Hirofumi BUG_ON(!phys); 164e5174baaSOGAWA Hirofumi BUG_ON(*max_blocks != mapped_blocks); 1651da177e4SLinus Torvalds set_buffer_new(bh_result); 1661da177e4SLinus Torvalds map_bh(bh_result, sb, phys); 1671da177e4SLinus Torvalds 168e5174baaSOGAWA Hirofumi return 0; 169e5174baaSOGAWA Hirofumi } 170e5174baaSOGAWA Hirofumi 171e5174baaSOGAWA Hirofumi static int fat_get_block(struct inode *inode, sector_t iblock, 172e5174baaSOGAWA Hirofumi struct buffer_head *bh_result, int create) 173e5174baaSOGAWA Hirofumi { 1746a1d9805SOGAWA Hirofumi struct super_block *sb = inode->i_sb; 1756a1d9805SOGAWA Hirofumi unsigned long max_blocks = bh_result->b_size >> inode->i_blkbits; 1766a1d9805SOGAWA Hirofumi int err; 1776a1d9805SOGAWA Hirofumi 1786a1d9805SOGAWA Hirofumi err = __fat_get_block(inode, iblock, &max_blocks, bh_result, create); 1796a1d9805SOGAWA Hirofumi if (err) 1806a1d9805SOGAWA Hirofumi return err; 1816a1d9805SOGAWA Hirofumi bh_result->b_size = max_blocks << sb->s_blocksize_bits; 1826a1d9805SOGAWA Hirofumi return 0; 183e5174baaSOGAWA Hirofumi } 184e5174baaSOGAWA Hirofumi 1851da177e4SLinus Torvalds static int fat_writepage(struct page *page, struct writeback_control *wbc) 1861da177e4SLinus Torvalds { 1871da177e4SLinus Torvalds return block_write_full_page(page, fat_get_block, wbc); 1881da177e4SLinus Torvalds } 1891da177e4SLinus Torvalds 190a5425d29SOGAWA Hirofumi static int fat_writepages(struct address_space *mapping, 191a5425d29SOGAWA Hirofumi struct writeback_control *wbc) 192a5425d29SOGAWA Hirofumi { 193a5425d29SOGAWA Hirofumi return mpage_writepages(mapping, wbc, fat_get_block); 194a5425d29SOGAWA Hirofumi } 195a5425d29SOGAWA Hirofumi 1961da177e4SLinus Torvalds static int fat_readpage(struct file *file, struct page *page) 1971da177e4SLinus Torvalds { 198a5425d29SOGAWA Hirofumi return mpage_readpage(page, fat_get_block); 199a5425d29SOGAWA Hirofumi } 200a5425d29SOGAWA Hirofumi 201a5425d29SOGAWA Hirofumi static int fat_readpages(struct file *file, struct address_space *mapping, 202a5425d29SOGAWA Hirofumi struct list_head *pages, unsigned nr_pages) 203a5425d29SOGAWA Hirofumi { 204a5425d29SOGAWA Hirofumi return mpage_readpages(mapping, pages, nr_pages, fat_get_block); 2051da177e4SLinus Torvalds } 2061da177e4SLinus Torvalds 207459f6ed3Snpiggin@suse.de static void fat_write_failed(struct address_space *mapping, loff_t to) 208459f6ed3Snpiggin@suse.de { 209459f6ed3Snpiggin@suse.de struct inode *inode = mapping->host; 210459f6ed3Snpiggin@suse.de 211459f6ed3Snpiggin@suse.de if (to > inode->i_size) { 2127caef267SKirill A. Shutemov truncate_pagecache(inode, inode->i_size); 213459f6ed3Snpiggin@suse.de fat_truncate_blocks(inode, inode->i_size); 214459f6ed3Snpiggin@suse.de } 215459f6ed3Snpiggin@suse.de } 216459f6ed3Snpiggin@suse.de 217d7777a25SNick Piggin static int fat_write_begin(struct file *file, struct address_space *mapping, 218d7777a25SNick Piggin loff_t pos, unsigned len, unsigned flags, 219d7777a25SNick Piggin struct page **pagep, void **fsdata) 2201da177e4SLinus Torvalds { 221459f6ed3Snpiggin@suse.de int err; 222459f6ed3Snpiggin@suse.de 223d7777a25SNick Piggin *pagep = NULL; 224282dc178SChristoph Hellwig err = cont_write_begin(file, mapping, pos, len, flags, 225459f6ed3Snpiggin@suse.de pagep, fsdata, fat_get_block, 226d7777a25SNick Piggin &MSDOS_I(mapping->host)->mmu_private); 227459f6ed3Snpiggin@suse.de if (err < 0) 228459f6ed3Snpiggin@suse.de fat_write_failed(mapping, pos + len); 229459f6ed3Snpiggin@suse.de return err; 2301da177e4SLinus Torvalds } 2311da177e4SLinus Torvalds 232d7777a25SNick Piggin static int fat_write_end(struct file *file, struct address_space *mapping, 233d7777a25SNick Piggin loff_t pos, unsigned len, unsigned copied, 234d7777a25SNick Piggin struct page *pagep, void *fsdata) 235ef402268SOGAWA Hirofumi { 236d7777a25SNick Piggin struct inode *inode = mapping->host; 237d7777a25SNick Piggin int err; 238d7777a25SNick Piggin err = generic_write_end(file, mapping, pos, len, copied, pagep, fsdata); 239459f6ed3Snpiggin@suse.de if (err < len) 240459f6ed3Snpiggin@suse.de fat_write_failed(mapping, pos + len); 241d7777a25SNick Piggin if (!(err < 0) && !(MSDOS_I(inode)->i_attrs & ATTR_ARCH)) { 242ef402268SOGAWA Hirofumi inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC; 243ef402268SOGAWA Hirofumi MSDOS_I(inode)->i_attrs |= ATTR_ARCH; 244ef402268SOGAWA Hirofumi mark_inode_dirty(inode); 245ef402268SOGAWA Hirofumi } 246ef402268SOGAWA Hirofumi return err; 247ef402268SOGAWA Hirofumi } 248ef402268SOGAWA Hirofumi 249e5174baaSOGAWA Hirofumi static ssize_t fat_direct_IO(int rw, struct kiocb *iocb, 250e5174baaSOGAWA Hirofumi const struct iovec *iov, 251e5174baaSOGAWA Hirofumi loff_t offset, unsigned long nr_segs) 252e5174baaSOGAWA Hirofumi { 253e5174baaSOGAWA Hirofumi struct file *file = iocb->ki_filp; 254459f6ed3Snpiggin@suse.de struct address_space *mapping = file->f_mapping; 255459f6ed3Snpiggin@suse.de struct inode *inode = mapping->host; 256459f6ed3Snpiggin@suse.de ssize_t ret; 257e5174baaSOGAWA Hirofumi 258e5174baaSOGAWA Hirofumi if (rw == WRITE) { 259e5174baaSOGAWA Hirofumi /* 2604e02ed4bSNick Piggin * FIXME: blockdev_direct_IO() doesn't use ->write_begin(), 261e5174baaSOGAWA Hirofumi * so we need to update the ->mmu_private to block boundary. 262e5174baaSOGAWA Hirofumi * 263e5174baaSOGAWA Hirofumi * But we must fill the remaining area or hole by nul for 264e5174baaSOGAWA Hirofumi * updating ->mmu_private. 26594412a96SOGAWA Hirofumi * 26694412a96SOGAWA Hirofumi * Return 0, and fallback to normal buffered write. 267e5174baaSOGAWA Hirofumi */ 268e5174baaSOGAWA Hirofumi loff_t size = offset + iov_length(iov, nr_segs); 269e5174baaSOGAWA Hirofumi if (MSDOS_I(inode)->mmu_private < size) 27094412a96SOGAWA Hirofumi return 0; 271e5174baaSOGAWA Hirofumi } 272e5174baaSOGAWA Hirofumi 273e5174baaSOGAWA Hirofumi /* 274e5174baaSOGAWA Hirofumi * FAT need to use the DIO_LOCKING for avoiding the race 275e5174baaSOGAWA Hirofumi * condition of fat_get_block() and ->truncate(). 276e5174baaSOGAWA Hirofumi */ 277aacfc19cSChristoph Hellwig ret = blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs, 278aacfc19cSChristoph Hellwig fat_get_block); 279459f6ed3Snpiggin@suse.de if (ret < 0 && (rw & WRITE)) 280459f6ed3Snpiggin@suse.de fat_write_failed(mapping, offset + iov_length(iov, nr_segs)); 281459f6ed3Snpiggin@suse.de 282459f6ed3Snpiggin@suse.de return ret; 283e5174baaSOGAWA Hirofumi } 284e5174baaSOGAWA Hirofumi 2851da177e4SLinus Torvalds static sector_t _fat_bmap(struct address_space *mapping, sector_t block) 2861da177e4SLinus Torvalds { 287fa93ca18SOGAWA Hirofumi sector_t blocknr; 288fa93ca18SOGAWA Hirofumi 289fa93ca18SOGAWA Hirofumi /* fat_get_cluster() assumes the requested blocknr isn't truncated. */ 29058268691SChristoph Hellwig down_read(&MSDOS_I(mapping->host)->truncate_lock); 291fa93ca18SOGAWA Hirofumi blocknr = generic_block_bmap(mapping, block, fat_get_block); 29258268691SChristoph Hellwig up_read(&MSDOS_I(mapping->host)->truncate_lock); 293fa93ca18SOGAWA Hirofumi 294fa93ca18SOGAWA Hirofumi return blocknr; 2951da177e4SLinus Torvalds } 2961da177e4SLinus Torvalds 297f5e54d6eSChristoph Hellwig static const struct address_space_operations fat_aops = { 2981da177e4SLinus Torvalds .readpage = fat_readpage, 299a5425d29SOGAWA Hirofumi .readpages = fat_readpages, 3001da177e4SLinus Torvalds .writepage = fat_writepage, 301a5425d29SOGAWA Hirofumi .writepages = fat_writepages, 302d7777a25SNick Piggin .write_begin = fat_write_begin, 303d7777a25SNick Piggin .write_end = fat_write_end, 304e5174baaSOGAWA Hirofumi .direct_IO = fat_direct_IO, 3051da177e4SLinus Torvalds .bmap = _fat_bmap 3061da177e4SLinus Torvalds }; 3071da177e4SLinus Torvalds 3081da177e4SLinus Torvalds /* 3091da177e4SLinus Torvalds * New FAT inode stuff. We do the following: 3101da177e4SLinus Torvalds * a) i_ino is constant and has nothing with on-disk location. 3111da177e4SLinus Torvalds * b) FAT manages its own cache of directory entries. 3121da177e4SLinus Torvalds * c) *This* cache is indexed by on-disk location. 3131da177e4SLinus Torvalds * d) inode has an associated directory entry, all right, but 3141da177e4SLinus Torvalds * it may be unhashed. 3151da177e4SLinus Torvalds * e) currently entries are stored within struct inode. That should 3161da177e4SLinus Torvalds * change. 3171da177e4SLinus Torvalds * f) we deal with races in the following way: 3181da177e4SLinus Torvalds * 1. readdir() and lookup() do FAT-dir-cache lookup. 3191da177e4SLinus Torvalds * 2. rename() unhashes the F-d-c entry and rehashes it in 3201da177e4SLinus Torvalds * a new place. 3211da177e4SLinus Torvalds * 3. unlink() and rmdir() unhash F-d-c entry. 3221da177e4SLinus Torvalds * 4. fat_write_inode() checks whether the thing is unhashed. 3231da177e4SLinus Torvalds * If it is we silently return. If it isn't we do bread(), 3241da177e4SLinus Torvalds * check if the location is still valid and retry if it 3251da177e4SLinus Torvalds * isn't. Otherwise we do changes. 3261da177e4SLinus Torvalds * 5. Spinlock is used to protect hash/unhash/location check/lookup 327deee3ce4SAl Viro * 6. fat_evict_inode() unhashes the F-d-c entry. 3281da177e4SLinus Torvalds * 7. lookup() and readdir() do igrab() if they find a F-d-c entry 3291da177e4SLinus Torvalds * and consider negative result as cache miss. 3301da177e4SLinus Torvalds */ 3311da177e4SLinus Torvalds 3321da177e4SLinus Torvalds static void fat_hash_init(struct super_block *sb) 3331da177e4SLinus Torvalds { 3341da177e4SLinus Torvalds struct msdos_sb_info *sbi = MSDOS_SB(sb); 3351da177e4SLinus Torvalds int i; 3361da177e4SLinus Torvalds 3371da177e4SLinus Torvalds spin_lock_init(&sbi->inode_hash_lock); 3381da177e4SLinus Torvalds for (i = 0; i < FAT_HASH_SIZE; i++) 3391da177e4SLinus Torvalds INIT_HLIST_HEAD(&sbi->inode_hashtable[i]); 3401da177e4SLinus Torvalds } 3411da177e4SLinus Torvalds 342d3dfa822SOGAWA Hirofumi static inline unsigned long fat_hash(loff_t i_pos) 3431da177e4SLinus Torvalds { 344d3dfa822SOGAWA Hirofumi return hash_32(i_pos, FAT_HASH_BITS); 3451da177e4SLinus Torvalds } 3461da177e4SLinus Torvalds 3477669e8fbSSteven J. Magnani static void dir_hash_init(struct super_block *sb) 3487669e8fbSSteven J. Magnani { 3497669e8fbSSteven J. Magnani struct msdos_sb_info *sbi = MSDOS_SB(sb); 3507669e8fbSSteven J. Magnani int i; 3517669e8fbSSteven J. Magnani 3527669e8fbSSteven J. Magnani spin_lock_init(&sbi->dir_hash_lock); 3537669e8fbSSteven J. Magnani for (i = 0; i < FAT_HASH_SIZE; i++) 3547669e8fbSSteven J. Magnani INIT_HLIST_HEAD(&sbi->dir_hashtable[i]); 3557669e8fbSSteven J. Magnani } 3567669e8fbSSteven J. Magnani 3571da177e4SLinus Torvalds void fat_attach(struct inode *inode, loff_t i_pos) 3581da177e4SLinus Torvalds { 359d3dfa822SOGAWA Hirofumi struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb); 3607669e8fbSSteven J. Magnani 3617669e8fbSSteven J. Magnani if (inode->i_ino != MSDOS_ROOT_INO) { 3627669e8fbSSteven J. Magnani struct hlist_head *head = sbi->inode_hashtable 3637669e8fbSSteven J. Magnani + fat_hash(i_pos); 3641da177e4SLinus Torvalds 3651da177e4SLinus Torvalds spin_lock(&sbi->inode_hash_lock); 3661da177e4SLinus Torvalds MSDOS_I(inode)->i_pos = i_pos; 367d3dfa822SOGAWA Hirofumi hlist_add_head(&MSDOS_I(inode)->i_fat_hash, head); 3681da177e4SLinus Torvalds spin_unlock(&sbi->inode_hash_lock); 3691da177e4SLinus Torvalds } 3707669e8fbSSteven J. Magnani 3717669e8fbSSteven J. Magnani /* If NFS support is enabled, cache the mapping of start cluster 3727669e8fbSSteven J. Magnani * to directory inode. This is used during reconnection of 3737669e8fbSSteven J. Magnani * dentries to the filesystem root. 3747669e8fbSSteven J. Magnani */ 3757669e8fbSSteven J. Magnani if (S_ISDIR(inode->i_mode) && sbi->options.nfs) { 3767669e8fbSSteven J. Magnani struct hlist_head *d_head = sbi->dir_hashtable; 3777669e8fbSSteven J. Magnani d_head += fat_dir_hash(MSDOS_I(inode)->i_logstart); 3787669e8fbSSteven J. Magnani 3797669e8fbSSteven J. Magnani spin_lock(&sbi->dir_hash_lock); 3807669e8fbSSteven J. Magnani hlist_add_head(&MSDOS_I(inode)->i_dir_hash, d_head); 3817669e8fbSSteven J. Magnani spin_unlock(&sbi->dir_hash_lock); 3827669e8fbSSteven J. Magnani } 3837669e8fbSSteven J. Magnani } 3847c709d00SOGAWA Hirofumi EXPORT_SYMBOL_GPL(fat_attach); 3851da177e4SLinus Torvalds 3861da177e4SLinus Torvalds void fat_detach(struct inode *inode) 3871da177e4SLinus Torvalds { 3881da177e4SLinus Torvalds struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb); 3891da177e4SLinus Torvalds spin_lock(&sbi->inode_hash_lock); 3901da177e4SLinus Torvalds MSDOS_I(inode)->i_pos = 0; 3911da177e4SLinus Torvalds hlist_del_init(&MSDOS_I(inode)->i_fat_hash); 3921da177e4SLinus Torvalds spin_unlock(&sbi->inode_hash_lock); 3937669e8fbSSteven J. Magnani 3947669e8fbSSteven J. Magnani if (S_ISDIR(inode->i_mode) && sbi->options.nfs) { 3957669e8fbSSteven J. Magnani spin_lock(&sbi->dir_hash_lock); 3967669e8fbSSteven J. Magnani hlist_del_init(&MSDOS_I(inode)->i_dir_hash); 3977669e8fbSSteven J. Magnani spin_unlock(&sbi->dir_hash_lock); 3987669e8fbSSteven J. Magnani } 3991da177e4SLinus Torvalds } 4007c709d00SOGAWA Hirofumi EXPORT_SYMBOL_GPL(fat_detach); 4011da177e4SLinus Torvalds 4021da177e4SLinus Torvalds struct inode *fat_iget(struct super_block *sb, loff_t i_pos) 4031da177e4SLinus Torvalds { 4041da177e4SLinus Torvalds struct msdos_sb_info *sbi = MSDOS_SB(sb); 405d3dfa822SOGAWA Hirofumi struct hlist_head *head = sbi->inode_hashtable + fat_hash(i_pos); 4061da177e4SLinus Torvalds struct msdos_inode_info *i; 4071da177e4SLinus Torvalds struct inode *inode = NULL; 4081da177e4SLinus Torvalds 4091da177e4SLinus Torvalds spin_lock(&sbi->inode_hash_lock); 410b67bfe0dSSasha Levin hlist_for_each_entry(i, head, i_fat_hash) { 4111da177e4SLinus Torvalds BUG_ON(i->vfs_inode.i_sb != sb); 4121da177e4SLinus Torvalds if (i->i_pos != i_pos) 4131da177e4SLinus Torvalds continue; 4141da177e4SLinus Torvalds inode = igrab(&i->vfs_inode); 4151da177e4SLinus Torvalds if (inode) 4161da177e4SLinus Torvalds break; 4171da177e4SLinus Torvalds } 4181da177e4SLinus Torvalds spin_unlock(&sbi->inode_hash_lock); 4191da177e4SLinus Torvalds return inode; 4201da177e4SLinus Torvalds } 4211da177e4SLinus Torvalds 4221da177e4SLinus Torvalds static int is_exec(unsigned char *extension) 4231da177e4SLinus Torvalds { 4241da177e4SLinus Torvalds unsigned char *exe_extensions = "EXECOMBAT", *walk; 4251da177e4SLinus Torvalds 4261da177e4SLinus Torvalds for (walk = exe_extensions; *walk; walk += 3) 4271da177e4SLinus Torvalds if (!strncmp(extension, walk, 3)) 4281da177e4SLinus Torvalds return 1; 4291da177e4SLinus Torvalds return 0; 4301da177e4SLinus Torvalds } 4311da177e4SLinus Torvalds 4321da177e4SLinus Torvalds static int fat_calc_dir_size(struct inode *inode) 4331da177e4SLinus Torvalds { 4341da177e4SLinus Torvalds struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb); 4351da177e4SLinus Torvalds int ret, fclus, dclus; 4361da177e4SLinus Torvalds 4371da177e4SLinus Torvalds inode->i_size = 0; 4381da177e4SLinus Torvalds if (MSDOS_I(inode)->i_start == 0) 4391da177e4SLinus Torvalds return 0; 4401da177e4SLinus Torvalds 4411da177e4SLinus Torvalds ret = fat_get_cluster(inode, FAT_ENT_EOF, &fclus, &dclus); 4421da177e4SLinus Torvalds if (ret < 0) 4431da177e4SLinus Torvalds return ret; 4441da177e4SLinus Torvalds inode->i_size = (fclus + 1) << sbi->cluster_bits; 4451da177e4SLinus Torvalds 4461da177e4SLinus Torvalds return 0; 4471da177e4SLinus Torvalds } 4481da177e4SLinus Torvalds 4491da177e4SLinus Torvalds /* doesn't deal with root inode */ 450f1e6fb0aSNamjae Jeon int fat_fill_inode(struct inode *inode, struct msdos_dir_entry *de) 4511da177e4SLinus Torvalds { 4521da177e4SLinus Torvalds struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb); 4531da177e4SLinus Torvalds int error; 4541da177e4SLinus Torvalds 4551da177e4SLinus Torvalds MSDOS_I(inode)->i_pos = 0; 4561da177e4SLinus Torvalds inode->i_uid = sbi->options.fs_uid; 4571da177e4SLinus Torvalds inode->i_gid = sbi->options.fs_gid; 4581da177e4SLinus Torvalds inode->i_version++; 4591da177e4SLinus Torvalds inode->i_generation = get_seconds(); 4601da177e4SLinus Torvalds 4611da177e4SLinus Torvalds if ((de->attr & ATTR_DIR) && !IS_FREE(de->name)) { 4621da177e4SLinus Torvalds inode->i_generation &= ~1; 4639c0aa1b8SOGAWA Hirofumi inode->i_mode = fat_make_mode(sbi, de->attr, S_IRWXUGO); 4641da177e4SLinus Torvalds inode->i_op = sbi->dir_ops; 4651da177e4SLinus Torvalds inode->i_fop = &fat_dir_operations; 4661da177e4SLinus Torvalds 467a943ed71SSteven J. Magnani MSDOS_I(inode)->i_start = fat_get_start(sbi, de); 4681da177e4SLinus Torvalds MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start; 4691da177e4SLinus Torvalds error = fat_calc_dir_size(inode); 4701da177e4SLinus Torvalds if (error < 0) 4711da177e4SLinus Torvalds return error; 4721da177e4SLinus Torvalds MSDOS_I(inode)->mmu_private = inode->i_size; 4731da177e4SLinus Torvalds 474bfe86848SMiklos Szeredi set_nlink(inode, fat_subdirs(inode)); 4751da177e4SLinus Torvalds } else { /* not a directory */ 4761da177e4SLinus Torvalds inode->i_generation |= 1; 4779c0aa1b8SOGAWA Hirofumi inode->i_mode = fat_make_mode(sbi, de->attr, 4789aacd599SOGAWA Hirofumi ((sbi->options.showexec && !is_exec(de->name + 8)) 4799c0aa1b8SOGAWA Hirofumi ? S_IRUGO|S_IWUGO : S_IRWXUGO)); 480a943ed71SSteven J. Magnani MSDOS_I(inode)->i_start = fat_get_start(sbi, de); 4811da177e4SLinus Torvalds 4821da177e4SLinus Torvalds MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start; 4831da177e4SLinus Torvalds inode->i_size = le32_to_cpu(de->size); 4841da177e4SLinus Torvalds inode->i_op = &fat_file_inode_operations; 4851da177e4SLinus Torvalds inode->i_fop = &fat_file_operations; 4861da177e4SLinus Torvalds inode->i_mapping->a_ops = &fat_aops; 4871da177e4SLinus Torvalds MSDOS_I(inode)->mmu_private = inode->i_size; 4881da177e4SLinus Torvalds } 4891da177e4SLinus Torvalds if (de->attr & ATTR_SYS) { 4901da177e4SLinus Torvalds if (sbi->options.sys_immutable) 4911da177e4SLinus Torvalds inode->i_flags |= S_IMMUTABLE; 4921da177e4SLinus Torvalds } 4939c0aa1b8SOGAWA Hirofumi fat_save_attrs(inode, de->attr); 4949c0aa1b8SOGAWA Hirofumi 4951da177e4SLinus Torvalds inode->i_blocks = ((inode->i_size + (sbi->cluster_size - 1)) 4961da177e4SLinus Torvalds & ~((loff_t)sbi->cluster_size - 1)) >> 9; 4977decd1cbSOGAWA Hirofumi 4987decd1cbSOGAWA Hirofumi fat_time_fat2unix(sbi, &inode->i_mtime, de->time, de->date, 0); 4991da177e4SLinus Torvalds if (sbi->options.isvfat) { 5007decd1cbSOGAWA Hirofumi fat_time_fat2unix(sbi, &inode->i_ctime, de->ctime, 5017decd1cbSOGAWA Hirofumi de->cdate, de->ctime_cs); 5027decd1cbSOGAWA Hirofumi fat_time_fat2unix(sbi, &inode->i_atime, 0, de->adate, 0); 5031da177e4SLinus Torvalds } else 50462a36c43SStephane Kardas inode->i_ctime = inode->i_atime = inode->i_mtime; 5051da177e4SLinus Torvalds 5061da177e4SLinus Torvalds return 0; 5071da177e4SLinus Torvalds } 5081da177e4SLinus Torvalds 5098fceb4e0SNamjae Jeon static inline void fat_lock_build_inode(struct msdos_sb_info *sbi) 5108fceb4e0SNamjae Jeon { 5118fceb4e0SNamjae Jeon if (sbi->options.nfs == FAT_NFS_NOSTALE_RO) 5128fceb4e0SNamjae Jeon mutex_lock(&sbi->nfs_build_inode_lock); 5138fceb4e0SNamjae Jeon } 5148fceb4e0SNamjae Jeon 5158fceb4e0SNamjae Jeon static inline void fat_unlock_build_inode(struct msdos_sb_info *sbi) 5168fceb4e0SNamjae Jeon { 5178fceb4e0SNamjae Jeon if (sbi->options.nfs == FAT_NFS_NOSTALE_RO) 5188fceb4e0SNamjae Jeon mutex_unlock(&sbi->nfs_build_inode_lock); 5198fceb4e0SNamjae Jeon } 5208fceb4e0SNamjae Jeon 5211da177e4SLinus Torvalds struct inode *fat_build_inode(struct super_block *sb, 5221da177e4SLinus Torvalds struct msdos_dir_entry *de, loff_t i_pos) 5231da177e4SLinus Torvalds { 5241da177e4SLinus Torvalds struct inode *inode; 5251da177e4SLinus Torvalds int err; 5261da177e4SLinus Torvalds 5278fceb4e0SNamjae Jeon fat_lock_build_inode(MSDOS_SB(sb)); 5281da177e4SLinus Torvalds inode = fat_iget(sb, i_pos); 5291da177e4SLinus Torvalds if (inode) 5301da177e4SLinus Torvalds goto out; 5311da177e4SLinus Torvalds inode = new_inode(sb); 5321da177e4SLinus Torvalds if (!inode) { 5331da177e4SLinus Torvalds inode = ERR_PTR(-ENOMEM); 5341da177e4SLinus Torvalds goto out; 5351da177e4SLinus Torvalds } 5361da177e4SLinus Torvalds inode->i_ino = iunique(sb, MSDOS_ROOT_INO); 5371da177e4SLinus Torvalds inode->i_version = 1; 5381da177e4SLinus Torvalds err = fat_fill_inode(inode, de); 5391da177e4SLinus Torvalds if (err) { 5401da177e4SLinus Torvalds iput(inode); 5411da177e4SLinus Torvalds inode = ERR_PTR(err); 5421da177e4SLinus Torvalds goto out; 5431da177e4SLinus Torvalds } 5441da177e4SLinus Torvalds fat_attach(inode, i_pos); 5451da177e4SLinus Torvalds insert_inode_hash(inode); 5461da177e4SLinus Torvalds out: 5478fceb4e0SNamjae Jeon fat_unlock_build_inode(MSDOS_SB(sb)); 5481da177e4SLinus Torvalds return inode; 5491da177e4SLinus Torvalds } 5501da177e4SLinus Torvalds 5517c709d00SOGAWA Hirofumi EXPORT_SYMBOL_GPL(fat_build_inode); 5521da177e4SLinus Torvalds 553deee3ce4SAl Viro static void fat_evict_inode(struct inode *inode) 5541da177e4SLinus Torvalds { 55591b0abe3SJohannes Weiner truncate_inode_pages_final(&inode->i_data); 556deee3ce4SAl Viro if (!inode->i_nlink) { 5571da177e4SLinus Torvalds inode->i_size = 0; 558459f6ed3Snpiggin@suse.de fat_truncate_blocks(inode, 0); 5591da177e4SLinus Torvalds } 560deee3ce4SAl Viro invalidate_inode_buffers(inode); 561dbd5768fSJan Kara clear_inode(inode); 5621da177e4SLinus Torvalds fat_cache_inval_inode(inode); 563a993b542SOGAWA Hirofumi fat_detach(inode); 5641da177e4SLinus Torvalds } 5651da177e4SLinus Torvalds 566b88a1058SOleksij Rempel static void fat_set_state(struct super_block *sb, 567b88a1058SOleksij Rempel unsigned int set, unsigned int force) 568b88a1058SOleksij Rempel { 569b88a1058SOleksij Rempel struct buffer_head *bh; 570b88a1058SOleksij Rempel struct fat_boot_sector *b; 571b88a1058SOleksij Rempel struct msdos_sb_info *sbi = sb->s_fs_info; 572b88a1058SOleksij Rempel 573b88a1058SOleksij Rempel /* do not change any thing if mounted read only */ 574b88a1058SOleksij Rempel if ((sb->s_flags & MS_RDONLY) && !force) 575b88a1058SOleksij Rempel return; 576b88a1058SOleksij Rempel 577b88a1058SOleksij Rempel /* do not change state if fs was dirty */ 578b88a1058SOleksij Rempel if (sbi->dirty) { 579b88a1058SOleksij Rempel /* warn only on set (mount). */ 580b88a1058SOleksij Rempel if (set) 581b88a1058SOleksij Rempel fat_msg(sb, KERN_WARNING, "Volume was not properly " 582b88a1058SOleksij Rempel "unmounted. Some data may be corrupt. " 583b88a1058SOleksij Rempel "Please run fsck."); 584b88a1058SOleksij Rempel return; 585b88a1058SOleksij Rempel } 586b88a1058SOleksij Rempel 587b88a1058SOleksij Rempel bh = sb_bread(sb, 0); 588b88a1058SOleksij Rempel if (bh == NULL) { 589b88a1058SOleksij Rempel fat_msg(sb, KERN_ERR, "unable to read boot sector " 590b88a1058SOleksij Rempel "to mark fs as dirty"); 591b88a1058SOleksij Rempel return; 592b88a1058SOleksij Rempel } 593b88a1058SOleksij Rempel 594b88a1058SOleksij Rempel b = (struct fat_boot_sector *) bh->b_data; 595b88a1058SOleksij Rempel 596b88a1058SOleksij Rempel if (sbi->fat_bits == 32) { 597b88a1058SOleksij Rempel if (set) 598b88a1058SOleksij Rempel b->fat32.state |= FAT_STATE_DIRTY; 599b88a1058SOleksij Rempel else 600b88a1058SOleksij Rempel b->fat32.state &= ~FAT_STATE_DIRTY; 601b88a1058SOleksij Rempel } else /* fat 16 and 12 */ { 602b88a1058SOleksij Rempel if (set) 603b88a1058SOleksij Rempel b->fat16.state |= FAT_STATE_DIRTY; 604b88a1058SOleksij Rempel else 605b88a1058SOleksij Rempel b->fat16.state &= ~FAT_STATE_DIRTY; 606b88a1058SOleksij Rempel } 607b88a1058SOleksij Rempel 608b88a1058SOleksij Rempel mark_buffer_dirty(bh); 609b88a1058SOleksij Rempel sync_dirty_buffer(bh); 610b88a1058SOleksij Rempel brelse(bh); 611b88a1058SOleksij Rempel } 612b88a1058SOleksij Rempel 613cac45b06SAl Viro static void delayed_free(struct rcu_head *p) 614cac45b06SAl Viro { 615cac45b06SAl Viro struct msdos_sb_info *sbi = container_of(p, struct msdos_sb_info, rcu); 616cac45b06SAl Viro unload_nls(sbi->nls_disk); 617cac45b06SAl Viro unload_nls(sbi->nls_io); 618cac45b06SAl Viro if (sbi->options.iocharset != fat_default_iocharset) 619cac45b06SAl Viro kfree(sbi->options.iocharset); 620cac45b06SAl Viro kfree(sbi); 621cac45b06SAl Viro } 622cac45b06SAl Viro 623a6bf6b21SOGAWA Hirofumi static void fat_put_super(struct super_block *sb) 624a6bf6b21SOGAWA Hirofumi { 625a6bf6b21SOGAWA Hirofumi struct msdos_sb_info *sbi = MSDOS_SB(sb); 6261da177e4SLinus Torvalds 627b88a1058SOleksij Rempel fat_set_state(sb, 0, 0); 628b88a1058SOleksij Rempel 629020ac5b6SArtem Bityutskiy iput(sbi->fsinfo_inode); 630b522412aSAl Viro iput(sbi->fat_inode); 631b522412aSAl Viro 632cac45b06SAl Viro call_rcu(&sbi->rcu, delayed_free); 6331da177e4SLinus Torvalds } 6341da177e4SLinus Torvalds 635e18b890bSChristoph Lameter static struct kmem_cache *fat_inode_cachep; 6361da177e4SLinus Torvalds 6371da177e4SLinus Torvalds static struct inode *fat_alloc_inode(struct super_block *sb) 6381da177e4SLinus Torvalds { 6391da177e4SLinus Torvalds struct msdos_inode_info *ei; 6408f593427SLinus Torvalds ei = kmem_cache_alloc(fat_inode_cachep, GFP_NOFS); 6411da177e4SLinus Torvalds if (!ei) 6421da177e4SLinus Torvalds return NULL; 64358268691SChristoph Hellwig 64458268691SChristoph Hellwig init_rwsem(&ei->truncate_lock); 6451da177e4SLinus Torvalds return &ei->vfs_inode; 6461da177e4SLinus Torvalds } 6471da177e4SLinus Torvalds 648fa0d7e3dSNick Piggin static void fat_i_callback(struct rcu_head *head) 649fa0d7e3dSNick Piggin { 650fa0d7e3dSNick Piggin struct inode *inode = container_of(head, struct inode, i_rcu); 651fa0d7e3dSNick Piggin kmem_cache_free(fat_inode_cachep, MSDOS_I(inode)); 652fa0d7e3dSNick Piggin } 653fa0d7e3dSNick Piggin 6541da177e4SLinus Torvalds static void fat_destroy_inode(struct inode *inode) 6551da177e4SLinus Torvalds { 656fa0d7e3dSNick Piggin call_rcu(&inode->i_rcu, fat_i_callback); 6571da177e4SLinus Torvalds } 6581da177e4SLinus Torvalds 65951cc5068SAlexey Dobriyan static void init_once(void *foo) 6601da177e4SLinus Torvalds { 6611da177e4SLinus Torvalds struct msdos_inode_info *ei = (struct msdos_inode_info *)foo; 6621da177e4SLinus Torvalds 6631da177e4SLinus Torvalds spin_lock_init(&ei->cache_lru_lock); 6641da177e4SLinus Torvalds ei->nr_caches = 0; 6651da177e4SLinus Torvalds ei->cache_valid_id = FAT_CACHE_VALID + 1; 6661da177e4SLinus Torvalds INIT_LIST_HEAD(&ei->cache_lru); 6671da177e4SLinus Torvalds INIT_HLIST_NODE(&ei->i_fat_hash); 6687669e8fbSSteven J. Magnani INIT_HLIST_NODE(&ei->i_dir_hash); 6691da177e4SLinus Torvalds inode_init_once(&ei->vfs_inode); 6701da177e4SLinus Torvalds } 6711da177e4SLinus Torvalds 6721da177e4SLinus Torvalds static int __init fat_init_inodecache(void) 6731da177e4SLinus Torvalds { 6741da177e4SLinus Torvalds fat_inode_cachep = kmem_cache_create("fat_inode_cache", 6751da177e4SLinus Torvalds sizeof(struct msdos_inode_info), 676fffb60f9SPaul Jackson 0, (SLAB_RECLAIM_ACCOUNT| 677fffb60f9SPaul Jackson SLAB_MEM_SPREAD), 67820c2df83SPaul Mundt init_once); 6791da177e4SLinus Torvalds if (fat_inode_cachep == NULL) 6801da177e4SLinus Torvalds return -ENOMEM; 6811da177e4SLinus Torvalds return 0; 6821da177e4SLinus Torvalds } 6831da177e4SLinus Torvalds 6841da177e4SLinus Torvalds static void __exit fat_destroy_inodecache(void) 6851da177e4SLinus Torvalds { 6868c0a8537SKirill A. Shutemov /* 6878c0a8537SKirill A. Shutemov * Make sure all delayed rcu free inodes are flushed before we 6888c0a8537SKirill A. Shutemov * destroy cache. 6898c0a8537SKirill A. Shutemov */ 6908c0a8537SKirill A. Shutemov rcu_barrier(); 6911a1d92c1SAlexey Dobriyan kmem_cache_destroy(fat_inode_cachep); 6921da177e4SLinus Torvalds } 6931da177e4SLinus Torvalds 6941da177e4SLinus Torvalds static int fat_remount(struct super_block *sb, int *flags, char *data) 6951da177e4SLinus Torvalds { 696b88a1058SOleksij Rempel int new_rdonly; 6971da177e4SLinus Torvalds struct msdos_sb_info *sbi = MSDOS_SB(sb); 6981da177e4SLinus Torvalds *flags |= MS_NODIRATIME | (sbi->options.isvfat ? 0 : MS_NOATIME); 699b88a1058SOleksij Rempel 70002b9984dSTheodore Ts'o sync_filesystem(sb); 70102b9984dSTheodore Ts'o 702b88a1058SOleksij Rempel /* make sure we update state on remount. */ 703b88a1058SOleksij Rempel new_rdonly = *flags & MS_RDONLY; 704b88a1058SOleksij Rempel if (new_rdonly != (sb->s_flags & MS_RDONLY)) { 705b88a1058SOleksij Rempel if (new_rdonly) 706b88a1058SOleksij Rempel fat_set_state(sb, 0, 0); 707b88a1058SOleksij Rempel else 708b88a1058SOleksij Rempel fat_set_state(sb, 1, 1); 709b88a1058SOleksij Rempel } 7101da177e4SLinus Torvalds return 0; 7111da177e4SLinus Torvalds } 7121da177e4SLinus Torvalds 713726c3342SDavid Howells static int fat_statfs(struct dentry *dentry, struct kstatfs *buf) 7141da177e4SLinus Torvalds { 715aac49b75SColy Li struct super_block *sb = dentry->d_sb; 716aac49b75SColy Li struct msdos_sb_info *sbi = MSDOS_SB(sb); 717aac49b75SColy Li u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 7181da177e4SLinus Torvalds 7191da177e4SLinus Torvalds /* If the count of free cluster is still unknown, counts it here. */ 720606e423eSOGAWA Hirofumi if (sbi->free_clusters == -1 || !sbi->free_clus_valid) { 721726c3342SDavid Howells int err = fat_count_free_clusters(dentry->d_sb); 7221da177e4SLinus Torvalds if (err) 7231da177e4SLinus Torvalds return err; 7241da177e4SLinus Torvalds } 7251da177e4SLinus Torvalds 726726c3342SDavid Howells buf->f_type = dentry->d_sb->s_magic; 7271da177e4SLinus Torvalds buf->f_bsize = sbi->cluster_size; 7281da177e4SLinus Torvalds buf->f_blocks = sbi->max_cluster - FAT_START_ENT; 7291da177e4SLinus Torvalds buf->f_bfree = sbi->free_clusters; 7301da177e4SLinus Torvalds buf->f_bavail = sbi->free_clusters; 731aac49b75SColy Li buf->f_fsid.val[0] = (u32)id; 732aac49b75SColy Li buf->f_fsid.val[1] = (u32)(id >> 32); 733f68e542fSOGAWA Hirofumi buf->f_namelen = 734f68e542fSOGAWA Hirofumi (sbi->options.isvfat ? FAT_LFN_LEN : 12) * NLS_MAX_CHARSET_SIZE; 7351da177e4SLinus Torvalds 7361da177e4SLinus Torvalds return 0; 7371da177e4SLinus Torvalds } 7381da177e4SLinus Torvalds 739a9185b41SChristoph Hellwig static int __fat_write_inode(struct inode *inode, int wait) 7401da177e4SLinus Torvalds { 7411da177e4SLinus Torvalds struct super_block *sb = inode->i_sb; 7421da177e4SLinus Torvalds struct msdos_sb_info *sbi = MSDOS_SB(sb); 7431da177e4SLinus Torvalds struct buffer_head *bh; 7441da177e4SLinus Torvalds struct msdos_dir_entry *raw_entry; 7451da177e4SLinus Torvalds loff_t i_pos; 746e22a4442SNamjae Jeon sector_t blocknr; 747e22a4442SNamjae Jeon int err, offset; 7481da177e4SLinus Torvalds 7499ca59f4cSOGAWA Hirofumi if (inode->i_ino == MSDOS_ROOT_INO) 7509ca59f4cSOGAWA Hirofumi return 0; 7519ca59f4cSOGAWA Hirofumi 7521da177e4SLinus Torvalds retry: 7539ca59f4cSOGAWA Hirofumi i_pos = fat_i_pos_read(sbi, inode); 7549ca59f4cSOGAWA Hirofumi if (!i_pos) 7551da177e4SLinus Torvalds return 0; 7561da177e4SLinus Torvalds 757e22a4442SNamjae Jeon fat_get_blknr_offset(sbi, i_pos, &blocknr, &offset); 758e22a4442SNamjae Jeon bh = sb_bread(sb, blocknr); 7591da177e4SLinus Torvalds if (!bh) { 760869f58c0SAlexey Fisher fat_msg(sb, KERN_ERR, "unable to read inode block " 761869f58c0SAlexey Fisher "for updating (i_pos %lld)", i_pos); 7625f22ca9bSLinus Torvalds return -EIO; 7631da177e4SLinus Torvalds } 7641da177e4SLinus Torvalds spin_lock(&sbi->inode_hash_lock); 7651da177e4SLinus Torvalds if (i_pos != MSDOS_I(inode)->i_pos) { 7661da177e4SLinus Torvalds spin_unlock(&sbi->inode_hash_lock); 7671da177e4SLinus Torvalds brelse(bh); 7681da177e4SLinus Torvalds goto retry; 7691da177e4SLinus Torvalds } 7701da177e4SLinus Torvalds 771e22a4442SNamjae Jeon raw_entry = &((struct msdos_dir_entry *) (bh->b_data))[offset]; 7721da177e4SLinus Torvalds if (S_ISDIR(inode->i_mode)) 7731da177e4SLinus Torvalds raw_entry->size = 0; 7741da177e4SLinus Torvalds else 7751da177e4SLinus Torvalds raw_entry->size = cpu_to_le32(inode->i_size); 7769c0aa1b8SOGAWA Hirofumi raw_entry->attr = fat_make_attrs(inode); 777a943ed71SSteven J. Magnani fat_set_start(raw_entry, MSDOS_I(inode)->i_logstart); 7787decd1cbSOGAWA Hirofumi fat_time_unix2fat(sbi, &inode->i_mtime, &raw_entry->time, 7797decd1cbSOGAWA Hirofumi &raw_entry->date, NULL); 7801da177e4SLinus Torvalds if (sbi->options.isvfat) { 78162a36c43SStephane Kardas __le16 atime; 7827decd1cbSOGAWA Hirofumi fat_time_unix2fat(sbi, &inode->i_ctime, &raw_entry->ctime, 7837decd1cbSOGAWA Hirofumi &raw_entry->cdate, &raw_entry->ctime_cs); 7847decd1cbSOGAWA Hirofumi fat_time_unix2fat(sbi, &inode->i_atime, &atime, 7857decd1cbSOGAWA Hirofumi &raw_entry->adate, NULL); 7861da177e4SLinus Torvalds } 7871da177e4SLinus Torvalds spin_unlock(&sbi->inode_hash_lock); 7881da177e4SLinus Torvalds mark_buffer_dirty(bh); 7895f22ca9bSLinus Torvalds err = 0; 7901da177e4SLinus Torvalds if (wait) 7911da177e4SLinus Torvalds err = sync_dirty_buffer(bh); 7921da177e4SLinus Torvalds brelse(bh); 7931da177e4SLinus Torvalds return err; 7941da177e4SLinus Torvalds } 7951da177e4SLinus Torvalds 796a9185b41SChristoph Hellwig static int fat_write_inode(struct inode *inode, struct writeback_control *wbc) 797a9185b41SChristoph Hellwig { 79878491189SArtem Bityutskiy int err; 79978491189SArtem Bityutskiy 80078491189SArtem Bityutskiy if (inode->i_ino == MSDOS_FSINFO_INO) { 80178491189SArtem Bityutskiy struct super_block *sb = inode->i_sb; 80278491189SArtem Bityutskiy 803e40b34c7SMarco Stornelli mutex_lock(&MSDOS_SB(sb)->s_lock); 80478491189SArtem Bityutskiy err = fat_clusters_flush(sb); 805e40b34c7SMarco Stornelli mutex_unlock(&MSDOS_SB(sb)->s_lock); 80678491189SArtem Bityutskiy } else 80778491189SArtem Bityutskiy err = __fat_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL); 80878491189SArtem Bityutskiy 80978491189SArtem Bityutskiy return err; 810a9185b41SChristoph Hellwig } 811a9185b41SChristoph Hellwig 8121da177e4SLinus Torvalds int fat_sync_inode(struct inode *inode) 8131da177e4SLinus Torvalds { 814a9185b41SChristoph Hellwig return __fat_write_inode(inode, 1); 8151da177e4SLinus Torvalds } 8161da177e4SLinus Torvalds 8177c709d00SOGAWA Hirofumi EXPORT_SYMBOL_GPL(fat_sync_inode); 8181da177e4SLinus Torvalds 81934c80b1dSAl Viro static int fat_show_options(struct seq_file *m, struct dentry *root); 820ee9b6d61SJosef 'Jeff' Sipek static const struct super_operations fat_sops = { 8211da177e4SLinus Torvalds .alloc_inode = fat_alloc_inode, 8221da177e4SLinus Torvalds .destroy_inode = fat_destroy_inode, 8231da177e4SLinus Torvalds .write_inode = fat_write_inode, 824deee3ce4SAl Viro .evict_inode = fat_evict_inode, 8251da177e4SLinus Torvalds .put_super = fat_put_super, 8261da177e4SLinus Torvalds .statfs = fat_statfs, 8271da177e4SLinus Torvalds .remount_fs = fat_remount, 8281da177e4SLinus Torvalds 8291da177e4SLinus Torvalds .show_options = fat_show_options, 8301da177e4SLinus Torvalds }; 8311da177e4SLinus Torvalds 83234c80b1dSAl Viro static int fat_show_options(struct seq_file *m, struct dentry *root) 8331da177e4SLinus Torvalds { 83434c80b1dSAl Viro struct msdos_sb_info *sbi = MSDOS_SB(root->d_sb); 8351da177e4SLinus Torvalds struct fat_mount_options *opts = &sbi->options; 8361da177e4SLinus Torvalds int isvfat = opts->isvfat; 8371da177e4SLinus Torvalds 838170782ebSEric W. Biederman if (!uid_eq(opts->fs_uid, GLOBAL_ROOT_UID)) 839170782ebSEric W. Biederman seq_printf(m, ",uid=%u", 840170782ebSEric W. Biederman from_kuid_munged(&init_user_ns, opts->fs_uid)); 841170782ebSEric W. Biederman if (!gid_eq(opts->fs_gid, GLOBAL_ROOT_GID)) 842170782ebSEric W. Biederman seq_printf(m, ",gid=%u", 843170782ebSEric W. Biederman from_kgid_munged(&init_user_ns, opts->fs_gid)); 8441da177e4SLinus Torvalds seq_printf(m, ",fmask=%04o", opts->fs_fmask); 8451da177e4SLinus Torvalds seq_printf(m, ",dmask=%04o", opts->fs_dmask); 8461ae43f82SOGAWA Hirofumi if (opts->allow_utime) 8471ae43f82SOGAWA Hirofumi seq_printf(m, ",allow_utime=%04o", opts->allow_utime); 8481da177e4SLinus Torvalds if (sbi->nls_disk) 849c6c20372SDave Reisner /* strip "cp" prefix from displayed option */ 850c6c20372SDave Reisner seq_printf(m, ",codepage=%s", &sbi->nls_disk->charset[2]); 8511da177e4SLinus Torvalds if (isvfat) { 8521da177e4SLinus Torvalds if (sbi->nls_io) 8531da177e4SLinus Torvalds seq_printf(m, ",iocharset=%s", sbi->nls_io->charset); 8541da177e4SLinus Torvalds 8551da177e4SLinus Torvalds switch (opts->shortname) { 8561da177e4SLinus Torvalds case VFAT_SFN_DISPLAY_WIN95 | VFAT_SFN_CREATE_WIN95: 8571da177e4SLinus Torvalds seq_puts(m, ",shortname=win95"); 8581da177e4SLinus Torvalds break; 8591da177e4SLinus Torvalds case VFAT_SFN_DISPLAY_WINNT | VFAT_SFN_CREATE_WINNT: 8601da177e4SLinus Torvalds seq_puts(m, ",shortname=winnt"); 8611da177e4SLinus Torvalds break; 8621da177e4SLinus Torvalds case VFAT_SFN_DISPLAY_WINNT | VFAT_SFN_CREATE_WIN95: 8631da177e4SLinus Torvalds seq_puts(m, ",shortname=mixed"); 8641da177e4SLinus Torvalds break; 8651da177e4SLinus Torvalds case VFAT_SFN_DISPLAY_LOWER | VFAT_SFN_CREATE_WIN95: 86695523475SPaul Wise seq_puts(m, ",shortname=lower"); 8671da177e4SLinus Torvalds break; 8681da177e4SLinus Torvalds default: 8691da177e4SLinus Torvalds seq_puts(m, ",shortname=unknown"); 8701da177e4SLinus Torvalds break; 8711da177e4SLinus Torvalds } 8721da177e4SLinus Torvalds } 8731da177e4SLinus Torvalds if (opts->name_check != 'n') 8741da177e4SLinus Torvalds seq_printf(m, ",check=%c", opts->name_check); 87528ec039cSOGAWA Hirofumi if (opts->usefree) 87628ec039cSOGAWA Hirofumi seq_puts(m, ",usefree"); 8771da177e4SLinus Torvalds if (opts->quiet) 8781da177e4SLinus Torvalds seq_puts(m, ",quiet"); 8791da177e4SLinus Torvalds if (opts->showexec) 8801da177e4SLinus Torvalds seq_puts(m, ",showexec"); 8811da177e4SLinus Torvalds if (opts->sys_immutable) 8821da177e4SLinus Torvalds seq_puts(m, ",sys_immutable"); 8831da177e4SLinus Torvalds if (!isvfat) { 8841da177e4SLinus Torvalds if (opts->dotsOK) 8851da177e4SLinus Torvalds seq_puts(m, ",dotsOK=yes"); 8861da177e4SLinus Torvalds if (opts->nocase) 8871da177e4SLinus Torvalds seq_puts(m, ",nocase"); 8881da177e4SLinus Torvalds } else { 8891da177e4SLinus Torvalds if (opts->utf8) 8901da177e4SLinus Torvalds seq_puts(m, ",utf8"); 8911da177e4SLinus Torvalds if (opts->unicode_xlate) 8921da177e4SLinus Torvalds seq_puts(m, ",uni_xlate"); 8931da177e4SLinus Torvalds if (!opts->numtail) 8941da177e4SLinus Torvalds seq_puts(m, ",nonumtail"); 895dfc209c0SOGAWA Hirofumi if (opts->rodir) 896dfc209c0SOGAWA Hirofumi seq_puts(m, ",rodir"); 8971da177e4SLinus Torvalds } 898dfc209c0SOGAWA Hirofumi if (opts->flush) 899c1fca3b6SMiklos Szeredi seq_puts(m, ",flush"); 90058156c8fSJan Kara if (opts->tz_set) { 90158156c8fSJan Kara if (opts->time_offset) 90258156c8fSJan Kara seq_printf(m, ",time_offset=%d", opts->time_offset); 90358156c8fSJan Kara else 904b271e067SJoe Peterson seq_puts(m, ",tz=UTC"); 90558156c8fSJan Kara } 90685c78591SDenis Karpov if (opts->errors == FAT_ERRORS_CONT) 90785c78591SDenis Karpov seq_puts(m, ",errors=continue"); 90885c78591SDenis Karpov else if (opts->errors == FAT_ERRORS_PANIC) 90985c78591SDenis Karpov seq_puts(m, ",errors=panic"); 91085c78591SDenis Karpov else 91185c78591SDenis Karpov seq_puts(m, ",errors=remount-ro"); 9122628b7a6SNamjae Jeon if (opts->nfs == FAT_NFS_NOSTALE_RO) 9132628b7a6SNamjae Jeon seq_puts(m, ",nfs=nostale_ro"); 9142628b7a6SNamjae Jeon else if (opts->nfs) 9152628b7a6SNamjae Jeon seq_puts(m, ",nfs=stale_rw"); 916681142f9SChristoph Hellwig if (opts->discard) 917681142f9SChristoph Hellwig seq_puts(m, ",discard"); 918*190a8843SConrad Meyer if (opts->dos1xfloppy) 919*190a8843SConrad Meyer seq_puts(m, ",dos1xfloppy"); 9201da177e4SLinus Torvalds 9211da177e4SLinus Torvalds return 0; 9221da177e4SLinus Torvalds } 9231da177e4SLinus Torvalds 9241da177e4SLinus Torvalds enum { 9251da177e4SLinus Torvalds Opt_check_n, Opt_check_r, Opt_check_s, Opt_uid, Opt_gid, 9261ae43f82SOGAWA Hirofumi Opt_umask, Opt_dmask, Opt_fmask, Opt_allow_utime, Opt_codepage, 9271ae43f82SOGAWA Hirofumi Opt_usefree, Opt_nocase, Opt_quiet, Opt_showexec, Opt_debug, 9281ae43f82SOGAWA Hirofumi Opt_immutable, Opt_dots, Opt_nodots, 9291da177e4SLinus Torvalds Opt_charset, Opt_shortname_lower, Opt_shortname_win95, 9301da177e4SLinus Torvalds Opt_shortname_winnt, Opt_shortname_mixed, Opt_utf8_no, Opt_utf8_yes, 9311da177e4SLinus Torvalds Opt_uni_xl_no, Opt_uni_xl_yes, Opt_nonumtail_no, Opt_nonumtail_yes, 932d7a83c0fSGeert Uytterhoeven Opt_obsolete, Opt_flush, Opt_tz_utc, Opt_rodir, Opt_err_cont, 93358156c8fSJan Kara Opt_err_panic, Opt_err_ro, Opt_discard, Opt_nfs, Opt_time_offset, 934*190a8843SConrad Meyer Opt_nfs_stale_rw, Opt_nfs_nostale_ro, Opt_err, Opt_dos1xfloppy, 9351da177e4SLinus Torvalds }; 9361da177e4SLinus Torvalds 937a447c093SSteven Whitehouse static const match_table_t fat_tokens = { 9381da177e4SLinus Torvalds {Opt_check_r, "check=relaxed"}, 9391da177e4SLinus Torvalds {Opt_check_s, "check=strict"}, 9401da177e4SLinus Torvalds {Opt_check_n, "check=normal"}, 9411da177e4SLinus Torvalds {Opt_check_r, "check=r"}, 9421da177e4SLinus Torvalds {Opt_check_s, "check=s"}, 9431da177e4SLinus Torvalds {Opt_check_n, "check=n"}, 9441da177e4SLinus Torvalds {Opt_uid, "uid=%u"}, 9451da177e4SLinus Torvalds {Opt_gid, "gid=%u"}, 9461da177e4SLinus Torvalds {Opt_umask, "umask=%o"}, 9471da177e4SLinus Torvalds {Opt_dmask, "dmask=%o"}, 9481da177e4SLinus Torvalds {Opt_fmask, "fmask=%o"}, 9491ae43f82SOGAWA Hirofumi {Opt_allow_utime, "allow_utime=%o"}, 9501da177e4SLinus Torvalds {Opt_codepage, "codepage=%u"}, 95128ec039cSOGAWA Hirofumi {Opt_usefree, "usefree"}, 9521da177e4SLinus Torvalds {Opt_nocase, "nocase"}, 9531da177e4SLinus Torvalds {Opt_quiet, "quiet"}, 9541da177e4SLinus Torvalds {Opt_showexec, "showexec"}, 9551da177e4SLinus Torvalds {Opt_debug, "debug"}, 9561da177e4SLinus Torvalds {Opt_immutable, "sys_immutable"}, 95785c78591SDenis Karpov {Opt_flush, "flush"}, 95885c78591SDenis Karpov {Opt_tz_utc, "tz=UTC"}, 95958156c8fSJan Kara {Opt_time_offset, "time_offset=%d"}, 96085c78591SDenis Karpov {Opt_err_cont, "errors=continue"}, 96185c78591SDenis Karpov {Opt_err_panic, "errors=panic"}, 96285c78591SDenis Karpov {Opt_err_ro, "errors=remount-ro"}, 963681142f9SChristoph Hellwig {Opt_discard, "discard"}, 9642628b7a6SNamjae Jeon {Opt_nfs_stale_rw, "nfs"}, 9652628b7a6SNamjae Jeon {Opt_nfs_stale_rw, "nfs=stale_rw"}, 9662628b7a6SNamjae Jeon {Opt_nfs_nostale_ro, "nfs=nostale_ro"}, 967*190a8843SConrad Meyer {Opt_dos1xfloppy, "dos1xfloppy"}, 968d7a83c0fSGeert Uytterhoeven {Opt_obsolete, "conv=binary"}, 969d7a83c0fSGeert Uytterhoeven {Opt_obsolete, "conv=text"}, 970d7a83c0fSGeert Uytterhoeven {Opt_obsolete, "conv=auto"}, 971d7a83c0fSGeert Uytterhoeven {Opt_obsolete, "conv=b"}, 972d7a83c0fSGeert Uytterhoeven {Opt_obsolete, "conv=t"}, 973d7a83c0fSGeert Uytterhoeven {Opt_obsolete, "conv=a"}, 974d7a83c0fSGeert Uytterhoeven {Opt_obsolete, "fat=%u"}, 975d7a83c0fSGeert Uytterhoeven {Opt_obsolete, "blocksize=%u"}, 976d7a83c0fSGeert Uytterhoeven {Opt_obsolete, "cvf_format=%20s"}, 977d7a83c0fSGeert Uytterhoeven {Opt_obsolete, "cvf_options=%100s"}, 978d7a83c0fSGeert Uytterhoeven {Opt_obsolete, "posix"}, 979ae78bf9cSChris Mason {Opt_err, NULL}, 9801da177e4SLinus Torvalds }; 981a447c093SSteven Whitehouse static const match_table_t msdos_tokens = { 9821da177e4SLinus Torvalds {Opt_nodots, "nodots"}, 9831da177e4SLinus Torvalds {Opt_nodots, "dotsOK=no"}, 9841da177e4SLinus Torvalds {Opt_dots, "dots"}, 9851da177e4SLinus Torvalds {Opt_dots, "dotsOK=yes"}, 9861da177e4SLinus Torvalds {Opt_err, NULL} 9871da177e4SLinus Torvalds }; 988a447c093SSteven Whitehouse static const match_table_t vfat_tokens = { 9891da177e4SLinus Torvalds {Opt_charset, "iocharset=%s"}, 9901da177e4SLinus Torvalds {Opt_shortname_lower, "shortname=lower"}, 9911da177e4SLinus Torvalds {Opt_shortname_win95, "shortname=win95"}, 9921da177e4SLinus Torvalds {Opt_shortname_winnt, "shortname=winnt"}, 9931da177e4SLinus Torvalds {Opt_shortname_mixed, "shortname=mixed"}, 9941da177e4SLinus Torvalds {Opt_utf8_no, "utf8=0"}, /* 0 or no or false */ 9951da177e4SLinus Torvalds {Opt_utf8_no, "utf8=no"}, 9961da177e4SLinus Torvalds {Opt_utf8_no, "utf8=false"}, 9971da177e4SLinus Torvalds {Opt_utf8_yes, "utf8=1"}, /* empty or 1 or yes or true */ 9981da177e4SLinus Torvalds {Opt_utf8_yes, "utf8=yes"}, 9991da177e4SLinus Torvalds {Opt_utf8_yes, "utf8=true"}, 10001da177e4SLinus Torvalds {Opt_utf8_yes, "utf8"}, 10011da177e4SLinus Torvalds {Opt_uni_xl_no, "uni_xlate=0"}, /* 0 or no or false */ 10021da177e4SLinus Torvalds {Opt_uni_xl_no, "uni_xlate=no"}, 10031da177e4SLinus Torvalds {Opt_uni_xl_no, "uni_xlate=false"}, 10041da177e4SLinus Torvalds {Opt_uni_xl_yes, "uni_xlate=1"}, /* empty or 1 or yes or true */ 10051da177e4SLinus Torvalds {Opt_uni_xl_yes, "uni_xlate=yes"}, 10061da177e4SLinus Torvalds {Opt_uni_xl_yes, "uni_xlate=true"}, 10071da177e4SLinus Torvalds {Opt_uni_xl_yes, "uni_xlate"}, 10081da177e4SLinus Torvalds {Opt_nonumtail_no, "nonumtail=0"}, /* 0 or no or false */ 10091da177e4SLinus Torvalds {Opt_nonumtail_no, "nonumtail=no"}, 10101da177e4SLinus Torvalds {Opt_nonumtail_no, "nonumtail=false"}, 10111da177e4SLinus Torvalds {Opt_nonumtail_yes, "nonumtail=1"}, /* empty or 1 or yes or true */ 10121da177e4SLinus Torvalds {Opt_nonumtail_yes, "nonumtail=yes"}, 10131da177e4SLinus Torvalds {Opt_nonumtail_yes, "nonumtail=true"}, 10141da177e4SLinus Torvalds {Opt_nonumtail_yes, "nonumtail"}, 1015dfc209c0SOGAWA Hirofumi {Opt_rodir, "rodir"}, 10161da177e4SLinus Torvalds {Opt_err, NULL} 10171da177e4SLinus Torvalds }; 10181da177e4SLinus Torvalds 1019869f58c0SAlexey Fisher static int parse_options(struct super_block *sb, char *options, int is_vfat, 1020869f58c0SAlexey Fisher int silent, int *debug, struct fat_mount_options *opts) 10211da177e4SLinus Torvalds { 10221da177e4SLinus Torvalds char *p; 10231da177e4SLinus Torvalds substring_t args[MAX_OPT_ARGS]; 10241da177e4SLinus Torvalds int option; 10251da177e4SLinus Torvalds char *iocharset; 10261da177e4SLinus Torvalds 10271da177e4SLinus Torvalds opts->isvfat = is_vfat; 10281da177e4SLinus Torvalds 1029f0ce7ee3SDavid Howells opts->fs_uid = current_uid(); 1030f0ce7ee3SDavid Howells opts->fs_gid = current_gid(); 10313e107603SOGAWA Hirofumi opts->fs_fmask = opts->fs_dmask = current_umask(); 10321ae43f82SOGAWA Hirofumi opts->allow_utime = -1; 10331da177e4SLinus Torvalds opts->codepage = fat_default_codepage; 10341da177e4SLinus Torvalds opts->iocharset = fat_default_iocharset; 1035dfc209c0SOGAWA Hirofumi if (is_vfat) { 103695523475SPaul Wise opts->shortname = VFAT_SFN_DISPLAY_WINNT|VFAT_SFN_CREATE_WIN95; 1037dfc209c0SOGAWA Hirofumi opts->rodir = 0; 1038dfc209c0SOGAWA Hirofumi } else { 10391da177e4SLinus Torvalds opts->shortname = 0; 1040dfc209c0SOGAWA Hirofumi opts->rodir = 1; 1041dfc209c0SOGAWA Hirofumi } 10421da177e4SLinus Torvalds opts->name_check = 'n'; 10431da177e4SLinus Torvalds opts->quiet = opts->showexec = opts->sys_immutable = opts->dotsOK = 0; 10441da177e4SLinus Torvalds opts->utf8 = opts->unicode_xlate = 0; 10451da177e4SLinus Torvalds opts->numtail = 1; 104628ec039cSOGAWA Hirofumi opts->usefree = opts->nocase = 0; 104758156c8fSJan Kara opts->tz_set = 0; 10487669e8fbSSteven J. Magnani opts->nfs = 0; 104985c78591SDenis Karpov opts->errors = FAT_ERRORS_RO; 10501da177e4SLinus Torvalds *debug = 0; 10511da177e4SLinus Torvalds 10521da177e4SLinus Torvalds if (!options) 10538d44d974SOGAWA Hirofumi goto out; 10541da177e4SLinus Torvalds 10551da177e4SLinus Torvalds while ((p = strsep(&options, ",")) != NULL) { 10561da177e4SLinus Torvalds int token; 10571da177e4SLinus Torvalds if (!*p) 10581da177e4SLinus Torvalds continue; 10591da177e4SLinus Torvalds 10601da177e4SLinus Torvalds token = match_token(p, fat_tokens, args); 10611da177e4SLinus Torvalds if (token == Opt_err) { 10621da177e4SLinus Torvalds if (is_vfat) 10631da177e4SLinus Torvalds token = match_token(p, vfat_tokens, args); 10641da177e4SLinus Torvalds else 10651da177e4SLinus Torvalds token = match_token(p, msdos_tokens, args); 10661da177e4SLinus Torvalds } 10671da177e4SLinus Torvalds switch (token) { 10681da177e4SLinus Torvalds case Opt_check_s: 10691da177e4SLinus Torvalds opts->name_check = 's'; 10701da177e4SLinus Torvalds break; 10711da177e4SLinus Torvalds case Opt_check_r: 10721da177e4SLinus Torvalds opts->name_check = 'r'; 10731da177e4SLinus Torvalds break; 10741da177e4SLinus Torvalds case Opt_check_n: 10751da177e4SLinus Torvalds opts->name_check = 'n'; 10761da177e4SLinus Torvalds break; 107728ec039cSOGAWA Hirofumi case Opt_usefree: 107828ec039cSOGAWA Hirofumi opts->usefree = 1; 107928ec039cSOGAWA Hirofumi break; 10801da177e4SLinus Torvalds case Opt_nocase: 10811da177e4SLinus Torvalds if (!is_vfat) 10821da177e4SLinus Torvalds opts->nocase = 1; 10831da177e4SLinus Torvalds else { 10841da177e4SLinus Torvalds /* for backward compatibility */ 10851da177e4SLinus Torvalds opts->shortname = VFAT_SFN_DISPLAY_WIN95 10861da177e4SLinus Torvalds | VFAT_SFN_CREATE_WIN95; 10871da177e4SLinus Torvalds } 10881da177e4SLinus Torvalds break; 10891da177e4SLinus Torvalds case Opt_quiet: 10901da177e4SLinus Torvalds opts->quiet = 1; 10911da177e4SLinus Torvalds break; 10921da177e4SLinus Torvalds case Opt_showexec: 10931da177e4SLinus Torvalds opts->showexec = 1; 10941da177e4SLinus Torvalds break; 10951da177e4SLinus Torvalds case Opt_debug: 10961da177e4SLinus Torvalds *debug = 1; 10971da177e4SLinus Torvalds break; 10981da177e4SLinus Torvalds case Opt_immutable: 10991da177e4SLinus Torvalds opts->sys_immutable = 1; 11001da177e4SLinus Torvalds break; 11011da177e4SLinus Torvalds case Opt_uid: 11021da177e4SLinus Torvalds if (match_int(&args[0], &option)) 11035b3d5aeaSJan Kara return -EINVAL; 1104170782ebSEric W. Biederman opts->fs_uid = make_kuid(current_user_ns(), option); 1105170782ebSEric W. Biederman if (!uid_valid(opts->fs_uid)) 11065b3d5aeaSJan Kara return -EINVAL; 11071da177e4SLinus Torvalds break; 11081da177e4SLinus Torvalds case Opt_gid: 11091da177e4SLinus Torvalds if (match_int(&args[0], &option)) 11105b3d5aeaSJan Kara return -EINVAL; 1111170782ebSEric W. Biederman opts->fs_gid = make_kgid(current_user_ns(), option); 1112170782ebSEric W. Biederman if (!gid_valid(opts->fs_gid)) 11135b3d5aeaSJan Kara return -EINVAL; 11141da177e4SLinus Torvalds break; 11151da177e4SLinus Torvalds case Opt_umask: 11161da177e4SLinus Torvalds if (match_octal(&args[0], &option)) 11175b3d5aeaSJan Kara return -EINVAL; 11181da177e4SLinus Torvalds opts->fs_fmask = opts->fs_dmask = option; 11191da177e4SLinus Torvalds break; 11201da177e4SLinus Torvalds case Opt_dmask: 11211da177e4SLinus Torvalds if (match_octal(&args[0], &option)) 11225b3d5aeaSJan Kara return -EINVAL; 11231da177e4SLinus Torvalds opts->fs_dmask = option; 11241da177e4SLinus Torvalds break; 11251da177e4SLinus Torvalds case Opt_fmask: 11261da177e4SLinus Torvalds if (match_octal(&args[0], &option)) 11275b3d5aeaSJan Kara return -EINVAL; 11281da177e4SLinus Torvalds opts->fs_fmask = option; 11291da177e4SLinus Torvalds break; 11301ae43f82SOGAWA Hirofumi case Opt_allow_utime: 11311ae43f82SOGAWA Hirofumi if (match_octal(&args[0], &option)) 11325b3d5aeaSJan Kara return -EINVAL; 11331ae43f82SOGAWA Hirofumi opts->allow_utime = option & (S_IWGRP | S_IWOTH); 11341ae43f82SOGAWA Hirofumi break; 11351da177e4SLinus Torvalds case Opt_codepage: 11361da177e4SLinus Torvalds if (match_int(&args[0], &option)) 11375b3d5aeaSJan Kara return -EINVAL; 11381da177e4SLinus Torvalds opts->codepage = option; 11391da177e4SLinus Torvalds break; 1140ae78bf9cSChris Mason case Opt_flush: 1141ae78bf9cSChris Mason opts->flush = 1; 1142ae78bf9cSChris Mason break; 114358156c8fSJan Kara case Opt_time_offset: 114458156c8fSJan Kara if (match_int(&args[0], &option)) 11455b3d5aeaSJan Kara return -EINVAL; 114658156c8fSJan Kara if (option < -12 * 60 || option > 12 * 60) 11475b3d5aeaSJan Kara return -EINVAL; 114858156c8fSJan Kara opts->tz_set = 1; 114958156c8fSJan Kara opts->time_offset = option; 115058156c8fSJan Kara break; 1151b271e067SJoe Peterson case Opt_tz_utc: 115258156c8fSJan Kara opts->tz_set = 1; 115358156c8fSJan Kara opts->time_offset = 0; 1154b271e067SJoe Peterson break; 115585c78591SDenis Karpov case Opt_err_cont: 115685c78591SDenis Karpov opts->errors = FAT_ERRORS_CONT; 115785c78591SDenis Karpov break; 115885c78591SDenis Karpov case Opt_err_panic: 115985c78591SDenis Karpov opts->errors = FAT_ERRORS_PANIC; 116085c78591SDenis Karpov break; 116185c78591SDenis Karpov case Opt_err_ro: 116285c78591SDenis Karpov opts->errors = FAT_ERRORS_RO; 116385c78591SDenis Karpov break; 11642628b7a6SNamjae Jeon case Opt_nfs_stale_rw: 11652628b7a6SNamjae Jeon opts->nfs = FAT_NFS_STALE_RW; 11662628b7a6SNamjae Jeon break; 11672628b7a6SNamjae Jeon case Opt_nfs_nostale_ro: 11682628b7a6SNamjae Jeon opts->nfs = FAT_NFS_NOSTALE_RO; 11692628b7a6SNamjae Jeon break; 1170*190a8843SConrad Meyer case Opt_dos1xfloppy: 1171*190a8843SConrad Meyer opts->dos1xfloppy = 1; 1172*190a8843SConrad Meyer break; 11731da177e4SLinus Torvalds 11741da177e4SLinus Torvalds /* msdos specific */ 11751da177e4SLinus Torvalds case Opt_dots: 11761da177e4SLinus Torvalds opts->dotsOK = 1; 11771da177e4SLinus Torvalds break; 11781da177e4SLinus Torvalds case Opt_nodots: 11791da177e4SLinus Torvalds opts->dotsOK = 0; 11801da177e4SLinus Torvalds break; 11811da177e4SLinus Torvalds 11821da177e4SLinus Torvalds /* vfat specific */ 11831da177e4SLinus Torvalds case Opt_charset: 11841da177e4SLinus Torvalds if (opts->iocharset != fat_default_iocharset) 11851da177e4SLinus Torvalds kfree(opts->iocharset); 11861da177e4SLinus Torvalds iocharset = match_strdup(&args[0]); 11871da177e4SLinus Torvalds if (!iocharset) 11881da177e4SLinus Torvalds return -ENOMEM; 11891da177e4SLinus Torvalds opts->iocharset = iocharset; 11901da177e4SLinus Torvalds break; 11911da177e4SLinus Torvalds case Opt_shortname_lower: 11921da177e4SLinus Torvalds opts->shortname = VFAT_SFN_DISPLAY_LOWER 11931da177e4SLinus Torvalds | VFAT_SFN_CREATE_WIN95; 11941da177e4SLinus Torvalds break; 11951da177e4SLinus Torvalds case Opt_shortname_win95: 11961da177e4SLinus Torvalds opts->shortname = VFAT_SFN_DISPLAY_WIN95 11971da177e4SLinus Torvalds | VFAT_SFN_CREATE_WIN95; 11981da177e4SLinus Torvalds break; 11991da177e4SLinus Torvalds case Opt_shortname_winnt: 12001da177e4SLinus Torvalds opts->shortname = VFAT_SFN_DISPLAY_WINNT 12011da177e4SLinus Torvalds | VFAT_SFN_CREATE_WINNT; 12021da177e4SLinus Torvalds break; 12031da177e4SLinus Torvalds case Opt_shortname_mixed: 12041da177e4SLinus Torvalds opts->shortname = VFAT_SFN_DISPLAY_WINNT 12051da177e4SLinus Torvalds | VFAT_SFN_CREATE_WIN95; 12061da177e4SLinus Torvalds break; 12071da177e4SLinus Torvalds case Opt_utf8_no: /* 0 or no or false */ 12081da177e4SLinus Torvalds opts->utf8 = 0; 12091da177e4SLinus Torvalds break; 12101da177e4SLinus Torvalds case Opt_utf8_yes: /* empty or 1 or yes or true */ 12111da177e4SLinus Torvalds opts->utf8 = 1; 12121da177e4SLinus Torvalds break; 12131da177e4SLinus Torvalds case Opt_uni_xl_no: /* 0 or no or false */ 12141da177e4SLinus Torvalds opts->unicode_xlate = 0; 12151da177e4SLinus Torvalds break; 12161da177e4SLinus Torvalds case Opt_uni_xl_yes: /* empty or 1 or yes or true */ 12171da177e4SLinus Torvalds opts->unicode_xlate = 1; 12181da177e4SLinus Torvalds break; 12191da177e4SLinus Torvalds case Opt_nonumtail_no: /* 0 or no or false */ 12201da177e4SLinus Torvalds opts->numtail = 1; /* negated option */ 12211da177e4SLinus Torvalds break; 12221da177e4SLinus Torvalds case Opt_nonumtail_yes: /* empty or 1 or yes or true */ 12231da177e4SLinus Torvalds opts->numtail = 0; /* negated option */ 12241da177e4SLinus Torvalds break; 1225dfc209c0SOGAWA Hirofumi case Opt_rodir: 1226dfc209c0SOGAWA Hirofumi opts->rodir = 1; 1227dfc209c0SOGAWA Hirofumi break; 1228681142f9SChristoph Hellwig case Opt_discard: 1229681142f9SChristoph Hellwig opts->discard = 1; 1230681142f9SChristoph Hellwig break; 12311da177e4SLinus Torvalds 12321da177e4SLinus Torvalds /* obsolete mount options */ 1233d7a83c0fSGeert Uytterhoeven case Opt_obsolete: 1234869f58c0SAlexey Fisher fat_msg(sb, KERN_INFO, "\"%s\" option is obsolete, " 1235869f58c0SAlexey Fisher "not supported now", p); 12361da177e4SLinus Torvalds break; 12371da177e4SLinus Torvalds /* unknown option */ 12381da177e4SLinus Torvalds default: 123941a34a4fSChristoph Hellwig if (!silent) { 1240869f58c0SAlexey Fisher fat_msg(sb, KERN_ERR, 1241869f58c0SAlexey Fisher "Unrecognized mount option \"%s\" " 1242869f58c0SAlexey Fisher "or missing value", p); 124341a34a4fSChristoph Hellwig } 12441da177e4SLinus Torvalds return -EINVAL; 12451da177e4SLinus Torvalds } 12461da177e4SLinus Torvalds } 12478d44d974SOGAWA Hirofumi 12488d44d974SOGAWA Hirofumi out: 12494de151d8SAlexey Dobriyan /* UTF-8 doesn't provide FAT semantics */ 12501da177e4SLinus Torvalds if (!strcmp(opts->iocharset, "utf8")) { 1251186b5370SMihai Moldovan fat_msg(sb, KERN_WARNING, "utf8 is not a recommended IO charset" 12528d44d974SOGAWA Hirofumi " for FAT filesystems, filesystem will be " 1253186b5370SMihai Moldovan "case sensitive!"); 12541da177e4SLinus Torvalds } 12551da177e4SLinus Torvalds 12561ae43f82SOGAWA Hirofumi /* If user doesn't specify allow_utime, it's initialized from dmask. */ 12571ae43f82SOGAWA Hirofumi if (opts->allow_utime == (unsigned short)-1) 12581ae43f82SOGAWA Hirofumi opts->allow_utime = ~opts->fs_dmask & (S_IWGRP | S_IWOTH); 12591da177e4SLinus Torvalds if (opts->unicode_xlate) 12601da177e4SLinus Torvalds opts->utf8 = 0; 1261ea3983acSNamjae Jeon if (opts->nfs == FAT_NFS_NOSTALE_RO) { 12622628b7a6SNamjae Jeon sb->s_flags |= MS_RDONLY; 1263ea3983acSNamjae Jeon sb->s_export_op = &fat_export_ops_nostale; 1264ea3983acSNamjae Jeon } 12651da177e4SLinus Torvalds 12661da177e4SLinus Torvalds return 0; 12671da177e4SLinus Torvalds } 12681da177e4SLinus Torvalds 12691da177e4SLinus Torvalds static int fat_read_root(struct inode *inode) 12701da177e4SLinus Torvalds { 12711da177e4SLinus Torvalds struct super_block *sb = inode->i_sb; 12721da177e4SLinus Torvalds struct msdos_sb_info *sbi = MSDOS_SB(sb); 12731da177e4SLinus Torvalds int error; 12741da177e4SLinus Torvalds 1275ea3983acSNamjae Jeon MSDOS_I(inode)->i_pos = MSDOS_ROOT_INO; 12761da177e4SLinus Torvalds inode->i_uid = sbi->options.fs_uid; 12771da177e4SLinus Torvalds inode->i_gid = sbi->options.fs_gid; 12781da177e4SLinus Torvalds inode->i_version++; 12791da177e4SLinus Torvalds inode->i_generation = 0; 12809c0aa1b8SOGAWA Hirofumi inode->i_mode = fat_make_mode(sbi, ATTR_DIR, S_IRWXUGO); 12811da177e4SLinus Torvalds inode->i_op = sbi->dir_ops; 12821da177e4SLinus Torvalds inode->i_fop = &fat_dir_operations; 12831da177e4SLinus Torvalds if (sbi->fat_bits == 32) { 12841da177e4SLinus Torvalds MSDOS_I(inode)->i_start = sbi->root_cluster; 12851da177e4SLinus Torvalds error = fat_calc_dir_size(inode); 12861da177e4SLinus Torvalds if (error < 0) 12871da177e4SLinus Torvalds return error; 12881da177e4SLinus Torvalds } else { 12891da177e4SLinus Torvalds MSDOS_I(inode)->i_start = 0; 12901da177e4SLinus Torvalds inode->i_size = sbi->dir_entries * sizeof(struct msdos_dir_entry); 12911da177e4SLinus Torvalds } 12921da177e4SLinus Torvalds inode->i_blocks = ((inode->i_size + (sbi->cluster_size - 1)) 12931da177e4SLinus Torvalds & ~((loff_t)sbi->cluster_size - 1)) >> 9; 12941da177e4SLinus Torvalds MSDOS_I(inode)->i_logstart = 0; 12951da177e4SLinus Torvalds MSDOS_I(inode)->mmu_private = inode->i_size; 12961da177e4SLinus Torvalds 12979c0aa1b8SOGAWA Hirofumi fat_save_attrs(inode, ATTR_DIR); 12981da177e4SLinus Torvalds inode->i_mtime.tv_sec = inode->i_atime.tv_sec = inode->i_ctime.tv_sec = 0; 12991da177e4SLinus Torvalds inode->i_mtime.tv_nsec = inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = 0; 1300bfe86848SMiklos Szeredi set_nlink(inode, fat_subdirs(inode)+2); 13011da177e4SLinus Torvalds 13021da177e4SLinus Torvalds return 0; 13031da177e4SLinus Torvalds } 13041da177e4SLinus Torvalds 13057b92d03cSOGAWA Hirofumi static unsigned long calc_fat_clusters(struct super_block *sb) 13067b92d03cSOGAWA Hirofumi { 13077b92d03cSOGAWA Hirofumi struct msdos_sb_info *sbi = MSDOS_SB(sb); 13087b92d03cSOGAWA Hirofumi 13097b92d03cSOGAWA Hirofumi /* Divide first to avoid overflow */ 13107b92d03cSOGAWA Hirofumi if (sbi->fat_bits != 12) { 13117b92d03cSOGAWA Hirofumi unsigned long ent_per_sec = sb->s_blocksize * 8 / sbi->fat_bits; 13127b92d03cSOGAWA Hirofumi return ent_per_sec * sbi->fat_length; 13137b92d03cSOGAWA Hirofumi } 13147b92d03cSOGAWA Hirofumi 13157b92d03cSOGAWA Hirofumi return sbi->fat_length * sb->s_blocksize * 8 / sbi->fat_bits; 13167b92d03cSOGAWA Hirofumi } 13177b92d03cSOGAWA Hirofumi 1318*190a8843SConrad Meyer static bool fat_bpb_is_zero(struct fat_boot_sector *b) 1319*190a8843SConrad Meyer { 1320*190a8843SConrad Meyer if (get_unaligned_le16(&b->sector_size)) 1321*190a8843SConrad Meyer return false; 1322*190a8843SConrad Meyer if (b->sec_per_clus) 1323*190a8843SConrad Meyer return false; 1324*190a8843SConrad Meyer if (b->reserved) 1325*190a8843SConrad Meyer return false; 1326*190a8843SConrad Meyer if (b->fats) 1327*190a8843SConrad Meyer return false; 1328*190a8843SConrad Meyer if (get_unaligned_le16(&b->dir_entries)) 1329*190a8843SConrad Meyer return false; 1330*190a8843SConrad Meyer if (get_unaligned_le16(&b->sectors)) 1331*190a8843SConrad Meyer return false; 1332*190a8843SConrad Meyer if (b->media) 1333*190a8843SConrad Meyer return false; 1334*190a8843SConrad Meyer if (b->fat_length) 1335*190a8843SConrad Meyer return false; 1336*190a8843SConrad Meyer if (b->secs_track) 1337*190a8843SConrad Meyer return false; 1338*190a8843SConrad Meyer if (b->heads) 1339*190a8843SConrad Meyer return false; 1340*190a8843SConrad Meyer return true; 1341*190a8843SConrad Meyer } 1342*190a8843SConrad Meyer 1343*190a8843SConrad Meyer static int fat_read_bpb(struct super_block *sb, struct fat_boot_sector *b, 1344*190a8843SConrad Meyer int silent, struct fat_bios_param_block *bpb) 1345*190a8843SConrad Meyer { 1346*190a8843SConrad Meyer int error = -EINVAL; 1347*190a8843SConrad Meyer 1348*190a8843SConrad Meyer /* Read in BPB ... */ 1349*190a8843SConrad Meyer memset(bpb, 0, sizeof(*bpb)); 1350*190a8843SConrad Meyer bpb->fat_sector_size = get_unaligned_le16(&b->sector_size); 1351*190a8843SConrad Meyer bpb->fat_sec_per_clus = b->sec_per_clus; 1352*190a8843SConrad Meyer bpb->fat_reserved = le16_to_cpu(b->reserved); 1353*190a8843SConrad Meyer bpb->fat_fats = b->fats; 1354*190a8843SConrad Meyer bpb->fat_dir_entries = get_unaligned_le16(&b->dir_entries); 1355*190a8843SConrad Meyer bpb->fat_sectors = get_unaligned_le16(&b->sectors); 1356*190a8843SConrad Meyer bpb->fat_fat_length = le16_to_cpu(b->fat_length); 1357*190a8843SConrad Meyer bpb->fat_total_sect = le32_to_cpu(b->total_sect); 1358*190a8843SConrad Meyer 1359*190a8843SConrad Meyer bpb->fat16_state = b->fat16.state; 1360*190a8843SConrad Meyer bpb->fat16_vol_id = get_unaligned_le32(b->fat16.vol_id); 1361*190a8843SConrad Meyer 1362*190a8843SConrad Meyer bpb->fat32_length = le32_to_cpu(b->fat32.length); 1363*190a8843SConrad Meyer bpb->fat32_root_cluster = le32_to_cpu(b->fat32.root_cluster); 1364*190a8843SConrad Meyer bpb->fat32_info_sector = le16_to_cpu(b->fat32.info_sector); 1365*190a8843SConrad Meyer bpb->fat32_state = b->fat32.state; 1366*190a8843SConrad Meyer bpb->fat32_vol_id = get_unaligned_le32(b->fat32.vol_id); 1367*190a8843SConrad Meyer 1368*190a8843SConrad Meyer /* Validate this looks like a FAT filesystem BPB */ 1369*190a8843SConrad Meyer if (!bpb->fat_reserved) { 1370*190a8843SConrad Meyer if (!silent) 1371*190a8843SConrad Meyer fat_msg(sb, KERN_ERR, 1372*190a8843SConrad Meyer "bogus number of reserved sectors"); 1373*190a8843SConrad Meyer goto out; 1374*190a8843SConrad Meyer } 1375*190a8843SConrad Meyer if (!bpb->fat_fats) { 1376*190a8843SConrad Meyer if (!silent) 1377*190a8843SConrad Meyer fat_msg(sb, KERN_ERR, "bogus number of FAT structure"); 1378*190a8843SConrad Meyer goto out; 1379*190a8843SConrad Meyer } 1380*190a8843SConrad Meyer 1381*190a8843SConrad Meyer /* 1382*190a8843SConrad Meyer * Earlier we checked here that b->secs_track and b->head are nonzero, 1383*190a8843SConrad Meyer * but it turns out valid FAT filesystems can have zero there. 1384*190a8843SConrad Meyer */ 1385*190a8843SConrad Meyer 1386*190a8843SConrad Meyer if (!fat_valid_media(b->media)) { 1387*190a8843SConrad Meyer if (!silent) 1388*190a8843SConrad Meyer fat_msg(sb, KERN_ERR, "invalid media value (0x%02x)", 1389*190a8843SConrad Meyer (unsigned)b->media); 1390*190a8843SConrad Meyer goto out; 1391*190a8843SConrad Meyer } 1392*190a8843SConrad Meyer 1393*190a8843SConrad Meyer if (!is_power_of_2(bpb->fat_sector_size) 1394*190a8843SConrad Meyer || (bpb->fat_sector_size < 512) 1395*190a8843SConrad Meyer || (bpb->fat_sector_size > 4096)) { 1396*190a8843SConrad Meyer if (!silent) 1397*190a8843SConrad Meyer fat_msg(sb, KERN_ERR, "bogus logical sector size %u", 1398*190a8843SConrad Meyer (unsigned)bpb->fat_sector_size); 1399*190a8843SConrad Meyer goto out; 1400*190a8843SConrad Meyer } 1401*190a8843SConrad Meyer 1402*190a8843SConrad Meyer if (!is_power_of_2(bpb->fat_sec_per_clus)) { 1403*190a8843SConrad Meyer if (!silent) 1404*190a8843SConrad Meyer fat_msg(sb, KERN_ERR, "bogus sectors per cluster %u", 1405*190a8843SConrad Meyer (unsigned)bpb->fat_sec_per_clus); 1406*190a8843SConrad Meyer goto out; 1407*190a8843SConrad Meyer } 1408*190a8843SConrad Meyer 1409*190a8843SConrad Meyer error = 0; 1410*190a8843SConrad Meyer 1411*190a8843SConrad Meyer out: 1412*190a8843SConrad Meyer return error; 1413*190a8843SConrad Meyer } 1414*190a8843SConrad Meyer 1415*190a8843SConrad Meyer static int fat_read_static_bpb(struct super_block *sb, 1416*190a8843SConrad Meyer struct fat_boot_sector *b, int silent, 1417*190a8843SConrad Meyer struct fat_bios_param_block *bpb) 1418*190a8843SConrad Meyer { 1419*190a8843SConrad Meyer static const char *notdos1x = "This doesn't look like a DOS 1.x volume"; 1420*190a8843SConrad Meyer 1421*190a8843SConrad Meyer struct fat_floppy_defaults *fdefaults = NULL; 1422*190a8843SConrad Meyer int error = -EINVAL; 1423*190a8843SConrad Meyer sector_t bd_sects; 1424*190a8843SConrad Meyer unsigned i; 1425*190a8843SConrad Meyer 1426*190a8843SConrad Meyer bd_sects = i_size_read(sb->s_bdev->bd_inode) / SECTOR_SIZE; 1427*190a8843SConrad Meyer 1428*190a8843SConrad Meyer /* 16-bit DOS 1.x reliably wrote bootstrap short-jmp code */ 1429*190a8843SConrad Meyer if (b->ignored[0] != 0xeb || b->ignored[2] != 0x90) { 1430*190a8843SConrad Meyer if (!silent) 1431*190a8843SConrad Meyer fat_msg(sb, KERN_ERR, 1432*190a8843SConrad Meyer "%s; no bootstrapping code", notdos1x); 1433*190a8843SConrad Meyer goto out; 1434*190a8843SConrad Meyer } 1435*190a8843SConrad Meyer 1436*190a8843SConrad Meyer /* 1437*190a8843SConrad Meyer * If any value in this region is non-zero, it isn't archaic 1438*190a8843SConrad Meyer * DOS. 1439*190a8843SConrad Meyer */ 1440*190a8843SConrad Meyer if (!fat_bpb_is_zero(b)) { 1441*190a8843SConrad Meyer if (!silent) 1442*190a8843SConrad Meyer fat_msg(sb, KERN_ERR, 1443*190a8843SConrad Meyer "%s; DOS 2.x BPB is non-zero", notdos1x); 1444*190a8843SConrad Meyer goto out; 1445*190a8843SConrad Meyer } 1446*190a8843SConrad Meyer 1447*190a8843SConrad Meyer for (i = 0; i < ARRAY_SIZE(floppy_defaults); i++) { 1448*190a8843SConrad Meyer if (floppy_defaults[i].nr_sectors == bd_sects) { 1449*190a8843SConrad Meyer fdefaults = &floppy_defaults[i]; 1450*190a8843SConrad Meyer break; 1451*190a8843SConrad Meyer } 1452*190a8843SConrad Meyer } 1453*190a8843SConrad Meyer 1454*190a8843SConrad Meyer if (fdefaults == NULL) { 1455*190a8843SConrad Meyer if (!silent) 1456*190a8843SConrad Meyer fat_msg(sb, KERN_WARNING, 1457*190a8843SConrad Meyer "This looks like a DOS 1.x volume, but isn't a recognized floppy size (%llu sectors)", 1458*190a8843SConrad Meyer (u64)bd_sects); 1459*190a8843SConrad Meyer goto out; 1460*190a8843SConrad Meyer } 1461*190a8843SConrad Meyer 1462*190a8843SConrad Meyer if (!silent) 1463*190a8843SConrad Meyer fat_msg(sb, KERN_INFO, 1464*190a8843SConrad Meyer "This looks like a DOS 1.x volume; assuming default BPB values"); 1465*190a8843SConrad Meyer 1466*190a8843SConrad Meyer memset(bpb, 0, sizeof(*bpb)); 1467*190a8843SConrad Meyer bpb->fat_sector_size = SECTOR_SIZE; 1468*190a8843SConrad Meyer bpb->fat_sec_per_clus = fdefaults->sec_per_clus; 1469*190a8843SConrad Meyer bpb->fat_reserved = 1; 1470*190a8843SConrad Meyer bpb->fat_fats = 2; 1471*190a8843SConrad Meyer bpb->fat_dir_entries = fdefaults->dir_entries; 1472*190a8843SConrad Meyer bpb->fat_sectors = fdefaults->nr_sectors; 1473*190a8843SConrad Meyer bpb->fat_fat_length = fdefaults->fat_length; 1474*190a8843SConrad Meyer 1475*190a8843SConrad Meyer error = 0; 1476*190a8843SConrad Meyer 1477*190a8843SConrad Meyer out: 1478*190a8843SConrad Meyer return error; 1479*190a8843SConrad Meyer } 1480*190a8843SConrad Meyer 14811da177e4SLinus Torvalds /* 14821da177e4SLinus Torvalds * Read the super block of an MS-DOS FS. 14831da177e4SLinus Torvalds */ 1484384f5c96SOGAWA Hirofumi int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat, 14853d23985dSAl Viro void (*setup)(struct super_block *)) 14861da177e4SLinus Torvalds { 1487b522412aSAl Viro struct inode *root_inode = NULL, *fat_inode = NULL; 1488020ac5b6SArtem Bityutskiy struct inode *fsinfo_inode = NULL; 14891da177e4SLinus Torvalds struct buffer_head *bh; 1490*190a8843SConrad Meyer struct fat_bios_param_block bpb; 14911da177e4SLinus Torvalds struct msdos_sb_info *sbi; 14921da177e4SLinus Torvalds u16 logical_sector_size; 14931da177e4SLinus Torvalds u32 total_sectors, total_clusters, fat_clusters, rootdir_sectors; 14941da177e4SLinus Torvalds int debug; 14951da177e4SLinus Torvalds long error; 14961da177e4SLinus Torvalds char buf[50]; 14971da177e4SLinus Torvalds 14988f593427SLinus Torvalds /* 14998f593427SLinus Torvalds * GFP_KERNEL is ok here, because while we do hold the 15008f593427SLinus Torvalds * supeblock lock, memory pressure can't call back into 15018f593427SLinus Torvalds * the filesystem, since we're only just about to mount 15028f593427SLinus Torvalds * it and have no inodes etc active! 15038f593427SLinus Torvalds */ 1504f8314dc6SPanagiotis Issaris sbi = kzalloc(sizeof(struct msdos_sb_info), GFP_KERNEL); 15051da177e4SLinus Torvalds if (!sbi) 15061da177e4SLinus Torvalds return -ENOMEM; 15071da177e4SLinus Torvalds sb->s_fs_info = sbi; 15081da177e4SLinus Torvalds 15091da177e4SLinus Torvalds sb->s_flags |= MS_NODIRATIME; 15101da177e4SLinus Torvalds sb->s_magic = MSDOS_SUPER_MAGIC; 15111da177e4SLinus Torvalds sb->s_op = &fat_sops; 15121da177e4SLinus Torvalds sb->s_export_op = &fat_export_ops; 15138fceb4e0SNamjae Jeon mutex_init(&sbi->nfs_build_inode_lock); 1514aaa04b48SOGAWA Hirofumi ratelimit_state_init(&sbi->ratelimit, DEFAULT_RATELIMIT_INTERVAL, 1515aaa04b48SOGAWA Hirofumi DEFAULT_RATELIMIT_BURST); 15161da177e4SLinus Torvalds 1517869f58c0SAlexey Fisher error = parse_options(sb, data, isvfat, silent, &debug, &sbi->options); 15181da177e4SLinus Torvalds if (error) 15191da177e4SLinus Torvalds goto out_fail; 15201da177e4SLinus Torvalds 15213d23985dSAl Viro setup(sb); /* flavour-specific stuff that needs options */ 15223d23985dSAl Viro 15231da177e4SLinus Torvalds error = -EIO; 15241da177e4SLinus Torvalds sb_min_blocksize(sb, 512); 15251da177e4SLinus Torvalds bh = sb_bread(sb, 0); 15261da177e4SLinus Torvalds if (bh == NULL) { 1527869f58c0SAlexey Fisher fat_msg(sb, KERN_ERR, "unable to read boot sector"); 15281da177e4SLinus Torvalds goto out_fail; 15291da177e4SLinus Torvalds } 15301da177e4SLinus Torvalds 1531*190a8843SConrad Meyer error = fat_read_bpb(sb, (struct fat_boot_sector *)bh->b_data, silent, 1532*190a8843SConrad Meyer &bpb); 1533*190a8843SConrad Meyer if (error == -EINVAL && sbi->options.dos1xfloppy) 1534*190a8843SConrad Meyer error = fat_read_static_bpb(sb, 1535*190a8843SConrad Meyer (struct fat_boot_sector *)bh->b_data, silent, &bpb); 15361da177e4SLinus Torvalds brelse(bh); 15371da177e4SLinus Torvalds 1538*190a8843SConrad Meyer if (error == -EINVAL) 1539*190a8843SConrad Meyer goto out_invalid; 1540*190a8843SConrad Meyer else if (error) 1541*190a8843SConrad Meyer goto out_fail; 15421da177e4SLinus Torvalds 1543*190a8843SConrad Meyer logical_sector_size = bpb.fat_sector_size; 1544*190a8843SConrad Meyer sbi->sec_per_clus = bpb.fat_sec_per_clus; 15451da177e4SLinus Torvalds 1546*190a8843SConrad Meyer error = -EIO; 15471da177e4SLinus Torvalds if (logical_sector_size < sb->s_blocksize) { 1548869f58c0SAlexey Fisher fat_msg(sb, KERN_ERR, "logical sector size too small for device" 1549869f58c0SAlexey Fisher " (logical sector size = %u)", logical_sector_size); 15501da177e4SLinus Torvalds goto out_fail; 15511da177e4SLinus Torvalds } 1552*190a8843SConrad Meyer 15531da177e4SLinus Torvalds if (logical_sector_size > sb->s_blocksize) { 1554*190a8843SConrad Meyer struct buffer_head *bh_resize; 15551da177e4SLinus Torvalds 15561da177e4SLinus Torvalds if (!sb_set_blocksize(sb, logical_sector_size)) { 1557869f58c0SAlexey Fisher fat_msg(sb, KERN_ERR, "unable to set blocksize %u", 15581da177e4SLinus Torvalds logical_sector_size); 15591da177e4SLinus Torvalds goto out_fail; 15601da177e4SLinus Torvalds } 1561*190a8843SConrad Meyer 1562*190a8843SConrad Meyer /* Verify that the larger boot sector is fully readable */ 1563*190a8843SConrad Meyer bh_resize = sb_bread(sb, 0); 1564*190a8843SConrad Meyer if (bh_resize == NULL) { 1565869f58c0SAlexey Fisher fat_msg(sb, KERN_ERR, "unable to read boot sector" 1566869f58c0SAlexey Fisher " (logical sector size = %lu)", 15671da177e4SLinus Torvalds sb->s_blocksize); 15681da177e4SLinus Torvalds goto out_fail; 15691da177e4SLinus Torvalds } 1570*190a8843SConrad Meyer brelse(bh_resize); 15711da177e4SLinus Torvalds } 15721da177e4SLinus Torvalds 1573e40b34c7SMarco Stornelli mutex_init(&sbi->s_lock); 15741da177e4SLinus Torvalds sbi->cluster_size = sb->s_blocksize * sbi->sec_per_clus; 15751da177e4SLinus Torvalds sbi->cluster_bits = ffs(sbi->cluster_size) - 1; 1576*190a8843SConrad Meyer sbi->fats = bpb.fat_fats; 15771da177e4SLinus Torvalds sbi->fat_bits = 0; /* Don't know yet */ 1578*190a8843SConrad Meyer sbi->fat_start = bpb.fat_reserved; 1579*190a8843SConrad Meyer sbi->fat_length = bpb.fat_fat_length; 15801da177e4SLinus Torvalds sbi->root_cluster = 0; 15811da177e4SLinus Torvalds sbi->free_clusters = -1; /* Don't know yet */ 1582606e423eSOGAWA Hirofumi sbi->free_clus_valid = 0; 15831da177e4SLinus Torvalds sbi->prev_free = FAT_START_ENT; 1584710d4403SNamjae Jeon sb->s_maxbytes = 0xffffffff; 15851da177e4SLinus Torvalds 1586*190a8843SConrad Meyer if (!sbi->fat_length && bpb.fat32_length) { 15871da177e4SLinus Torvalds struct fat_boot_fsinfo *fsinfo; 15881da177e4SLinus Torvalds struct buffer_head *fsinfo_bh; 15891da177e4SLinus Torvalds 15901da177e4SLinus Torvalds /* Must be FAT32 */ 15911da177e4SLinus Torvalds sbi->fat_bits = 32; 1592*190a8843SConrad Meyer sbi->fat_length = bpb.fat32_length; 1593*190a8843SConrad Meyer sbi->root_cluster = bpb.fat32_root_cluster; 15941da177e4SLinus Torvalds 15951da177e4SLinus Torvalds /* MC - if info_sector is 0, don't multiply by 0 */ 1596*190a8843SConrad Meyer sbi->fsinfo_sector = bpb.fat32_info_sector; 15971da177e4SLinus Torvalds if (sbi->fsinfo_sector == 0) 15981da177e4SLinus Torvalds sbi->fsinfo_sector = 1; 15991da177e4SLinus Torvalds 16001da177e4SLinus Torvalds fsinfo_bh = sb_bread(sb, sbi->fsinfo_sector); 16011da177e4SLinus Torvalds if (fsinfo_bh == NULL) { 1602869f58c0SAlexey Fisher fat_msg(sb, KERN_ERR, "bread failed, FSINFO block" 1603869f58c0SAlexey Fisher " (sector = %lu)", sbi->fsinfo_sector); 16041da177e4SLinus Torvalds goto out_fail; 16051da177e4SLinus Torvalds } 16061da177e4SLinus Torvalds 16071da177e4SLinus Torvalds fsinfo = (struct fat_boot_fsinfo *)fsinfo_bh->b_data; 16081da177e4SLinus Torvalds if (!IS_FSINFO(fsinfo)) { 1609869f58c0SAlexey Fisher fat_msg(sb, KERN_WARNING, "Invalid FSINFO signature: " 1610869f58c0SAlexey Fisher "0x%08x, 0x%08x (sector = %lu)", 16111da177e4SLinus Torvalds le32_to_cpu(fsinfo->signature1), 16121da177e4SLinus Torvalds le32_to_cpu(fsinfo->signature2), 16131da177e4SLinus Torvalds sbi->fsinfo_sector); 16141da177e4SLinus Torvalds } else { 161528ec039cSOGAWA Hirofumi if (sbi->options.usefree) 1616606e423eSOGAWA Hirofumi sbi->free_clus_valid = 1; 1617606e423eSOGAWA Hirofumi sbi->free_clusters = le32_to_cpu(fsinfo->free_clusters); 16181da177e4SLinus Torvalds sbi->prev_free = le32_to_cpu(fsinfo->next_cluster); 16191da177e4SLinus Torvalds } 16201da177e4SLinus Torvalds 16211da177e4SLinus Torvalds brelse(fsinfo_bh); 16221da177e4SLinus Torvalds } 16231da177e4SLinus Torvalds 16246e5b93eeSMike Lockwood /* interpret volume ID as a little endian 32 bit integer */ 16256e5b93eeSMike Lockwood if (sbi->fat_bits == 32) 1626*190a8843SConrad Meyer sbi->vol_id = bpb.fat32_vol_id; 16276e5b93eeSMike Lockwood else /* fat 16 or 12 */ 1628*190a8843SConrad Meyer sbi->vol_id = bpb.fat16_vol_id; 16296e5b93eeSMike Lockwood 16301da177e4SLinus Torvalds sbi->dir_per_block = sb->s_blocksize / sizeof(struct msdos_dir_entry); 16311da177e4SLinus Torvalds sbi->dir_per_block_bits = ffs(sbi->dir_per_block) - 1; 16321da177e4SLinus Torvalds 16331da177e4SLinus Torvalds sbi->dir_start = sbi->fat_start + sbi->fats * sbi->fat_length; 1634*190a8843SConrad Meyer sbi->dir_entries = bpb.fat_dir_entries; 16351da177e4SLinus Torvalds if (sbi->dir_entries & (sbi->dir_per_block - 1)) { 16361da177e4SLinus Torvalds if (!silent) 1637c39540c6SRavishankar N fat_msg(sb, KERN_ERR, "bogus directory-entries per block" 1638869f58c0SAlexey Fisher " (%u)", sbi->dir_entries); 16391da177e4SLinus Torvalds goto out_invalid; 16401da177e4SLinus Torvalds } 16411da177e4SLinus Torvalds 16421da177e4SLinus Torvalds rootdir_sectors = sbi->dir_entries 16431da177e4SLinus Torvalds * sizeof(struct msdos_dir_entry) / sb->s_blocksize; 16441da177e4SLinus Torvalds sbi->data_start = sbi->dir_start + rootdir_sectors; 1645*190a8843SConrad Meyer total_sectors = bpb.fat_sectors; 16461da177e4SLinus Torvalds if (total_sectors == 0) 1647*190a8843SConrad Meyer total_sectors = bpb.fat_total_sect; 16481da177e4SLinus Torvalds 16491da177e4SLinus Torvalds total_clusters = (total_sectors - sbi->data_start) / sbi->sec_per_clus; 16501da177e4SLinus Torvalds 16511da177e4SLinus Torvalds if (sbi->fat_bits != 32) 16521da177e4SLinus Torvalds sbi->fat_bits = (total_clusters > MAX_FAT12) ? 16 : 12; 16531da177e4SLinus Torvalds 1654b88a1058SOleksij Rempel /* some OSes set FAT_STATE_DIRTY and clean it on unmount. */ 1655b88a1058SOleksij Rempel if (sbi->fat_bits == 32) 1656*190a8843SConrad Meyer sbi->dirty = bpb.fat32_state & FAT_STATE_DIRTY; 1657b88a1058SOleksij Rempel else /* fat 16 or 12 */ 1658*190a8843SConrad Meyer sbi->dirty = bpb.fat16_state & FAT_STATE_DIRTY; 1659b88a1058SOleksij Rempel 16601da177e4SLinus Torvalds /* check that FAT table does not overflow */ 16617b92d03cSOGAWA Hirofumi fat_clusters = calc_fat_clusters(sb); 16621da177e4SLinus Torvalds total_clusters = min(total_clusters, fat_clusters - FAT_START_ENT); 16631da177e4SLinus Torvalds if (total_clusters > MAX_FAT(sb)) { 16641da177e4SLinus Torvalds if (!silent) 1665869f58c0SAlexey Fisher fat_msg(sb, KERN_ERR, "count of clusters too big (%u)", 16661da177e4SLinus Torvalds total_clusters); 16671da177e4SLinus Torvalds goto out_invalid; 16681da177e4SLinus Torvalds } 16691da177e4SLinus Torvalds 16701da177e4SLinus Torvalds sbi->max_cluster = total_clusters + FAT_START_ENT; 16711da177e4SLinus Torvalds /* check the free_clusters, it's not necessarily correct */ 16721da177e4SLinus Torvalds if (sbi->free_clusters != -1 && sbi->free_clusters > total_clusters) 16731da177e4SLinus Torvalds sbi->free_clusters = -1; 16741da177e4SLinus Torvalds /* check the prev_free, it's not necessarily correct */ 16751da177e4SLinus Torvalds sbi->prev_free %= sbi->max_cluster; 16761da177e4SLinus Torvalds if (sbi->prev_free < FAT_START_ENT) 16771da177e4SLinus Torvalds sbi->prev_free = FAT_START_ENT; 16781da177e4SLinus Torvalds 16791da177e4SLinus Torvalds /* set up enough so that it can read an inode */ 16801da177e4SLinus Torvalds fat_hash_init(sb); 16817669e8fbSSteven J. Magnani dir_hash_init(sb); 16821da177e4SLinus Torvalds fat_ent_access_init(sb); 16831da177e4SLinus Torvalds 16841da177e4SLinus Torvalds /* 16851da177e4SLinus Torvalds * The low byte of FAT's first entry must have same value with 16861da177e4SLinus Torvalds * media-field. But in real world, too many devices is 16871da177e4SLinus Torvalds * writing wrong value. So, removed that validity check. 16881da177e4SLinus Torvalds * 16891da177e4SLinus Torvalds * if (FAT_FIRST_ENT(sb, media) != first) 16901da177e4SLinus Torvalds */ 16911da177e4SLinus Torvalds 16921da177e4SLinus Torvalds error = -EINVAL; 16931da177e4SLinus Torvalds sprintf(buf, "cp%d", sbi->options.codepage); 16941da177e4SLinus Torvalds sbi->nls_disk = load_nls(buf); 16951da177e4SLinus Torvalds if (!sbi->nls_disk) { 1696869f58c0SAlexey Fisher fat_msg(sb, KERN_ERR, "codepage %s not found", buf); 16971da177e4SLinus Torvalds goto out_fail; 16981da177e4SLinus Torvalds } 16991da177e4SLinus Torvalds 17001da177e4SLinus Torvalds /* FIXME: utf8 is using iocharset for upper/lower conversion */ 17011da177e4SLinus Torvalds if (sbi->options.isvfat) { 17021da177e4SLinus Torvalds sbi->nls_io = load_nls(sbi->options.iocharset); 17031da177e4SLinus Torvalds if (!sbi->nls_io) { 1704869f58c0SAlexey Fisher fat_msg(sb, KERN_ERR, "IO charset %s not found", 17051da177e4SLinus Torvalds sbi->options.iocharset); 17061da177e4SLinus Torvalds goto out_fail; 17071da177e4SLinus Torvalds } 17081da177e4SLinus Torvalds } 17091da177e4SLinus Torvalds 17101da177e4SLinus Torvalds error = -ENOMEM; 1711b522412aSAl Viro fat_inode = new_inode(sb); 1712b522412aSAl Viro if (!fat_inode) 1713b522412aSAl Viro goto out_fail; 1714b522412aSAl Viro MSDOS_I(fat_inode)->i_pos = 0; 1715b522412aSAl Viro sbi->fat_inode = fat_inode; 1716020ac5b6SArtem Bityutskiy 1717020ac5b6SArtem Bityutskiy fsinfo_inode = new_inode(sb); 1718020ac5b6SArtem Bityutskiy if (!fsinfo_inode) 1719020ac5b6SArtem Bityutskiy goto out_fail; 1720020ac5b6SArtem Bityutskiy fsinfo_inode->i_ino = MSDOS_FSINFO_INO; 1721020ac5b6SArtem Bityutskiy sbi->fsinfo_inode = fsinfo_inode; 1722020ac5b6SArtem Bityutskiy insert_inode_hash(fsinfo_inode); 1723020ac5b6SArtem Bityutskiy 17241da177e4SLinus Torvalds root_inode = new_inode(sb); 17251da177e4SLinus Torvalds if (!root_inode) 17261da177e4SLinus Torvalds goto out_fail; 17271da177e4SLinus Torvalds root_inode->i_ino = MSDOS_ROOT_INO; 17281da177e4SLinus Torvalds root_inode->i_version = 1; 17291da177e4SLinus Torvalds error = fat_read_root(root_inode); 17301688f860SAl Viro if (error < 0) { 17311688f860SAl Viro iput(root_inode); 17321da177e4SLinus Torvalds goto out_fail; 17331688f860SAl Viro } 17341da177e4SLinus Torvalds error = -ENOMEM; 17351da177e4SLinus Torvalds insert_inode_hash(root_inode); 17367669e8fbSSteven J. Magnani fat_attach(root_inode, 0); 17371688f860SAl Viro sb->s_root = d_make_root(root_inode); 17381da177e4SLinus Torvalds if (!sb->s_root) { 1739869f58c0SAlexey Fisher fat_msg(sb, KERN_ERR, "get root inode failed"); 17401da177e4SLinus Torvalds goto out_fail; 17411da177e4SLinus Torvalds } 17421da177e4SLinus Torvalds 1743f562146aSNamjae Jeon if (sbi->options.discard) { 1744f562146aSNamjae Jeon struct request_queue *q = bdev_get_queue(sb->s_bdev); 1745f562146aSNamjae Jeon if (!blk_queue_discard(q)) 1746f562146aSNamjae Jeon fat_msg(sb, KERN_WARNING, 1747f562146aSNamjae Jeon "mounting with \"discard\" option, but " 1748f562146aSNamjae Jeon "the device does not support discard"); 1749f562146aSNamjae Jeon } 1750f562146aSNamjae Jeon 1751b88a1058SOleksij Rempel fat_set_state(sb, 1, 0); 17521da177e4SLinus Torvalds return 0; 17531da177e4SLinus Torvalds 17541da177e4SLinus Torvalds out_invalid: 17551da177e4SLinus Torvalds error = -EINVAL; 17561da177e4SLinus Torvalds if (!silent) 1757869f58c0SAlexey Fisher fat_msg(sb, KERN_INFO, "Can't find a valid FAT filesystem"); 17581da177e4SLinus Torvalds 17591da177e4SLinus Torvalds out_fail: 1760020ac5b6SArtem Bityutskiy if (fsinfo_inode) 1761020ac5b6SArtem Bityutskiy iput(fsinfo_inode); 1762b522412aSAl Viro if (fat_inode) 1763b522412aSAl Viro iput(fat_inode); 17641da177e4SLinus Torvalds unload_nls(sbi->nls_io); 17651da177e4SLinus Torvalds unload_nls(sbi->nls_disk); 17661da177e4SLinus Torvalds if (sbi->options.iocharset != fat_default_iocharset) 17671da177e4SLinus Torvalds kfree(sbi->options.iocharset); 17681da177e4SLinus Torvalds sb->s_fs_info = NULL; 17691da177e4SLinus Torvalds kfree(sbi); 17701da177e4SLinus Torvalds return error; 17711da177e4SLinus Torvalds } 17721da177e4SLinus Torvalds 17737c709d00SOGAWA Hirofumi EXPORT_SYMBOL_GPL(fat_fill_super); 17741da177e4SLinus Torvalds 1775ae78bf9cSChris Mason /* 1776ae78bf9cSChris Mason * helper function for fat_flush_inodes. This writes both the inode 1777ae78bf9cSChris Mason * and the file data blocks, waiting for in flight data blocks before 1778ae78bf9cSChris Mason * the start of the call. It does not wait for any io started 1779ae78bf9cSChris Mason * during the call 1780ae78bf9cSChris Mason */ 1781ae78bf9cSChris Mason static int writeback_inode(struct inode *inode) 1782ae78bf9cSChris Mason { 1783ae78bf9cSChris Mason 1784ae78bf9cSChris Mason int ret; 178514864655SNamjae Jeon 178614864655SNamjae Jeon /* if we used wait=1, sync_inode_metadata waits for the io for the 178714864655SNamjae Jeon * inode to finish. So wait=0 is sent down to sync_inode_metadata 1788ae78bf9cSChris Mason * and filemap_fdatawrite is used for the data blocks 1789ae78bf9cSChris Mason */ 179014864655SNamjae Jeon ret = sync_inode_metadata(inode, 0); 1791ae78bf9cSChris Mason if (!ret) 179214864655SNamjae Jeon ret = filemap_fdatawrite(inode->i_mapping); 1793ae78bf9cSChris Mason return ret; 1794ae78bf9cSChris Mason } 1795ae78bf9cSChris Mason 1796ae78bf9cSChris Mason /* 1797ae78bf9cSChris Mason * write data and metadata corresponding to i1 and i2. The io is 1798ae78bf9cSChris Mason * started but we do not wait for any of it to finish. 1799ae78bf9cSChris Mason * 1800ae78bf9cSChris Mason * filemap_flush is used for the block device, so if there is a dirty 1801ae78bf9cSChris Mason * page for a block already in flight, we will not wait and start the 1802ae78bf9cSChris Mason * io over again 1803ae78bf9cSChris Mason */ 1804ae78bf9cSChris Mason int fat_flush_inodes(struct super_block *sb, struct inode *i1, struct inode *i2) 1805ae78bf9cSChris Mason { 1806ae78bf9cSChris Mason int ret = 0; 1807ae78bf9cSChris Mason if (!MSDOS_SB(sb)->options.flush) 1808ae78bf9cSChris Mason return 0; 1809ae78bf9cSChris Mason if (i1) 1810ae78bf9cSChris Mason ret = writeback_inode(i1); 1811ae78bf9cSChris Mason if (!ret && i2) 1812ae78bf9cSChris Mason ret = writeback_inode(i2); 181397e860d3SEric Sesterhenn if (!ret) { 1814ae78bf9cSChris Mason struct address_space *mapping = sb->s_bdev->bd_inode->i_mapping; 1815ae78bf9cSChris Mason ret = filemap_flush(mapping); 1816ae78bf9cSChris Mason } 1817ae78bf9cSChris Mason return ret; 1818ae78bf9cSChris Mason } 1819ae78bf9cSChris Mason EXPORT_SYMBOL_GPL(fat_flush_inodes); 1820ae78bf9cSChris Mason 18211da177e4SLinus Torvalds static int __init init_fat_fs(void) 18221da177e4SLinus Torvalds { 1823532a39a3SPekka J Enberg int err; 18241da177e4SLinus Torvalds 1825532a39a3SPekka J Enberg err = fat_cache_init(); 1826532a39a3SPekka J Enberg if (err) 1827532a39a3SPekka J Enberg return err; 1828532a39a3SPekka J Enberg 1829532a39a3SPekka J Enberg err = fat_init_inodecache(); 1830532a39a3SPekka J Enberg if (err) 1831532a39a3SPekka J Enberg goto failed; 1832532a39a3SPekka J Enberg 1833532a39a3SPekka J Enberg return 0; 1834532a39a3SPekka J Enberg 1835532a39a3SPekka J Enberg failed: 1836532a39a3SPekka J Enberg fat_cache_destroy(); 1837532a39a3SPekka J Enberg return err; 18381da177e4SLinus Torvalds } 18391da177e4SLinus Torvalds 18401da177e4SLinus Torvalds static void __exit exit_fat_fs(void) 18411da177e4SLinus Torvalds { 18421da177e4SLinus Torvalds fat_cache_destroy(); 18431da177e4SLinus Torvalds fat_destroy_inodecache(); 18441da177e4SLinus Torvalds } 18451da177e4SLinus Torvalds 18461da177e4SLinus Torvalds module_init(init_fat_fs) 18471da177e4SLinus Torvalds module_exit(exit_fat_fs) 18481da177e4SLinus Torvalds 18491da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 1850