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 | |
104 | int fat_add_cluster(struct inode *inode) |
105 | { |
106 | int err, cluster; |
107 | |
108 | err = fat_alloc_clusters(inode, cluster: &cluster, nr_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, new_dclus: cluster, nr_cluster: 1); |
114 | if (err) |
115 | fat_free_clusters(inode, cluster); |
116 | return err; |
117 | } |
118 | |
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, sector: iblock, phys: &phys, mapped_blocks: &mapped_blocks, create, from_bmap: false); |
130 | if (err) |
131 | return err; |
132 | if (phys) { |
133 | map_bh(bh: bh_result, sb, block: 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, sector: iblock, phys: &phys, mapped_blocks: &mapped_blocks, create, from_bmap: 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: bh_result, sb, block: phys); |
179 | |
180 | return 0; |
181 | } |
182 | |
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: &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 | |
197 | static int fat_writepages(struct address_space *mapping, |
198 | struct writeback_control *wbc) |
199 | { |
200 | return mpage_writepages(mapping, wbc, get_block: fat_get_block); |
201 | } |
202 | |
203 | static int fat_read_folio(struct file *file, struct folio *folio) |
204 | { |
205 | return mpage_read_folio(folio, get_block: fat_get_block); |
206 | } |
207 | |
208 | static void fat_readahead(struct readahead_control *rac) |
209 | { |
210 | mpage_readahead(rac, get_block: fat_get_block); |
211 | } |
212 | |
213 | static void fat_write_failed(struct address_space *mapping, loff_t to) |
214 | { |
215 | struct inode *inode = mapping->host; |
216 | |
217 | if (to > inode->i_size) { |
218 | truncate_pagecache(inode, new: inode->i_size); |
219 | fat_truncate_blocks(inode, offset: inode->i_size); |
220 | } |
221 | } |
222 | |
223 | static int fat_write_begin(struct file *file, struct address_space *mapping, |
224 | loff_t pos, unsigned len, |
225 | struct page **pagep, void **fsdata) |
226 | { |
227 | int err; |
228 | |
229 | *pagep = NULL; |
230 | err = cont_write_begin(file, mapping, pos, len, |
231 | pagep, fsdata, fat_get_block, |
232 | &MSDOS_I(inode: mapping->host)->mmu_private); |
233 | if (err < 0) |
234 | fat_write_failed(mapping, to: pos + len); |
235 | return err; |
236 | } |
237 | |
238 | static int fat_write_end(struct file *file, struct address_space *mapping, |
239 | loff_t pos, unsigned len, unsigned copied, |
240 | struct page *pagep, void *fsdata) |
241 | { |
242 | struct inode *inode = mapping->host; |
243 | int err; |
244 | err = generic_write_end(file, mapping, pos, len, copied, pagep, fsdata); |
245 | if (err < len) |
246 | fat_write_failed(mapping, to: pos + len); |
247 | if (!(err < 0) && !(MSDOS_I(inode)->i_attrs & ATTR_ARCH)) { |
248 | fat_truncate_time(inode, NULL, flags: S_CTIME|S_MTIME); |
249 | MSDOS_I(inode)->i_attrs |= ATTR_ARCH; |
250 | mark_inode_dirty(inode); |
251 | } |
252 | return err; |
253 | } |
254 | |
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(i: iter); |
261 | loff_t offset = iocb->ki_pos; |
262 | ssize_t ret; |
263 | |
264 | if (iov_iter_rw(i: 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, get_block: fat_get_block); |
284 | if (ret < 0 && iov_iter_rw(i: iter) == WRITE) |
285 | fat_write_failed(mapping, to: offset + count); |
286 | |
287 | return ret; |
288 | } |
289 | |
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, sector: iblock, phys: &bmap, mapped_blocks: &mapped_blocks, create, from_bmap: true); |
302 | if (err) |
303 | return err; |
304 | |
305 | if (bmap) { |
306 | map_bh(bh: bh_result, sb, block: 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 | |
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(sem: &MSDOS_I(inode: mapping->host)->truncate_lock); |
321 | blocknr = generic_block_bmap(mapping, block, fat_get_block_bmap); |
322 | up_read(sem: &MSDOS_I(inode: 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 | */ |
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 | |
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 | |
386 | static inline unsigned long fat_hash(loff_t i_pos) |
387 | { |
388 | return hash_32(val: i_pos, FAT_HASH_BITS); |
389 | } |
390 | |
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 | |
401 | void fat_attach(struct inode *inode, loff_t i_pos) |
402 | { |
403 | struct msdos_sb_info *sbi = MSDOS_SB(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(lock: &sbi->inode_hash_lock); |
410 | MSDOS_I(inode)->i_pos = i_pos; |
411 | hlist_add_head(n: &MSDOS_I(inode)->i_fat_hash, h: head); |
412 | spin_unlock(lock: &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(logstart: MSDOS_I(inode)->i_logstart); |
422 | |
423 | spin_lock(lock: &sbi->dir_hash_lock); |
424 | hlist_add_head(n: &MSDOS_I(inode)->i_dir_hash, h: d_head); |
425 | spin_unlock(lock: &sbi->dir_hash_lock); |
426 | } |
427 | } |
428 | EXPORT_SYMBOL_GPL(fat_attach); |
429 | |
430 | void fat_detach(struct inode *inode) |
431 | { |
432 | struct msdos_sb_info *sbi = MSDOS_SB(sb: inode->i_sb); |
433 | spin_lock(lock: &sbi->inode_hash_lock); |
434 | MSDOS_I(inode)->i_pos = 0; |
435 | hlist_del_init(n: &MSDOS_I(inode)->i_fat_hash); |
436 | spin_unlock(lock: &sbi->inode_hash_lock); |
437 | |
438 | if (S_ISDIR(inode->i_mode) && sbi->options.nfs) { |
439 | spin_lock(lock: &sbi->dir_hash_lock); |
440 | hlist_del_init(n: &MSDOS_I(inode)->i_dir_hash); |
441 | spin_unlock(lock: &sbi->dir_hash_lock); |
442 | } |
443 | } |
444 | EXPORT_SYMBOL_GPL(fat_detach); |
445 | |
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(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(lock: &sbi->inode_hash_lock); |
463 | return inode; |
464 | } |
465 | |
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 | |
476 | static int fat_calc_dir_size(struct inode *inode) |
477 | { |
478 | struct msdos_sb_info *sbi = MSDOS_SB(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: &fclus, dclus: &dclus); |
486 | if (ret < 0) |
487 | return ret; |
488 | inode->i_size = (fclus + 1) << sbi->cluster_bits; |
489 | |
490 | return 0; |
491 | } |
492 | |
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(inode: dir)->i_start == 0 || |
503 | MSDOS_I(inode: 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 */ |
512 | int fat_fill_inode(struct inode *inode, struct msdos_dir_entry *de) |
513 | { |
514 | struct msdos_sb_info *sbi = MSDOS_SB(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, attrs: 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, nlink: fat_subdirs(dir: inode)); |
538 | |
539 | error = fat_validate_dir(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, attrs: de->attr, |
545 | mode: ((sbi->options.showexec && !is_exec(extension: 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, attrs: 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, ts: &mtime, time: de->time, date: de->date, time_cs: 0); |
566 | inode_set_mtime_to_ts(inode, ts: mtime); |
567 | inode_set_ctime_to_ts(inode, ts: mtime); |
568 | if (sbi->options.isvfat) { |
569 | struct timespec64 atime; |
570 | |
571 | fat_time_fat2unix(sbi, ts: &atime, time: 0, date: de->adate, time_cs: 0); |
572 | inode_set_atime_to_ts(inode, ts: atime); |
573 | fat_time_fat2unix(sbi, ts: &MSDOS_I(inode)->i_crtime, time: de->ctime, |
574 | date: de->cdate, time_cs: de->ctime_cs); |
575 | } else |
576 | inode_set_atime_to_ts(inode, ts: fat_truncate_atime(sbi, ts: &mtime)); |
577 | |
578 | return 0; |
579 | } |
580 | |
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 | |
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(lock: &sbi->nfs_build_inode_lock); |
591 | } |
592 | |
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(sbi: 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(error: -ENOMEM); |
606 | goto out; |
607 | } |
608 | inode->i_ino = iunique(sb, MSDOS_ROOT_INO); |
609 | inode_set_iversion(inode, val: 1); |
610 | err = fat_fill_inode(inode, de); |
611 | if (err) { |
612 | iput(inode); |
613 | inode = ERR_PTR(error: err); |
614 | goto out; |
615 | } |
616 | fat_attach(inode, i_pos); |
617 | insert_inode_hash(inode); |
618 | out: |
619 | fat_unlock_build_inode(sbi: 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 | |
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, offset: 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, wait: 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 | |
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, offset: 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 | |
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, block: 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 | |
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(objp: opts->iocharset); |
720 | opts->iocharset = fat_default_iocharset; |
721 | } |
722 | } |
723 | |
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(opts: &sbi->options); |
730 | kfree(objp: sbi); |
731 | } |
732 | |
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, set: 0, force: 0); |
738 | |
739 | iput(sbi->fsinfo_inode); |
740 | iput(sbi->fat_inode); |
741 | |
742 | call_rcu(head: &sbi->rcu, func: delayed_free); |
743 | } |
744 | |
745 | static struct kmem_cache *fat_inode_cachep; |
746 | |
747 | static struct inode *fat_alloc_inode(struct super_block *sb) |
748 | { |
749 | struct msdos_inode_info *ei; |
750 | ei = alloc_inode_sb(sb, cache: 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 | |
767 | static void fat_free_inode(struct inode *inode) |
768 | { |
769 | kmem_cache_free(s: fat_inode_cachep, objp: MSDOS_I(inode)); |
770 | } |
771 | |
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(list: &ei->cache_lru); |
780 | INIT_HLIST_NODE(h: &ei->i_fat_hash); |
781 | INIT_HLIST_NODE(h: &ei->i_dir_hash); |
782 | inode_init_once(&ei->vfs_inode); |
783 | } |
784 | |
785 | static int __init fat_init_inodecache(void) |
786 | { |
787 | fat_inode_cachep = kmem_cache_create(name: "fat_inode_cache" , |
788 | size: sizeof(struct msdos_inode_info), |
789 | align: 0, flags: (SLAB_RECLAIM_ACCOUNT| |
790 | SLAB_MEM_SPREAD|SLAB_ACCOUNT), |
791 | ctor: init_once); |
792 | if (fat_inode_cachep == NULL) |
793 | return -ENOMEM; |
794 | return 0; |
795 | } |
796 | |
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(s: fat_inode_cachep); |
805 | } |
806 | |
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, set: 0, force: 0); |
820 | else |
821 | fat_set_state(sb, set: 1, force: 1); |
822 | } |
823 | return 0; |
824 | } |
825 | |
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(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(sb: 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(v: id); |
845 | buf->f_namelen = |
846 | (sbi->options.isvfat ? FAT_LFN_LEN : 12) * NLS_MAX_CHARSET_SIZE; |
847 | |
848 | return 0; |
849 | } |
850 | |
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 | struct timespec64 mtime; |
858 | loff_t i_pos; |
859 | sector_t blocknr; |
860 | int err, offset; |
861 | |
862 | if (inode->i_ino == MSDOS_ROOT_INO) |
863 | return 0; |
864 | |
865 | retry: |
866 | i_pos = fat_i_pos_read(sbi, inode); |
867 | if (!i_pos) |
868 | return 0; |
869 | |
870 | fat_get_blknr_offset(sbi, i_pos, blknr: &blocknr, offset: &offset); |
871 | bh = sb_bread(sb, block: blocknr); |
872 | if (!bh) { |
873 | fat_msg(sb, KERN_ERR, "unable to read inode block " |
874 | "for updating (i_pos %lld)" , i_pos); |
875 | return -EIO; |
876 | } |
877 | spin_lock(lock: &sbi->inode_hash_lock); |
878 | if (i_pos != MSDOS_I(inode)->i_pos) { |
879 | spin_unlock(lock: &sbi->inode_hash_lock); |
880 | brelse(bh); |
881 | goto retry; |
882 | } |
883 | |
884 | raw_entry = &((struct msdos_dir_entry *) (bh->b_data))[offset]; |
885 | if (S_ISDIR(inode->i_mode)) |
886 | raw_entry->size = 0; |
887 | else |
888 | raw_entry->size = cpu_to_le32(inode->i_size); |
889 | raw_entry->attr = fat_make_attrs(inode); |
890 | fat_set_start(de: raw_entry, cluster: MSDOS_I(inode)->i_logstart); |
891 | mtime = inode_get_mtime(inode); |
892 | fat_time_unix2fat(sbi, ts: &mtime, time: &raw_entry->time, |
893 | date: &raw_entry->date, NULL); |
894 | if (sbi->options.isvfat) { |
895 | struct timespec64 ts = inode_get_atime(inode); |
896 | __le16 atime; |
897 | |
898 | fat_time_unix2fat(sbi, ts: &ts, time: &atime, date: &raw_entry->adate, NULL); |
899 | fat_time_unix2fat(sbi, ts: &MSDOS_I(inode)->i_crtime, time: &raw_entry->ctime, |
900 | date: &raw_entry->cdate, time_cs: &raw_entry->ctime_cs); |
901 | } |
902 | spin_unlock(lock: &sbi->inode_hash_lock); |
903 | mark_buffer_dirty(bh); |
904 | err = 0; |
905 | if (wait) |
906 | err = sync_dirty_buffer(bh); |
907 | brelse(bh); |
908 | return err; |
909 | } |
910 | |
911 | static int fat_write_inode(struct inode *inode, struct writeback_control *wbc) |
912 | { |
913 | int err; |
914 | |
915 | if (inode->i_ino == MSDOS_FSINFO_INO) { |
916 | struct super_block *sb = inode->i_sb; |
917 | |
918 | mutex_lock(&MSDOS_SB(sb)->s_lock); |
919 | err = fat_clusters_flush(sb); |
920 | mutex_unlock(lock: &MSDOS_SB(sb)->s_lock); |
921 | } else |
922 | err = __fat_write_inode(inode, wait: wbc->sync_mode == WB_SYNC_ALL); |
923 | |
924 | return err; |
925 | } |
926 | |
927 | int fat_sync_inode(struct inode *inode) |
928 | { |
929 | return __fat_write_inode(inode, wait: 1); |
930 | } |
931 | |
932 | EXPORT_SYMBOL_GPL(fat_sync_inode); |
933 | |
934 | static int fat_show_options(struct seq_file *m, struct dentry *root); |
935 | static const struct super_operations fat_sops = { |
936 | .alloc_inode = fat_alloc_inode, |
937 | .free_inode = fat_free_inode, |
938 | .write_inode = fat_write_inode, |
939 | .evict_inode = fat_evict_inode, |
940 | .put_super = fat_put_super, |
941 | .statfs = fat_statfs, |
942 | .remount_fs = fat_remount, |
943 | |
944 | .show_options = fat_show_options, |
945 | }; |
946 | |
947 | static int fat_show_options(struct seq_file *m, struct dentry *root) |
948 | { |
949 | struct msdos_sb_info *sbi = MSDOS_SB(sb: root->d_sb); |
950 | struct fat_mount_options *opts = &sbi->options; |
951 | int isvfat = opts->isvfat; |
952 | |
953 | if (!uid_eq(left: 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_n, Opt_check_r, Opt_check_s, Opt_uid, Opt_gid, |
1041 | Opt_umask, Opt_dmask, Opt_fmask, Opt_allow_utime, Opt_codepage, |
1042 | Opt_usefree, Opt_nocase, Opt_quiet, Opt_showexec, Opt_debug, |
1043 | Opt_immutable, Opt_dots, Opt_nodots, |
1044 | Opt_charset, Opt_shortname_lower, Opt_shortname_win95, |
1045 | Opt_shortname_winnt, Opt_shortname_mixed, Opt_utf8_no, Opt_utf8_yes, |
1046 | Opt_uni_xl_no, Opt_uni_xl_yes, Opt_nonumtail_no, Opt_nonumtail_yes, |
1047 | Opt_obsolete, Opt_flush, Opt_tz_utc, Opt_rodir, Opt_err_cont, |
1048 | Opt_err_panic, Opt_err_ro, Opt_discard, Opt_nfs, Opt_time_offset, |
1049 | Opt_nfs_stale_rw, Opt_nfs_nostale_ro, Opt_err, Opt_dos1xfloppy, |
1050 | }; |
1051 | |
1052 | static const match_table_t fat_tokens = { |
1053 | {Opt_check_r, "check=relaxed" }, |
1054 | {Opt_check_s, "check=strict" }, |
1055 | {Opt_check_n, "check=normal" }, |
1056 | {Opt_check_r, "check=r" }, |
1057 | {Opt_check_s, "check=s" }, |
1058 | {Opt_check_n, "check=n" }, |
1059 | {Opt_uid, "uid=%u" }, |
1060 | {Opt_gid, "gid=%u" }, |
1061 | {Opt_umask, "umask=%o" }, |
1062 | {Opt_dmask, "dmask=%o" }, |
1063 | {Opt_fmask, "fmask=%o" }, |
1064 | {Opt_allow_utime, "allow_utime=%o" }, |
1065 | {Opt_codepage, "codepage=%u" }, |
1066 | {Opt_usefree, "usefree" }, |
1067 | {Opt_nocase, "nocase" }, |
1068 | {Opt_quiet, "quiet" }, |
1069 | {Opt_showexec, "showexec" }, |
1070 | {Opt_debug, "debug" }, |
1071 | {Opt_immutable, "sys_immutable" }, |
1072 | {Opt_flush, "flush" }, |
1073 | {Opt_tz_utc, "tz=UTC" }, |
1074 | {Opt_time_offset, "time_offset=%d" }, |
1075 | {Opt_err_cont, "errors=continue" }, |
1076 | {Opt_err_panic, "errors=panic" }, |
1077 | {Opt_err_ro, "errors=remount-ro" }, |
1078 | {Opt_discard, "discard" }, |
1079 | {Opt_nfs_stale_rw, "nfs" }, |
1080 | {Opt_nfs_stale_rw, "nfs=stale_rw" }, |
1081 | {Opt_nfs_nostale_ro, "nfs=nostale_ro" }, |
1082 | {Opt_dos1xfloppy, "dos1xfloppy" }, |
1083 | {Opt_obsolete, "conv=binary" }, |
1084 | {Opt_obsolete, "conv=text" }, |
1085 | {Opt_obsolete, "conv=auto" }, |
1086 | {Opt_obsolete, "conv=b" }, |
1087 | {Opt_obsolete, "conv=t" }, |
1088 | {Opt_obsolete, "conv=a" }, |
1089 | {Opt_obsolete, "fat=%u" }, |
1090 | {Opt_obsolete, "blocksize=%u" }, |
1091 | {Opt_obsolete, "cvf_format=%20s" }, |
1092 | {Opt_obsolete, "cvf_options=%100s" }, |
1093 | {Opt_obsolete, "posix" }, |
1094 | {Opt_err, NULL}, |
1095 | }; |
1096 | static const match_table_t msdos_tokens = { |
1097 | {Opt_nodots, "nodots" }, |
1098 | {Opt_nodots, "dotsOK=no" }, |
1099 | {Opt_dots, "dots" }, |
1100 | {Opt_dots, "dotsOK=yes" }, |
1101 | {Opt_err, NULL} |
1102 | }; |
1103 | static const match_table_t vfat_tokens = { |
1104 | {Opt_charset, "iocharset=%s" }, |
1105 | {Opt_shortname_lower, "shortname=lower" }, |
1106 | {Opt_shortname_win95, "shortname=win95" }, |
1107 | {Opt_shortname_winnt, "shortname=winnt" }, |
1108 | {Opt_shortname_mixed, "shortname=mixed" }, |
1109 | {Opt_utf8_no, "utf8=0" }, /* 0 or no or false */ |
1110 | {Opt_utf8_no, "utf8=no" }, |
1111 | {Opt_utf8_no, "utf8=false" }, |
1112 | {Opt_utf8_yes, "utf8=1" }, /* empty or 1 or yes or true */ |
1113 | {Opt_utf8_yes, "utf8=yes" }, |
1114 | {Opt_utf8_yes, "utf8=true" }, |
1115 | {Opt_utf8_yes, "utf8" }, |
1116 | {Opt_uni_xl_no, "uni_xlate=0" }, /* 0 or no or false */ |
1117 | {Opt_uni_xl_no, "uni_xlate=no" }, |
1118 | {Opt_uni_xl_no, "uni_xlate=false" }, |
1119 | {Opt_uni_xl_yes, "uni_xlate=1" }, /* empty or 1 or yes or true */ |
1120 | {Opt_uni_xl_yes, "uni_xlate=yes" }, |
1121 | {Opt_uni_xl_yes, "uni_xlate=true" }, |
1122 | {Opt_uni_xl_yes, "uni_xlate" }, |
1123 | {Opt_nonumtail_no, "nonumtail=0" }, /* 0 or no or false */ |
1124 | {Opt_nonumtail_no, "nonumtail=no" }, |
1125 | {Opt_nonumtail_no, "nonumtail=false" }, |
1126 | {Opt_nonumtail_yes, "nonumtail=1" }, /* empty or 1 or yes or true */ |
1127 | {Opt_nonumtail_yes, "nonumtail=yes" }, |
1128 | {Opt_nonumtail_yes, "nonumtail=true" }, |
1129 | {Opt_nonumtail_yes, "nonumtail" }, |
1130 | {Opt_rodir, "rodir" }, |
1131 | {Opt_err, NULL} |
1132 | }; |
1133 | |
1134 | static int parse_options(struct super_block *sb, char *options, int is_vfat, |
1135 | int silent, int *debug, struct fat_mount_options *opts) |
1136 | { |
1137 | char *p; |
1138 | substring_t args[MAX_OPT_ARGS]; |
1139 | int option; |
1140 | char *iocharset; |
1141 | |
1142 | opts->isvfat = is_vfat; |
1143 | |
1144 | opts->fs_uid = current_uid(); |
1145 | opts->fs_gid = current_gid(); |
1146 | opts->fs_fmask = opts->fs_dmask = current_umask(); |
1147 | opts->allow_utime = -1; |
1148 | opts->codepage = fat_default_codepage; |
1149 | fat_reset_iocharset(opts); |
1150 | if (is_vfat) { |
1151 | opts->shortname = VFAT_SFN_DISPLAY_WINNT|VFAT_SFN_CREATE_WIN95; |
1152 | opts->rodir = 0; |
1153 | } else { |
1154 | opts->shortname = 0; |
1155 | opts->rodir = 1; |
1156 | } |
1157 | opts->name_check = 'n'; |
1158 | opts->quiet = opts->showexec = opts->sys_immutable = opts->dotsOK = 0; |
1159 | opts->unicode_xlate = 0; |
1160 | opts->numtail = 1; |
1161 | opts->usefree = opts->nocase = 0; |
1162 | opts->tz_set = 0; |
1163 | opts->nfs = 0; |
1164 | opts->errors = FAT_ERRORS_RO; |
1165 | *debug = 0; |
1166 | |
1167 | opts->utf8 = IS_ENABLED(CONFIG_FAT_DEFAULT_UTF8) && is_vfat; |
1168 | |
1169 | if (!options) |
1170 | goto out; |
1171 | |
1172 | while ((p = strsep(&options, "," )) != NULL) { |
1173 | int token; |
1174 | if (!*p) |
1175 | continue; |
1176 | |
1177 | token = match_token(p, table: fat_tokens, args); |
1178 | if (token == Opt_err) { |
1179 | if (is_vfat) |
1180 | token = match_token(p, table: vfat_tokens, args); |
1181 | else |
1182 | token = match_token(p, table: msdos_tokens, args); |
1183 | } |
1184 | switch (token) { |
1185 | case Opt_check_s: |
1186 | opts->name_check = 's'; |
1187 | break; |
1188 | case Opt_check_r: |
1189 | opts->name_check = 'r'; |
1190 | break; |
1191 | case Opt_check_n: |
1192 | opts->name_check = 'n'; |
1193 | break; |
1194 | case Opt_usefree: |
1195 | opts->usefree = 1; |
1196 | break; |
1197 | case Opt_nocase: |
1198 | if (!is_vfat) |
1199 | opts->nocase = 1; |
1200 | else { |
1201 | /* for backward compatibility */ |
1202 | opts->shortname = VFAT_SFN_DISPLAY_WIN95 |
1203 | | VFAT_SFN_CREATE_WIN95; |
1204 | } |
1205 | break; |
1206 | case Opt_quiet: |
1207 | opts->quiet = 1; |
1208 | break; |
1209 | case Opt_showexec: |
1210 | opts->showexec = 1; |
1211 | break; |
1212 | case Opt_debug: |
1213 | *debug = 1; |
1214 | break; |
1215 | case Opt_immutable: |
1216 | opts->sys_immutable = 1; |
1217 | break; |
1218 | case Opt_uid: |
1219 | if (match_int(&args[0], result: &option)) |
1220 | return -EINVAL; |
1221 | opts->fs_uid = make_kuid(current_user_ns(), uid: option); |
1222 | if (!uid_valid(uid: opts->fs_uid)) |
1223 | return -EINVAL; |
1224 | break; |
1225 | case Opt_gid: |
1226 | if (match_int(&args[0], result: &option)) |
1227 | return -EINVAL; |
1228 | opts->fs_gid = make_kgid(current_user_ns(), gid: option); |
1229 | if (!gid_valid(gid: opts->fs_gid)) |
1230 | return -EINVAL; |
1231 | break; |
1232 | case Opt_umask: |
1233 | if (match_octal(&args[0], result: &option)) |
1234 | return -EINVAL; |
1235 | opts->fs_fmask = opts->fs_dmask = option; |
1236 | break; |
1237 | case Opt_dmask: |
1238 | if (match_octal(&args[0], result: &option)) |
1239 | return -EINVAL; |
1240 | opts->fs_dmask = option; |
1241 | break; |
1242 | case Opt_fmask: |
1243 | if (match_octal(&args[0], result: &option)) |
1244 | return -EINVAL; |
1245 | opts->fs_fmask = option; |
1246 | break; |
1247 | case Opt_allow_utime: |
1248 | if (match_octal(&args[0], result: &option)) |
1249 | return -EINVAL; |
1250 | opts->allow_utime = option & (S_IWGRP | S_IWOTH); |
1251 | break; |
1252 | case Opt_codepage: |
1253 | if (match_int(&args[0], result: &option)) |
1254 | return -EINVAL; |
1255 | opts->codepage = option; |
1256 | break; |
1257 | case Opt_flush: |
1258 | opts->flush = 1; |
1259 | break; |
1260 | case Opt_time_offset: |
1261 | if (match_int(&args[0], result: &option)) |
1262 | return -EINVAL; |
1263 | /* |
1264 | * GMT+-12 zones may have DST corrections so at least |
1265 | * 13 hours difference is needed. Make the limit 24 |
1266 | * just in case someone invents something unusual. |
1267 | */ |
1268 | if (option < -24 * 60 || option > 24 * 60) |
1269 | return -EINVAL; |
1270 | opts->tz_set = 1; |
1271 | opts->time_offset = option; |
1272 | break; |
1273 | case Opt_tz_utc: |
1274 | opts->tz_set = 1; |
1275 | opts->time_offset = 0; |
1276 | break; |
1277 | case Opt_err_cont: |
1278 | opts->errors = FAT_ERRORS_CONT; |
1279 | break; |
1280 | case Opt_err_panic: |
1281 | opts->errors = FAT_ERRORS_PANIC; |
1282 | break; |
1283 | case Opt_err_ro: |
1284 | opts->errors = FAT_ERRORS_RO; |
1285 | break; |
1286 | case Opt_nfs_stale_rw: |
1287 | opts->nfs = FAT_NFS_STALE_RW; |
1288 | break; |
1289 | case Opt_nfs_nostale_ro: |
1290 | opts->nfs = FAT_NFS_NOSTALE_RO; |
1291 | break; |
1292 | case Opt_dos1xfloppy: |
1293 | opts->dos1xfloppy = 1; |
1294 | break; |
1295 | |
1296 | /* msdos specific */ |
1297 | case Opt_dots: |
1298 | opts->dotsOK = 1; |
1299 | break; |
1300 | case Opt_nodots: |
1301 | opts->dotsOK = 0; |
1302 | break; |
1303 | |
1304 | /* vfat specific */ |
1305 | case Opt_charset: |
1306 | fat_reset_iocharset(opts); |
1307 | iocharset = match_strdup(&args[0]); |
1308 | if (!iocharset) |
1309 | return -ENOMEM; |
1310 | opts->iocharset = iocharset; |
1311 | break; |
1312 | case Opt_shortname_lower: |
1313 | opts->shortname = VFAT_SFN_DISPLAY_LOWER |
1314 | | VFAT_SFN_CREATE_WIN95; |
1315 | break; |
1316 | case Opt_shortname_win95: |
1317 | opts->shortname = VFAT_SFN_DISPLAY_WIN95 |
1318 | | VFAT_SFN_CREATE_WIN95; |
1319 | break; |
1320 | case Opt_shortname_winnt: |
1321 | opts->shortname = VFAT_SFN_DISPLAY_WINNT |
1322 | | VFAT_SFN_CREATE_WINNT; |
1323 | break; |
1324 | case Opt_shortname_mixed: |
1325 | opts->shortname = VFAT_SFN_DISPLAY_WINNT |
1326 | | VFAT_SFN_CREATE_WIN95; |
1327 | break; |
1328 | case Opt_utf8_no: /* 0 or no or false */ |
1329 | opts->utf8 = 0; |
1330 | break; |
1331 | case Opt_utf8_yes: /* empty or 1 or yes or true */ |
1332 | opts->utf8 = 1; |
1333 | break; |
1334 | case Opt_uni_xl_no: /* 0 or no or false */ |
1335 | opts->unicode_xlate = 0; |
1336 | break; |
1337 | case Opt_uni_xl_yes: /* empty or 1 or yes or true */ |
1338 | opts->unicode_xlate = 1; |
1339 | break; |
1340 | case Opt_nonumtail_no: /* 0 or no or false */ |
1341 | opts->numtail = 1; /* negated option */ |
1342 | break; |
1343 | case Opt_nonumtail_yes: /* empty or 1 or yes or true */ |
1344 | opts->numtail = 0; /* negated option */ |
1345 | break; |
1346 | case Opt_rodir: |
1347 | opts->rodir = 1; |
1348 | break; |
1349 | case Opt_discard: |
1350 | opts->discard = 1; |
1351 | break; |
1352 | |
1353 | /* obsolete mount options */ |
1354 | case Opt_obsolete: |
1355 | fat_msg(sb, KERN_INFO, "\"%s\" option is obsolete, " |
1356 | "not supported now" , p); |
1357 | break; |
1358 | /* unknown option */ |
1359 | default: |
1360 | if (!silent) { |
1361 | fat_msg(sb, KERN_ERR, |
1362 | "Unrecognized mount option \"%s\" " |
1363 | "or missing value" , p); |
1364 | } |
1365 | return -EINVAL; |
1366 | } |
1367 | } |
1368 | |
1369 | out: |
1370 | /* UTF-8 doesn't provide FAT semantics */ |
1371 | if (!strcmp(opts->iocharset, "utf8" )) { |
1372 | fat_msg(sb, KERN_WARNING, "utf8 is not a recommended IO charset" |
1373 | " for FAT filesystems, filesystem will be " |
1374 | "case sensitive!" ); |
1375 | } |
1376 | |
1377 | /* If user doesn't specify allow_utime, it's initialized from dmask. */ |
1378 | if (opts->allow_utime == (unsigned short)-1) |
1379 | opts->allow_utime = ~opts->fs_dmask & (S_IWGRP | S_IWOTH); |
1380 | if (opts->unicode_xlate) |
1381 | opts->utf8 = 0; |
1382 | if (opts->nfs == FAT_NFS_NOSTALE_RO) { |
1383 | sb->s_flags |= SB_RDONLY; |
1384 | sb->s_export_op = &fat_export_ops_nostale; |
1385 | } |
1386 | |
1387 | return 0; |
1388 | } |
1389 | |
1390 | static int fat_read_root(struct inode *inode) |
1391 | { |
1392 | struct msdos_sb_info *sbi = MSDOS_SB(sb: inode->i_sb); |
1393 | int error; |
1394 | |
1395 | MSDOS_I(inode)->i_pos = MSDOS_ROOT_INO; |
1396 | inode->i_uid = sbi->options.fs_uid; |
1397 | inode->i_gid = sbi->options.fs_gid; |
1398 | inode_inc_iversion(inode); |
1399 | inode->i_generation = 0; |
1400 | inode->i_mode = fat_make_mode(sbi, ATTR_DIR, S_IRWXUGO); |
1401 | inode->i_op = sbi->dir_ops; |
1402 | inode->i_fop = &fat_dir_operations; |
1403 | if (is_fat32(sbi)) { |
1404 | MSDOS_I(inode)->i_start = sbi->root_cluster; |
1405 | error = fat_calc_dir_size(inode); |
1406 | if (error < 0) |
1407 | return error; |
1408 | } else { |
1409 | MSDOS_I(inode)->i_start = 0; |
1410 | inode->i_size = sbi->dir_entries * sizeof(struct msdos_dir_entry); |
1411 | } |
1412 | inode->i_blocks = ((inode->i_size + (sbi->cluster_size - 1)) |
1413 | & ~((loff_t)sbi->cluster_size - 1)) >> 9; |
1414 | MSDOS_I(inode)->i_logstart = 0; |
1415 | MSDOS_I(inode)->mmu_private = inode->i_size; |
1416 | |
1417 | fat_save_attrs(inode, ATTR_DIR); |
1418 | inode_set_mtime_to_ts(inode, |
1419 | ts: inode_set_atime_to_ts(inode, ts: inode_set_ctime(inode, sec: 0, nsec: 0))); |
1420 | set_nlink(inode, nlink: fat_subdirs(dir: inode)+2); |
1421 | |
1422 | return 0; |
1423 | } |
1424 | |
1425 | static unsigned long calc_fat_clusters(struct super_block *sb) |
1426 | { |
1427 | struct msdos_sb_info *sbi = MSDOS_SB(sb); |
1428 | |
1429 | /* Divide first to avoid overflow */ |
1430 | if (!is_fat12(sbi)) { |
1431 | unsigned long ent_per_sec = sb->s_blocksize * 8 / sbi->fat_bits; |
1432 | return ent_per_sec * sbi->fat_length; |
1433 | } |
1434 | |
1435 | return sbi->fat_length * sb->s_blocksize * 8 / sbi->fat_bits; |
1436 | } |
1437 | |
1438 | static bool fat_bpb_is_zero(struct fat_boot_sector *b) |
1439 | { |
1440 | if (get_unaligned_le16(p: &b->sector_size)) |
1441 | return false; |
1442 | if (b->sec_per_clus) |
1443 | return false; |
1444 | if (b->reserved) |
1445 | return false; |
1446 | if (b->fats) |
1447 | return false; |
1448 | if (get_unaligned_le16(p: &b->dir_entries)) |
1449 | return false; |
1450 | if (get_unaligned_le16(p: &b->sectors)) |
1451 | return false; |
1452 | if (b->media) |
1453 | return false; |
1454 | if (b->fat_length) |
1455 | return false; |
1456 | if (b->secs_track) |
1457 | return false; |
1458 | if (b->heads) |
1459 | return false; |
1460 | return true; |
1461 | } |
1462 | |
1463 | static int fat_read_bpb(struct super_block *sb, struct fat_boot_sector *b, |
1464 | int silent, struct fat_bios_param_block *bpb) |
1465 | { |
1466 | int error = -EINVAL; |
1467 | |
1468 | /* Read in BPB ... */ |
1469 | memset(bpb, 0, sizeof(*bpb)); |
1470 | bpb->fat_sector_size = get_unaligned_le16(p: &b->sector_size); |
1471 | bpb->fat_sec_per_clus = b->sec_per_clus; |
1472 | bpb->fat_reserved = le16_to_cpu(b->reserved); |
1473 | bpb->fat_fats = b->fats; |
1474 | bpb->fat_dir_entries = get_unaligned_le16(p: &b->dir_entries); |
1475 | bpb->fat_sectors = get_unaligned_le16(p: &b->sectors); |
1476 | bpb->fat_fat_length = le16_to_cpu(b->fat_length); |
1477 | bpb->fat_total_sect = le32_to_cpu(b->total_sect); |
1478 | |
1479 | bpb->fat16_state = b->fat16.state; |
1480 | bpb->fat16_vol_id = get_unaligned_le32(p: b->fat16.vol_id); |
1481 | |
1482 | bpb->fat32_length = le32_to_cpu(b->fat32.length); |
1483 | bpb->fat32_root_cluster = le32_to_cpu(b->fat32.root_cluster); |
1484 | bpb->fat32_info_sector = le16_to_cpu(b->fat32.info_sector); |
1485 | bpb->fat32_state = b->fat32.state; |
1486 | bpb->fat32_vol_id = get_unaligned_le32(p: b->fat32.vol_id); |
1487 | |
1488 | /* Validate this looks like a FAT filesystem BPB */ |
1489 | if (!bpb->fat_reserved) { |
1490 | if (!silent) |
1491 | fat_msg(sb, KERN_ERR, |
1492 | "bogus number of reserved sectors" ); |
1493 | goto out; |
1494 | } |
1495 | if (!bpb->fat_fats) { |
1496 | if (!silent) |
1497 | fat_msg(sb, KERN_ERR, "bogus number of FAT structure" ); |
1498 | goto out; |
1499 | } |
1500 | |
1501 | /* |
1502 | * Earlier we checked here that b->secs_track and b->head are nonzero, |
1503 | * but it turns out valid FAT filesystems can have zero there. |
1504 | */ |
1505 | |
1506 | if (!fat_valid_media(media: b->media)) { |
1507 | if (!silent) |
1508 | fat_msg(sb, KERN_ERR, "invalid media value (0x%02x)" , |
1509 | (unsigned)b->media); |
1510 | goto out; |
1511 | } |
1512 | |
1513 | if (!is_power_of_2(n: bpb->fat_sector_size) |
1514 | || (bpb->fat_sector_size < 512) |
1515 | || (bpb->fat_sector_size > 4096)) { |
1516 | if (!silent) |
1517 | fat_msg(sb, KERN_ERR, "bogus logical sector size %u" , |
1518 | (unsigned)bpb->fat_sector_size); |
1519 | goto out; |
1520 | } |
1521 | |
1522 | if (!is_power_of_2(n: bpb->fat_sec_per_clus)) { |
1523 | if (!silent) |
1524 | fat_msg(sb, KERN_ERR, "bogus sectors per cluster %u" , |
1525 | (unsigned)bpb->fat_sec_per_clus); |
1526 | goto out; |
1527 | } |
1528 | |
1529 | if (bpb->fat_fat_length == 0 && bpb->fat32_length == 0) { |
1530 | if (!silent) |
1531 | fat_msg(sb, KERN_ERR, "bogus number of FAT sectors" ); |
1532 | goto out; |
1533 | } |
1534 | |
1535 | error = 0; |
1536 | |
1537 | out: |
1538 | return error; |
1539 | } |
1540 | |
1541 | static int fat_read_static_bpb(struct super_block *sb, |
1542 | struct fat_boot_sector *b, int silent, |
1543 | struct fat_bios_param_block *bpb) |
1544 | { |
1545 | static const char *notdos1x = "This doesn't look like a DOS 1.x volume" ; |
1546 | sector_t bd_sects = bdev_nr_sectors(bdev: sb->s_bdev); |
1547 | struct fat_floppy_defaults *fdefaults = NULL; |
1548 | int error = -EINVAL; |
1549 | unsigned i; |
1550 | |
1551 | /* 16-bit DOS 1.x reliably wrote bootstrap short-jmp code */ |
1552 | if (b->ignored[0] != 0xeb || b->ignored[2] != 0x90) { |
1553 | if (!silent) |
1554 | fat_msg(sb, KERN_ERR, |
1555 | "%s; no bootstrapping code" , notdos1x); |
1556 | goto out; |
1557 | } |
1558 | |
1559 | /* |
1560 | * If any value in this region is non-zero, it isn't archaic |
1561 | * DOS. |
1562 | */ |
1563 | if (!fat_bpb_is_zero(b)) { |
1564 | if (!silent) |
1565 | fat_msg(sb, KERN_ERR, |
1566 | "%s; DOS 2.x BPB is non-zero" , notdos1x); |
1567 | goto out; |
1568 | } |
1569 | |
1570 | for (i = 0; i < ARRAY_SIZE(floppy_defaults); i++) { |
1571 | if (floppy_defaults[i].nr_sectors == bd_sects) { |
1572 | fdefaults = &floppy_defaults[i]; |
1573 | break; |
1574 | } |
1575 | } |
1576 | |
1577 | if (fdefaults == NULL) { |
1578 | if (!silent) |
1579 | fat_msg(sb, KERN_WARNING, |
1580 | "This looks like a DOS 1.x volume, but isn't a recognized floppy size (%llu sectors)" , |
1581 | (u64)bd_sects); |
1582 | goto out; |
1583 | } |
1584 | |
1585 | if (!silent) |
1586 | fat_msg(sb, KERN_INFO, |
1587 | "This looks like a DOS 1.x volume; assuming default BPB values" ); |
1588 | |
1589 | memset(bpb, 0, sizeof(*bpb)); |
1590 | bpb->fat_sector_size = SECTOR_SIZE; |
1591 | bpb->fat_sec_per_clus = fdefaults->sec_per_clus; |
1592 | bpb->fat_reserved = 1; |
1593 | bpb->fat_fats = 2; |
1594 | bpb->fat_dir_entries = fdefaults->dir_entries; |
1595 | bpb->fat_sectors = fdefaults->nr_sectors; |
1596 | bpb->fat_fat_length = fdefaults->fat_length; |
1597 | |
1598 | error = 0; |
1599 | |
1600 | out: |
1601 | return error; |
1602 | } |
1603 | |
1604 | /* |
1605 | * Read the super block of an MS-DOS FS. |
1606 | */ |
1607 | int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat, |
1608 | void (*setup)(struct super_block *)) |
1609 | { |
1610 | struct inode *root_inode = NULL, *fat_inode = NULL; |
1611 | struct inode *fsinfo_inode = NULL; |
1612 | struct buffer_head *bh; |
1613 | struct fat_bios_param_block bpb; |
1614 | struct msdos_sb_info *sbi; |
1615 | u16 logical_sector_size; |
1616 | u32 total_sectors, total_clusters, fat_clusters, rootdir_sectors; |
1617 | int debug; |
1618 | long error; |
1619 | char buf[50]; |
1620 | struct timespec64 ts; |
1621 | |
1622 | /* |
1623 | * GFP_KERNEL is ok here, because while we do hold the |
1624 | * superblock lock, memory pressure can't call back into |
1625 | * the filesystem, since we're only just about to mount |
1626 | * it and have no inodes etc active! |
1627 | */ |
1628 | sbi = kzalloc(size: sizeof(struct msdos_sb_info), GFP_KERNEL); |
1629 | if (!sbi) |
1630 | return -ENOMEM; |
1631 | sb->s_fs_info = sbi; |
1632 | |
1633 | sb->s_flags |= SB_NODIRATIME; |
1634 | sb->s_magic = MSDOS_SUPER_MAGIC; |
1635 | sb->s_op = &fat_sops; |
1636 | sb->s_export_op = &fat_export_ops; |
1637 | /* |
1638 | * fat timestamps are complex and truncated by fat itself, so |
1639 | * we set 1 here to be fast |
1640 | */ |
1641 | sb->s_time_gran = 1; |
1642 | mutex_init(&sbi->nfs_build_inode_lock); |
1643 | ratelimit_state_init(rs: &sbi->ratelimit, DEFAULT_RATELIMIT_INTERVAL, |
1644 | DEFAULT_RATELIMIT_BURST); |
1645 | |
1646 | error = parse_options(sb, options: data, is_vfat: isvfat, silent, debug: &debug, opts: &sbi->options); |
1647 | if (error) |
1648 | goto out_fail; |
1649 | |
1650 | setup(sb); /* flavour-specific stuff that needs options */ |
1651 | |
1652 | error = -EIO; |
1653 | sb_min_blocksize(sb, 512); |
1654 | bh = sb_bread(sb, block: 0); |
1655 | if (bh == NULL) { |
1656 | fat_msg(sb, KERN_ERR, "unable to read boot sector" ); |
1657 | goto out_fail; |
1658 | } |
1659 | |
1660 | error = fat_read_bpb(sb, b: (struct fat_boot_sector *)bh->b_data, silent, |
1661 | bpb: &bpb); |
1662 | if (error == -EINVAL && sbi->options.dos1xfloppy) |
1663 | error = fat_read_static_bpb(sb, |
1664 | b: (struct fat_boot_sector *)bh->b_data, silent, bpb: &bpb); |
1665 | brelse(bh); |
1666 | |
1667 | if (error == -EINVAL) |
1668 | goto out_invalid; |
1669 | else if (error) |
1670 | goto out_fail; |
1671 | |
1672 | logical_sector_size = bpb.fat_sector_size; |
1673 | sbi->sec_per_clus = bpb.fat_sec_per_clus; |
1674 | |
1675 | error = -EIO; |
1676 | if (logical_sector_size < sb->s_blocksize) { |
1677 | fat_msg(sb, KERN_ERR, "logical sector size too small for device" |
1678 | " (logical sector size = %u)" , logical_sector_size); |
1679 | goto out_fail; |
1680 | } |
1681 | |
1682 | if (logical_sector_size > sb->s_blocksize) { |
1683 | struct buffer_head *bh_resize; |
1684 | |
1685 | if (!sb_set_blocksize(sb, logical_sector_size)) { |
1686 | fat_msg(sb, KERN_ERR, "unable to set blocksize %u" , |
1687 | logical_sector_size); |
1688 | goto out_fail; |
1689 | } |
1690 | |
1691 | /* Verify that the larger boot sector is fully readable */ |
1692 | bh_resize = sb_bread(sb, block: 0); |
1693 | if (bh_resize == NULL) { |
1694 | fat_msg(sb, KERN_ERR, "unable to read boot sector" |
1695 | " (logical sector size = %lu)" , |
1696 | sb->s_blocksize); |
1697 | goto out_fail; |
1698 | } |
1699 | brelse(bh: bh_resize); |
1700 | } |
1701 | |
1702 | mutex_init(&sbi->s_lock); |
1703 | sbi->cluster_size = sb->s_blocksize * sbi->sec_per_clus; |
1704 | sbi->cluster_bits = ffs(sbi->cluster_size) - 1; |
1705 | sbi->fats = bpb.fat_fats; |
1706 | sbi->fat_bits = 0; /* Don't know yet */ |
1707 | sbi->fat_start = bpb.fat_reserved; |
1708 | sbi->fat_length = bpb.fat_fat_length; |
1709 | sbi->root_cluster = 0; |
1710 | sbi->free_clusters = -1; /* Don't know yet */ |
1711 | sbi->free_clus_valid = 0; |
1712 | sbi->prev_free = FAT_START_ENT; |
1713 | sb->s_maxbytes = 0xffffffff; |
1714 | fat_time_fat2unix(sbi, ts: &ts, time: 0, cpu_to_le16(FAT_DATE_MIN), time_cs: 0); |
1715 | sb->s_time_min = ts.tv_sec; |
1716 | |
1717 | fat_time_fat2unix(sbi, ts: &ts, cpu_to_le16(FAT_TIME_MAX), |
1718 | cpu_to_le16(FAT_DATE_MAX), time_cs: 0); |
1719 | sb->s_time_max = ts.tv_sec; |
1720 | |
1721 | if (!sbi->fat_length && bpb.fat32_length) { |
1722 | struct fat_boot_fsinfo *fsinfo; |
1723 | struct buffer_head *fsinfo_bh; |
1724 | |
1725 | /* Must be FAT32 */ |
1726 | sbi->fat_bits = 32; |
1727 | sbi->fat_length = bpb.fat32_length; |
1728 | sbi->root_cluster = bpb.fat32_root_cluster; |
1729 | |
1730 | /* MC - if info_sector is 0, don't multiply by 0 */ |
1731 | sbi->fsinfo_sector = bpb.fat32_info_sector; |
1732 | if (sbi->fsinfo_sector == 0) |
1733 | sbi->fsinfo_sector = 1; |
1734 | |
1735 | fsinfo_bh = sb_bread(sb, block: sbi->fsinfo_sector); |
1736 | if (fsinfo_bh == NULL) { |
1737 | fat_msg(sb, KERN_ERR, "bread failed, FSINFO block" |
1738 | " (sector = %lu)" , sbi->fsinfo_sector); |
1739 | goto out_fail; |
1740 | } |
1741 | |
1742 | fsinfo = (struct fat_boot_fsinfo *)fsinfo_bh->b_data; |
1743 | if (!IS_FSINFO(fsinfo)) { |
1744 | fat_msg(sb, KERN_WARNING, "Invalid FSINFO signature: " |
1745 | "0x%08x, 0x%08x (sector = %lu)" , |
1746 | le32_to_cpu(fsinfo->signature1), |
1747 | le32_to_cpu(fsinfo->signature2), |
1748 | sbi->fsinfo_sector); |
1749 | } else { |
1750 | if (sbi->options.usefree) |
1751 | sbi->free_clus_valid = 1; |
1752 | sbi->free_clusters = le32_to_cpu(fsinfo->free_clusters); |
1753 | sbi->prev_free = le32_to_cpu(fsinfo->next_cluster); |
1754 | } |
1755 | |
1756 | brelse(bh: fsinfo_bh); |
1757 | } |
1758 | |
1759 | /* interpret volume ID as a little endian 32 bit integer */ |
1760 | if (is_fat32(sbi)) |
1761 | sbi->vol_id = bpb.fat32_vol_id; |
1762 | else /* fat 16 or 12 */ |
1763 | sbi->vol_id = bpb.fat16_vol_id; |
1764 | |
1765 | sbi->dir_per_block = sb->s_blocksize / sizeof(struct msdos_dir_entry); |
1766 | sbi->dir_per_block_bits = ffs(sbi->dir_per_block) - 1; |
1767 | |
1768 | sbi->dir_start = sbi->fat_start + sbi->fats * sbi->fat_length; |
1769 | sbi->dir_entries = bpb.fat_dir_entries; |
1770 | if (sbi->dir_entries & (sbi->dir_per_block - 1)) { |
1771 | if (!silent) |
1772 | fat_msg(sb, KERN_ERR, "bogus number of directory entries" |
1773 | " (%u)" , sbi->dir_entries); |
1774 | goto out_invalid; |
1775 | } |
1776 | |
1777 | rootdir_sectors = sbi->dir_entries |
1778 | * sizeof(struct msdos_dir_entry) / sb->s_blocksize; |
1779 | sbi->data_start = sbi->dir_start + rootdir_sectors; |
1780 | total_sectors = bpb.fat_sectors; |
1781 | if (total_sectors == 0) |
1782 | total_sectors = bpb.fat_total_sect; |
1783 | |
1784 | total_clusters = (total_sectors - sbi->data_start) / sbi->sec_per_clus; |
1785 | |
1786 | if (!is_fat32(sbi)) |
1787 | sbi->fat_bits = (total_clusters > MAX_FAT12) ? 16 : 12; |
1788 | |
1789 | /* some OSes set FAT_STATE_DIRTY and clean it on unmount. */ |
1790 | if (is_fat32(sbi)) |
1791 | sbi->dirty = bpb.fat32_state & FAT_STATE_DIRTY; |
1792 | else /* fat 16 or 12 */ |
1793 | sbi->dirty = bpb.fat16_state & FAT_STATE_DIRTY; |
1794 | |
1795 | /* check that FAT table does not overflow */ |
1796 | fat_clusters = calc_fat_clusters(sb); |
1797 | total_clusters = min(total_clusters, fat_clusters - FAT_START_ENT); |
1798 | if (total_clusters > max_fat(sb)) { |
1799 | if (!silent) |
1800 | fat_msg(sb, KERN_ERR, "count of clusters too big (%u)" , |
1801 | total_clusters); |
1802 | goto out_invalid; |
1803 | } |
1804 | |
1805 | sbi->max_cluster = total_clusters + FAT_START_ENT; |
1806 | /* check the free_clusters, it's not necessarily correct */ |
1807 | if (sbi->free_clusters != -1 && sbi->free_clusters > total_clusters) |
1808 | sbi->free_clusters = -1; |
1809 | /* check the prev_free, it's not necessarily correct */ |
1810 | sbi->prev_free %= sbi->max_cluster; |
1811 | if (sbi->prev_free < FAT_START_ENT) |
1812 | sbi->prev_free = FAT_START_ENT; |
1813 | |
1814 | /* set up enough so that it can read an inode */ |
1815 | fat_hash_init(sb); |
1816 | dir_hash_init(sb); |
1817 | fat_ent_access_init(sb); |
1818 | |
1819 | /* |
1820 | * The low byte of the first FAT entry must have the same value as |
1821 | * the media field of the boot sector. But in real world, too many |
1822 | * devices are writing wrong values. So, removed that validity check. |
1823 | * |
1824 | * The removed check compared the first FAT entry to a value dependent |
1825 | * on the media field like this: |
1826 | * == (0x0F00 | media), for FAT12 |
1827 | * == (0XFF00 | media), for FAT16 |
1828 | * == (0x0FFFFF | media), for FAT32 |
1829 | */ |
1830 | |
1831 | error = -EINVAL; |
1832 | sprintf(buf, fmt: "cp%d" , sbi->options.codepage); |
1833 | sbi->nls_disk = load_nls(charset: buf); |
1834 | if (!sbi->nls_disk) { |
1835 | fat_msg(sb, KERN_ERR, "codepage %s not found" , buf); |
1836 | goto out_fail; |
1837 | } |
1838 | |
1839 | /* FIXME: utf8 is using iocharset for upper/lower conversion */ |
1840 | if (sbi->options.isvfat) { |
1841 | sbi->nls_io = load_nls(charset: sbi->options.iocharset); |
1842 | if (!sbi->nls_io) { |
1843 | fat_msg(sb, KERN_ERR, "IO charset %s not found" , |
1844 | sbi->options.iocharset); |
1845 | goto out_fail; |
1846 | } |
1847 | } |
1848 | |
1849 | error = -ENOMEM; |
1850 | fat_inode = new_inode(sb); |
1851 | if (!fat_inode) |
1852 | goto out_fail; |
1853 | sbi->fat_inode = fat_inode; |
1854 | |
1855 | fsinfo_inode = new_inode(sb); |
1856 | if (!fsinfo_inode) |
1857 | goto out_fail; |
1858 | fsinfo_inode->i_ino = MSDOS_FSINFO_INO; |
1859 | sbi->fsinfo_inode = fsinfo_inode; |
1860 | insert_inode_hash(inode: fsinfo_inode); |
1861 | |
1862 | root_inode = new_inode(sb); |
1863 | if (!root_inode) |
1864 | goto out_fail; |
1865 | root_inode->i_ino = MSDOS_ROOT_INO; |
1866 | inode_set_iversion(inode: root_inode, val: 1); |
1867 | error = fat_read_root(inode: root_inode); |
1868 | if (error < 0) { |
1869 | iput(root_inode); |
1870 | goto out_fail; |
1871 | } |
1872 | error = -ENOMEM; |
1873 | insert_inode_hash(inode: root_inode); |
1874 | fat_attach(root_inode, 0); |
1875 | sb->s_root = d_make_root(root_inode); |
1876 | if (!sb->s_root) { |
1877 | fat_msg(sb, KERN_ERR, "get root inode failed" ); |
1878 | goto out_fail; |
1879 | } |
1880 | |
1881 | if (sbi->options.discard && !bdev_max_discard_sectors(bdev: sb->s_bdev)) |
1882 | fat_msg(sb, KERN_WARNING, |
1883 | "mounting with \"discard\" option, but the device does not support discard" ); |
1884 | |
1885 | fat_set_state(sb, set: 1, force: 0); |
1886 | return 0; |
1887 | |
1888 | out_invalid: |
1889 | error = -EINVAL; |
1890 | if (!silent) |
1891 | fat_msg(sb, KERN_INFO, "Can't find a valid FAT filesystem" ); |
1892 | |
1893 | out_fail: |
1894 | iput(fsinfo_inode); |
1895 | iput(fat_inode); |
1896 | unload_nls(sbi->nls_io); |
1897 | unload_nls(sbi->nls_disk); |
1898 | fat_reset_iocharset(opts: &sbi->options); |
1899 | sb->s_fs_info = NULL; |
1900 | kfree(objp: sbi); |
1901 | return error; |
1902 | } |
1903 | |
1904 | EXPORT_SYMBOL_GPL(fat_fill_super); |
1905 | |
1906 | /* |
1907 | * helper function for fat_flush_inodes. This writes both the inode |
1908 | * and the file data blocks, waiting for in flight data blocks before |
1909 | * the start of the call. It does not wait for any io started |
1910 | * during the call |
1911 | */ |
1912 | static int writeback_inode(struct inode *inode) |
1913 | { |
1914 | |
1915 | int ret; |
1916 | |
1917 | /* if we used wait=1, sync_inode_metadata waits for the io for the |
1918 | * inode to finish. So wait=0 is sent down to sync_inode_metadata |
1919 | * and filemap_fdatawrite is used for the data blocks |
1920 | */ |
1921 | ret = sync_inode_metadata(inode, wait: 0); |
1922 | if (!ret) |
1923 | ret = filemap_fdatawrite(inode->i_mapping); |
1924 | return ret; |
1925 | } |
1926 | |
1927 | /* |
1928 | * write data and metadata corresponding to i1 and i2. The io is |
1929 | * started but we do not wait for any of it to finish. |
1930 | * |
1931 | * filemap_flush is used for the block device, so if there is a dirty |
1932 | * page for a block already in flight, we will not wait and start the |
1933 | * io over again |
1934 | */ |
1935 | int fat_flush_inodes(struct super_block *sb, struct inode *i1, struct inode *i2) |
1936 | { |
1937 | int ret = 0; |
1938 | if (!MSDOS_SB(sb)->options.flush) |
1939 | return 0; |
1940 | if (i1) |
1941 | ret = writeback_inode(inode: i1); |
1942 | if (!ret && i2) |
1943 | ret = writeback_inode(inode: i2); |
1944 | if (!ret) |
1945 | ret = sync_blockdev_nowait(bdev: sb->s_bdev); |
1946 | return ret; |
1947 | } |
1948 | EXPORT_SYMBOL_GPL(fat_flush_inodes); |
1949 | |
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 | |
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_LICENSE("GPL" ); |
1979 | |