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