inode.c 43.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 *  linux/fs/fat/inode.c
 *
 *  Written 1992,1993 by Werner Almesberger
 *  VFAT extensions by Gordon Chaffee, merged with msdos fs by Henrik Storner
 *  Rewritten for the constant inumbers support by Al Viro
 *
 *  Fixes:
 *
 *	Max Cohan: Fixed invalid FSINFO offset when info_sector is 0
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/time.h>
#include <linux/slab.h>
#include <linux/seq_file.h>
#include <linux/pagemap.h>
19
#include <linux/mpage.h>
L
Linus Torvalds 已提交
20 21
#include <linux/buffer_head.h>
#include <linux/mount.h>
22
#include <linux/aio.h>
L
Linus Torvalds 已提交
23 24
#include <linux/vfs.h>
#include <linux/parser.h>
25
#include <linux/uio.h>
C
Chris Mason 已提交
26
#include <linux/writeback.h>
V
Vignesh Babu BM 已提交
27
#include <linux/log2.h>
O
OGAWA Hirofumi 已提交
28
#include <linux/hash.h>
29
#include <linux/blkdev.h>
L
Linus Torvalds 已提交
30
#include <asm/unaligned.h>
O
OGAWA Hirofumi 已提交
31
#include "fat.h"
L
Linus Torvalds 已提交
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

#ifndef CONFIG_FAT_DEFAULT_IOCHARSET
/* if user don't select VFAT, this is undefined. */
#define CONFIG_FAT_DEFAULT_IOCHARSET	""
#endif

static int fat_default_codepage = CONFIG_FAT_DEFAULT_CODEPAGE;
static char fat_default_iocharset[] = CONFIG_FAT_DEFAULT_IOCHARSET;


static int fat_add_cluster(struct inode *inode)
{
	int err, cluster;

	err = fat_alloc_clusters(inode, &cluster, 1);
	if (err)
		return err;
	/* FIXME: this cluster should be added after data of this
	 * cluster is writed */
	err = fat_chain_add(inode, cluster, 1);
	if (err)
		fat_free_clusters(inode, cluster);
	return err;
}

57 58 59
static inline int __fat_get_block(struct inode *inode, sector_t iblock,
				  unsigned long *max_blocks,
				  struct buffer_head *bh_result, int create)
L
Linus Torvalds 已提交
60 61
{
	struct super_block *sb = inode->i_sb;
62 63
	struct msdos_sb_info *sbi = MSDOS_SB(sb);
	unsigned long mapped_blocks;
64
	sector_t phys;
65
	int err, offset;
L
Linus Torvalds 已提交
66

O
OGAWA Hirofumi 已提交
67
	err = fat_bmap(inode, iblock, &phys, &mapped_blocks, create);
L
Linus Torvalds 已提交
68 69 70 71
	if (err)
		return err;
	if (phys) {
		map_bh(bh_result, sb, phys);
72
		*max_blocks = min(mapped_blocks, *max_blocks);
L
Linus Torvalds 已提交
73 74 75 76
		return 0;
	}
	if (!create)
		return 0;
77

L
Linus Torvalds 已提交
78
	if (iblock != MSDOS_I(inode)->mmu_private >> sb->s_blocksize_bits) {
D
Denis Karpov 已提交
79
		fat_fs_error(sb, "corrupted file size (i_pos %lld, %lld)",
80
			MSDOS_I(inode)->i_pos, MSDOS_I(inode)->mmu_private);
L
Linus Torvalds 已提交
81 82
		return -EIO;
	}
83 84 85 86

	offset = (unsigned long)iblock & (sbi->sec_per_clus - 1);
	if (!offset) {
		/* TODO: multiple cluster allocation would be desirable. */
L
Linus Torvalds 已提交
87 88 89 90
		err = fat_add_cluster(inode);
		if (err)
			return err;
	}
91 92 93 94 95 96
	/* available blocks on this cluster */
	mapped_blocks = sbi->sec_per_clus - offset;

	*max_blocks = min(mapped_blocks, *max_blocks);
	MSDOS_I(inode)->mmu_private += *max_blocks << sb->s_blocksize_bits;

O
OGAWA Hirofumi 已提交
97
	err = fat_bmap(inode, iblock, &phys, &mapped_blocks, create);
L
Linus Torvalds 已提交
98 99
	if (err)
		return err;
100

101 102
	BUG_ON(!phys);
	BUG_ON(*max_blocks != mapped_blocks);
L
Linus Torvalds 已提交
103 104
	set_buffer_new(bh_result);
	map_bh(bh_result, sb, phys);
105

L
Linus Torvalds 已提交
106 107 108
	return 0;
}

109 110
static int fat_get_block(struct inode *inode, sector_t iblock,
			 struct buffer_head *bh_result, int create)
111 112
{
	struct super_block *sb = inode->i_sb;
113
	unsigned long max_blocks = bh_result->b_size >> inode->i_blkbits;
114
	int err;
115

116
	err = __fat_get_block(inode, iblock, &max_blocks, bh_result, create);
117 118 119 120 121 122
	if (err)
		return err;
	bh_result->b_size = max_blocks << sb->s_blocksize_bits;
	return 0;
}

L
Linus Torvalds 已提交
123 124 125 126 127
static int fat_writepage(struct page *page, struct writeback_control *wbc)
{
	return block_write_full_page(page, fat_get_block, wbc);
}

128 129 130 131 132 133
static int fat_writepages(struct address_space *mapping,
			  struct writeback_control *wbc)
{
	return mpage_writepages(mapping, wbc, fat_get_block);
}

L
Linus Torvalds 已提交
134 135
static int fat_readpage(struct file *file, struct page *page)
{
136 137 138 139 140 141 142
	return mpage_readpage(page, fat_get_block);
}

static int fat_readpages(struct file *file, struct address_space *mapping,
			 struct list_head *pages, unsigned nr_pages)
{
	return mpage_readpages(mapping, pages, nr_pages, fat_get_block);
L
Linus Torvalds 已提交
143 144
}

145 146 147 148 149
static void fat_write_failed(struct address_space *mapping, loff_t to)
{
	struct inode *inode = mapping->host;

	if (to > inode->i_size) {
150
		truncate_pagecache(inode, inode->i_size);
151 152 153 154
		fat_truncate_blocks(inode, inode->i_size);
	}
}

N
Nick Piggin 已提交
155 156 157
static int fat_write_begin(struct file *file, struct address_space *mapping,
			loff_t pos, unsigned len, unsigned flags,
			struct page **pagep, void **fsdata)
L
Linus Torvalds 已提交
158
{
159 160
	int err;

N
Nick Piggin 已提交
161
	*pagep = NULL;
162
	err = cont_write_begin(file, mapping, pos, len, flags,
163
				pagep, fsdata, fat_get_block,
N
Nick Piggin 已提交
164
				&MSDOS_I(mapping->host)->mmu_private);
165 166 167
	if (err < 0)
		fat_write_failed(mapping, pos + len);
	return err;
L
Linus Torvalds 已提交
168 169
}

N
Nick Piggin 已提交
170 171 172
static int fat_write_end(struct file *file, struct address_space *mapping,
			loff_t pos, unsigned len, unsigned copied,
			struct page *pagep, void *fsdata)
173
{
N
Nick Piggin 已提交
174 175 176
	struct inode *inode = mapping->host;
	int err;
	err = generic_write_end(file, mapping, pos, len, copied, pagep, fsdata);
177 178
	if (err < len)
		fat_write_failed(mapping, pos + len);
N
Nick Piggin 已提交
179
	if (!(err < 0) && !(MSDOS_I(inode)->i_attrs & ATTR_ARCH)) {
180 181 182 183 184 185 186
		inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
		MSDOS_I(inode)->i_attrs |= ATTR_ARCH;
		mark_inode_dirty(inode);
	}
	return err;
}

187 188 189 190 191
static ssize_t fat_direct_IO(int rw, struct kiocb *iocb,
			     const struct iovec *iov,
			     loff_t offset, unsigned long nr_segs)
{
	struct file *file = iocb->ki_filp;
192 193 194
	struct address_space *mapping = file->f_mapping;
	struct inode *inode = mapping->host;
	ssize_t ret;
195 196 197

	if (rw == WRITE) {
		/*
198
		 * FIXME: blockdev_direct_IO() doesn't use ->write_begin(),
199 200 201 202
		 * so we need to update the ->mmu_private to block boundary.
		 *
		 * But we must fill the remaining area or hole by nul for
		 * updating ->mmu_private.
203 204
		 *
		 * Return 0, and fallback to normal buffered write.
205 206 207
		 */
		loff_t size = offset + iov_length(iov, nr_segs);
		if (MSDOS_I(inode)->mmu_private < size)
208
			return 0;
209 210 211 212 213 214
	}

	/*
	 * FAT need to use the DIO_LOCKING for avoiding the race
	 * condition of fat_get_block() and ->truncate().
	 */
215 216
	ret = blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs,
				 fat_get_block);
217 218 219 220
	if (ret < 0 && (rw & WRITE))
		fat_write_failed(mapping, offset + iov_length(iov, nr_segs));

	return ret;
221 222
}

L
Linus Torvalds 已提交
223 224
static sector_t _fat_bmap(struct address_space *mapping, sector_t block)
{
O
OGAWA Hirofumi 已提交
225 226 227
	sector_t blocknr;

	/* fat_get_cluster() assumes the requested blocknr isn't truncated. */
228
	down_read(&MSDOS_I(mapping->host)->truncate_lock);
O
OGAWA Hirofumi 已提交
229
	blocknr = generic_block_bmap(mapping, block, fat_get_block);
230
	up_read(&MSDOS_I(mapping->host)->truncate_lock);
O
OGAWA Hirofumi 已提交
231 232

	return blocknr;
L
Linus Torvalds 已提交
233 234
}

235
static const struct address_space_operations fat_aops = {
L
Linus Torvalds 已提交
236
	.readpage	= fat_readpage,
237
	.readpages	= fat_readpages,
L
Linus Torvalds 已提交
238
	.writepage	= fat_writepage,
239
	.writepages	= fat_writepages,
N
Nick Piggin 已提交
240 241
	.write_begin	= fat_write_begin,
	.write_end	= fat_write_end,
242
	.direct_IO	= fat_direct_IO,
L
Linus Torvalds 已提交
243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
	.bmap		= _fat_bmap
};

/*
 * New FAT inode stuff. We do the following:
 *	a) i_ino is constant and has nothing with on-disk location.
 *	b) FAT manages its own cache of directory entries.
 *	c) *This* cache is indexed by on-disk location.
 *	d) inode has an associated directory entry, all right, but
 *		it may be unhashed.
 *	e) currently entries are stored within struct inode. That should
 *		change.
 *	f) we deal with races in the following way:
 *		1. readdir() and lookup() do FAT-dir-cache lookup.
 *		2. rename() unhashes the F-d-c entry and rehashes it in
 *			a new place.
 *		3. unlink() and rmdir() unhash F-d-c entry.
 *		4. fat_write_inode() checks whether the thing is unhashed.
 *			If it is we silently return. If it isn't we do bread(),
 *			check if the location is still valid and retry if it
 *			isn't. Otherwise we do changes.
 *		5. Spinlock is used to protect hash/unhash/location check/lookup
A
Al Viro 已提交
265
 *		6. fat_evict_inode() unhashes the F-d-c entry.
L
Linus Torvalds 已提交
266 267 268 269 270 271 272 273 274 275 276 277 278 279
 *		7. lookup() and readdir() do igrab() if they find a F-d-c entry
 *			and consider negative result as cache miss.
 */

static void fat_hash_init(struct super_block *sb)
{
	struct msdos_sb_info *sbi = MSDOS_SB(sb);
	int i;

	spin_lock_init(&sbi->inode_hash_lock);
	for (i = 0; i < FAT_HASH_SIZE; i++)
		INIT_HLIST_HEAD(&sbi->inode_hashtable[i]);
}

O
OGAWA Hirofumi 已提交
280
static inline unsigned long fat_hash(loff_t i_pos)
L
Linus Torvalds 已提交
281
{
O
OGAWA Hirofumi 已提交
282
	return hash_32(i_pos, FAT_HASH_BITS);
L
Linus Torvalds 已提交
283 284
}

285 286 287 288 289 290 291 292 293 294
static void dir_hash_init(struct super_block *sb)
{
	struct msdos_sb_info *sbi = MSDOS_SB(sb);
	int i;

	spin_lock_init(&sbi->dir_hash_lock);
	for (i = 0; i < FAT_HASH_SIZE; i++)
		INIT_HLIST_HEAD(&sbi->dir_hashtable[i]);
}

L
Linus Torvalds 已提交
295 296
void fat_attach(struct inode *inode, loff_t i_pos)
{
O
OGAWA Hirofumi 已提交
297
	struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
L
Linus Torvalds 已提交
298

299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320
	if (inode->i_ino != MSDOS_ROOT_INO) {
		struct hlist_head *head =   sbi->inode_hashtable
					  + fat_hash(i_pos);

		spin_lock(&sbi->inode_hash_lock);
		MSDOS_I(inode)->i_pos = i_pos;
		hlist_add_head(&MSDOS_I(inode)->i_fat_hash, head);
		spin_unlock(&sbi->inode_hash_lock);
	}

	/* If NFS support is enabled, cache the mapping of start cluster
	 * to directory inode. This is used during reconnection of
	 * dentries to the filesystem root.
	 */
	if (S_ISDIR(inode->i_mode) && sbi->options.nfs) {
		struct hlist_head *d_head = sbi->dir_hashtable;
		d_head += fat_dir_hash(MSDOS_I(inode)->i_logstart);

		spin_lock(&sbi->dir_hash_lock);
		hlist_add_head(&MSDOS_I(inode)->i_dir_hash, d_head);
		spin_unlock(&sbi->dir_hash_lock);
	}
L
Linus Torvalds 已提交
321
}
322
EXPORT_SYMBOL_GPL(fat_attach);
L
Linus Torvalds 已提交
323 324 325 326 327 328 329 330

void fat_detach(struct inode *inode)
{
	struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
	spin_lock(&sbi->inode_hash_lock);
	MSDOS_I(inode)->i_pos = 0;
	hlist_del_init(&MSDOS_I(inode)->i_fat_hash);
	spin_unlock(&sbi->inode_hash_lock);
331 332 333 334 335 336

	if (S_ISDIR(inode->i_mode) && sbi->options.nfs) {
		spin_lock(&sbi->dir_hash_lock);
		hlist_del_init(&MSDOS_I(inode)->i_dir_hash);
		spin_unlock(&sbi->dir_hash_lock);
	}
L
Linus Torvalds 已提交
337
}
338
EXPORT_SYMBOL_GPL(fat_detach);
L
Linus Torvalds 已提交
339 340 341 342

struct inode *fat_iget(struct super_block *sb, loff_t i_pos)
{
	struct msdos_sb_info *sbi = MSDOS_SB(sb);
O
OGAWA Hirofumi 已提交
343
	struct hlist_head *head = sbi->inode_hashtable + fat_hash(i_pos);
L
Linus Torvalds 已提交
344 345 346 347
	struct msdos_inode_info *i;
	struct inode *inode = NULL;

	spin_lock(&sbi->inode_hash_lock);
348
	hlist_for_each_entry(i, head, i_fat_hash) {
L
Linus Torvalds 已提交
349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
		BUG_ON(i->vfs_inode.i_sb != sb);
		if (i->i_pos != i_pos)
			continue;
		inode = igrab(&i->vfs_inode);
		if (inode)
			break;
	}
	spin_unlock(&sbi->inode_hash_lock);
	return inode;
}

static int is_exec(unsigned char *extension)
{
	unsigned char *exe_extensions = "EXECOMBAT", *walk;

	for (walk = exe_extensions; *walk; walk += 3)
		if (!strncmp(extension, walk, 3))
			return 1;
	return 0;
}

static int fat_calc_dir_size(struct inode *inode)
{
	struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
	int ret, fclus, dclus;

	inode->i_size = 0;
	if (MSDOS_I(inode)->i_start == 0)
		return 0;

	ret = fat_get_cluster(inode, FAT_ENT_EOF, &fclus, &dclus);
	if (ret < 0)
		return ret;
	inode->i_size = (fclus + 1) << sbi->cluster_bits;

	return 0;
}

/* doesn't deal with root inode */
388
int fat_fill_inode(struct inode *inode, struct msdos_dir_entry *de)
L
Linus Torvalds 已提交
389 390 391 392 393 394 395 396 397 398 399 400
{
	struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
	int error;

	MSDOS_I(inode)->i_pos = 0;
	inode->i_uid = sbi->options.fs_uid;
	inode->i_gid = sbi->options.fs_gid;
	inode->i_version++;
	inode->i_generation = get_seconds();

	if ((de->attr & ATTR_DIR) && !IS_FREE(de->name)) {
		inode->i_generation &= ~1;
O
OGAWA Hirofumi 已提交
401
		inode->i_mode = fat_make_mode(sbi, de->attr, S_IRWXUGO);
L
Linus Torvalds 已提交
402 403 404
		inode->i_op = sbi->dir_ops;
		inode->i_fop = &fat_dir_operations;

405
		MSDOS_I(inode)->i_start = fat_get_start(sbi, de);
L
Linus Torvalds 已提交
406 407 408 409 410 411
		MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start;
		error = fat_calc_dir_size(inode);
		if (error < 0)
			return error;
		MSDOS_I(inode)->mmu_private = inode->i_size;

M
Miklos Szeredi 已提交
412
		set_nlink(inode, fat_subdirs(inode));
L
Linus Torvalds 已提交
413 414
	} else { /* not a directory */
		inode->i_generation |= 1;
O
OGAWA Hirofumi 已提交
415 416 417
		inode->i_mode = fat_make_mode(sbi, de->attr,
			((sbi->options.showexec && !is_exec(de->name + 8))
			 ? S_IRUGO|S_IWUGO : S_IRWXUGO));
418
		MSDOS_I(inode)->i_start = fat_get_start(sbi, de);
L
Linus Torvalds 已提交
419 420 421 422 423 424 425 426 427 428 429 430

		MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start;
		inode->i_size = le32_to_cpu(de->size);
		inode->i_op = &fat_file_inode_operations;
		inode->i_fop = &fat_file_operations;
		inode->i_mapping->a_ops = &fat_aops;
		MSDOS_I(inode)->mmu_private = inode->i_size;
	}
	if (de->attr & ATTR_SYS) {
		if (sbi->options.sys_immutable)
			inode->i_flags |= S_IMMUTABLE;
	}
O
OGAWA Hirofumi 已提交
431 432
	fat_save_attrs(inode, de->attr);

L
Linus Torvalds 已提交
433 434
	inode->i_blocks = ((inode->i_size + (sbi->cluster_size - 1))
			   & ~((loff_t)sbi->cluster_size - 1)) >> 9;
435 436

	fat_time_fat2unix(sbi, &inode->i_mtime, de->time, de->date, 0);
L
Linus Torvalds 已提交
437
	if (sbi->options.isvfat) {
438 439 440
		fat_time_fat2unix(sbi, &inode->i_ctime, de->ctime,
				  de->cdate, de->ctime_cs);
		fat_time_fat2unix(sbi, &inode->i_atime, 0, de->adate, 0);
L
Linus Torvalds 已提交
441
	} else
S
Stephane Kardas 已提交
442
		inode->i_ctime = inode->i_atime = inode->i_mtime;
L
Linus Torvalds 已提交
443 444 445 446

	return 0;
}

447 448 449 450 451 452 453 454 455 456 457 458
static inline void fat_lock_build_inode(struct msdos_sb_info *sbi)
{
	if (sbi->options.nfs == FAT_NFS_NOSTALE_RO)
		mutex_lock(&sbi->nfs_build_inode_lock);
}

static inline void fat_unlock_build_inode(struct msdos_sb_info *sbi)
{
	if (sbi->options.nfs == FAT_NFS_NOSTALE_RO)
		mutex_unlock(&sbi->nfs_build_inode_lock);
}

L
Linus Torvalds 已提交
459 460 461 462 463 464
struct inode *fat_build_inode(struct super_block *sb,
			struct msdos_dir_entry *de, loff_t i_pos)
{
	struct inode *inode;
	int err;

465
	fat_lock_build_inode(MSDOS_SB(sb));
L
Linus Torvalds 已提交
466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484
	inode = fat_iget(sb, i_pos);
	if (inode)
		goto out;
	inode = new_inode(sb);
	if (!inode) {
		inode = ERR_PTR(-ENOMEM);
		goto out;
	}
	inode->i_ino = iunique(sb, MSDOS_ROOT_INO);
	inode->i_version = 1;
	err = fat_fill_inode(inode, de);
	if (err) {
		iput(inode);
		inode = ERR_PTR(err);
		goto out;
	}
	fat_attach(inode, i_pos);
	insert_inode_hash(inode);
out:
485
	fat_unlock_build_inode(MSDOS_SB(sb));
L
Linus Torvalds 已提交
486 487 488
	return inode;
}

489
EXPORT_SYMBOL_GPL(fat_build_inode);
L
Linus Torvalds 已提交
490

A
Al Viro 已提交
491
static void fat_evict_inode(struct inode *inode)
L
Linus Torvalds 已提交
492
{
493
	truncate_inode_pages(&inode->i_data, 0);
A
Al Viro 已提交
494 495 496 497 498
	if (!inode->i_nlink) {
		inode->i_size = 0;
		fat_truncate_blocks(inode, 0);
	}
	invalidate_inode_buffers(inode);
499
	clear_inode(inode);
L
Linus Torvalds 已提交
500
	fat_cache_inval_inode(inode);
501
	fat_detach(inode);
L
Linus Torvalds 已提交
502 503
}

504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550
static void fat_set_state(struct super_block *sb,
			unsigned int set, unsigned int force)
{
	struct buffer_head *bh;
	struct fat_boot_sector *b;
	struct msdos_sb_info *sbi = sb->s_fs_info;

	/* do not change any thing if mounted read only */
	if ((sb->s_flags & MS_RDONLY) && !force)
		return;

	/* do not change state if fs was dirty */
	if (sbi->dirty) {
		/* warn only on set (mount). */
		if (set)
			fat_msg(sb, KERN_WARNING, "Volume was not properly "
				"unmounted. Some data may be corrupt. "
				"Please run fsck.");
		return;
	}

	bh = sb_bread(sb, 0);
	if (bh == NULL) {
		fat_msg(sb, KERN_ERR, "unable to read boot sector "
			"to mark fs as dirty");
		return;
	}

	b = (struct fat_boot_sector *) bh->b_data;

	if (sbi->fat_bits == 32) {
		if (set)
			b->fat32.state |= FAT_STATE_DIRTY;
		else
			b->fat32.state &= ~FAT_STATE_DIRTY;
	} else /* fat 16 and 12 */ {
		if (set)
			b->fat16.state |= FAT_STATE_DIRTY;
		else
			b->fat16.state &= ~FAT_STATE_DIRTY;
	}

	mark_buffer_dirty(bh);
	sync_dirty_buffer(bh);
	brelse(bh);
}

551 552 553
static void fat_put_super(struct super_block *sb)
{
	struct msdos_sb_info *sbi = MSDOS_SB(sb);
L
Linus Torvalds 已提交
554

555 556
	fat_set_state(sb, 0, 0);

557
	iput(sbi->fsinfo_inode);
A
Al Viro 已提交
558 559
	iput(sbi->fat_inode);

560 561 562 563
	unload_nls(sbi->nls_disk);
	unload_nls(sbi->nls_io);

	if (sbi->options.iocharset != fat_default_iocharset)
L
Linus Torvalds 已提交
564 565 566 567 568 569
		kfree(sbi->options.iocharset);

	sb->s_fs_info = NULL;
	kfree(sbi);
}

570
static struct kmem_cache *fat_inode_cachep;
L
Linus Torvalds 已提交
571 572 573 574

static struct inode *fat_alloc_inode(struct super_block *sb)
{
	struct msdos_inode_info *ei;
575
	ei = kmem_cache_alloc(fat_inode_cachep, GFP_NOFS);
L
Linus Torvalds 已提交
576 577
	if (!ei)
		return NULL;
578 579

	init_rwsem(&ei->truncate_lock);
L
Linus Torvalds 已提交
580 581 582
	return &ei->vfs_inode;
}

N
Nick Piggin 已提交
583
static void fat_i_callback(struct rcu_head *head)
L
Linus Torvalds 已提交
584
{
N
Nick Piggin 已提交
585
	struct inode *inode = container_of(head, struct inode, i_rcu);
L
Linus Torvalds 已提交
586 587 588
	kmem_cache_free(fat_inode_cachep, MSDOS_I(inode));
}

N
Nick Piggin 已提交
589 590 591 592 593
static void fat_destroy_inode(struct inode *inode)
{
	call_rcu(&inode->i_rcu, fat_i_callback);
}

594
static void init_once(void *foo)
L
Linus Torvalds 已提交
595 596 597
{
	struct msdos_inode_info *ei = (struct msdos_inode_info *)foo;

C
Christoph Lameter 已提交
598 599 600 601 602
	spin_lock_init(&ei->cache_lru_lock);
	ei->nr_caches = 0;
	ei->cache_valid_id = FAT_CACHE_VALID + 1;
	INIT_LIST_HEAD(&ei->cache_lru);
	INIT_HLIST_NODE(&ei->i_fat_hash);
603
	INIT_HLIST_NODE(&ei->i_dir_hash);
C
Christoph Lameter 已提交
604
	inode_init_once(&ei->vfs_inode);
L
Linus Torvalds 已提交
605 606 607 608 609 610
}

static int __init fat_init_inodecache(void)
{
	fat_inode_cachep = kmem_cache_create("fat_inode_cache",
					     sizeof(struct msdos_inode_info),
611 612
					     0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
613
					     init_once);
L
Linus Torvalds 已提交
614 615 616 617 618 619 620
	if (fat_inode_cachep == NULL)
		return -ENOMEM;
	return 0;
}

static void __exit fat_destroy_inodecache(void)
{
621 622 623 624 625
	/*
	 * Make sure all delayed rcu free inodes are flushed before we
	 * destroy cache.
	 */
	rcu_barrier();
626
	kmem_cache_destroy(fat_inode_cachep);
L
Linus Torvalds 已提交
627 628 629 630
}

static int fat_remount(struct super_block *sb, int *flags, char *data)
{
631
	int new_rdonly;
L
Linus Torvalds 已提交
632 633
	struct msdos_sb_info *sbi = MSDOS_SB(sb);
	*flags |= MS_NODIRATIME | (sbi->options.isvfat ? 0 : MS_NOATIME);
634 635 636 637 638 639 640 641 642

	/* make sure we update state on remount. */
	new_rdonly = *flags & MS_RDONLY;
	if (new_rdonly != (sb->s_flags & MS_RDONLY)) {
		if (new_rdonly)
			fat_set_state(sb, 0, 0);
		else
			fat_set_state(sb, 1, 1);
	}
L
Linus Torvalds 已提交
643 644 645
	return 0;
}

646
static int fat_statfs(struct dentry *dentry, struct kstatfs *buf)
L
Linus Torvalds 已提交
647
{
C
Coly Li 已提交
648 649 650
	struct super_block *sb = dentry->d_sb;
	struct msdos_sb_info *sbi = MSDOS_SB(sb);
	u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
L
Linus Torvalds 已提交
651 652

	/* If the count of free cluster is still unknown, counts it here. */
653
	if (sbi->free_clusters == -1 || !sbi->free_clus_valid) {
654
		int err = fat_count_free_clusters(dentry->d_sb);
L
Linus Torvalds 已提交
655 656 657 658
		if (err)
			return err;
	}

659
	buf->f_type = dentry->d_sb->s_magic;
L
Linus Torvalds 已提交
660 661 662 663
	buf->f_bsize = sbi->cluster_size;
	buf->f_blocks = sbi->max_cluster - FAT_START_ENT;
	buf->f_bfree = sbi->free_clusters;
	buf->f_bavail = sbi->free_clusters;
C
Coly Li 已提交
664 665
	buf->f_fsid.val[0] = (u32)id;
	buf->f_fsid.val[1] = (u32)(id >> 32);
O
OGAWA Hirofumi 已提交
666 667
	buf->f_namelen =
		(sbi->options.isvfat ? FAT_LFN_LEN : 12) * NLS_MAX_CHARSET_SIZE;
L
Linus Torvalds 已提交
668 669 670 671

	return 0;
}

672
static int __fat_write_inode(struct inode *inode, int wait)
L
Linus Torvalds 已提交
673 674 675 676 677 678
{
	struct super_block *sb = inode->i_sb;
	struct msdos_sb_info *sbi = MSDOS_SB(sb);
	struct buffer_head *bh;
	struct msdos_dir_entry *raw_entry;
	loff_t i_pos;
679 680
	sector_t blocknr;
	int err, offset;
L
Linus Torvalds 已提交
681

O
OGAWA Hirofumi 已提交
682 683 684
	if (inode->i_ino == MSDOS_ROOT_INO)
		return 0;

L
Linus Torvalds 已提交
685
retry:
O
OGAWA Hirofumi 已提交
686 687
	i_pos = fat_i_pos_read(sbi, inode);
	if (!i_pos)
L
Linus Torvalds 已提交
688 689
		return 0;

690 691
	fat_get_blknr_offset(sbi, i_pos, &blocknr, &offset);
	bh = sb_bread(sb, blocknr);
L
Linus Torvalds 已提交
692
	if (!bh) {
693 694
		fat_msg(sb, KERN_ERR, "unable to read inode block "
		       "for updating (i_pos %lld)", i_pos);
695
		return -EIO;
L
Linus Torvalds 已提交
696 697 698 699 700 701 702 703
	}
	spin_lock(&sbi->inode_hash_lock);
	if (i_pos != MSDOS_I(inode)->i_pos) {
		spin_unlock(&sbi->inode_hash_lock);
		brelse(bh);
		goto retry;
	}

704
	raw_entry = &((struct msdos_dir_entry *) (bh->b_data))[offset];
L
Linus Torvalds 已提交
705 706 707 708
	if (S_ISDIR(inode->i_mode))
		raw_entry->size = 0;
	else
		raw_entry->size = cpu_to_le32(inode->i_size);
O
OGAWA Hirofumi 已提交
709
	raw_entry->attr = fat_make_attrs(inode);
710
	fat_set_start(raw_entry, MSDOS_I(inode)->i_logstart);
711 712
	fat_time_unix2fat(sbi, &inode->i_mtime, &raw_entry->time,
			  &raw_entry->date, NULL);
L
Linus Torvalds 已提交
713
	if (sbi->options.isvfat) {
S
Stephane Kardas 已提交
714
		__le16 atime;
715 716 717 718
		fat_time_unix2fat(sbi, &inode->i_ctime, &raw_entry->ctime,
				  &raw_entry->cdate, &raw_entry->ctime_cs);
		fat_time_unix2fat(sbi, &inode->i_atime, &atime,
				  &raw_entry->adate, NULL);
L
Linus Torvalds 已提交
719 720 721
	}
	spin_unlock(&sbi->inode_hash_lock);
	mark_buffer_dirty(bh);
722
	err = 0;
L
Linus Torvalds 已提交
723 724 725 726 727 728
	if (wait)
		err = sync_dirty_buffer(bh);
	brelse(bh);
	return err;
}

729 730
static int fat_write_inode(struct inode *inode, struct writeback_control *wbc)
{
A
Artem Bityutskiy 已提交
731 732 733 734 735
	int err;

	if (inode->i_ino == MSDOS_FSINFO_INO) {
		struct super_block *sb = inode->i_sb;

M
Marco Stornelli 已提交
736
		mutex_lock(&MSDOS_SB(sb)->s_lock);
A
Artem Bityutskiy 已提交
737
		err = fat_clusters_flush(sb);
M
Marco Stornelli 已提交
738
		mutex_unlock(&MSDOS_SB(sb)->s_lock);
A
Artem Bityutskiy 已提交
739 740 741 742
	} else
		err = __fat_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL);

	return err;
743 744
}

L
Linus Torvalds 已提交
745 746
int fat_sync_inode(struct inode *inode)
{
747
	return __fat_write_inode(inode, 1);
L
Linus Torvalds 已提交
748 749
}

750
EXPORT_SYMBOL_GPL(fat_sync_inode);
L
Linus Torvalds 已提交
751

752
static int fat_show_options(struct seq_file *m, struct dentry *root);
753
static const struct super_operations fat_sops = {
L
Linus Torvalds 已提交
754 755 756
	.alloc_inode	= fat_alloc_inode,
	.destroy_inode	= fat_destroy_inode,
	.write_inode	= fat_write_inode,
A
Al Viro 已提交
757
	.evict_inode	= fat_evict_inode,
L
Linus Torvalds 已提交
758 759 760 761 762 763 764
	.put_super	= fat_put_super,
	.statfs		= fat_statfs,
	.remount_fs	= fat_remount,

	.show_options	= fat_show_options,
};

765
static int fat_show_options(struct seq_file *m, struct dentry *root)
L
Linus Torvalds 已提交
766
{
767
	struct msdos_sb_info *sbi = MSDOS_SB(root->d_sb);
L
Linus Torvalds 已提交
768 769 770
	struct fat_mount_options *opts = &sbi->options;
	int isvfat = opts->isvfat;

771 772 773 774 775 776
	if (!uid_eq(opts->fs_uid, GLOBAL_ROOT_UID))
		seq_printf(m, ",uid=%u",
				from_kuid_munged(&init_user_ns, opts->fs_uid));
	if (!gid_eq(opts->fs_gid, GLOBAL_ROOT_GID))
		seq_printf(m, ",gid=%u",
				from_kgid_munged(&init_user_ns, opts->fs_gid));
L
Linus Torvalds 已提交
777 778
	seq_printf(m, ",fmask=%04o", opts->fs_fmask);
	seq_printf(m, ",dmask=%04o", opts->fs_dmask);
O
OGAWA Hirofumi 已提交
779 780
	if (opts->allow_utime)
		seq_printf(m, ",allow_utime=%04o", opts->allow_utime);
L
Linus Torvalds 已提交
781
	if (sbi->nls_disk)
782 783
		/* strip "cp" prefix from displayed option */
		seq_printf(m, ",codepage=%s", &sbi->nls_disk->charset[2]);
L
Linus Torvalds 已提交
784 785 786 787 788 789 790 791 792 793 794 795 796 797 798
	if (isvfat) {
		if (sbi->nls_io)
			seq_printf(m, ",iocharset=%s", sbi->nls_io->charset);

		switch (opts->shortname) {
		case VFAT_SFN_DISPLAY_WIN95 | VFAT_SFN_CREATE_WIN95:
			seq_puts(m, ",shortname=win95");
			break;
		case VFAT_SFN_DISPLAY_WINNT | VFAT_SFN_CREATE_WINNT:
			seq_puts(m, ",shortname=winnt");
			break;
		case VFAT_SFN_DISPLAY_WINNT | VFAT_SFN_CREATE_WIN95:
			seq_puts(m, ",shortname=mixed");
			break;
		case VFAT_SFN_DISPLAY_LOWER | VFAT_SFN_CREATE_WIN95:
799
			seq_puts(m, ",shortname=lower");
L
Linus Torvalds 已提交
800 801 802 803 804 805 806 807
			break;
		default:
			seq_puts(m, ",shortname=unknown");
			break;
		}
	}
	if (opts->name_check != 'n')
		seq_printf(m, ",check=%c", opts->name_check);
808 809
	if (opts->usefree)
		seq_puts(m, ",usefree");
L
Linus Torvalds 已提交
810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827
	if (opts->quiet)
		seq_puts(m, ",quiet");
	if (opts->showexec)
		seq_puts(m, ",showexec");
	if (opts->sys_immutable)
		seq_puts(m, ",sys_immutable");
	if (!isvfat) {
		if (opts->dotsOK)
			seq_puts(m, ",dotsOK=yes");
		if (opts->nocase)
			seq_puts(m, ",nocase");
	} else {
		if (opts->utf8)
			seq_puts(m, ",utf8");
		if (opts->unicode_xlate)
			seq_puts(m, ",uni_xlate");
		if (!opts->numtail)
			seq_puts(m, ",nonumtail");
O
OGAWA Hirofumi 已提交
828 829
		if (opts->rodir)
			seq_puts(m, ",rodir");
L
Linus Torvalds 已提交
830
	}
O
OGAWA Hirofumi 已提交
831
	if (opts->flush)
M
Miklos Szeredi 已提交
832
		seq_puts(m, ",flush");
833 834 835 836 837 838
	if (opts->tz_set) {
		if (opts->time_offset)
			seq_printf(m, ",time_offset=%d", opts->time_offset);
		else
			seq_puts(m, ",tz=UTC");
	}
D
Denis Karpov 已提交
839 840 841 842 843 844
	if (opts->errors == FAT_ERRORS_CONT)
		seq_puts(m, ",errors=continue");
	else if (opts->errors == FAT_ERRORS_PANIC)
		seq_puts(m, ",errors=panic");
	else
		seq_puts(m, ",errors=remount-ro");
845 846 847 848
	if (opts->nfs == FAT_NFS_NOSTALE_RO)
		seq_puts(m, ",nfs=nostale_ro");
	else if (opts->nfs)
		seq_puts(m, ",nfs=stale_rw");
849 850
	if (opts->discard)
		seq_puts(m, ",discard");
L
Linus Torvalds 已提交
851 852 853 854 855 856

	return 0;
}

enum {
	Opt_check_n, Opt_check_r, Opt_check_s, Opt_uid, Opt_gid,
O
OGAWA Hirofumi 已提交
857 858 859
	Opt_umask, Opt_dmask, Opt_fmask, Opt_allow_utime, Opt_codepage,
	Opt_usefree, Opt_nocase, Opt_quiet, Opt_showexec, Opt_debug,
	Opt_immutable, Opt_dots, Opt_nodots,
L
Linus Torvalds 已提交
860 861 862
	Opt_charset, Opt_shortname_lower, Opt_shortname_win95,
	Opt_shortname_winnt, Opt_shortname_mixed, Opt_utf8_no, Opt_utf8_yes,
	Opt_uni_xl_no, Opt_uni_xl_yes, Opt_nonumtail_no, Opt_nonumtail_yes,
863
	Opt_obsolete, Opt_flush, Opt_tz_utc, Opt_rodir, Opt_err_cont,
864
	Opt_err_panic, Opt_err_ro, Opt_discard, Opt_nfs, Opt_time_offset,
865
	Opt_nfs_stale_rw, Opt_nfs_nostale_ro, Opt_err,
L
Linus Torvalds 已提交
866 867
};

868
static const match_table_t fat_tokens = {
L
Linus Torvalds 已提交
869 870 871 872 873 874 875 876 877 878 879
	{Opt_check_r, "check=relaxed"},
	{Opt_check_s, "check=strict"},
	{Opt_check_n, "check=normal"},
	{Opt_check_r, "check=r"},
	{Opt_check_s, "check=s"},
	{Opt_check_n, "check=n"},
	{Opt_uid, "uid=%u"},
	{Opt_gid, "gid=%u"},
	{Opt_umask, "umask=%o"},
	{Opt_dmask, "dmask=%o"},
	{Opt_fmask, "fmask=%o"},
O
OGAWA Hirofumi 已提交
880
	{Opt_allow_utime, "allow_utime=%o"},
L
Linus Torvalds 已提交
881
	{Opt_codepage, "codepage=%u"},
882
	{Opt_usefree, "usefree"},
L
Linus Torvalds 已提交
883 884 885 886 887
	{Opt_nocase, "nocase"},
	{Opt_quiet, "quiet"},
	{Opt_showexec, "showexec"},
	{Opt_debug, "debug"},
	{Opt_immutable, "sys_immutable"},
D
Denis Karpov 已提交
888 889
	{Opt_flush, "flush"},
	{Opt_tz_utc, "tz=UTC"},
890
	{Opt_time_offset, "time_offset=%d"},
D
Denis Karpov 已提交
891 892 893
	{Opt_err_cont, "errors=continue"},
	{Opt_err_panic, "errors=panic"},
	{Opt_err_ro, "errors=remount-ro"},
894
	{Opt_discard, "discard"},
895 896 897
	{Opt_nfs_stale_rw, "nfs"},
	{Opt_nfs_stale_rw, "nfs=stale_rw"},
	{Opt_nfs_nostale_ro, "nfs=nostale_ro"},
898 899 900 901 902 903 904 905 906 907 908
	{Opt_obsolete, "conv=binary"},
	{Opt_obsolete, "conv=text"},
	{Opt_obsolete, "conv=auto"},
	{Opt_obsolete, "conv=b"},
	{Opt_obsolete, "conv=t"},
	{Opt_obsolete, "conv=a"},
	{Opt_obsolete, "fat=%u"},
	{Opt_obsolete, "blocksize=%u"},
	{Opt_obsolete, "cvf_format=%20s"},
	{Opt_obsolete, "cvf_options=%100s"},
	{Opt_obsolete, "posix"},
C
Chris Mason 已提交
909
	{Opt_err, NULL},
L
Linus Torvalds 已提交
910
};
911
static const match_table_t msdos_tokens = {
L
Linus Torvalds 已提交
912 913 914 915 916 917
	{Opt_nodots, "nodots"},
	{Opt_nodots, "dotsOK=no"},
	{Opt_dots, "dots"},
	{Opt_dots, "dotsOK=yes"},
	{Opt_err, NULL}
};
918
static const match_table_t vfat_tokens = {
L
Linus Torvalds 已提交
919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944
	{Opt_charset, "iocharset=%s"},
	{Opt_shortname_lower, "shortname=lower"},
	{Opt_shortname_win95, "shortname=win95"},
	{Opt_shortname_winnt, "shortname=winnt"},
	{Opt_shortname_mixed, "shortname=mixed"},
	{Opt_utf8_no, "utf8=0"},		/* 0 or no or false */
	{Opt_utf8_no, "utf8=no"},
	{Opt_utf8_no, "utf8=false"},
	{Opt_utf8_yes, "utf8=1"},		/* empty or 1 or yes or true */
	{Opt_utf8_yes, "utf8=yes"},
	{Opt_utf8_yes, "utf8=true"},
	{Opt_utf8_yes, "utf8"},
	{Opt_uni_xl_no, "uni_xlate=0"},		/* 0 or no or false */
	{Opt_uni_xl_no, "uni_xlate=no"},
	{Opt_uni_xl_no, "uni_xlate=false"},
	{Opt_uni_xl_yes, "uni_xlate=1"},	/* empty or 1 or yes or true */
	{Opt_uni_xl_yes, "uni_xlate=yes"},
	{Opt_uni_xl_yes, "uni_xlate=true"},
	{Opt_uni_xl_yes, "uni_xlate"},
	{Opt_nonumtail_no, "nonumtail=0"},	/* 0 or no or false */
	{Opt_nonumtail_no, "nonumtail=no"},
	{Opt_nonumtail_no, "nonumtail=false"},
	{Opt_nonumtail_yes, "nonumtail=1"},	/* empty or 1 or yes or true */
	{Opt_nonumtail_yes, "nonumtail=yes"},
	{Opt_nonumtail_yes, "nonumtail=true"},
	{Opt_nonumtail_yes, "nonumtail"},
O
OGAWA Hirofumi 已提交
945
	{Opt_rodir, "rodir"},
L
Linus Torvalds 已提交
946 947 948
	{Opt_err, NULL}
};

949 950
static int parse_options(struct super_block *sb, char *options, int is_vfat,
			 int silent, int *debug, struct fat_mount_options *opts)
L
Linus Torvalds 已提交
951 952 953 954 955 956 957 958
{
	char *p;
	substring_t args[MAX_OPT_ARGS];
	int option;
	char *iocharset;

	opts->isvfat = is_vfat;

959 960
	opts->fs_uid = current_uid();
	opts->fs_gid = current_gid();
961
	opts->fs_fmask = opts->fs_dmask = current_umask();
O
OGAWA Hirofumi 已提交
962
	opts->allow_utime = -1;
L
Linus Torvalds 已提交
963 964
	opts->codepage = fat_default_codepage;
	opts->iocharset = fat_default_iocharset;
O
OGAWA Hirofumi 已提交
965
	if (is_vfat) {
966
		opts->shortname = VFAT_SFN_DISPLAY_WINNT|VFAT_SFN_CREATE_WIN95;
O
OGAWA Hirofumi 已提交
967 968
		opts->rodir = 0;
	} else {
L
Linus Torvalds 已提交
969
		opts->shortname = 0;
O
OGAWA Hirofumi 已提交
970 971
		opts->rodir = 1;
	}
L
Linus Torvalds 已提交
972 973 974 975
	opts->name_check = 'n';
	opts->quiet = opts->showexec = opts->sys_immutable = opts->dotsOK =  0;
	opts->utf8 = opts->unicode_xlate = 0;
	opts->numtail = 1;
976
	opts->usefree = opts->nocase = 0;
977
	opts->tz_set = 0;
978
	opts->nfs = 0;
D
Denis Karpov 已提交
979
	opts->errors = FAT_ERRORS_RO;
L
Linus Torvalds 已提交
980 981 982
	*debug = 0;

	if (!options)
O
OGAWA Hirofumi 已提交
983
		goto out;
L
Linus Torvalds 已提交
984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006

	while ((p = strsep(&options, ",")) != NULL) {
		int token;
		if (!*p)
			continue;

		token = match_token(p, fat_tokens, args);
		if (token == Opt_err) {
			if (is_vfat)
				token = match_token(p, vfat_tokens, args);
			else
				token = match_token(p, msdos_tokens, args);
		}
		switch (token) {
		case Opt_check_s:
			opts->name_check = 's';
			break;
		case Opt_check_r:
			opts->name_check = 'r';
			break;
		case Opt_check_n:
			opts->name_check = 'n';
			break;
1007 1008 1009
		case Opt_usefree:
			opts->usefree = 1;
			break;
L
Linus Torvalds 已提交
1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
		case Opt_nocase:
			if (!is_vfat)
				opts->nocase = 1;
			else {
				/* for backward compatibility */
				opts->shortname = VFAT_SFN_DISPLAY_WIN95
					| VFAT_SFN_CREATE_WIN95;
			}
			break;
		case Opt_quiet:
			opts->quiet = 1;
			break;
		case Opt_showexec:
			opts->showexec = 1;
			break;
		case Opt_debug:
			*debug = 1;
			break;
		case Opt_immutable:
			opts->sys_immutable = 1;
			break;
		case Opt_uid:
			if (match_int(&args[0], &option))
J
Jan Kara 已提交
1033
				return -EINVAL;
1034 1035
			opts->fs_uid = make_kuid(current_user_ns(), option);
			if (!uid_valid(opts->fs_uid))
J
Jan Kara 已提交
1036
				return -EINVAL;
L
Linus Torvalds 已提交
1037 1038 1039
			break;
		case Opt_gid:
			if (match_int(&args[0], &option))
J
Jan Kara 已提交
1040
				return -EINVAL;
1041 1042
			opts->fs_gid = make_kgid(current_user_ns(), option);
			if (!gid_valid(opts->fs_gid))
J
Jan Kara 已提交
1043
				return -EINVAL;
L
Linus Torvalds 已提交
1044 1045 1046
			break;
		case Opt_umask:
			if (match_octal(&args[0], &option))
J
Jan Kara 已提交
1047
				return -EINVAL;
L
Linus Torvalds 已提交
1048 1049 1050 1051
			opts->fs_fmask = opts->fs_dmask = option;
			break;
		case Opt_dmask:
			if (match_octal(&args[0], &option))
J
Jan Kara 已提交
1052
				return -EINVAL;
L
Linus Torvalds 已提交
1053 1054 1055 1056
			opts->fs_dmask = option;
			break;
		case Opt_fmask:
			if (match_octal(&args[0], &option))
J
Jan Kara 已提交
1057
				return -EINVAL;
L
Linus Torvalds 已提交
1058 1059
			opts->fs_fmask = option;
			break;
O
OGAWA Hirofumi 已提交
1060 1061
		case Opt_allow_utime:
			if (match_octal(&args[0], &option))
J
Jan Kara 已提交
1062
				return -EINVAL;
O
OGAWA Hirofumi 已提交
1063 1064
			opts->allow_utime = option & (S_IWGRP | S_IWOTH);
			break;
L
Linus Torvalds 已提交
1065 1066
		case Opt_codepage:
			if (match_int(&args[0], &option))
J
Jan Kara 已提交
1067
				return -EINVAL;
L
Linus Torvalds 已提交
1068 1069
			opts->codepage = option;
			break;
C
Chris Mason 已提交
1070 1071 1072
		case Opt_flush:
			opts->flush = 1;
			break;
1073 1074
		case Opt_time_offset:
			if (match_int(&args[0], &option))
J
Jan Kara 已提交
1075
				return -EINVAL;
1076
			if (option < -12 * 60 || option > 12 * 60)
J
Jan Kara 已提交
1077
				return -EINVAL;
1078 1079 1080
			opts->tz_set = 1;
			opts->time_offset = option;
			break;
J
Joe Peterson 已提交
1081
		case Opt_tz_utc:
1082 1083
			opts->tz_set = 1;
			opts->time_offset = 0;
J
Joe Peterson 已提交
1084
			break;
D
Denis Karpov 已提交
1085 1086 1087 1088 1089 1090 1091 1092 1093
		case Opt_err_cont:
			opts->errors = FAT_ERRORS_CONT;
			break;
		case Opt_err_panic:
			opts->errors = FAT_ERRORS_PANIC;
			break;
		case Opt_err_ro:
			opts->errors = FAT_ERRORS_RO;
			break;
1094 1095 1096 1097 1098 1099
		case Opt_nfs_stale_rw:
			opts->nfs = FAT_NFS_STALE_RW;
			break;
		case Opt_nfs_nostale_ro:
			opts->nfs = FAT_NFS_NOSTALE_RO;
			break;
L
Linus Torvalds 已提交
1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151

		/* msdos specific */
		case Opt_dots:
			opts->dotsOK = 1;
			break;
		case Opt_nodots:
			opts->dotsOK = 0;
			break;

		/* vfat specific */
		case Opt_charset:
			if (opts->iocharset != fat_default_iocharset)
				kfree(opts->iocharset);
			iocharset = match_strdup(&args[0]);
			if (!iocharset)
				return -ENOMEM;
			opts->iocharset = iocharset;
			break;
		case Opt_shortname_lower:
			opts->shortname = VFAT_SFN_DISPLAY_LOWER
					| VFAT_SFN_CREATE_WIN95;
			break;
		case Opt_shortname_win95:
			opts->shortname = VFAT_SFN_DISPLAY_WIN95
					| VFAT_SFN_CREATE_WIN95;
			break;
		case Opt_shortname_winnt:
			opts->shortname = VFAT_SFN_DISPLAY_WINNT
					| VFAT_SFN_CREATE_WINNT;
			break;
		case Opt_shortname_mixed:
			opts->shortname = VFAT_SFN_DISPLAY_WINNT
					| VFAT_SFN_CREATE_WIN95;
			break;
		case Opt_utf8_no:		/* 0 or no or false */
			opts->utf8 = 0;
			break;
		case Opt_utf8_yes:		/* empty or 1 or yes or true */
			opts->utf8 = 1;
			break;
		case Opt_uni_xl_no:		/* 0 or no or false */
			opts->unicode_xlate = 0;
			break;
		case Opt_uni_xl_yes:		/* empty or 1 or yes or true */
			opts->unicode_xlate = 1;
			break;
		case Opt_nonumtail_no:		/* 0 or no or false */
			opts->numtail = 1;	/* negated option */
			break;
		case Opt_nonumtail_yes:		/* empty or 1 or yes or true */
			opts->numtail = 0;	/* negated option */
			break;
O
OGAWA Hirofumi 已提交
1152 1153 1154
		case Opt_rodir:
			opts->rodir = 1;
			break;
1155 1156 1157
		case Opt_discard:
			opts->discard = 1;
			break;
L
Linus Torvalds 已提交
1158 1159

		/* obsolete mount options */
1160
		case Opt_obsolete:
1161 1162
			fat_msg(sb, KERN_INFO, "\"%s\" option is obsolete, "
			       "not supported now", p);
L
Linus Torvalds 已提交
1163 1164 1165
			break;
		/* unknown option */
		default:
1166
			if (!silent) {
1167 1168 1169
				fat_msg(sb, KERN_ERR,
				       "Unrecognized mount option \"%s\" "
				       "or missing value", p);
1170
			}
L
Linus Torvalds 已提交
1171 1172 1173
			return -EINVAL;
		}
	}
O
OGAWA Hirofumi 已提交
1174 1175

out:
A
Alexey Dobriyan 已提交
1176
	/* UTF-8 doesn't provide FAT semantics */
L
Linus Torvalds 已提交
1177
	if (!strcmp(opts->iocharset, "utf8")) {
1178
		fat_msg(sb, KERN_WARNING, "utf8 is not a recommended IO charset"
O
OGAWA Hirofumi 已提交
1179
		       " for FAT filesystems, filesystem will be "
1180
		       "case sensitive!");
L
Linus Torvalds 已提交
1181 1182
	}

O
OGAWA Hirofumi 已提交
1183 1184 1185
	/* If user doesn't specify allow_utime, it's initialized from dmask. */
	if (opts->allow_utime == (unsigned short)-1)
		opts->allow_utime = ~opts->fs_dmask & (S_IWGRP | S_IWOTH);
L
Linus Torvalds 已提交
1186 1187
	if (opts->unicode_xlate)
		opts->utf8 = 0;
N
Namjae Jeon 已提交
1188
	if (opts->nfs == FAT_NFS_NOSTALE_RO) {
1189
		sb->s_flags |= MS_RDONLY;
N
Namjae Jeon 已提交
1190 1191
		sb->s_export_op = &fat_export_ops_nostale;
	}
L
Linus Torvalds 已提交
1192 1193 1194 1195 1196 1197 1198 1199 1200 1201

	return 0;
}

static int fat_read_root(struct inode *inode)
{
	struct super_block *sb = inode->i_sb;
	struct msdos_sb_info *sbi = MSDOS_SB(sb);
	int error;

N
Namjae Jeon 已提交
1202
	MSDOS_I(inode)->i_pos = MSDOS_ROOT_INO;
L
Linus Torvalds 已提交
1203 1204 1205 1206
	inode->i_uid = sbi->options.fs_uid;
	inode->i_gid = sbi->options.fs_gid;
	inode->i_version++;
	inode->i_generation = 0;
O
OGAWA Hirofumi 已提交
1207
	inode->i_mode = fat_make_mode(sbi, ATTR_DIR, S_IRWXUGO);
L
Linus Torvalds 已提交
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223
	inode->i_op = sbi->dir_ops;
	inode->i_fop = &fat_dir_operations;
	if (sbi->fat_bits == 32) {
		MSDOS_I(inode)->i_start = sbi->root_cluster;
		error = fat_calc_dir_size(inode);
		if (error < 0)
			return error;
	} else {
		MSDOS_I(inode)->i_start = 0;
		inode->i_size = sbi->dir_entries * sizeof(struct msdos_dir_entry);
	}
	inode->i_blocks = ((inode->i_size + (sbi->cluster_size - 1))
			   & ~((loff_t)sbi->cluster_size - 1)) >> 9;
	MSDOS_I(inode)->i_logstart = 0;
	MSDOS_I(inode)->mmu_private = inode->i_size;

O
OGAWA Hirofumi 已提交
1224
	fat_save_attrs(inode, ATTR_DIR);
L
Linus Torvalds 已提交
1225 1226
	inode->i_mtime.tv_sec = inode->i_atime.tv_sec = inode->i_ctime.tv_sec = 0;
	inode->i_mtime.tv_nsec = inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = 0;
M
Miklos Szeredi 已提交
1227
	set_nlink(inode, fat_subdirs(inode)+2);
L
Linus Torvalds 已提交
1228 1229 1230 1231

	return 0;
}

1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244
static unsigned long calc_fat_clusters(struct super_block *sb)
{
	struct msdos_sb_info *sbi = MSDOS_SB(sb);

	/* Divide first to avoid overflow */
	if (sbi->fat_bits != 12) {
		unsigned long ent_per_sec = sb->s_blocksize * 8 / sbi->fat_bits;
		return ent_per_sec * sbi->fat_length;
	}

	return sbi->fat_length * sb->s_blocksize * 8 / sbi->fat_bits;
}

L
Linus Torvalds 已提交
1245 1246 1247
/*
 * Read the super block of an MS-DOS FS.
 */
1248
int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
1249
		   void (*setup)(struct super_block *))
L
Linus Torvalds 已提交
1250
{
A
Al Viro 已提交
1251
	struct inode *root_inode = NULL, *fat_inode = NULL;
1252
	struct inode *fsinfo_inode = NULL;
L
Linus Torvalds 已提交
1253 1254 1255 1256 1257 1258 1259 1260 1261 1262
	struct buffer_head *bh;
	struct fat_boot_sector *b;
	struct msdos_sb_info *sbi;
	u16 logical_sector_size;
	u32 total_sectors, total_clusters, fat_clusters, rootdir_sectors;
	int debug;
	unsigned int media;
	long error;
	char buf[50];

1263 1264 1265 1266 1267 1268
	/*
	 * GFP_KERNEL is ok here, because while we do hold the
	 * supeblock lock, memory pressure can't call back into
	 * the filesystem, since we're only just about to mount
	 * it and have no inodes etc active!
	 */
1269
	sbi = kzalloc(sizeof(struct msdos_sb_info), GFP_KERNEL);
L
Linus Torvalds 已提交
1270 1271 1272 1273 1274 1275 1276 1277
	if (!sbi)
		return -ENOMEM;
	sb->s_fs_info = sbi;

	sb->s_flags |= MS_NODIRATIME;
	sb->s_magic = MSDOS_SUPER_MAGIC;
	sb->s_op = &fat_sops;
	sb->s_export_op = &fat_export_ops;
1278
	mutex_init(&sbi->nfs_build_inode_lock);
1279 1280
	ratelimit_state_init(&sbi->ratelimit, DEFAULT_RATELIMIT_INTERVAL,
			     DEFAULT_RATELIMIT_BURST);
L
Linus Torvalds 已提交
1281

1282
	error = parse_options(sb, data, isvfat, silent, &debug, &sbi->options);
L
Linus Torvalds 已提交
1283 1284 1285
	if (error)
		goto out_fail;

1286 1287
	setup(sb); /* flavour-specific stuff that needs options */

L
Linus Torvalds 已提交
1288 1289 1290 1291
	error = -EIO;
	sb_min_blocksize(sb, 512);
	bh = sb_bread(sb, 0);
	if (bh == NULL) {
1292
		fat_msg(sb, KERN_ERR, "unable to read boot sector");
L
Linus Torvalds 已提交
1293 1294 1295 1296 1297 1298
		goto out_fail;
	}

	b = (struct fat_boot_sector *) bh->b_data;
	if (!b->reserved) {
		if (!silent)
1299
			fat_msg(sb, KERN_ERR, "bogus number of reserved sectors");
L
Linus Torvalds 已提交
1300 1301 1302 1303 1304
		brelse(bh);
		goto out_invalid;
	}
	if (!b->fats) {
		if (!silent)
1305
			fat_msg(sb, KERN_ERR, "bogus number of FAT structure");
L
Linus Torvalds 已提交
1306 1307 1308 1309 1310 1311 1312 1313 1314 1315
		brelse(bh);
		goto out_invalid;
	}

	/*
	 * Earlier we checked here that b->secs_track and b->head are nonzero,
	 * but it turns out valid FAT filesystems can have zero there.
	 */

	media = b->media;
1316
	if (!fat_valid_media(media)) {
L
Linus Torvalds 已提交
1317
		if (!silent)
1318
			fat_msg(sb, KERN_ERR, "invalid media value (0x%02x)",
L
Linus Torvalds 已提交
1319 1320 1321 1322
			       media);
		brelse(bh);
		goto out_invalid;
	}
1323
	logical_sector_size = get_unaligned_le16(&b->sector_size);
V
Vignesh Babu BM 已提交
1324
	if (!is_power_of_2(logical_sector_size)
L
Linus Torvalds 已提交
1325
	    || (logical_sector_size < 512)
1326
	    || (logical_sector_size > 4096)) {
L
Linus Torvalds 已提交
1327
		if (!silent)
1328
			fat_msg(sb, KERN_ERR, "bogus logical sector size %u",
L
Linus Torvalds 已提交
1329 1330 1331 1332 1333
			       logical_sector_size);
		brelse(bh);
		goto out_invalid;
	}
	sbi->sec_per_clus = b->sec_per_clus;
V
Vignesh Babu BM 已提交
1334
	if (!is_power_of_2(sbi->sec_per_clus)) {
L
Linus Torvalds 已提交
1335
		if (!silent)
1336
			fat_msg(sb, KERN_ERR, "bogus sectors per cluster %u",
L
Linus Torvalds 已提交
1337 1338 1339 1340 1341 1342
			       sbi->sec_per_clus);
		brelse(bh);
		goto out_invalid;
	}

	if (logical_sector_size < sb->s_blocksize) {
1343 1344
		fat_msg(sb, KERN_ERR, "logical sector size too small for device"
		       " (logical sector size = %u)", logical_sector_size);
L
Linus Torvalds 已提交
1345 1346 1347 1348 1349 1350 1351
		brelse(bh);
		goto out_fail;
	}
	if (logical_sector_size > sb->s_blocksize) {
		brelse(bh);

		if (!sb_set_blocksize(sb, logical_sector_size)) {
1352
			fat_msg(sb, KERN_ERR, "unable to set blocksize %u",
L
Linus Torvalds 已提交
1353 1354 1355 1356 1357
			       logical_sector_size);
			goto out_fail;
		}
		bh = sb_bread(sb, 0);
		if (bh == NULL) {
1358 1359
			fat_msg(sb, KERN_ERR, "unable to read boot sector"
			       " (logical sector size = %lu)",
L
Linus Torvalds 已提交
1360 1361 1362 1363 1364 1365
			       sb->s_blocksize);
			goto out_fail;
		}
		b = (struct fat_boot_sector *) bh->b_data;
	}

M
Marco Stornelli 已提交
1366
	mutex_init(&sbi->s_lock);
L
Linus Torvalds 已提交
1367 1368 1369 1370 1371 1372 1373 1374
	sbi->cluster_size = sb->s_blocksize * sbi->sec_per_clus;
	sbi->cluster_bits = ffs(sbi->cluster_size) - 1;
	sbi->fats = b->fats;
	sbi->fat_bits = 0;		/* Don't know yet */
	sbi->fat_start = le16_to_cpu(b->reserved);
	sbi->fat_length = le16_to_cpu(b->fat_length);
	sbi->root_cluster = 0;
	sbi->free_clusters = -1;	/* Don't know yet */
1375
	sbi->free_clus_valid = 0;
L
Linus Torvalds 已提交
1376
	sbi->prev_free = FAT_START_ENT;
1377
	sb->s_maxbytes = 0xffffffff;
L
Linus Torvalds 已提交
1378

1379
	if (!sbi->fat_length && b->fat32.length) {
L
Linus Torvalds 已提交
1380 1381 1382 1383 1384
		struct fat_boot_fsinfo *fsinfo;
		struct buffer_head *fsinfo_bh;

		/* Must be FAT32 */
		sbi->fat_bits = 32;
1385 1386
		sbi->fat_length = le32_to_cpu(b->fat32.length);
		sbi->root_cluster = le32_to_cpu(b->fat32.root_cluster);
L
Linus Torvalds 已提交
1387 1388

		/* MC - if info_sector is 0, don't multiply by 0 */
1389
		sbi->fsinfo_sector = le16_to_cpu(b->fat32.info_sector);
L
Linus Torvalds 已提交
1390 1391 1392 1393 1394
		if (sbi->fsinfo_sector == 0)
			sbi->fsinfo_sector = 1;

		fsinfo_bh = sb_bread(sb, sbi->fsinfo_sector);
		if (fsinfo_bh == NULL) {
1395 1396
			fat_msg(sb, KERN_ERR, "bread failed, FSINFO block"
			       " (sector = %lu)", sbi->fsinfo_sector);
L
Linus Torvalds 已提交
1397 1398 1399 1400 1401 1402
			brelse(bh);
			goto out_fail;
		}

		fsinfo = (struct fat_boot_fsinfo *)fsinfo_bh->b_data;
		if (!IS_FSINFO(fsinfo)) {
1403 1404
			fat_msg(sb, KERN_WARNING, "Invalid FSINFO signature: "
			       "0x%08x, 0x%08x (sector = %lu)",
L
Linus Torvalds 已提交
1405 1406 1407 1408
			       le32_to_cpu(fsinfo->signature1),
			       le32_to_cpu(fsinfo->signature2),
			       sbi->fsinfo_sector);
		} else {
1409
			if (sbi->options.usefree)
1410 1411
				sbi->free_clus_valid = 1;
			sbi->free_clusters = le32_to_cpu(fsinfo->free_clusters);
L
Linus Torvalds 已提交
1412 1413 1414 1415 1416 1417
			sbi->prev_free = le32_to_cpu(fsinfo->next_cluster);
		}

		brelse(fsinfo_bh);
	}

1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429
	/* interpret volume ID as a little endian 32 bit integer */
	if (sbi->fat_bits == 32)
		sbi->vol_id = (((u32)b->fat32.vol_id[0]) |
					((u32)b->fat32.vol_id[1] << 8) |
					((u32)b->fat32.vol_id[2] << 16) |
					((u32)b->fat32.vol_id[3] << 24));
	else /* fat 16 or 12 */
		sbi->vol_id = (((u32)b->fat16.vol_id[0]) |
					((u32)b->fat16.vol_id[1] << 8) |
					((u32)b->fat16.vol_id[2] << 16) |
					((u32)b->fat16.vol_id[3] << 24));

L
Linus Torvalds 已提交
1430 1431 1432 1433
	sbi->dir_per_block = sb->s_blocksize / sizeof(struct msdos_dir_entry);
	sbi->dir_per_block_bits = ffs(sbi->dir_per_block) - 1;

	sbi->dir_start = sbi->fat_start + sbi->fats * sbi->fat_length;
1434
	sbi->dir_entries = get_unaligned_le16(&b->dir_entries);
L
Linus Torvalds 已提交
1435 1436
	if (sbi->dir_entries & (sbi->dir_per_block - 1)) {
		if (!silent)
1437
			fat_msg(sb, KERN_ERR, "bogus directory-entries per block"
1438
			       " (%u)", sbi->dir_entries);
L
Linus Torvalds 已提交
1439 1440 1441 1442 1443 1444 1445
		brelse(bh);
		goto out_invalid;
	}

	rootdir_sectors = sbi->dir_entries
		* sizeof(struct msdos_dir_entry) / sb->s_blocksize;
	sbi->data_start = sbi->dir_start + rootdir_sectors;
1446
	total_sectors = get_unaligned_le16(&b->sectors);
L
Linus Torvalds 已提交
1447 1448 1449 1450 1451 1452 1453 1454
	if (total_sectors == 0)
		total_sectors = le32_to_cpu(b->total_sect);

	total_clusters = (total_sectors - sbi->data_start) / sbi->sec_per_clus;

	if (sbi->fat_bits != 32)
		sbi->fat_bits = (total_clusters > MAX_FAT12) ? 16 : 12;

1455 1456 1457 1458 1459 1460
	/* some OSes set FAT_STATE_DIRTY and clean it on unmount. */
	if (sbi->fat_bits == 32)
		sbi->dirty = b->fat32.state & FAT_STATE_DIRTY;
	else /* fat 16 or 12 */
		sbi->dirty = b->fat16.state & FAT_STATE_DIRTY;

L
Linus Torvalds 已提交
1461
	/* check that FAT table does not overflow */
1462
	fat_clusters = calc_fat_clusters(sb);
L
Linus Torvalds 已提交
1463 1464 1465
	total_clusters = min(total_clusters, fat_clusters - FAT_START_ENT);
	if (total_clusters > MAX_FAT(sb)) {
		if (!silent)
1466
			fat_msg(sb, KERN_ERR, "count of clusters too big (%u)",
L
Linus Torvalds 已提交
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484
			       total_clusters);
		brelse(bh);
		goto out_invalid;
	}

	sbi->max_cluster = total_clusters + FAT_START_ENT;
	/* check the free_clusters, it's not necessarily correct */
	if (sbi->free_clusters != -1 && sbi->free_clusters > total_clusters)
		sbi->free_clusters = -1;
	/* check the prev_free, it's not necessarily correct */
	sbi->prev_free %= sbi->max_cluster;
	if (sbi->prev_free < FAT_START_ENT)
		sbi->prev_free = FAT_START_ENT;

	brelse(bh);

	/* set up enough so that it can read an inode */
	fat_hash_init(sb);
1485
	dir_hash_init(sb);
L
Linus Torvalds 已提交
1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499
	fat_ent_access_init(sb);

	/*
	 * The low byte of FAT's first entry must have same value with
	 * media-field.  But in real world, too many devices is
	 * writing wrong value.  So, removed that validity check.
	 *
	 * if (FAT_FIRST_ENT(sb, media) != first)
	 */

	error = -EINVAL;
	sprintf(buf, "cp%d", sbi->options.codepage);
	sbi->nls_disk = load_nls(buf);
	if (!sbi->nls_disk) {
1500
		fat_msg(sb, KERN_ERR, "codepage %s not found", buf);
L
Linus Torvalds 已提交
1501 1502 1503 1504 1505 1506 1507
		goto out_fail;
	}

	/* FIXME: utf8 is using iocharset for upper/lower conversion */
	if (sbi->options.isvfat) {
		sbi->nls_io = load_nls(sbi->options.iocharset);
		if (!sbi->nls_io) {
1508
			fat_msg(sb, KERN_ERR, "IO charset %s not found",
L
Linus Torvalds 已提交
1509 1510 1511 1512 1513 1514
			       sbi->options.iocharset);
			goto out_fail;
		}
	}

	error = -ENOMEM;
A
Al Viro 已提交
1515 1516 1517 1518 1519
	fat_inode = new_inode(sb);
	if (!fat_inode)
		goto out_fail;
	MSDOS_I(fat_inode)->i_pos = 0;
	sbi->fat_inode = fat_inode;
1520 1521 1522 1523 1524 1525 1526 1527

	fsinfo_inode = new_inode(sb);
	if (!fsinfo_inode)
		goto out_fail;
	fsinfo_inode->i_ino = MSDOS_FSINFO_INO;
	sbi->fsinfo_inode = fsinfo_inode;
	insert_inode_hash(fsinfo_inode);

L
Linus Torvalds 已提交
1528 1529 1530 1531 1532 1533
	root_inode = new_inode(sb);
	if (!root_inode)
		goto out_fail;
	root_inode->i_ino = MSDOS_ROOT_INO;
	root_inode->i_version = 1;
	error = fat_read_root(root_inode);
A
Al Viro 已提交
1534 1535
	if (error < 0) {
		iput(root_inode);
L
Linus Torvalds 已提交
1536
		goto out_fail;
A
Al Viro 已提交
1537
	}
L
Linus Torvalds 已提交
1538 1539
	error = -ENOMEM;
	insert_inode_hash(root_inode);
1540
	fat_attach(root_inode, 0);
A
Al Viro 已提交
1541
	sb->s_root = d_make_root(root_inode);
L
Linus Torvalds 已提交
1542
	if (!sb->s_root) {
1543
		fat_msg(sb, KERN_ERR, "get root inode failed");
L
Linus Torvalds 已提交
1544 1545 1546
		goto out_fail;
	}

1547 1548 1549 1550 1551 1552 1553 1554
	if (sbi->options.discard) {
		struct request_queue *q = bdev_get_queue(sb->s_bdev);
		if (!blk_queue_discard(q))
			fat_msg(sb, KERN_WARNING,
					"mounting with \"discard\" option, but "
					"the device does not support discard");
	}

1555
	fat_set_state(sb, 1, 0);
L
Linus Torvalds 已提交
1556 1557 1558 1559 1560
	return 0;

out_invalid:
	error = -EINVAL;
	if (!silent)
1561
		fat_msg(sb, KERN_INFO, "Can't find a valid FAT filesystem");
L
Linus Torvalds 已提交
1562 1563

out_fail:
1564 1565
	if (fsinfo_inode)
		iput(fsinfo_inode);
A
Al Viro 已提交
1566 1567
	if (fat_inode)
		iput(fat_inode);
O
OGAWA Hirofumi 已提交
1568 1569
	unload_nls(sbi->nls_io);
	unload_nls(sbi->nls_disk);
L
Linus Torvalds 已提交
1570 1571 1572 1573 1574 1575 1576
	if (sbi->options.iocharset != fat_default_iocharset)
		kfree(sbi->options.iocharset);
	sb->s_fs_info = NULL;
	kfree(sbi);
	return error;
}

1577
EXPORT_SYMBOL_GPL(fat_fill_super);
L
Linus Torvalds 已提交
1578

C
Chris Mason 已提交
1579 1580 1581 1582 1583 1584 1585 1586 1587 1588
/*
 * helper function for fat_flush_inodes.  This writes both the inode
 * and the file data blocks, waiting for in flight data blocks before
 * the start of the call.  It does not wait for any io started
 * during the call
 */
static int writeback_inode(struct inode *inode)
{

	int ret;
N
Namjae Jeon 已提交
1589 1590 1591

	/* if we used wait=1, sync_inode_metadata waits for the io for the
	* inode to finish.  So wait=0 is sent down to sync_inode_metadata
C
Chris Mason 已提交
1592 1593
	* and filemap_fdatawrite is used for the data blocks
	*/
N
Namjae Jeon 已提交
1594
	ret = sync_inode_metadata(inode, 0);
C
Chris Mason 已提交
1595
	if (!ret)
N
Namjae Jeon 已提交
1596
		ret = filemap_fdatawrite(inode->i_mapping);
C
Chris Mason 已提交
1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616
	return ret;
}

/*
 * write data and metadata corresponding to i1 and i2.  The io is
 * started but we do not wait for any of it to finish.
 *
 * filemap_flush is used for the block device, so if there is a dirty
 * page for a block already in flight, we will not wait and start the
 * io over again
 */
int fat_flush_inodes(struct super_block *sb, struct inode *i1, struct inode *i2)
{
	int ret = 0;
	if (!MSDOS_SB(sb)->options.flush)
		return 0;
	if (i1)
		ret = writeback_inode(i1);
	if (!ret && i2)
		ret = writeback_inode(i2);
1617
	if (!ret) {
C
Chris Mason 已提交
1618 1619 1620 1621 1622 1623 1624
		struct address_space *mapping = sb->s_bdev->bd_inode->i_mapping;
		ret = filemap_flush(mapping);
	}
	return ret;
}
EXPORT_SYMBOL_GPL(fat_flush_inodes);

L
Linus Torvalds 已提交
1625 1626
static int __init init_fat_fs(void)
{
1627
	int err;
L
Linus Torvalds 已提交
1628

1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641
	err = fat_cache_init();
	if (err)
		return err;

	err = fat_init_inodecache();
	if (err)
		goto failed;

	return 0;

failed:
	fat_cache_destroy();
	return err;
L
Linus Torvalds 已提交
1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653
}

static void __exit exit_fat_fs(void)
{
	fat_cache_destroy();
	fat_destroy_inodecache();
}

module_init(init_fat_fs)
module_exit(exit_fat_fs)

MODULE_LICENSE("GPL");