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