2019-05-19 12:08:20 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* linux/fs/fat/inode.c
|
|
|
|
*
|
|
|
|
* Written 1992,1993 by Werner Almesberger
|
|
|
|
* VFAT extensions by Gordon Chaffee, merged with msdos fs by Henrik Storner
|
|
|
|
* Rewritten for the constant inumbers support by Al Viro
|
|
|
|
*
|
|
|
|
* Fixes:
|
|
|
|
*
|
|
|
|
* Max Cohan: Fixed invalid FSINFO offset when info_sector is 0
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/pagemap.h>
|
2006-01-08 09:02:10 +00:00
|
|
|
#include <linux/mpage.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/vfs.h>
|
2015-04-16 19:47:24 +00:00
|
|
|
#include <linux/seq_file.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/parser.h>
|
2006-01-08 09:02:11 +00:00
|
|
|
#include <linux/uio.h>
|
2012-12-18 00:02:56 +00:00
|
|
|
#include <linux/blkdev.h>
|
2015-05-22 21:13:32 +00:00
|
|
|
#include <linux/backing-dev.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/unaligned.h>
|
2019-10-24 13:31:19 +00:00
|
|
|
#include <linux/random.h>
|
2017-12-11 11:35:09 +00:00
|
|
|
#include <linux/iversion.h>
|
2008-11-06 20:53:46 +00:00
|
|
|
#include "fat.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#ifndef CONFIG_FAT_DEFAULT_IOCHARSET
|
|
|
|
/* if user don't select VFAT, this is undefined. */
|
|
|
|
#define CONFIG_FAT_DEFAULT_IOCHARSET ""
|
|
|
|
#endif
|
|
|
|
|
2014-06-06 21:36:37 +00:00
|
|
|
#define KB_IN_SECTORS 2
|
|
|
|
|
2019-03-22 23:42:54 +00:00
|
|
|
/* DOS dates from 1980/1/1 through 2107/12/31 */
|
|
|
|
#define FAT_DATE_MIN (0<<9 | 1<<5 | 1)
|
|
|
|
#define FAT_DATE_MAX (127<<9 | 12<<5 | 31)
|
|
|
|
#define FAT_TIME_MAX (23<<11 | 59<<5 | 29)
|
|
|
|
|
2014-06-06 21:36:37 +00:00
|
|
|
/*
|
|
|
|
* A deserialized copy of the on-disk structure laid out in struct
|
|
|
|
* fat_boot_sector.
|
|
|
|
*/
|
|
|
|
struct fat_bios_param_block {
|
|
|
|
u16 fat_sector_size;
|
|
|
|
u8 fat_sec_per_clus;
|
|
|
|
u16 fat_reserved;
|
|
|
|
u8 fat_fats;
|
|
|
|
u16 fat_dir_entries;
|
|
|
|
u16 fat_sectors;
|
|
|
|
u16 fat_fat_length;
|
|
|
|
u32 fat_total_sect;
|
|
|
|
|
|
|
|
u8 fat16_state;
|
|
|
|
u32 fat16_vol_id;
|
|
|
|
|
|
|
|
u32 fat32_length;
|
|
|
|
u32 fat32_root_cluster;
|
|
|
|
u16 fat32_info_sector;
|
|
|
|
u8 fat32_state;
|
|
|
|
u32 fat32_vol_id;
|
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int fat_default_codepage = CONFIG_FAT_DEFAULT_CODEPAGE;
|
|
|
|
static char fat_default_iocharset[] = CONFIG_FAT_DEFAULT_IOCHARSET;
|
|
|
|
|
2014-06-06 21:36:37 +00:00
|
|
|
static struct fat_floppy_defaults {
|
|
|
|
unsigned nr_sectors;
|
|
|
|
unsigned sec_per_clus;
|
|
|
|
unsigned dir_entries;
|
|
|
|
unsigned media;
|
|
|
|
unsigned fat_length;
|
|
|
|
} floppy_defaults[] = {
|
|
|
|
{
|
|
|
|
.nr_sectors = 160 * KB_IN_SECTORS,
|
|
|
|
.sec_per_clus = 1,
|
|
|
|
.dir_entries = 64,
|
|
|
|
.media = 0xFE,
|
|
|
|
.fat_length = 1,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.nr_sectors = 180 * KB_IN_SECTORS,
|
|
|
|
.sec_per_clus = 1,
|
|
|
|
.dir_entries = 64,
|
|
|
|
.media = 0xFC,
|
|
|
|
.fat_length = 2,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.nr_sectors = 320 * KB_IN_SECTORS,
|
|
|
|
.sec_per_clus = 2,
|
|
|
|
.dir_entries = 112,
|
|
|
|
.media = 0xFF,
|
|
|
|
.fat_length = 1,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.nr_sectors = 360 * KB_IN_SECTORS,
|
|
|
|
.sec_per_clus = 2,
|
|
|
|
.dir_entries = 112,
|
|
|
|
.media = 0xFD,
|
|
|
|
.fat_length = 2,
|
|
|
|
},
|
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-01-20 22:59:41 +00:00
|
|
|
int fat_add_cluster(struct inode *inode)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int err, cluster;
|
|
|
|
|
|
|
|
err = fat_alloc_clusters(inode, &cluster, 1);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
/* FIXME: this cluster should be added after data of this
|
|
|
|
* cluster is writed */
|
|
|
|
err = fat_chain_add(inode, cluster, 1);
|
|
|
|
if (err)
|
|
|
|
fat_free_clusters(inode, cluster);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2006-09-27 08:50:45 +00:00
|
|
|
static inline int __fat_get_block(struct inode *inode, sector_t iblock,
|
|
|
|
unsigned long *max_blocks,
|
|
|
|
struct buffer_head *bh_result, int create)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct super_block *sb = inode->i_sb;
|
2006-01-08 09:02:11 +00:00
|
|
|
struct msdos_sb_info *sbi = MSDOS_SB(sb);
|
|
|
|
unsigned long mapped_blocks;
|
2016-01-20 22:59:43 +00:00
|
|
|
sector_t phys, last_block;
|
2006-01-08 09:02:11 +00:00
|
|
|
int err, offset;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-01-20 22:59:46 +00:00
|
|
|
err = fat_bmap(inode, iblock, &phys, &mapped_blocks, create, false);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
if (phys) {
|
|
|
|
map_bh(bh_result, sb, phys);
|
2006-01-08 09:02:11 +00:00
|
|
|
*max_blocks = min(mapped_blocks, *max_blocks);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (!create)
|
|
|
|
return 0;
|
2006-01-08 09:02:11 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (iblock != MSDOS_I(inode)->mmu_private >> sb->s_blocksize_bits) {
|
2009-06-03 17:34:22 +00:00
|
|
|
fat_fs_error(sb, "corrupted file size (i_pos %lld, %lld)",
|
2006-09-27 08:50:45 +00:00
|
|
|
MSDOS_I(inode)->i_pos, MSDOS_I(inode)->mmu_private);
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
2006-01-08 09:02:11 +00:00
|
|
|
|
2016-01-20 22:59:43 +00:00
|
|
|
last_block = inode->i_blocks >> (sb->s_blocksize_bits - 9);
|
2006-01-08 09:02:11 +00:00
|
|
|
offset = (unsigned long)iblock & (sbi->sec_per_clus - 1);
|
2016-01-20 22:59:43 +00:00
|
|
|
/*
|
|
|
|
* allocate a cluster according to the following.
|
|
|
|
* 1) no more available blocks
|
|
|
|
* 2) not part of fallocate region
|
|
|
|
*/
|
|
|
|
if (!offset && !(iblock < last_block)) {
|
2006-01-08 09:02:11 +00:00
|
|
|
/* TODO: multiple cluster allocation would be desirable. */
|
2005-04-16 22:20:36 +00:00
|
|
|
err = fat_add_cluster(inode);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}
|
2006-01-08 09:02:11 +00:00
|
|
|
/* available blocks on this cluster */
|
|
|
|
mapped_blocks = sbi->sec_per_clus - offset;
|
|
|
|
|
|
|
|
*max_blocks = min(mapped_blocks, *max_blocks);
|
|
|
|
MSDOS_I(inode)->mmu_private += *max_blocks << sb->s_blocksize_bits;
|
|
|
|
|
2016-01-20 22:59:46 +00:00
|
|
|
err = fat_bmap(inode, iblock, &phys, &mapped_blocks, create, false);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (err)
|
|
|
|
return err;
|
2018-06-14 22:27:21 +00:00
|
|
|
if (!phys) {
|
|
|
|
fat_fs_error(sb,
|
|
|
|
"invalid FAT chain (i_pos %lld, last_block %llu)",
|
|
|
|
MSDOS_I(inode)->i_pos,
|
|
|
|
(unsigned long long)last_block);
|
|
|
|
return -EIO;
|
|
|
|
}
|
2006-09-27 08:50:45 +00:00
|
|
|
|
2006-01-08 09:02:11 +00:00
|
|
|
BUG_ON(*max_blocks != mapped_blocks);
|
2005-04-16 22:20:36 +00:00
|
|
|
set_buffer_new(bh_result);
|
|
|
|
map_bh(bh_result, sb, phys);
|
2006-09-27 08:50:45 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-09-27 08:50:45 +00:00
|
|
|
static int fat_get_block(struct inode *inode, sector_t iblock,
|
|
|
|
struct buffer_head *bh_result, int create)
|
2006-01-08 09:02:11 +00:00
|
|
|
{
|
|
|
|
struct super_block *sb = inode->i_sb;
|
2006-03-26 09:38:02 +00:00
|
|
|
unsigned long max_blocks = bh_result->b_size >> inode->i_blkbits;
|
2006-09-27 08:50:45 +00:00
|
|
|
int err;
|
2006-01-08 09:02:11 +00:00
|
|
|
|
2006-09-27 08:50:45 +00:00
|
|
|
err = __fat_get_block(inode, iblock, &max_blocks, bh_result, create);
|
2006-01-08 09:02:11 +00:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
bh_result->b_size = max_blocks << sb->s_blocksize_bits;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int fat_writepage(struct page *page, struct writeback_control *wbc)
|
|
|
|
{
|
|
|
|
return block_write_full_page(page, fat_get_block, wbc);
|
|
|
|
}
|
|
|
|
|
2006-01-08 09:02:10 +00:00
|
|
|
static int fat_writepages(struct address_space *mapping,
|
|
|
|
struct writeback_control *wbc)
|
|
|
|
{
|
|
|
|
return mpage_writepages(mapping, wbc, fat_get_block);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int fat_readpage(struct file *file, struct page *page)
|
|
|
|
{
|
2006-01-08 09:02:10 +00:00
|
|
|
return mpage_readpage(page, fat_get_block);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fat_readpages(struct file *file, struct address_space *mapping,
|
|
|
|
struct list_head *pages, unsigned nr_pages)
|
|
|
|
{
|
|
|
|
return mpage_readpages(mapping, pages, nr_pages, fat_get_block);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2010-05-26 15:05:38 +00:00
|
|
|
static void fat_write_failed(struct address_space *mapping, loff_t to)
|
|
|
|
{
|
|
|
|
struct inode *inode = mapping->host;
|
|
|
|
|
|
|
|
if (to > inode->i_size) {
|
2013-09-12 22:13:56 +00:00
|
|
|
truncate_pagecache(inode, inode->i_size);
|
2010-05-26 15:05:38 +00:00
|
|
|
fat_truncate_blocks(inode, inode->i_size);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-16 08:25:08 +00:00
|
|
|
static int fat_write_begin(struct file *file, struct address_space *mapping,
|
|
|
|
loff_t pos, unsigned len, unsigned flags,
|
|
|
|
struct page **pagep, void **fsdata)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2010-05-26 15:05:38 +00:00
|
|
|
int err;
|
|
|
|
|
2007-10-16 08:25:08 +00:00
|
|
|
*pagep = NULL;
|
2010-06-04 09:29:55 +00:00
|
|
|
err = cont_write_begin(file, mapping, pos, len, flags,
|
2010-05-26 15:05:38 +00:00
|
|
|
pagep, fsdata, fat_get_block,
|
2007-10-16 08:25:08 +00:00
|
|
|
&MSDOS_I(mapping->host)->mmu_private);
|
2010-05-26 15:05:38 +00:00
|
|
|
if (err < 0)
|
|
|
|
fat_write_failed(mapping, pos + len);
|
|
|
|
return err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-10-16 08:25:08 +00:00
|
|
|
static int fat_write_end(struct file *file, struct address_space *mapping,
|
|
|
|
loff_t pos, unsigned len, unsigned copied,
|
|
|
|
struct page *pagep, void *fsdata)
|
2005-09-17 02:28:13 +00:00
|
|
|
{
|
2007-10-16 08:25:08 +00:00
|
|
|
struct inode *inode = mapping->host;
|
|
|
|
int err;
|
|
|
|
err = generic_write_end(file, mapping, pos, len, copied, pagep, fsdata);
|
2010-05-26 15:05:38 +00:00
|
|
|
if (err < len)
|
|
|
|
fat_write_failed(mapping, pos + len);
|
2007-10-16 08:25:08 +00:00
|
|
|
if (!(err < 0) && !(MSDOS_I(inode)->i_attrs & ATTR_ARCH)) {
|
2018-10-30 22:06:57 +00:00
|
|
|
fat_truncate_time(inode, NULL, S_CTIME|S_MTIME);
|
2005-09-17 02:28:13 +00:00
|
|
|
MSDOS_I(inode)->i_attrs |= ATTR_ARCH;
|
|
|
|
mark_inode_dirty(inode);
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2016-04-07 15:51:58 +00:00
|
|
|
static ssize_t fat_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
|
2006-01-08 09:02:11 +00:00
|
|
|
{
|
|
|
|
struct file *file = iocb->ki_filp;
|
2010-05-26 15:05:38 +00:00
|
|
|
struct address_space *mapping = file->f_mapping;
|
|
|
|
struct inode *inode = mapping->host;
|
2014-03-05 03:38:00 +00:00
|
|
|
size_t count = iov_iter_count(iter);
|
2016-04-07 15:51:58 +00:00
|
|
|
loff_t offset = iocb->ki_pos;
|
2010-05-26 15:05:38 +00:00
|
|
|
ssize_t ret;
|
2006-01-08 09:02:11 +00:00
|
|
|
|
2015-03-16 11:33:52 +00:00
|
|
|
if (iov_iter_rw(iter) == WRITE) {
|
2006-01-08 09:02:11 +00:00
|
|
|
/*
|
2008-10-29 21:00:55 +00:00
|
|
|
* FIXME: blockdev_direct_IO() doesn't use ->write_begin(),
|
2006-01-08 09:02:11 +00:00
|
|
|
* so we need to update the ->mmu_private to block boundary.
|
|
|
|
*
|
|
|
|
* But we must fill the remaining area or hole by nul for
|
|
|
|
* updating ->mmu_private.
|
2007-02-20 21:57:55 +00:00
|
|
|
*
|
|
|
|
* Return 0, and fallback to normal buffered write.
|
2006-01-08 09:02:11 +00:00
|
|
|
*/
|
2014-03-05 03:38:00 +00:00
|
|
|
loff_t size = offset + count;
|
2006-01-08 09:02:11 +00:00
|
|
|
if (MSDOS_I(inode)->mmu_private < size)
|
2007-02-20 21:57:55 +00:00
|
|
|
return 0;
|
2006-01-08 09:02:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* FAT need to use the DIO_LOCKING for avoiding the race
|
|
|
|
* condition of fat_get_block() and ->truncate().
|
|
|
|
*/
|
2016-04-07 15:51:58 +00:00
|
|
|
ret = blockdev_direct_IO(iocb, inode, iter, fat_get_block);
|
2015-03-16 11:33:52 +00:00
|
|
|
if (ret < 0 && iov_iter_rw(iter) == WRITE)
|
2014-03-05 03:38:00 +00:00
|
|
|
fat_write_failed(mapping, offset + count);
|
2010-05-26 15:05:38 +00:00
|
|
|
|
|
|
|
return ret;
|
2006-01-08 09:02:11 +00:00
|
|
|
}
|
|
|
|
|
2016-01-20 22:59:46 +00:00
|
|
|
static int fat_get_block_bmap(struct inode *inode, sector_t iblock,
|
|
|
|
struct buffer_head *bh_result, int create)
|
|
|
|
{
|
|
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
unsigned long max_blocks = bh_result->b_size >> inode->i_blkbits;
|
|
|
|
int err;
|
|
|
|
sector_t bmap;
|
|
|
|
unsigned long mapped_blocks;
|
|
|
|
|
|
|
|
BUG_ON(create != 0);
|
|
|
|
|
|
|
|
err = fat_bmap(inode, iblock, &bmap, &mapped_blocks, create, true);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (bmap) {
|
|
|
|
map_bh(bh_result, sb, bmap);
|
|
|
|
max_blocks = min(mapped_blocks, max_blocks);
|
|
|
|
}
|
|
|
|
|
|
|
|
bh_result->b_size = max_blocks << sb->s_blocksize_bits;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static sector_t _fat_bmap(struct address_space *mapping, sector_t block)
|
|
|
|
{
|
2008-11-06 20:53:56 +00:00
|
|
|
sector_t blocknr;
|
|
|
|
|
|
|
|
/* fat_get_cluster() assumes the requested blocknr isn't truncated. */
|
2011-06-24 18:29:40 +00:00
|
|
|
down_read(&MSDOS_I(mapping->host)->truncate_lock);
|
2016-01-20 22:59:46 +00:00
|
|
|
blocknr = generic_block_bmap(mapping, block, fat_get_block_bmap);
|
2011-06-24 18:29:40 +00:00
|
|
|
up_read(&MSDOS_I(mapping->host)->truncate_lock);
|
2008-11-06 20:53:56 +00:00
|
|
|
|
|
|
|
return blocknr;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2014-12-13 00:57:26 +00:00
|
|
|
/*
|
|
|
|
* fat_block_truncate_page() zeroes out a mapping from file offset `from'
|
|
|
|
* up to the end of the block which corresponds to `from'.
|
|
|
|
* This is required during truncate to physically zeroout the tail end
|
|
|
|
* of that block so it doesn't yield old data if the file is later grown.
|
|
|
|
* Also, avoid causing failure from fsx for cases of "data past EOF"
|
|
|
|
*/
|
|
|
|
int fat_block_truncate_page(struct inode *inode, loff_t from)
|
|
|
|
{
|
|
|
|
return block_truncate_page(inode->i_mapping, from, fat_get_block);
|
|
|
|
}
|
|
|
|
|
2006-06-28 11:26:44 +00:00
|
|
|
static const struct address_space_operations fat_aops = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.readpage = fat_readpage,
|
2006-01-08 09:02:10 +00:00
|
|
|
.readpages = fat_readpages,
|
2005-04-16 22:20:36 +00:00
|
|
|
.writepage = fat_writepage,
|
2006-01-08 09:02:10 +00:00
|
|
|
.writepages = fat_writepages,
|
2007-10-16 08:25:08 +00:00
|
|
|
.write_begin = fat_write_begin,
|
|
|
|
.write_end = fat_write_end,
|
2006-01-08 09:02:11 +00:00
|
|
|
.direct_IO = fat_direct_IO,
|
2005-04-16 22:20:36 +00:00
|
|
|
.bmap = _fat_bmap
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* New FAT inode stuff. We do the following:
|
|
|
|
* a) i_ino is constant and has nothing with on-disk location.
|
|
|
|
* b) FAT manages its own cache of directory entries.
|
|
|
|
* c) *This* cache is indexed by on-disk location.
|
|
|
|
* d) inode has an associated directory entry, all right, but
|
|
|
|
* it may be unhashed.
|
|
|
|
* e) currently entries are stored within struct inode. That should
|
|
|
|
* change.
|
|
|
|
* f) we deal with races in the following way:
|
|
|
|
* 1. readdir() and lookup() do FAT-dir-cache lookup.
|
|
|
|
* 2. rename() unhashes the F-d-c entry and rehashes it in
|
|
|
|
* a new place.
|
|
|
|
* 3. unlink() and rmdir() unhash F-d-c entry.
|
|
|
|
* 4. fat_write_inode() checks whether the thing is unhashed.
|
|
|
|
* If it is we silently return. If it isn't we do bread(),
|
|
|
|
* check if the location is still valid and retry if it
|
|
|
|
* isn't. Otherwise we do changes.
|
|
|
|
* 5. Spinlock is used to protect hash/unhash/location check/lookup
|
2010-06-05 23:28:32 +00:00
|
|
|
* 6. fat_evict_inode() unhashes the F-d-c entry.
|
2005-04-16 22:20:36 +00:00
|
|
|
* 7. lookup() and readdir() do igrab() if they find a F-d-c entry
|
|
|
|
* and consider negative result as cache miss.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void fat_hash_init(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct msdos_sb_info *sbi = MSDOS_SB(sb);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
spin_lock_init(&sbi->inode_hash_lock);
|
|
|
|
for (i = 0; i < FAT_HASH_SIZE; i++)
|
|
|
|
INIT_HLIST_HEAD(&sbi->inode_hashtable[i]);
|
|
|
|
}
|
|
|
|
|
2008-11-06 20:53:49 +00:00
|
|
|
static inline unsigned long fat_hash(loff_t i_pos)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-11-06 20:53:49 +00:00
|
|
|
return hash_32(i_pos, FAT_HASH_BITS);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2012-10-05 00:14:45 +00:00
|
|
|
static void dir_hash_init(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct msdos_sb_info *sbi = MSDOS_SB(sb);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
spin_lock_init(&sbi->dir_hash_lock);
|
|
|
|
for (i = 0; i < FAT_HASH_SIZE; i++)
|
|
|
|
INIT_HLIST_HEAD(&sbi->dir_hashtable[i]);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
void fat_attach(struct inode *inode, loff_t i_pos)
|
|
|
|
{
|
2008-11-06 20:53:49 +00:00
|
|
|
struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-10-05 00:14:45 +00:00
|
|
|
if (inode->i_ino != MSDOS_ROOT_INO) {
|
|
|
|
struct hlist_head *head = sbi->inode_hashtable
|
|
|
|
+ fat_hash(i_pos);
|
|
|
|
|
|
|
|
spin_lock(&sbi->inode_hash_lock);
|
|
|
|
MSDOS_I(inode)->i_pos = i_pos;
|
|
|
|
hlist_add_head(&MSDOS_I(inode)->i_fat_hash, head);
|
|
|
|
spin_unlock(&sbi->inode_hash_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If NFS support is enabled, cache the mapping of start cluster
|
|
|
|
* to directory inode. This is used during reconnection of
|
|
|
|
* dentries to the filesystem root.
|
|
|
|
*/
|
|
|
|
if (S_ISDIR(inode->i_mode) && sbi->options.nfs) {
|
|
|
|
struct hlist_head *d_head = sbi->dir_hashtable;
|
|
|
|
d_head += fat_dir_hash(MSDOS_I(inode)->i_logstart);
|
|
|
|
|
|
|
|
spin_lock(&sbi->dir_hash_lock);
|
|
|
|
hlist_add_head(&MSDOS_I(inode)->i_dir_hash, d_head);
|
|
|
|
spin_unlock(&sbi->dir_hash_lock);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-01-08 09:02:10 +00:00
|
|
|
EXPORT_SYMBOL_GPL(fat_attach);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
void fat_detach(struct inode *inode)
|
|
|
|
{
|
|
|
|
struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
|
|
|
|
spin_lock(&sbi->inode_hash_lock);
|
|
|
|
MSDOS_I(inode)->i_pos = 0;
|
|
|
|
hlist_del_init(&MSDOS_I(inode)->i_fat_hash);
|
|
|
|
spin_unlock(&sbi->inode_hash_lock);
|
2012-10-05 00:14:45 +00:00
|
|
|
|
|
|
|
if (S_ISDIR(inode->i_mode) && sbi->options.nfs) {
|
|
|
|
spin_lock(&sbi->dir_hash_lock);
|
|
|
|
hlist_del_init(&MSDOS_I(inode)->i_dir_hash);
|
|
|
|
spin_unlock(&sbi->dir_hash_lock);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-01-08 09:02:10 +00:00
|
|
|
EXPORT_SYMBOL_GPL(fat_detach);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
struct inode *fat_iget(struct super_block *sb, loff_t i_pos)
|
|
|
|
{
|
|
|
|
struct msdos_sb_info *sbi = MSDOS_SB(sb);
|
2008-11-06 20:53:49 +00:00
|
|
|
struct hlist_head *head = sbi->inode_hashtable + fat_hash(i_pos);
|
2005-04-16 22:20:36 +00:00
|
|
|
struct msdos_inode_info *i;
|
|
|
|
struct inode *inode = NULL;
|
|
|
|
|
|
|
|
spin_lock(&sbi->inode_hash_lock);
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 01:06:00 +00:00
|
|
|
hlist_for_each_entry(i, head, i_fat_hash) {
|
2005-04-16 22:20:36 +00:00
|
|
|
BUG_ON(i->vfs_inode.i_sb != sb);
|
|
|
|
if (i->i_pos != i_pos)
|
|
|
|
continue;
|
|
|
|
inode = igrab(&i->vfs_inode);
|
|
|
|
if (inode)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
spin_unlock(&sbi->inode_hash_lock);
|
|
|
|
return inode;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int is_exec(unsigned char *extension)
|
|
|
|
{
|
2014-06-06 21:36:38 +00:00
|
|
|
unsigned char exe_extensions[] = "EXECOMBAT", *walk;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
for (walk = exe_extensions; *walk; walk += 3)
|
|
|
|
if (!strncmp(extension, walk, 3))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fat_calc_dir_size(struct inode *inode)
|
|
|
|
{
|
|
|
|
struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
|
|
|
|
int ret, fclus, dclus;
|
|
|
|
|
|
|
|
inode->i_size = 0;
|
|
|
|
if (MSDOS_I(inode)->i_start == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ret = fat_get_cluster(inode, FAT_ENT_EOF, &fclus, &dclus);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
inode->i_size = (fclus + 1) << sbi->cluster_bits;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-01-20 22:59:38 +00:00
|
|
|
static int fat_validate_dir(struct inode *dir)
|
|
|
|
{
|
|
|
|
struct super_block *sb = dir->i_sb;
|
|
|
|
|
|
|
|
if (dir->i_nlink < 2) {
|
|
|
|
/* Directory should have "."/".." entries at least. */
|
|
|
|
fat_fs_error(sb, "corrupted directory (invalid entries)");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
if (MSDOS_I(dir)->i_start == 0 ||
|
|
|
|
MSDOS_I(dir)->i_start == MSDOS_SB(sb)->root_cluster) {
|
|
|
|
/* Directory should point valid cluster. */
|
|
|
|
fat_fs_error(sb, "corrupted directory (invalid i_start)");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* doesn't deal with root inode */
|
2013-04-29 23:21:14 +00:00
|
|
|
int fat_fill_inode(struct inode *inode, struct msdos_dir_entry *de)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
|
|
|
|
int error;
|
|
|
|
|
|
|
|
MSDOS_I(inode)->i_pos = 0;
|
|
|
|
inode->i_uid = sbi->options.fs_uid;
|
|
|
|
inode->i_gid = sbi->options.fs_gid;
|
2017-12-11 11:35:09 +00:00
|
|
|
inode_inc_iversion(inode);
|
2019-10-24 13:31:19 +00:00
|
|
|
inode->i_generation = prandom_u32();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if ((de->attr & ATTR_DIR) && !IS_FREE(de->name)) {
|
|
|
|
inode->i_generation &= ~1;
|
2008-11-06 20:53:54 +00:00
|
|
|
inode->i_mode = fat_make_mode(sbi, de->attr, S_IRWXUGO);
|
2005-04-16 22:20:36 +00:00
|
|
|
inode->i_op = sbi->dir_ops;
|
|
|
|
inode->i_fop = &fat_dir_operations;
|
|
|
|
|
2012-07-30 21:42:13 +00:00
|
|
|
MSDOS_I(inode)->i_start = fat_get_start(sbi, de);
|
2005-04-16 22:20:36 +00:00
|
|
|
MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start;
|
|
|
|
error = fat_calc_dir_size(inode);
|
|
|
|
if (error < 0)
|
|
|
|
return error;
|
|
|
|
MSDOS_I(inode)->mmu_private = inode->i_size;
|
|
|
|
|
2011-10-28 12:13:29 +00:00
|
|
|
set_nlink(inode, fat_subdirs(inode));
|
2016-01-20 22:59:38 +00:00
|
|
|
|
|
|
|
error = fat_validate_dir(inode);
|
|
|
|
if (error < 0)
|
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
} else { /* not a directory */
|
|
|
|
inode->i_generation |= 1;
|
2008-11-06 20:53:54 +00:00
|
|
|
inode->i_mode = fat_make_mode(sbi, de->attr,
|
|
|
|
((sbi->options.showexec && !is_exec(de->name + 8))
|
|
|
|
? S_IRUGO|S_IWUGO : S_IRWXUGO));
|
2012-07-30 21:42:13 +00:00
|
|
|
MSDOS_I(inode)->i_start = fat_get_start(sbi, de);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start;
|
|
|
|
inode->i_size = le32_to_cpu(de->size);
|
|
|
|
inode->i_op = &fat_file_inode_operations;
|
|
|
|
inode->i_fop = &fat_file_operations;
|
|
|
|
inode->i_mapping->a_ops = &fat_aops;
|
|
|
|
MSDOS_I(inode)->mmu_private = inode->i_size;
|
|
|
|
}
|
|
|
|
if (de->attr & ATTR_SYS) {
|
|
|
|
if (sbi->options.sys_immutable)
|
|
|
|
inode->i_flags |= S_IMMUTABLE;
|
|
|
|
}
|
2008-11-06 20:53:54 +00:00
|
|
|
fat_save_attrs(inode, de->attr);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
inode->i_blocks = ((inode->i_size + (sbi->cluster_size - 1))
|
|
|
|
& ~((loff_t)sbi->cluster_size - 1)) >> 9;
|
2008-11-06 20:53:47 +00:00
|
|
|
|
2018-08-22 04:59:48 +00:00
|
|
|
fat_time_fat2unix(sbi, &inode->i_mtime, de->time, de->date, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (sbi->options.isvfat) {
|
2018-08-22 04:59:48 +00:00
|
|
|
fat_time_fat2unix(sbi, &inode->i_ctime, de->ctime,
|
2008-11-06 20:53:47 +00:00
|
|
|
de->cdate, de->ctime_cs);
|
2018-08-22 04:59:48 +00:00
|
|
|
fat_time_fat2unix(sbi, &inode->i_atime, 0, de->adate, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else
|
2018-10-30 22:06:57 +00:00
|
|
|
fat_truncate_time(inode, &inode->i_mtime, S_ATIME|S_CTIME);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-04-29 23:21:12 +00:00
|
|
|
static inline void fat_lock_build_inode(struct msdos_sb_info *sbi)
|
|
|
|
{
|
|
|
|
if (sbi->options.nfs == FAT_NFS_NOSTALE_RO)
|
|
|
|
mutex_lock(&sbi->nfs_build_inode_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void fat_unlock_build_inode(struct msdos_sb_info *sbi)
|
|
|
|
{
|
|
|
|
if (sbi->options.nfs == FAT_NFS_NOSTALE_RO)
|
|
|
|
mutex_unlock(&sbi->nfs_build_inode_lock);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct inode *fat_build_inode(struct super_block *sb,
|
|
|
|
struct msdos_dir_entry *de, loff_t i_pos)
|
|
|
|
{
|
|
|
|
struct inode *inode;
|
|
|
|
int err;
|
|
|
|
|
2013-04-29 23:21:12 +00:00
|
|
|
fat_lock_build_inode(MSDOS_SB(sb));
|
2005-04-16 22:20:36 +00:00
|
|
|
inode = fat_iget(sb, i_pos);
|
|
|
|
if (inode)
|
|
|
|
goto out;
|
|
|
|
inode = new_inode(sb);
|
|
|
|
if (!inode) {
|
|
|
|
inode = ERR_PTR(-ENOMEM);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
inode->i_ino = iunique(sb, MSDOS_ROOT_INO);
|
2017-12-11 11:35:09 +00:00
|
|
|
inode_set_iversion(inode, 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
err = fat_fill_inode(inode, de);
|
|
|
|
if (err) {
|
|
|
|
iput(inode);
|
|
|
|
inode = ERR_PTR(err);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
fat_attach(inode, i_pos);
|
|
|
|
insert_inode_hash(inode);
|
|
|
|
out:
|
2013-04-29 23:21:12 +00:00
|
|
|
fat_unlock_build_inode(MSDOS_SB(sb));
|
2005-04-16 22:20:36 +00:00
|
|
|
return inode;
|
|
|
|
}
|
|
|
|
|
2006-01-08 09:02:10 +00:00
|
|
|
EXPORT_SYMBOL_GPL(fat_build_inode);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-01-20 22:59:41 +00:00
|
|
|
static int __fat_write_inode(struct inode *inode, int wait);
|
|
|
|
|
|
|
|
static void fat_free_eofblocks(struct inode *inode)
|
|
|
|
{
|
|
|
|
/* Release unwritten fallocated blocks on inode eviction. */
|
|
|
|
if ((inode->i_blocks << 9) >
|
|
|
|
round_up(MSDOS_I(inode)->mmu_private,
|
|
|
|
MSDOS_SB(inode->i_sb)->cluster_size)) {
|
|
|
|
int err;
|
|
|
|
|
|
|
|
fat_truncate_blocks(inode, MSDOS_I(inode)->mmu_private);
|
|
|
|
/* Fallocate results in updating the i_start/iogstart
|
|
|
|
* for the zero byte file. So, make it return to
|
|
|
|
* original state during evict and commit it to avoid
|
|
|
|
* any corruption on the next access to the cluster
|
|
|
|
* chain for the file.
|
|
|
|
*/
|
|
|
|
err = __fat_write_inode(inode, inode_needs_sync(inode));
|
|
|
|
if (err) {
|
|
|
|
fat_msg(inode->i_sb, KERN_WARNING, "Failed to "
|
|
|
|
"update on disk inode for unused "
|
|
|
|
"fallocated blocks, inode could be "
|
|
|
|
"corrupted. Please run fsck");
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-06-05 23:28:32 +00:00
|
|
|
static void fat_evict_inode(struct inode *inode)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2014-04-03 21:47:49 +00:00
|
|
|
truncate_inode_pages_final(&inode->i_data);
|
2010-06-05 23:28:32 +00:00
|
|
|
if (!inode->i_nlink) {
|
|
|
|
inode->i_size = 0;
|
|
|
|
fat_truncate_blocks(inode, 0);
|
2016-01-20 22:59:41 +00:00
|
|
|
} else
|
|
|
|
fat_free_eofblocks(inode);
|
|
|
|
|
2010-06-05 23:28:32 +00:00
|
|
|
invalidate_inode_buffers(inode);
|
2012-05-03 12:48:02 +00:00
|
|
|
clear_inode(inode);
|
2005-04-16 22:20:36 +00:00
|
|
|
fat_cache_inval_inode(inode);
|
2008-11-06 20:53:50 +00:00
|
|
|
fat_detach(inode);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-02-28 01:03:09 +00:00
|
|
|
static void fat_set_state(struct super_block *sb,
|
|
|
|
unsigned int set, unsigned int force)
|
|
|
|
{
|
|
|
|
struct buffer_head *bh;
|
|
|
|
struct fat_boot_sector *b;
|
2015-02-17 21:45:36 +00:00
|
|
|
struct msdos_sb_info *sbi = MSDOS_SB(sb);
|
2013-02-28 01:03:09 +00:00
|
|
|
|
|
|
|
/* do not change any thing if mounted read only */
|
2017-07-17 07:45:34 +00:00
|
|
|
if (sb_rdonly(sb) && !force)
|
2013-02-28 01:03:09 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* do not change state if fs was dirty */
|
|
|
|
if (sbi->dirty) {
|
|
|
|
/* warn only on set (mount). */
|
|
|
|
if (set)
|
|
|
|
fat_msg(sb, KERN_WARNING, "Volume was not properly "
|
|
|
|
"unmounted. Some data may be corrupt. "
|
|
|
|
"Please run fsck.");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
bh = sb_bread(sb, 0);
|
|
|
|
if (bh == NULL) {
|
|
|
|
fat_msg(sb, KERN_ERR, "unable to read boot sector "
|
|
|
|
"to mark fs as dirty");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
b = (struct fat_boot_sector *) bh->b_data;
|
|
|
|
|
2019-01-03 23:28:00 +00:00
|
|
|
if (is_fat32(sbi)) {
|
2013-02-28 01:03:09 +00:00
|
|
|
if (set)
|
|
|
|
b->fat32.state |= FAT_STATE_DIRTY;
|
|
|
|
else
|
|
|
|
b->fat32.state &= ~FAT_STATE_DIRTY;
|
|
|
|
} else /* fat 16 and 12 */ {
|
|
|
|
if (set)
|
|
|
|
b->fat16.state |= FAT_STATE_DIRTY;
|
|
|
|
else
|
|
|
|
b->fat16.state &= ~FAT_STATE_DIRTY;
|
|
|
|
}
|
|
|
|
|
|
|
|
mark_buffer_dirty(bh);
|
|
|
|
sync_dirty_buffer(bh);
|
|
|
|
brelse(bh);
|
|
|
|
}
|
|
|
|
|
2018-07-21 00:53:42 +00:00
|
|
|
static void fat_reset_iocharset(struct fat_mount_options *opts)
|
|
|
|
{
|
|
|
|
if (opts->iocharset != fat_default_iocharset) {
|
|
|
|
/* Note: opts->iocharset can be NULL here */
|
|
|
|
kfree(opts->iocharset);
|
|
|
|
opts->iocharset = fat_default_iocharset;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-10-03 17:16:50 +00:00
|
|
|
static void delayed_free(struct rcu_head *p)
|
|
|
|
{
|
|
|
|
struct msdos_sb_info *sbi = container_of(p, struct msdos_sb_info, rcu);
|
|
|
|
unload_nls(sbi->nls_disk);
|
|
|
|
unload_nls(sbi->nls_io);
|
2018-07-21 00:53:42 +00:00
|
|
|
fat_reset_iocharset(&sbi->options);
|
2013-10-03 17:16:50 +00:00
|
|
|
kfree(sbi);
|
|
|
|
}
|
|
|
|
|
2006-01-08 09:02:08 +00:00
|
|
|
static void fat_put_super(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct msdos_sb_info *sbi = MSDOS_SB(sb);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-02-28 01:03:09 +00:00
|
|
|
fat_set_state(sb, 0, 0);
|
|
|
|
|
2012-05-31 23:26:12 +00:00
|
|
|
iput(sbi->fsinfo_inode);
|
2009-06-07 17:44:36 +00:00
|
|
|
iput(sbi->fat_inode);
|
|
|
|
|
2013-10-03 17:16:50 +00:00
|
|
|
call_rcu(&sbi->rcu, delayed_free);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-12-07 04:33:20 +00:00
|
|
|
static struct kmem_cache *fat_inode_cachep;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static struct inode *fat_alloc_inode(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct msdos_inode_info *ei;
|
2008-05-20 02:53:01 +00:00
|
|
|
ei = kmem_cache_alloc(fat_inode_cachep, GFP_NOFS);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!ei)
|
|
|
|
return NULL;
|
2011-06-24 18:29:40 +00:00
|
|
|
|
|
|
|
init_rwsem(&ei->truncate_lock);
|
2020-03-06 06:28:36 +00:00
|
|
|
/* Zeroing to allow iput() even if partial initialized inode. */
|
|
|
|
ei->mmu_private = 0;
|
|
|
|
ei->i_start = 0;
|
|
|
|
ei->i_logstart = 0;
|
|
|
|
ei->i_attrs = 0;
|
|
|
|
ei->i_pos = 0;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return &ei->vfs_inode;
|
|
|
|
}
|
|
|
|
|
2019-04-15 23:29:56 +00:00
|
|
|
static void fat_free_inode(struct inode *inode)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
kmem_cache_free(fat_inode_cachep, MSDOS_I(inode));
|
|
|
|
}
|
|
|
|
|
2008-07-26 02:45:34 +00:00
|
|
|
static void init_once(void *foo)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct msdos_inode_info *ei = (struct msdos_inode_info *)foo;
|
|
|
|
|
2007-05-17 05:10:57 +00:00
|
|
|
spin_lock_init(&ei->cache_lru_lock);
|
|
|
|
ei->nr_caches = 0;
|
|
|
|
ei->cache_valid_id = FAT_CACHE_VALID + 1;
|
|
|
|
INIT_LIST_HEAD(&ei->cache_lru);
|
|
|
|
INIT_HLIST_NODE(&ei->i_fat_hash);
|
2012-10-05 00:14:45 +00:00
|
|
|
INIT_HLIST_NODE(&ei->i_dir_hash);
|
2007-05-17 05:10:57 +00:00
|
|
|
inode_init_once(&ei->vfs_inode);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int __init fat_init_inodecache(void)
|
|
|
|
{
|
|
|
|
fat_inode_cachep = kmem_cache_create("fat_inode_cache",
|
|
|
|
sizeof(struct msdos_inode_info),
|
2006-03-24 11:16:06 +00:00
|
|
|
0, (SLAB_RECLAIM_ACCOUNT|
|
2016-01-14 23:18:21 +00:00
|
|
|
SLAB_MEM_SPREAD|SLAB_ACCOUNT),
|
2007-07-20 01:11:58 +00:00
|
|
|
init_once);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (fat_inode_cachep == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit fat_destroy_inodecache(void)
|
|
|
|
{
|
2012-09-26 01:33:07 +00:00
|
|
|
/*
|
|
|
|
* Make sure all delayed rcu free inodes are flushed before we
|
|
|
|
* destroy cache.
|
|
|
|
*/
|
|
|
|
rcu_barrier();
|
2006-09-27 08:49:40 +00:00
|
|
|
kmem_cache_destroy(fat_inode_cachep);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int fat_remount(struct super_block *sb, int *flags, char *data)
|
|
|
|
{
|
2017-11-30 00:11:19 +00:00
|
|
|
bool new_rdonly;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct msdos_sb_info *sbi = MSDOS_SB(sb);
|
2017-11-27 21:05:09 +00:00
|
|
|
*flags |= SB_NODIRATIME | (sbi->options.isvfat ? 0 : SB_NOATIME);
|
2013-02-28 01:03:09 +00:00
|
|
|
|
2014-03-13 14:14:33 +00:00
|
|
|
sync_filesystem(sb);
|
|
|
|
|
2013-02-28 01:03:09 +00:00
|
|
|
/* make sure we update state on remount. */
|
2017-11-27 21:05:09 +00:00
|
|
|
new_rdonly = *flags & SB_RDONLY;
|
2017-07-17 07:45:34 +00:00
|
|
|
if (new_rdonly != sb_rdonly(sb)) {
|
2013-02-28 01:03:09 +00:00
|
|
|
if (new_rdonly)
|
|
|
|
fat_set_state(sb, 0, 0);
|
|
|
|
else
|
|
|
|
fat_set_state(sb, 1, 1);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-06-23 09:02:58 +00:00
|
|
|
static int fat_statfs(struct dentry *dentry, struct kstatfs *buf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-04-02 23:59:35 +00:00
|
|
|
struct super_block *sb = dentry->d_sb;
|
|
|
|
struct msdos_sb_info *sbi = MSDOS_SB(sb);
|
|
|
|
u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* If the count of free cluster is still unknown, counts it here. */
|
2008-04-28 09:16:27 +00:00
|
|
|
if (sbi->free_clusters == -1 || !sbi->free_clus_valid) {
|
2006-06-23 09:02:58 +00:00
|
|
|
int err = fat_count_free_clusters(dentry->d_sb);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2006-06-23 09:02:58 +00:00
|
|
|
buf->f_type = dentry->d_sb->s_magic;
|
2005-04-16 22:20:36 +00:00
|
|
|
buf->f_bsize = sbi->cluster_size;
|
|
|
|
buf->f_blocks = sbi->max_cluster - FAT_START_ENT;
|
|
|
|
buf->f_bfree = sbi->free_clusters;
|
|
|
|
buf->f_bavail = sbi->free_clusters;
|
2009-04-02 23:59:35 +00:00
|
|
|
buf->f_fsid.val[0] = (u32)id;
|
|
|
|
buf->f_fsid.val[1] = (u32)(id >> 32);
|
2011-04-12 12:08:39 +00:00
|
|
|
buf->f_namelen =
|
|
|
|
(sbi->options.isvfat ? FAT_LFN_LEN : 12) * NLS_MAX_CHARSET_SIZE;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-03-05 08:21:37 +00:00
|
|
|
static int __fat_write_inode(struct inode *inode, int wait)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
struct msdos_sb_info *sbi = MSDOS_SB(sb);
|
|
|
|
struct buffer_head *bh;
|
|
|
|
struct msdos_dir_entry *raw_entry;
|
|
|
|
loff_t i_pos;
|
2013-04-29 23:21:10 +00:00
|
|
|
sector_t blocknr;
|
|
|
|
int err, offset;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-11-06 20:53:57 +00:00
|
|
|
if (inode->i_ino == MSDOS_ROOT_INO)
|
|
|
|
return 0;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
retry:
|
2008-11-06 20:53:57 +00:00
|
|
|
i_pos = fat_i_pos_read(sbi, inode);
|
|
|
|
if (!i_pos)
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
|
2013-04-29 23:21:10 +00:00
|
|
|
fat_get_blknr_offset(sbi, i_pos, &blocknr, &offset);
|
|
|
|
bh = sb_bread(sb, blocknr);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!bh) {
|
2011-04-12 12:08:38 +00:00
|
|
|
fat_msg(sb, KERN_ERR, "unable to read inode block "
|
|
|
|
"for updating (i_pos %lld)", i_pos);
|
vfat: fix 'sync' mount deadlock due to BKL->lock_super conversion
There was another FAT BKL conversion deadlock reported by Bart
Trojanowski due to the BKL being used as a recursive lock by FAT, which
was missed because it only triggers with 'sync' (or 'dirsync') mounts.
The recursion worked for the BKL, but after the conversion to lock_super
(which uses a mutex), it just deadlocks.
Thanks to Bart for debugging this and testing the fix. The lock
debugging information from the original report:
=============================================
[ INFO: possible recursive locking detected ]
2.6.27-rc3-bisect-00448-ga7f5aaf #16
---------------------------------------------
mv/4020 is trying to acquire lock:
(&type->s_lock_key#9){--..}, at: [<c01a90fe>] lock_super+0x1e/0x20
but task is already holding lock:
(&type->s_lock_key#9){--..}, at: [<c01a90fe>] lock_super+0x1e/0x20
other info that might help us debug this:
3 locks held by mv/4020:
#0: (&sb->s_type->i_mutex_key#9/1){--..}, at: [<c01b2336>] do_unlinkat+0x66/0x140
#1: (&sb->s_type->i_mutex_key#9){--..}, at: [<c01b0954>] vfs_unlink+0x84/0x110
#2: (&type->s_lock_key#9){--..}, at: [<c01a90fe>] lock_super+0x1e/0x20
stack backtrace:
Pid: 4020, comm: mv Not tainted 2.6.27-rc3-bisect-00448-ga7f5aaf #16
[<c014e694>] validate_chain+0x984/0xea0
[<c0108d70>] ? native_sched_clock+0x0/0xf0
[<c014ee9c>] __lock_acquire+0x2ec/0x9b0
[<c014f5cf>] lock_acquire+0x6f/0x90
[<c01a90fe>] ? lock_super+0x1e/0x20
[<c044e5fd>] mutex_lock_nested+0xad/0x300
[<c01a90fe>] ? lock_super+0x1e/0x20
[<c01a90fe>] ? lock_super+0x1e/0x20
[<c01a90fe>] lock_super+0x1e/0x20
[<f8b3a700>] fat_write_inode+0x60/0x2b0 [fat]
[<c0450878>] ? _spin_unlock_irqrestore+0x48/0x80
[<f8b3a953>] ? fat_sync_inode+0x3/0x20 [fat]
[<f8b3a962>] fat_sync_inode+0x12/0x20 [fat]
[<f8b37c7e>] fat_remove_entries+0xbe/0x120 [fat]
[<f8b422ef>] vfat_unlink+0x5f/0x90 [vfat]
[<f8b42290>] ? vfat_unlink+0x0/0x90 [vfat]
[<c01b0968>] vfs_unlink+0x98/0x110
[<c01b2400>] do_unlinkat+0x130/0x140
[<c016a8f5>] ? audit_syscall_entry+0x105/0x150
[<c01b253b>] sys_unlinkat+0x3b/0x40
[<c01040d3>] sysenter_do_call+0x12/0x3f
=======================
where the deadlock is due to the nesting of lock_super from vfat_unlink
to fat_write_inode:
- do_unlinkat
- vfs_unlink
- vfat_unlink
* lock_super
- fat_remove_entries
- fat_sync_inode
- fat_write_inode
* lock_super
and the fix is to simply remove the use of lock_super() in fat_write_inode.
The lock_super() there had been just an automatic conversion of the
kernel lock to the superblock lock, but no locking was actually needed
there, since the code in fat_write_inode already protected all relevant
accesses with a spinlock (sbi->inode_hash_lock to be exact). The only
code inside the BKL (and thus the superblock lock) was accesses tp local
variables or calls to functions that have long been SMP-safe (i.e.
sb_bread, mark_buffe_dirty and brlese).
Bart reports:
"Looks good. I ran 10 parallel processes creating 1M files truncating
them, writing to them again and then deleting them. This patch fixes
the issue I ran into.
Signed-off-by: Bart Trojanowski <bart@jukie.net>"
Reported-and-tested-by: Bart Trojanowski <bart@jukie.net>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-08-20 15:31:19 +00:00
|
|
|
return -EIO;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
spin_lock(&sbi->inode_hash_lock);
|
|
|
|
if (i_pos != MSDOS_I(inode)->i_pos) {
|
|
|
|
spin_unlock(&sbi->inode_hash_lock);
|
|
|
|
brelse(bh);
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
|
2013-04-29 23:21:10 +00:00
|
|
|
raw_entry = &((struct msdos_dir_entry *) (bh->b_data))[offset];
|
2005-04-16 22:20:36 +00:00
|
|
|
if (S_ISDIR(inode->i_mode))
|
|
|
|
raw_entry->size = 0;
|
|
|
|
else
|
|
|
|
raw_entry->size = cpu_to_le32(inode->i_size);
|
2008-11-06 20:53:54 +00:00
|
|
|
raw_entry->attr = fat_make_attrs(inode);
|
2012-07-30 21:42:13 +00:00
|
|
|
fat_set_start(raw_entry, MSDOS_I(inode)->i_logstart);
|
2018-08-22 04:59:48 +00:00
|
|
|
fat_time_unix2fat(sbi, &inode->i_mtime, &raw_entry->time,
|
2008-11-06 20:53:47 +00:00
|
|
|
&raw_entry->date, NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (sbi->options.isvfat) {
|
2005-09-21 16:55:45 +00:00
|
|
|
__le16 atime;
|
2018-08-22 04:59:48 +00:00
|
|
|
fat_time_unix2fat(sbi, &inode->i_ctime, &raw_entry->ctime,
|
2008-11-06 20:53:47 +00:00
|
|
|
&raw_entry->cdate, &raw_entry->ctime_cs);
|
2018-08-22 04:59:48 +00:00
|
|
|
fat_time_unix2fat(sbi, &inode->i_atime, &atime,
|
2008-11-06 20:53:47 +00:00
|
|
|
&raw_entry->adate, NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
spin_unlock(&sbi->inode_hash_lock);
|
|
|
|
mark_buffer_dirty(bh);
|
vfat: fix 'sync' mount deadlock due to BKL->lock_super conversion
There was another FAT BKL conversion deadlock reported by Bart
Trojanowski due to the BKL being used as a recursive lock by FAT, which
was missed because it only triggers with 'sync' (or 'dirsync') mounts.
The recursion worked for the BKL, but after the conversion to lock_super
(which uses a mutex), it just deadlocks.
Thanks to Bart for debugging this and testing the fix. The lock
debugging information from the original report:
=============================================
[ INFO: possible recursive locking detected ]
2.6.27-rc3-bisect-00448-ga7f5aaf #16
---------------------------------------------
mv/4020 is trying to acquire lock:
(&type->s_lock_key#9){--..}, at: [<c01a90fe>] lock_super+0x1e/0x20
but task is already holding lock:
(&type->s_lock_key#9){--..}, at: [<c01a90fe>] lock_super+0x1e/0x20
other info that might help us debug this:
3 locks held by mv/4020:
#0: (&sb->s_type->i_mutex_key#9/1){--..}, at: [<c01b2336>] do_unlinkat+0x66/0x140
#1: (&sb->s_type->i_mutex_key#9){--..}, at: [<c01b0954>] vfs_unlink+0x84/0x110
#2: (&type->s_lock_key#9){--..}, at: [<c01a90fe>] lock_super+0x1e/0x20
stack backtrace:
Pid: 4020, comm: mv Not tainted 2.6.27-rc3-bisect-00448-ga7f5aaf #16
[<c014e694>] validate_chain+0x984/0xea0
[<c0108d70>] ? native_sched_clock+0x0/0xf0
[<c014ee9c>] __lock_acquire+0x2ec/0x9b0
[<c014f5cf>] lock_acquire+0x6f/0x90
[<c01a90fe>] ? lock_super+0x1e/0x20
[<c044e5fd>] mutex_lock_nested+0xad/0x300
[<c01a90fe>] ? lock_super+0x1e/0x20
[<c01a90fe>] ? lock_super+0x1e/0x20
[<c01a90fe>] lock_super+0x1e/0x20
[<f8b3a700>] fat_write_inode+0x60/0x2b0 [fat]
[<c0450878>] ? _spin_unlock_irqrestore+0x48/0x80
[<f8b3a953>] ? fat_sync_inode+0x3/0x20 [fat]
[<f8b3a962>] fat_sync_inode+0x12/0x20 [fat]
[<f8b37c7e>] fat_remove_entries+0xbe/0x120 [fat]
[<f8b422ef>] vfat_unlink+0x5f/0x90 [vfat]
[<f8b42290>] ? vfat_unlink+0x0/0x90 [vfat]
[<c01b0968>] vfs_unlink+0x98/0x110
[<c01b2400>] do_unlinkat+0x130/0x140
[<c016a8f5>] ? audit_syscall_entry+0x105/0x150
[<c01b253b>] sys_unlinkat+0x3b/0x40
[<c01040d3>] sysenter_do_call+0x12/0x3f
=======================
where the deadlock is due to the nesting of lock_super from vfat_unlink
to fat_write_inode:
- do_unlinkat
- vfs_unlink
- vfat_unlink
* lock_super
- fat_remove_entries
- fat_sync_inode
- fat_write_inode
* lock_super
and the fix is to simply remove the use of lock_super() in fat_write_inode.
The lock_super() there had been just an automatic conversion of the
kernel lock to the superblock lock, but no locking was actually needed
there, since the code in fat_write_inode already protected all relevant
accesses with a spinlock (sbi->inode_hash_lock to be exact). The only
code inside the BKL (and thus the superblock lock) was accesses tp local
variables or calls to functions that have long been SMP-safe (i.e.
sb_bread, mark_buffe_dirty and brlese).
Bart reports:
"Looks good. I ran 10 parallel processes creating 1M files truncating
them, writing to them again and then deleting them. This patch fixes
the issue I ran into.
Signed-off-by: Bart Trojanowski <bart@jukie.net>"
Reported-and-tested-by: Bart Trojanowski <bart@jukie.net>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-08-20 15:31:19 +00:00
|
|
|
err = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (wait)
|
|
|
|
err = sync_dirty_buffer(bh);
|
|
|
|
brelse(bh);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2010-03-05 08:21:37 +00:00
|
|
|
static int fat_write_inode(struct inode *inode, struct writeback_control *wbc)
|
|
|
|
{
|
2012-05-31 23:26:13 +00:00
|
|
|
int err;
|
|
|
|
|
|
|
|
if (inode->i_ino == MSDOS_FSINFO_INO) {
|
|
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
|
2012-10-06 10:40:03 +00:00
|
|
|
mutex_lock(&MSDOS_SB(sb)->s_lock);
|
2012-05-31 23:26:13 +00:00
|
|
|
err = fat_clusters_flush(sb);
|
2012-10-06 10:40:03 +00:00
|
|
|
mutex_unlock(&MSDOS_SB(sb)->s_lock);
|
2012-05-31 23:26:13 +00:00
|
|
|
} else
|
|
|
|
err = __fat_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
|
|
|
|
|
|
|
|
return err;
|
2010-03-05 08:21:37 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
int fat_sync_inode(struct inode *inode)
|
|
|
|
{
|
2010-03-05 08:21:37 +00:00
|
|
|
return __fat_write_inode(inode, 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-01-08 09:02:10 +00:00
|
|
|
EXPORT_SYMBOL_GPL(fat_sync_inode);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-12-09 02:32:45 +00:00
|
|
|
static int fat_show_options(struct seq_file *m, struct dentry *root);
|
2007-02-12 08:55:41 +00:00
|
|
|
static const struct super_operations fat_sops = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.alloc_inode = fat_alloc_inode,
|
2019-04-15 23:29:56 +00:00
|
|
|
.free_inode = fat_free_inode,
|
2005-04-16 22:20:36 +00:00
|
|
|
.write_inode = fat_write_inode,
|
2010-06-05 23:28:32 +00:00
|
|
|
.evict_inode = fat_evict_inode,
|
2005-04-16 22:20:36 +00:00
|
|
|
.put_super = fat_put_super,
|
|
|
|
.statfs = fat_statfs,
|
|
|
|
.remount_fs = fat_remount,
|
|
|
|
|
|
|
|
.show_options = fat_show_options,
|
|
|
|
};
|
|
|
|
|
2011-12-09 02:32:45 +00:00
|
|
|
static int fat_show_options(struct seq_file *m, struct dentry *root)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2011-12-09 02:32:45 +00:00
|
|
|
struct msdos_sb_info *sbi = MSDOS_SB(root->d_sb);
|
2005-04-16 22:20:36 +00:00
|
|
|
struct fat_mount_options *opts = &sbi->options;
|
|
|
|
int isvfat = opts->isvfat;
|
|
|
|
|
2012-02-08 00:25:39 +00:00
|
|
|
if (!uid_eq(opts->fs_uid, GLOBAL_ROOT_UID))
|
|
|
|
seq_printf(m, ",uid=%u",
|
|
|
|
from_kuid_munged(&init_user_ns, opts->fs_uid));
|
|
|
|
if (!gid_eq(opts->fs_gid, GLOBAL_ROOT_GID))
|
|
|
|
seq_printf(m, ",gid=%u",
|
|
|
|
from_kgid_munged(&init_user_ns, opts->fs_gid));
|
2005-04-16 22:20:36 +00:00
|
|
|
seq_printf(m, ",fmask=%04o", opts->fs_fmask);
|
|
|
|
seq_printf(m, ",dmask=%04o", opts->fs_dmask);
|
2008-04-28 09:16:26 +00:00
|
|
|
if (opts->allow_utime)
|
|
|
|
seq_printf(m, ",allow_utime=%04o", opts->allow_utime);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (sbi->nls_disk)
|
2012-12-18 00:03:01 +00:00
|
|
|
/* strip "cp" prefix from displayed option */
|
|
|
|
seq_printf(m, ",codepage=%s", &sbi->nls_disk->charset[2]);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (isvfat) {
|
|
|
|
if (sbi->nls_io)
|
|
|
|
seq_printf(m, ",iocharset=%s", sbi->nls_io->charset);
|
|
|
|
|
|
|
|
switch (opts->shortname) {
|
|
|
|
case VFAT_SFN_DISPLAY_WIN95 | VFAT_SFN_CREATE_WIN95:
|
|
|
|
seq_puts(m, ",shortname=win95");
|
|
|
|
break;
|
|
|
|
case VFAT_SFN_DISPLAY_WINNT | VFAT_SFN_CREATE_WINNT:
|
|
|
|
seq_puts(m, ",shortname=winnt");
|
|
|
|
break;
|
|
|
|
case VFAT_SFN_DISPLAY_WINNT | VFAT_SFN_CREATE_WIN95:
|
|
|
|
seq_puts(m, ",shortname=mixed");
|
|
|
|
break;
|
|
|
|
case VFAT_SFN_DISPLAY_LOWER | VFAT_SFN_CREATE_WIN95:
|
2009-08-01 12:30:31 +00:00
|
|
|
seq_puts(m, ",shortname=lower");
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
seq_puts(m, ",shortname=unknown");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (opts->name_check != 'n')
|
|
|
|
seq_printf(m, ",check=%c", opts->name_check);
|
2007-05-08 07:31:01 +00:00
|
|
|
if (opts->usefree)
|
|
|
|
seq_puts(m, ",usefree");
|
2005-04-16 22:20:36 +00:00
|
|
|
if (opts->quiet)
|
|
|
|
seq_puts(m, ",quiet");
|
|
|
|
if (opts->showexec)
|
|
|
|
seq_puts(m, ",showexec");
|
|
|
|
if (opts->sys_immutable)
|
|
|
|
seq_puts(m, ",sys_immutable");
|
|
|
|
if (!isvfat) {
|
|
|
|
if (opts->dotsOK)
|
|
|
|
seq_puts(m, ",dotsOK=yes");
|
|
|
|
if (opts->nocase)
|
|
|
|
seq_puts(m, ",nocase");
|
|
|
|
} else {
|
|
|
|
if (opts->utf8)
|
|
|
|
seq_puts(m, ",utf8");
|
|
|
|
if (opts->unicode_xlate)
|
|
|
|
seq_puts(m, ",uni_xlate");
|
|
|
|
if (!opts->numtail)
|
|
|
|
seq_puts(m, ",nonumtail");
|
2008-11-06 20:53:55 +00:00
|
|
|
if (opts->rodir)
|
|
|
|
seq_puts(m, ",rodir");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-11-06 20:53:55 +00:00
|
|
|
if (opts->flush)
|
2008-02-08 12:21:42 +00:00
|
|
|
seq_puts(m, ",flush");
|
2012-12-18 00:02:58 +00:00
|
|
|
if (opts->tz_set) {
|
|
|
|
if (opts->time_offset)
|
|
|
|
seq_printf(m, ",time_offset=%d", opts->time_offset);
|
|
|
|
else
|
|
|
|
seq_puts(m, ",tz=UTC");
|
|
|
|
}
|
2009-06-03 17:34:22 +00:00
|
|
|
if (opts->errors == FAT_ERRORS_CONT)
|
|
|
|
seq_puts(m, ",errors=continue");
|
|
|
|
else if (opts->errors == FAT_ERRORS_PANIC)
|
|
|
|
seq_puts(m, ",errors=panic");
|
|
|
|
else
|
|
|
|
seq_puts(m, ",errors=remount-ro");
|
2013-04-29 23:21:08 +00:00
|
|
|
if (opts->nfs == FAT_NFS_NOSTALE_RO)
|
|
|
|
seq_puts(m, ",nfs=nostale_ro");
|
|
|
|
else if (opts->nfs)
|
|
|
|
seq_puts(m, ",nfs=stale_rw");
|
2009-11-21 11:28:52 +00:00
|
|
|
if (opts->discard)
|
|
|
|
seq_puts(m, ",discard");
|
2014-06-06 21:36:37 +00:00
|
|
|
if (opts->dos1xfloppy)
|
|
|
|
seq_puts(m, ",dos1xfloppy");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
enum {
|
|
|
|
Opt_check_n, Opt_check_r, Opt_check_s, Opt_uid, Opt_gid,
|
2008-04-28 09:16:26 +00:00
|
|
|
Opt_umask, Opt_dmask, Opt_fmask, Opt_allow_utime, Opt_codepage,
|
|
|
|
Opt_usefree, Opt_nocase, Opt_quiet, Opt_showexec, Opt_debug,
|
|
|
|
Opt_immutable, Opt_dots, Opt_nodots,
|
2005-04-16 22:20:36 +00:00
|
|
|
Opt_charset, Opt_shortname_lower, Opt_shortname_win95,
|
|
|
|
Opt_shortname_winnt, Opt_shortname_mixed, Opt_utf8_no, Opt_utf8_yes,
|
|
|
|
Opt_uni_xl_no, Opt_uni_xl_yes, Opt_nonumtail_no, Opt_nonumtail_yes,
|
2011-10-31 19:50:45 +00:00
|
|
|
Opt_obsolete, Opt_flush, Opt_tz_utc, Opt_rodir, Opt_err_cont,
|
2012-12-18 00:02:58 +00:00
|
|
|
Opt_err_panic, Opt_err_ro, Opt_discard, Opt_nfs, Opt_time_offset,
|
2014-06-06 21:36:37 +00:00
|
|
|
Opt_nfs_stale_rw, Opt_nfs_nostale_ro, Opt_err, Opt_dos1xfloppy,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2008-10-13 09:46:57 +00:00
|
|
|
static const match_table_t fat_tokens = {
|
2005-04-16 22:20:36 +00:00
|
|
|
{Opt_check_r, "check=relaxed"},
|
|
|
|
{Opt_check_s, "check=strict"},
|
|
|
|
{Opt_check_n, "check=normal"},
|
|
|
|
{Opt_check_r, "check=r"},
|
|
|
|
{Opt_check_s, "check=s"},
|
|
|
|
{Opt_check_n, "check=n"},
|
|
|
|
{Opt_uid, "uid=%u"},
|
|
|
|
{Opt_gid, "gid=%u"},
|
|
|
|
{Opt_umask, "umask=%o"},
|
|
|
|
{Opt_dmask, "dmask=%o"},
|
|
|
|
{Opt_fmask, "fmask=%o"},
|
2008-04-28 09:16:26 +00:00
|
|
|
{Opt_allow_utime, "allow_utime=%o"},
|
2005-04-16 22:20:36 +00:00
|
|
|
{Opt_codepage, "codepage=%u"},
|
2007-05-08 07:31:01 +00:00
|
|
|
{Opt_usefree, "usefree"},
|
2005-04-16 22:20:36 +00:00
|
|
|
{Opt_nocase, "nocase"},
|
|
|
|
{Opt_quiet, "quiet"},
|
|
|
|
{Opt_showexec, "showexec"},
|
|
|
|
{Opt_debug, "debug"},
|
|
|
|
{Opt_immutable, "sys_immutable"},
|
2009-06-03 17:34:22 +00:00
|
|
|
{Opt_flush, "flush"},
|
|
|
|
{Opt_tz_utc, "tz=UTC"},
|
2012-12-18 00:02:58 +00:00
|
|
|
{Opt_time_offset, "time_offset=%d"},
|
2009-06-03 17:34:22 +00:00
|
|
|
{Opt_err_cont, "errors=continue"},
|
|
|
|
{Opt_err_panic, "errors=panic"},
|
|
|
|
{Opt_err_ro, "errors=remount-ro"},
|
2009-11-21 11:28:52 +00:00
|
|
|
{Opt_discard, "discard"},
|
2013-04-29 23:21:08 +00:00
|
|
|
{Opt_nfs_stale_rw, "nfs"},
|
|
|
|
{Opt_nfs_stale_rw, "nfs=stale_rw"},
|
|
|
|
{Opt_nfs_nostale_ro, "nfs=nostale_ro"},
|
2014-06-06 21:36:37 +00:00
|
|
|
{Opt_dos1xfloppy, "dos1xfloppy"},
|
2011-10-31 19:50:45 +00:00
|
|
|
{Opt_obsolete, "conv=binary"},
|
|
|
|
{Opt_obsolete, "conv=text"},
|
|
|
|
{Opt_obsolete, "conv=auto"},
|
|
|
|
{Opt_obsolete, "conv=b"},
|
|
|
|
{Opt_obsolete, "conv=t"},
|
|
|
|
{Opt_obsolete, "conv=a"},
|
|
|
|
{Opt_obsolete, "fat=%u"},
|
|
|
|
{Opt_obsolete, "blocksize=%u"},
|
|
|
|
{Opt_obsolete, "cvf_format=%20s"},
|
|
|
|
{Opt_obsolete, "cvf_options=%100s"},
|
|
|
|
{Opt_obsolete, "posix"},
|
2006-09-29 09:00:03 +00:00
|
|
|
{Opt_err, NULL},
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
2008-10-13 09:46:57 +00:00
|
|
|
static const match_table_t msdos_tokens = {
|
2005-04-16 22:20:36 +00:00
|
|
|
{Opt_nodots, "nodots"},
|
|
|
|
{Opt_nodots, "dotsOK=no"},
|
|
|
|
{Opt_dots, "dots"},
|
|
|
|
{Opt_dots, "dotsOK=yes"},
|
|
|
|
{Opt_err, NULL}
|
|
|
|
};
|
2008-10-13 09:46:57 +00:00
|
|
|
static const match_table_t vfat_tokens = {
|
2005-04-16 22:20:36 +00:00
|
|
|
{Opt_charset, "iocharset=%s"},
|
|
|
|
{Opt_shortname_lower, "shortname=lower"},
|
|
|
|
{Opt_shortname_win95, "shortname=win95"},
|
|
|
|
{Opt_shortname_winnt, "shortname=winnt"},
|
|
|
|
{Opt_shortname_mixed, "shortname=mixed"},
|
|
|
|
{Opt_utf8_no, "utf8=0"}, /* 0 or no or false */
|
|
|
|
{Opt_utf8_no, "utf8=no"},
|
|
|
|
{Opt_utf8_no, "utf8=false"},
|
|
|
|
{Opt_utf8_yes, "utf8=1"}, /* empty or 1 or yes or true */
|
|
|
|
{Opt_utf8_yes, "utf8=yes"},
|
|
|
|
{Opt_utf8_yes, "utf8=true"},
|
|
|
|
{Opt_utf8_yes, "utf8"},
|
|
|
|
{Opt_uni_xl_no, "uni_xlate=0"}, /* 0 or no or false */
|
|
|
|
{Opt_uni_xl_no, "uni_xlate=no"},
|
|
|
|
{Opt_uni_xl_no, "uni_xlate=false"},
|
|
|
|
{Opt_uni_xl_yes, "uni_xlate=1"}, /* empty or 1 or yes or true */
|
|
|
|
{Opt_uni_xl_yes, "uni_xlate=yes"},
|
|
|
|
{Opt_uni_xl_yes, "uni_xlate=true"},
|
|
|
|
{Opt_uni_xl_yes, "uni_xlate"},
|
|
|
|
{Opt_nonumtail_no, "nonumtail=0"}, /* 0 or no or false */
|
|
|
|
{Opt_nonumtail_no, "nonumtail=no"},
|
|
|
|
{Opt_nonumtail_no, "nonumtail=false"},
|
|
|
|
{Opt_nonumtail_yes, "nonumtail=1"}, /* empty or 1 or yes or true */
|
|
|
|
{Opt_nonumtail_yes, "nonumtail=yes"},
|
|
|
|
{Opt_nonumtail_yes, "nonumtail=true"},
|
|
|
|
{Opt_nonumtail_yes, "nonumtail"},
|
2008-11-06 20:53:55 +00:00
|
|
|
{Opt_rodir, "rodir"},
|
2005-04-16 22:20:36 +00:00
|
|
|
{Opt_err, NULL}
|
|
|
|
};
|
|
|
|
|
2011-04-12 12:08:38 +00:00
|
|
|
static int parse_options(struct super_block *sb, char *options, int is_vfat,
|
|
|
|
int silent, int *debug, struct fat_mount_options *opts)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
substring_t args[MAX_OPT_ARGS];
|
|
|
|
int option;
|
|
|
|
char *iocharset;
|
|
|
|
|
|
|
|
opts->isvfat = is_vfat;
|
|
|
|
|
2008-11-13 23:38:52 +00:00
|
|
|
opts->fs_uid = current_uid();
|
|
|
|
opts->fs_gid = current_gid();
|
2009-06-20 12:50:07 +00:00
|
|
|
opts->fs_fmask = opts->fs_dmask = current_umask();
|
2008-04-28 09:16:26 +00:00
|
|
|
opts->allow_utime = -1;
|
2005-04-16 22:20:36 +00:00
|
|
|
opts->codepage = fat_default_codepage;
|
2018-07-21 00:53:42 +00:00
|
|
|
fat_reset_iocharset(opts);
|
2008-11-06 20:53:55 +00:00
|
|
|
if (is_vfat) {
|
2009-08-01 12:30:31 +00:00
|
|
|
opts->shortname = VFAT_SFN_DISPLAY_WINNT|VFAT_SFN_CREATE_WIN95;
|
2008-11-06 20:53:55 +00:00
|
|
|
opts->rodir = 0;
|
|
|
|
} else {
|
2005-04-16 22:20:36 +00:00
|
|
|
opts->shortname = 0;
|
2008-11-06 20:53:55 +00:00
|
|
|
opts->rodir = 1;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
opts->name_check = 'n';
|
|
|
|
opts->quiet = opts->showexec = opts->sys_immutable = opts->dotsOK = 0;
|
2016-03-22 21:25:30 +00:00
|
|
|
opts->unicode_xlate = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
opts->numtail = 1;
|
2007-05-08 07:31:01 +00:00
|
|
|
opts->usefree = opts->nocase = 0;
|
2012-12-18 00:02:58 +00:00
|
|
|
opts->tz_set = 0;
|
2012-10-05 00:14:45 +00:00
|
|
|
opts->nfs = 0;
|
2009-06-03 17:34:22 +00:00
|
|
|
opts->errors = FAT_ERRORS_RO;
|
2005-04-16 22:20:36 +00:00
|
|
|
*debug = 0;
|
|
|
|
|
2016-03-22 21:25:30 +00:00
|
|
|
opts->utf8 = IS_ENABLED(CONFIG_FAT_DEFAULT_UTF8) && is_vfat;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!options)
|
2008-07-25 08:46:41 +00:00
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
while ((p = strsep(&options, ",")) != NULL) {
|
|
|
|
int token;
|
|
|
|
if (!*p)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
token = match_token(p, fat_tokens, args);
|
|
|
|
if (token == Opt_err) {
|
|
|
|
if (is_vfat)
|
|
|
|
token = match_token(p, vfat_tokens, args);
|
|
|
|
else
|
|
|
|
token = match_token(p, msdos_tokens, args);
|
|
|
|
}
|
|
|
|
switch (token) {
|
|
|
|
case Opt_check_s:
|
|
|
|
opts->name_check = 's';
|
|
|
|
break;
|
|
|
|
case Opt_check_r:
|
|
|
|
opts->name_check = 'r';
|
|
|
|
break;
|
|
|
|
case Opt_check_n:
|
|
|
|
opts->name_check = 'n';
|
|
|
|
break;
|
2007-05-08 07:31:01 +00:00
|
|
|
case Opt_usefree:
|
|
|
|
opts->usefree = 1;
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
case Opt_nocase:
|
|
|
|
if (!is_vfat)
|
|
|
|
opts->nocase = 1;
|
|
|
|
else {
|
|
|
|
/* for backward compatibility */
|
|
|
|
opts->shortname = VFAT_SFN_DISPLAY_WIN95
|
|
|
|
| VFAT_SFN_CREATE_WIN95;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Opt_quiet:
|
|
|
|
opts->quiet = 1;
|
|
|
|
break;
|
|
|
|
case Opt_showexec:
|
|
|
|
opts->showexec = 1;
|
|
|
|
break;
|
|
|
|
case Opt_debug:
|
|
|
|
*debug = 1;
|
|
|
|
break;
|
|
|
|
case Opt_immutable:
|
|
|
|
opts->sys_immutable = 1;
|
|
|
|
break;
|
|
|
|
case Opt_uid:
|
|
|
|
if (match_int(&args[0], &option))
|
2012-12-18 00:02:59 +00:00
|
|
|
return -EINVAL;
|
2012-02-08 00:25:39 +00:00
|
|
|
opts->fs_uid = make_kuid(current_user_ns(), option);
|
|
|
|
if (!uid_valid(opts->fs_uid))
|
2012-12-18 00:02:59 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case Opt_gid:
|
|
|
|
if (match_int(&args[0], &option))
|
2012-12-18 00:02:59 +00:00
|
|
|
return -EINVAL;
|
2012-02-08 00:25:39 +00:00
|
|
|
opts->fs_gid = make_kgid(current_user_ns(), option);
|
|
|
|
if (!gid_valid(opts->fs_gid))
|
2012-12-18 00:02:59 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case Opt_umask:
|
|
|
|
if (match_octal(&args[0], &option))
|
2012-12-18 00:02:59 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
opts->fs_fmask = opts->fs_dmask = option;
|
|
|
|
break;
|
|
|
|
case Opt_dmask:
|
|
|
|
if (match_octal(&args[0], &option))
|
2012-12-18 00:02:59 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
opts->fs_dmask = option;
|
|
|
|
break;
|
|
|
|
case Opt_fmask:
|
|
|
|
if (match_octal(&args[0], &option))
|
2012-12-18 00:02:59 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
opts->fs_fmask = option;
|
|
|
|
break;
|
2008-04-28 09:16:26 +00:00
|
|
|
case Opt_allow_utime:
|
|
|
|
if (match_octal(&args[0], &option))
|
2012-12-18 00:02:59 +00:00
|
|
|
return -EINVAL;
|
2008-04-28 09:16:26 +00:00
|
|
|
opts->allow_utime = option & (S_IWGRP | S_IWOTH);
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
case Opt_codepage:
|
|
|
|
if (match_int(&args[0], &option))
|
2012-12-18 00:02:59 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
opts->codepage = option;
|
|
|
|
break;
|
2006-09-29 09:00:03 +00:00
|
|
|
case Opt_flush:
|
|
|
|
opts->flush = 1;
|
|
|
|
break;
|
2012-12-18 00:02:58 +00:00
|
|
|
case Opt_time_offset:
|
|
|
|
if (match_int(&args[0], &option))
|
2012-12-18 00:02:59 +00:00
|
|
|
return -EINVAL;
|
2016-01-20 22:59:35 +00:00
|
|
|
/*
|
|
|
|
* GMT+-12 zones may have DST corrections so at least
|
|
|
|
* 13 hours difference is needed. Make the limit 24
|
|
|
|
* just in case someone invents something unusual.
|
|
|
|
*/
|
|
|
|
if (option < -24 * 60 || option > 24 * 60)
|
2012-12-18 00:02:59 +00:00
|
|
|
return -EINVAL;
|
2012-12-18 00:02:58 +00:00
|
|
|
opts->tz_set = 1;
|
|
|
|
opts->time_offset = option;
|
|
|
|
break;
|
fatfs: add UTC timestamp option
Provide a new mount option ("tz=UTC") for DOS (vfat/msdos) filesystems,
allowing timestamps to be in coordinated universal time (UTC) rather than
local time in applications where doing this is advantageous.
In particular, portable devices that use fat/vfat (such as digital
cameras) can benefit from using UTC in their internal clocks, thus
avoiding daylight saving time errors and general time ambiguity issues.
The user of the device does not have to worry about changing the time when
moving from place or when daylight saving changes.
The new mount option, when set, disables the counter-adjustment that Linux
currently makes to FAT timestamp info in anticipation of the normal
userspace time zone correction. When used in this new mode, all daylight
saving time and time zone handling is done in userspace as is normal for
many other filesystems (like ext3). The default mode, which remains
unchanged, is still appropriate when mounting volumes written in Windows
(because of its use of local time).
I originally based this patch on one submitted last year by Paul Collins,
but I updated it to work with current source and changed variable/option
naming. Ogawa Hirofumi (who maintains these filesystems) and I discussed
this patch at length on lkml, and he suggested using the option name in
the attached version of the patch. Barry Bouwsma pointed out a good
addition to the patch as well.
Signed-off-by: Joe Peterson <joe@skyrush.com>
Signed-off-by: Paul Collins <paul@ondioline.org>
Acked-by: OGAWA Hirofumi <hirofumi@mail.parknet.co.jp>
Cc: Barry Bouwsma <free_beer_for_all@yahoo.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-07-25 08:46:47 +00:00
|
|
|
case Opt_tz_utc:
|
2012-12-18 00:02:58 +00:00
|
|
|
opts->tz_set = 1;
|
|
|
|
opts->time_offset = 0;
|
fatfs: add UTC timestamp option
Provide a new mount option ("tz=UTC") for DOS (vfat/msdos) filesystems,
allowing timestamps to be in coordinated universal time (UTC) rather than
local time in applications where doing this is advantageous.
In particular, portable devices that use fat/vfat (such as digital
cameras) can benefit from using UTC in their internal clocks, thus
avoiding daylight saving time errors and general time ambiguity issues.
The user of the device does not have to worry about changing the time when
moving from place or when daylight saving changes.
The new mount option, when set, disables the counter-adjustment that Linux
currently makes to FAT timestamp info in anticipation of the normal
userspace time zone correction. When used in this new mode, all daylight
saving time and time zone handling is done in userspace as is normal for
many other filesystems (like ext3). The default mode, which remains
unchanged, is still appropriate when mounting volumes written in Windows
(because of its use of local time).
I originally based this patch on one submitted last year by Paul Collins,
but I updated it to work with current source and changed variable/option
naming. Ogawa Hirofumi (who maintains these filesystems) and I discussed
this patch at length on lkml, and he suggested using the option name in
the attached version of the patch. Barry Bouwsma pointed out a good
addition to the patch as well.
Signed-off-by: Joe Peterson <joe@skyrush.com>
Signed-off-by: Paul Collins <paul@ondioline.org>
Acked-by: OGAWA Hirofumi <hirofumi@mail.parknet.co.jp>
Cc: Barry Bouwsma <free_beer_for_all@yahoo.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-07-25 08:46:47 +00:00
|
|
|
break;
|
2009-06-03 17:34:22 +00:00
|
|
|
case Opt_err_cont:
|
|
|
|
opts->errors = FAT_ERRORS_CONT;
|
|
|
|
break;
|
|
|
|
case Opt_err_panic:
|
|
|
|
opts->errors = FAT_ERRORS_PANIC;
|
|
|
|
break;
|
|
|
|
case Opt_err_ro:
|
|
|
|
opts->errors = FAT_ERRORS_RO;
|
|
|
|
break;
|
2013-04-29 23:21:08 +00:00
|
|
|
case Opt_nfs_stale_rw:
|
|
|
|
opts->nfs = FAT_NFS_STALE_RW;
|
|
|
|
break;
|
|
|
|
case Opt_nfs_nostale_ro:
|
|
|
|
opts->nfs = FAT_NFS_NOSTALE_RO;
|
|
|
|
break;
|
2014-06-06 21:36:37 +00:00
|
|
|
case Opt_dos1xfloppy:
|
|
|
|
opts->dos1xfloppy = 1;
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* msdos specific */
|
|
|
|
case Opt_dots:
|
|
|
|
opts->dotsOK = 1;
|
|
|
|
break;
|
|
|
|
case Opt_nodots:
|
|
|
|
opts->dotsOK = 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* vfat specific */
|
|
|
|
case Opt_charset:
|
2018-07-21 00:53:42 +00:00
|
|
|
fat_reset_iocharset(opts);
|
2005-04-16 22:20:36 +00:00
|
|
|
iocharset = match_strdup(&args[0]);
|
|
|
|
if (!iocharset)
|
|
|
|
return -ENOMEM;
|
|
|
|
opts->iocharset = iocharset;
|
|
|
|
break;
|
|
|
|
case Opt_shortname_lower:
|
|
|
|
opts->shortname = VFAT_SFN_DISPLAY_LOWER
|
|
|
|
| VFAT_SFN_CREATE_WIN95;
|
|
|
|
break;
|
|
|
|
case Opt_shortname_win95:
|
|
|
|
opts->shortname = VFAT_SFN_DISPLAY_WIN95
|
|
|
|
| VFAT_SFN_CREATE_WIN95;
|
|
|
|
break;
|
|
|
|
case Opt_shortname_winnt:
|
|
|
|
opts->shortname = VFAT_SFN_DISPLAY_WINNT
|
|
|
|
| VFAT_SFN_CREATE_WINNT;
|
|
|
|
break;
|
|
|
|
case Opt_shortname_mixed:
|
|
|
|
opts->shortname = VFAT_SFN_DISPLAY_WINNT
|
|
|
|
| VFAT_SFN_CREATE_WIN95;
|
|
|
|
break;
|
|
|
|
case Opt_utf8_no: /* 0 or no or false */
|
|
|
|
opts->utf8 = 0;
|
|
|
|
break;
|
|
|
|
case Opt_utf8_yes: /* empty or 1 or yes or true */
|
|
|
|
opts->utf8 = 1;
|
|
|
|
break;
|
|
|
|
case Opt_uni_xl_no: /* 0 or no or false */
|
|
|
|
opts->unicode_xlate = 0;
|
|
|
|
break;
|
|
|
|
case Opt_uni_xl_yes: /* empty or 1 or yes or true */
|
|
|
|
opts->unicode_xlate = 1;
|
|
|
|
break;
|
|
|
|
case Opt_nonumtail_no: /* 0 or no or false */
|
|
|
|
opts->numtail = 1; /* negated option */
|
|
|
|
break;
|
|
|
|
case Opt_nonumtail_yes: /* empty or 1 or yes or true */
|
|
|
|
opts->numtail = 0; /* negated option */
|
|
|
|
break;
|
2008-11-06 20:53:55 +00:00
|
|
|
case Opt_rodir:
|
|
|
|
opts->rodir = 1;
|
|
|
|
break;
|
2009-11-21 11:28:52 +00:00
|
|
|
case Opt_discard:
|
|
|
|
opts->discard = 1;
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* obsolete mount options */
|
2011-10-31 19:50:45 +00:00
|
|
|
case Opt_obsolete:
|
2011-04-12 12:08:38 +00:00
|
|
|
fat_msg(sb, KERN_INFO, "\"%s\" option is obsolete, "
|
|
|
|
"not supported now", p);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
/* unknown option */
|
|
|
|
default:
|
2005-11-09 05:34:57 +00:00
|
|
|
if (!silent) {
|
2011-04-12 12:08:38 +00:00
|
|
|
fat_msg(sb, KERN_ERR,
|
|
|
|
"Unrecognized mount option \"%s\" "
|
|
|
|
"or missing value", p);
|
2005-11-09 05:34:57 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
2008-07-25 08:46:41 +00:00
|
|
|
|
|
|
|
out:
|
2006-03-21 23:13:35 +00:00
|
|
|
/* UTF-8 doesn't provide FAT semantics */
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!strcmp(opts->iocharset, "utf8")) {
|
2011-08-17 10:10:08 +00:00
|
|
|
fat_msg(sb, KERN_WARNING, "utf8 is not a recommended IO charset"
|
2008-07-25 08:46:41 +00:00
|
|
|
" for FAT filesystems, filesystem will be "
|
2011-08-17 10:10:08 +00:00
|
|
|
"case sensitive!");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-04-28 09:16:26 +00:00
|
|
|
/* If user doesn't specify allow_utime, it's initialized from dmask. */
|
|
|
|
if (opts->allow_utime == (unsigned short)-1)
|
|
|
|
opts->allow_utime = ~opts->fs_dmask & (S_IWGRP | S_IWOTH);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (opts->unicode_xlate)
|
|
|
|
opts->utf8 = 0;
|
2013-04-29 23:21:11 +00:00
|
|
|
if (opts->nfs == FAT_NFS_NOSTALE_RO) {
|
2017-11-27 21:05:09 +00:00
|
|
|
sb->s_flags |= SB_RDONLY;
|
2013-04-29 23:21:11 +00:00
|
|
|
sb->s_export_op = &fat_export_ops_nostale;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fat_read_root(struct inode *inode)
|
|
|
|
{
|
2015-04-16 19:47:21 +00:00
|
|
|
struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
|
2005-04-16 22:20:36 +00:00
|
|
|
int error;
|
|
|
|
|
2013-04-29 23:21:11 +00:00
|
|
|
MSDOS_I(inode)->i_pos = MSDOS_ROOT_INO;
|
2005-04-16 22:20:36 +00:00
|
|
|
inode->i_uid = sbi->options.fs_uid;
|
|
|
|
inode->i_gid = sbi->options.fs_gid;
|
2017-12-11 11:35:09 +00:00
|
|
|
inode_inc_iversion(inode);
|
2005-04-16 22:20:36 +00:00
|
|
|
inode->i_generation = 0;
|
2008-11-06 20:53:54 +00:00
|
|
|
inode->i_mode = fat_make_mode(sbi, ATTR_DIR, S_IRWXUGO);
|
2005-04-16 22:20:36 +00:00
|
|
|
inode->i_op = sbi->dir_ops;
|
|
|
|
inode->i_fop = &fat_dir_operations;
|
2019-01-03 23:28:00 +00:00
|
|
|
if (is_fat32(sbi)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
MSDOS_I(inode)->i_start = sbi->root_cluster;
|
|
|
|
error = fat_calc_dir_size(inode);
|
|
|
|
if (error < 0)
|
|
|
|
return error;
|
|
|
|
} else {
|
|
|
|
MSDOS_I(inode)->i_start = 0;
|
|
|
|
inode->i_size = sbi->dir_entries * sizeof(struct msdos_dir_entry);
|
|
|
|
}
|
|
|
|
inode->i_blocks = ((inode->i_size + (sbi->cluster_size - 1))
|
|
|
|
& ~((loff_t)sbi->cluster_size - 1)) >> 9;
|
|
|
|
MSDOS_I(inode)->i_logstart = 0;
|
|
|
|
MSDOS_I(inode)->mmu_private = inode->i_size;
|
|
|
|
|
2008-11-06 20:53:54 +00:00
|
|
|
fat_save_attrs(inode, ATTR_DIR);
|
2005-04-16 22:20:36 +00:00
|
|
|
inode->i_mtime.tv_sec = inode->i_atime.tv_sec = inode->i_ctime.tv_sec = 0;
|
|
|
|
inode->i_mtime.tv_nsec = inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = 0;
|
2011-10-28 12:13:29 +00:00
|
|
|
set_nlink(inode, fat_subdirs(inode)+2);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-05-24 22:55:08 +00:00
|
|
|
static unsigned long calc_fat_clusters(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct msdos_sb_info *sbi = MSDOS_SB(sb);
|
|
|
|
|
|
|
|
/* Divide first to avoid overflow */
|
2019-01-03 23:28:00 +00:00
|
|
|
if (!is_fat12(sbi)) {
|
2013-05-24 22:55:08 +00:00
|
|
|
unsigned long ent_per_sec = sb->s_blocksize * 8 / sbi->fat_bits;
|
|
|
|
return ent_per_sec * sbi->fat_length;
|
|
|
|
}
|
|
|
|
|
|
|
|
return sbi->fat_length * sb->s_blocksize * 8 / sbi->fat_bits;
|
|
|
|
}
|
|
|
|
|
2014-06-06 21:36:37 +00:00
|
|
|
static bool fat_bpb_is_zero(struct fat_boot_sector *b)
|
|
|
|
{
|
|
|
|
if (get_unaligned_le16(&b->sector_size))
|
|
|
|
return false;
|
|
|
|
if (b->sec_per_clus)
|
|
|
|
return false;
|
|
|
|
if (b->reserved)
|
|
|
|
return false;
|
|
|
|
if (b->fats)
|
|
|
|
return false;
|
|
|
|
if (get_unaligned_le16(&b->dir_entries))
|
|
|
|
return false;
|
|
|
|
if (get_unaligned_le16(&b->sectors))
|
|
|
|
return false;
|
|
|
|
if (b->media)
|
|
|
|
return false;
|
|
|
|
if (b->fat_length)
|
|
|
|
return false;
|
|
|
|
if (b->secs_track)
|
|
|
|
return false;
|
|
|
|
if (b->heads)
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fat_read_bpb(struct super_block *sb, struct fat_boot_sector *b,
|
|
|
|
int silent, struct fat_bios_param_block *bpb)
|
|
|
|
{
|
|
|
|
int error = -EINVAL;
|
|
|
|
|
|
|
|
/* Read in BPB ... */
|
|
|
|
memset(bpb, 0, sizeof(*bpb));
|
|
|
|
bpb->fat_sector_size = get_unaligned_le16(&b->sector_size);
|
|
|
|
bpb->fat_sec_per_clus = b->sec_per_clus;
|
|
|
|
bpb->fat_reserved = le16_to_cpu(b->reserved);
|
|
|
|
bpb->fat_fats = b->fats;
|
|
|
|
bpb->fat_dir_entries = get_unaligned_le16(&b->dir_entries);
|
|
|
|
bpb->fat_sectors = get_unaligned_le16(&b->sectors);
|
|
|
|
bpb->fat_fat_length = le16_to_cpu(b->fat_length);
|
|
|
|
bpb->fat_total_sect = le32_to_cpu(b->total_sect);
|
|
|
|
|
|
|
|
bpb->fat16_state = b->fat16.state;
|
|
|
|
bpb->fat16_vol_id = get_unaligned_le32(b->fat16.vol_id);
|
|
|
|
|
|
|
|
bpb->fat32_length = le32_to_cpu(b->fat32.length);
|
|
|
|
bpb->fat32_root_cluster = le32_to_cpu(b->fat32.root_cluster);
|
|
|
|
bpb->fat32_info_sector = le16_to_cpu(b->fat32.info_sector);
|
|
|
|
bpb->fat32_state = b->fat32.state;
|
|
|
|
bpb->fat32_vol_id = get_unaligned_le32(b->fat32.vol_id);
|
|
|
|
|
|
|
|
/* Validate this looks like a FAT filesystem BPB */
|
|
|
|
if (!bpb->fat_reserved) {
|
|
|
|
if (!silent)
|
|
|
|
fat_msg(sb, KERN_ERR,
|
|
|
|
"bogus number of reserved sectors");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (!bpb->fat_fats) {
|
|
|
|
if (!silent)
|
|
|
|
fat_msg(sb, KERN_ERR, "bogus number of FAT structure");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Earlier we checked here that b->secs_track and b->head are nonzero,
|
|
|
|
* but it turns out valid FAT filesystems can have zero there.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (!fat_valid_media(b->media)) {
|
|
|
|
if (!silent)
|
|
|
|
fat_msg(sb, KERN_ERR, "invalid media value (0x%02x)",
|
|
|
|
(unsigned)b->media);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!is_power_of_2(bpb->fat_sector_size)
|
|
|
|
|| (bpb->fat_sector_size < 512)
|
|
|
|
|| (bpb->fat_sector_size > 4096)) {
|
|
|
|
if (!silent)
|
|
|
|
fat_msg(sb, KERN_ERR, "bogus logical sector size %u",
|
|
|
|
(unsigned)bpb->fat_sector_size);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!is_power_of_2(bpb->fat_sec_per_clus)) {
|
|
|
|
if (!silent)
|
|
|
|
fat_msg(sb, KERN_ERR, "bogus sectors per cluster %u",
|
|
|
|
(unsigned)bpb->fat_sec_per_clus);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = 0;
|
|
|
|
|
|
|
|
out:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fat_read_static_bpb(struct super_block *sb,
|
|
|
|
struct fat_boot_sector *b, int silent,
|
|
|
|
struct fat_bios_param_block *bpb)
|
|
|
|
{
|
|
|
|
static const char *notdos1x = "This doesn't look like a DOS 1.x volume";
|
|
|
|
|
|
|
|
struct fat_floppy_defaults *fdefaults = NULL;
|
|
|
|
int error = -EINVAL;
|
|
|
|
sector_t bd_sects;
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
bd_sects = i_size_read(sb->s_bdev->bd_inode) / SECTOR_SIZE;
|
|
|
|
|
|
|
|
/* 16-bit DOS 1.x reliably wrote bootstrap short-jmp code */
|
|
|
|
if (b->ignored[0] != 0xeb || b->ignored[2] != 0x90) {
|
|
|
|
if (!silent)
|
|
|
|
fat_msg(sb, KERN_ERR,
|
|
|
|
"%s; no bootstrapping code", notdos1x);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If any value in this region is non-zero, it isn't archaic
|
|
|
|
* DOS.
|
|
|
|
*/
|
|
|
|
if (!fat_bpb_is_zero(b)) {
|
|
|
|
if (!silent)
|
|
|
|
fat_msg(sb, KERN_ERR,
|
|
|
|
"%s; DOS 2.x BPB is non-zero", notdos1x);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(floppy_defaults); i++) {
|
|
|
|
if (floppy_defaults[i].nr_sectors == bd_sects) {
|
|
|
|
fdefaults = &floppy_defaults[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fdefaults == NULL) {
|
|
|
|
if (!silent)
|
|
|
|
fat_msg(sb, KERN_WARNING,
|
|
|
|
"This looks like a DOS 1.x volume, but isn't a recognized floppy size (%llu sectors)",
|
|
|
|
(u64)bd_sects);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!silent)
|
|
|
|
fat_msg(sb, KERN_INFO,
|
|
|
|
"This looks like a DOS 1.x volume; assuming default BPB values");
|
|
|
|
|
|
|
|
memset(bpb, 0, sizeof(*bpb));
|
|
|
|
bpb->fat_sector_size = SECTOR_SIZE;
|
|
|
|
bpb->fat_sec_per_clus = fdefaults->sec_per_clus;
|
|
|
|
bpb->fat_reserved = 1;
|
|
|
|
bpb->fat_fats = 2;
|
|
|
|
bpb->fat_dir_entries = fdefaults->dir_entries;
|
|
|
|
bpb->fat_sectors = fdefaults->nr_sectors;
|
|
|
|
bpb->fat_fat_length = fdefaults->fat_length;
|
|
|
|
|
|
|
|
error = 0;
|
|
|
|
|
|
|
|
out:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Read the super block of an MS-DOS FS.
|
|
|
|
*/
|
2011-04-12 12:08:37 +00:00
|
|
|
int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
|
2010-12-18 15:44:00 +00:00
|
|
|
void (*setup)(struct super_block *))
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-06-07 17:44:36 +00:00
|
|
|
struct inode *root_inode = NULL, *fat_inode = NULL;
|
2012-05-31 23:26:12 +00:00
|
|
|
struct inode *fsinfo_inode = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct buffer_head *bh;
|
2014-06-06 21:36:37 +00:00
|
|
|
struct fat_bios_param_block bpb;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct msdos_sb_info *sbi;
|
|
|
|
u16 logical_sector_size;
|
|
|
|
u32 total_sectors, total_clusters, fat_clusters, rootdir_sectors;
|
|
|
|
int debug;
|
|
|
|
long error;
|
|
|
|
char buf[50];
|
2019-03-22 23:42:54 +00:00
|
|
|
struct timespec64 ts;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-05-20 02:53:01 +00:00
|
|
|
/*
|
|
|
|
* GFP_KERNEL is ok here, because while we do hold the
|
2016-06-21 03:51:29 +00:00
|
|
|
* superblock lock, memory pressure can't call back into
|
2008-05-20 02:53:01 +00:00
|
|
|
* the filesystem, since we're only just about to mount
|
|
|
|
* it and have no inodes etc active!
|
|
|
|
*/
|
2006-09-27 08:49:37 +00:00
|
|
|
sbi = kzalloc(sizeof(struct msdos_sb_info), GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!sbi)
|
|
|
|
return -ENOMEM;
|
|
|
|
sb->s_fs_info = sbi;
|
|
|
|
|
2017-11-27 21:05:09 +00:00
|
|
|
sb->s_flags |= SB_NODIRATIME;
|
2005-04-16 22:20:36 +00:00
|
|
|
sb->s_magic = MSDOS_SUPER_MAGIC;
|
|
|
|
sb->s_op = &fat_sops;
|
|
|
|
sb->s_export_op = &fat_export_ops;
|
2018-10-30 22:06:53 +00:00
|
|
|
/*
|
|
|
|
* fat timestamps are complex and truncated by fat itself, so
|
|
|
|
* we set 1 here to be fast
|
|
|
|
*/
|
|
|
|
sb->s_time_gran = 1;
|
2013-04-29 23:21:12 +00:00
|
|
|
mutex_init(&sbi->nfs_build_inode_lock);
|
2010-05-24 21:33:12 +00:00
|
|
|
ratelimit_state_init(&sbi->ratelimit, DEFAULT_RATELIMIT_INTERVAL,
|
|
|
|
DEFAULT_RATELIMIT_BURST);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-04-12 12:08:38 +00:00
|
|
|
error = parse_options(sb, data, isvfat, silent, &debug, &sbi->options);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (error)
|
|
|
|
goto out_fail;
|
|
|
|
|
2010-12-18 15:44:00 +00:00
|
|
|
setup(sb); /* flavour-specific stuff that needs options */
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
error = -EIO;
|
|
|
|
sb_min_blocksize(sb, 512);
|
|
|
|
bh = sb_bread(sb, 0);
|
|
|
|
if (bh == NULL) {
|
2011-04-12 12:08:38 +00:00
|
|
|
fat_msg(sb, KERN_ERR, "unable to read boot sector");
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out_fail;
|
|
|
|
}
|
|
|
|
|
2014-06-06 21:36:37 +00:00
|
|
|
error = fat_read_bpb(sb, (struct fat_boot_sector *)bh->b_data, silent,
|
|
|
|
&bpb);
|
|
|
|
if (error == -EINVAL && sbi->options.dos1xfloppy)
|
|
|
|
error = fat_read_static_bpb(sb,
|
|
|
|
(struct fat_boot_sector *)bh->b_data, silent, &bpb);
|
|
|
|
brelse(bh);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-06-06 21:36:37 +00:00
|
|
|
if (error == -EINVAL)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out_invalid;
|
2014-06-06 21:36:37 +00:00
|
|
|
else if (error)
|
|
|
|
goto out_fail;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-06-06 21:36:37 +00:00
|
|
|
logical_sector_size = bpb.fat_sector_size;
|
|
|
|
sbi->sec_per_clus = bpb.fat_sec_per_clus;
|
|
|
|
|
|
|
|
error = -EIO;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (logical_sector_size < sb->s_blocksize) {
|
2011-04-12 12:08:38 +00:00
|
|
|
fat_msg(sb, KERN_ERR, "logical sector size too small for device"
|
|
|
|
" (logical sector size = %u)", logical_sector_size);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out_fail;
|
|
|
|
}
|
2014-06-06 21:36:37 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (logical_sector_size > sb->s_blocksize) {
|
2014-06-06 21:36:37 +00:00
|
|
|
struct buffer_head *bh_resize;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!sb_set_blocksize(sb, logical_sector_size)) {
|
2011-04-12 12:08:38 +00:00
|
|
|
fat_msg(sb, KERN_ERR, "unable to set blocksize %u",
|
2005-04-16 22:20:36 +00:00
|
|
|
logical_sector_size);
|
|
|
|
goto out_fail;
|
|
|
|
}
|
2014-06-06 21:36:37 +00:00
|
|
|
|
|
|
|
/* Verify that the larger boot sector is fully readable */
|
|
|
|
bh_resize = sb_bread(sb, 0);
|
|
|
|
if (bh_resize == NULL) {
|
2011-04-12 12:08:38 +00:00
|
|
|
fat_msg(sb, KERN_ERR, "unable to read boot sector"
|
|
|
|
" (logical sector size = %lu)",
|
2005-04-16 22:20:36 +00:00
|
|
|
sb->s_blocksize);
|
|
|
|
goto out_fail;
|
|
|
|
}
|
2014-06-06 21:36:37 +00:00
|
|
|
brelse(bh_resize);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2012-10-06 10:40:03 +00:00
|
|
|
mutex_init(&sbi->s_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
sbi->cluster_size = sb->s_blocksize * sbi->sec_per_clus;
|
|
|
|
sbi->cluster_bits = ffs(sbi->cluster_size) - 1;
|
2014-06-06 21:36:37 +00:00
|
|
|
sbi->fats = bpb.fat_fats;
|
2005-04-16 22:20:36 +00:00
|
|
|
sbi->fat_bits = 0; /* Don't know yet */
|
2014-06-06 21:36:37 +00:00
|
|
|
sbi->fat_start = bpb.fat_reserved;
|
|
|
|
sbi->fat_length = bpb.fat_fat_length;
|
2005-04-16 22:20:36 +00:00
|
|
|
sbi->root_cluster = 0;
|
|
|
|
sbi->free_clusters = -1; /* Don't know yet */
|
2008-04-28 09:16:27 +00:00
|
|
|
sbi->free_clus_valid = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
sbi->prev_free = FAT_START_ENT;
|
2011-08-17 10:10:09 +00:00
|
|
|
sb->s_maxbytes = 0xffffffff;
|
2019-03-22 23:42:54 +00:00
|
|
|
fat_time_fat2unix(sbi, &ts, 0, cpu_to_le16(FAT_DATE_MIN), 0);
|
|
|
|
sb->s_time_min = ts.tv_sec;
|
|
|
|
|
|
|
|
fat_time_fat2unix(sbi, &ts, cpu_to_le16(FAT_TIME_MAX),
|
|
|
|
cpu_to_le16(FAT_DATE_MAX), 0);
|
|
|
|
sb->s_time_max = ts.tv_sec;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-06-06 21:36:37 +00:00
|
|
|
if (!sbi->fat_length && bpb.fat32_length) {
|
2005-04-16 22:20:36 +00:00
|
|
|
struct fat_boot_fsinfo *fsinfo;
|
|
|
|
struct buffer_head *fsinfo_bh;
|
|
|
|
|
|
|
|
/* Must be FAT32 */
|
|
|
|
sbi->fat_bits = 32;
|
2014-06-06 21:36:37 +00:00
|
|
|
sbi->fat_length = bpb.fat32_length;
|
|
|
|
sbi->root_cluster = bpb.fat32_root_cluster;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* MC - if info_sector is 0, don't multiply by 0 */
|
2014-06-06 21:36:37 +00:00
|
|
|
sbi->fsinfo_sector = bpb.fat32_info_sector;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (sbi->fsinfo_sector == 0)
|
|
|
|
sbi->fsinfo_sector = 1;
|
|
|
|
|
|
|
|
fsinfo_bh = sb_bread(sb, sbi->fsinfo_sector);
|
|
|
|
if (fsinfo_bh == NULL) {
|
2011-04-12 12:08:38 +00:00
|
|
|
fat_msg(sb, KERN_ERR, "bread failed, FSINFO block"
|
|
|
|
" (sector = %lu)", sbi->fsinfo_sector);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out_fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
fsinfo = (struct fat_boot_fsinfo *)fsinfo_bh->b_data;
|
|
|
|
if (!IS_FSINFO(fsinfo)) {
|
2011-04-12 12:08:38 +00:00
|
|
|
fat_msg(sb, KERN_WARNING, "Invalid FSINFO signature: "
|
|
|
|
"0x%08x, 0x%08x (sector = %lu)",
|
2005-04-16 22:20:36 +00:00
|
|
|
le32_to_cpu(fsinfo->signature1),
|
|
|
|
le32_to_cpu(fsinfo->signature2),
|
|
|
|
sbi->fsinfo_sector);
|
|
|
|
} else {
|
2007-05-08 07:31:01 +00:00
|
|
|
if (sbi->options.usefree)
|
2008-04-28 09:16:27 +00:00
|
|
|
sbi->free_clus_valid = 1;
|
|
|
|
sbi->free_clusters = le32_to_cpu(fsinfo->free_clusters);
|
2005-04-16 22:20:36 +00:00
|
|
|
sbi->prev_free = le32_to_cpu(fsinfo->next_cluster);
|
|
|
|
}
|
|
|
|
|
|
|
|
brelse(fsinfo_bh);
|
|
|
|
}
|
|
|
|
|
fatfs: add FAT_IOCTL_GET_VOLUME_ID
This patch, originally from Android kernel, adds vfat ioctl command
FAT_IOCTL_GET_VOLUME_ID, with this command we can get the vfat volume ID
using following code:
ioctl(fd, FAT_IOCTL_GET_VOLUME_ID, &volume_ID)
This patch is a modified version of the patch by Mike Lockwood, with
changes from Dmitry Pervushin, who noticed the original patch makes some
volume IDs abiguous with error returns: for example, if volume id is
0xFFFFFDAD, that matches -ENOIOCTLCMD, we get "FFFFFFFF" from the user
space.
So add a parameter to ioctl to get the correct volume ID.
Android uses vfat volume ID to identify different sd card, when a new sd
card is inserted to device, android can scan the media on it and pop up
new contents.
Signed-off-by: Bintian Wang <bintian.wang@linaro.org>
Cc: dmitry pervushin <dpervushin@gmail.com>
Cc: Mike Lockwood <lockwood@android.com>
Cc: Colin Cross <ccross@android.com>
Acked-by: OGAWA Hirofumi <hirofumi@mail.parknet.co.jp>
Cc: John Stultz <john.stultz@linaro.org>
Cc: Sean McNeil <sean@mcneil.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-07-08 23:00:46 +00:00
|
|
|
/* interpret volume ID as a little endian 32 bit integer */
|
2019-01-03 23:28:00 +00:00
|
|
|
if (is_fat32(sbi))
|
2014-06-06 21:36:37 +00:00
|
|
|
sbi->vol_id = bpb.fat32_vol_id;
|
fatfs: add FAT_IOCTL_GET_VOLUME_ID
This patch, originally from Android kernel, adds vfat ioctl command
FAT_IOCTL_GET_VOLUME_ID, with this command we can get the vfat volume ID
using following code:
ioctl(fd, FAT_IOCTL_GET_VOLUME_ID, &volume_ID)
This patch is a modified version of the patch by Mike Lockwood, with
changes from Dmitry Pervushin, who noticed the original patch makes some
volume IDs abiguous with error returns: for example, if volume id is
0xFFFFFDAD, that matches -ENOIOCTLCMD, we get "FFFFFFFF" from the user
space.
So add a parameter to ioctl to get the correct volume ID.
Android uses vfat volume ID to identify different sd card, when a new sd
card is inserted to device, android can scan the media on it and pop up
new contents.
Signed-off-by: Bintian Wang <bintian.wang@linaro.org>
Cc: dmitry pervushin <dpervushin@gmail.com>
Cc: Mike Lockwood <lockwood@android.com>
Cc: Colin Cross <ccross@android.com>
Acked-by: OGAWA Hirofumi <hirofumi@mail.parknet.co.jp>
Cc: John Stultz <john.stultz@linaro.org>
Cc: Sean McNeil <sean@mcneil.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-07-08 23:00:46 +00:00
|
|
|
else /* fat 16 or 12 */
|
2014-06-06 21:36:37 +00:00
|
|
|
sbi->vol_id = bpb.fat16_vol_id;
|
fatfs: add FAT_IOCTL_GET_VOLUME_ID
This patch, originally from Android kernel, adds vfat ioctl command
FAT_IOCTL_GET_VOLUME_ID, with this command we can get the vfat volume ID
using following code:
ioctl(fd, FAT_IOCTL_GET_VOLUME_ID, &volume_ID)
This patch is a modified version of the patch by Mike Lockwood, with
changes from Dmitry Pervushin, who noticed the original patch makes some
volume IDs abiguous with error returns: for example, if volume id is
0xFFFFFDAD, that matches -ENOIOCTLCMD, we get "FFFFFFFF" from the user
space.
So add a parameter to ioctl to get the correct volume ID.
Android uses vfat volume ID to identify different sd card, when a new sd
card is inserted to device, android can scan the media on it and pop up
new contents.
Signed-off-by: Bintian Wang <bintian.wang@linaro.org>
Cc: dmitry pervushin <dpervushin@gmail.com>
Cc: Mike Lockwood <lockwood@android.com>
Cc: Colin Cross <ccross@android.com>
Acked-by: OGAWA Hirofumi <hirofumi@mail.parknet.co.jp>
Cc: John Stultz <john.stultz@linaro.org>
Cc: Sean McNeil <sean@mcneil.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-07-08 23:00:46 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
sbi->dir_per_block = sb->s_blocksize / sizeof(struct msdos_dir_entry);
|
|
|
|
sbi->dir_per_block_bits = ffs(sbi->dir_per_block) - 1;
|
|
|
|
|
|
|
|
sbi->dir_start = sbi->fat_start + sbi->fats * sbi->fat_length;
|
2014-06-06 21:36:37 +00:00
|
|
|
sbi->dir_entries = bpb.fat_dir_entries;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (sbi->dir_entries & (sbi->dir_per_block - 1)) {
|
|
|
|
if (!silent)
|
2016-06-24 05:31:00 +00:00
|
|
|
fat_msg(sb, KERN_ERR, "bogus number of directory entries"
|
2011-04-12 12:08:38 +00:00
|
|
|
" (%u)", sbi->dir_entries);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out_invalid;
|
|
|
|
}
|
|
|
|
|
|
|
|
rootdir_sectors = sbi->dir_entries
|
|
|
|
* sizeof(struct msdos_dir_entry) / sb->s_blocksize;
|
|
|
|
sbi->data_start = sbi->dir_start + rootdir_sectors;
|
2014-06-06 21:36:37 +00:00
|
|
|
total_sectors = bpb.fat_sectors;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (total_sectors == 0)
|
2014-06-06 21:36:37 +00:00
|
|
|
total_sectors = bpb.fat_total_sect;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
total_clusters = (total_sectors - sbi->data_start) / sbi->sec_per_clus;
|
|
|
|
|
2019-01-03 23:28:00 +00:00
|
|
|
if (!is_fat32(sbi))
|
2005-04-16 22:20:36 +00:00
|
|
|
sbi->fat_bits = (total_clusters > MAX_FAT12) ? 16 : 12;
|
|
|
|
|
2013-02-28 01:03:09 +00:00
|
|
|
/* some OSes set FAT_STATE_DIRTY and clean it on unmount. */
|
2019-01-03 23:28:00 +00:00
|
|
|
if (is_fat32(sbi))
|
2014-06-06 21:36:37 +00:00
|
|
|
sbi->dirty = bpb.fat32_state & FAT_STATE_DIRTY;
|
2013-02-28 01:03:09 +00:00
|
|
|
else /* fat 16 or 12 */
|
2014-06-06 21:36:37 +00:00
|
|
|
sbi->dirty = bpb.fat16_state & FAT_STATE_DIRTY;
|
2013-02-28 01:03:09 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* check that FAT table does not overflow */
|
2013-05-24 22:55:08 +00:00
|
|
|
fat_clusters = calc_fat_clusters(sb);
|
2005-04-16 22:20:36 +00:00
|
|
|
total_clusters = min(total_clusters, fat_clusters - FAT_START_ENT);
|
2019-01-03 23:27:56 +00:00
|
|
|
if (total_clusters > max_fat(sb)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!silent)
|
2011-04-12 12:08:38 +00:00
|
|
|
fat_msg(sb, KERN_ERR, "count of clusters too big (%u)",
|
2005-04-16 22:20:36 +00:00
|
|
|
total_clusters);
|
|
|
|
goto out_invalid;
|
|
|
|
}
|
|
|
|
|
|
|
|
sbi->max_cluster = total_clusters + FAT_START_ENT;
|
|
|
|
/* check the free_clusters, it's not necessarily correct */
|
|
|
|
if (sbi->free_clusters != -1 && sbi->free_clusters > total_clusters)
|
|
|
|
sbi->free_clusters = -1;
|
|
|
|
/* check the prev_free, it's not necessarily correct */
|
|
|
|
sbi->prev_free %= sbi->max_cluster;
|
|
|
|
if (sbi->prev_free < FAT_START_ENT)
|
|
|
|
sbi->prev_free = FAT_START_ENT;
|
|
|
|
|
|
|
|
/* set up enough so that it can read an inode */
|
|
|
|
fat_hash_init(sb);
|
2012-10-05 00:14:45 +00:00
|
|
|
dir_hash_init(sb);
|
2005-04-16 22:20:36 +00:00
|
|
|
fat_ent_access_init(sb);
|
|
|
|
|
|
|
|
/*
|
2019-01-03 23:27:53 +00:00
|
|
|
* The low byte of the first FAT entry must have the same value as
|
|
|
|
* the media field of the boot sector. But in real world, too many
|
|
|
|
* devices are writing wrong values. So, removed that validity check.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2019-01-03 23:27:53 +00:00
|
|
|
* The removed check compared the first FAT entry to a value dependent
|
|
|
|
* on the media field like this:
|
|
|
|
* == (0x0F00 | media), for FAT12
|
|
|
|
* == (0XFF00 | media), for FAT16
|
|
|
|
* == (0x0FFFFF | media), for FAT32
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
error = -EINVAL;
|
|
|
|
sprintf(buf, "cp%d", sbi->options.codepage);
|
|
|
|
sbi->nls_disk = load_nls(buf);
|
|
|
|
if (!sbi->nls_disk) {
|
2011-04-12 12:08:38 +00:00
|
|
|
fat_msg(sb, KERN_ERR, "codepage %s not found", buf);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out_fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* FIXME: utf8 is using iocharset for upper/lower conversion */
|
|
|
|
if (sbi->options.isvfat) {
|
|
|
|
sbi->nls_io = load_nls(sbi->options.iocharset);
|
|
|
|
if (!sbi->nls_io) {
|
2011-04-12 12:08:38 +00:00
|
|
|
fat_msg(sb, KERN_ERR, "IO charset %s not found",
|
2005-04-16 22:20:36 +00:00
|
|
|
sbi->options.iocharset);
|
|
|
|
goto out_fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
error = -ENOMEM;
|
2009-06-07 17:44:36 +00:00
|
|
|
fat_inode = new_inode(sb);
|
|
|
|
if (!fat_inode)
|
|
|
|
goto out_fail;
|
|
|
|
sbi->fat_inode = fat_inode;
|
2012-05-31 23:26:12 +00:00
|
|
|
|
|
|
|
fsinfo_inode = new_inode(sb);
|
|
|
|
if (!fsinfo_inode)
|
|
|
|
goto out_fail;
|
|
|
|
fsinfo_inode->i_ino = MSDOS_FSINFO_INO;
|
|
|
|
sbi->fsinfo_inode = fsinfo_inode;
|
|
|
|
insert_inode_hash(fsinfo_inode);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
root_inode = new_inode(sb);
|
|
|
|
if (!root_inode)
|
|
|
|
goto out_fail;
|
|
|
|
root_inode->i_ino = MSDOS_ROOT_INO;
|
2017-12-11 11:35:09 +00:00
|
|
|
inode_set_iversion(root_inode, 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
error = fat_read_root(root_inode);
|
2012-02-13 03:06:33 +00:00
|
|
|
if (error < 0) {
|
|
|
|
iput(root_inode);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out_fail;
|
2012-02-13 03:06:33 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
error = -ENOMEM;
|
|
|
|
insert_inode_hash(root_inode);
|
2012-10-05 00:14:45 +00:00
|
|
|
fat_attach(root_inode, 0);
|
2012-02-13 03:06:33 +00:00
|
|
|
sb->s_root = d_make_root(root_inode);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!sb->s_root) {
|
2011-04-12 12:08:38 +00:00
|
|
|
fat_msg(sb, KERN_ERR, "get root inode failed");
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out_fail;
|
|
|
|
}
|
|
|
|
|
2012-12-18 00:02:56 +00:00
|
|
|
if (sbi->options.discard) {
|
|
|
|
struct request_queue *q = bdev_get_queue(sb->s_bdev);
|
|
|
|
if (!blk_queue_discard(q))
|
|
|
|
fat_msg(sb, KERN_WARNING,
|
|
|
|
"mounting with \"discard\" option, but "
|
|
|
|
"the device does not support discard");
|
|
|
|
}
|
|
|
|
|
2013-02-28 01:03:09 +00:00
|
|
|
fat_set_state(sb, 1, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_invalid:
|
|
|
|
error = -EINVAL;
|
|
|
|
if (!silent)
|
2011-04-12 12:08:38 +00:00
|
|
|
fat_msg(sb, KERN_INFO, "Can't find a valid FAT filesystem");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
out_fail:
|
2012-05-31 23:26:12 +00:00
|
|
|
if (fsinfo_inode)
|
|
|
|
iput(fsinfo_inode);
|
2009-06-07 17:44:36 +00:00
|
|
|
if (fat_inode)
|
|
|
|
iput(fat_inode);
|
2010-03-15 20:48:09 +00:00
|
|
|
unload_nls(sbi->nls_io);
|
|
|
|
unload_nls(sbi->nls_disk);
|
2018-07-21 00:53:42 +00:00
|
|
|
fat_reset_iocharset(&sbi->options);
|
2005-04-16 22:20:36 +00:00
|
|
|
sb->s_fs_info = NULL;
|
|
|
|
kfree(sbi);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-01-08 09:02:10 +00:00
|
|
|
EXPORT_SYMBOL_GPL(fat_fill_super);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-09-29 09:00:03 +00:00
|
|
|
/*
|
|
|
|
* helper function for fat_flush_inodes. This writes both the inode
|
|
|
|
* and the file data blocks, waiting for in flight data blocks before
|
|
|
|
* the start of the call. It does not wait for any io started
|
|
|
|
* during the call
|
|
|
|
*/
|
|
|
|
static int writeback_inode(struct inode *inode)
|
|
|
|
{
|
|
|
|
|
|
|
|
int ret;
|
2012-10-05 00:15:04 +00:00
|
|
|
|
|
|
|
/* if we used wait=1, sync_inode_metadata waits for the io for the
|
|
|
|
* inode to finish. So wait=0 is sent down to sync_inode_metadata
|
2006-09-29 09:00:03 +00:00
|
|
|
* and filemap_fdatawrite is used for the data blocks
|
|
|
|
*/
|
2012-10-05 00:15:04 +00:00
|
|
|
ret = sync_inode_metadata(inode, 0);
|
2006-09-29 09:00:03 +00:00
|
|
|
if (!ret)
|
2012-10-05 00:15:04 +00:00
|
|
|
ret = filemap_fdatawrite(inode->i_mapping);
|
2006-09-29 09:00:03 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* write data and metadata corresponding to i1 and i2. The io is
|
|
|
|
* started but we do not wait for any of it to finish.
|
|
|
|
*
|
|
|
|
* filemap_flush is used for the block device, so if there is a dirty
|
|
|
|
* page for a block already in flight, we will not wait and start the
|
|
|
|
* io over again
|
|
|
|
*/
|
|
|
|
int fat_flush_inodes(struct super_block *sb, struct inode *i1, struct inode *i2)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
if (!MSDOS_SB(sb)->options.flush)
|
|
|
|
return 0;
|
|
|
|
if (i1)
|
|
|
|
ret = writeback_inode(i1);
|
|
|
|
if (!ret && i2)
|
|
|
|
ret = writeback_inode(i2);
|
2006-10-11 08:21:59 +00:00
|
|
|
if (!ret) {
|
2006-09-29 09:00:03 +00:00
|
|
|
struct address_space *mapping = sb->s_bdev->bd_inode->i_mapping;
|
|
|
|
ret = filemap_flush(mapping);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(fat_flush_inodes);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int __init init_fat_fs(void)
|
|
|
|
{
|
2005-06-30 09:59:01 +00:00
|
|
|
int err;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-06-30 09:59:01 +00:00
|
|
|
err = fat_cache_init();
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = fat_init_inodecache();
|
|
|
|
if (err)
|
|
|
|
goto failed;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
failed:
|
|
|
|
fat_cache_destroy();
|
|
|
|
return err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit exit_fat_fs(void)
|
|
|
|
{
|
|
|
|
fat_cache_destroy();
|
|
|
|
fat_destroy_inodecache();
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(init_fat_fs)
|
|
|
|
module_exit(exit_fat_fs)
|
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|