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