xref: /openbmc/linux/fs/fat/inode.c (revision a6cbcd4a4a85e2fdb0b3344b88df2e8b3d526b9e)
1 /*
2  *  linux/fs/fat/inode.c
3  *
4  *  Written 1992,1993 by Werner Almesberger
5  *  VFAT extensions by Gordon Chaffee, merged with msdos fs by Henrik Storner
6  *  Rewritten for the constant inumbers support by Al Viro
7  *
8  *  Fixes:
9  *
10  *	Max Cohan: Fixed invalid FSINFO offset when info_sector is 0
11  */
12 
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/time.h>
16 #include <linux/slab.h>
17 #include <linux/seq_file.h>
18 #include <linux/pagemap.h>
19 #include <linux/mpage.h>
20 #include <linux/buffer_head.h>
21 #include <linux/mount.h>
22 #include <linux/aio.h>
23 #include <linux/vfs.h>
24 #include <linux/parser.h>
25 #include <linux/uio.h>
26 #include <linux/writeback.h>
27 #include <linux/log2.h>
28 #include <linux/hash.h>
29 #include <linux/blkdev.h>
30 #include <asm/unaligned.h>
31 #include "fat.h"
32 
33 #ifndef CONFIG_FAT_DEFAULT_IOCHARSET
34 /* if user don't select VFAT, this is undefined. */
35 #define CONFIG_FAT_DEFAULT_IOCHARSET	""
36 #endif
37 
38 static int fat_default_codepage = CONFIG_FAT_DEFAULT_CODEPAGE;
39 static char fat_default_iocharset[] = CONFIG_FAT_DEFAULT_IOCHARSET;
40 
41 
42 static int fat_add_cluster(struct inode *inode)
43 {
44 	int err, cluster;
45 
46 	err = fat_alloc_clusters(inode, &cluster, 1);
47 	if (err)
48 		return err;
49 	/* FIXME: this cluster should be added after data of this
50 	 * cluster is writed */
51 	err = fat_chain_add(inode, cluster, 1);
52 	if (err)
53 		fat_free_clusters(inode, cluster);
54 	return err;
55 }
56 
57 static inline int __fat_get_block(struct inode *inode, sector_t iblock,
58 				  unsigned long *max_blocks,
59 				  struct buffer_head *bh_result, int create)
60 {
61 	struct super_block *sb = inode->i_sb;
62 	struct msdos_sb_info *sbi = MSDOS_SB(sb);
63 	unsigned long mapped_blocks;
64 	sector_t phys;
65 	int err, offset;
66 
67 	err = fat_bmap(inode, iblock, &phys, &mapped_blocks, create);
68 	if (err)
69 		return err;
70 	if (phys) {
71 		map_bh(bh_result, sb, phys);
72 		*max_blocks = min(mapped_blocks, *max_blocks);
73 		return 0;
74 	}
75 	if (!create)
76 		return 0;
77 
78 	if (iblock != MSDOS_I(inode)->mmu_private >> sb->s_blocksize_bits) {
79 		fat_fs_error(sb, "corrupted file size (i_pos %lld, %lld)",
80 			MSDOS_I(inode)->i_pos, MSDOS_I(inode)->mmu_private);
81 		return -EIO;
82 	}
83 
84 	offset = (unsigned long)iblock & (sbi->sec_per_clus - 1);
85 	if (!offset) {
86 		/* TODO: multiple cluster allocation would be desirable. */
87 		err = fat_add_cluster(inode);
88 		if (err)
89 			return err;
90 	}
91 	/* available blocks on this cluster */
92 	mapped_blocks = sbi->sec_per_clus - offset;
93 
94 	*max_blocks = min(mapped_blocks, *max_blocks);
95 	MSDOS_I(inode)->mmu_private += *max_blocks << sb->s_blocksize_bits;
96 
97 	err = fat_bmap(inode, iblock, &phys, &mapped_blocks, create);
98 	if (err)
99 		return err;
100 
101 	BUG_ON(!phys);
102 	BUG_ON(*max_blocks != mapped_blocks);
103 	set_buffer_new(bh_result);
104 	map_bh(bh_result, sb, phys);
105 
106 	return 0;
107 }
108 
109 static int fat_get_block(struct inode *inode, sector_t iblock,
110 			 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 	if (err)
118 		return err;
119 	bh_result->b_size = max_blocks << sb->s_blocksize_bits;
120 	return 0;
121 }
122 
123 static int fat_writepage(struct page *page, struct writeback_control *wbc)
124 {
125 	return block_write_full_page(page, fat_get_block, wbc);
126 }
127 
128 static int fat_writepages(struct address_space *mapping,
129 			  struct writeback_control *wbc)
130 {
131 	return mpage_writepages(mapping, wbc, fat_get_block);
132 }
133 
134 static int fat_readpage(struct file *file, struct page *page)
135 {
136 	return mpage_readpage(page, fat_get_block);
137 }
138 
139 static int fat_readpages(struct file *file, struct address_space *mapping,
140 			 struct list_head *pages, unsigned nr_pages)
141 {
142 	return mpage_readpages(mapping, pages, nr_pages, fat_get_block);
143 }
144 
145 static void fat_write_failed(struct address_space *mapping, loff_t to)
146 {
147 	struct inode *inode = mapping->host;
148 
149 	if (to > inode->i_size) {
150 		truncate_pagecache(inode, inode->i_size);
151 		fat_truncate_blocks(inode, inode->i_size);
152 	}
153 }
154 
155 static int fat_write_begin(struct file *file, struct address_space *mapping,
156 			loff_t pos, unsigned len, unsigned flags,
157 			struct page **pagep, void **fsdata)
158 {
159 	int err;
160 
161 	*pagep = NULL;
162 	err = cont_write_begin(file, mapping, pos, len, flags,
163 				pagep, fsdata, fat_get_block,
164 				&MSDOS_I(mapping->host)->mmu_private);
165 	if (err < 0)
166 		fat_write_failed(mapping, pos + len);
167 	return err;
168 }
169 
170 static int fat_write_end(struct file *file, struct address_space *mapping,
171 			loff_t pos, unsigned len, unsigned copied,
172 			struct page *pagep, void *fsdata)
173 {
174 	struct inode *inode = mapping->host;
175 	int err;
176 	err = generic_write_end(file, mapping, pos, len, copied, pagep, fsdata);
177 	if (err < len)
178 		fat_write_failed(mapping, pos + len);
179 	if (!(err < 0) && !(MSDOS_I(inode)->i_attrs & ATTR_ARCH)) {
180 		inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
181 		MSDOS_I(inode)->i_attrs |= ATTR_ARCH;
182 		mark_inode_dirty(inode);
183 	}
184 	return err;
185 }
186 
187 static ssize_t fat_direct_IO(int rw, struct kiocb *iocb,
188 			     struct iov_iter *iter,
189 			     loff_t offset)
190 {
191 	struct file *file = iocb->ki_filp;
192 	struct address_space *mapping = file->f_mapping;
193 	struct inode *inode = mapping->host;
194 	size_t count = iov_iter_count(iter);
195 	ssize_t ret;
196 
197 	if (rw == WRITE) {
198 		/*
199 		 * FIXME: blockdev_direct_IO() doesn't use ->write_begin(),
200 		 * so we need to update the ->mmu_private to block boundary.
201 		 *
202 		 * But we must fill the remaining area or hole by nul for
203 		 * updating ->mmu_private.
204 		 *
205 		 * Return 0, and fallback to normal buffered write.
206 		 */
207 		loff_t size = offset + count;
208 		if (MSDOS_I(inode)->mmu_private < size)
209 			return 0;
210 	}
211 
212 	/*
213 	 * FAT need to use the DIO_LOCKING for avoiding the race
214 	 * condition of fat_get_block() and ->truncate().
215 	 */
216 	ret = blockdev_direct_IO(rw, iocb, inode, iter->iov, offset,
217 				 iter->nr_segs, fat_get_block);
218 	if (ret < 0 && (rw & WRITE))
219 		fat_write_failed(mapping, offset + count);
220 
221 	return ret;
222 }
223 
224 static sector_t _fat_bmap(struct address_space *mapping, sector_t block)
225 {
226 	sector_t blocknr;
227 
228 	/* fat_get_cluster() assumes the requested blocknr isn't truncated. */
229 	down_read(&MSDOS_I(mapping->host)->truncate_lock);
230 	blocknr = generic_block_bmap(mapping, block, fat_get_block);
231 	up_read(&MSDOS_I(mapping->host)->truncate_lock);
232 
233 	return blocknr;
234 }
235 
236 static const struct address_space_operations fat_aops = {
237 	.readpage	= fat_readpage,
238 	.readpages	= fat_readpages,
239 	.writepage	= fat_writepage,
240 	.writepages	= fat_writepages,
241 	.write_begin	= fat_write_begin,
242 	.write_end	= fat_write_end,
243 	.direct_IO	= fat_direct_IO,
244 	.bmap		= _fat_bmap
245 };
246 
247 /*
248  * New FAT inode stuff. We do the following:
249  *	a) i_ino is constant and has nothing with on-disk location.
250  *	b) FAT manages its own cache of directory entries.
251  *	c) *This* cache is indexed by on-disk location.
252  *	d) inode has an associated directory entry, all right, but
253  *		it may be unhashed.
254  *	e) currently entries are stored within struct inode. That should
255  *		change.
256  *	f) we deal with races in the following way:
257  *		1. readdir() and lookup() do FAT-dir-cache lookup.
258  *		2. rename() unhashes the F-d-c entry and rehashes it in
259  *			a new place.
260  *		3. unlink() and rmdir() unhash F-d-c entry.
261  *		4. fat_write_inode() checks whether the thing is unhashed.
262  *			If it is we silently return. If it isn't we do bread(),
263  *			check if the location is still valid and retry if it
264  *			isn't. Otherwise we do changes.
265  *		5. Spinlock is used to protect hash/unhash/location check/lookup
266  *		6. fat_evict_inode() unhashes the F-d-c entry.
267  *		7. lookup() and readdir() do igrab() if they find a F-d-c entry
268  *			and consider negative result as cache miss.
269  */
270 
271 static void fat_hash_init(struct super_block *sb)
272 {
273 	struct msdos_sb_info *sbi = MSDOS_SB(sb);
274 	int i;
275 
276 	spin_lock_init(&sbi->inode_hash_lock);
277 	for (i = 0; i < FAT_HASH_SIZE; i++)
278 		INIT_HLIST_HEAD(&sbi->inode_hashtable[i]);
279 }
280 
281 static inline unsigned long fat_hash(loff_t i_pos)
282 {
283 	return hash_32(i_pos, FAT_HASH_BITS);
284 }
285 
286 static void dir_hash_init(struct super_block *sb)
287 {
288 	struct msdos_sb_info *sbi = MSDOS_SB(sb);
289 	int i;
290 
291 	spin_lock_init(&sbi->dir_hash_lock);
292 	for (i = 0; i < FAT_HASH_SIZE; i++)
293 		INIT_HLIST_HEAD(&sbi->dir_hashtable[i]);
294 }
295 
296 void fat_attach(struct inode *inode, loff_t i_pos)
297 {
298 	struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
299 
300 	if (inode->i_ino != MSDOS_ROOT_INO) {
301 		struct hlist_head *head =   sbi->inode_hashtable
302 					  + fat_hash(i_pos);
303 
304 		spin_lock(&sbi->inode_hash_lock);
305 		MSDOS_I(inode)->i_pos = i_pos;
306 		hlist_add_head(&MSDOS_I(inode)->i_fat_hash, head);
307 		spin_unlock(&sbi->inode_hash_lock);
308 	}
309 
310 	/* If NFS support is enabled, cache the mapping of start cluster
311 	 * to directory inode. This is used during reconnection of
312 	 * dentries to the filesystem root.
313 	 */
314 	if (S_ISDIR(inode->i_mode) && sbi->options.nfs) {
315 		struct hlist_head *d_head = sbi->dir_hashtable;
316 		d_head += fat_dir_hash(MSDOS_I(inode)->i_logstart);
317 
318 		spin_lock(&sbi->dir_hash_lock);
319 		hlist_add_head(&MSDOS_I(inode)->i_dir_hash, d_head);
320 		spin_unlock(&sbi->dir_hash_lock);
321 	}
322 }
323 EXPORT_SYMBOL_GPL(fat_attach);
324 
325 void fat_detach(struct inode *inode)
326 {
327 	struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
328 	spin_lock(&sbi->inode_hash_lock);
329 	MSDOS_I(inode)->i_pos = 0;
330 	hlist_del_init(&MSDOS_I(inode)->i_fat_hash);
331 	spin_unlock(&sbi->inode_hash_lock);
332 
333 	if (S_ISDIR(inode->i_mode) && sbi->options.nfs) {
334 		spin_lock(&sbi->dir_hash_lock);
335 		hlist_del_init(&MSDOS_I(inode)->i_dir_hash);
336 		spin_unlock(&sbi->dir_hash_lock);
337 	}
338 }
339 EXPORT_SYMBOL_GPL(fat_detach);
340 
341 struct inode *fat_iget(struct super_block *sb, loff_t i_pos)
342 {
343 	struct msdos_sb_info *sbi = MSDOS_SB(sb);
344 	struct hlist_head *head = sbi->inode_hashtable + fat_hash(i_pos);
345 	struct msdos_inode_info *i;
346 	struct inode *inode = NULL;
347 
348 	spin_lock(&sbi->inode_hash_lock);
349 	hlist_for_each_entry(i, head, i_fat_hash) {
350 		BUG_ON(i->vfs_inode.i_sb != sb);
351 		if (i->i_pos != i_pos)
352 			continue;
353 		inode = igrab(&i->vfs_inode);
354 		if (inode)
355 			break;
356 	}
357 	spin_unlock(&sbi->inode_hash_lock);
358 	return inode;
359 }
360 
361 static int is_exec(unsigned char *extension)
362 {
363 	unsigned char *exe_extensions = "EXECOMBAT", *walk;
364 
365 	for (walk = exe_extensions; *walk; walk += 3)
366 		if (!strncmp(extension, walk, 3))
367 			return 1;
368 	return 0;
369 }
370 
371 static int fat_calc_dir_size(struct inode *inode)
372 {
373 	struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
374 	int ret, fclus, dclus;
375 
376 	inode->i_size = 0;
377 	if (MSDOS_I(inode)->i_start == 0)
378 		return 0;
379 
380 	ret = fat_get_cluster(inode, FAT_ENT_EOF, &fclus, &dclus);
381 	if (ret < 0)
382 		return ret;
383 	inode->i_size = (fclus + 1) << sbi->cluster_bits;
384 
385 	return 0;
386 }
387 
388 /* doesn't deal with root inode */
389 int fat_fill_inode(struct inode *inode, struct msdos_dir_entry *de)
390 {
391 	struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
392 	int error;
393 
394 	MSDOS_I(inode)->i_pos = 0;
395 	inode->i_uid = sbi->options.fs_uid;
396 	inode->i_gid = sbi->options.fs_gid;
397 	inode->i_version++;
398 	inode->i_generation = get_seconds();
399 
400 	if ((de->attr & ATTR_DIR) && !IS_FREE(de->name)) {
401 		inode->i_generation &= ~1;
402 		inode->i_mode = fat_make_mode(sbi, de->attr, S_IRWXUGO);
403 		inode->i_op = sbi->dir_ops;
404 		inode->i_fop = &fat_dir_operations;
405 
406 		MSDOS_I(inode)->i_start = fat_get_start(sbi, de);
407 		MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start;
408 		error = fat_calc_dir_size(inode);
409 		if (error < 0)
410 			return error;
411 		MSDOS_I(inode)->mmu_private = inode->i_size;
412 
413 		set_nlink(inode, fat_subdirs(inode));
414 	} else { /* not a directory */
415 		inode->i_generation |= 1;
416 		inode->i_mode = fat_make_mode(sbi, de->attr,
417 			((sbi->options.showexec && !is_exec(de->name + 8))
418 			 ? S_IRUGO|S_IWUGO : S_IRWXUGO));
419 		MSDOS_I(inode)->i_start = fat_get_start(sbi, de);
420 
421 		MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start;
422 		inode->i_size = le32_to_cpu(de->size);
423 		inode->i_op = &fat_file_inode_operations;
424 		inode->i_fop = &fat_file_operations;
425 		inode->i_mapping->a_ops = &fat_aops;
426 		MSDOS_I(inode)->mmu_private = inode->i_size;
427 	}
428 	if (de->attr & ATTR_SYS) {
429 		if (sbi->options.sys_immutable)
430 			inode->i_flags |= S_IMMUTABLE;
431 	}
432 	fat_save_attrs(inode, de->attr);
433 
434 	inode->i_blocks = ((inode->i_size + (sbi->cluster_size - 1))
435 			   & ~((loff_t)sbi->cluster_size - 1)) >> 9;
436 
437 	fat_time_fat2unix(sbi, &inode->i_mtime, de->time, de->date, 0);
438 	if (sbi->options.isvfat) {
439 		fat_time_fat2unix(sbi, &inode->i_ctime, de->ctime,
440 				  de->cdate, de->ctime_cs);
441 		fat_time_fat2unix(sbi, &inode->i_atime, 0, de->adate, 0);
442 	} else
443 		inode->i_ctime = inode->i_atime = inode->i_mtime;
444 
445 	return 0;
446 }
447 
448 static inline void fat_lock_build_inode(struct msdos_sb_info *sbi)
449 {
450 	if (sbi->options.nfs == FAT_NFS_NOSTALE_RO)
451 		mutex_lock(&sbi->nfs_build_inode_lock);
452 }
453 
454 static inline void fat_unlock_build_inode(struct msdos_sb_info *sbi)
455 {
456 	if (sbi->options.nfs == FAT_NFS_NOSTALE_RO)
457 		mutex_unlock(&sbi->nfs_build_inode_lock);
458 }
459 
460 struct inode *fat_build_inode(struct super_block *sb,
461 			struct msdos_dir_entry *de, loff_t i_pos)
462 {
463 	struct inode *inode;
464 	int err;
465 
466 	fat_lock_build_inode(MSDOS_SB(sb));
467 	inode = fat_iget(sb, i_pos);
468 	if (inode)
469 		goto out;
470 	inode = new_inode(sb);
471 	if (!inode) {
472 		inode = ERR_PTR(-ENOMEM);
473 		goto out;
474 	}
475 	inode->i_ino = iunique(sb, MSDOS_ROOT_INO);
476 	inode->i_version = 1;
477 	err = fat_fill_inode(inode, de);
478 	if (err) {
479 		iput(inode);
480 		inode = ERR_PTR(err);
481 		goto out;
482 	}
483 	fat_attach(inode, i_pos);
484 	insert_inode_hash(inode);
485 out:
486 	fat_unlock_build_inode(MSDOS_SB(sb));
487 	return inode;
488 }
489 
490 EXPORT_SYMBOL_GPL(fat_build_inode);
491 
492 static void fat_evict_inode(struct inode *inode)
493 {
494 	truncate_inode_pages_final(&inode->i_data);
495 	if (!inode->i_nlink) {
496 		inode->i_size = 0;
497 		fat_truncate_blocks(inode, 0);
498 	}
499 	invalidate_inode_buffers(inode);
500 	clear_inode(inode);
501 	fat_cache_inval_inode(inode);
502 	fat_detach(inode);
503 }
504 
505 static void fat_set_state(struct super_block *sb,
506 			unsigned int set, unsigned int force)
507 {
508 	struct buffer_head *bh;
509 	struct fat_boot_sector *b;
510 	struct msdos_sb_info *sbi = sb->s_fs_info;
511 
512 	/* do not change any thing if mounted read only */
513 	if ((sb->s_flags & MS_RDONLY) && !force)
514 		return;
515 
516 	/* do not change state if fs was dirty */
517 	if (sbi->dirty) {
518 		/* warn only on set (mount). */
519 		if (set)
520 			fat_msg(sb, KERN_WARNING, "Volume was not properly "
521 				"unmounted. Some data may be corrupt. "
522 				"Please run fsck.");
523 		return;
524 	}
525 
526 	bh = sb_bread(sb, 0);
527 	if (bh == NULL) {
528 		fat_msg(sb, KERN_ERR, "unable to read boot sector "
529 			"to mark fs as dirty");
530 		return;
531 	}
532 
533 	b = (struct fat_boot_sector *) bh->b_data;
534 
535 	if (sbi->fat_bits == 32) {
536 		if (set)
537 			b->fat32.state |= FAT_STATE_DIRTY;
538 		else
539 			b->fat32.state &= ~FAT_STATE_DIRTY;
540 	} else /* fat 16 and 12 */ {
541 		if (set)
542 			b->fat16.state |= FAT_STATE_DIRTY;
543 		else
544 			b->fat16.state &= ~FAT_STATE_DIRTY;
545 	}
546 
547 	mark_buffer_dirty(bh);
548 	sync_dirty_buffer(bh);
549 	brelse(bh);
550 }
551 
552 static void delayed_free(struct rcu_head *p)
553 {
554 	struct msdos_sb_info *sbi = container_of(p, struct msdos_sb_info, rcu);
555 	unload_nls(sbi->nls_disk);
556 	unload_nls(sbi->nls_io);
557 	if (sbi->options.iocharset != fat_default_iocharset)
558 		kfree(sbi->options.iocharset);
559 	kfree(sbi);
560 }
561 
562 static void fat_put_super(struct super_block *sb)
563 {
564 	struct msdos_sb_info *sbi = MSDOS_SB(sb);
565 
566 	fat_set_state(sb, 0, 0);
567 
568 	iput(sbi->fsinfo_inode);
569 	iput(sbi->fat_inode);
570 
571 	call_rcu(&sbi->rcu, delayed_free);
572 }
573 
574 static struct kmem_cache *fat_inode_cachep;
575 
576 static struct inode *fat_alloc_inode(struct super_block *sb)
577 {
578 	struct msdos_inode_info *ei;
579 	ei = kmem_cache_alloc(fat_inode_cachep, GFP_NOFS);
580 	if (!ei)
581 		return NULL;
582 
583 	init_rwsem(&ei->truncate_lock);
584 	return &ei->vfs_inode;
585 }
586 
587 static void fat_i_callback(struct rcu_head *head)
588 {
589 	struct inode *inode = container_of(head, struct inode, i_rcu);
590 	kmem_cache_free(fat_inode_cachep, MSDOS_I(inode));
591 }
592 
593 static void fat_destroy_inode(struct inode *inode)
594 {
595 	call_rcu(&inode->i_rcu, fat_i_callback);
596 }
597 
598 static void init_once(void *foo)
599 {
600 	struct msdos_inode_info *ei = (struct msdos_inode_info *)foo;
601 
602 	spin_lock_init(&ei->cache_lru_lock);
603 	ei->nr_caches = 0;
604 	ei->cache_valid_id = FAT_CACHE_VALID + 1;
605 	INIT_LIST_HEAD(&ei->cache_lru);
606 	INIT_HLIST_NODE(&ei->i_fat_hash);
607 	INIT_HLIST_NODE(&ei->i_dir_hash);
608 	inode_init_once(&ei->vfs_inode);
609 }
610 
611 static int __init fat_init_inodecache(void)
612 {
613 	fat_inode_cachep = kmem_cache_create("fat_inode_cache",
614 					     sizeof(struct msdos_inode_info),
615 					     0, (SLAB_RECLAIM_ACCOUNT|
616 						SLAB_MEM_SPREAD),
617 					     init_once);
618 	if (fat_inode_cachep == NULL)
619 		return -ENOMEM;
620 	return 0;
621 }
622 
623 static void __exit fat_destroy_inodecache(void)
624 {
625 	/*
626 	 * Make sure all delayed rcu free inodes are flushed before we
627 	 * destroy cache.
628 	 */
629 	rcu_barrier();
630 	kmem_cache_destroy(fat_inode_cachep);
631 }
632 
633 static int fat_remount(struct super_block *sb, int *flags, char *data)
634 {
635 	int new_rdonly;
636 	struct msdos_sb_info *sbi = MSDOS_SB(sb);
637 	*flags |= MS_NODIRATIME | (sbi->options.isvfat ? 0 : MS_NOATIME);
638 
639 	sync_filesystem(sb);
640 
641 	/* make sure we update state on remount. */
642 	new_rdonly = *flags & MS_RDONLY;
643 	if (new_rdonly != (sb->s_flags & MS_RDONLY)) {
644 		if (new_rdonly)
645 			fat_set_state(sb, 0, 0);
646 		else
647 			fat_set_state(sb, 1, 1);
648 	}
649 	return 0;
650 }
651 
652 static int fat_statfs(struct dentry *dentry, struct kstatfs *buf)
653 {
654 	struct super_block *sb = dentry->d_sb;
655 	struct msdos_sb_info *sbi = MSDOS_SB(sb);
656 	u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
657 
658 	/* If the count of free cluster is still unknown, counts it here. */
659 	if (sbi->free_clusters == -1 || !sbi->free_clus_valid) {
660 		int err = fat_count_free_clusters(dentry->d_sb);
661 		if (err)
662 			return err;
663 	}
664 
665 	buf->f_type = dentry->d_sb->s_magic;
666 	buf->f_bsize = sbi->cluster_size;
667 	buf->f_blocks = sbi->max_cluster - FAT_START_ENT;
668 	buf->f_bfree = sbi->free_clusters;
669 	buf->f_bavail = sbi->free_clusters;
670 	buf->f_fsid.val[0] = (u32)id;
671 	buf->f_fsid.val[1] = (u32)(id >> 32);
672 	buf->f_namelen =
673 		(sbi->options.isvfat ? FAT_LFN_LEN : 12) * NLS_MAX_CHARSET_SIZE;
674 
675 	return 0;
676 }
677 
678 static int __fat_write_inode(struct inode *inode, int wait)
679 {
680 	struct super_block *sb = inode->i_sb;
681 	struct msdos_sb_info *sbi = MSDOS_SB(sb);
682 	struct buffer_head *bh;
683 	struct msdos_dir_entry *raw_entry;
684 	loff_t i_pos;
685 	sector_t blocknr;
686 	int err, offset;
687 
688 	if (inode->i_ino == MSDOS_ROOT_INO)
689 		return 0;
690 
691 retry:
692 	i_pos = fat_i_pos_read(sbi, inode);
693 	if (!i_pos)
694 		return 0;
695 
696 	fat_get_blknr_offset(sbi, i_pos, &blocknr, &offset);
697 	bh = sb_bread(sb, blocknr);
698 	if (!bh) {
699 		fat_msg(sb, KERN_ERR, "unable to read inode block "
700 		       "for updating (i_pos %lld)", i_pos);
701 		return -EIO;
702 	}
703 	spin_lock(&sbi->inode_hash_lock);
704 	if (i_pos != MSDOS_I(inode)->i_pos) {
705 		spin_unlock(&sbi->inode_hash_lock);
706 		brelse(bh);
707 		goto retry;
708 	}
709 
710 	raw_entry = &((struct msdos_dir_entry *) (bh->b_data))[offset];
711 	if (S_ISDIR(inode->i_mode))
712 		raw_entry->size = 0;
713 	else
714 		raw_entry->size = cpu_to_le32(inode->i_size);
715 	raw_entry->attr = fat_make_attrs(inode);
716 	fat_set_start(raw_entry, MSDOS_I(inode)->i_logstart);
717 	fat_time_unix2fat(sbi, &inode->i_mtime, &raw_entry->time,
718 			  &raw_entry->date, NULL);
719 	if (sbi->options.isvfat) {
720 		__le16 atime;
721 		fat_time_unix2fat(sbi, &inode->i_ctime, &raw_entry->ctime,
722 				  &raw_entry->cdate, &raw_entry->ctime_cs);
723 		fat_time_unix2fat(sbi, &inode->i_atime, &atime,
724 				  &raw_entry->adate, NULL);
725 	}
726 	spin_unlock(&sbi->inode_hash_lock);
727 	mark_buffer_dirty(bh);
728 	err = 0;
729 	if (wait)
730 		err = sync_dirty_buffer(bh);
731 	brelse(bh);
732 	return err;
733 }
734 
735 static int fat_write_inode(struct inode *inode, struct writeback_control *wbc)
736 {
737 	int err;
738 
739 	if (inode->i_ino == MSDOS_FSINFO_INO) {
740 		struct super_block *sb = inode->i_sb;
741 
742 		mutex_lock(&MSDOS_SB(sb)->s_lock);
743 		err = fat_clusters_flush(sb);
744 		mutex_unlock(&MSDOS_SB(sb)->s_lock);
745 	} else
746 		err = __fat_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
747 
748 	return err;
749 }
750 
751 int fat_sync_inode(struct inode *inode)
752 {
753 	return __fat_write_inode(inode, 1);
754 }
755 
756 EXPORT_SYMBOL_GPL(fat_sync_inode);
757 
758 static int fat_show_options(struct seq_file *m, struct dentry *root);
759 static const struct super_operations fat_sops = {
760 	.alloc_inode	= fat_alloc_inode,
761 	.destroy_inode	= fat_destroy_inode,
762 	.write_inode	= fat_write_inode,
763 	.evict_inode	= fat_evict_inode,
764 	.put_super	= fat_put_super,
765 	.statfs		= fat_statfs,
766 	.remount_fs	= fat_remount,
767 
768 	.show_options	= fat_show_options,
769 };
770 
771 static int fat_show_options(struct seq_file *m, struct dentry *root)
772 {
773 	struct msdos_sb_info *sbi = MSDOS_SB(root->d_sb);
774 	struct fat_mount_options *opts = &sbi->options;
775 	int isvfat = opts->isvfat;
776 
777 	if (!uid_eq(opts->fs_uid, GLOBAL_ROOT_UID))
778 		seq_printf(m, ",uid=%u",
779 				from_kuid_munged(&init_user_ns, opts->fs_uid));
780 	if (!gid_eq(opts->fs_gid, GLOBAL_ROOT_GID))
781 		seq_printf(m, ",gid=%u",
782 				from_kgid_munged(&init_user_ns, opts->fs_gid));
783 	seq_printf(m, ",fmask=%04o", opts->fs_fmask);
784 	seq_printf(m, ",dmask=%04o", opts->fs_dmask);
785 	if (opts->allow_utime)
786 		seq_printf(m, ",allow_utime=%04o", opts->allow_utime);
787 	if (sbi->nls_disk)
788 		/* strip "cp" prefix from displayed option */
789 		seq_printf(m, ",codepage=%s", &sbi->nls_disk->charset[2]);
790 	if (isvfat) {
791 		if (sbi->nls_io)
792 			seq_printf(m, ",iocharset=%s", sbi->nls_io->charset);
793 
794 		switch (opts->shortname) {
795 		case VFAT_SFN_DISPLAY_WIN95 | VFAT_SFN_CREATE_WIN95:
796 			seq_puts(m, ",shortname=win95");
797 			break;
798 		case VFAT_SFN_DISPLAY_WINNT | VFAT_SFN_CREATE_WINNT:
799 			seq_puts(m, ",shortname=winnt");
800 			break;
801 		case VFAT_SFN_DISPLAY_WINNT | VFAT_SFN_CREATE_WIN95:
802 			seq_puts(m, ",shortname=mixed");
803 			break;
804 		case VFAT_SFN_DISPLAY_LOWER | VFAT_SFN_CREATE_WIN95:
805 			seq_puts(m, ",shortname=lower");
806 			break;
807 		default:
808 			seq_puts(m, ",shortname=unknown");
809 			break;
810 		}
811 	}
812 	if (opts->name_check != 'n')
813 		seq_printf(m, ",check=%c", opts->name_check);
814 	if (opts->usefree)
815 		seq_puts(m, ",usefree");
816 	if (opts->quiet)
817 		seq_puts(m, ",quiet");
818 	if (opts->showexec)
819 		seq_puts(m, ",showexec");
820 	if (opts->sys_immutable)
821 		seq_puts(m, ",sys_immutable");
822 	if (!isvfat) {
823 		if (opts->dotsOK)
824 			seq_puts(m, ",dotsOK=yes");
825 		if (opts->nocase)
826 			seq_puts(m, ",nocase");
827 	} else {
828 		if (opts->utf8)
829 			seq_puts(m, ",utf8");
830 		if (opts->unicode_xlate)
831 			seq_puts(m, ",uni_xlate");
832 		if (!opts->numtail)
833 			seq_puts(m, ",nonumtail");
834 		if (opts->rodir)
835 			seq_puts(m, ",rodir");
836 	}
837 	if (opts->flush)
838 		seq_puts(m, ",flush");
839 	if (opts->tz_set) {
840 		if (opts->time_offset)
841 			seq_printf(m, ",time_offset=%d", opts->time_offset);
842 		else
843 			seq_puts(m, ",tz=UTC");
844 	}
845 	if (opts->errors == FAT_ERRORS_CONT)
846 		seq_puts(m, ",errors=continue");
847 	else if (opts->errors == FAT_ERRORS_PANIC)
848 		seq_puts(m, ",errors=panic");
849 	else
850 		seq_puts(m, ",errors=remount-ro");
851 	if (opts->nfs == FAT_NFS_NOSTALE_RO)
852 		seq_puts(m, ",nfs=nostale_ro");
853 	else if (opts->nfs)
854 		seq_puts(m, ",nfs=stale_rw");
855 	if (opts->discard)
856 		seq_puts(m, ",discard");
857 
858 	return 0;
859 }
860 
861 enum {
862 	Opt_check_n, Opt_check_r, Opt_check_s, Opt_uid, Opt_gid,
863 	Opt_umask, Opt_dmask, Opt_fmask, Opt_allow_utime, Opt_codepage,
864 	Opt_usefree, Opt_nocase, Opt_quiet, Opt_showexec, Opt_debug,
865 	Opt_immutable, Opt_dots, Opt_nodots,
866 	Opt_charset, Opt_shortname_lower, Opt_shortname_win95,
867 	Opt_shortname_winnt, Opt_shortname_mixed, Opt_utf8_no, Opt_utf8_yes,
868 	Opt_uni_xl_no, Opt_uni_xl_yes, Opt_nonumtail_no, Opt_nonumtail_yes,
869 	Opt_obsolete, Opt_flush, Opt_tz_utc, Opt_rodir, Opt_err_cont,
870 	Opt_err_panic, Opt_err_ro, Opt_discard, Opt_nfs, Opt_time_offset,
871 	Opt_nfs_stale_rw, Opt_nfs_nostale_ro, Opt_err,
872 };
873 
874 static const match_table_t fat_tokens = {
875 	{Opt_check_r, "check=relaxed"},
876 	{Opt_check_s, "check=strict"},
877 	{Opt_check_n, "check=normal"},
878 	{Opt_check_r, "check=r"},
879 	{Opt_check_s, "check=s"},
880 	{Opt_check_n, "check=n"},
881 	{Opt_uid, "uid=%u"},
882 	{Opt_gid, "gid=%u"},
883 	{Opt_umask, "umask=%o"},
884 	{Opt_dmask, "dmask=%o"},
885 	{Opt_fmask, "fmask=%o"},
886 	{Opt_allow_utime, "allow_utime=%o"},
887 	{Opt_codepage, "codepage=%u"},
888 	{Opt_usefree, "usefree"},
889 	{Opt_nocase, "nocase"},
890 	{Opt_quiet, "quiet"},
891 	{Opt_showexec, "showexec"},
892 	{Opt_debug, "debug"},
893 	{Opt_immutable, "sys_immutable"},
894 	{Opt_flush, "flush"},
895 	{Opt_tz_utc, "tz=UTC"},
896 	{Opt_time_offset, "time_offset=%d"},
897 	{Opt_err_cont, "errors=continue"},
898 	{Opt_err_panic, "errors=panic"},
899 	{Opt_err_ro, "errors=remount-ro"},
900 	{Opt_discard, "discard"},
901 	{Opt_nfs_stale_rw, "nfs"},
902 	{Opt_nfs_stale_rw, "nfs=stale_rw"},
903 	{Opt_nfs_nostale_ro, "nfs=nostale_ro"},
904 	{Opt_obsolete, "conv=binary"},
905 	{Opt_obsolete, "conv=text"},
906 	{Opt_obsolete, "conv=auto"},
907 	{Opt_obsolete, "conv=b"},
908 	{Opt_obsolete, "conv=t"},
909 	{Opt_obsolete, "conv=a"},
910 	{Opt_obsolete, "fat=%u"},
911 	{Opt_obsolete, "blocksize=%u"},
912 	{Opt_obsolete, "cvf_format=%20s"},
913 	{Opt_obsolete, "cvf_options=%100s"},
914 	{Opt_obsolete, "posix"},
915 	{Opt_err, NULL},
916 };
917 static const match_table_t msdos_tokens = {
918 	{Opt_nodots, "nodots"},
919 	{Opt_nodots, "dotsOK=no"},
920 	{Opt_dots, "dots"},
921 	{Opt_dots, "dotsOK=yes"},
922 	{Opt_err, NULL}
923 };
924 static const match_table_t vfat_tokens = {
925 	{Opt_charset, "iocharset=%s"},
926 	{Opt_shortname_lower, "shortname=lower"},
927 	{Opt_shortname_win95, "shortname=win95"},
928 	{Opt_shortname_winnt, "shortname=winnt"},
929 	{Opt_shortname_mixed, "shortname=mixed"},
930 	{Opt_utf8_no, "utf8=0"},		/* 0 or no or false */
931 	{Opt_utf8_no, "utf8=no"},
932 	{Opt_utf8_no, "utf8=false"},
933 	{Opt_utf8_yes, "utf8=1"},		/* empty or 1 or yes or true */
934 	{Opt_utf8_yes, "utf8=yes"},
935 	{Opt_utf8_yes, "utf8=true"},
936 	{Opt_utf8_yes, "utf8"},
937 	{Opt_uni_xl_no, "uni_xlate=0"},		/* 0 or no or false */
938 	{Opt_uni_xl_no, "uni_xlate=no"},
939 	{Opt_uni_xl_no, "uni_xlate=false"},
940 	{Opt_uni_xl_yes, "uni_xlate=1"},	/* empty or 1 or yes or true */
941 	{Opt_uni_xl_yes, "uni_xlate=yes"},
942 	{Opt_uni_xl_yes, "uni_xlate=true"},
943 	{Opt_uni_xl_yes, "uni_xlate"},
944 	{Opt_nonumtail_no, "nonumtail=0"},	/* 0 or no or false */
945 	{Opt_nonumtail_no, "nonumtail=no"},
946 	{Opt_nonumtail_no, "nonumtail=false"},
947 	{Opt_nonumtail_yes, "nonumtail=1"},	/* empty or 1 or yes or true */
948 	{Opt_nonumtail_yes, "nonumtail=yes"},
949 	{Opt_nonumtail_yes, "nonumtail=true"},
950 	{Opt_nonumtail_yes, "nonumtail"},
951 	{Opt_rodir, "rodir"},
952 	{Opt_err, NULL}
953 };
954 
955 static int parse_options(struct super_block *sb, char *options, int is_vfat,
956 			 int silent, int *debug, struct fat_mount_options *opts)
957 {
958 	char *p;
959 	substring_t args[MAX_OPT_ARGS];
960 	int option;
961 	char *iocharset;
962 
963 	opts->isvfat = is_vfat;
964 
965 	opts->fs_uid = current_uid();
966 	opts->fs_gid = current_gid();
967 	opts->fs_fmask = opts->fs_dmask = current_umask();
968 	opts->allow_utime = -1;
969 	opts->codepage = fat_default_codepage;
970 	opts->iocharset = fat_default_iocharset;
971 	if (is_vfat) {
972 		opts->shortname = VFAT_SFN_DISPLAY_WINNT|VFAT_SFN_CREATE_WIN95;
973 		opts->rodir = 0;
974 	} else {
975 		opts->shortname = 0;
976 		opts->rodir = 1;
977 	}
978 	opts->name_check = 'n';
979 	opts->quiet = opts->showexec = opts->sys_immutable = opts->dotsOK =  0;
980 	opts->utf8 = opts->unicode_xlate = 0;
981 	opts->numtail = 1;
982 	opts->usefree = opts->nocase = 0;
983 	opts->tz_set = 0;
984 	opts->nfs = 0;
985 	opts->errors = FAT_ERRORS_RO;
986 	*debug = 0;
987 
988 	if (!options)
989 		goto out;
990 
991 	while ((p = strsep(&options, ",")) != NULL) {
992 		int token;
993 		if (!*p)
994 			continue;
995 
996 		token = match_token(p, fat_tokens, args);
997 		if (token == Opt_err) {
998 			if (is_vfat)
999 				token = match_token(p, vfat_tokens, args);
1000 			else
1001 				token = match_token(p, msdos_tokens, args);
1002 		}
1003 		switch (token) {
1004 		case Opt_check_s:
1005 			opts->name_check = 's';
1006 			break;
1007 		case Opt_check_r:
1008 			opts->name_check = 'r';
1009 			break;
1010 		case Opt_check_n:
1011 			opts->name_check = 'n';
1012 			break;
1013 		case Opt_usefree:
1014 			opts->usefree = 1;
1015 			break;
1016 		case Opt_nocase:
1017 			if (!is_vfat)
1018 				opts->nocase = 1;
1019 			else {
1020 				/* for backward compatibility */
1021 				opts->shortname = VFAT_SFN_DISPLAY_WIN95
1022 					| VFAT_SFN_CREATE_WIN95;
1023 			}
1024 			break;
1025 		case Opt_quiet:
1026 			opts->quiet = 1;
1027 			break;
1028 		case Opt_showexec:
1029 			opts->showexec = 1;
1030 			break;
1031 		case Opt_debug:
1032 			*debug = 1;
1033 			break;
1034 		case Opt_immutable:
1035 			opts->sys_immutable = 1;
1036 			break;
1037 		case Opt_uid:
1038 			if (match_int(&args[0], &option))
1039 				return -EINVAL;
1040 			opts->fs_uid = make_kuid(current_user_ns(), option);
1041 			if (!uid_valid(opts->fs_uid))
1042 				return -EINVAL;
1043 			break;
1044 		case Opt_gid:
1045 			if (match_int(&args[0], &option))
1046 				return -EINVAL;
1047 			opts->fs_gid = make_kgid(current_user_ns(), option);
1048 			if (!gid_valid(opts->fs_gid))
1049 				return -EINVAL;
1050 			break;
1051 		case Opt_umask:
1052 			if (match_octal(&args[0], &option))
1053 				return -EINVAL;
1054 			opts->fs_fmask = opts->fs_dmask = option;
1055 			break;
1056 		case Opt_dmask:
1057 			if (match_octal(&args[0], &option))
1058 				return -EINVAL;
1059 			opts->fs_dmask = option;
1060 			break;
1061 		case Opt_fmask:
1062 			if (match_octal(&args[0], &option))
1063 				return -EINVAL;
1064 			opts->fs_fmask = option;
1065 			break;
1066 		case Opt_allow_utime:
1067 			if (match_octal(&args[0], &option))
1068 				return -EINVAL;
1069 			opts->allow_utime = option & (S_IWGRP | S_IWOTH);
1070 			break;
1071 		case Opt_codepage:
1072 			if (match_int(&args[0], &option))
1073 				return -EINVAL;
1074 			opts->codepage = option;
1075 			break;
1076 		case Opt_flush:
1077 			opts->flush = 1;
1078 			break;
1079 		case Opt_time_offset:
1080 			if (match_int(&args[0], &option))
1081 				return -EINVAL;
1082 			if (option < -12 * 60 || option > 12 * 60)
1083 				return -EINVAL;
1084 			opts->tz_set = 1;
1085 			opts->time_offset = option;
1086 			break;
1087 		case Opt_tz_utc:
1088 			opts->tz_set = 1;
1089 			opts->time_offset = 0;
1090 			break;
1091 		case Opt_err_cont:
1092 			opts->errors = FAT_ERRORS_CONT;
1093 			break;
1094 		case Opt_err_panic:
1095 			opts->errors = FAT_ERRORS_PANIC;
1096 			break;
1097 		case Opt_err_ro:
1098 			opts->errors = FAT_ERRORS_RO;
1099 			break;
1100 		case Opt_nfs_stale_rw:
1101 			opts->nfs = FAT_NFS_STALE_RW;
1102 			break;
1103 		case Opt_nfs_nostale_ro:
1104 			opts->nfs = FAT_NFS_NOSTALE_RO;
1105 			break;
1106 
1107 		/* msdos specific */
1108 		case Opt_dots:
1109 			opts->dotsOK = 1;
1110 			break;
1111 		case Opt_nodots:
1112 			opts->dotsOK = 0;
1113 			break;
1114 
1115 		/* vfat specific */
1116 		case Opt_charset:
1117 			if (opts->iocharset != fat_default_iocharset)
1118 				kfree(opts->iocharset);
1119 			iocharset = match_strdup(&args[0]);
1120 			if (!iocharset)
1121 				return -ENOMEM;
1122 			opts->iocharset = iocharset;
1123 			break;
1124 		case Opt_shortname_lower:
1125 			opts->shortname = VFAT_SFN_DISPLAY_LOWER
1126 					| VFAT_SFN_CREATE_WIN95;
1127 			break;
1128 		case Opt_shortname_win95:
1129 			opts->shortname = VFAT_SFN_DISPLAY_WIN95
1130 					| VFAT_SFN_CREATE_WIN95;
1131 			break;
1132 		case Opt_shortname_winnt:
1133 			opts->shortname = VFAT_SFN_DISPLAY_WINNT
1134 					| VFAT_SFN_CREATE_WINNT;
1135 			break;
1136 		case Opt_shortname_mixed:
1137 			opts->shortname = VFAT_SFN_DISPLAY_WINNT
1138 					| VFAT_SFN_CREATE_WIN95;
1139 			break;
1140 		case Opt_utf8_no:		/* 0 or no or false */
1141 			opts->utf8 = 0;
1142 			break;
1143 		case Opt_utf8_yes:		/* empty or 1 or yes or true */
1144 			opts->utf8 = 1;
1145 			break;
1146 		case Opt_uni_xl_no:		/* 0 or no or false */
1147 			opts->unicode_xlate = 0;
1148 			break;
1149 		case Opt_uni_xl_yes:		/* empty or 1 or yes or true */
1150 			opts->unicode_xlate = 1;
1151 			break;
1152 		case Opt_nonumtail_no:		/* 0 or no or false */
1153 			opts->numtail = 1;	/* negated option */
1154 			break;
1155 		case Opt_nonumtail_yes:		/* empty or 1 or yes or true */
1156 			opts->numtail = 0;	/* negated option */
1157 			break;
1158 		case Opt_rodir:
1159 			opts->rodir = 1;
1160 			break;
1161 		case Opt_discard:
1162 			opts->discard = 1;
1163 			break;
1164 
1165 		/* obsolete mount options */
1166 		case Opt_obsolete:
1167 			fat_msg(sb, KERN_INFO, "\"%s\" option is obsolete, "
1168 			       "not supported now", p);
1169 			break;
1170 		/* unknown option */
1171 		default:
1172 			if (!silent) {
1173 				fat_msg(sb, KERN_ERR,
1174 				       "Unrecognized mount option \"%s\" "
1175 				       "or missing value", p);
1176 			}
1177 			return -EINVAL;
1178 		}
1179 	}
1180 
1181 out:
1182 	/* UTF-8 doesn't provide FAT semantics */
1183 	if (!strcmp(opts->iocharset, "utf8")) {
1184 		fat_msg(sb, KERN_WARNING, "utf8 is not a recommended IO charset"
1185 		       " for FAT filesystems, filesystem will be "
1186 		       "case sensitive!");
1187 	}
1188 
1189 	/* If user doesn't specify allow_utime, it's initialized from dmask. */
1190 	if (opts->allow_utime == (unsigned short)-1)
1191 		opts->allow_utime = ~opts->fs_dmask & (S_IWGRP | S_IWOTH);
1192 	if (opts->unicode_xlate)
1193 		opts->utf8 = 0;
1194 	if (opts->nfs == FAT_NFS_NOSTALE_RO) {
1195 		sb->s_flags |= MS_RDONLY;
1196 		sb->s_export_op = &fat_export_ops_nostale;
1197 	}
1198 
1199 	return 0;
1200 }
1201 
1202 static int fat_read_root(struct inode *inode)
1203 {
1204 	struct super_block *sb = inode->i_sb;
1205 	struct msdos_sb_info *sbi = MSDOS_SB(sb);
1206 	int error;
1207 
1208 	MSDOS_I(inode)->i_pos = MSDOS_ROOT_INO;
1209 	inode->i_uid = sbi->options.fs_uid;
1210 	inode->i_gid = sbi->options.fs_gid;
1211 	inode->i_version++;
1212 	inode->i_generation = 0;
1213 	inode->i_mode = fat_make_mode(sbi, ATTR_DIR, S_IRWXUGO);
1214 	inode->i_op = sbi->dir_ops;
1215 	inode->i_fop = &fat_dir_operations;
1216 	if (sbi->fat_bits == 32) {
1217 		MSDOS_I(inode)->i_start = sbi->root_cluster;
1218 		error = fat_calc_dir_size(inode);
1219 		if (error < 0)
1220 			return error;
1221 	} else {
1222 		MSDOS_I(inode)->i_start = 0;
1223 		inode->i_size = sbi->dir_entries * sizeof(struct msdos_dir_entry);
1224 	}
1225 	inode->i_blocks = ((inode->i_size + (sbi->cluster_size - 1))
1226 			   & ~((loff_t)sbi->cluster_size - 1)) >> 9;
1227 	MSDOS_I(inode)->i_logstart = 0;
1228 	MSDOS_I(inode)->mmu_private = inode->i_size;
1229 
1230 	fat_save_attrs(inode, ATTR_DIR);
1231 	inode->i_mtime.tv_sec = inode->i_atime.tv_sec = inode->i_ctime.tv_sec = 0;
1232 	inode->i_mtime.tv_nsec = inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = 0;
1233 	set_nlink(inode, fat_subdirs(inode)+2);
1234 
1235 	return 0;
1236 }
1237 
1238 static unsigned long calc_fat_clusters(struct super_block *sb)
1239 {
1240 	struct msdos_sb_info *sbi = MSDOS_SB(sb);
1241 
1242 	/* Divide first to avoid overflow */
1243 	if (sbi->fat_bits != 12) {
1244 		unsigned long ent_per_sec = sb->s_blocksize * 8 / sbi->fat_bits;
1245 		return ent_per_sec * sbi->fat_length;
1246 	}
1247 
1248 	return sbi->fat_length * sb->s_blocksize * 8 / sbi->fat_bits;
1249 }
1250 
1251 /*
1252  * Read the super block of an MS-DOS FS.
1253  */
1254 int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
1255 		   void (*setup)(struct super_block *))
1256 {
1257 	struct inode *root_inode = NULL, *fat_inode = NULL;
1258 	struct inode *fsinfo_inode = NULL;
1259 	struct buffer_head *bh;
1260 	struct fat_boot_sector *b;
1261 	struct msdos_sb_info *sbi;
1262 	u16 logical_sector_size;
1263 	u32 total_sectors, total_clusters, fat_clusters, rootdir_sectors;
1264 	int debug;
1265 	unsigned int media;
1266 	long error;
1267 	char buf[50];
1268 
1269 	/*
1270 	 * GFP_KERNEL is ok here, because while we do hold the
1271 	 * supeblock lock, memory pressure can't call back into
1272 	 * the filesystem, since we're only just about to mount
1273 	 * it and have no inodes etc active!
1274 	 */
1275 	sbi = kzalloc(sizeof(struct msdos_sb_info), GFP_KERNEL);
1276 	if (!sbi)
1277 		return -ENOMEM;
1278 	sb->s_fs_info = sbi;
1279 
1280 	sb->s_flags |= MS_NODIRATIME;
1281 	sb->s_magic = MSDOS_SUPER_MAGIC;
1282 	sb->s_op = &fat_sops;
1283 	sb->s_export_op = &fat_export_ops;
1284 	mutex_init(&sbi->nfs_build_inode_lock);
1285 	ratelimit_state_init(&sbi->ratelimit, DEFAULT_RATELIMIT_INTERVAL,
1286 			     DEFAULT_RATELIMIT_BURST);
1287 
1288 	error = parse_options(sb, data, isvfat, silent, &debug, &sbi->options);
1289 	if (error)
1290 		goto out_fail;
1291 
1292 	setup(sb); /* flavour-specific stuff that needs options */
1293 
1294 	error = -EIO;
1295 	sb_min_blocksize(sb, 512);
1296 	bh = sb_bread(sb, 0);
1297 	if (bh == NULL) {
1298 		fat_msg(sb, KERN_ERR, "unable to read boot sector");
1299 		goto out_fail;
1300 	}
1301 
1302 	b = (struct fat_boot_sector *) bh->b_data;
1303 	if (!b->reserved) {
1304 		if (!silent)
1305 			fat_msg(sb, KERN_ERR, "bogus number of reserved sectors");
1306 		brelse(bh);
1307 		goto out_invalid;
1308 	}
1309 	if (!b->fats) {
1310 		if (!silent)
1311 			fat_msg(sb, KERN_ERR, "bogus number of FAT structure");
1312 		brelse(bh);
1313 		goto out_invalid;
1314 	}
1315 
1316 	/*
1317 	 * Earlier we checked here that b->secs_track and b->head are nonzero,
1318 	 * but it turns out valid FAT filesystems can have zero there.
1319 	 */
1320 
1321 	media = b->media;
1322 	if (!fat_valid_media(media)) {
1323 		if (!silent)
1324 			fat_msg(sb, KERN_ERR, "invalid media value (0x%02x)",
1325 			       media);
1326 		brelse(bh);
1327 		goto out_invalid;
1328 	}
1329 	logical_sector_size = get_unaligned_le16(&b->sector_size);
1330 	if (!is_power_of_2(logical_sector_size)
1331 	    || (logical_sector_size < 512)
1332 	    || (logical_sector_size > 4096)) {
1333 		if (!silent)
1334 			fat_msg(sb, KERN_ERR, "bogus logical sector size %u",
1335 			       logical_sector_size);
1336 		brelse(bh);
1337 		goto out_invalid;
1338 	}
1339 	sbi->sec_per_clus = b->sec_per_clus;
1340 	if (!is_power_of_2(sbi->sec_per_clus)) {
1341 		if (!silent)
1342 			fat_msg(sb, KERN_ERR, "bogus sectors per cluster %u",
1343 			       sbi->sec_per_clus);
1344 		brelse(bh);
1345 		goto out_invalid;
1346 	}
1347 
1348 	if (logical_sector_size < sb->s_blocksize) {
1349 		fat_msg(sb, KERN_ERR, "logical sector size too small for device"
1350 		       " (logical sector size = %u)", logical_sector_size);
1351 		brelse(bh);
1352 		goto out_fail;
1353 	}
1354 	if (logical_sector_size > sb->s_blocksize) {
1355 		brelse(bh);
1356 
1357 		if (!sb_set_blocksize(sb, logical_sector_size)) {
1358 			fat_msg(sb, KERN_ERR, "unable to set blocksize %u",
1359 			       logical_sector_size);
1360 			goto out_fail;
1361 		}
1362 		bh = sb_bread(sb, 0);
1363 		if (bh == NULL) {
1364 			fat_msg(sb, KERN_ERR, "unable to read boot sector"
1365 			       " (logical sector size = %lu)",
1366 			       sb->s_blocksize);
1367 			goto out_fail;
1368 		}
1369 		b = (struct fat_boot_sector *) bh->b_data;
1370 	}
1371 
1372 	mutex_init(&sbi->s_lock);
1373 	sbi->cluster_size = sb->s_blocksize * sbi->sec_per_clus;
1374 	sbi->cluster_bits = ffs(sbi->cluster_size) - 1;
1375 	sbi->fats = b->fats;
1376 	sbi->fat_bits = 0;		/* Don't know yet */
1377 	sbi->fat_start = le16_to_cpu(b->reserved);
1378 	sbi->fat_length = le16_to_cpu(b->fat_length);
1379 	sbi->root_cluster = 0;
1380 	sbi->free_clusters = -1;	/* Don't know yet */
1381 	sbi->free_clus_valid = 0;
1382 	sbi->prev_free = FAT_START_ENT;
1383 	sb->s_maxbytes = 0xffffffff;
1384 
1385 	if (!sbi->fat_length && b->fat32.length) {
1386 		struct fat_boot_fsinfo *fsinfo;
1387 		struct buffer_head *fsinfo_bh;
1388 
1389 		/* Must be FAT32 */
1390 		sbi->fat_bits = 32;
1391 		sbi->fat_length = le32_to_cpu(b->fat32.length);
1392 		sbi->root_cluster = le32_to_cpu(b->fat32.root_cluster);
1393 
1394 		/* MC - if info_sector is 0, don't multiply by 0 */
1395 		sbi->fsinfo_sector = le16_to_cpu(b->fat32.info_sector);
1396 		if (sbi->fsinfo_sector == 0)
1397 			sbi->fsinfo_sector = 1;
1398 
1399 		fsinfo_bh = sb_bread(sb, sbi->fsinfo_sector);
1400 		if (fsinfo_bh == NULL) {
1401 			fat_msg(sb, KERN_ERR, "bread failed, FSINFO block"
1402 			       " (sector = %lu)", sbi->fsinfo_sector);
1403 			brelse(bh);
1404 			goto out_fail;
1405 		}
1406 
1407 		fsinfo = (struct fat_boot_fsinfo *)fsinfo_bh->b_data;
1408 		if (!IS_FSINFO(fsinfo)) {
1409 			fat_msg(sb, KERN_WARNING, "Invalid FSINFO signature: "
1410 			       "0x%08x, 0x%08x (sector = %lu)",
1411 			       le32_to_cpu(fsinfo->signature1),
1412 			       le32_to_cpu(fsinfo->signature2),
1413 			       sbi->fsinfo_sector);
1414 		} else {
1415 			if (sbi->options.usefree)
1416 				sbi->free_clus_valid = 1;
1417 			sbi->free_clusters = le32_to_cpu(fsinfo->free_clusters);
1418 			sbi->prev_free = le32_to_cpu(fsinfo->next_cluster);
1419 		}
1420 
1421 		brelse(fsinfo_bh);
1422 	}
1423 
1424 	/* interpret volume ID as a little endian 32 bit integer */
1425 	if (sbi->fat_bits == 32)
1426 		sbi->vol_id = (((u32)b->fat32.vol_id[0]) |
1427 					((u32)b->fat32.vol_id[1] << 8) |
1428 					((u32)b->fat32.vol_id[2] << 16) |
1429 					((u32)b->fat32.vol_id[3] << 24));
1430 	else /* fat 16 or 12 */
1431 		sbi->vol_id = (((u32)b->fat16.vol_id[0]) |
1432 					((u32)b->fat16.vol_id[1] << 8) |
1433 					((u32)b->fat16.vol_id[2] << 16) |
1434 					((u32)b->fat16.vol_id[3] << 24));
1435 
1436 	sbi->dir_per_block = sb->s_blocksize / sizeof(struct msdos_dir_entry);
1437 	sbi->dir_per_block_bits = ffs(sbi->dir_per_block) - 1;
1438 
1439 	sbi->dir_start = sbi->fat_start + sbi->fats * sbi->fat_length;
1440 	sbi->dir_entries = get_unaligned_le16(&b->dir_entries);
1441 	if (sbi->dir_entries & (sbi->dir_per_block - 1)) {
1442 		if (!silent)
1443 			fat_msg(sb, KERN_ERR, "bogus directory-entries per block"
1444 			       " (%u)", sbi->dir_entries);
1445 		brelse(bh);
1446 		goto out_invalid;
1447 	}
1448 
1449 	rootdir_sectors = sbi->dir_entries
1450 		* sizeof(struct msdos_dir_entry) / sb->s_blocksize;
1451 	sbi->data_start = sbi->dir_start + rootdir_sectors;
1452 	total_sectors = get_unaligned_le16(&b->sectors);
1453 	if (total_sectors == 0)
1454 		total_sectors = le32_to_cpu(b->total_sect);
1455 
1456 	total_clusters = (total_sectors - sbi->data_start) / sbi->sec_per_clus;
1457 
1458 	if (sbi->fat_bits != 32)
1459 		sbi->fat_bits = (total_clusters > MAX_FAT12) ? 16 : 12;
1460 
1461 	/* some OSes set FAT_STATE_DIRTY and clean it on unmount. */
1462 	if (sbi->fat_bits == 32)
1463 		sbi->dirty = b->fat32.state & FAT_STATE_DIRTY;
1464 	else /* fat 16 or 12 */
1465 		sbi->dirty = b->fat16.state & FAT_STATE_DIRTY;
1466 
1467 	/* check that FAT table does not overflow */
1468 	fat_clusters = calc_fat_clusters(sb);
1469 	total_clusters = min(total_clusters, fat_clusters - FAT_START_ENT);
1470 	if (total_clusters > MAX_FAT(sb)) {
1471 		if (!silent)
1472 			fat_msg(sb, KERN_ERR, "count of clusters too big (%u)",
1473 			       total_clusters);
1474 		brelse(bh);
1475 		goto out_invalid;
1476 	}
1477 
1478 	sbi->max_cluster = total_clusters + FAT_START_ENT;
1479 	/* check the free_clusters, it's not necessarily correct */
1480 	if (sbi->free_clusters != -1 && sbi->free_clusters > total_clusters)
1481 		sbi->free_clusters = -1;
1482 	/* check the prev_free, it's not necessarily correct */
1483 	sbi->prev_free %= sbi->max_cluster;
1484 	if (sbi->prev_free < FAT_START_ENT)
1485 		sbi->prev_free = FAT_START_ENT;
1486 
1487 	brelse(bh);
1488 
1489 	/* set up enough so that it can read an inode */
1490 	fat_hash_init(sb);
1491 	dir_hash_init(sb);
1492 	fat_ent_access_init(sb);
1493 
1494 	/*
1495 	 * The low byte of FAT's first entry must have same value with
1496 	 * media-field.  But in real world, too many devices is
1497 	 * writing wrong value.  So, removed that validity check.
1498 	 *
1499 	 * if (FAT_FIRST_ENT(sb, media) != first)
1500 	 */
1501 
1502 	error = -EINVAL;
1503 	sprintf(buf, "cp%d", sbi->options.codepage);
1504 	sbi->nls_disk = load_nls(buf);
1505 	if (!sbi->nls_disk) {
1506 		fat_msg(sb, KERN_ERR, "codepage %s not found", buf);
1507 		goto out_fail;
1508 	}
1509 
1510 	/* FIXME: utf8 is using iocharset for upper/lower conversion */
1511 	if (sbi->options.isvfat) {
1512 		sbi->nls_io = load_nls(sbi->options.iocharset);
1513 		if (!sbi->nls_io) {
1514 			fat_msg(sb, KERN_ERR, "IO charset %s not found",
1515 			       sbi->options.iocharset);
1516 			goto out_fail;
1517 		}
1518 	}
1519 
1520 	error = -ENOMEM;
1521 	fat_inode = new_inode(sb);
1522 	if (!fat_inode)
1523 		goto out_fail;
1524 	MSDOS_I(fat_inode)->i_pos = 0;
1525 	sbi->fat_inode = fat_inode;
1526 
1527 	fsinfo_inode = new_inode(sb);
1528 	if (!fsinfo_inode)
1529 		goto out_fail;
1530 	fsinfo_inode->i_ino = MSDOS_FSINFO_INO;
1531 	sbi->fsinfo_inode = fsinfo_inode;
1532 	insert_inode_hash(fsinfo_inode);
1533 
1534 	root_inode = new_inode(sb);
1535 	if (!root_inode)
1536 		goto out_fail;
1537 	root_inode->i_ino = MSDOS_ROOT_INO;
1538 	root_inode->i_version = 1;
1539 	error = fat_read_root(root_inode);
1540 	if (error < 0) {
1541 		iput(root_inode);
1542 		goto out_fail;
1543 	}
1544 	error = -ENOMEM;
1545 	insert_inode_hash(root_inode);
1546 	fat_attach(root_inode, 0);
1547 	sb->s_root = d_make_root(root_inode);
1548 	if (!sb->s_root) {
1549 		fat_msg(sb, KERN_ERR, "get root inode failed");
1550 		goto out_fail;
1551 	}
1552 
1553 	if (sbi->options.discard) {
1554 		struct request_queue *q = bdev_get_queue(sb->s_bdev);
1555 		if (!blk_queue_discard(q))
1556 			fat_msg(sb, KERN_WARNING,
1557 					"mounting with \"discard\" option, but "
1558 					"the device does not support discard");
1559 	}
1560 
1561 	fat_set_state(sb, 1, 0);
1562 	return 0;
1563 
1564 out_invalid:
1565 	error = -EINVAL;
1566 	if (!silent)
1567 		fat_msg(sb, KERN_INFO, "Can't find a valid FAT filesystem");
1568 
1569 out_fail:
1570 	if (fsinfo_inode)
1571 		iput(fsinfo_inode);
1572 	if (fat_inode)
1573 		iput(fat_inode);
1574 	unload_nls(sbi->nls_io);
1575 	unload_nls(sbi->nls_disk);
1576 	if (sbi->options.iocharset != fat_default_iocharset)
1577 		kfree(sbi->options.iocharset);
1578 	sb->s_fs_info = NULL;
1579 	kfree(sbi);
1580 	return error;
1581 }
1582 
1583 EXPORT_SYMBOL_GPL(fat_fill_super);
1584 
1585 /*
1586  * helper function for fat_flush_inodes.  This writes both the inode
1587  * and the file data blocks, waiting for in flight data blocks before
1588  * the start of the call.  It does not wait for any io started
1589  * during the call
1590  */
1591 static int writeback_inode(struct inode *inode)
1592 {
1593 
1594 	int ret;
1595 
1596 	/* if we used wait=1, sync_inode_metadata waits for the io for the
1597 	* inode to finish.  So wait=0 is sent down to sync_inode_metadata
1598 	* and filemap_fdatawrite is used for the data blocks
1599 	*/
1600 	ret = sync_inode_metadata(inode, 0);
1601 	if (!ret)
1602 		ret = filemap_fdatawrite(inode->i_mapping);
1603 	return ret;
1604 }
1605 
1606 /*
1607  * write data and metadata corresponding to i1 and i2.  The io is
1608  * started but we do not wait for any of it to finish.
1609  *
1610  * filemap_flush is used for the block device, so if there is a dirty
1611  * page for a block already in flight, we will not wait and start the
1612  * io over again
1613  */
1614 int fat_flush_inodes(struct super_block *sb, struct inode *i1, struct inode *i2)
1615 {
1616 	int ret = 0;
1617 	if (!MSDOS_SB(sb)->options.flush)
1618 		return 0;
1619 	if (i1)
1620 		ret = writeback_inode(i1);
1621 	if (!ret && i2)
1622 		ret = writeback_inode(i2);
1623 	if (!ret) {
1624 		struct address_space *mapping = sb->s_bdev->bd_inode->i_mapping;
1625 		ret = filemap_flush(mapping);
1626 	}
1627 	return ret;
1628 }
1629 EXPORT_SYMBOL_GPL(fat_flush_inodes);
1630 
1631 static int __init init_fat_fs(void)
1632 {
1633 	int err;
1634 
1635 	err = fat_cache_init();
1636 	if (err)
1637 		return err;
1638 
1639 	err = fat_init_inodecache();
1640 	if (err)
1641 		goto failed;
1642 
1643 	return 0;
1644 
1645 failed:
1646 	fat_cache_destroy();
1647 	return err;
1648 }
1649 
1650 static void __exit exit_fat_fs(void)
1651 {
1652 	fat_cache_destroy();
1653 	fat_destroy_inodecache();
1654 }
1655 
1656 module_init(init_fat_fs)
1657 module_exit(exit_fat_fs)
1658 
1659 MODULE_LICENSE("GPL");
1660