source: src/linux/universal/linux-3.18/fs/fat/inode.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 2 months ago

update

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