mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-14 06:35:12 +00:00
52b0c4709d
Remove 'fs_func struct' and change indirect calls to direct calls. The following issues are described in exfat's TODO. > Create helper function for exfat_set_entry_time () and > exfat_set_entry_type () because it's sort of ugly to be calling the same functionn directly and other code calling through the fs_func struc ponters ... The fs_func struct was used for switching the helper functions of fat16/fat32/exfat. Now, it has lost the role of switching, just making the code less readable. Signed-off-by: Tetsuhiro Kohada <Kohada.Tetsuhiro@dc.MitsubishiElectric.co.jp> Link: https://lore.kernel.org/r/20200123102445.123033-1-Kohada.Tetsuhiro@dc.MitsubishiElectric.co.jp Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
3883 lines
91 KiB
C
3883 lines
91 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/init.h>
|
|
#include <linux/time.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/seq_file.h>
|
|
#include <linux/pagemap.h>
|
|
#include <linux/mpage.h>
|
|
#include <linux/buffer_head.h>
|
|
#include <linux/exportfs.h>
|
|
#include <linux/mount.h>
|
|
#include <linux/vfs.h>
|
|
#include <linux/aio.h>
|
|
#include <linux/iversion.h>
|
|
#include <linux/parser.h>
|
|
#include <linux/uio.h>
|
|
#include <linux/writeback.h>
|
|
#include <linux/log2.h>
|
|
#include <linux/hash.h>
|
|
#include <linux/backing-dev.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/fs_struct.h>
|
|
#include <linux/namei.h>
|
|
#include <linux/random.h>
|
|
#include <linux/string.h>
|
|
#include <linux/nls.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/swap.h>
|
|
|
|
#define EXFAT_VERSION "1.3.0"
|
|
|
|
#include "exfat.h"
|
|
|
|
static struct kmem_cache *exfat_inode_cachep;
|
|
|
|
static int exfat_default_codepage = CONFIG_STAGING_EXFAT_DEFAULT_CODEPAGE;
|
|
static char exfat_default_iocharset[] = CONFIG_STAGING_EXFAT_DEFAULT_IOCHARSET;
|
|
|
|
#define INC_IVERSION(x) (inode_inc_iversion(x))
|
|
#define GET_IVERSION(x) (inode_peek_iversion_raw(x))
|
|
#define SET_IVERSION(x, y) (inode_set_iversion(x, y))
|
|
|
|
static struct inode *exfat_iget(struct super_block *sb, loff_t i_pos);
|
|
static int exfat_sync_inode(struct inode *inode);
|
|
static struct inode *exfat_build_inode(struct super_block *sb,
|
|
struct file_id_t *fid, loff_t i_pos);
|
|
static int exfat_write_inode(struct inode *inode,
|
|
struct writeback_control *wbc);
|
|
static void exfat_write_super(struct super_block *sb);
|
|
|
|
#define UNIX_SECS_1980 315532800L
|
|
#define UNIX_SECS_2108 4354819200L
|
|
|
|
/* Convert a FAT time/date pair to a UNIX date (seconds since 1 1 70). */
|
|
static void exfat_time_fat2unix(struct timespec64 *ts, struct date_time_t *tp)
|
|
{
|
|
ts->tv_sec = mktime64(tp->Year + 1980, tp->Month + 1, tp->Day,
|
|
tp->Hour, tp->Minute, tp->Second);
|
|
|
|
ts->tv_nsec = tp->MilliSecond * NSEC_PER_MSEC;
|
|
}
|
|
|
|
/* Convert linear UNIX date to a FAT time/date pair. */
|
|
static void exfat_time_unix2fat(struct timespec64 *ts, struct date_time_t *tp)
|
|
{
|
|
time64_t second = ts->tv_sec;
|
|
struct tm tm;
|
|
|
|
time64_to_tm(second, 0, &tm);
|
|
|
|
if (second < UNIX_SECS_1980) {
|
|
tp->MilliSecond = 0;
|
|
tp->Second = 0;
|
|
tp->Minute = 0;
|
|
tp->Hour = 0;
|
|
tp->Day = 1;
|
|
tp->Month = 1;
|
|
tp->Year = 0;
|
|
return;
|
|
}
|
|
|
|
if (second >= UNIX_SECS_2108) {
|
|
tp->MilliSecond = 999;
|
|
tp->Second = 59;
|
|
tp->Minute = 59;
|
|
tp->Hour = 23;
|
|
tp->Day = 31;
|
|
tp->Month = 12;
|
|
tp->Year = 127;
|
|
return;
|
|
}
|
|
|
|
tp->MilliSecond = ts->tv_nsec / NSEC_PER_MSEC;
|
|
tp->Second = tm.tm_sec;
|
|
tp->Minute = tm.tm_min;
|
|
tp->Hour = tm.tm_hour;
|
|
tp->Day = tm.tm_mday;
|
|
tp->Month = tm.tm_mon + 1;
|
|
tp->Year = tm.tm_year + 1900 - 1980;
|
|
}
|
|
|
|
struct timestamp_t *tm_current(struct timestamp_t *tp)
|
|
{
|
|
time64_t second = ktime_get_real_seconds();
|
|
struct tm tm;
|
|
|
|
time64_to_tm(second, 0, &tm);
|
|
|
|
if (second < UNIX_SECS_1980) {
|
|
tp->sec = 0;
|
|
tp->min = 0;
|
|
tp->hour = 0;
|
|
tp->day = 1;
|
|
tp->mon = 1;
|
|
tp->year = 0;
|
|
return tp;
|
|
}
|
|
|
|
if (second >= UNIX_SECS_2108) {
|
|
tp->sec = 59;
|
|
tp->min = 59;
|
|
tp->hour = 23;
|
|
tp->day = 31;
|
|
tp->mon = 12;
|
|
tp->year = 127;
|
|
return tp;
|
|
}
|
|
|
|
tp->sec = tm.tm_sec;
|
|
tp->min = tm.tm_min;
|
|
tp->hour = tm.tm_hour;
|
|
tp->day = tm.tm_mday;
|
|
tp->mon = tm.tm_mon + 1;
|
|
tp->year = tm.tm_year + 1900 - 1980;
|
|
|
|
return tp;
|
|
}
|
|
|
|
static void __lock_super(struct super_block *sb)
|
|
{
|
|
struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
|
|
|
mutex_lock(&sbi->s_lock);
|
|
}
|
|
|
|
static void __unlock_super(struct super_block *sb)
|
|
{
|
|
struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
|
|
|
mutex_unlock(&sbi->s_lock);
|
|
}
|
|
|
|
static int __is_sb_dirty(struct super_block *sb)
|
|
{
|
|
struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
|
|
|
return sbi->s_dirt;
|
|
}
|
|
|
|
static void __set_sb_clean(struct super_block *sb)
|
|
{
|
|
struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
|
|
|
sbi->s_dirt = 0;
|
|
}
|
|
|
|
static int __exfat_revalidate(struct dentry *dentry)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static int exfat_revalidate(struct dentry *dentry, unsigned int flags)
|
|
{
|
|
if (flags & LOOKUP_RCU)
|
|
return -ECHILD;
|
|
|
|
if (dentry->d_inode)
|
|
return 1;
|
|
return __exfat_revalidate(dentry);
|
|
}
|
|
|
|
static int exfat_revalidate_ci(struct dentry *dentry, unsigned int flags)
|
|
{
|
|
if (flags & LOOKUP_RCU)
|
|
return -ECHILD;
|
|
|
|
if (dentry->d_inode)
|
|
return 1;
|
|
|
|
if (!flags)
|
|
return 0;
|
|
|
|
if (flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
|
|
return 0;
|
|
|
|
return __exfat_revalidate(dentry);
|
|
}
|
|
|
|
static unsigned int __exfat_striptail_len(unsigned int len, const char *name)
|
|
{
|
|
while (len && name[len - 1] == '.')
|
|
len--;
|
|
return len;
|
|
}
|
|
|
|
static unsigned int exfat_striptail_len(const struct qstr *qstr)
|
|
{
|
|
return __exfat_striptail_len(qstr->len, qstr->name);
|
|
}
|
|
|
|
static int exfat_d_hash(const struct dentry *dentry, struct qstr *qstr)
|
|
{
|
|
qstr->hash = full_name_hash(dentry, qstr->name,
|
|
exfat_striptail_len(qstr));
|
|
return 0;
|
|
}
|
|
|
|
static int exfat_d_hashi(const struct dentry *dentry, struct qstr *qstr)
|
|
{
|
|
struct super_block *sb = dentry->d_sb;
|
|
const unsigned char *name;
|
|
unsigned int len;
|
|
unsigned long hash;
|
|
|
|
name = qstr->name;
|
|
len = exfat_striptail_len(qstr);
|
|
|
|
hash = init_name_hash(dentry);
|
|
while (len--)
|
|
hash = partial_name_hash(nls_upper(sb, *name++), hash);
|
|
qstr->hash = end_name_hash(hash);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int exfat_cmpi(const struct dentry *dentry, unsigned int len,
|
|
const char *str, const struct qstr *name)
|
|
{
|
|
struct nls_table *t = EXFAT_SB(dentry->d_sb)->nls_io;
|
|
unsigned int alen, blen;
|
|
|
|
alen = exfat_striptail_len(name);
|
|
blen = __exfat_striptail_len(len, str);
|
|
if (alen == blen) {
|
|
if (!t) {
|
|
if (strncasecmp(name->name, str, alen) == 0)
|
|
return 0;
|
|
} else {
|
|
if (nls_strnicmp(t, name->name, str, alen) == 0)
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int exfat_cmp(const struct dentry *dentry, unsigned int len,
|
|
const char *str, const struct qstr *name)
|
|
{
|
|
unsigned int alen, blen;
|
|
|
|
alen = exfat_striptail_len(name);
|
|
blen = __exfat_striptail_len(len, str);
|
|
if (alen == blen) {
|
|
if (strncmp(name->name, str, alen) == 0)
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static const struct dentry_operations exfat_ci_dentry_ops = {
|
|
.d_revalidate = exfat_revalidate_ci,
|
|
.d_hash = exfat_d_hashi,
|
|
.d_compare = exfat_cmpi,
|
|
};
|
|
|
|
static const struct dentry_operations exfat_dentry_ops = {
|
|
.d_revalidate = exfat_revalidate,
|
|
.d_hash = exfat_d_hash,
|
|
.d_compare = exfat_cmp,
|
|
};
|
|
|
|
static DEFINE_MUTEX(z_mutex);
|
|
|
|
static inline void fs_sync(struct super_block *sb, bool do_sync)
|
|
{
|
|
if (do_sync)
|
|
exfat_bdev_sync(sb);
|
|
}
|
|
|
|
/*
|
|
* If ->i_mode can't hold S_IWUGO (i.e. ATTR_RO), we use ->i_attrs to
|
|
* save ATTR_RO instead of ->i_mode.
|
|
*
|
|
* If it's directory and !sbi->options.rodir, ATTR_RO isn't read-only
|
|
* bit, it's just used as flag for app.
|
|
*/
|
|
static inline int exfat_mode_can_hold_ro(struct inode *inode)
|
|
{
|
|
struct exfat_sb_info *sbi = EXFAT_SB(inode->i_sb);
|
|
|
|
if (S_ISDIR(inode->i_mode))
|
|
return 0;
|
|
|
|
if ((~sbi->options.fs_fmask) & 0222)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
/* Convert attribute bits and a mask to the UNIX mode. */
|
|
static inline mode_t exfat_make_mode(struct exfat_sb_info *sbi, u32 attr,
|
|
mode_t mode)
|
|
{
|
|
if ((attr & ATTR_READONLY) && !(attr & ATTR_SUBDIR))
|
|
mode &= ~0222;
|
|
|
|
if (attr & ATTR_SUBDIR)
|
|
return (mode & ~sbi->options.fs_dmask) | S_IFDIR;
|
|
else if (attr & ATTR_SYMLINK)
|
|
return (mode & ~sbi->options.fs_dmask) | S_IFLNK;
|
|
else
|
|
return (mode & ~sbi->options.fs_fmask) | S_IFREG;
|
|
}
|
|
|
|
/* Return the FAT attribute byte for this inode */
|
|
static inline u32 exfat_make_attr(struct inode *inode)
|
|
{
|
|
if (exfat_mode_can_hold_ro(inode) && !(inode->i_mode & 0222))
|
|
return (EXFAT_I(inode)->fid.attr) | ATTR_READONLY;
|
|
else
|
|
return EXFAT_I(inode)->fid.attr;
|
|
}
|
|
|
|
static inline void exfat_save_attr(struct inode *inode, u32 attr)
|
|
{
|
|
if (exfat_mode_can_hold_ro(inode))
|
|
EXFAT_I(inode)->fid.attr = attr & ATTR_RWMASK;
|
|
else
|
|
EXFAT_I(inode)->fid.attr = attr & (ATTR_RWMASK | ATTR_READONLY);
|
|
}
|
|
|
|
static int ffsMountVol(struct super_block *sb)
|
|
{
|
|
int i, ret;
|
|
struct pbr_sector_t *p_pbr;
|
|
struct buffer_head *tmp_bh = NULL;
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
|
|
|
|
pr_info("[EXFAT] trying to mount...\n");
|
|
|
|
mutex_lock(&z_mutex);
|
|
|
|
exfat_buf_init(sb);
|
|
|
|
mutex_init(&p_fs->v_mutex);
|
|
p_fs->dev_ejected = 0;
|
|
|
|
/* open the block device */
|
|
exfat_bdev_open(sb);
|
|
|
|
if (p_bd->sector_size < sb->s_blocksize) {
|
|
printk(KERN_INFO "EXFAT: mount failed - sector size %d less than blocksize %ld\n",
|
|
p_bd->sector_size, sb->s_blocksize);
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
if (p_bd->sector_size > sb->s_blocksize)
|
|
sb_set_blocksize(sb, p_bd->sector_size);
|
|
|
|
/* read Sector 0 */
|
|
if (sector_read(sb, 0, &tmp_bh, 1) != 0) {
|
|
ret = -EIO;
|
|
goto out;
|
|
}
|
|
|
|
p_fs->PBR_sector = 0;
|
|
|
|
p_pbr = (struct pbr_sector_t *)tmp_bh->b_data;
|
|
|
|
/* check the validity of PBR */
|
|
if (GET16_A(p_pbr->signature) != PBR_SIGNATURE) {
|
|
brelse(tmp_bh);
|
|
exfat_bdev_close(sb);
|
|
ret = -EFSCORRUPTED;
|
|
goto out;
|
|
}
|
|
|
|
/* fill fs_struct */
|
|
for (i = 0; i < 53; i++)
|
|
if (p_pbr->bpb[i])
|
|
break;
|
|
|
|
if (i < 53) {
|
|
/* 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 {
|
|
ret = exfat_mount(sb, p_pbr);
|
|
}
|
|
|
|
brelse(tmp_bh);
|
|
|
|
if (ret) {
|
|
exfat_bdev_close(sb);
|
|
goto out;
|
|
}
|
|
|
|
ret = load_alloc_bitmap(sb);
|
|
if (ret) {
|
|
exfat_bdev_close(sb);
|
|
goto out;
|
|
}
|
|
ret = load_upcase_table(sb);
|
|
if (ret) {
|
|
free_alloc_bitmap(sb);
|
|
exfat_bdev_close(sb);
|
|
goto out;
|
|
}
|
|
|
|
if (p_fs->dev_ejected) {
|
|
free_upcase_table(sb);
|
|
free_alloc_bitmap(sb);
|
|
exfat_bdev_close(sb);
|
|
ret = -EIO;
|
|
goto out;
|
|
}
|
|
|
|
pr_info("[EXFAT] mounted successfully\n");
|
|
|
|
out:
|
|
mutex_unlock(&z_mutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int ffsUmountVol(struct super_block *sb)
|
|
{
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
int err = 0;
|
|
|
|
pr_info("[EXFAT] trying to unmount...\n");
|
|
|
|
mutex_lock(&z_mutex);
|
|
|
|
/* acquire the lock for file system critical section */
|
|
mutex_lock(&p_fs->v_mutex);
|
|
|
|
fs_sync(sb, true);
|
|
fs_set_vol_flags(sb, VOL_CLEAN);
|
|
|
|
free_upcase_table(sb);
|
|
free_alloc_bitmap(sb);
|
|
|
|
exfat_fat_release_all(sb);
|
|
exfat_buf_release_all(sb);
|
|
|
|
/* close the block device */
|
|
exfat_bdev_close(sb);
|
|
|
|
if (p_fs->dev_ejected) {
|
|
pr_info("[EXFAT] unmounted with media errors. Device is already ejected.\n");
|
|
err = -EIO;
|
|
}
|
|
|
|
exfat_buf_shutdown(sb);
|
|
|
|
/* release the lock for file system critical section */
|
|
mutex_unlock(&p_fs->v_mutex);
|
|
mutex_unlock(&z_mutex);
|
|
|
|
pr_info("[EXFAT] unmounted successfully\n");
|
|
|
|
return err;
|
|
}
|
|
|
|
static int ffsGetVolInfo(struct super_block *sb, struct vol_info_t *info)
|
|
{
|
|
int err = 0;
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
|
|
/* check the validity of pointer parameters */
|
|
if (!info)
|
|
return -EINVAL;
|
|
|
|
/* acquire the lock for file system critical section */
|
|
mutex_lock(&p_fs->v_mutex);
|
|
|
|
if (p_fs->used_clusters == UINT_MAX)
|
|
p_fs->used_clusters = exfat_count_used_clusters(sb);
|
|
|
|
info->FatType = p_fs->vol_type;
|
|
info->ClusterSize = p_fs->cluster_size;
|
|
info->NumClusters = p_fs->num_clusters - 2; /* clu 0 & 1 */
|
|
info->UsedClusters = p_fs->used_clusters;
|
|
info->FreeClusters = info->NumClusters - info->UsedClusters;
|
|
|
|
if (p_fs->dev_ejected)
|
|
err = -EIO;
|
|
|
|
/* release the lock for file system critical section */
|
|
mutex_unlock(&p_fs->v_mutex);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int ffsSyncVol(struct super_block *sb, bool do_sync)
|
|
{
|
|
int err = 0;
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
|
|
/* acquire the lock for file system critical section */
|
|
mutex_lock(&p_fs->v_mutex);
|
|
|
|
/* synchronize the file system */
|
|
fs_sync(sb, do_sync);
|
|
fs_set_vol_flags(sb, VOL_CLEAN);
|
|
|
|
if (p_fs->dev_ejected)
|
|
err = -EIO;
|
|
|
|
/* release the lock for file system critical section */
|
|
mutex_unlock(&p_fs->v_mutex);
|
|
|
|
return err;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* File Operation Functions */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static int ffsLookupFile(struct inode *inode, char *path, struct file_id_t *fid)
|
|
{
|
|
int ret, dentry, num_entries;
|
|
struct chain_t dir;
|
|
struct uni_name_t uni_name;
|
|
struct dos_name_t dos_name;
|
|
struct dentry_t *ep, *ep2;
|
|
struct entry_set_cache_t *es = NULL;
|
|
struct super_block *sb = inode->i_sb;
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
|
|
pr_debug("%s entered\n", __func__);
|
|
|
|
/* check the validity of pointer parameters */
|
|
if (!fid || !path || (*path == '\0'))
|
|
return -EINVAL;
|
|
|
|
/* acquire the lock for file system critical section */
|
|
mutex_lock(&p_fs->v_mutex);
|
|
|
|
/* check the validity of directory name in the given pathname */
|
|
ret = resolve_path(inode, path, &dir, &uni_name);
|
|
if (ret)
|
|
goto out;
|
|
|
|
ret = get_num_entries_and_dos_name(sb, &dir, &uni_name, &num_entries,
|
|
&dos_name);
|
|
if (ret)
|
|
goto out;
|
|
|
|
/* search the file name for directories */
|
|
dentry = exfat_find_dir_entry(sb, &dir, &uni_name, num_entries,
|
|
&dos_name, TYPE_ALL);
|
|
if (dentry < -1) {
|
|
ret = -ENOENT;
|
|
goto out;
|
|
}
|
|
|
|
fid->dir.dir = dir.dir;
|
|
fid->dir.size = dir.size;
|
|
fid->dir.flags = dir.flags;
|
|
fid->entry = dentry;
|
|
|
|
if (dentry == -1) {
|
|
fid->type = TYPE_DIR;
|
|
fid->rwoffset = 0;
|
|
fid->hint_last_off = -1;
|
|
|
|
fid->attr = ATTR_SUBDIR;
|
|
fid->flags = 0x01;
|
|
fid->size = 0;
|
|
fid->start_clu = p_fs->root_dir;
|
|
} else {
|
|
es = get_entry_set_in_dir(sb, &dir, dentry,
|
|
ES_2_ENTRIES, &ep);
|
|
if (!es) {
|
|
ret = -ENOENT;
|
|
goto out;
|
|
}
|
|
ep2 = ep + 1;
|
|
|
|
fid->type = exfat_get_entry_type(ep);
|
|
fid->rwoffset = 0;
|
|
fid->hint_last_off = -1;
|
|
fid->attr = exfat_get_entry_attr(ep);
|
|
|
|
fid->size = exfat_get_entry_size(ep2);
|
|
if ((fid->type == TYPE_FILE) && (fid->size == 0)) {
|
|
fid->flags = (p_fs->vol_type == EXFAT) ? 0x03 : 0x01;
|
|
fid->start_clu = CLUSTER_32(~0);
|
|
} else {
|
|
fid->flags = exfat_get_entry_flag(ep2);
|
|
fid->start_clu = exfat_get_entry_clu0(ep2);
|
|
}
|
|
|
|
release_entry_set(es);
|
|
}
|
|
|
|
if (p_fs->dev_ejected)
|
|
ret = -EIO;
|
|
out:
|
|
/* release the lock for file system critical section */
|
|
mutex_unlock(&p_fs->v_mutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int ffsCreateFile(struct inode *inode, char *path, u8 mode,
|
|
struct file_id_t *fid)
|
|
{
|
|
struct chain_t dir;
|
|
struct uni_name_t uni_name;
|
|
struct super_block *sb = inode->i_sb;
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
int ret = 0;
|
|
|
|
/* check the validity of pointer parameters */
|
|
if (!fid || !path || (*path == '\0'))
|
|
return -EINVAL;
|
|
|
|
/* acquire the lock for file system critical section */
|
|
mutex_lock(&p_fs->v_mutex);
|
|
|
|
/* check the validity of directory name in the given pathname */
|
|
ret = resolve_path(inode, path, &dir, &uni_name);
|
|
if (ret)
|
|
goto out;
|
|
|
|
fs_set_vol_flags(sb, VOL_DIRTY);
|
|
|
|
/* create a new file */
|
|
ret = create_file(inode, &dir, &uni_name, mode, fid);
|
|
|
|
#ifndef CONFIG_STAGING_EXFAT_DELAYED_SYNC
|
|
fs_sync(sb, true);
|
|
fs_set_vol_flags(sb, VOL_CLEAN);
|
|
#endif
|
|
|
|
if (p_fs->dev_ejected)
|
|
ret = -EIO;
|
|
|
|
out:
|
|
/* release the lock for file system critical section */
|
|
mutex_unlock(&p_fs->v_mutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int ffsReadFile(struct inode *inode, struct file_id_t *fid, void *buffer,
|
|
u64 count, u64 *rcount)
|
|
{
|
|
s32 offset, sec_offset, clu_offset;
|
|
u32 clu;
|
|
int ret = 0;
|
|
sector_t LogSector;
|
|
u64 oneblkread, read_bytes;
|
|
struct buffer_head *tmp_bh = NULL;
|
|
struct super_block *sb = inode->i_sb;
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
|
|
|
|
/* check the validity of the given file id */
|
|
if (!fid)
|
|
return -EINVAL;
|
|
|
|
/* check the validity of pointer parameters */
|
|
if (!buffer)
|
|
return -EINVAL;
|
|
|
|
/* acquire the lock for file system critical section */
|
|
mutex_lock(&p_fs->v_mutex);
|
|
|
|
/* check if the given file ID is opened */
|
|
if (fid->type != TYPE_FILE) {
|
|
ret = -EPERM;
|
|
goto out;
|
|
}
|
|
|
|
if (fid->rwoffset > fid->size)
|
|
fid->rwoffset = fid->size;
|
|
|
|
if (count > (fid->size - fid->rwoffset))
|
|
count = fid->size - fid->rwoffset;
|
|
|
|
if (count == 0) {
|
|
if (rcount)
|
|
*rcount = 0;
|
|
ret = 0;
|
|
goto out;
|
|
}
|
|
|
|
read_bytes = 0;
|
|
|
|
while (count > 0) {
|
|
clu_offset = (s32)(fid->rwoffset >> p_fs->cluster_size_bits);
|
|
clu = fid->start_clu;
|
|
|
|
if (fid->flags == 0x03) {
|
|
clu += clu_offset;
|
|
} else {
|
|
/* hint information */
|
|
if ((clu_offset > 0) && (fid->hint_last_off > 0) &&
|
|
(clu_offset >= fid->hint_last_off)) {
|
|
clu_offset -= fid->hint_last_off;
|
|
clu = fid->hint_last_clu;
|
|
}
|
|
|
|
while (clu_offset > 0) {
|
|
/* clu = exfat_fat_read(sb, clu); */
|
|
if (exfat_fat_read(sb, clu, &clu) == -1) {
|
|
ret = -EIO;
|
|
goto out;
|
|
}
|
|
|
|
clu_offset--;
|
|
}
|
|
}
|
|
|
|
/* hint information */
|
|
fid->hint_last_off = (s32)(fid->rwoffset >>
|
|
p_fs->cluster_size_bits);
|
|
fid->hint_last_clu = clu;
|
|
|
|
/* byte offset in cluster */
|
|
offset = (s32)(fid->rwoffset & (p_fs->cluster_size - 1));
|
|
|
|
/* sector offset in cluster */
|
|
sec_offset = offset >> p_bd->sector_size_bits;
|
|
|
|
/* byte offset in sector */
|
|
offset &= p_bd->sector_size_mask;
|
|
|
|
LogSector = START_SECTOR(clu) + sec_offset;
|
|
|
|
oneblkread = (u64)(p_bd->sector_size - offset);
|
|
if (oneblkread > count)
|
|
oneblkread = count;
|
|
|
|
if ((offset == 0) && (oneblkread == p_bd->sector_size)) {
|
|
if (sector_read(sb, LogSector, &tmp_bh, 1) !=
|
|
0)
|
|
goto err_out;
|
|
memcpy((char *)buffer + read_bytes,
|
|
(char *)tmp_bh->b_data, (s32)oneblkread);
|
|
} else {
|
|
if (sector_read(sb, LogSector, &tmp_bh, 1) !=
|
|
0)
|
|
goto err_out;
|
|
memcpy((char *)buffer + read_bytes,
|
|
(char *)tmp_bh->b_data + offset,
|
|
(s32)oneblkread);
|
|
}
|
|
count -= oneblkread;
|
|
read_bytes += oneblkread;
|
|
fid->rwoffset += oneblkread;
|
|
}
|
|
brelse(tmp_bh);
|
|
|
|
/* How did this ever work and not leak a brlse()?? */
|
|
err_out:
|
|
/* set the size of read bytes */
|
|
if (rcount)
|
|
*rcount = read_bytes;
|
|
|
|
if (p_fs->dev_ejected)
|
|
ret = -EIO;
|
|
|
|
out:
|
|
/* release the lock for file system critical section */
|
|
mutex_unlock(&p_fs->v_mutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int ffsWriteFile(struct inode *inode, struct file_id_t *fid,
|
|
void *buffer, u64 count, u64 *wcount)
|
|
{
|
|
bool modified = false;
|
|
s32 offset, sec_offset, clu_offset;
|
|
s32 num_clusters, num_alloc, num_alloced = (s32)~0;
|
|
int ret = 0;
|
|
u32 clu, last_clu;
|
|
sector_t LogSector;
|
|
u64 oneblkwrite, write_bytes;
|
|
struct chain_t new_clu;
|
|
struct timestamp_t tm;
|
|
struct dentry_t *ep, *ep2;
|
|
struct entry_set_cache_t *es = NULL;
|
|
struct buffer_head *tmp_bh = NULL;
|
|
struct super_block *sb = inode->i_sb;
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
|
|
|
|
/* check the validity of the given file id */
|
|
if (!fid)
|
|
return -EINVAL;
|
|
|
|
/* check the validity of pointer parameters */
|
|
if (!buffer)
|
|
return -EINVAL;
|
|
|
|
/* acquire the lock for file system critical section */
|
|
mutex_lock(&p_fs->v_mutex);
|
|
|
|
/* check if the given file ID is opened */
|
|
if (fid->type != TYPE_FILE) {
|
|
ret = -EPERM;
|
|
goto out;
|
|
}
|
|
|
|
if (fid->rwoffset > fid->size)
|
|
fid->rwoffset = fid->size;
|
|
|
|
if (count == 0) {
|
|
if (wcount)
|
|
*wcount = 0;
|
|
ret = 0;
|
|
goto out;
|
|
}
|
|
|
|
fs_set_vol_flags(sb, VOL_DIRTY);
|
|
|
|
if (fid->size == 0)
|
|
num_clusters = 0;
|
|
else
|
|
num_clusters = (s32)((fid->size - 1) >>
|
|
p_fs->cluster_size_bits) + 1;
|
|
|
|
write_bytes = 0;
|
|
|
|
while (count > 0) {
|
|
clu_offset = (s32)(fid->rwoffset >> p_fs->cluster_size_bits);
|
|
clu = fid->start_clu;
|
|
last_clu = fid->start_clu;
|
|
|
|
if (fid->flags == 0x03) {
|
|
if ((clu_offset > 0) && (clu != CLUSTER_32(~0))) {
|
|
last_clu += clu_offset - 1;
|
|
|
|
if (clu_offset == num_clusters)
|
|
clu = CLUSTER_32(~0);
|
|
else
|
|
clu += clu_offset;
|
|
}
|
|
} else {
|
|
/* hint information */
|
|
if ((clu_offset > 0) && (fid->hint_last_off > 0) &&
|
|
(clu_offset >= fid->hint_last_off)) {
|
|
clu_offset -= fid->hint_last_off;
|
|
clu = fid->hint_last_clu;
|
|
}
|
|
|
|
while ((clu_offset > 0) && (clu != CLUSTER_32(~0))) {
|
|
last_clu = clu;
|
|
/* clu = exfat_fat_read(sb, clu); */
|
|
if (exfat_fat_read(sb, clu, &clu) == -1) {
|
|
ret = -EIO;
|
|
goto out;
|
|
}
|
|
clu_offset--;
|
|
}
|
|
}
|
|
|
|
if (clu == CLUSTER_32(~0)) {
|
|
num_alloc = (s32)((count - 1) >>
|
|
p_fs->cluster_size_bits) + 1;
|
|
new_clu.dir = (last_clu == CLUSTER_32(~0)) ?
|
|
CLUSTER_32(~0) : last_clu + 1;
|
|
new_clu.size = 0;
|
|
new_clu.flags = fid->flags;
|
|
|
|
/* (1) allocate a chain of clusters */
|
|
num_alloced = exfat_alloc_cluster(sb,
|
|
num_alloc,
|
|
&new_clu);
|
|
if (num_alloced == 0)
|
|
break;
|
|
if (num_alloced < 0) {
|
|
ret = num_alloced;
|
|
goto out;
|
|
}
|
|
|
|
/* (2) append to the FAT chain */
|
|
if (last_clu == CLUSTER_32(~0)) {
|
|
if (new_clu.flags == 0x01)
|
|
fid->flags = 0x01;
|
|
fid->start_clu = new_clu.dir;
|
|
modified = true;
|
|
} else {
|
|
if (new_clu.flags != fid->flags) {
|
|
exfat_chain_cont_cluster(sb,
|
|
fid->start_clu,
|
|
num_clusters);
|
|
fid->flags = 0x01;
|
|
modified = true;
|
|
}
|
|
if (new_clu.flags == 0x01)
|
|
exfat_fat_write(sb, last_clu, new_clu.dir);
|
|
}
|
|
|
|
num_clusters += num_alloced;
|
|
clu = new_clu.dir;
|
|
}
|
|
|
|
/* hint information */
|
|
fid->hint_last_off = (s32)(fid->rwoffset >>
|
|
p_fs->cluster_size_bits);
|
|
fid->hint_last_clu = clu;
|
|
|
|
/* byte offset in cluster */
|
|
offset = (s32)(fid->rwoffset & (p_fs->cluster_size - 1));
|
|
|
|
/* sector offset in cluster */
|
|
sec_offset = offset >> p_bd->sector_size_bits;
|
|
|
|
/* byte offset in sector */
|
|
offset &= p_bd->sector_size_mask;
|
|
|
|
LogSector = START_SECTOR(clu) + sec_offset;
|
|
|
|
oneblkwrite = (u64)(p_bd->sector_size - offset);
|
|
if (oneblkwrite > count)
|
|
oneblkwrite = count;
|
|
|
|
if ((offset == 0) && (oneblkwrite == p_bd->sector_size)) {
|
|
if (sector_read(sb, LogSector, &tmp_bh, 0) !=
|
|
0)
|
|
goto err_out;
|
|
memcpy((char *)tmp_bh->b_data,
|
|
(char *)buffer + write_bytes, (s32)oneblkwrite);
|
|
if (sector_write(sb, LogSector, tmp_bh, 0) !=
|
|
0) {
|
|
brelse(tmp_bh);
|
|
goto err_out;
|
|
}
|
|
} else {
|
|
if ((offset > 0) ||
|
|
((fid->rwoffset + oneblkwrite) < fid->size)) {
|
|
if (sector_read(sb, LogSector, &tmp_bh, 1) !=
|
|
0)
|
|
goto err_out;
|
|
} else {
|
|
if (sector_read(sb, LogSector, &tmp_bh, 0) !=
|
|
0)
|
|
goto err_out;
|
|
}
|
|
|
|
memcpy((char *)tmp_bh->b_data + offset,
|
|
(char *)buffer + write_bytes, (s32)oneblkwrite);
|
|
if (sector_write(sb, LogSector, tmp_bh, 0) !=
|
|
0) {
|
|
brelse(tmp_bh);
|
|
goto err_out;
|
|
}
|
|
}
|
|
|
|
count -= oneblkwrite;
|
|
write_bytes += oneblkwrite;
|
|
fid->rwoffset += oneblkwrite;
|
|
|
|
fid->attr |= ATTR_ARCHIVE;
|
|
|
|
if (fid->size < fid->rwoffset) {
|
|
fid->size = fid->rwoffset;
|
|
modified = true;
|
|
}
|
|
}
|
|
|
|
brelse(tmp_bh);
|
|
|
|
/* (3) update the direcoty entry */
|
|
es = get_entry_set_in_dir(sb, &fid->dir, fid->entry,
|
|
ES_ALL_ENTRIES, &ep);
|
|
if (!es)
|
|
goto err_out;
|
|
ep2 = ep + 1;
|
|
|
|
exfat_set_entry_time(ep, tm_current(&tm), TM_MODIFY);
|
|
exfat_set_entry_attr(ep, fid->attr);
|
|
|
|
if (modified) {
|
|
if (exfat_get_entry_flag(ep2) != fid->flags)
|
|
exfat_set_entry_flag(ep2, fid->flags);
|
|
|
|
if (exfat_get_entry_size(ep2) != fid->size)
|
|
exfat_set_entry_size(ep2, fid->size);
|
|
|
|
if (exfat_get_entry_clu0(ep2) != fid->start_clu)
|
|
exfat_set_entry_clu0(ep2, fid->start_clu);
|
|
}
|
|
|
|
update_dir_checksum_with_entry_set(sb, es);
|
|
release_entry_set(es);
|
|
|
|
#ifndef CONFIG_STAGING_EXFAT_DELAYED_SYNC
|
|
fs_sync(sb, true);
|
|
fs_set_vol_flags(sb, VOL_CLEAN);
|
|
#endif
|
|
|
|
err_out:
|
|
/* set the size of written bytes */
|
|
if (wcount)
|
|
*wcount = write_bytes;
|
|
|
|
if (num_alloced == 0)
|
|
ret = -ENOSPC;
|
|
|
|
else if (p_fs->dev_ejected)
|
|
ret = -EIO;
|
|
|
|
out:
|
|
/* release the lock for file system critical section */
|
|
mutex_unlock(&p_fs->v_mutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int ffsTruncateFile(struct inode *inode, u64 old_size, u64 new_size)
|
|
{
|
|
s32 num_clusters;
|
|
u32 last_clu = CLUSTER_32(0);
|
|
int ret = 0;
|
|
struct chain_t clu;
|
|
struct timestamp_t tm;
|
|
struct dentry_t *ep, *ep2;
|
|
struct super_block *sb = inode->i_sb;
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
struct file_id_t *fid = &(EXFAT_I(inode)->fid);
|
|
struct entry_set_cache_t *es = NULL;
|
|
|
|
pr_debug("%s entered (inode %p size %llu)\n", __func__, inode,
|
|
new_size);
|
|
|
|
/* acquire the lock for file system critical section */
|
|
mutex_lock(&p_fs->v_mutex);
|
|
|
|
/* check if the given file ID is opened */
|
|
if (fid->type != TYPE_FILE) {
|
|
ret = -EPERM;
|
|
goto out;
|
|
}
|
|
|
|
if (fid->size != old_size) {
|
|
pr_err("[EXFAT] truncate : can't skip it because of size-mismatch(old:%lld->fid:%lld).\n",
|
|
old_size, fid->size);
|
|
}
|
|
|
|
if (old_size <= new_size) {
|
|
ret = 0;
|
|
goto out;
|
|
}
|
|
|
|
fs_set_vol_flags(sb, VOL_DIRTY);
|
|
|
|
clu.dir = fid->start_clu;
|
|
clu.size = (s32)((old_size - 1) >> p_fs->cluster_size_bits) + 1;
|
|
clu.flags = fid->flags;
|
|
|
|
if (new_size > 0) {
|
|
num_clusters = (s32)((new_size - 1) >>
|
|
p_fs->cluster_size_bits) + 1;
|
|
|
|
if (clu.flags == 0x03) {
|
|
clu.dir += num_clusters;
|
|
} else {
|
|
while (num_clusters > 0) {
|
|
last_clu = clu.dir;
|
|
if (exfat_fat_read(sb, clu.dir, &clu.dir) == -1) {
|
|
ret = -EIO;
|
|
goto out;
|
|
}
|
|
num_clusters--;
|
|
}
|
|
}
|
|
|
|
clu.size -= num_clusters;
|
|
}
|
|
|
|
fid->size = new_size;
|
|
fid->attr |= ATTR_ARCHIVE;
|
|
if (new_size == 0) {
|
|
fid->flags = (p_fs->vol_type == EXFAT) ? 0x03 : 0x01;
|
|
fid->start_clu = CLUSTER_32(~0);
|
|
}
|
|
|
|
/* (1) update the directory entry */
|
|
es = get_entry_set_in_dir(sb, &fid->dir, fid->entry,
|
|
ES_ALL_ENTRIES, &ep);
|
|
if (!es) {
|
|
ret = -ENOENT;
|
|
goto out;
|
|
}
|
|
ep2 = ep + 1;
|
|
|
|
exfat_set_entry_time(ep, tm_current(&tm), TM_MODIFY);
|
|
exfat_set_entry_attr(ep, fid->attr);
|
|
|
|
exfat_set_entry_size(ep2, new_size);
|
|
if (new_size == 0) {
|
|
exfat_set_entry_flag(ep2, 0x01);
|
|
exfat_set_entry_clu0(ep2, CLUSTER_32(0));
|
|
}
|
|
|
|
update_dir_checksum_with_entry_set(sb, es);
|
|
release_entry_set(es);
|
|
|
|
/* (2) cut off from the FAT chain */
|
|
if (last_clu != CLUSTER_32(0)) {
|
|
if (fid->flags == 0x01)
|
|
exfat_fat_write(sb, last_clu, CLUSTER_32(~0));
|
|
}
|
|
|
|
/* (3) free the clusters */
|
|
exfat_free_cluster(sb, &clu, 0);
|
|
|
|
/* hint information */
|
|
fid->hint_last_off = -1;
|
|
if (fid->rwoffset > fid->size)
|
|
fid->rwoffset = fid->size;
|
|
|
|
#ifndef CONFIG_STAGING_EXFAT_DELAYED_SYNC
|
|
fs_sync(sb, true);
|
|
fs_set_vol_flags(sb, VOL_CLEAN);
|
|
#endif
|
|
|
|
if (p_fs->dev_ejected)
|
|
ret = -EIO;
|
|
|
|
out:
|
|
pr_debug("%s exited (%d)\n", __func__, ret);
|
|
/* release the lock for file system critical section */
|
|
mutex_unlock(&p_fs->v_mutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void update_parent_info(struct file_id_t *fid,
|
|
struct inode *parent_inode)
|
|
{
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(parent_inode->i_sb)->fs_info);
|
|
struct file_id_t *parent_fid = &(EXFAT_I(parent_inode)->fid);
|
|
|
|
if (unlikely((parent_fid->flags != fid->dir.flags) ||
|
|
(parent_fid->size !=
|
|
(fid->dir.size << p_fs->cluster_size_bits)) ||
|
|
(parent_fid->start_clu != fid->dir.dir))) {
|
|
fid->dir.dir = parent_fid->start_clu;
|
|
fid->dir.flags = parent_fid->flags;
|
|
fid->dir.size = ((parent_fid->size + (p_fs->cluster_size - 1))
|
|
>> p_fs->cluster_size_bits);
|
|
}
|
|
}
|
|
|
|
static int ffsMoveFile(struct inode *old_parent_inode, struct file_id_t *fid,
|
|
struct inode *new_parent_inode, struct dentry *new_dentry)
|
|
{
|
|
s32 ret;
|
|
s32 dentry;
|
|
struct chain_t olddir, newdir;
|
|
struct chain_t *p_dir = NULL;
|
|
struct uni_name_t uni_name;
|
|
struct dentry_t *ep;
|
|
struct super_block *sb = old_parent_inode->i_sb;
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
u8 *new_path = (u8 *)new_dentry->d_name.name;
|
|
struct inode *new_inode = new_dentry->d_inode;
|
|
int num_entries;
|
|
struct file_id_t *new_fid = NULL;
|
|
s32 new_entry = 0;
|
|
|
|
/* check the validity of the given file id */
|
|
if (!fid)
|
|
return -EINVAL;
|
|
|
|
/* check the validity of pointer parameters */
|
|
if (!new_path || (*new_path == '\0'))
|
|
return -EINVAL;
|
|
|
|
/* acquire the lock for file system critical section */
|
|
mutex_lock(&p_fs->v_mutex);
|
|
|
|
update_parent_info(fid, old_parent_inode);
|
|
|
|
olddir.dir = fid->dir.dir;
|
|
olddir.size = fid->dir.size;
|
|
olddir.flags = fid->dir.flags;
|
|
|
|
dentry = fid->entry;
|
|
|
|
/* check if the old file is "." or ".." */
|
|
if (p_fs->vol_type != EXFAT) {
|
|
if ((olddir.dir != p_fs->root_dir) && (dentry < 2)) {
|
|
ret = -EPERM;
|
|
goto out2;
|
|
}
|
|
}
|
|
|
|
ep = get_entry_in_dir(sb, &olddir, dentry, NULL);
|
|
if (!ep) {
|
|
ret = -ENOENT;
|
|
goto out2;
|
|
}
|
|
|
|
if (exfat_get_entry_attr(ep) & ATTR_READONLY) {
|
|
ret = -EPERM;
|
|
goto out2;
|
|
}
|
|
|
|
/* check whether new dir is existing directory and empty */
|
|
if (new_inode) {
|
|
u32 entry_type;
|
|
|
|
ret = -ENOENT;
|
|
new_fid = &EXFAT_I(new_inode)->fid;
|
|
|
|
update_parent_info(new_fid, new_parent_inode);
|
|
|
|
p_dir = &new_fid->dir;
|
|
new_entry = new_fid->entry;
|
|
ep = get_entry_in_dir(sb, p_dir, new_entry, NULL);
|
|
if (!ep)
|
|
goto out;
|
|
|
|
entry_type = exfat_get_entry_type(ep);
|
|
|
|
if (entry_type == TYPE_DIR) {
|
|
struct chain_t new_clu;
|
|
|
|
new_clu.dir = new_fid->start_clu;
|
|
new_clu.size = (s32)((new_fid->size - 1) >>
|
|
p_fs->cluster_size_bits) + 1;
|
|
new_clu.flags = new_fid->flags;
|
|
|
|
if (!is_dir_empty(sb, &new_clu)) {
|
|
ret = -EEXIST;
|
|
goto out;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* check the validity of directory name in the given new pathname */
|
|
ret = resolve_path(new_parent_inode, new_path, &newdir, &uni_name);
|
|
if (ret)
|
|
goto out2;
|
|
|
|
fs_set_vol_flags(sb, VOL_DIRTY);
|
|
|
|
if (olddir.dir == newdir.dir)
|
|
ret = exfat_rename_file(new_parent_inode, &olddir, dentry,
|
|
&uni_name, fid);
|
|
else
|
|
ret = move_file(new_parent_inode, &olddir, dentry, &newdir,
|
|
&uni_name, fid);
|
|
|
|
if ((ret == 0) && new_inode) {
|
|
/* delete entries of new_dir */
|
|
ep = get_entry_in_dir(sb, p_dir, new_entry, NULL);
|
|
if (!ep)
|
|
goto out;
|
|
|
|
num_entries = exfat_count_ext_entries(sb, p_dir,
|
|
new_entry, ep);
|
|
if (num_entries < 0)
|
|
goto out;
|
|
exfat_delete_dir_entry(sb, p_dir, new_entry, 0,
|
|
num_entries + 1);
|
|
}
|
|
out:
|
|
#ifndef CONFIG_STAGING_EXFAT_DELAYED_SYNC
|
|
fs_sync(sb, true);
|
|
fs_set_vol_flags(sb, VOL_CLEAN);
|
|
#endif
|
|
|
|
if (p_fs->dev_ejected)
|
|
ret = -EIO;
|
|
out2:
|
|
/* release the lock for file system critical section */
|
|
mutex_unlock(&p_fs->v_mutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int ffsRemoveFile(struct inode *inode, struct file_id_t *fid)
|
|
{
|
|
s32 dentry;
|
|
int ret = 0;
|
|
struct chain_t dir, clu_to_free;
|
|
struct dentry_t *ep;
|
|
struct super_block *sb = inode->i_sb;
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
|
|
/* check the validity of the given file id */
|
|
if (!fid)
|
|
return -EINVAL;
|
|
|
|
/* acquire the lock for file system critical section */
|
|
mutex_lock(&p_fs->v_mutex);
|
|
|
|
dir.dir = fid->dir.dir;
|
|
dir.size = fid->dir.size;
|
|
dir.flags = fid->dir.flags;
|
|
|
|
dentry = fid->entry;
|
|
|
|
ep = get_entry_in_dir(sb, &dir, dentry, NULL);
|
|
if (!ep) {
|
|
ret = -ENOENT;
|
|
goto out;
|
|
}
|
|
|
|
if (exfat_get_entry_attr(ep) & ATTR_READONLY) {
|
|
ret = -EPERM;
|
|
goto out;
|
|
}
|
|
fs_set_vol_flags(sb, VOL_DIRTY);
|
|
|
|
/* (1) update the directory entry */
|
|
remove_file(inode, &dir, dentry);
|
|
|
|
clu_to_free.dir = fid->start_clu;
|
|
clu_to_free.size = (s32)((fid->size - 1) >> p_fs->cluster_size_bits) + 1;
|
|
clu_to_free.flags = fid->flags;
|
|
|
|
/* (2) free the clusters */
|
|
exfat_free_cluster(sb, &clu_to_free, 0);
|
|
|
|
fid->size = 0;
|
|
fid->start_clu = CLUSTER_32(~0);
|
|
fid->flags = (p_fs->vol_type == EXFAT) ? 0x03 : 0x01;
|
|
|
|
#ifndef CONFIG_STAGING_EXFAT_DELAYED_SYNC
|
|
fs_sync(sb, true);
|
|
fs_set_vol_flags(sb, VOL_CLEAN);
|
|
#endif
|
|
|
|
if (p_fs->dev_ejected)
|
|
ret = -EIO;
|
|
out:
|
|
/* release the lock for file system critical section */
|
|
mutex_unlock(&p_fs->v_mutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
#if 0
|
|
/* Not currently wired up */
|
|
static int ffsSetAttr(struct inode *inode, u32 attr)
|
|
{
|
|
u32 type;
|
|
int ret = 0;
|
|
sector_t sector = 0;
|
|
struct dentry_t *ep;
|
|
struct super_block *sb = inode->i_sb;
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
struct file_id_t *fid = &(EXFAT_I(inode)->fid);
|
|
u8 is_dir = (fid->type == TYPE_DIR) ? 1 : 0;
|
|
struct entry_set_cache_t *es = NULL;
|
|
|
|
if (fid->attr == attr) {
|
|
if (p_fs->dev_ejected)
|
|
return -EIO;
|
|
return 0;
|
|
}
|
|
|
|
if (is_dir) {
|
|
if ((fid->dir.dir == p_fs->root_dir) &&
|
|
(fid->entry == -1)) {
|
|
if (p_fs->dev_ejected)
|
|
return -EIO;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* acquire the lock for file system critical section */
|
|
mutex_lock(&p_fs->v_mutex);
|
|
|
|
/* get the directory entry of given file */
|
|
es = get_entry_set_in_dir(sb, &fid->dir, fid->entry,
|
|
ES_ALL_ENTRIES, &ep);
|
|
if (!es) {
|
|
ret = -ENOENT;
|
|
goto out;
|
|
}
|
|
|
|
type = exfat_get_entry_type(ep);
|
|
|
|
if (((type == TYPE_FILE) && (attr & ATTR_SUBDIR)) ||
|
|
((type == TYPE_DIR) && (!(attr & ATTR_SUBDIR)))) {
|
|
if (p_fs->dev_ejected)
|
|
ret = -EIO;
|
|
else
|
|
ret = -EINVAL;
|
|
|
|
release_entry_set(es);
|
|
goto out;
|
|
}
|
|
|
|
fs_set_vol_flags(sb, VOL_DIRTY);
|
|
|
|
/* set the file attribute */
|
|
fid->attr = attr;
|
|
exfat_set_entry_attr(ep, attr);
|
|
|
|
update_dir_checksum_with_entry_set(sb, es);
|
|
release_entry_set(es);
|
|
|
|
#ifndef CONFIG_STAGING_EXFAT_DELAYED_SYNC
|
|
fs_sync(sb, true);
|
|
fs_set_vol_flags(sb, VOL_CLEAN);
|
|
#endif
|
|
|
|
if (p_fs->dev_ejected)
|
|
ret = -EIO;
|
|
out:
|
|
/* release the lock for file system critical section */
|
|
mutex_unlock(&p_fs->v_mutex);
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
static int ffsReadStat(struct inode *inode, struct dir_entry_t *info)
|
|
{
|
|
s32 count;
|
|
int ret = 0;
|
|
struct chain_t dir;
|
|
struct uni_name_t uni_name;
|
|
struct timestamp_t tm;
|
|
struct dentry_t *ep, *ep2;
|
|
struct super_block *sb = inode->i_sb;
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
struct file_id_t *fid = &(EXFAT_I(inode)->fid);
|
|
struct entry_set_cache_t *es = NULL;
|
|
u8 is_dir = (fid->type == TYPE_DIR) ? 1 : 0;
|
|
|
|
pr_debug("%s entered\n", __func__);
|
|
|
|
/* acquire the lock for file system critical section */
|
|
mutex_lock(&p_fs->v_mutex);
|
|
|
|
if (is_dir) {
|
|
if ((fid->dir.dir == p_fs->root_dir) &&
|
|
(fid->entry == -1)) {
|
|
info->Attr = ATTR_SUBDIR;
|
|
memset((char *)&info->CreateTimestamp, 0,
|
|
sizeof(struct date_time_t));
|
|
memset((char *)&info->ModifyTimestamp, 0,
|
|
sizeof(struct date_time_t));
|
|
memset((char *)&info->AccessTimestamp, 0,
|
|
sizeof(struct date_time_t));
|
|
strcpy(info->ShortName, ".");
|
|
strcpy(info->Name, ".");
|
|
|
|
dir.dir = p_fs->root_dir;
|
|
dir.flags = 0x01;
|
|
|
|
if (p_fs->root_dir == CLUSTER_32(0)) {
|
|
/* FAT16 root_dir */
|
|
info->Size = p_fs->dentries_in_root <<
|
|
DENTRY_SIZE_BITS;
|
|
} else {
|
|
info->Size = count_num_clusters(sb, &dir) <<
|
|
p_fs->cluster_size_bits;
|
|
}
|
|
|
|
count = count_dos_name_entries(sb, &dir, TYPE_DIR);
|
|
if (count < 0) {
|
|
ret = count; /* propagate error upward */
|
|
goto out;
|
|
}
|
|
info->NumSubdirs = count;
|
|
|
|
if (p_fs->dev_ejected)
|
|
ret = -EIO;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
/* get the directory entry of given file or directory */
|
|
es = get_entry_set_in_dir(sb, &fid->dir, fid->entry,
|
|
ES_2_ENTRIES, &ep);
|
|
if (!es) {
|
|
ret = -ENOENT;
|
|
goto out;
|
|
}
|
|
ep2 = ep + 1;
|
|
|
|
/* set FILE_INFO structure using the acquired struct dentry_t */
|
|
info->Attr = exfat_get_entry_attr(ep);
|
|
|
|
exfat_get_entry_time(ep, &tm, TM_CREATE);
|
|
info->CreateTimestamp.Year = tm.year;
|
|
info->CreateTimestamp.Month = tm.mon;
|
|
info->CreateTimestamp.Day = tm.day;
|
|
info->CreateTimestamp.Hour = tm.hour;
|
|
info->CreateTimestamp.Minute = tm.min;
|
|
info->CreateTimestamp.Second = tm.sec;
|
|
info->CreateTimestamp.MilliSecond = 0;
|
|
|
|
exfat_get_entry_time(ep, &tm, TM_MODIFY);
|
|
info->ModifyTimestamp.Year = tm.year;
|
|
info->ModifyTimestamp.Month = tm.mon;
|
|
info->ModifyTimestamp.Day = tm.day;
|
|
info->ModifyTimestamp.Hour = tm.hour;
|
|
info->ModifyTimestamp.Minute = tm.min;
|
|
info->ModifyTimestamp.Second = tm.sec;
|
|
info->ModifyTimestamp.MilliSecond = 0;
|
|
|
|
memset((char *)&info->AccessTimestamp, 0, sizeof(struct date_time_t));
|
|
|
|
*uni_name.name = 0x0;
|
|
/* XXX this is very bad for exfat cuz name is already included in es.
|
|
* API should be revised
|
|
*/
|
|
exfat_get_uni_name_from_ext_entry(sb, &fid->dir, fid->entry,
|
|
uni_name.name);
|
|
nls_uniname_to_cstring(sb, info->Name, &uni_name);
|
|
|
|
info->NumSubdirs = 2;
|
|
|
|
info->Size = exfat_get_entry_size(ep2);
|
|
|
|
release_entry_set(es);
|
|
|
|
if (is_dir) {
|
|
dir.dir = fid->start_clu;
|
|
dir.flags = 0x01;
|
|
|
|
if (info->Size == 0)
|
|
info->Size = (u64)count_num_clusters(sb, &dir) <<
|
|
p_fs->cluster_size_bits;
|
|
|
|
count = count_dos_name_entries(sb, &dir, TYPE_DIR);
|
|
if (count < 0) {
|
|
ret = count; /* propagate error upward */
|
|
goto out;
|
|
}
|
|
info->NumSubdirs += count;
|
|
}
|
|
|
|
if (p_fs->dev_ejected)
|
|
ret = -EIO;
|
|
|
|
out:
|
|
/* release the lock for file system critical section */
|
|
mutex_unlock(&p_fs->v_mutex);
|
|
|
|
pr_debug("%s exited successfully\n", __func__);
|
|
return ret;
|
|
}
|
|
|
|
static int ffsWriteStat(struct inode *inode, struct dir_entry_t *info)
|
|
{
|
|
int ret = 0;
|
|
struct timestamp_t tm;
|
|
struct dentry_t *ep, *ep2;
|
|
struct entry_set_cache_t *es = NULL;
|
|
struct super_block *sb = inode->i_sb;
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
struct file_id_t *fid = &(EXFAT_I(inode)->fid);
|
|
u8 is_dir = (fid->type == TYPE_DIR) ? 1 : 0;
|
|
|
|
pr_debug("%s entered (inode %p info %p\n", __func__, inode, info);
|
|
|
|
/* acquire the lock for file system critical section */
|
|
mutex_lock(&p_fs->v_mutex);
|
|
|
|
if (is_dir) {
|
|
if ((fid->dir.dir == p_fs->root_dir) &&
|
|
(fid->entry == -1)) {
|
|
if (p_fs->dev_ejected)
|
|
ret = -EIO;
|
|
ret = 0;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
fs_set_vol_flags(sb, VOL_DIRTY);
|
|
|
|
/* get the directory entry of given file or directory */
|
|
es = get_entry_set_in_dir(sb, &fid->dir, fid->entry,
|
|
ES_ALL_ENTRIES, &ep);
|
|
if (!es) {
|
|
ret = -ENOENT;
|
|
goto out;
|
|
}
|
|
ep2 = ep + 1;
|
|
|
|
exfat_set_entry_attr(ep, info->Attr);
|
|
|
|
/* set FILE_INFO structure using the acquired struct dentry_t */
|
|
tm.sec = info->CreateTimestamp.Second;
|
|
tm.min = info->CreateTimestamp.Minute;
|
|
tm.hour = info->CreateTimestamp.Hour;
|
|
tm.day = info->CreateTimestamp.Day;
|
|
tm.mon = info->CreateTimestamp.Month;
|
|
tm.year = info->CreateTimestamp.Year;
|
|
exfat_set_entry_time(ep, &tm, TM_CREATE);
|
|
|
|
tm.sec = info->ModifyTimestamp.Second;
|
|
tm.min = info->ModifyTimestamp.Minute;
|
|
tm.hour = info->ModifyTimestamp.Hour;
|
|
tm.day = info->ModifyTimestamp.Day;
|
|
tm.mon = info->ModifyTimestamp.Month;
|
|
tm.year = info->ModifyTimestamp.Year;
|
|
exfat_set_entry_time(ep, &tm, TM_MODIFY);
|
|
|
|
exfat_set_entry_size(ep2, info->Size);
|
|
|
|
update_dir_checksum_with_entry_set(sb, es);
|
|
release_entry_set(es);
|
|
|
|
if (p_fs->dev_ejected)
|
|
ret = -EIO;
|
|
|
|
out:
|
|
/* release the lock for file system critical section */
|
|
mutex_unlock(&p_fs->v_mutex);
|
|
|
|
pr_debug("%s exited (%d)\n", __func__, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int ffsMapCluster(struct inode *inode, s32 clu_offset, u32 *clu)
|
|
{
|
|
s32 num_clusters, num_alloced;
|
|
bool modified = false;
|
|
u32 last_clu;
|
|
int ret = 0;
|
|
struct chain_t new_clu;
|
|
struct dentry_t *ep;
|
|
struct entry_set_cache_t *es = NULL;
|
|
struct super_block *sb = inode->i_sb;
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
struct file_id_t *fid = &(EXFAT_I(inode)->fid);
|
|
|
|
/* check the validity of pointer parameters */
|
|
if (!clu)
|
|
return -EINVAL;
|
|
|
|
/* acquire the lock for file system critical section */
|
|
mutex_lock(&p_fs->v_mutex);
|
|
|
|
fid->rwoffset = (s64)(clu_offset) << p_fs->cluster_size_bits;
|
|
|
|
if (EXFAT_I(inode)->mmu_private == 0)
|
|
num_clusters = 0;
|
|
else
|
|
num_clusters = (s32)((EXFAT_I(inode)->mmu_private - 1) >>
|
|
p_fs->cluster_size_bits) + 1;
|
|
|
|
*clu = last_clu = fid->start_clu;
|
|
|
|
if (fid->flags == 0x03) {
|
|
if ((clu_offset > 0) && (*clu != CLUSTER_32(~0))) {
|
|
last_clu += clu_offset - 1;
|
|
|
|
if (clu_offset == num_clusters)
|
|
*clu = CLUSTER_32(~0);
|
|
else
|
|
*clu += clu_offset;
|
|
}
|
|
} else {
|
|
/* hint information */
|
|
if ((clu_offset > 0) && (fid->hint_last_off > 0) &&
|
|
(clu_offset >= fid->hint_last_off)) {
|
|
clu_offset -= fid->hint_last_off;
|
|
*clu = fid->hint_last_clu;
|
|
}
|
|
|
|
while ((clu_offset > 0) && (*clu != CLUSTER_32(~0))) {
|
|
last_clu = *clu;
|
|
if (exfat_fat_read(sb, *clu, clu) == -1) {
|
|
ret = -EIO;
|
|
goto out;
|
|
}
|
|
clu_offset--;
|
|
}
|
|
}
|
|
|
|
if (*clu == CLUSTER_32(~0)) {
|
|
fs_set_vol_flags(sb, VOL_DIRTY);
|
|
|
|
new_clu.dir = (last_clu == CLUSTER_32(~0)) ? CLUSTER_32(~0) :
|
|
last_clu + 1;
|
|
new_clu.size = 0;
|
|
new_clu.flags = fid->flags;
|
|
|
|
/* (1) allocate a cluster */
|
|
num_alloced = exfat_alloc_cluster(sb, 1, &new_clu);
|
|
if (num_alloced < 0) {
|
|
ret = -EIO;
|
|
goto out;
|
|
} else if (num_alloced == 0) {
|
|
ret = -ENOSPC;
|
|
goto out;
|
|
}
|
|
|
|
/* (2) append to the FAT chain */
|
|
if (last_clu == CLUSTER_32(~0)) {
|
|
if (new_clu.flags == 0x01)
|
|
fid->flags = 0x01;
|
|
fid->start_clu = new_clu.dir;
|
|
modified = true;
|
|
} else {
|
|
if (new_clu.flags != fid->flags) {
|
|
exfat_chain_cont_cluster(sb, fid->start_clu,
|
|
num_clusters);
|
|
fid->flags = 0x01;
|
|
modified = true;
|
|
}
|
|
if (new_clu.flags == 0x01)
|
|
exfat_fat_write(sb, last_clu, new_clu.dir);
|
|
}
|
|
|
|
num_clusters += num_alloced;
|
|
*clu = new_clu.dir;
|
|
|
|
es = get_entry_set_in_dir(sb, &fid->dir, fid->entry,
|
|
ES_ALL_ENTRIES, &ep);
|
|
if (!es) {
|
|
ret = -ENOENT;
|
|
goto out;
|
|
}
|
|
/* get stream entry */
|
|
ep++;
|
|
|
|
/* (3) update directory entry */
|
|
if (modified) {
|
|
if (exfat_get_entry_flag(ep) != fid->flags)
|
|
exfat_set_entry_flag(ep, fid->flags);
|
|
|
|
if (exfat_get_entry_clu0(ep) != fid->start_clu)
|
|
exfat_set_entry_clu0(ep, fid->start_clu);
|
|
}
|
|
|
|
update_dir_checksum_with_entry_set(sb, es);
|
|
release_entry_set(es);
|
|
|
|
/* add number of new blocks to inode */
|
|
inode->i_blocks += num_alloced << (p_fs->cluster_size_bits - 9);
|
|
}
|
|
|
|
/* hint information */
|
|
fid->hint_last_off = (s32)(fid->rwoffset >> p_fs->cluster_size_bits);
|
|
fid->hint_last_clu = *clu;
|
|
|
|
if (p_fs->dev_ejected)
|
|
ret = -EIO;
|
|
|
|
out:
|
|
/* release the lock for file system critical section */
|
|
mutex_unlock(&p_fs->v_mutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* Directory Operation Functions */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static int ffsCreateDir(struct inode *inode, char *path, struct file_id_t *fid)
|
|
{
|
|
int ret = 0;
|
|
struct chain_t dir;
|
|
struct uni_name_t uni_name;
|
|
struct super_block *sb = inode->i_sb;
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
|
|
pr_debug("%s entered\n", __func__);
|
|
|
|
/* check the validity of pointer parameters */
|
|
if (!fid || !path || (*path == '\0'))
|
|
return -EINVAL;
|
|
|
|
/* acquire the lock for file system critical section */
|
|
mutex_lock(&p_fs->v_mutex);
|
|
|
|
/* check the validity of directory name in the given old pathname */
|
|
ret = resolve_path(inode, path, &dir, &uni_name);
|
|
if (ret)
|
|
goto out;
|
|
|
|
fs_set_vol_flags(sb, VOL_DIRTY);
|
|
|
|
ret = create_dir(inode, &dir, &uni_name, fid);
|
|
|
|
#ifndef CONFIG_STAGING_EXFAT_DELAYED_SYNC
|
|
fs_sync(sb, true);
|
|
fs_set_vol_flags(sb, VOL_CLEAN);
|
|
#endif
|
|
|
|
if (p_fs->dev_ejected)
|
|
ret = -EIO;
|
|
out:
|
|
/* release the lock for file system critical section */
|
|
mutex_unlock(&p_fs->v_mutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int ffsReadDir(struct inode *inode, struct dir_entry_t *dir_entry)
|
|
{
|
|
int i, dentry, clu_offset;
|
|
int ret = 0;
|
|
s32 dentries_per_clu, dentries_per_clu_bits = 0;
|
|
u32 type;
|
|
sector_t sector;
|
|
struct chain_t dir, clu;
|
|
struct uni_name_t uni_name;
|
|
struct timestamp_t tm;
|
|
struct dentry_t *ep;
|
|
struct super_block *sb = inode->i_sb;
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
struct file_id_t *fid = &(EXFAT_I(inode)->fid);
|
|
|
|
/* check the validity of pointer parameters */
|
|
if (!dir_entry)
|
|
return -EINVAL;
|
|
|
|
/* check if the given file ID is opened */
|
|
if (fid->type != TYPE_DIR)
|
|
return -ENOTDIR;
|
|
|
|
/* acquire the lock for file system critical section */
|
|
mutex_lock(&p_fs->v_mutex);
|
|
|
|
if (fid->entry == -1) {
|
|
dir.dir = p_fs->root_dir;
|
|
dir.flags = 0x01;
|
|
} else {
|
|
dir.dir = fid->start_clu;
|
|
dir.size = (s32)(fid->size >> p_fs->cluster_size_bits);
|
|
dir.flags = fid->flags;
|
|
}
|
|
|
|
dentry = (s32)fid->rwoffset;
|
|
|
|
if (dir.dir == CLUSTER_32(0)) {
|
|
/* FAT16 root_dir */
|
|
dentries_per_clu = p_fs->dentries_in_root;
|
|
|
|
if (dentry == dentries_per_clu) {
|
|
clu.dir = CLUSTER_32(~0);
|
|
} else {
|
|
clu.dir = dir.dir;
|
|
clu.size = dir.size;
|
|
clu.flags = dir.flags;
|
|
}
|
|
} else {
|
|
dentries_per_clu = p_fs->dentries_per_clu;
|
|
dentries_per_clu_bits = ilog2(dentries_per_clu);
|
|
|
|
clu_offset = dentry >> dentries_per_clu_bits;
|
|
clu.dir = dir.dir;
|
|
clu.size = dir.size;
|
|
clu.flags = dir.flags;
|
|
|
|
if (clu.flags == 0x03) {
|
|
clu.dir += clu_offset;
|
|
clu.size -= clu_offset;
|
|
} else {
|
|
/* hint_information */
|
|
if ((clu_offset > 0) && (fid->hint_last_off > 0) &&
|
|
(clu_offset >= fid->hint_last_off)) {
|
|
clu_offset -= fid->hint_last_off;
|
|
clu.dir = fid->hint_last_clu;
|
|
}
|
|
|
|
while (clu_offset > 0) {
|
|
/* clu.dir = exfat_fat_read(sb, clu.dir); */
|
|
if (exfat_fat_read(sb, clu.dir, &clu.dir) == -1) {
|
|
ret = -EIO;
|
|
goto out;
|
|
}
|
|
clu_offset--;
|
|
}
|
|
}
|
|
}
|
|
|
|
while (clu.dir != CLUSTER_32(~0)) {
|
|
if (p_fs->dev_ejected)
|
|
break;
|
|
|
|
if (dir.dir == CLUSTER_32(0)) /* FAT16 root_dir */
|
|
i = dentry % dentries_per_clu;
|
|
else
|
|
i = dentry & (dentries_per_clu - 1);
|
|
|
|
for ( ; i < dentries_per_clu; i++, dentry++) {
|
|
ep = get_entry_in_dir(sb, &clu, i, §or);
|
|
if (!ep) {
|
|
ret = -ENOENT;
|
|
goto out;
|
|
}
|
|
type = exfat_get_entry_type(ep);
|
|
|
|
if (type == TYPE_UNUSED)
|
|
break;
|
|
|
|
if ((type != TYPE_FILE) && (type != TYPE_DIR))
|
|
continue;
|
|
|
|
exfat_buf_lock(sb, sector);
|
|
dir_entry->Attr = exfat_get_entry_attr(ep);
|
|
|
|
exfat_get_entry_time(ep, &tm, TM_CREATE);
|
|
dir_entry->CreateTimestamp.Year = tm.year;
|
|
dir_entry->CreateTimestamp.Month = tm.mon;
|
|
dir_entry->CreateTimestamp.Day = tm.day;
|
|
dir_entry->CreateTimestamp.Hour = tm.hour;
|
|
dir_entry->CreateTimestamp.Minute = tm.min;
|
|
dir_entry->CreateTimestamp.Second = tm.sec;
|
|
dir_entry->CreateTimestamp.MilliSecond = 0;
|
|
|
|
exfat_get_entry_time(ep, &tm, TM_MODIFY);
|
|
dir_entry->ModifyTimestamp.Year = tm.year;
|
|
dir_entry->ModifyTimestamp.Month = tm.mon;
|
|
dir_entry->ModifyTimestamp.Day = tm.day;
|
|
dir_entry->ModifyTimestamp.Hour = tm.hour;
|
|
dir_entry->ModifyTimestamp.Minute = tm.min;
|
|
dir_entry->ModifyTimestamp.Second = tm.sec;
|
|
dir_entry->ModifyTimestamp.MilliSecond = 0;
|
|
|
|
memset((char *)&dir_entry->AccessTimestamp, 0,
|
|
sizeof(struct date_time_t));
|
|
|
|
*uni_name.name = 0x0;
|
|
exfat_get_uni_name_from_ext_entry(sb, &dir, dentry,
|
|
uni_name.name);
|
|
nls_uniname_to_cstring(sb, dir_entry->Name, &uni_name);
|
|
exfat_buf_unlock(sb, sector);
|
|
|
|
ep = get_entry_in_dir(sb, &clu, i + 1, NULL);
|
|
if (!ep) {
|
|
ret = -ENOENT;
|
|
goto out;
|
|
}
|
|
|
|
dir_entry->Size = exfat_get_entry_size(ep);
|
|
|
|
/* hint information */
|
|
if (dir.dir == CLUSTER_32(0)) { /* FAT16 root_dir */
|
|
} else {
|
|
fid->hint_last_off = dentry >>
|
|
dentries_per_clu_bits;
|
|
fid->hint_last_clu = clu.dir;
|
|
}
|
|
|
|
fid->rwoffset = (s64)(++dentry);
|
|
|
|
if (p_fs->dev_ejected)
|
|
ret = -EIO;
|
|
goto out;
|
|
}
|
|
|
|
if (dir.dir == CLUSTER_32(0))
|
|
break; /* FAT16 root_dir */
|
|
|
|
if (clu.flags == 0x03) {
|
|
if ((--clu.size) > 0)
|
|
clu.dir++;
|
|
else
|
|
clu.dir = CLUSTER_32(~0);
|
|
} else {
|
|
/* clu.dir = exfat_fat_read(sb, clu.dir); */
|
|
if (exfat_fat_read(sb, clu.dir, &clu.dir) == -1) {
|
|
ret = -EIO;
|
|
goto out;
|
|
}
|
|
}
|
|
}
|
|
|
|
*dir_entry->Name = '\0';
|
|
|
|
fid->rwoffset = (s64)(++dentry);
|
|
|
|
if (p_fs->dev_ejected)
|
|
ret = -EIO;
|
|
|
|
out:
|
|
/* release the lock for file system critical section */
|
|
mutex_unlock(&p_fs->v_mutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int ffsRemoveDir(struct inode *inode, struct file_id_t *fid)
|
|
{
|
|
s32 dentry;
|
|
int ret = 0;
|
|
struct chain_t dir, clu_to_free;
|
|
struct super_block *sb = inode->i_sb;
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
|
|
/* check the validity of the given file id */
|
|
if (!fid)
|
|
return -EINVAL;
|
|
|
|
dir.dir = fid->dir.dir;
|
|
dir.size = fid->dir.size;
|
|
dir.flags = fid->dir.flags;
|
|
|
|
dentry = fid->entry;
|
|
|
|
/* check if the file is "." or ".." */
|
|
if (p_fs->vol_type != EXFAT) {
|
|
if ((dir.dir != p_fs->root_dir) && (dentry < 2))
|
|
return -EPERM;
|
|
}
|
|
|
|
/* acquire the lock for file system critical section */
|
|
mutex_lock(&p_fs->v_mutex);
|
|
|
|
clu_to_free.dir = fid->start_clu;
|
|
clu_to_free.size = (s32)((fid->size - 1) >> p_fs->cluster_size_bits) + 1;
|
|
clu_to_free.flags = fid->flags;
|
|
|
|
if (!is_dir_empty(sb, &clu_to_free)) {
|
|
ret = -ENOTEMPTY;
|
|
goto out;
|
|
}
|
|
|
|
fs_set_vol_flags(sb, VOL_DIRTY);
|
|
|
|
/* (1) update the directory entry */
|
|
remove_file(inode, &dir, dentry);
|
|
|
|
/* (2) free the clusters */
|
|
exfat_free_cluster(sb, &clu_to_free, 1);
|
|
|
|
fid->size = 0;
|
|
fid->start_clu = CLUSTER_32(~0);
|
|
fid->flags = (p_fs->vol_type == EXFAT) ? 0x03 : 0x01;
|
|
|
|
#ifndef CONFIG_STAGING_EXFAT_DELAYED_SYNC
|
|
fs_sync(sb, true);
|
|
fs_set_vol_flags(sb, VOL_CLEAN);
|
|
#endif
|
|
|
|
if (p_fs->dev_ejected)
|
|
ret = -EIO;
|
|
|
|
out:
|
|
/* release the lock for file system critical section */
|
|
mutex_unlock(&p_fs->v_mutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*======================================================================*/
|
|
/* Directory Entry Operations */
|
|
/*======================================================================*/
|
|
|
|
static int exfat_readdir(struct file *filp, struct dir_context *ctx)
|
|
{
|
|
struct inode *inode = file_inode(filp);
|
|
struct super_block *sb = inode->i_sb;
|
|
struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
|
struct fs_info_t *p_fs = &sbi->fs_info;
|
|
struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
|
|
struct dir_entry_t de;
|
|
unsigned long inum;
|
|
loff_t cpos;
|
|
int err = 0;
|
|
|
|
__lock_super(sb);
|
|
|
|
cpos = ctx->pos;
|
|
/* Fake . and .. for the root directory. */
|
|
if ((p_fs->vol_type == EXFAT) || (inode->i_ino == EXFAT_ROOT_INO)) {
|
|
while (cpos < 2) {
|
|
if (inode->i_ino == EXFAT_ROOT_INO)
|
|
inum = EXFAT_ROOT_INO;
|
|
else if (cpos == 0)
|
|
inum = inode->i_ino;
|
|
else /* (cpos == 1) */
|
|
inum = parent_ino(filp->f_path.dentry);
|
|
|
|
if (!dir_emit_dots(filp, ctx))
|
|
goto out;
|
|
cpos++;
|
|
ctx->pos++;
|
|
}
|
|
if (cpos == 2)
|
|
cpos = 0;
|
|
}
|
|
if (cpos & (DENTRY_SIZE - 1)) {
|
|
err = -ENOENT;
|
|
goto out;
|
|
}
|
|
|
|
get_new:
|
|
EXFAT_I(inode)->fid.size = i_size_read(inode);
|
|
EXFAT_I(inode)->fid.rwoffset = cpos >> DENTRY_SIZE_BITS;
|
|
|
|
err = ffsReadDir(inode, &de);
|
|
if (err) {
|
|
/* at least we tried to read a sector
|
|
* move cpos to next sector position (should be aligned)
|
|
*/
|
|
if (err == -EIO) {
|
|
cpos += 1 << p_bd->sector_size_bits;
|
|
cpos &= ~((1 << p_bd->sector_size_bits) - 1);
|
|
}
|
|
|
|
goto end_of_dir;
|
|
}
|
|
|
|
cpos = EXFAT_I(inode)->fid.rwoffset << DENTRY_SIZE_BITS;
|
|
|
|
if (!de.Name[0])
|
|
goto end_of_dir;
|
|
|
|
if (!memcmp(de.ShortName, DOS_CUR_DIR_NAME, DOS_NAME_LENGTH)) {
|
|
inum = inode->i_ino;
|
|
} else if (!memcmp(de.ShortName, DOS_PAR_DIR_NAME, DOS_NAME_LENGTH)) {
|
|
inum = parent_ino(filp->f_path.dentry);
|
|
} else {
|
|
loff_t i_pos = ((loff_t)EXFAT_I(inode)->fid.start_clu << 32) |
|
|
((EXFAT_I(inode)->fid.rwoffset - 1) & 0xffffffff);
|
|
struct inode *tmp = exfat_iget(sb, i_pos);
|
|
|
|
if (tmp) {
|
|
inum = tmp->i_ino;
|
|
iput(tmp);
|
|
} else {
|
|
inum = iunique(sb, EXFAT_ROOT_INO);
|
|
}
|
|
}
|
|
|
|
if (!dir_emit(ctx, de.Name, strlen(de.Name), inum,
|
|
(de.Attr & ATTR_SUBDIR) ? DT_DIR : DT_REG))
|
|
goto out;
|
|
|
|
ctx->pos = cpos;
|
|
goto get_new;
|
|
|
|
end_of_dir:
|
|
ctx->pos = cpos;
|
|
out:
|
|
__unlock_super(sb);
|
|
return err;
|
|
}
|
|
|
|
static int exfat_ioctl_volume_id(struct inode *dir)
|
|
{
|
|
struct super_block *sb = dir->i_sb;
|
|
struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
|
struct fs_info_t *p_fs = &sbi->fs_info;
|
|
|
|
return p_fs->vol_id;
|
|
}
|
|
|
|
static long exfat_generic_ioctl(struct file *filp, unsigned int cmd,
|
|
unsigned long arg)
|
|
{
|
|
struct inode *inode = filp->f_path.dentry->d_inode;
|
|
#ifdef CONFIG_STAGING_EXFAT_KERNEL_DEBUG
|
|
unsigned int flags;
|
|
#endif /* CONFIG_STAGING_EXFAT_KERNEL_DEBUG */
|
|
|
|
switch (cmd) {
|
|
case EXFAT_IOCTL_GET_VOLUME_ID:
|
|
return exfat_ioctl_volume_id(inode);
|
|
#ifdef CONFIG_STAGING_EXFAT_KERNEL_DEBUG
|
|
case EXFAT_IOC_GET_DEBUGFLAGS: {
|
|
struct super_block *sb = inode->i_sb;
|
|
struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
|
|
|
flags = sbi->debug_flags;
|
|
return put_user(flags, (int __user *)arg);
|
|
}
|
|
case EXFAT_IOC_SET_DEBUGFLAGS: {
|
|
struct super_block *sb = inode->i_sb;
|
|
struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
return -EPERM;
|
|
|
|
if (get_user(flags, (int __user *)arg))
|
|
return -EFAULT;
|
|
|
|
__lock_super(sb);
|
|
sbi->debug_flags = flags;
|
|
__unlock_super(sb);
|
|
|
|
return 0;
|
|
}
|
|
#endif /* CONFIG_STAGING_EXFAT_KERNEL_DEBUG */
|
|
default:
|
|
return -ENOTTY; /* Inappropriate ioctl for device */
|
|
}
|
|
}
|
|
|
|
static const struct file_operations exfat_dir_operations = {
|
|
.llseek = generic_file_llseek,
|
|
.read = generic_read_dir,
|
|
.iterate = exfat_readdir,
|
|
.unlocked_ioctl = exfat_generic_ioctl,
|
|
.fsync = generic_file_fsync,
|
|
};
|
|
|
|
static int exfat_create(struct inode *dir, struct dentry *dentry, umode_t mode,
|
|
bool excl)
|
|
{
|
|
struct super_block *sb = dir->i_sb;
|
|
struct timespec64 curtime;
|
|
struct inode *inode;
|
|
struct file_id_t fid;
|
|
loff_t i_pos;
|
|
int err;
|
|
|
|
__lock_super(sb);
|
|
|
|
pr_debug("%s entered\n", __func__);
|
|
|
|
err = ffsCreateFile(dir, (u8 *)dentry->d_name.name, FM_REGULAR, &fid);
|
|
if (err)
|
|
goto out;
|
|
|
|
INC_IVERSION(dir);
|
|
curtime = current_time(dir);
|
|
dir->i_ctime = curtime;
|
|
dir->i_mtime = curtime;
|
|
dir->i_atime = curtime;
|
|
if (IS_DIRSYNC(dir))
|
|
(void)exfat_sync_inode(dir);
|
|
else
|
|
mark_inode_dirty(dir);
|
|
|
|
i_pos = ((loff_t)fid.dir.dir << 32) | (fid.entry & 0xffffffff);
|
|
|
|
inode = exfat_build_inode(sb, &fid, i_pos);
|
|
if (IS_ERR(inode)) {
|
|
err = PTR_ERR(inode);
|
|
goto out;
|
|
}
|
|
INC_IVERSION(inode);
|
|
curtime = current_time(inode);
|
|
inode->i_mtime = curtime;
|
|
inode->i_atime = curtime;
|
|
inode->i_ctime = curtime;
|
|
/*
|
|
* timestamp is already written, so mark_inode_dirty() is unnecessary.
|
|
*/
|
|
|
|
dentry->d_time = GET_IVERSION(dentry->d_parent->d_inode);
|
|
d_instantiate(dentry, inode);
|
|
|
|
out:
|
|
__unlock_super(sb);
|
|
pr_debug("%s exited\n", __func__);
|
|
return err;
|
|
}
|
|
|
|
static int exfat_find(struct inode *dir, struct qstr *qname,
|
|
struct file_id_t *fid)
|
|
{
|
|
int err;
|
|
|
|
if (qname->len == 0)
|
|
return -ENOENT;
|
|
|
|
err = ffsLookupFile(dir, (u8 *)qname->name, fid);
|
|
if (err)
|
|
return -ENOENT;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int exfat_d_anon_disconn(struct dentry *dentry)
|
|
{
|
|
return IS_ROOT(dentry) && (dentry->d_flags & DCACHE_DISCONNECTED);
|
|
}
|
|
|
|
static struct dentry *exfat_lookup(struct inode *dir, struct dentry *dentry,
|
|
unsigned int flags)
|
|
{
|
|
struct super_block *sb = dir->i_sb;
|
|
struct inode *inode;
|
|
struct dentry *alias;
|
|
int err;
|
|
struct file_id_t fid;
|
|
loff_t i_pos;
|
|
u64 ret;
|
|
mode_t i_mode;
|
|
|
|
__lock_super(sb);
|
|
pr_debug("%s entered\n", __func__);
|
|
err = exfat_find(dir, &dentry->d_name, &fid);
|
|
if (err) {
|
|
if (err == -ENOENT) {
|
|
inode = NULL;
|
|
goto out;
|
|
}
|
|
goto error;
|
|
}
|
|
|
|
i_pos = ((loff_t)fid.dir.dir << 32) | (fid.entry & 0xffffffff);
|
|
inode = exfat_build_inode(sb, &fid, i_pos);
|
|
if (IS_ERR(inode)) {
|
|
err = PTR_ERR(inode);
|
|
goto error;
|
|
}
|
|
|
|
i_mode = inode->i_mode;
|
|
if (S_ISLNK(i_mode) && !EXFAT_I(inode)->target) {
|
|
EXFAT_I(inode)->target = kmalloc(i_size_read(inode) + 1,
|
|
GFP_KERNEL);
|
|
if (!EXFAT_I(inode)->target) {
|
|
err = -ENOMEM;
|
|
goto error;
|
|
}
|
|
ffsReadFile(dir, &fid, EXFAT_I(inode)->target,
|
|
i_size_read(inode), &ret);
|
|
*(EXFAT_I(inode)->target + i_size_read(inode)) = '\0';
|
|
}
|
|
|
|
alias = d_find_alias(inode);
|
|
if (alias && !exfat_d_anon_disconn(alias)) {
|
|
BUG_ON(d_unhashed(alias));
|
|
if (!S_ISDIR(i_mode))
|
|
d_move(alias, dentry);
|
|
iput(inode);
|
|
__unlock_super(sb);
|
|
pr_debug("%s exited 1\n", __func__);
|
|
return alias;
|
|
}
|
|
dput(alias);
|
|
out:
|
|
__unlock_super(sb);
|
|
dentry->d_time = GET_IVERSION(dentry->d_parent->d_inode);
|
|
dentry = d_splice_alias(inode, dentry);
|
|
if (dentry)
|
|
dentry->d_time = GET_IVERSION(dentry->d_parent->d_inode);
|
|
pr_debug("%s exited 2\n", __func__);
|
|
return dentry;
|
|
|
|
error:
|
|
__unlock_super(sb);
|
|
pr_debug("%s exited 3\n", __func__);
|
|
return ERR_PTR(err);
|
|
}
|
|
|
|
static inline unsigned long exfat_hash(loff_t i_pos)
|
|
{
|
|
return hash_32(i_pos, EXFAT_HASH_BITS);
|
|
}
|
|
|
|
static void exfat_attach(struct inode *inode, loff_t i_pos)
|
|
{
|
|
struct exfat_sb_info *sbi = EXFAT_SB(inode->i_sb);
|
|
struct hlist_head *head = sbi->inode_hashtable + exfat_hash(i_pos);
|
|
|
|
spin_lock(&sbi->inode_hash_lock);
|
|
EXFAT_I(inode)->i_pos = i_pos;
|
|
hlist_add_head(&EXFAT_I(inode)->i_hash_fat, head);
|
|
spin_unlock(&sbi->inode_hash_lock);
|
|
}
|
|
|
|
static void exfat_detach(struct inode *inode)
|
|
{
|
|
struct exfat_sb_info *sbi = EXFAT_SB(inode->i_sb);
|
|
|
|
spin_lock(&sbi->inode_hash_lock);
|
|
hlist_del_init(&EXFAT_I(inode)->i_hash_fat);
|
|
EXFAT_I(inode)->i_pos = 0;
|
|
spin_unlock(&sbi->inode_hash_lock);
|
|
}
|
|
|
|
static int exfat_unlink(struct inode *dir, struct dentry *dentry)
|
|
{
|
|
struct inode *inode = dentry->d_inode;
|
|
struct super_block *sb = dir->i_sb;
|
|
struct timespec64 curtime;
|
|
int err;
|
|
|
|
__lock_super(sb);
|
|
|
|
pr_debug("%s entered\n", __func__);
|
|
|
|
EXFAT_I(inode)->fid.size = i_size_read(inode);
|
|
|
|
err = ffsRemoveFile(dir, &(EXFAT_I(inode)->fid));
|
|
if (err)
|
|
goto out;
|
|
|
|
INC_IVERSION(dir);
|
|
curtime = current_time(dir);
|
|
dir->i_mtime = curtime;
|
|
dir->i_atime = curtime;
|
|
if (IS_DIRSYNC(dir))
|
|
(void)exfat_sync_inode(dir);
|
|
else
|
|
mark_inode_dirty(dir);
|
|
|
|
clear_nlink(inode);
|
|
curtime = current_time(inode);
|
|
inode->i_mtime = curtime;
|
|
inode->i_atime = curtime;
|
|
exfat_detach(inode);
|
|
remove_inode_hash(inode);
|
|
|
|
out:
|
|
__unlock_super(sb);
|
|
pr_debug("%s exited\n", __func__);
|
|
return err;
|
|
}
|
|
|
|
static int exfat_symlink(struct inode *dir, struct dentry *dentry,
|
|
const char *target)
|
|
{
|
|
struct super_block *sb = dir->i_sb;
|
|
struct timespec64 curtime;
|
|
struct inode *inode;
|
|
struct file_id_t fid;
|
|
loff_t i_pos;
|
|
int err;
|
|
u64 len = (u64)strlen(target);
|
|
u64 ret;
|
|
|
|
__lock_super(sb);
|
|
|
|
pr_debug("%s entered\n", __func__);
|
|
|
|
err = ffsCreateFile(dir, (u8 *)dentry->d_name.name, FM_SYMLINK, &fid);
|
|
if (err)
|
|
goto out;
|
|
|
|
|
|
err = ffsWriteFile(dir, &fid, (char *)target, len, &ret);
|
|
|
|
if (err) {
|
|
ffsRemoveFile(dir, &fid);
|
|
goto out;
|
|
}
|
|
|
|
INC_IVERSION(dir);
|
|
curtime = current_time(dir);
|
|
dir->i_ctime = curtime;
|
|
dir->i_mtime = curtime;
|
|
dir->i_atime = curtime;
|
|
if (IS_DIRSYNC(dir))
|
|
(void)exfat_sync_inode(dir);
|
|
else
|
|
mark_inode_dirty(dir);
|
|
|
|
i_pos = ((loff_t)fid.dir.dir << 32) | (fid.entry & 0xffffffff);
|
|
|
|
inode = exfat_build_inode(sb, &fid, i_pos);
|
|
if (IS_ERR(inode)) {
|
|
err = PTR_ERR(inode);
|
|
goto out;
|
|
}
|
|
INC_IVERSION(inode);
|
|
curtime = current_time(inode);
|
|
inode->i_mtime = curtime;
|
|
inode->i_atime = curtime;
|
|
inode->i_ctime = curtime;
|
|
/* timestamp is already written, so mark_inode_dirty() is unneeded. */
|
|
|
|
EXFAT_I(inode)->target = kmemdup(target, len + 1, GFP_KERNEL);
|
|
if (!EXFAT_I(inode)->target) {
|
|
err = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
dentry->d_time = GET_IVERSION(dentry->d_parent->d_inode);
|
|
d_instantiate(dentry, inode);
|
|
|
|
out:
|
|
__unlock_super(sb);
|
|
pr_debug("%s exited\n", __func__);
|
|
return err;
|
|
}
|
|
|
|
static int exfat_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
|
|
{
|
|
struct super_block *sb = dir->i_sb;
|
|
struct timespec64 curtime;
|
|
struct inode *inode;
|
|
struct file_id_t fid;
|
|
loff_t i_pos;
|
|
int err;
|
|
|
|
__lock_super(sb);
|
|
|
|
pr_debug("%s entered\n", __func__);
|
|
|
|
err = ffsCreateDir(dir, (u8 *)dentry->d_name.name, &fid);
|
|
if (err)
|
|
goto out;
|
|
|
|
INC_IVERSION(dir);
|
|
curtime = current_time(dir);
|
|
dir->i_ctime = curtime;
|
|
dir->i_mtime = curtime;
|
|
dir->i_atime = curtime;
|
|
if (IS_DIRSYNC(dir))
|
|
(void)exfat_sync_inode(dir);
|
|
else
|
|
mark_inode_dirty(dir);
|
|
inc_nlink(dir);
|
|
|
|
i_pos = ((loff_t)fid.dir.dir << 32) | (fid.entry & 0xffffffff);
|
|
|
|
inode = exfat_build_inode(sb, &fid, i_pos);
|
|
if (IS_ERR(inode)) {
|
|
err = PTR_ERR(inode);
|
|
goto out;
|
|
}
|
|
INC_IVERSION(inode);
|
|
curtime = current_time(inode);
|
|
inode->i_mtime = curtime;
|
|
inode->i_atime = curtime;
|
|
inode->i_ctime = curtime;
|
|
/* timestamp is already written, so mark_inode_dirty() is unneeded. */
|
|
|
|
dentry->d_time = GET_IVERSION(dentry->d_parent->d_inode);
|
|
d_instantiate(dentry, inode);
|
|
|
|
out:
|
|
__unlock_super(sb);
|
|
pr_debug("%s exited\n", __func__);
|
|
return err;
|
|
}
|
|
|
|
static int exfat_rmdir(struct inode *dir, struct dentry *dentry)
|
|
{
|
|
struct inode *inode = dentry->d_inode;
|
|
struct super_block *sb = dir->i_sb;
|
|
struct timespec64 curtime;
|
|
int err;
|
|
|
|
__lock_super(sb);
|
|
|
|
pr_debug("%s entered\n", __func__);
|
|
|
|
EXFAT_I(inode)->fid.size = i_size_read(inode);
|
|
|
|
err = ffsRemoveDir(dir, &(EXFAT_I(inode)->fid));
|
|
if (err)
|
|
goto out;
|
|
|
|
INC_IVERSION(dir);
|
|
curtime = current_time(dir);
|
|
dir->i_mtime = curtime;
|
|
dir->i_atime = curtime;
|
|
if (IS_DIRSYNC(dir))
|
|
(void)exfat_sync_inode(dir);
|
|
else
|
|
mark_inode_dirty(dir);
|
|
drop_nlink(dir);
|
|
|
|
clear_nlink(inode);
|
|
curtime = current_time(inode);
|
|
inode->i_mtime = curtime;
|
|
inode->i_atime = curtime;
|
|
exfat_detach(inode);
|
|
remove_inode_hash(inode);
|
|
|
|
out:
|
|
__unlock_super(sb);
|
|
pr_debug("%s exited\n", __func__);
|
|
return err;
|
|
}
|
|
|
|
static int exfat_rename(struct inode *old_dir, struct dentry *old_dentry,
|
|
struct inode *new_dir, struct dentry *new_dentry,
|
|
unsigned int flags)
|
|
{
|
|
struct inode *old_inode, *new_inode;
|
|
struct super_block *sb = old_dir->i_sb;
|
|
struct timespec64 curtime;
|
|
loff_t i_pos;
|
|
int err;
|
|
|
|
if (flags)
|
|
return -EINVAL;
|
|
|
|
__lock_super(sb);
|
|
|
|
pr_debug("%s entered\n", __func__);
|
|
|
|
old_inode = old_dentry->d_inode;
|
|
new_inode = new_dentry->d_inode;
|
|
|
|
EXFAT_I(old_inode)->fid.size = i_size_read(old_inode);
|
|
|
|
err = ffsMoveFile(old_dir, &(EXFAT_I(old_inode)->fid), new_dir,
|
|
new_dentry);
|
|
if (err)
|
|
goto out;
|
|
|
|
INC_IVERSION(new_dir);
|
|
curtime = current_time(new_dir);
|
|
new_dir->i_ctime = curtime;
|
|
new_dir->i_mtime = curtime;
|
|
new_dir->i_atime = curtime;
|
|
|
|
if (IS_DIRSYNC(new_dir))
|
|
(void)exfat_sync_inode(new_dir);
|
|
else
|
|
mark_inode_dirty(new_dir);
|
|
|
|
i_pos = ((loff_t)EXFAT_I(old_inode)->fid.dir.dir << 32) |
|
|
(EXFAT_I(old_inode)->fid.entry & 0xffffffff);
|
|
|
|
exfat_detach(old_inode);
|
|
exfat_attach(old_inode, i_pos);
|
|
if (IS_DIRSYNC(new_dir))
|
|
(void)exfat_sync_inode(old_inode);
|
|
else
|
|
mark_inode_dirty(old_inode);
|
|
|
|
if ((S_ISDIR(old_inode->i_mode)) && (old_dir != new_dir)) {
|
|
drop_nlink(old_dir);
|
|
if (!new_inode)
|
|
inc_nlink(new_dir);
|
|
}
|
|
INC_IVERSION(old_dir);
|
|
curtime = current_time(old_dir);
|
|
old_dir->i_ctime = curtime;
|
|
old_dir->i_mtime = curtime;
|
|
if (IS_DIRSYNC(old_dir))
|
|
(void)exfat_sync_inode(old_dir);
|
|
else
|
|
mark_inode_dirty(old_dir);
|
|
|
|
if (new_inode) {
|
|
exfat_detach(new_inode);
|
|
drop_nlink(new_inode);
|
|
if (S_ISDIR(new_inode->i_mode))
|
|
drop_nlink(new_inode);
|
|
new_inode->i_ctime = current_time(new_inode);
|
|
}
|
|
|
|
out:
|
|
__unlock_super(sb);
|
|
pr_debug("%s exited\n", __func__);
|
|
return err;
|
|
}
|
|
|
|
static int exfat_cont_expand(struct inode *inode, loff_t size)
|
|
{
|
|
struct address_space *mapping = inode->i_mapping;
|
|
loff_t start = i_size_read(inode), count = size - i_size_read(inode);
|
|
struct timespec64 curtime;
|
|
int err, err2;
|
|
|
|
err = generic_cont_expand_simple(inode, size);
|
|
if (err != 0)
|
|
return err;
|
|
|
|
curtime = current_time(inode);
|
|
inode->i_ctime = curtime;
|
|
inode->i_mtime = curtime;
|
|
mark_inode_dirty(inode);
|
|
|
|
if (IS_SYNC(inode)) {
|
|
err = filemap_fdatawrite_range(mapping, start,
|
|
start + count - 1);
|
|
err2 = sync_mapping_buffers(mapping);
|
|
err = (err) ? (err) : (err2);
|
|
err2 = write_inode_now(inode, 1);
|
|
err = (err) ? (err) : (err2);
|
|
if (!err)
|
|
err = filemap_fdatawait_range(mapping, start,
|
|
start + count - 1);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
static int exfat_allow_set_time(struct exfat_sb_info *sbi, struct inode *inode)
|
|
{
|
|
mode_t allow_utime = sbi->options.allow_utime;
|
|
|
|
if (!uid_eq(current_fsuid(), inode->i_uid)) {
|
|
if (in_group_p(inode->i_gid))
|
|
allow_utime >>= 3;
|
|
if (allow_utime & MAY_WRITE)
|
|
return 1;
|
|
}
|
|
|
|
/* use a default check */
|
|
return 0;
|
|
}
|
|
|
|
static int exfat_sanitize_mode(const struct exfat_sb_info *sbi,
|
|
struct inode *inode, umode_t *mode_ptr)
|
|
{
|
|
mode_t i_mode, mask, perm;
|
|
|
|
i_mode = inode->i_mode;
|
|
|
|
if (S_ISREG(i_mode) || S_ISLNK(i_mode))
|
|
mask = sbi->options.fs_fmask;
|
|
else
|
|
mask = sbi->options.fs_dmask;
|
|
|
|
perm = *mode_ptr & ~(S_IFMT | mask);
|
|
|
|
/* Of the r and x bits, all (subject to umask) must be present.*/
|
|
if ((perm & 0555) != (i_mode & 0555))
|
|
return -EPERM;
|
|
|
|
if (exfat_mode_can_hold_ro(inode)) {
|
|
/*
|
|
* Of the w bits, either all (subject to umask) or none must be
|
|
* present.
|
|
*/
|
|
if ((perm & 0222) && ((perm & 0222) != (0222 & ~mask)))
|
|
return -EPERM;
|
|
} else {
|
|
/*
|
|
* If exfat_mode_can_hold_ro(inode) is false, can't change w
|
|
* bits.
|
|
*/
|
|
if ((perm & 0222) != (0222 & ~mask))
|
|
return -EPERM;
|
|
}
|
|
|
|
*mode_ptr &= S_IFMT | perm;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void exfat_truncate(struct inode *inode, loff_t old_size)
|
|
{
|
|
struct super_block *sb = inode->i_sb;
|
|
struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
|
struct fs_info_t *p_fs = &sbi->fs_info;
|
|
struct timespec64 curtime;
|
|
int err;
|
|
|
|
__lock_super(sb);
|
|
|
|
/*
|
|
* This protects against truncating a file bigger than it was then
|
|
* trying to write into the hole.
|
|
*/
|
|
if (EXFAT_I(inode)->mmu_private > i_size_read(inode))
|
|
EXFAT_I(inode)->mmu_private = i_size_read(inode);
|
|
|
|
if (EXFAT_I(inode)->fid.start_clu == 0)
|
|
goto out;
|
|
|
|
err = ffsTruncateFile(inode, old_size, i_size_read(inode));
|
|
if (err)
|
|
goto out;
|
|
|
|
curtime = current_time(inode);
|
|
inode->i_ctime = curtime;
|
|
inode->i_mtime = curtime;
|
|
if (IS_DIRSYNC(inode))
|
|
(void)exfat_sync_inode(inode);
|
|
else
|
|
mark_inode_dirty(inode);
|
|
|
|
inode->i_blocks = ((i_size_read(inode) + (p_fs->cluster_size - 1)) &
|
|
~((loff_t)p_fs->cluster_size - 1)) >> 9;
|
|
out:
|
|
__unlock_super(sb);
|
|
}
|
|
|
|
static int exfat_setattr(struct dentry *dentry, struct iattr *attr)
|
|
{
|
|
struct exfat_sb_info *sbi = EXFAT_SB(dentry->d_sb);
|
|
struct inode *inode = dentry->d_inode;
|
|
unsigned int ia_valid;
|
|
int error;
|
|
loff_t old_size;
|
|
|
|
pr_debug("%s entered\n", __func__);
|
|
|
|
if ((attr->ia_valid & ATTR_SIZE) &&
|
|
attr->ia_size > i_size_read(inode)) {
|
|
error = exfat_cont_expand(inode, attr->ia_size);
|
|
if (error || attr->ia_valid == ATTR_SIZE)
|
|
return error;
|
|
attr->ia_valid &= ~ATTR_SIZE;
|
|
}
|
|
|
|
ia_valid = attr->ia_valid;
|
|
|
|
if ((ia_valid & (ATTR_MTIME_SET | ATTR_ATIME_SET | ATTR_TIMES_SET)) &&
|
|
exfat_allow_set_time(sbi, inode)) {
|
|
attr->ia_valid &= ~(ATTR_MTIME_SET |
|
|
ATTR_ATIME_SET |
|
|
ATTR_TIMES_SET);
|
|
}
|
|
|
|
error = setattr_prepare(dentry, attr);
|
|
attr->ia_valid = ia_valid;
|
|
if (error)
|
|
return error;
|
|
|
|
if (((attr->ia_valid & ATTR_UID) &&
|
|
(!uid_eq(attr->ia_uid, sbi->options.fs_uid))) ||
|
|
((attr->ia_valid & ATTR_GID) &&
|
|
(!gid_eq(attr->ia_gid, sbi->options.fs_gid))) ||
|
|
((attr->ia_valid & ATTR_MODE) &&
|
|
(attr->ia_mode & ~(S_IFREG | S_IFLNK | S_IFDIR | 0777)))) {
|
|
return -EPERM;
|
|
}
|
|
|
|
/*
|
|
* We don't return -EPERM here. Yes, strange, but this is too
|
|
* old behavior.
|
|
*/
|
|
if (attr->ia_valid & ATTR_MODE) {
|
|
if (exfat_sanitize_mode(sbi, inode, &attr->ia_mode) < 0)
|
|
attr->ia_valid &= ~ATTR_MODE;
|
|
}
|
|
|
|
EXFAT_I(inode)->fid.size = i_size_read(inode);
|
|
|
|
if (attr->ia_valid & ATTR_SIZE) {
|
|
old_size = i_size_read(inode);
|
|
down_write(&EXFAT_I(inode)->truncate_lock);
|
|
truncate_setsize(inode, attr->ia_size);
|
|
exfat_truncate(inode, old_size);
|
|
up_write(&EXFAT_I(inode)->truncate_lock);
|
|
}
|
|
setattr_copy(inode, attr);
|
|
mark_inode_dirty(inode);
|
|
|
|
pr_debug("%s exited\n", __func__);
|
|
return error;
|
|
}
|
|
|
|
static int exfat_getattr(const struct path *path, struct kstat *stat,
|
|
u32 request_mask, unsigned int flags)
|
|
{
|
|
struct inode *inode = path->dentry->d_inode;
|
|
|
|
pr_debug("%s entered\n", __func__);
|
|
|
|
generic_fillattr(inode, stat);
|
|
stat->blksize = EXFAT_SB(inode->i_sb)->fs_info.cluster_size;
|
|
|
|
pr_debug("%s exited\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
static const struct inode_operations exfat_dir_inode_operations = {
|
|
.create = exfat_create,
|
|
.lookup = exfat_lookup,
|
|
.unlink = exfat_unlink,
|
|
.symlink = exfat_symlink,
|
|
.mkdir = exfat_mkdir,
|
|
.rmdir = exfat_rmdir,
|
|
.rename = exfat_rename,
|
|
.setattr = exfat_setattr,
|
|
.getattr = exfat_getattr,
|
|
};
|
|
|
|
/*======================================================================*/
|
|
/* File Operations */
|
|
/*======================================================================*/
|
|
static const char *exfat_get_link(struct dentry *dentry, struct inode *inode,
|
|
struct delayed_call *done)
|
|
{
|
|
struct exfat_inode_info *ei = EXFAT_I(inode);
|
|
|
|
if (ei->target) {
|
|
char *cookie = ei->target;
|
|
|
|
if (cookie)
|
|
return (char *)(ei->target);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static const struct inode_operations exfat_symlink_inode_operations = {
|
|
.get_link = exfat_get_link,
|
|
};
|
|
|
|
static int exfat_file_release(struct inode *inode, struct file *filp)
|
|
{
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
EXFAT_I(inode)->fid.size = i_size_read(inode);
|
|
ffsSyncVol(sb, false);
|
|
return 0;
|
|
}
|
|
|
|
static const struct file_operations exfat_file_operations = {
|
|
.llseek = generic_file_llseek,
|
|
.read_iter = generic_file_read_iter,
|
|
.write_iter = generic_file_write_iter,
|
|
.mmap = generic_file_mmap,
|
|
.release = exfat_file_release,
|
|
.unlocked_ioctl = exfat_generic_ioctl,
|
|
.fsync = generic_file_fsync,
|
|
.splice_read = generic_file_splice_read,
|
|
};
|
|
|
|
static const struct inode_operations exfat_file_inode_operations = {
|
|
.setattr = exfat_setattr,
|
|
.getattr = exfat_getattr,
|
|
};
|
|
|
|
/*======================================================================*/
|
|
/* Address Space Operations */
|
|
/*======================================================================*/
|
|
|
|
static int exfat_bmap(struct inode *inode, sector_t sector, sector_t *phys,
|
|
unsigned long *mapped_blocks, int *create)
|
|
{
|
|
struct super_block *sb = inode->i_sb;
|
|
struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
|
struct fs_info_t *p_fs = &sbi->fs_info;
|
|
const unsigned long blocksize = sb->s_blocksize;
|
|
const unsigned char blocksize_bits = sb->s_blocksize_bits;
|
|
sector_t last_block;
|
|
int err, clu_offset, sec_offset;
|
|
unsigned int cluster;
|
|
|
|
*phys = 0;
|
|
*mapped_blocks = 0;
|
|
|
|
last_block = (i_size_read(inode) + (blocksize - 1)) >> blocksize_bits;
|
|
if (sector >= last_block) {
|
|
if (*create == 0)
|
|
return 0;
|
|
} else {
|
|
*create = 0;
|
|
}
|
|
|
|
/* cluster offset */
|
|
clu_offset = sector >> p_fs->sectors_per_clu_bits;
|
|
|
|
/* sector offset in cluster */
|
|
sec_offset = sector & (p_fs->sectors_per_clu - 1);
|
|
|
|
EXFAT_I(inode)->fid.size = i_size_read(inode);
|
|
|
|
err = ffsMapCluster(inode, clu_offset, &cluster);
|
|
|
|
if (!err && (cluster != CLUSTER_32(~0))) {
|
|
*phys = START_SECTOR(cluster) + sec_offset;
|
|
*mapped_blocks = p_fs->sectors_per_clu - sec_offset;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int exfat_get_block(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;
|
|
unsigned long mapped_blocks;
|
|
sector_t phys;
|
|
|
|
__lock_super(sb);
|
|
|
|
err = exfat_bmap(inode, iblock, &phys, &mapped_blocks, &create);
|
|
if (err) {
|
|
__unlock_super(sb);
|
|
return err;
|
|
}
|
|
|
|
if (phys) {
|
|
max_blocks = min(mapped_blocks, max_blocks);
|
|
if (create) {
|
|
EXFAT_I(inode)->mmu_private += max_blocks <<
|
|
sb->s_blocksize_bits;
|
|
set_buffer_new(bh_result);
|
|
}
|
|
map_bh(bh_result, sb, phys);
|
|
}
|
|
|
|
bh_result->b_size = max_blocks << sb->s_blocksize_bits;
|
|
__unlock_super(sb);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int exfat_readpage(struct file *file, struct page *page)
|
|
{
|
|
return mpage_readpage(page, exfat_get_block);
|
|
}
|
|
|
|
static int exfat_readpages(struct file *file, struct address_space *mapping,
|
|
struct list_head *pages, unsigned int nr_pages)
|
|
{
|
|
return mpage_readpages(mapping, pages, nr_pages, exfat_get_block);
|
|
}
|
|
|
|
static int exfat_writepage(struct page *page, struct writeback_control *wbc)
|
|
{
|
|
return block_write_full_page(page, exfat_get_block, wbc);
|
|
}
|
|
|
|
static int exfat_writepages(struct address_space *mapping,
|
|
struct writeback_control *wbc)
|
|
{
|
|
return mpage_writepages(mapping, wbc, exfat_get_block);
|
|
}
|
|
|
|
static void exfat_write_failed(struct address_space *mapping, loff_t to)
|
|
{
|
|
struct inode *inode = mapping->host;
|
|
|
|
if (to > i_size_read(inode)) {
|
|
truncate_pagecache(inode, i_size_read(inode));
|
|
EXFAT_I(inode)->fid.size = i_size_read(inode);
|
|
exfat_truncate(inode, i_size_read(inode));
|
|
}
|
|
}
|
|
|
|
static int exfat_write_begin(struct file *file, struct address_space *mapping,
|
|
loff_t pos, unsigned int len, unsigned int flags,
|
|
struct page **pagep, void **fsdata)
|
|
{
|
|
int ret;
|
|
|
|
*pagep = NULL;
|
|
ret = cont_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
|
|
exfat_get_block,
|
|
&EXFAT_I(mapping->host)->mmu_private);
|
|
|
|
if (ret < 0)
|
|
exfat_write_failed(mapping, pos + len);
|
|
return ret;
|
|
}
|
|
|
|
static int exfat_write_end(struct file *file, struct address_space *mapping,
|
|
loff_t pos, unsigned int len, unsigned int copied,
|
|
struct page *pagep, void *fsdata)
|
|
{
|
|
struct inode *inode = mapping->host;
|
|
struct file_id_t *fid = &(EXFAT_I(inode)->fid);
|
|
struct timespec64 curtime;
|
|
int err;
|
|
|
|
err = generic_write_end(file, mapping, pos, len, copied, pagep, fsdata);
|
|
|
|
if (err < len)
|
|
exfat_write_failed(mapping, pos + len);
|
|
|
|
if (!(err < 0) && !(fid->attr & ATTR_ARCHIVE)) {
|
|
curtime = current_time(inode);
|
|
inode->i_mtime = curtime;
|
|
inode->i_ctime = curtime;
|
|
fid->attr |= ATTR_ARCHIVE;
|
|
mark_inode_dirty(inode);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
static ssize_t exfat_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
|
|
{
|
|
struct inode *inode = iocb->ki_filp->f_mapping->host;
|
|
struct address_space *mapping = iocb->ki_filp->f_mapping;
|
|
ssize_t ret;
|
|
int rw;
|
|
|
|
rw = iov_iter_rw(iter);
|
|
|
|
if (rw == WRITE) {
|
|
if (EXFAT_I(inode)->mmu_private < iov_iter_count(iter))
|
|
return 0;
|
|
}
|
|
ret = blockdev_direct_IO(iocb, inode, iter, exfat_get_block);
|
|
|
|
if ((ret < 0) && (rw & WRITE))
|
|
exfat_write_failed(mapping, iov_iter_count(iter));
|
|
return ret;
|
|
}
|
|
|
|
static sector_t _exfat_bmap(struct address_space *mapping, sector_t block)
|
|
{
|
|
sector_t blocknr;
|
|
|
|
/* exfat_get_cluster() assumes the requested blocknr isn't truncated. */
|
|
down_read(&EXFAT_I(mapping->host)->truncate_lock);
|
|
blocknr = generic_block_bmap(mapping, block, exfat_get_block);
|
|
up_read(&EXFAT_I(mapping->host)->truncate_lock);
|
|
|
|
return blocknr;
|
|
}
|
|
|
|
static const struct address_space_operations exfat_aops = {
|
|
.readpage = exfat_readpage,
|
|
.readpages = exfat_readpages,
|
|
.writepage = exfat_writepage,
|
|
.writepages = exfat_writepages,
|
|
.write_begin = exfat_write_begin,
|
|
.write_end = exfat_write_end,
|
|
.direct_IO = exfat_direct_IO,
|
|
.bmap = _exfat_bmap
|
|
};
|
|
|
|
/*======================================================================*/
|
|
/* Super Operations */
|
|
/*======================================================================*/
|
|
|
|
static struct inode *exfat_iget(struct super_block *sb, loff_t i_pos)
|
|
{
|
|
struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
|
struct exfat_inode_info *info;
|
|
struct hlist_head *head = sbi->inode_hashtable + exfat_hash(i_pos);
|
|
struct inode *inode = NULL;
|
|
|
|
spin_lock(&sbi->inode_hash_lock);
|
|
hlist_for_each_entry(info, head, i_hash_fat) {
|
|
BUG_ON(info->vfs_inode.i_sb != sb);
|
|
|
|
if (i_pos != info->i_pos)
|
|
continue;
|
|
inode = igrab(&info->vfs_inode);
|
|
if (inode)
|
|
break;
|
|
}
|
|
spin_unlock(&sbi->inode_hash_lock);
|
|
return inode;
|
|
}
|
|
|
|
/* doesn't deal with root inode */
|
|
static int exfat_fill_inode(struct inode *inode, struct file_id_t *fid)
|
|
{
|
|
struct exfat_sb_info *sbi = EXFAT_SB(inode->i_sb);
|
|
struct fs_info_t *p_fs = &sbi->fs_info;
|
|
struct dir_entry_t info;
|
|
|
|
memcpy(&(EXFAT_I(inode)->fid), fid, sizeof(struct file_id_t));
|
|
|
|
ffsReadStat(inode, &info);
|
|
|
|
EXFAT_I(inode)->i_pos = 0;
|
|
EXFAT_I(inode)->target = NULL;
|
|
inode->i_uid = sbi->options.fs_uid;
|
|
inode->i_gid = sbi->options.fs_gid;
|
|
INC_IVERSION(inode);
|
|
inode->i_generation = prandom_u32();
|
|
|
|
if (info.Attr & ATTR_SUBDIR) { /* directory */
|
|
inode->i_generation &= ~1;
|
|
inode->i_mode = exfat_make_mode(sbi, info.Attr, 0777);
|
|
inode->i_op = &exfat_dir_inode_operations;
|
|
inode->i_fop = &exfat_dir_operations;
|
|
|
|
i_size_write(inode, info.Size);
|
|
EXFAT_I(inode)->mmu_private = i_size_read(inode);
|
|
set_nlink(inode, info.NumSubdirs);
|
|
} else if (info.Attr & ATTR_SYMLINK) { /* symbolic link */
|
|
inode->i_generation |= 1;
|
|
inode->i_mode = exfat_make_mode(sbi, info.Attr, 0777);
|
|
inode->i_op = &exfat_symlink_inode_operations;
|
|
|
|
i_size_write(inode, info.Size);
|
|
EXFAT_I(inode)->mmu_private = i_size_read(inode);
|
|
} else { /* regular file */
|
|
inode->i_generation |= 1;
|
|
inode->i_mode = exfat_make_mode(sbi, info.Attr, 0777);
|
|
inode->i_op = &exfat_file_inode_operations;
|
|
inode->i_fop = &exfat_file_operations;
|
|
inode->i_mapping->a_ops = &exfat_aops;
|
|
inode->i_mapping->nrpages = 0;
|
|
|
|
i_size_write(inode, info.Size);
|
|
EXFAT_I(inode)->mmu_private = i_size_read(inode);
|
|
}
|
|
exfat_save_attr(inode, info.Attr);
|
|
|
|
inode->i_blocks = ((i_size_read(inode) + (p_fs->cluster_size - 1))
|
|
& ~((loff_t)p_fs->cluster_size - 1)) >> 9;
|
|
|
|
exfat_time_fat2unix(&inode->i_mtime, &info.ModifyTimestamp);
|
|
exfat_time_fat2unix(&inode->i_ctime, &info.CreateTimestamp);
|
|
exfat_time_fat2unix(&inode->i_atime, &info.AccessTimestamp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct inode *exfat_build_inode(struct super_block *sb,
|
|
struct file_id_t *fid, loff_t i_pos)
|
|
{
|
|
struct inode *inode;
|
|
int err;
|
|
|
|
inode = exfat_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, EXFAT_ROOT_INO);
|
|
SET_IVERSION(inode, 1);
|
|
err = exfat_fill_inode(inode, fid);
|
|
if (err) {
|
|
iput(inode);
|
|
inode = ERR_PTR(err);
|
|
goto out;
|
|
}
|
|
exfat_attach(inode, i_pos);
|
|
insert_inode_hash(inode);
|
|
out:
|
|
return inode;
|
|
}
|
|
|
|
static int exfat_sync_inode(struct inode *inode)
|
|
{
|
|
return exfat_write_inode(inode, NULL);
|
|
}
|
|
|
|
static struct inode *exfat_alloc_inode(struct super_block *sb)
|
|
{
|
|
struct exfat_inode_info *ei;
|
|
|
|
ei = kmem_cache_alloc(exfat_inode_cachep, GFP_NOFS);
|
|
if (!ei)
|
|
return NULL;
|
|
|
|
init_rwsem(&ei->truncate_lock);
|
|
|
|
return &ei->vfs_inode;
|
|
}
|
|
|
|
static void exfat_destroy_inode(struct inode *inode)
|
|
{
|
|
kfree(EXFAT_I(inode)->target);
|
|
EXFAT_I(inode)->target = NULL;
|
|
|
|
kmem_cache_free(exfat_inode_cachep, EXFAT_I(inode));
|
|
}
|
|
|
|
static int exfat_write_inode(struct inode *inode, struct writeback_control *wbc)
|
|
{
|
|
struct dir_entry_t info;
|
|
|
|
if (inode->i_ino == EXFAT_ROOT_INO)
|
|
return 0;
|
|
|
|
info.Attr = exfat_make_attr(inode);
|
|
info.Size = i_size_read(inode);
|
|
|
|
exfat_time_unix2fat(&inode->i_mtime, &info.ModifyTimestamp);
|
|
exfat_time_unix2fat(&inode->i_ctime, &info.CreateTimestamp);
|
|
exfat_time_unix2fat(&inode->i_atime, &info.AccessTimestamp);
|
|
|
|
ffsWriteStat(inode, &info);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void exfat_evict_inode(struct inode *inode)
|
|
{
|
|
truncate_inode_pages(&inode->i_data, 0);
|
|
|
|
if (!inode->i_nlink)
|
|
i_size_write(inode, 0);
|
|
invalidate_inode_buffers(inode);
|
|
clear_inode(inode);
|
|
exfat_detach(inode);
|
|
|
|
remove_inode_hash(inode);
|
|
}
|
|
|
|
static void exfat_free_super(struct exfat_sb_info *sbi)
|
|
{
|
|
if (sbi->nls_disk)
|
|
unload_nls(sbi->nls_disk);
|
|
if (sbi->nls_io)
|
|
unload_nls(sbi->nls_io);
|
|
if (sbi->options.iocharset != exfat_default_iocharset)
|
|
kfree(sbi->options.iocharset);
|
|
/* mutex_init is in exfat_fill_super function. only for 3.7+ */
|
|
mutex_destroy(&sbi->s_lock);
|
|
kvfree(sbi);
|
|
}
|
|
|
|
static void exfat_put_super(struct super_block *sb)
|
|
{
|
|
struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
|
|
|
if (__is_sb_dirty(sb))
|
|
exfat_write_super(sb);
|
|
|
|
ffsUmountVol(sb);
|
|
|
|
sb->s_fs_info = NULL;
|
|
exfat_free_super(sbi);
|
|
}
|
|
|
|
static void exfat_write_super(struct super_block *sb)
|
|
{
|
|
__lock_super(sb);
|
|
|
|
__set_sb_clean(sb);
|
|
|
|
if (!sb_rdonly(sb))
|
|
ffsSyncVol(sb, true);
|
|
|
|
__unlock_super(sb);
|
|
}
|
|
|
|
static int exfat_sync_fs(struct super_block *sb, int wait)
|
|
{
|
|
int err = 0;
|
|
|
|
if (__is_sb_dirty(sb)) {
|
|
__lock_super(sb);
|
|
__set_sb_clean(sb);
|
|
err = ffsSyncVol(sb, true);
|
|
__unlock_super(sb);
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
static int exfat_statfs(struct dentry *dentry, struct kstatfs *buf)
|
|
{
|
|
struct super_block *sb = dentry->d_sb;
|
|
u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
struct vol_info_t info;
|
|
|
|
if (p_fs->used_clusters == UINT_MAX) {
|
|
if (ffsGetVolInfo(sb, &info) == -EIO)
|
|
return -EIO;
|
|
|
|
} else {
|
|
info.FatType = p_fs->vol_type;
|
|
info.ClusterSize = p_fs->cluster_size;
|
|
info.NumClusters = p_fs->num_clusters - 2;
|
|
info.UsedClusters = p_fs->used_clusters;
|
|
info.FreeClusters = info.NumClusters - info.UsedClusters;
|
|
|
|
if (p_fs->dev_ejected)
|
|
pr_info("[EXFAT] statfs on device that is ejected\n");
|
|
}
|
|
|
|
buf->f_type = sb->s_magic;
|
|
buf->f_bsize = info.ClusterSize;
|
|
buf->f_blocks = info.NumClusters;
|
|
buf->f_bfree = info.FreeClusters;
|
|
buf->f_bavail = info.FreeClusters;
|
|
buf->f_fsid.val[0] = (u32)id;
|
|
buf->f_fsid.val[1] = (u32)(id >> 32);
|
|
buf->f_namelen = 260;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int exfat_remount(struct super_block *sb, int *flags, char *data)
|
|
{
|
|
*flags |= SB_NODIRATIME;
|
|
return 0;
|
|
}
|
|
|
|
static int exfat_show_options(struct seq_file *m, struct dentry *root)
|
|
{
|
|
struct exfat_sb_info *sbi = EXFAT_SB(root->d_sb);
|
|
struct exfat_mount_options *opts = &sbi->options;
|
|
|
|
if (__kuid_val(opts->fs_uid))
|
|
seq_printf(m, ",uid=%u", __kuid_val(opts->fs_uid));
|
|
if (__kgid_val(opts->fs_gid))
|
|
seq_printf(m, ",gid=%u", __kgid_val(opts->fs_gid));
|
|
seq_printf(m, ",fmask=%04o", opts->fs_fmask);
|
|
seq_printf(m, ",dmask=%04o", opts->fs_dmask);
|
|
if (opts->allow_utime)
|
|
seq_printf(m, ",allow_utime=%04o", opts->allow_utime);
|
|
if (sbi->nls_disk)
|
|
seq_printf(m, ",codepage=%s", sbi->nls_disk->charset);
|
|
if (sbi->nls_io)
|
|
seq_printf(m, ",iocharset=%s", sbi->nls_io->charset);
|
|
seq_printf(m, ",namecase=%u", opts->casesensitive);
|
|
if (opts->errors == EXFAT_ERRORS_CONT)
|
|
seq_puts(m, ",errors=continue");
|
|
else if (opts->errors == EXFAT_ERRORS_PANIC)
|
|
seq_puts(m, ",errors=panic");
|
|
else
|
|
seq_puts(m, ",errors=remount-ro");
|
|
#ifdef CONFIG_STAGING_EXFAT_DISCARD
|
|
if (opts->discard)
|
|
seq_puts(m, ",discard");
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static const struct super_operations exfat_sops = {
|
|
.alloc_inode = exfat_alloc_inode,
|
|
.destroy_inode = exfat_destroy_inode,
|
|
.write_inode = exfat_write_inode,
|
|
.evict_inode = exfat_evict_inode,
|
|
.put_super = exfat_put_super,
|
|
.sync_fs = exfat_sync_fs,
|
|
.statfs = exfat_statfs,
|
|
.remount_fs = exfat_remount,
|
|
.show_options = exfat_show_options,
|
|
};
|
|
|
|
/*======================================================================*/
|
|
/* Export Operations */
|
|
/*======================================================================*/
|
|
|
|
static struct inode *exfat_nfs_get_inode(struct super_block *sb, u64 ino,
|
|
u32 generation)
|
|
{
|
|
struct inode *inode = NULL;
|
|
|
|
if (ino < EXFAT_ROOT_INO)
|
|
return inode;
|
|
inode = ilookup(sb, ino);
|
|
|
|
if (inode && generation && (inode->i_generation != generation)) {
|
|
iput(inode);
|
|
inode = NULL;
|
|
}
|
|
|
|
return inode;
|
|
}
|
|
|
|
static struct dentry *exfat_fh_to_dentry(struct super_block *sb,
|
|
struct fid *fid, int fh_len,
|
|
int fh_type)
|
|
{
|
|
return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
|
|
exfat_nfs_get_inode);
|
|
}
|
|
|
|
static struct dentry *exfat_fh_to_parent(struct super_block *sb,
|
|
struct fid *fid, int fh_len,
|
|
int fh_type)
|
|
{
|
|
return generic_fh_to_parent(sb, fid, fh_len, fh_type,
|
|
exfat_nfs_get_inode);
|
|
}
|
|
|
|
static const struct export_operations exfat_export_ops = {
|
|
.fh_to_dentry = exfat_fh_to_dentry,
|
|
.fh_to_parent = exfat_fh_to_parent,
|
|
};
|
|
|
|
/*======================================================================*/
|
|
/* Super Block Read Operations */
|
|
/*======================================================================*/
|
|
|
|
enum {
|
|
Opt_uid,
|
|
Opt_gid,
|
|
Opt_umask,
|
|
Opt_dmask,
|
|
Opt_fmask,
|
|
Opt_allow_utime,
|
|
Opt_codepage,
|
|
Opt_charset,
|
|
Opt_namecase,
|
|
Opt_debug,
|
|
Opt_err_cont,
|
|
Opt_err_panic,
|
|
Opt_err_ro,
|
|
Opt_utf8_hack,
|
|
Opt_err,
|
|
#ifdef CONFIG_STAGING_EXFAT_DISCARD
|
|
Opt_discard,
|
|
#endif /* EXFAT_CONFIG_DISCARD */
|
|
};
|
|
|
|
static const match_table_t exfat_tokens = {
|
|
{Opt_uid, "uid=%u"},
|
|
{Opt_gid, "gid=%u"},
|
|
{Opt_umask, "umask=%o"},
|
|
{Opt_dmask, "dmask=%o"},
|
|
{Opt_fmask, "fmask=%o"},
|
|
{Opt_allow_utime, "allow_utime=%o"},
|
|
{Opt_codepage, "codepage=%u"},
|
|
{Opt_charset, "iocharset=%s"},
|
|
{Opt_namecase, "namecase=%u"},
|
|
{Opt_debug, "debug"},
|
|
{Opt_err_cont, "errors=continue"},
|
|
{Opt_err_panic, "errors=panic"},
|
|
{Opt_err_ro, "errors=remount-ro"},
|
|
{Opt_utf8_hack, "utf8"},
|
|
#ifdef CONFIG_STAGING_EXFAT_DISCARD
|
|
{Opt_discard, "discard"},
|
|
#endif /* CONFIG_STAGING_EXFAT_DISCARD */
|
|
{Opt_err, NULL}
|
|
};
|
|
|
|
static int parse_options(char *options, int silent, int *debug,
|
|
struct exfat_mount_options *opts)
|
|
{
|
|
char *p;
|
|
substring_t args[MAX_OPT_ARGS];
|
|
int option;
|
|
char *iocharset;
|
|
|
|
opts->fs_uid = current_uid();
|
|
opts->fs_gid = current_gid();
|
|
opts->fs_fmask = current->fs->umask;
|
|
opts->fs_dmask = current->fs->umask;
|
|
opts->allow_utime = U16_MAX;
|
|
opts->codepage = exfat_default_codepage;
|
|
opts->iocharset = exfat_default_iocharset;
|
|
opts->casesensitive = 0;
|
|
opts->errors = EXFAT_ERRORS_RO;
|
|
#ifdef CONFIG_STAGING_EXFAT_DISCARD
|
|
opts->discard = 0;
|
|
#endif
|
|
*debug = 0;
|
|
|
|
if (!options)
|
|
goto out;
|
|
|
|
while ((p = strsep(&options, ","))) {
|
|
int token;
|
|
|
|
if (!*p)
|
|
continue;
|
|
|
|
token = match_token(p, exfat_tokens, args);
|
|
switch (token) {
|
|
case Opt_uid:
|
|
if (match_int(&args[0], &option))
|
|
return 0;
|
|
opts->fs_uid = KUIDT_INIT(option);
|
|
break;
|
|
case Opt_gid:
|
|
if (match_int(&args[0], &option))
|
|
return 0;
|
|
opts->fs_gid = KGIDT_INIT(option);
|
|
break;
|
|
case Opt_umask:
|
|
case Opt_dmask:
|
|
case Opt_fmask:
|
|
if (match_octal(&args[0], &option))
|
|
return 0;
|
|
if (token != Opt_dmask)
|
|
opts->fs_fmask = option;
|
|
if (token != Opt_fmask)
|
|
opts->fs_dmask = option;
|
|
break;
|
|
case Opt_allow_utime:
|
|
if (match_octal(&args[0], &option))
|
|
return 0;
|
|
opts->allow_utime = option & 0022;
|
|
break;
|
|
case Opt_codepage:
|
|
if (match_int(&args[0], &option))
|
|
return 0;
|
|
opts->codepage = option;
|
|
break;
|
|
case Opt_charset:
|
|
if (opts->iocharset != exfat_default_iocharset)
|
|
kfree(opts->iocharset);
|
|
iocharset = match_strdup(&args[0]);
|
|
if (!iocharset)
|
|
return -ENOMEM;
|
|
opts->iocharset = iocharset;
|
|
break;
|
|
case Opt_namecase:
|
|
if (match_int(&args[0], &option))
|
|
return 0;
|
|
opts->casesensitive = option;
|
|
break;
|
|
case Opt_err_cont:
|
|
opts->errors = EXFAT_ERRORS_CONT;
|
|
break;
|
|
case Opt_err_panic:
|
|
opts->errors = EXFAT_ERRORS_PANIC;
|
|
break;
|
|
case Opt_err_ro:
|
|
opts->errors = EXFAT_ERRORS_RO;
|
|
break;
|
|
case Opt_debug:
|
|
*debug = 1;
|
|
break;
|
|
#ifdef CONFIG_STAGING_EXFAT_DISCARD
|
|
case Opt_discard:
|
|
opts->discard = 1;
|
|
break;
|
|
#endif /* CONFIG_STAGING_EXFAT_DISCARD */
|
|
case Opt_utf8_hack:
|
|
break;
|
|
default:
|
|
if (!silent)
|
|
pr_err("[EXFAT] Unrecognized mount option %s or missing value\n",
|
|
p);
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
out:
|
|
if (opts->allow_utime == U16_MAX)
|
|
opts->allow_utime = ~opts->fs_dmask & 0022;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void exfat_hash_init(struct super_block *sb)
|
|
{
|
|
struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
|
int i;
|
|
|
|
spin_lock_init(&sbi->inode_hash_lock);
|
|
for (i = 0; i < EXFAT_HASH_SIZE; i++)
|
|
INIT_HLIST_HEAD(&sbi->inode_hashtable[i]);
|
|
}
|
|
|
|
static int exfat_read_root(struct inode *inode)
|
|
{
|
|
struct super_block *sb = inode->i_sb;
|
|
struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
|
struct fs_info_t *p_fs = &sbi->fs_info;
|
|
struct timespec64 curtime;
|
|
struct dir_entry_t info;
|
|
|
|
EXFAT_I(inode)->fid.dir.dir = p_fs->root_dir;
|
|
EXFAT_I(inode)->fid.dir.flags = 0x01;
|
|
EXFAT_I(inode)->fid.entry = -1;
|
|
EXFAT_I(inode)->fid.start_clu = p_fs->root_dir;
|
|
EXFAT_I(inode)->fid.flags = 0x01;
|
|
EXFAT_I(inode)->fid.type = TYPE_DIR;
|
|
EXFAT_I(inode)->fid.rwoffset = 0;
|
|
EXFAT_I(inode)->fid.hint_last_off = -1;
|
|
|
|
EXFAT_I(inode)->target = NULL;
|
|
|
|
ffsReadStat(inode, &info);
|
|
|
|
inode->i_uid = sbi->options.fs_uid;
|
|
inode->i_gid = sbi->options.fs_gid;
|
|
INC_IVERSION(inode);
|
|
inode->i_generation = 0;
|
|
inode->i_mode = exfat_make_mode(sbi, ATTR_SUBDIR, 0777);
|
|
inode->i_op = &exfat_dir_inode_operations;
|
|
inode->i_fop = &exfat_dir_operations;
|
|
|
|
i_size_write(inode, info.Size);
|
|
inode->i_blocks = ((i_size_read(inode) + (p_fs->cluster_size - 1))
|
|
& ~((loff_t)p_fs->cluster_size - 1)) >> 9;
|
|
EXFAT_I(inode)->i_pos = ((loff_t)p_fs->root_dir << 32) | 0xffffffff;
|
|
EXFAT_I(inode)->mmu_private = i_size_read(inode);
|
|
|
|
exfat_save_attr(inode, ATTR_SUBDIR);
|
|
curtime = current_time(inode);
|
|
inode->i_mtime = curtime;
|
|
inode->i_atime = curtime;
|
|
inode->i_ctime = curtime;
|
|
set_nlink(inode, info.NumSubdirs + 2);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void setup_dops(struct super_block *sb)
|
|
{
|
|
if (EXFAT_SB(sb)->options.casesensitive == 0)
|
|
sb->s_d_op = &exfat_ci_dentry_ops;
|
|
else
|
|
sb->s_d_op = &exfat_dentry_ops;
|
|
}
|
|
|
|
static int exfat_fill_super(struct super_block *sb, void *data, int silent)
|
|
{
|
|
struct inode *root_inode = NULL;
|
|
struct exfat_sb_info *sbi;
|
|
int debug, ret;
|
|
long error;
|
|
|
|
/*
|
|
* GFP_KERNEL is ok here, because while we do hold the
|
|
* supeblock lock, memory pressure can't call back into
|
|
* the filesystem, since we're only just about to mount
|
|
* it and have no inodes etc active!
|
|
*/
|
|
sbi = kvzalloc(sizeof(*sbi), GFP_KERNEL);
|
|
if (!sbi)
|
|
return -ENOMEM;
|
|
mutex_init(&sbi->s_lock);
|
|
sb->s_fs_info = sbi;
|
|
sb->s_flags |= SB_NODIRATIME;
|
|
sb->s_magic = EXFAT_SUPER_MAGIC;
|
|
sb->s_op = &exfat_sops;
|
|
sb->s_export_op = &exfat_export_ops;
|
|
|
|
error = parse_options(data, silent, &debug, &sbi->options);
|
|
if (error)
|
|
goto out_fail;
|
|
|
|
setup_dops(sb);
|
|
|
|
error = -EIO;
|
|
sb_min_blocksize(sb, 512);
|
|
sb->s_maxbytes = 0x7fffffffffffffffLL; /* maximum file size */
|
|
|
|
ret = ffsMountVol(sb);
|
|
if (ret) {
|
|
if (!silent)
|
|
pr_err("[EXFAT] ffsMountVol failed\n");
|
|
|
|
goto out_fail;
|
|
}
|
|
|
|
/* set up enough so that it can read an inode */
|
|
exfat_hash_init(sb);
|
|
|
|
/*
|
|
* The low byte of FAT's first entry must have same value with
|
|
* media-field. But in real world, too many devices is
|
|
* writing wrong value. So, removed that validity check.
|
|
*
|
|
* if (FAT_FIRST_ENT(sb, media) != first)
|
|
*/
|
|
|
|
sbi->nls_io = load_nls(sbi->options.iocharset);
|
|
|
|
error = -ENOMEM;
|
|
root_inode = new_inode(sb);
|
|
if (!root_inode)
|
|
goto out_fail2;
|
|
root_inode->i_ino = EXFAT_ROOT_INO;
|
|
SET_IVERSION(root_inode, 1);
|
|
|
|
error = exfat_read_root(root_inode);
|
|
if (error < 0)
|
|
goto out_fail2;
|
|
error = -ENOMEM;
|
|
exfat_attach(root_inode, EXFAT_I(root_inode)->i_pos);
|
|
insert_inode_hash(root_inode);
|
|
sb->s_root = d_make_root(root_inode);
|
|
if (!sb->s_root) {
|
|
pr_err("[EXFAT] Getting the root inode failed\n");
|
|
goto out_fail2;
|
|
}
|
|
|
|
return 0;
|
|
|
|
out_fail2:
|
|
ffsUmountVol(sb);
|
|
out_fail:
|
|
if (root_inode)
|
|
iput(root_inode);
|
|
sb->s_fs_info = NULL;
|
|
exfat_free_super(sbi);
|
|
return error;
|
|
}
|
|
|
|
static struct dentry *exfat_fs_mount(struct file_system_type *fs_type,
|
|
int flags, const char *dev_name,
|
|
void *data)
|
|
{
|
|
return mount_bdev(fs_type, flags, dev_name, data, exfat_fill_super);
|
|
}
|
|
|
|
static void init_once(void *foo)
|
|
{
|
|
struct exfat_inode_info *ei = (struct exfat_inode_info *)foo;
|
|
|
|
INIT_HLIST_NODE(&ei->i_hash_fat);
|
|
inode_init_once(&ei->vfs_inode);
|
|
}
|
|
|
|
static int __init exfat_init_inodecache(void)
|
|
{
|
|
exfat_inode_cachep = kmem_cache_create("exfat_inode_cache",
|
|
sizeof(struct exfat_inode_info),
|
|
0,
|
|
(SLAB_RECLAIM_ACCOUNT |
|
|
SLAB_MEM_SPREAD),
|
|
init_once);
|
|
if (!exfat_inode_cachep)
|
|
return -ENOMEM;
|
|
return 0;
|
|
}
|
|
|
|
static void __exit exfat_destroy_inodecache(void)
|
|
{
|
|
/*
|
|
* Make sure all delayed rcu free inodes are flushed before we
|
|
* destroy cache.
|
|
*/
|
|
rcu_barrier();
|
|
kmem_cache_destroy(exfat_inode_cachep);
|
|
}
|
|
|
|
#ifdef CONFIG_STAGING_EXFAT_KERNEL_DEBUG
|
|
static void exfat_debug_kill_sb(struct super_block *sb)
|
|
{
|
|
struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
|
struct block_device *bdev = sb->s_bdev;
|
|
struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
|
|
|
|
long flags;
|
|
|
|
if (sbi) {
|
|
flags = sbi->debug_flags;
|
|
|
|
if (flags & EXFAT_DEBUGFLAGS_INVALID_UMOUNT) {
|
|
/*
|
|
* invalidate_bdev drops all device cache include
|
|
* dirty. We use this to simulate device removal.
|
|
*/
|
|
mutex_lock(&p_fs->v_mutex);
|
|
exfat_fat_release_all(sb);
|
|
exfat_buf_release_all(sb);
|
|
mutex_unlock(&p_fs->v_mutex);
|
|
|
|
invalidate_bdev(bdev);
|
|
}
|
|
}
|
|
|
|
kill_block_super(sb);
|
|
}
|
|
#endif /* CONFIG_STAGING_EXFAT_KERNEL_DEBUG */
|
|
|
|
static struct file_system_type exfat_fs_type = {
|
|
.owner = THIS_MODULE,
|
|
.name = "exfat",
|
|
.mount = exfat_fs_mount,
|
|
#ifdef CONFIG_STAGING_EXFAT_KERNEL_DEBUG
|
|
.kill_sb = exfat_debug_kill_sb,
|
|
#else
|
|
.kill_sb = kill_block_super,
|
|
#endif /* CONFIG_STAGING_EXFAT_KERNEL_DEBUG */
|
|
.fs_flags = FS_REQUIRES_DEV,
|
|
};
|
|
|
|
static int __init init_exfat(void)
|
|
{
|
|
int err;
|
|
|
|
BUILD_BUG_ON(sizeof(struct dentry_t) != DENTRY_SIZE);
|
|
BUILD_BUG_ON(sizeof(struct dos_dentry_t) != DENTRY_SIZE);
|
|
BUILD_BUG_ON(sizeof(struct ext_dentry_t) != DENTRY_SIZE);
|
|
BUILD_BUG_ON(sizeof(struct file_dentry_t) != DENTRY_SIZE);
|
|
BUILD_BUG_ON(sizeof(struct strm_dentry_t) != DENTRY_SIZE);
|
|
BUILD_BUG_ON(sizeof(struct name_dentry_t) != DENTRY_SIZE);
|
|
BUILD_BUG_ON(sizeof(struct bmap_dentry_t) != DENTRY_SIZE);
|
|
BUILD_BUG_ON(sizeof(struct case_dentry_t) != DENTRY_SIZE);
|
|
BUILD_BUG_ON(sizeof(struct volm_dentry_t) != DENTRY_SIZE);
|
|
|
|
pr_info("exFAT: Version %s\n", EXFAT_VERSION);
|
|
|
|
err = exfat_init_inodecache();
|
|
if (err)
|
|
return err;
|
|
|
|
err = register_filesystem(&exfat_fs_type);
|
|
if (err)
|
|
return err;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void __exit exit_exfat(void)
|
|
{
|
|
exfat_destroy_inodecache();
|
|
unregister_filesystem(&exfat_fs_type);
|
|
}
|
|
|
|
module_init(init_exfat);
|
|
module_exit(exit_exfat);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_DESCRIPTION("exFAT Filesystem Driver");
|
|
MODULE_ALIAS_FS("exfat");
|