iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

staging: exfat: Remove FAT/VFAT mount support, part 1

Browse Source 
Remove the top-level mount functionality, to make this driver handle
only exfat file systems.

Signed-off-by: Valdis Kletnieks <Valdis.Kletnieks@vt.edu>
Link: https://lore.kernel.org/r/20191112211238.156490-2-Valdis.Kletnieks@vt.edu
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Valdis Kletnieks 2019-11-12 16:12:27 -05:00 committed by Greg Kroah-Hartman
parent ecbc9e989f
commit 04a991cd90
4 changed files with 1 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
drivers/staging/exfat/Kconfig
View File

@ -6,15 +6,6 @@ config EXFAT_FS
help
This adds support for the exFAT file system.
config EXFAT_DONT_MOUNT_VFAT
bool "Prohibit mounting of fat/vfat filesystems by exFAT"
depends on EXFAT_FS
default y
help
By default, the exFAT driver will only mount exFAT filesystems, and refuse
to mount fat/vfat filesystems. Set this to 'n' to allow the exFAT driver
to mount these filesystems.
config EXFAT_DISCARD
bool "enable discard support"
depends on EXFAT_FS

2
drivers/staging/exfat/exfat.h
View File

@ -915,8 +915,6 @@ s32 resolve_path(struct inode *inode, char *path, struct chain_t *p_dir,
s32 resolve_name(u8 *name, u8 **arg);
/* file operation functions */
s32 fat16_mount(struct super_block *sb, struct pbr_sector_t *p_pbr);
s32 fat32_mount(struct super_block *sb, struct pbr_sector_t *p_pbr);
s32 exfat_mount(struct super_block *sb, struct pbr_sector_t *p_pbr);
s32 create_dir(struct inode *inode, struct chain_t *p_dir,
struct uni_name_t *p_uniname, struct file_id_t *fid);

193
drivers/staging/exfat/exfat_core.c
View File

@ -1284,57 +1284,6 @@ s32 exfat_init_dir_entry(struct super_block *sb, struct chain_t *p_dir,
return 0;
}
static s32 fat_init_ext_entry(struct super_block *sb, struct chain_t *p_dir,
s32 entry, s32 num_entries,
struct uni_name_t *p_uniname,
struct dos_name_t *p_dosname)
{
int i;
sector_t sector;
u8 chksum;
u16 *uniname = p_uniname->name;
struct dos_dentry_t *dos_ep;
struct ext_dentry_t *ext_ep;
dos_ep = (struct dos_dentry_t *)get_entry_in_dir(sb, p_dir, entry,
&sector);
if (!dos_ep)
return -EIO;
dos_ep->lcase = p_dosname->name_case;
memcpy(dos_ep->name, p_dosname->name, DOS_NAME_LENGTH);
buf_modify(sb, sector);
if ((--num_entries) > 0) {
chksum = calc_checksum_1byte((void *)dos_ep->name,
DOS_NAME_LENGTH, 0);
for (i = 1; i < num_entries; i++) {
ext_ep = (struct ext_dentry_t *)get_entry_in_dir(sb,
p_dir,
entry - i,
&sector);
if (!ext_ep)
return -EIO;
init_ext_entry(ext_ep, i, chksum, uniname);
buf_modify(sb, sector);
uniname += 13;
}
ext_ep = (struct ext_dentry_t *)get_entry_in_dir(sb, p_dir,
entry - i,
&sector);
if (!ext_ep)
return -EIO;
init_ext_entry(ext_ep, i + 0x40, chksum, uniname);
buf_modify(sb, sector);
}
return 0;
}
static s32 exfat_init_ext_entry(struct super_block *sb, struct chain_t *p_dir,
s32 entry, s32 num_entries,
struct uni_name_t *p_uniname,
@ -2981,148 +2930,6 @@ s32 resolve_path(struct inode *inode, char *path, struct chain_t *p_dir,
/*
* File Operation Functions
*/
static struct fs_func fat_fs_func = {
.alloc_cluster = fat_alloc_cluster,
.free_cluster = fat_free_cluster,
.count_used_clusters = fat_count_used_clusters,
.init_dir_entry = fat_init_dir_entry,
.init_ext_entry = fat_init_ext_entry,
.find_dir_entry = fat_find_dir_entry,
.delete_dir_entry = fat_delete_dir_entry,
.get_uni_name_from_ext_entry = fat_get_uni_name_from_ext_entry,
.count_ext_entries = fat_count_ext_entries,
.calc_num_entries = fat_calc_num_entries,
.get_entry_type = fat_get_entry_type,
.set_entry_type = fat_set_entry_type,
.get_entry_attr = fat_get_entry_attr,
.set_entry_attr = fat_set_entry_attr,
.get_entry_flag = fat_get_entry_flag,
.set_entry_flag = fat_set_entry_flag,
.get_entry_clu0 = fat_get_entry_clu0,
.set_entry_clu0 = fat_set_entry_clu0,
.get_entry_size = fat_get_entry_size,
.set_entry_size = fat_set_entry_size,
.get_entry_time = fat_get_entry_time,
.set_entry_time = fat_set_entry_time,
};
s32 fat16_mount(struct super_block *sb, struct pbr_sector_t *p_pbr)
{
s32 num_reserved, num_root_sectors;
struct bpb16_t *p_bpb = (struct bpb16_t *)p_pbr->bpb;
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
if (p_bpb->num_fats == 0)
return -EFSCORRUPTED;
num_root_sectors = GET16(p_bpb->num_root_entries) << DENTRY_SIZE_BITS;
num_root_sectors = ((num_root_sectors - 1) >>
p_bd->sector_size_bits) + 1;
p_fs->sectors_per_clu = p_bpb->sectors_per_clu;
p_fs->sectors_per_clu_bits = ilog2(p_bpb->sectors_per_clu);
p_fs->cluster_size_bits = p_fs->sectors_per_clu_bits +
p_bd->sector_size_bits;
p_fs->cluster_size = 1 << p_fs->cluster_size_bits;
p_fs->num_FAT_sectors = GET16(p_bpb->num_fat_sectors);
p_fs->FAT1_start_sector = p_fs->PBR_sector + GET16(p_bpb->num_reserved);
if (p_bpb->num_fats == 1)
p_fs->FAT2_start_sector = p_fs->FAT1_start_sector;
else
p_fs->FAT2_start_sector = p_fs->FAT1_start_sector +
p_fs->num_FAT_sectors;
p_fs->root_start_sector = p_fs->FAT2_start_sector +
p_fs->num_FAT_sectors;
p_fs->data_start_sector = p_fs->root_start_sector + num_root_sectors;
p_fs->num_sectors = GET16(p_bpb->num_sectors);
if (p_fs->num_sectors == 0)
p_fs->num_sectors = GET32(p_bpb->num_huge_sectors);
num_reserved = p_fs->data_start_sector - p_fs->PBR_sector;
p_fs->num_clusters = ((p_fs->num_sectors - num_reserved) >>
p_fs->sectors_per_clu_bits) + 2;
/* because the cluster index starts with 2 */
if (p_fs->num_clusters < FAT12_THRESHOLD)
p_fs->vol_type = FAT12;
else
p_fs->vol_type = FAT16;
p_fs->vol_id = GET32(p_bpb->vol_serial);
p_fs->root_dir = 0;
p_fs->dentries_in_root = GET16(p_bpb->num_root_entries);
p_fs->dentries_per_clu = 1 << (p_fs->cluster_size_bits -
DENTRY_SIZE_BITS);
p_fs->vol_flag = VOL_CLEAN;
p_fs->clu_srch_ptr = 2;
p_fs->used_clusters = UINT_MAX;
p_fs->fs_func = &fat_fs_func;
return 0;
}
s32 fat32_mount(struct super_block *sb, struct pbr_sector_t *p_pbr)
{
s32 num_reserved;
struct bpb32_t *p_bpb = (struct bpb32_t *)p_pbr->bpb;
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
if (p_bpb->num_fats == 0)
return -EFSCORRUPTED;
p_fs->sectors_per_clu = p_bpb->sectors_per_clu;
p_fs->sectors_per_clu_bits = ilog2(p_bpb->sectors_per_clu);
p_fs->cluster_size_bits = p_fs->sectors_per_clu_bits +
p_bd->sector_size_bits;
p_fs->cluster_size = 1 << p_fs->cluster_size_bits;
p_fs->num_FAT_sectors = GET32(p_bpb->num_fat32_sectors);
p_fs->FAT1_start_sector = p_fs->PBR_sector + GET16(p_bpb->num_reserved);
if (p_bpb->num_fats == 1)
p_fs->FAT2_start_sector = p_fs->FAT1_start_sector;
else
p_fs->FAT2_start_sector = p_fs->FAT1_start_sector +
p_fs->num_FAT_sectors;
p_fs->root_start_sector = p_fs->FAT2_start_sector +
p_fs->num_FAT_sectors;
p_fs->data_start_sector = p_fs->root_start_sector;
p_fs->num_sectors = GET32(p_bpb->num_huge_sectors);
num_reserved = p_fs->data_start_sector - p_fs->PBR_sector;
p_fs->num_clusters = ((p_fs->num_sectors - num_reserved) >>
p_fs->sectors_per_clu_bits) + 2;
/* because the cluster index starts with 2 */
p_fs->vol_type = FAT32;
p_fs->vol_id = GET32(p_bpb->vol_serial);
p_fs->root_dir = GET32(p_bpb->root_cluster);
p_fs->dentries_in_root = 0;
p_fs->dentries_per_clu = 1 << (p_fs->cluster_size_bits -
DENTRY_SIZE_BITS);
p_fs->vol_flag = VOL_CLEAN;
p_fs->clu_srch_ptr = 2;
p_fs->used_clusters = UINT_MAX;
p_fs->fs_func = &fat_fs_func;
return 0;
}
static struct fs_func exfat_fs_func = {
.alloc_cluster = exfat_alloc_cluster,
.free_cluster = exfat_free_cluster,

8
drivers/staging/exfat/exfat_super.c
View File

@ -396,16 +396,10 @@ static int ffsMountVol(struct super_block *sb)
break;
if (i < 53) {
#ifdef CONFIG_EXFAT_DONT_MOUNT_VFAT
/* Not sure how we'd get here, but complain if it does */
ret = -EINVAL;
pr_info("EXFAT: Attempted to mount VFAT filesystem\n");
goto out;
#else
if (GET16(p_pbr->bpb + 11)) /* num_fat_sectors */
ret = fat16_mount(sb, p_pbr);
else
ret = fat32_mount(sb, p_pbr);
#endif
} else {
ret = exfat_mount(sb, p_pbr);
}