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