fs/fat/inode.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  linux/fs/fat/inode.c
   4  *
   5  *  Written 1992,1993 by Werner Almesberger
   6  *  VFAT extensions by Gordon Chaffee, merged with msdos fs by Henrik Storner
   7  *  Rewritten for the constant inumbers support by Al Viro
   8  *
   9  *  Fixes:
  10  *
  11  *      Max Cohan: Fixed invalid FSINFO offset when info_sector is 0
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/pagemap.h>
  16 #include <linux/mpage.h>
  17 #include <linux/vfs.h>
  18 #include <linux/seq_file.h>
  19 #include <linux/uio.h>
  20 #include <linux/blkdev.h>
  21 #include <linux/backing-dev.h>
  22 #include <linux/unaligned.h>
  23 #include <linux/random.h>
  24 #include <linux/iversion.h>
  25 #include "fat.h"
  26
  27 #ifndef CONFIG_FAT_DEFAULT_IOCHARSET
  28 /* if user don't select VFAT, this is undefined. */
  29 #define CONFIG_FAT_DEFAULT_IOCHARSET    ""
  30 #endif
  31
  32 #define KB_IN_SECTORS 2
  33
  34 /* DOS dates from 1980/1/1 through 2107/12/31 */
  35 #define FAT_DATE_MIN (0<<9 | 1<<5 | 1)
  36 #define FAT_DATE_MAX (127<<9 | 12<<5 | 31)
  37 #define FAT_TIME_MAX (23<<11 | 59<<5 | 29)
  38
  39 /*
  40  * A deserialized copy of the on-disk structure laid out in struct
  41  * fat_boot_sector.
  42  */
  43 struct fat_bios_param_block {
  44         u16     fat_sector_size;
  45         u8      fat_sec_per_clus;
  46         u16     fat_reserved;
  47         u8      fat_fats;
  48         u16     fat_dir_entries;
  49         u16     fat_sectors;
  50         u16     fat_fat_length;
  51         u32     fat_total_sect;
  52
  53         u8      fat16_state;
  54         u32     fat16_vol_id;
  55
  56         u32     fat32_length;
  57         u32     fat32_root_cluster;
  58         u16     fat32_info_sector;
  59         u8      fat32_state;
  60         u32     fat32_vol_id;
  61 };
  62
  63 static int fat_default_codepage = CONFIG_FAT_DEFAULT_CODEPAGE;
  64 static char fat_default_iocharset[] = CONFIG_FAT_DEFAULT_IOCHARSET;
  65
  66 static struct fat_floppy_defaults {
  67         unsigned nr_sectors;
  68         unsigned sec_per_clus;
  69         unsigned dir_entries;
  70         unsigned media;
  71         unsigned fat_length;
  72 } floppy_defaults[] = {
  73 {
  74         .nr_sectors = 160 * KB_IN_SECTORS,
  75         .sec_per_clus = 1,
  76         .dir_entries = 64,
  77         .media = 0xFE,
  78         .fat_length = 1,
  79 },
  80 {
  81         .nr_sectors = 180 * KB_IN_SECTORS,
  82         .sec_per_clus = 1,
  83         .dir_entries = 64,
  84         .media = 0xFC,
  85         .fat_length = 2,
  86 },
  87 {
  88         .nr_sectors = 320 * KB_IN_SECTORS,
  89         .sec_per_clus = 2,
  90         .dir_entries = 112,
  91         .media = 0xFF,
  92         .fat_length = 1,
  93 },
  94 {
  95         .nr_sectors = 360 * KB_IN_SECTORS,
  96         .sec_per_clus = 2,
  97         .dir_entries = 112,
  98         .media = 0xFD,
  99         .fat_length = 2,
 100 },
 101 };
 102
 103 int fat_add_cluster(struct inode *inode)
 104 {
 105         int err, cluster;
 106
 107         err = fat_alloc_clusters(inode, &cluster, 1);
 108         if (err)
 109                 return err;
 110         /* FIXME: this cluster should be added after data of this
 111          * cluster is writed */
 112         err = fat_chain_add(inode, cluster, 1);
 113         if (err)
 114                 fat_free_clusters(inode, cluster);
 115         return err;
 116 }
 117
 118 static inline int __fat_get_block(struct inode *inode, sector_t iblock,
 119                                   unsigned long *max_blocks,
 120                                   struct buffer_head *bh_result, int create)
 121 {
 122         struct super_block *sb = inode->i_sb;
 123         struct msdos_sb_info *sbi = MSDOS_SB(sb);
 124         unsigned long mapped_blocks;
 125         sector_t phys, last_block;
 126         int err, offset;
 127
 128         err = fat_bmap(inode, iblock, &phys, &mapped_blocks, create, false);
 129         if (err)
 130                 return err;
 131         if (phys) {
 132                 map_bh(bh_result, sb, phys);
 133                 *max_blocks = min(mapped_blocks, *max_blocks);
 134                 return 0;
 135         }
 136         if (!create)
 137                 return 0;
 138
 139         if (iblock != MSDOS_I(inode)->mmu_private >> sb->s_blocksize_bits) {
 140                 fat_fs_error(sb, "corrupted file size (i_pos %lld, %lld)",
 141                         MSDOS_I(inode)->i_pos, MSDOS_I(inode)->mmu_private);
 142                 return -EIO;
 143         }
 144
 145         last_block = inode->i_blocks >> (sb->s_blocksize_bits - 9);
 146         offset = (unsigned long)iblock & (sbi->sec_per_clus - 1);
 147         /*
 148          * allocate a cluster according to the following.
 149          * 1) no more available blocks
 150          * 2) not part of fallocate region
 151          */
 152         if (!offset && !(iblock < last_block)) {
 153                 /* TODO: multiple cluster allocation would be desirable. */
 154                 err = fat_add_cluster(inode);
 155                 if (err)
 156                         return err;
 157         }
 158         /* available blocks on this cluster */
 159         mapped_blocks = sbi->sec_per_clus - offset;
 160
 161         *max_blocks = min(mapped_blocks, *max_blocks);
 162         MSDOS_I(inode)->mmu_private += *max_blocks << sb->s_blocksize_bits;
 163
 164         err = fat_bmap(inode, iblock, &phys, &mapped_blocks, create, false);
 165         if (err)
 166                 return err;
 167         if (!phys) {
 168                 fat_fs_error(sb,
 169                              "invalid FAT chain (i_pos %lld, last_block %llu)",
 170                              MSDOS_I(inode)->i_pos,
 171                              (unsigned long long)last_block);
 172                 return -EIO;
 173         }
 174
 175         BUG_ON(*max_blocks != mapped_blocks);
 176         set_buffer_new(bh_result);
 177         map_bh(bh_result, sb, phys);
 178
 179         return 0;
 180 }
 181
 182 static int fat_get_block(struct inode *inode, sector_t iblock,
 183                          struct buffer_head *bh_result, int create)
 184 {
 185         struct super_block *sb = inode->i_sb;
 186         unsigned long max_blocks = bh_result->b_size >> inode->i_blkbits;
 187         int err;
 188
 189         err = __fat_get_block(inode, iblock, &max_blocks, bh_result, create);
 190         if (err)
 191                 return err;
 192         bh_result->b_size = max_blocks << sb->s_blocksize_bits;
 193         return 0;
 194 }
 195
 196 static int fat_writepages(struct address_space *mapping,
 197                           struct writeback_control *wbc)
 198 {
 199         return mpage_writepages(mapping, wbc, fat_get_block);
 200 }
 201
 202 static int fat_read_folio(struct file *file, struct folio *folio)
 203 {
 204         return mpage_read_folio(folio, fat_get_block);
 205 }
 206
 207 static void fat_readahead(struct readahead_control *rac)
 208 {
 209         mpage_readahead(rac, fat_get_block);
 210 }
 211
 212 static void fat_write_failed(struct address_space *mapping, loff_t to)
 213 {
 214         struct inode *inode = mapping->host;
 215
 216         if (to > inode->i_size) {
 217                 truncate_pagecache(inode, inode->i_size);
 218                 fat_truncate_blocks(inode, inode->i_size);
 219         }
 220 }
 221
 222 static int fat_write_begin(struct file *file, struct address_space *mapping,
 223                         loff_t pos, unsigned len,
 224                         struct folio **foliop, void **fsdata)
 225 {
 226         int err;
 227
 228         err = cont_write_begin(file, mapping, pos, len,
 229                                 foliop, fsdata, fat_get_block,
 230                                 &MSDOS_I(mapping->host)->mmu_private);
 231         if (err < 0)
 232                 fat_write_failed(mapping, pos + len);
 233         return err;
 234 }
 235
 236 static int fat_write_end(struct file *file, struct address_space *mapping,
 237                         loff_t pos, unsigned len, unsigned copied,
 238                         struct folio *folio, void *fsdata)
 239 {
 240         struct inode *inode = mapping->host;
 241         int err;
 242         err = generic_write_end(file, mapping, pos, len, copied, folio, fsdata);
 243         if (err < len)
 244                 fat_write_failed(mapping, pos + len);
 245         if (!(err < 0) && !(MSDOS_I(inode)->i_attrs & ATTR_ARCH)) {
 246                 fat_truncate_time(inode, NULL, S_CTIME|S_MTIME);
 247                 MSDOS_I(inode)->i_attrs |= ATTR_ARCH;
 248                 mark_inode_dirty(inode);
 249         }
 250         return err;
 251 }
 252
 253 static ssize_t fat_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
 254 {
 255         struct file *file = iocb->ki_filp;
 256         struct address_space *mapping = file->f_mapping;
 257         struct inode *inode = mapping->host;
 258         size_t count = iov_iter_count(iter);
 259         loff_t offset = iocb->ki_pos;
 260         ssize_t ret;
 261
 262         if (iov_iter_rw(iter) == WRITE) {
 263                 /*
 264                  * FIXME: blockdev_direct_IO() doesn't use ->write_begin(),
 265                  * so we need to update the ->mmu_private to block boundary.
 266                  *
 267                  * But we must fill the remaining area or hole by nul for
 268                  * updating ->mmu_private.
 269                  *
 270                  * Return 0, and fallback to normal buffered write.
 271                  */
 272                 loff_t size = offset + count;
 273                 if (MSDOS_I(inode)->mmu_private < size)
 274                         return 0;
 275         }
 276
 277         /*
 278          * FAT need to use the DIO_LOCKING for avoiding the race
 279          * condition of fat_get_block() and ->truncate().
 280          */
 281         ret = blockdev_direct_IO(iocb, inode, iter, fat_get_block);
 282         if (ret < 0 && iov_iter_rw(iter) == WRITE)
 283                 fat_write_failed(mapping, offset + count);
 284
 285         return ret;
 286 }
 287
 288 static int fat_get_block_bmap(struct inode *inode, sector_t iblock,
 289                 struct buffer_head *bh_result, int create)
 290 {
 291         struct super_block *sb = inode->i_sb;
 292         unsigned long max_blocks = bh_result->b_size >> inode->i_blkbits;
 293         int err;
 294         sector_t bmap;
 295         unsigned long mapped_blocks;
 296
 297         BUG_ON(create != 0);
 298
 299         err = fat_bmap(inode, iblock, &bmap, &mapped_blocks, create, true);
 300         if (err)
 301                 return err;
 302
 303         if (bmap) {
 304                 map_bh(bh_result, sb, bmap);
 305                 max_blocks = min(mapped_blocks, max_blocks);
 306         }
 307
 308         bh_result->b_size = max_blocks << sb->s_blocksize_bits;
 309
 310         return 0;
 311 }
 312
 313 static sector_t _fat_bmap(struct address_space *mapping, sector_t block)
 314 {
 315         sector_t blocknr;
 316
 317         /* fat_get_cluster() assumes the requested blocknr isn't truncated. */
 318         down_read(&MSDOS_I(mapping->host)->truncate_lock);
 319         blocknr = generic_block_bmap(mapping, block, fat_get_block_bmap);
 320         up_read(&MSDOS_I(mapping->host)->truncate_lock);
 321
 322         return blocknr;
 323 }
 324
 325 /*
 326  * fat_block_truncate_page() zeroes out a mapping from file offset `from'
 327  * up to the end of the block which corresponds to `from'.
 328  * This is required during truncate to physically zeroout the tail end
 329  * of that block so it doesn't yield old data if the file is later grown.
 330  * Also, avoid causing failure from fsx for cases of "data past EOF"
 331  */
 332 int fat_block_truncate_page(struct inode *inode, loff_t from)
 333 {
 334         return block_truncate_page(inode->i_mapping, from, fat_get_block);
 335 }
 336
 337 static const struct address_space_operations fat_aops = {
 338         .dirty_folio    = block_dirty_folio,
 339         .invalidate_folio = block_invalidate_folio,
 340         .read_folio     = fat_read_folio,
 341         .readahead      = fat_readahead,
 342         .writepages     = fat_writepages,
 343         .write_begin    = fat_write_begin,
 344         .write_end      = fat_write_end,
 345         .direct_IO      = fat_direct_IO,
 346         .bmap           = _fat_bmap,
 347         .migrate_folio  = buffer_migrate_folio,
 348 };
 349
 350 /*
 351  * New FAT inode stuff. We do the following:
 352  *      a) i_ino is constant and has nothing with on-disk location.
 353  *      b) FAT manages its own cache of directory entries.
 354  *      c) *This* cache is indexed by on-disk location.
 355  *      d) inode has an associated directory entry, all right, but
 356  *              it may be unhashed.
 357  *      e) currently entries are stored within struct inode. That should
 358  *              change.
 359  *      f) we deal with races in the following way:
 360  *              1. readdir() and lookup() do FAT-dir-cache lookup.
 361  *              2. rename() unhashes the F-d-c entry and rehashes it in
 362  *                      a new place.
 363  *              3. unlink() and rmdir() unhash F-d-c entry.
 364  *              4. fat_write_inode() checks whether the thing is unhashed.
 365  *                      If it is we silently return. If it isn't we do bread(),
 366  *                      check if the location is still valid and retry if it
 367  *                      isn't. Otherwise we do changes.
 368  *              5. Spinlock is used to protect hash/unhash/location check/lookup
 369  *              6. fat_evict_inode() unhashes the F-d-c entry.
 370  *              7. lookup() and readdir() do igrab() if they find a F-d-c entry
 371  *                      and consider negative result as cache miss.
 372  */
 373
 374 static void fat_hash_init(struct super_block *sb)
 375 {
 376         struct msdos_sb_info *sbi = MSDOS_SB(sb);
 377         int i;
 378
 379         spin_lock_init(&sbi->inode_hash_lock);
 380         for (i = 0; i < FAT_HASH_SIZE; i++)
 381                 INIT_HLIST_HEAD(&sbi->inode_hashtable[i]);
 382 }
 383
 384 static inline unsigned long fat_hash(loff_t i_pos)
 385 {
 386         return hash_32(i_pos, FAT_HASH_BITS);
 387 }
 388
 389 static void dir_hash_init(struct super_block *sb)
 390 {
 391         struct msdos_sb_info *sbi = MSDOS_SB(sb);
 392         int i;
 393
 394         spin_lock_init(&sbi->dir_hash_lock);
 395         for (i = 0; i < FAT_HASH_SIZE; i++)
 396                 INIT_HLIST_HEAD(&sbi->dir_hashtable[i]);
 397 }
 398
 399 void fat_attach(struct inode *inode, loff_t i_pos)
 400 {
 401         struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
 402
 403         if (inode->i_ino != MSDOS_ROOT_INO) {
 404                 struct hlist_head *head =   sbi->inode_hashtable
 405                                           + fat_hash(i_pos);
 406
 407                 spin_lock(&sbi->inode_hash_lock);
 408                 MSDOS_I(inode)->i_pos = i_pos;
 409                 hlist_add_head(&MSDOS_I(inode)->i_fat_hash, head);
 410                 spin_unlock(&sbi->inode_hash_lock);
 411         }
 412
 413         /* If NFS support is enabled, cache the mapping of start cluster
 414          * to directory inode. This is used during reconnection of
 415          * dentries to the filesystem root.
 416          */
 417         if (S_ISDIR(inode->i_mode) && sbi->options.nfs) {
 418                 struct hlist_head *d_head = sbi->dir_hashtable;
 419                 d_head += fat_dir_hash(MSDOS_I(inode)->i_logstart);
 420
 421                 spin_lock(&sbi->dir_hash_lock);
 422                 hlist_add_head(&MSDOS_I(inode)->i_dir_hash, d_head);
 423                 spin_unlock(&sbi->dir_hash_lock);
 424         }
 425 }
 426 EXPORT_SYMBOL_GPL(fat_attach);
 427
 428 void fat_detach(struct inode *inode)
 429 {
 430         struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
 431         spin_lock(&sbi->inode_hash_lock);
 432         MSDOS_I(inode)->i_pos = 0;
 433         hlist_del_init(&MSDOS_I(inode)->i_fat_hash);
 434         spin_unlock(&sbi->inode_hash_lock);
 435
 436         if (S_ISDIR(inode->i_mode) && sbi->options.nfs) {
 437                 spin_lock(&sbi->dir_hash_lock);
 438                 hlist_del_init(&MSDOS_I(inode)->i_dir_hash);
 439                 spin_unlock(&sbi->dir_hash_lock);
 440         }
 441 }
 442 EXPORT_SYMBOL_GPL(fat_detach);
 443
 444 struct inode *fat_iget(struct super_block *sb, loff_t i_pos)
 445 {
 446         struct msdos_sb_info *sbi = MSDOS_SB(sb);
 447         struct hlist_head *head = sbi->inode_hashtable + fat_hash(i_pos);
 448         struct msdos_inode_info *i;
 449         struct inode *inode = NULL;
 450
 451         spin_lock(&sbi->inode_hash_lock);
 452         hlist_for_each_entry(i, head, i_fat_hash) {
 453                 BUG_ON(i->vfs_inode.i_sb != sb);
 454                 if (i->i_pos != i_pos)
 455                         continue;
 456                 inode = igrab(&i->vfs_inode);
 457                 if (inode)
 458                         break;
 459         }
 460         spin_unlock(&sbi->inode_hash_lock);
 461         return inode;
 462 }
 463
 464 static int is_exec(unsigned char *extension)
 465 {
 466         unsigned char exe_extensions[] = "EXECOMBAT", *walk;
 467
 468         for (walk = exe_extensions; *walk; walk += 3)
 469                 if (!strncmp(extension, walk, 3))
 470                         return 1;
 471         return 0;
 472 }
 473
 474 static int fat_calc_dir_size(struct inode *inode)
 475 {
 476         struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
 477         int ret, fclus, dclus;
 478
 479         inode->i_size = 0;
 480         if (MSDOS_I(inode)->i_start == 0)
 481                 return 0;
 482
 483         ret = fat_get_cluster(inode, FAT_ENT_EOF, &fclus, &dclus);
 484         if (ret < 0)
 485                 return ret;
 486         inode->i_size = (fclus + 1) << sbi->cluster_bits;
 487
 488         return 0;
 489 }
 490
 491 static int fat_validate_dir(struct inode *dir)
 492 {
 493         struct super_block *sb = dir->i_sb;
 494
 495         if (dir->i_nlink < 2) {
 496                 /* Directory should have "."/".." entries at least. */
 497                 fat_fs_error(sb, "corrupted directory (invalid entries)");
 498                 return -EIO;
 499         }
 500         if (MSDOS_I(dir)->i_start == 0 ||
 501             MSDOS_I(dir)->i_start == MSDOS_SB(sb)->root_cluster) {
 502                 /* Directory should point valid cluster. */
 503                 fat_fs_error(sb, "corrupted directory (invalid i_start)");
 504                 return -EIO;
 505         }
 506         return 0;
 507 }
 508
 509 /* doesn't deal with root inode */
 510 int fat_fill_inode(struct inode *inode, struct msdos_dir_entry *de)
 511 {
 512         struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
 513         struct timespec64 mtime;
 514         int error;
 515
 516         MSDOS_I(inode)->i_pos = 0;
 517         inode->i_uid = sbi->options.fs_uid;
 518         inode->i_gid = sbi->options.fs_gid;
 519         inode_inc_iversion(inode);
 520         inode->i_generation = get_random_u32();
 521
 522         if ((de->attr & ATTR_DIR) && !IS_FREE(de->name)) {
 523                 inode->i_generation &= ~1;
 524                 inode->i_mode = fat_make_mode(sbi, de->attr, S_IRWXUGO);
 525                 inode->i_op = sbi->dir_ops;
 526                 inode->i_fop = &fat_dir_operations;
 527
 528                 MSDOS_I(inode)->i_start = fat_get_start(sbi, de);
 529                 MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start;
 530                 error = fat_calc_dir_size(inode);
 531                 if (error < 0)
 532                         return error;
 533                 MSDOS_I(inode)->mmu_private = inode->i_size;
 534
 535                 set_nlink(inode, fat_subdirs(inode));
 536
 537                 error = fat_validate_dir(inode);
 538                 if (error < 0)
 539                         return error;
 540         } else { /* not a directory */
 541                 inode->i_generation |= 1;
 542                 inode->i_mode = fat_make_mode(sbi, de->attr,
 543                         ((sbi->options.showexec && !is_exec(de->name + 8))
 544                          ? S_IRUGO|S_IWUGO : S_IRWXUGO));
 545                 MSDOS_I(inode)->i_start = fat_get_start(sbi, de);
 546
 547                 MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start;
 548                 inode->i_size = le32_to_cpu(de->size);
 549                 inode->i_op = &fat_file_inode_operations;
 550                 inode->i_fop = &fat_file_operations;
 551                 inode->i_mapping->a_ops = &fat_aops;
 552                 MSDOS_I(inode)->mmu_private = inode->i_size;
 553         }
 554         if (de->attr & ATTR_SYS) {
 555                 if (sbi->options.sys_immutable)
 556                         inode->i_flags |= S_IMMUTABLE;
 557         }
 558         fat_save_attrs(inode, de->attr);
 559
 560         inode->i_blocks = ((inode->i_size + (sbi->cluster_size - 1))
 561                            & ~((loff_t)sbi->cluster_size - 1)) >> 9;
 562
 563         fat_time_fat2unix(sbi, &mtime, de->time, de->date, 0);
 564         inode_set_mtime_to_ts(inode, mtime);
 565         inode_set_ctime_to_ts(inode, mtime);
 566         if (sbi->options.isvfat) {
 567                 struct timespec64 atime;
 568
 569                 fat_time_fat2unix(sbi, &atime, 0, de->adate, 0);
 570                 inode_set_atime_to_ts(inode, atime);
 571                 fat_time_fat2unix(sbi, &MSDOS_I(inode)->i_crtime, de->ctime,
 572                                   de->cdate, de->ctime_cs);
 573         } else
 574                 inode_set_atime_to_ts(inode, fat_truncate_atime(sbi, &mtime));
 575
 576         return 0;
 577 }
 578
 579 static inline void fat_lock_build_inode(struct msdos_sb_info *sbi)
 580 {
 581         if (sbi->options.nfs == FAT_NFS_NOSTALE_RO)
 582                 mutex_lock(&sbi->nfs_build_inode_lock);
 583 }
 584
 585 static inline void fat_unlock_build_inode(struct msdos_sb_info *sbi)
 586 {
 587         if (sbi->options.nfs == FAT_NFS_NOSTALE_RO)
 588                 mutex_unlock(&sbi->nfs_build_inode_lock);
 589 }
 590
 591 struct inode *fat_build_inode(struct super_block *sb,
 592                         struct msdos_dir_entry *de, loff_t i_pos)
 593 {
 594         struct inode *inode;
 595         int err;
 596
 597         fat_lock_build_inode(MSDOS_SB(sb));
 598         inode = fat_iget(sb, i_pos);
 599         if (inode)
 600                 goto out;
 601         inode = new_inode(sb);
 602         if (!inode) {
 603                 inode = ERR_PTR(-ENOMEM);
 604                 goto out;
 605         }
 606         inode->i_ino = iunique(sb, MSDOS_ROOT_INO);
 607         inode_set_iversion(inode, 1);
 608         err = fat_fill_inode(inode, de);
 609         if (err) {
 610                 iput(inode);
 611                 inode = ERR_PTR(err);
 612                 goto out;
 613         }
 614         fat_attach(inode, i_pos);
 615         insert_inode_hash(inode);
 616 out:
 617         fat_unlock_build_inode(MSDOS_SB(sb));
 618         return inode;
 619 }
 620
 621 EXPORT_SYMBOL_GPL(fat_build_inode);
 622
 623 static int __fat_write_inode(struct inode *inode, int wait);
 624
 625 static void fat_free_eofblocks(struct inode *inode)
 626 {
 627         /* Release unwritten fallocated blocks on inode eviction. */
 628         if ((inode->i_blocks << 9) >
 629                         round_up(MSDOS_I(inode)->mmu_private,
 630                                 MSDOS_SB(inode->i_sb)->cluster_size)) {
 631                 int err;
 632
 633                 fat_truncate_blocks(inode, MSDOS_I(inode)->mmu_private);
 634                 /* Fallocate results in updating the i_start/iogstart
 635                  * for the zero byte file. So, make it return to
 636                  * original state during evict and commit it to avoid
 637                  * any corruption on the next access to the cluster
 638                  * chain for the file.
 639                  */
 640                 err = __fat_write_inode(inode, inode_needs_sync(inode));
 641                 if (err) {
 642                         fat_msg(inode->i_sb, KERN_WARNING, "Failed to "
 643                                         "update on disk inode for unused "
 644                                         "fallocated blocks, inode could be "
 645                                         "corrupted. Please run fsck");
 646                 }
 647
 648         }
 649 }
 650
 651 static void fat_evict_inode(struct inode *inode)
 652 {
 653         truncate_inode_pages_final(&inode->i_data);
 654         if (!inode->i_nlink) {
 655                 inode->i_size = 0;
 656                 fat_truncate_blocks(inode, 0);
 657         } else
 658                 fat_free_eofblocks(inode);
 659
 660         invalidate_inode_buffers(inode);
 661         clear_inode(inode);
 662         fat_cache_inval_inode(inode);
 663         fat_detach(inode);
 664 }
 665
 666 static void fat_set_state(struct super_block *sb,
 667                         unsigned int set, unsigned int force)
 668 {
 669         struct buffer_head *bh;
 670         struct fat_boot_sector *b;
 671         struct msdos_sb_info *sbi = MSDOS_SB(sb);
 672
 673         /* do not change any thing if mounted read only */
 674         if (sb_rdonly(sb) && !force)
 675                 return;
 676
 677         /* do not change state if fs was dirty */
 678         if (sbi->dirty) {
 679                 /* warn only on set (mount). */
 680                 if (set)
 681                         fat_msg(sb, KERN_WARNING, "Volume was not properly "
 682                                 "unmounted. Some data may be corrupt. "
 683                                 "Please run fsck.");
 684                 return;
 685         }
 686
 687         bh = sb_bread(sb, 0);
 688         if (bh == NULL) {
 689                 fat_msg(sb, KERN_ERR, "unable to read boot sector "
 690                         "to mark fs as dirty");
 691                 return;
 692         }
 693
 694         b = (struct fat_boot_sector *) bh->b_data;
 695
 696         if (is_fat32(sbi)) {
 697                 if (set)
 698                         b->fat32.state |= FAT_STATE_DIRTY;
 699                 else
 700                         b->fat32.state &= ~FAT_STATE_DIRTY;
 701         } else /* fat 16 and 12 */ {
 702                 if (set)
 703                         b->fat16.state |= FAT_STATE_DIRTY;
 704                 else
 705                         b->fat16.state &= ~FAT_STATE_DIRTY;
 706         }
 707
 708         mark_buffer_dirty(bh);
 709         sync_dirty_buffer(bh);
 710         brelse(bh);
 711 }
 712
 713 static void fat_reset_iocharset(struct fat_mount_options *opts)
 714 {
 715         if (opts->iocharset != fat_default_iocharset) {
 716                 /* Note: opts->iocharset can be NULL here */
 717                 kfree(opts->iocharset);
 718                 opts->iocharset = fat_default_iocharset;
 719         }
 720 }
 721
 722 static void delayed_free(struct rcu_head *p)
 723 {
 724         struct msdos_sb_info *sbi = container_of(p, struct msdos_sb_info, rcu);
 725         unload_nls(sbi->nls_disk);
 726         unload_nls(sbi->nls_io);
 727         fat_reset_iocharset(&sbi->options);
 728         kfree(sbi);
 729 }
 730
 731 static void fat_put_super(struct super_block *sb)
 732 {
 733         struct msdos_sb_info *sbi = MSDOS_SB(sb);
 734
 735         fat_set_state(sb, 0, 0);
 736
 737         iput(sbi->fsinfo_inode);
 738         iput(sbi->fat_inode);
 739
 740         call_rcu(&sbi->rcu, delayed_free);
 741 }
 742
 743 static struct kmem_cache *fat_inode_cachep;
 744
 745 static struct inode *fat_alloc_inode(struct super_block *sb)
 746 {
 747         struct msdos_inode_info *ei;
 748         ei = alloc_inode_sb(sb, fat_inode_cachep, GFP_NOFS);
 749         if (!ei)
 750                 return NULL;
 751
 752         init_rwsem(&ei->truncate_lock);
 753         /* Zeroing to allow iput() even if partial initialized inode. */
 754         ei->mmu_private = 0;
 755         ei->i_start = 0;
 756         ei->i_logstart = 0;
 757         ei->i_attrs = 0;
 758         ei->i_pos = 0;
 759         ei->i_crtime.tv_sec = 0;
 760         ei->i_crtime.tv_nsec = 0;
 761
 762         return &ei->vfs_inode;
 763 }
 764
 765 static void fat_free_inode(struct inode *inode)
 766 {
 767         kmem_cache_free(fat_inode_cachep, MSDOS_I(inode));
 768 }
 769
 770 static void init_once(void *foo)
 771 {
 772         struct msdos_inode_info *ei = (struct msdos_inode_info *)foo;
 773
 774         spin_lock_init(&ei->cache_lru_lock);
 775         ei->nr_caches = 0;
 776         ei->cache_valid_id = FAT_CACHE_VALID + 1;
 777         INIT_LIST_HEAD(&ei->cache_lru);
 778         INIT_HLIST_NODE(&ei->i_fat_hash);
 779         INIT_HLIST_NODE(&ei->i_dir_hash);
 780         inode_init_once(&ei->vfs_inode);
 781 }
 782
 783 static int __init fat_init_inodecache(void)
 784 {
 785         fat_inode_cachep = kmem_cache_create("fat_inode_cache",
 786                                              sizeof(struct msdos_inode_info),
 787                                              0, (SLAB_RECLAIM_ACCOUNT|
 788                                                 SLAB_ACCOUNT),
 789                                              init_once);
 790         if (fat_inode_cachep == NULL)
 791                 return -ENOMEM;
 792         return 0;
 793 }
 794
 795 static void __exit fat_destroy_inodecache(void)
 796 {
 797         /*
 798          * Make sure all delayed rcu free inodes are flushed before we
 799          * destroy cache.
 800          */
 801         rcu_barrier();
 802         kmem_cache_destroy(fat_inode_cachep);
 803 }
 804
 805 int fat_reconfigure(struct fs_context *fc)
 806 {
 807         bool new_rdonly;
 808         struct super_block *sb = fc->root->d_sb;
 809         struct msdos_sb_info *sbi = MSDOS_SB(sb);
 810         fc->sb_flags |= SB_NODIRATIME | (sbi->options.isvfat ? 0 : SB_NOATIME);
 811
 812         sync_filesystem(sb);
 813
 814         /* make sure we update state on remount. */
 815         new_rdonly = fc->sb_flags & SB_RDONLY;
 816         if (new_rdonly != sb_rdonly(sb)) {
 817                 if (new_rdonly)
 818                         fat_set_state(sb, 0, 0);
 819                 else
 820                         fat_set_state(sb, 1, 1);
 821         }
 822         return 0;
 823 }
 824 EXPORT_SYMBOL_GPL(fat_reconfigure);
 825
 826 static int fat_statfs(struct dentry *dentry, struct kstatfs *buf)
 827 {
 828         struct super_block *sb = dentry->d_sb;
 829         struct msdos_sb_info *sbi = MSDOS_SB(sb);
 830         u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
 831
 832         /* If the count of free cluster is still unknown, counts it here. */
 833         if (sbi->free_clusters == -1 || !sbi->free_clus_valid) {
 834                 int err = fat_count_free_clusters(dentry->d_sb);
 835                 if (err)
 836                         return err;
 837         }
 838
 839         buf->f_type = dentry->d_sb->s_magic;
 840         buf->f_bsize = sbi->cluster_size;
 841         buf->f_blocks = sbi->max_cluster - FAT_START_ENT;
 842         buf->f_bfree = sbi->free_clusters;
 843         buf->f_bavail = sbi->free_clusters;
 844         buf->f_fsid = u64_to_fsid(id);
 845         buf->f_namelen =
 846                 (sbi->options.isvfat ? FAT_LFN_LEN : 12) * NLS_MAX_CHARSET_SIZE;
 847
 848         return 0;
 849 }
 850
 851 static int __fat_write_inode(struct inode *inode, int wait)
 852 {
 853         struct super_block *sb = inode->i_sb;
 854         struct msdos_sb_info *sbi = MSDOS_SB(sb);
 855         struct buffer_head *bh;
 856         struct msdos_dir_entry *raw_entry;
 857         struct timespec64 mtime;
 858         loff_t i_pos;
 859         sector_t blocknr;
 860         int err, offset;
 861
 862         if (inode->i_ino == MSDOS_ROOT_INO)
 863                 return 0;
 864
 865 retry:
 866         i_pos = fat_i_pos_read(sbi, inode);
 867         if (!i_pos)
 868                 return 0;
 869
 870         fat_get_blknr_offset(sbi, i_pos, &blocknr, &offset);
 871         bh = sb_bread(sb, blocknr);
 872         if (!bh) {
 873                 fat_msg(sb, KERN_ERR, "unable to read inode block "
 874                        "for updating (i_pos %lld)", i_pos);
 875                 return -EIO;
 876         }
 877         spin_lock(&sbi->inode_hash_lock);
 878         if (i_pos != MSDOS_I(inode)->i_pos) {
 879                 spin_unlock(&sbi->inode_hash_lock);
 880                 brelse(bh);
 881                 goto retry;
 882         }
 883
 884         raw_entry = &((struct msdos_dir_entry *) (bh->b_data))[offset];
 885         if (S_ISDIR(inode->i_mode))
 886                 raw_entry->size = 0;
 887         else
 888                 raw_entry->size = cpu_to_le32(inode->i_size);
 889         raw_entry->attr = fat_make_attrs(inode);
 890         fat_set_start(raw_entry, MSDOS_I(inode)->i_logstart);
 891         mtime = inode_get_mtime(inode);
 892         fat_time_unix2fat(sbi, &mtime, &raw_entry->time,
 893                           &raw_entry->date, NULL);
 894         if (sbi->options.isvfat) {
 895                 struct timespec64 ts = inode_get_atime(inode);
 896                 __le16 atime;
 897
 898                 fat_time_unix2fat(sbi, &ts, &atime, &raw_entry->adate, NULL);
 899                 fat_time_unix2fat(sbi, &MSDOS_I(inode)->i_crtime, &raw_entry->ctime,
 900                                   &raw_entry->cdate, &raw_entry->ctime_cs);
 901         }
 902         spin_unlock(&sbi->inode_hash_lock);
 903         mark_buffer_dirty(bh);
 904         err = 0;
 905         if (wait)
 906                 err = sync_dirty_buffer(bh);
 907         brelse(bh);
 908         return err;
 909 }
 910
 911 static int fat_write_inode(struct inode *inode, struct writeback_control *wbc)
 912 {
 913         int err;
 914
 915         if (inode->i_ino == MSDOS_FSINFO_INO) {
 916                 struct super_block *sb = inode->i_sb;
 917
 918                 mutex_lock(&MSDOS_SB(sb)->s_lock);
 919                 err = fat_clusters_flush(sb);
 920                 mutex_unlock(&MSDOS_SB(sb)->s_lock);
 921         } else
 922                 err = __fat_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
 923
 924         return err;
 925 }
 926
 927 int fat_sync_inode(struct inode *inode)
 928 {
 929         return __fat_write_inode(inode, 1);
 930 }
 931
 932 EXPORT_SYMBOL_GPL(fat_sync_inode);
 933
 934 static int fat_show_options(struct seq_file *m, struct dentry *root);
 935 static const struct super_operations fat_sops = {
 936         .alloc_inode    = fat_alloc_inode,
 937         .free_inode     = fat_free_inode,
 938         .write_inode    = fat_write_inode,
 939         .evict_inode    = fat_evict_inode,
 940         .put_super      = fat_put_super,
 941         .statfs         = fat_statfs,
 942         .show_options   = fat_show_options,
 943 };
 944
 945 static int fat_show_options(struct seq_file *m, struct dentry *root)
 946 {
 947         struct msdos_sb_info *sbi = MSDOS_SB(root->d_sb);
 948         struct fat_mount_options *opts = &sbi->options;
 949         int isvfat = opts->isvfat;
 950
 951         if (!uid_eq(opts->fs_uid, GLOBAL_ROOT_UID))
 952                 seq_printf(m, ",uid=%u",
 953                                 from_kuid_munged(&init_user_ns, opts->fs_uid));
 954         if (!gid_eq(opts->fs_gid, GLOBAL_ROOT_GID))
 955                 seq_printf(m, ",gid=%u",
 956                                 from_kgid_munged(&init_user_ns, opts->fs_gid));
 957         seq_printf(m, ",fmask=%04o", opts->fs_fmask);
 958         seq_printf(m, ",dmask=%04o", opts->fs_dmask);
 959         if (opts->allow_utime)
 960                 seq_printf(m, ",allow_utime=%04o", opts->allow_utime);
 961         if (sbi->nls_disk)
 962                 /* strip "cp" prefix from displayed option */
 963                 seq_printf(m, ",codepage=%s", &sbi->nls_disk->charset[2]);
 964         if (isvfat) {
 965                 if (sbi->nls_io)
 966                         seq_printf(m, ",iocharset=%s", sbi->nls_io->charset);
 967
 968                 switch (opts->shortname) {
 969                 case VFAT_SFN_DISPLAY_WIN95 | VFAT_SFN_CREATE_WIN95:
 970                         seq_puts(m, ",shortname=win95");
 971                         break;
 972                 case VFAT_SFN_DISPLAY_WINNT | VFAT_SFN_CREATE_WINNT:
 973                         seq_puts(m, ",shortname=winnt");
 974                         break;
 975                 case VFAT_SFN_DISPLAY_WINNT | VFAT_SFN_CREATE_WIN95:
 976                         seq_puts(m, ",shortname=mixed");
 977                         break;
 978                 case VFAT_SFN_DISPLAY_LOWER | VFAT_SFN_CREATE_WIN95:
 979                         seq_puts(m, ",shortname=lower");
 980                         break;
 981                 default:
 982                         seq_puts(m, ",shortname=unknown");
 983                         break;
 984                 }
 985         }
 986         if (opts->name_check != 'n')
 987                 seq_printf(m, ",check=%c", opts->name_check);
 988         if (opts->usefree)
 989                 seq_puts(m, ",usefree");
 990         if (opts->quiet)
 991                 seq_puts(m, ",quiet");
 992         if (opts->showexec)
 993                 seq_puts(m, ",showexec");
 994         if (opts->sys_immutable)
 995                 seq_puts(m, ",sys_immutable");
 996         if (!isvfat) {
 997                 if (opts->dotsOK)
 998                         seq_puts(m, ",dotsOK=yes");
 999                 if (opts->nocase)
1000                         seq_puts(m, ",nocase");
1001         } else {
1002                 if (opts->utf8)
1003                         seq_puts(m, ",utf8");
1004                 if (opts->unicode_xlate)
1005                         seq_puts(m, ",uni_xlate");
1006                 if (!opts->numtail)
1007                         seq_puts(m, ",nonumtail");
1008                 if (opts->rodir)
1009                         seq_puts(m, ",rodir");
1010         }
1011         if (opts->flush)
1012                 seq_puts(m, ",flush");
1013         if (opts->tz_set) {
1014                 if (opts->time_offset)
1015                         seq_printf(m, ",time_offset=%d", opts->time_offset);
1016                 else
1017                         seq_puts(m, ",tz=UTC");
1018         }
1019         if (opts->errors == FAT_ERRORS_CONT)
1020                 seq_puts(m, ",errors=continue");
1021         else if (opts->errors == FAT_ERRORS_PANIC)
1022                 seq_puts(m, ",errors=panic");
1023         else
1024                 seq_puts(m, ",errors=remount-ro");
1025         if (opts->nfs == FAT_NFS_NOSTALE_RO)
1026                 seq_puts(m, ",nfs=nostale_ro");
1027         else if (opts->nfs)
1028                 seq_puts(m, ",nfs=stale_rw");
1029         if (opts->discard)
1030                 seq_puts(m, ",discard");
1031         if (opts->dos1xfloppy)
1032                 seq_puts(m, ",dos1xfloppy");
1033
1034         return 0;
1035 }
1036
1037 enum {
1038         Opt_check, Opt_uid, Opt_gid, Opt_umask, Opt_dmask, Opt_fmask,
1039         Opt_allow_utime, Opt_codepage, Opt_usefree, Opt_nocase, Opt_quiet,
1040         Opt_showexec, Opt_debug, Opt_immutable, Opt_dots, Opt_dotsOK,
1041         Opt_charset, Opt_shortname, Opt_utf8, Opt_utf8_bool,
1042         Opt_uni_xl, Opt_uni_xl_bool, Opt_nonumtail, Opt_nonumtail_bool,
1043         Opt_obsolete, Opt_flush, Opt_tz, Opt_rodir, Opt_errors, Opt_discard,
1044         Opt_nfs, Opt_nfs_enum, Opt_time_offset, Opt_dos1xfloppy,
1045 };
1046
1047 static const struct constant_table fat_param_check[] = {
1048         {"relaxed",     'r'},
1049         {"r",           'r'},
1050         {"strict",      's'},
1051         {"s",           's'},
1052         {"normal",      'n'},
1053         {"n",           'n'},
1054         {}
1055 };
1056
1057 static const struct constant_table fat_param_tz[] = {
1058         {"UTC",         0},
1059         {}
1060 };
1061
1062 static const struct constant_table fat_param_errors[] = {
1063         {"continue",    FAT_ERRORS_CONT},
1064         {"panic",       FAT_ERRORS_PANIC},
1065         {"remount-ro",  FAT_ERRORS_RO},
1066         {}
1067 };
1068
1069
1070 static const struct constant_table fat_param_nfs[] = {
1071         {"stale_rw",    FAT_NFS_STALE_RW},
1072         {"nostale_ro",  FAT_NFS_NOSTALE_RO},
1073         {}
1074 };
1075
1076 /*
1077  * These are all obsolete but we still reject invalid options.
1078  * The corresponding values are therefore meaningless.
1079  */
1080 static const struct constant_table fat_param_conv[] = {
1081         {"binary",      0},
1082         {"text",        0},
1083         {"auto",        0},
1084         {"b",           0},
1085         {"t",           0},
1086         {"a",           0},
1087         {}
1088 };
1089
1090 /* Core options. See below for vfat and msdos extras */
1091 const struct fs_parameter_spec fat_param_spec[] = {
1092         fsparam_enum    ("check",       Opt_check, fat_param_check),
1093         fsparam_uid     ("uid",         Opt_uid),
1094         fsparam_gid     ("gid",         Opt_gid),
1095         fsparam_u32oct  ("umask",       Opt_umask),
1096         fsparam_u32oct  ("dmask",       Opt_dmask),
1097         fsparam_u32oct  ("fmask",       Opt_fmask),
1098         fsparam_u32oct  ("allow_utime", Opt_allow_utime),
1099         fsparam_u32     ("codepage",    Opt_codepage),
1100         fsparam_flag    ("usefree",     Opt_usefree),
1101         fsparam_flag    ("nocase",      Opt_nocase),
1102         fsparam_flag    ("quiet",       Opt_quiet),
1103         fsparam_flag    ("showexec",    Opt_showexec),
1104         fsparam_flag    ("debug",       Opt_debug),
1105         fsparam_flag    ("sys_immutable", Opt_immutable),
1106         fsparam_flag    ("flush",       Opt_flush),
1107         fsparam_enum    ("tz",          Opt_tz, fat_param_tz),
1108         fsparam_s32     ("time_offset", Opt_time_offset),
1109         fsparam_enum    ("errors",      Opt_errors, fat_param_errors),
1110         fsparam_flag    ("discard",     Opt_discard),
1111         fsparam_flag    ("nfs",         Opt_nfs),
1112         fsparam_enum    ("nfs",         Opt_nfs_enum, fat_param_nfs),
1113         fsparam_flag    ("dos1xfloppy", Opt_dos1xfloppy),
1114         __fsparam(fs_param_is_enum,     "conv",
1115                   Opt_obsolete, fs_param_deprecated, fat_param_conv),
1116         __fsparam(fs_param_is_u32,      "fat",
1117                   Opt_obsolete, fs_param_deprecated, NULL),
1118         __fsparam(fs_param_is_u32,      "blocksize",
1119                   Opt_obsolete, fs_param_deprecated, NULL),
1120         __fsparam(fs_param_is_string,   "cvf_format",
1121                   Opt_obsolete, fs_param_deprecated, NULL),
1122         __fsparam(fs_param_is_string,   "cvf_options",
1123                   Opt_obsolete, fs_param_deprecated, NULL),
1124         __fsparam(NULL,                 "posix",
1125                   Opt_obsolete, fs_param_deprecated, NULL),
1126         {}
1127 };
1128 EXPORT_SYMBOL_GPL(fat_param_spec);
1129
1130 static const struct fs_parameter_spec msdos_param_spec[] = {
1131         fsparam_flag_no ("dots",        Opt_dots),
1132         fsparam_bool    ("dotsOK",      Opt_dotsOK),
1133         {}
1134 };
1135
1136 static const struct constant_table fat_param_shortname[] = {
1137         {"lower",       VFAT_SFN_DISPLAY_LOWER | VFAT_SFN_CREATE_WIN95},
1138         {"win95",       VFAT_SFN_DISPLAY_WIN95 | VFAT_SFN_CREATE_WIN95},
1139         {"winnt",       VFAT_SFN_DISPLAY_WINNT | VFAT_SFN_CREATE_WINNT},
1140         {"mixed",       VFAT_SFN_DISPLAY_WINNT | VFAT_SFN_CREATE_WIN95},
1141         {}
1142 };
1143
1144 static const struct fs_parameter_spec vfat_param_spec[] = {
1145         fsparam_string  ("iocharset",   Opt_charset),
1146         fsparam_enum    ("shortname",   Opt_shortname, fat_param_shortname),
1147         fsparam_flag    ("utf8",        Opt_utf8),
1148         fsparam_bool    ("utf8",        Opt_utf8_bool),
1149         fsparam_flag    ("uni_xlate",   Opt_uni_xl),
1150         fsparam_bool    ("uni_xlate",   Opt_uni_xl_bool),
1151         fsparam_flag    ("nonumtail",   Opt_nonumtail),
1152         fsparam_bool    ("nonumtail",   Opt_nonumtail_bool),
1153         fsparam_flag    ("rodir",       Opt_rodir),
1154         {}
1155 };
1156
1157 int fat_parse_param(struct fs_context *fc, struct fs_parameter *param,
1158                            bool is_vfat)
1159 {
1160         struct fat_mount_options *opts = fc->fs_private;
1161         struct fs_parse_result result;
1162         int opt;
1163
1164         /* remount options have traditionally been ignored */
1165         if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE)
1166                 return 0;
1167
1168         opt = fs_parse(fc, fat_param_spec, param, &result);
1169         /* If option not found in fat_param_spec, try vfat/msdos options */
1170         if (opt == -ENOPARAM) {
1171                 if (is_vfat)
1172                         opt = fs_parse(fc, vfat_param_spec, param, &result);
1173                 else
1174                         opt = fs_parse(fc, msdos_param_spec, param, &result);
1175         }
1176
1177         if (opt < 0)
1178                 return opt;
1179
1180         switch (opt) {
1181         case Opt_check:
1182                 opts->name_check = result.uint_32;
1183                 break;
1184         case Opt_usefree:
1185                 opts->usefree = 1;
1186                 break;
1187         case Opt_nocase:
1188                 if (!is_vfat)
1189                         opts->nocase = 1;
1190                 else {
1191                         /* for backward compatibility */
1192                         opts->shortname = VFAT_SFN_DISPLAY_WIN95
1193                                 | VFAT_SFN_CREATE_WIN95;
1194                 }
1195                 break;
1196         case Opt_quiet:
1197                 opts->quiet = 1;
1198                 break;
1199         case Opt_showexec:
1200                 opts->showexec = 1;
1201                 break;
1202         case Opt_debug:
1203                 opts->debug = 1;
1204                 break;
1205         case Opt_immutable:
1206                 opts->sys_immutable = 1;
1207                 break;
1208         case Opt_uid:
1209                 opts->fs_uid = result.uid;
1210                 break;
1211         case Opt_gid:
1212                 opts->fs_gid = result.gid;
1213                 break;
1214         case Opt_umask:
1215                 opts->fs_fmask = opts->fs_dmask = result.uint_32;
1216                 break;
1217         case Opt_dmask:
1218                 opts->fs_dmask = result.uint_32;
1219                 break;
1220         case Opt_fmask:
1221                 opts->fs_fmask = result.uint_32;
1222                 break;
1223         case Opt_allow_utime:
1224                 opts->allow_utime = result.uint_32 & (S_IWGRP | S_IWOTH);
1225                 break;
1226         case Opt_codepage:
1227                 opts->codepage = result.uint_32;
1228                 break;
1229         case Opt_flush:
1230                 opts->flush = 1;
1231                 break;
1232         case Opt_time_offset:
1233                 /*
1234                  * GMT+-12 zones may have DST corrections so at least
1235                  * 13 hours difference is needed. Make the limit 24
1236                  * just in case someone invents something unusual.
1237                  */
1238                 if (result.int_32 < -24 * 60 || result.int_32 > 24 * 60)
1239                         return -EINVAL;
1240                 opts->tz_set = 1;
1241                 opts->time_offset = result.int_32;
1242                 break;
1243         case Opt_tz:
1244                 opts->tz_set = 1;
1245                 opts->time_offset = result.uint_32;
1246                 break;
1247         case Opt_errors:
1248                 opts->errors = result.uint_32;
1249                 break;
1250         case Opt_nfs:
1251                 opts->nfs = FAT_NFS_STALE_RW;
1252                 break;
1253         case Opt_nfs_enum:
1254                 opts->nfs = result.uint_32;
1255                 break;
1256         case Opt_dos1xfloppy:
1257                 opts->dos1xfloppy = 1;
1258                 break;
1259
1260         /* msdos specific */
1261         case Opt_dots:  /* dots / nodots */
1262                 opts->dotsOK = !result.negated;
1263                 break;
1264         case Opt_dotsOK:        /* dotsOK = yes/no */
1265                 opts->dotsOK = result.boolean;
1266                 break;
1267
1268         /* vfat specific */
1269         case Opt_charset:
1270                 fat_reset_iocharset(opts);
1271                 opts->iocharset = param->string;
1272                 param->string = NULL;   /* Steal string */
1273                 break;
1274         case Opt_shortname:
1275                 opts->shortname = result.uint_32;
1276                 break;
1277         case Opt_utf8:
1278                 opts->utf8 = 1;
1279                 break;
1280         case Opt_utf8_bool:
1281                 opts->utf8 = result.boolean;
1282                 break;
1283         case Opt_uni_xl:
1284                 opts->unicode_xlate = 1;
1285                 break;
1286         case Opt_uni_xl_bool:
1287                 opts->unicode_xlate = result.boolean;
1288                 break;
1289         case Opt_nonumtail:
1290                 opts->numtail = 0;      /* negated option */
1291                 break;
1292         case Opt_nonumtail_bool:
1293                 opts->numtail = !result.boolean; /* negated option */
1294                 break;
1295         case Opt_rodir:
1296                 opts->rodir = 1;
1297                 break;
1298         case Opt_discard:
1299                 opts->discard = 1;
1300                 break;
1301
1302         /* obsolete mount options */
1303         case Opt_obsolete:
1304                 printk(KERN_INFO "FAT-fs: \"%s\" option is obsolete, "
1305                         "not supported now", param->key);
1306                 break;
1307         default:
1308                 return -EINVAL;
1309         }
1310
1311         return 0;
1312 }
1313 EXPORT_SYMBOL_GPL(fat_parse_param);
1314
1315 static int fat_read_root(struct inode *inode)
1316 {
1317         struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
1318         int error;
1319
1320         MSDOS_I(inode)->i_pos = MSDOS_ROOT_INO;
1321         inode->i_uid = sbi->options.fs_uid;
1322         inode->i_gid = sbi->options.fs_gid;
1323         inode_inc_iversion(inode);
1324         inode->i_generation = 0;
1325         inode->i_mode = fat_make_mode(sbi, ATTR_DIR, S_IRWXUGO);
1326         inode->i_op = sbi->dir_ops;
1327         inode->i_fop = &fat_dir_operations;
1328         if (is_fat32(sbi)) {
1329                 MSDOS_I(inode)->i_start = sbi->root_cluster;
1330                 error = fat_calc_dir_size(inode);
1331                 if (error < 0)
1332                         return error;
1333         } else {
1334                 MSDOS_I(inode)->i_start = 0;
1335                 inode->i_size = sbi->dir_entries * sizeof(struct msdos_dir_entry);
1336         }
1337         inode->i_blocks = ((inode->i_size + (sbi->cluster_size - 1))
1338                            & ~((loff_t)sbi->cluster_size - 1)) >> 9;
1339         MSDOS_I(inode)->i_logstart = 0;
1340         MSDOS_I(inode)->mmu_private = inode->i_size;
1341
1342         fat_save_attrs(inode, ATTR_DIR);
1343         inode_set_mtime_to_ts(inode,
1344                               inode_set_atime_to_ts(inode, inode_set_ctime(inode, 0, 0)));
1345         set_nlink(inode, fat_subdirs(inode)+2);
1346
1347         return 0;
1348 }
1349
1350 static unsigned long calc_fat_clusters(struct super_block *sb)
1351 {
1352         struct msdos_sb_info *sbi = MSDOS_SB(sb);
1353
1354         /* Divide first to avoid overflow */
1355         if (!is_fat12(sbi)) {
1356                 unsigned long ent_per_sec = sb->s_blocksize * 8 / sbi->fat_bits;
1357                 return ent_per_sec * sbi->fat_length;
1358         }
1359
1360         return sbi->fat_length * sb->s_blocksize * 8 / sbi->fat_bits;
1361 }
1362
1363 static bool fat_bpb_is_zero(struct fat_boot_sector *b)
1364 {
1365         if (get_unaligned_le16(&b->sector_size))
1366                 return false;
1367         if (b->sec_per_clus)
1368                 return false;
1369         if (b->reserved)
1370                 return false;
1371         if (b->fats)
1372                 return false;
1373         if (get_unaligned_le16(&b->dir_entries))
1374                 return false;
1375         if (get_unaligned_le16(&b->sectors))
1376                 return false;
1377         if (b->media)
1378                 return false;
1379         if (b->fat_length)
1380                 return false;
1381         if (b->secs_track)
1382                 return false;
1383         if (b->heads)
1384                 return false;
1385         return true;
1386 }
1387
1388 static int fat_read_bpb(struct super_block *sb, struct fat_boot_sector *b,
1389         int silent, struct fat_bios_param_block *bpb)
1390 {
1391         int error = -EINVAL;
1392
1393         /* Read in BPB ... */
1394         memset(bpb, 0, sizeof(*bpb));
1395         bpb->fat_sector_size = get_unaligned_le16(&b->sector_size);
1396         bpb->fat_sec_per_clus = b->sec_per_clus;
1397         bpb->fat_reserved = le16_to_cpu(b->reserved);
1398         bpb->fat_fats = b->fats;
1399         bpb->fat_dir_entries = get_unaligned_le16(&b->dir_entries);
1400         bpb->fat_sectors = get_unaligned_le16(&b->sectors);
1401         bpb->fat_fat_length = le16_to_cpu(b->fat_length);
1402         bpb->fat_total_sect = le32_to_cpu(b->total_sect);
1403
1404         bpb->fat16_state = b->fat16.state;
1405         bpb->fat16_vol_id = get_unaligned_le32(b->fat16.vol_id);
1406
1407         bpb->fat32_length = le32_to_cpu(b->fat32.length);
1408         bpb->fat32_root_cluster = le32_to_cpu(b->fat32.root_cluster);
1409         bpb->fat32_info_sector = le16_to_cpu(b->fat32.info_sector);
1410         bpb->fat32_state = b->fat32.state;
1411         bpb->fat32_vol_id = get_unaligned_le32(b->fat32.vol_id);
1412
1413         /* Validate this looks like a FAT filesystem BPB */
1414         if (!bpb->fat_reserved) {
1415                 if (!silent)
1416                         fat_msg(sb, KERN_ERR,
1417                                 "bogus number of reserved sectors");
1418                 goto out;
1419         }
1420         if (!bpb->fat_fats) {
1421                 if (!silent)
1422                         fat_msg(sb, KERN_ERR, "bogus number of FAT structure");
1423                 goto out;
1424         }
1425
1426         /*
1427          * Earlier we checked here that b->secs_track and b->head are nonzero,
1428          * but it turns out valid FAT filesystems can have zero there.
1429          */
1430
1431         if (!fat_valid_media(b->media)) {
1432                 if (!silent)
1433                         fat_msg(sb, KERN_ERR, "invalid media value (0x%02x)",
1434                                 (unsigned)b->media);
1435                 goto out;
1436         }
1437
1438         if (!is_power_of_2(bpb->fat_sector_size)
1439             || (bpb->fat_sector_size < 512)
1440             || (bpb->fat_sector_size > 4096)) {
1441                 if (!silent)
1442                         fat_msg(sb, KERN_ERR, "bogus logical sector size %u",
1443                                (unsigned)bpb->fat_sector_size);
1444                 goto out;
1445         }
1446
1447         if (!is_power_of_2(bpb->fat_sec_per_clus)) {
1448                 if (!silent)
1449                         fat_msg(sb, KERN_ERR, "bogus sectors per cluster %u",
1450                                 (unsigned)bpb->fat_sec_per_clus);
1451                 goto out;
1452         }
1453
1454         if (bpb->fat_fat_length == 0 && bpb->fat32_length == 0) {
1455                 if (!silent)
1456                         fat_msg(sb, KERN_ERR, "bogus number of FAT sectors");
1457                 goto out;
1458         }
1459
1460         error = 0;
1461
1462 out:
1463         return error;
1464 }
1465
1466 static int fat_read_static_bpb(struct super_block *sb,
1467         struct fat_boot_sector *b, int silent,
1468         struct fat_bios_param_block *bpb)
1469 {
1470         static const char *notdos1x = "This doesn't look like a DOS 1.x volume";
1471         sector_t bd_sects = bdev_nr_sectors(sb->s_bdev);
1472         struct fat_floppy_defaults *fdefaults = NULL;
1473         int error = -EINVAL;
1474         unsigned i;
1475
1476         /* 16-bit DOS 1.x reliably wrote bootstrap short-jmp code */
1477         if (b->ignored[0] != 0xeb || b->ignored[2] != 0x90) {
1478                 if (!silent)
1479                         fat_msg(sb, KERN_ERR,
1480                                 "%s; no bootstrapping code", notdos1x);
1481                 goto out;
1482         }
1483
1484         /*
1485          * If any value in this region is non-zero, it isn't archaic
1486          * DOS.
1487          */
1488         if (!fat_bpb_is_zero(b)) {
1489                 if (!silent)
1490                         fat_msg(sb, KERN_ERR,
1491                                 "%s; DOS 2.x BPB is non-zero", notdos1x);
1492                 goto out;
1493         }
1494
1495         for (i = 0; i < ARRAY_SIZE(floppy_defaults); i++) {
1496                 if (floppy_defaults[i].nr_sectors == bd_sects) {
1497                         fdefaults = &floppy_defaults[i];
1498                         break;
1499                 }
1500         }
1501
1502         if (fdefaults == NULL) {
1503                 if (!silent)
1504                         fat_msg(sb, KERN_WARNING,
1505                                 "This looks like a DOS 1.x volume, but isn't a recognized floppy size (%llu sectors)",
1506                                 (u64)bd_sects);
1507                 goto out;
1508         }
1509
1510         if (!silent)
1511                 fat_msg(sb, KERN_INFO,
1512                         "This looks like a DOS 1.x volume; assuming default BPB values");
1513
1514         memset(bpb, 0, sizeof(*bpb));
1515         bpb->fat_sector_size = SECTOR_SIZE;
1516         bpb->fat_sec_per_clus = fdefaults->sec_per_clus;
1517         bpb->fat_reserved = 1;
1518         bpb->fat_fats = 2;
1519         bpb->fat_dir_entries = fdefaults->dir_entries;
1520         bpb->fat_sectors = fdefaults->nr_sectors;
1521         bpb->fat_fat_length = fdefaults->fat_length;
1522
1523         error = 0;
1524
1525 out:
1526         return error;
1527 }
1528
1529 /*
1530  * Read the super block of an MS-DOS FS.
1531  */
1532 int fat_fill_super(struct super_block *sb, struct fs_context *fc,
1533                    void (*setup)(struct super_block *))
1534 {
1535         struct fat_mount_options *opts = fc->fs_private;
1536         int silent = fc->sb_flags & SB_SILENT;
1537         struct inode *root_inode = NULL, *fat_inode = NULL;
1538         struct inode *fsinfo_inode = NULL;
1539         struct buffer_head *bh;
1540         struct fat_bios_param_block bpb;
1541         struct msdos_sb_info *sbi;
1542         u16 logical_sector_size;
1543         u32 total_sectors, total_clusters, fat_clusters, rootdir_sectors;
1544         long error;
1545         char buf[50];
1546         struct timespec64 ts;
1547
1548         /*
1549          * GFP_KERNEL is ok here, because while we do hold the
1550          * superblock lock, memory pressure can't call back into
1551          * the filesystem, since we're only just about to mount
1552          * it and have no inodes etc active!
1553          */
1554         sbi = kzalloc(sizeof(struct msdos_sb_info), GFP_KERNEL);
1555         if (!sbi)
1556                 return -ENOMEM;
1557         sb->s_fs_info = sbi;
1558
1559         sb->s_flags |= SB_NODIRATIME;
1560         sb->s_magic = MSDOS_SUPER_MAGIC;
1561         sb->s_op = &fat_sops;
1562         sb->s_export_op = &fat_export_ops;
1563         /*
1564          * fat timestamps are complex and truncated by fat itself, so
1565          * we set 1 here to be fast
1566          */
1567         sb->s_time_gran = 1;
1568         mutex_init(&sbi->nfs_build_inode_lock);
1569         ratelimit_state_init(&sbi->ratelimit, DEFAULT_RATELIMIT_INTERVAL,
1570                              DEFAULT_RATELIMIT_BURST);
1571
1572         /* UTF-8 doesn't provide FAT semantics */
1573         if (!strcmp(opts->iocharset, "utf8")) {
1574                 fat_msg(sb, KERN_WARNING, "utf8 is not a recommended IO charset"
1575                        " for FAT filesystems, filesystem will be"
1576                        " case sensitive!");
1577         }
1578
1579         /* If user doesn't specify allow_utime, it's initialized from dmask. */
1580         if (opts->allow_utime == (unsigned short)-1)
1581                 opts->allow_utime = ~opts->fs_dmask & (S_IWGRP | S_IWOTH);
1582         if (opts->unicode_xlate)
1583                 opts->utf8 = 0;
1584         if (opts->nfs == FAT_NFS_NOSTALE_RO) {
1585                 sb->s_flags |= SB_RDONLY;
1586                 sb->s_export_op = &fat_export_ops_nostale;
1587         }
1588
1589         /* Apply parsed options to sbi (structure copy) */
1590         sbi->options = *opts;
1591         /* Transfer ownership of iocharset to sbi->options */
1592         opts->iocharset = NULL;
1593
1594         setup(sb); /* flavour-specific stuff that needs options */
1595
1596         error = -EIO;
1597         sb_min_blocksize(sb, 512);
1598         bh = sb_bread(sb, 0);
1599         if (bh == NULL) {
1600                 fat_msg(sb, KERN_ERR, "unable to read boot sector");
1601                 goto out_fail;
1602         }
1603
1604         error = fat_read_bpb(sb, (struct fat_boot_sector *)bh->b_data, silent,
1605                 &bpb);
1606         if (error == -EINVAL && sbi->options.dos1xfloppy)
1607                 error = fat_read_static_bpb(sb,
1608                         (struct fat_boot_sector *)bh->b_data, silent, &bpb);
1609         brelse(bh);
1610
1611         if (error == -EINVAL)
1612                 goto out_invalid;
1613         else if (error)
1614                 goto out_fail;
1615
1616         logical_sector_size = bpb.fat_sector_size;
1617         sbi->sec_per_clus = bpb.fat_sec_per_clus;
1618
1619         error = -EIO;
1620         if (logical_sector_size < sb->s_blocksize) {
1621                 fat_msg(sb, KERN_ERR, "logical sector size too small for device"
1622                        " (logical sector size = %u)", logical_sector_size);
1623                 goto out_fail;
1624         }
1625
1626         if (logical_sector_size > sb->s_blocksize) {
1627                 struct buffer_head *bh_resize;
1628
1629                 if (!sb_set_blocksize(sb, logical_sector_size)) {
1630                         fat_msg(sb, KERN_ERR, "unable to set blocksize %u",
1631                                logical_sector_size);
1632                         goto out_fail;
1633                 }
1634
1635                 /* Verify that the larger boot sector is fully readable */
1636                 bh_resize = sb_bread(sb, 0);
1637                 if (bh_resize == NULL) {
1638                         fat_msg(sb, KERN_ERR, "unable to read boot sector"
1639                                " (logical sector size = %lu)",
1640                                sb->s_blocksize);
1641                         goto out_fail;
1642                 }
1643                 brelse(bh_resize);
1644         }
1645
1646         mutex_init(&sbi->s_lock);
1647         sbi->cluster_size = sb->s_blocksize * sbi->sec_per_clus;
1648         sbi->cluster_bits = ffs(sbi->cluster_size) - 1;
1649         sbi->fats = bpb.fat_fats;
1650         sbi->fat_bits = 0;              /* Don't know yet */
1651         sbi->fat_start = bpb.fat_reserved;
1652         sbi->fat_length = bpb.fat_fat_length;
1653         sbi->root_cluster = 0;
1654         sbi->free_clusters = -1;        /* Don't know yet */
1655         sbi->free_clus_valid = 0;
1656         sbi->prev_free = FAT_START_ENT;
1657         sb->s_maxbytes = 0xffffffff;
1658         fat_time_fat2unix(sbi, &ts, 0, cpu_to_le16(FAT_DATE_MIN), 0);
1659         sb->s_time_min = ts.tv_sec;
1660
1661         fat_time_fat2unix(sbi, &ts, cpu_to_le16(FAT_TIME_MAX),
1662                           cpu_to_le16(FAT_DATE_MAX), 0);
1663         sb->s_time_max = ts.tv_sec;
1664
1665         if (!sbi->fat_length && bpb.fat32_length) {
1666                 struct fat_boot_fsinfo *fsinfo;
1667                 struct buffer_head *fsinfo_bh;
1668
1669                 /* Must be FAT32 */
1670                 sbi->fat_bits = 32;
1671                 sbi->fat_length = bpb.fat32_length;
1672                 sbi->root_cluster = bpb.fat32_root_cluster;
1673
1674                 /* MC - if info_sector is 0, don't multiply by 0 */
1675                 sbi->fsinfo_sector = bpb.fat32_info_sector;
1676                 if (sbi->fsinfo_sector == 0)
1677                         sbi->fsinfo_sector = 1;
1678
1679                 fsinfo_bh = sb_bread(sb, sbi->fsinfo_sector);
1680                 if (fsinfo_bh == NULL) {
1681                         fat_msg(sb, KERN_ERR, "bread failed, FSINFO block"
1682                                " (sector = %lu)", sbi->fsinfo_sector);
1683                         goto out_fail;
1684                 }
1685
1686                 fsinfo = (struct fat_boot_fsinfo *)fsinfo_bh->b_data;
1687                 if (!IS_FSINFO(fsinfo)) {
1688                         fat_msg(sb, KERN_WARNING, "Invalid FSINFO signature: "
1689                                "0x%08x, 0x%08x (sector = %lu)",
1690                                le32_to_cpu(fsinfo->signature1),
1691                                le32_to_cpu(fsinfo->signature2),
1692                                sbi->fsinfo_sector);
1693                 } else {
1694                         if (sbi->options.usefree)
1695                                 sbi->free_clus_valid = 1;
1696                         sbi->free_clusters = le32_to_cpu(fsinfo->free_clusters);
1697                         sbi->prev_free = le32_to_cpu(fsinfo->next_cluster);
1698                 }
1699
1700                 brelse(fsinfo_bh);
1701         }
1702
1703         /* interpret volume ID as a little endian 32 bit integer */
1704         if (is_fat32(sbi))
1705                 sbi->vol_id = bpb.fat32_vol_id;
1706         else /* fat 16 or 12 */
1707                 sbi->vol_id = bpb.fat16_vol_id;
1708
1709         __le32 vol_id_le = cpu_to_le32(sbi->vol_id);
1710         super_set_uuid(sb, (void *) &vol_id_le, sizeof(vol_id_le));
1711
1712         sbi->dir_per_block = sb->s_blocksize / sizeof(struct msdos_dir_entry);
1713         sbi->dir_per_block_bits = ffs(sbi->dir_per_block) - 1;
1714
1715         sbi->dir_start = sbi->fat_start + sbi->fats * sbi->fat_length;
1716         sbi->dir_entries = bpb.fat_dir_entries;
1717         if (sbi->dir_entries & (sbi->dir_per_block - 1)) {
1718                 if (!silent)
1719                         fat_msg(sb, KERN_ERR, "bogus number of directory entries"
1720                                " (%u)", sbi->dir_entries);
1721                 goto out_invalid;
1722         }
1723
1724         rootdir_sectors = sbi->dir_entries
1725                 * sizeof(struct msdos_dir_entry) / sb->s_blocksize;
1726         sbi->data_start = sbi->dir_start + rootdir_sectors;
1727         total_sectors = bpb.fat_sectors;
1728         if (total_sectors == 0)
1729                 total_sectors = bpb.fat_total_sect;
1730
1731         total_clusters = (total_sectors - sbi->data_start) / sbi->sec_per_clus;
1732
1733         if (!is_fat32(sbi))
1734                 sbi->fat_bits = (total_clusters > MAX_FAT12) ? 16 : 12;
1735
1736         /* some OSes set FAT_STATE_DIRTY and clean it on unmount. */
1737         if (is_fat32(sbi))
1738                 sbi->dirty = bpb.fat32_state & FAT_STATE_DIRTY;
1739         else /* fat 16 or 12 */
1740                 sbi->dirty = bpb.fat16_state & FAT_STATE_DIRTY;
1741
1742         /* check that FAT table does not overflow */
1743         fat_clusters = calc_fat_clusters(sb);
1744         total_clusters = min(total_clusters, fat_clusters - FAT_START_ENT);
1745         if (total_clusters > max_fat(sb)) {
1746                 if (!silent)
1747                         fat_msg(sb, KERN_ERR, "count of clusters too big (%u)",
1748                                total_clusters);
1749                 goto out_invalid;
1750         }
1751
1752         sbi->max_cluster = total_clusters + FAT_START_ENT;
1753         /* check the free_clusters, it's not necessarily correct */
1754         if (sbi->free_clusters != -1 && sbi->free_clusters > total_clusters)
1755                 sbi->free_clusters = -1;
1756         /* check the prev_free, it's not necessarily correct */
1757         sbi->prev_free %= sbi->max_cluster;
1758         if (sbi->prev_free < FAT_START_ENT)
1759                 sbi->prev_free = FAT_START_ENT;
1760
1761         /* set up enough so that it can read an inode */
1762         fat_hash_init(sb);
1763         dir_hash_init(sb);
1764         fat_ent_access_init(sb);
1765
1766         /*
1767          * The low byte of the first FAT entry must have the same value as
1768          * the media field of the boot sector. But in real world, too many
1769          * devices are writing wrong values. So, removed that validity check.
1770          *
1771          * The removed check compared the first FAT entry to a value dependent
1772          * on the media field like this:
1773          * == (0x0F00 | media), for FAT12
1774          * == (0XFF00 | media), for FAT16
1775          * == (0x0FFFFF | media), for FAT32
1776          */
1777
1778         error = -EINVAL;
1779         sprintf(buf, "cp%d", sbi->options.codepage);
1780         sbi->nls_disk = load_nls(buf);
1781         if (!sbi->nls_disk) {
1782                 fat_msg(sb, KERN_ERR, "codepage %s not found", buf);
1783                 goto out_fail;
1784         }
1785
1786         /* FIXME: utf8 is using iocharset for upper/lower conversion */
1787         if (sbi->options.isvfat) {
1788                 sbi->nls_io = load_nls(sbi->options.iocharset);
1789                 if (!sbi->nls_io) {
1790                         fat_msg(sb, KERN_ERR, "IO charset %s not found",
1791                                sbi->options.iocharset);
1792                         goto out_fail;
1793                 }
1794         }
1795
1796         error = -ENOMEM;
1797         fat_inode = new_inode(sb);
1798         if (!fat_inode)
1799                 goto out_fail;
1800         sbi->fat_inode = fat_inode;
1801
1802         fsinfo_inode = new_inode(sb);
1803         if (!fsinfo_inode)
1804                 goto out_fail;
1805         fsinfo_inode->i_ino = MSDOS_FSINFO_INO;
1806         sbi->fsinfo_inode = fsinfo_inode;
1807         insert_inode_hash(fsinfo_inode);
1808
1809         root_inode = new_inode(sb);
1810         if (!root_inode)
1811                 goto out_fail;
1812         root_inode->i_ino = MSDOS_ROOT_INO;
1813         inode_set_iversion(root_inode, 1);
1814         error = fat_read_root(root_inode);
1815         if (error < 0) {
1816                 iput(root_inode);
1817                 goto out_fail;
1818         }
1819         error = -ENOMEM;
1820         insert_inode_hash(root_inode);
1821         fat_attach(root_inode, 0);
1822         sb->s_root = d_make_root(root_inode);
1823         if (!sb->s_root) {
1824                 fat_msg(sb, KERN_ERR, "get root inode failed");
1825                 goto out_fail;
1826         }
1827
1828         if (sbi->options.discard && !bdev_max_discard_sectors(sb->s_bdev))
1829                 fat_msg(sb, KERN_WARNING,
1830                         "mounting with \"discard\" option, but the device does not support discard");
1831
1832         fat_set_state(sb, 1, 0);
1833         return 0;
1834
1835 out_invalid:
1836         error = -EINVAL;
1837         if (!silent)
1838                 fat_msg(sb, KERN_INFO, "Can't find a valid FAT filesystem");
1839
1840 out_fail:
1841         iput(fsinfo_inode);
1842         iput(fat_inode);
1843         unload_nls(sbi->nls_io);
1844         unload_nls(sbi->nls_disk);
1845         fat_reset_iocharset(&sbi->options);
1846         sb->s_fs_info = NULL;
1847         kfree(sbi);
1848         return error;
1849 }
1850
1851 EXPORT_SYMBOL_GPL(fat_fill_super);
1852
1853 /*
1854  * helper function for fat_flush_inodes.  This writes both the inode
1855  * and the file data blocks, waiting for in flight data blocks before
1856  * the start of the call.  It does not wait for any io started
1857  * during the call
1858  */
1859 static int writeback_inode(struct inode *inode)
1860 {
1861
1862         int ret;
1863
1864         /* if we used wait=1, sync_inode_metadata waits for the io for the
1865         * inode to finish.  So wait=0 is sent down to sync_inode_metadata
1866         * and filemap_fdatawrite is used for the data blocks
1867         */
1868         ret = sync_inode_metadata(inode, 0);
1869         if (!ret)
1870                 ret = filemap_fdatawrite(inode->i_mapping);
1871         return ret;
1872 }
1873
1874 /*
1875  * write data and metadata corresponding to i1 and i2.  The io is
1876  * started but we do not wait for any of it to finish.
1877  *
1878  * filemap_flush is used for the block device, so if there is a dirty
1879  * page for a block already in flight, we will not wait and start the
1880  * io over again
1881  */
1882 int fat_flush_inodes(struct super_block *sb, struct inode *i1, struct inode *i2)
1883 {
1884         int ret = 0;
1885         if (!MSDOS_SB(sb)->options.flush)
1886                 return 0;
1887         if (i1)
1888                 ret = writeback_inode(i1);
1889         if (!ret && i2)
1890                 ret = writeback_inode(i2);
1891         if (!ret)
1892                 ret = sync_blockdev_nowait(sb->s_bdev);
1893         return ret;
1894 }
1895 EXPORT_SYMBOL_GPL(fat_flush_inodes);
1896
1897 int fat_init_fs_context(struct fs_context *fc, bool is_vfat)
1898 {
1899         struct fat_mount_options *opts;
1900
1901         opts = kzalloc(sizeof(*opts), GFP_KERNEL);
1902         if (!opts)
1903                 return -ENOMEM;
1904
1905         opts->isvfat = is_vfat;
1906         opts->fs_uid = current_uid();
1907         opts->fs_gid = current_gid();
1908         opts->fs_fmask = opts->fs_dmask = current_umask();
1909         opts->allow_utime = -1;
1910         opts->codepage = fat_default_codepage;
1911         fat_reset_iocharset(opts);
1912         if (is_vfat) {
1913                 opts->shortname = VFAT_SFN_DISPLAY_WINNT|VFAT_SFN_CREATE_WIN95;
1914                 opts->rodir = 0;
1915         } else {
1916                 opts->shortname = 0;
1917                 opts->rodir = 1;
1918         }
1919         opts->name_check = 'n';
1920         opts->quiet = opts->showexec = opts->sys_immutable = opts->dotsOK =  0;
1921         opts->unicode_xlate = 0;
1922         opts->numtail = 1;
1923         opts->usefree = opts->nocase = 0;
1924         opts->tz_set = 0;
1925         opts->nfs = 0;
1926         opts->errors = FAT_ERRORS_RO;
1927         opts->debug = 0;
1928
1929         opts->utf8 = IS_ENABLED(CONFIG_FAT_DEFAULT_UTF8) && is_vfat;
1930
1931         fc->fs_private = opts;
1932         /* fc->ops assigned by caller */
1933
1934         return 0;
1935 }
1936 EXPORT_SYMBOL_GPL(fat_init_fs_context);
1937
1938 void fat_free_fc(struct fs_context *fc)
1939 {
1940         struct fat_mount_options *opts = fc->fs_private;
1941
1942         if (opts->iocharset != fat_default_iocharset)
1943                 kfree(opts->iocharset);
1944         kfree(fc->fs_private);
1945 }
1946 EXPORT_SYMBOL_GPL(fat_free_fc);
1947
1948 static int __init init_fat_fs(void)
1949 {
1950         int err;
1951
1952         err = fat_cache_init();
1953         if (err)
1954                 return err;
1955
1956         err = fat_init_inodecache();
1957         if (err)
1958                 goto failed;
1959
1960         return 0;
1961
1962 failed:
1963         fat_cache_destroy();
1964         return err;
1965 }
1966
1967 static void __exit exit_fat_fs(void)
1968 {
1969         fat_cache_destroy();
1970         fat_destroy_inodecache();
1971 }
1972
1973 module_init(init_fat_fs)
1974 module_exit(exit_fat_fs)
1975
1976 MODULE_DESCRIPTION("Core FAT filesystem support");
1977 MODULE_LICENSE("GPL");