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