mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-09 21:59:12 -04:00
Namjae Jeon
GitHub
commit
0e85284b46
11 changed files with 352 additions and 53 deletions
|
|
@ -148,9 +148,11 @@ script:
|
|||
- sudo ./check generic/248
|
||||
- sudo ./check generic/249
|
||||
- sudo ./check generic/257
|
||||
- sudo ./check generic/260
|
||||
- sudo ./check generic/263
|
||||
- sudo ./check generic/285
|
||||
- sudo ./check generic/286
|
||||
- sudo ./check generic/288
|
||||
- sudo ./check generic/308
|
||||
- sudo ./check generic/309
|
||||
- sudo ./check generic/310
|
||||
|
|
|
|||
103
balloc.c
103
balloc.c
|
|
@ -3,9 +3,13 @@
|
|||
* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
|
||||
*/
|
||||
|
||||
#include <linux/version.h>
|
||||
#include <linux/blkdev.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/buffer_head.h>
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 4, 0)
|
||||
#include <linux/sched/signal.h>
|
||||
#endif
|
||||
|
||||
#include "exfat_raw.h"
|
||||
#include "exfat_fs.h"
|
||||
|
|
@ -141,11 +145,7 @@ void exfat_free_bitmap(struct exfat_sb_info *sbi)
|
|||
kfree(sbi->vol_amap);
|
||||
}
|
||||
|
||||
/*
|
||||
* If the value of "clu" is 0, it means cluster 2 which is the first cluster of
|
||||
* the cluster heap.
|
||||
*/
|
||||
int exfat_set_bitmap(struct inode *inode, unsigned int clu)
|
||||
int exfat_set_bitmap(struct inode *inode, unsigned int clu, bool sync)
|
||||
{
|
||||
int i, b;
|
||||
unsigned int ent_idx;
|
||||
|
|
@ -158,15 +158,11 @@ int exfat_set_bitmap(struct inode *inode, unsigned int clu)
|
|||
b = BITMAP_OFFSET_BIT_IN_SECTOR(sb, ent_idx);
|
||||
|
||||
set_bit_le(b, sbi->vol_amap[i]->b_data);
|
||||
exfat_update_bh(sbi->vol_amap[i], IS_DIRSYNC(inode));
|
||||
exfat_update_bh(sbi->vol_amap[i], sync);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* If the value of "clu" is 0, it means cluster 2 which is the first cluster of
|
||||
* the cluster heap.
|
||||
*/
|
||||
void exfat_clear_bitmap(struct inode *inode, unsigned int clu)
|
||||
void exfat_clear_bitmap(struct inode *inode, unsigned int clu, bool sync)
|
||||
{
|
||||
int i, b;
|
||||
unsigned int ent_idx;
|
||||
|
|
@ -180,14 +176,13 @@ void exfat_clear_bitmap(struct inode *inode, unsigned int clu)
|
|||
b = BITMAP_OFFSET_BIT_IN_SECTOR(sb, ent_idx);
|
||||
|
||||
clear_bit_le(b, sbi->vol_amap[i]->b_data);
|
||||
exfat_update_bh(sbi->vol_amap[i], IS_DIRSYNC(inode));
|
||||
exfat_update_bh(sbi->vol_amap[i], sync);
|
||||
|
||||
if (opts->discard) {
|
||||
int ret_discard;
|
||||
|
||||
ret_discard = sb_issue_discard(sb,
|
||||
exfat_cluster_to_sector(sbi, clu +
|
||||
EXFAT_RESERVED_CLUSTERS),
|
||||
exfat_cluster_to_sector(sbi, clu),
|
||||
(1 << sbi->sect_per_clus_bits), GFP_NOFS, 0);
|
||||
|
||||
if (ret_discard == -EOPNOTSUPP) {
|
||||
|
|
@ -273,3 +268,83 @@ int exfat_count_used_clusters(struct super_block *sb, unsigned int *ret_count)
|
|||
*ret_count = count;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int exfat_trim_fs(struct inode *inode, struct fstrim_range *range)
|
||||
{
|
||||
unsigned int trim_begin, trim_end, count, next_free_clu;
|
||||
u64 clu_start, clu_end, trim_minlen, trimmed_total = 0;
|
||||
struct super_block *sb = inode->i_sb;
|
||||
struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
||||
int err = 0;
|
||||
|
||||
clu_start = max_t(u64, range->start >> sbi->cluster_size_bits,
|
||||
EXFAT_FIRST_CLUSTER);
|
||||
clu_end = clu_start + (range->len >> sbi->cluster_size_bits) - 1;
|
||||
trim_minlen = range->minlen >> sbi->cluster_size_bits;
|
||||
|
||||
if (clu_start >= sbi->num_clusters || range->len < sbi->cluster_size)
|
||||
return -EINVAL;
|
||||
|
||||
if (clu_end >= sbi->num_clusters)
|
||||
clu_end = sbi->num_clusters - 1;
|
||||
|
||||
mutex_lock(&sbi->bitmap_lock);
|
||||
|
||||
trim_begin = trim_end = exfat_find_free_bitmap(sb, clu_start);
|
||||
if (trim_begin == EXFAT_EOF_CLUSTER)
|
||||
goto unlock;
|
||||
|
||||
next_free_clu = exfat_find_free_bitmap(sb, trim_end + 1);
|
||||
if (next_free_clu == EXFAT_EOF_CLUSTER)
|
||||
goto unlock;
|
||||
|
||||
do {
|
||||
if (next_free_clu == trim_end + 1) {
|
||||
/* extend trim range for continuous free cluster */
|
||||
trim_end++;
|
||||
} else {
|
||||
/* trim current range if it's larger than trim_minlen */
|
||||
count = trim_end - trim_begin + 1;
|
||||
if (count >= trim_minlen) {
|
||||
err = sb_issue_discard(sb,
|
||||
exfat_cluster_to_sector(sbi, trim_begin),
|
||||
count * sbi->sect_per_clus, GFP_NOFS, 0);
|
||||
if (err)
|
||||
goto unlock;
|
||||
|
||||
trimmed_total += count;
|
||||
}
|
||||
|
||||
/* set next start point of the free hole */
|
||||
trim_begin = trim_end = next_free_clu;
|
||||
}
|
||||
|
||||
if (next_free_clu >= clu_end)
|
||||
break;
|
||||
|
||||
if (fatal_signal_pending(current)) {
|
||||
err = -ERESTARTSYS;
|
||||
goto unlock;
|
||||
}
|
||||
|
||||
next_free_clu = exfat_find_free_bitmap(sb, next_free_clu + 1);
|
||||
} while (next_free_clu != EXFAT_EOF_CLUSTER &&
|
||||
next_free_clu > trim_end);
|
||||
|
||||
/* try to trim remainder */
|
||||
count = trim_end - trim_begin + 1;
|
||||
if (count >= trim_minlen) {
|
||||
err = sb_issue_discard(sb, exfat_cluster_to_sector(sbi, trim_begin),
|
||||
count * sbi->sect_per_clus, GFP_NOFS, 0);
|
||||
if (err)
|
||||
goto unlock;
|
||||
|
||||
trimmed_total += count;
|
||||
}
|
||||
|
||||
unlock:
|
||||
mutex_unlock(&sbi->bitmap_lock);
|
||||
range->len = trimmed_total << sbi->cluster_size_bits;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
|
|||
26
dir.c
26
dir.c
|
|
@ -5,6 +5,7 @@
|
|||
|
||||
#include <linux/version.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/compat.h>
|
||||
#include <linux/bio.h>
|
||||
#include <linux/buffer_head.h>
|
||||
|
||||
|
|
@ -147,7 +148,7 @@ static int exfat_readdir(struct inode *inode, loff_t *cpos, struct exfat_dir_ent
|
|||
0);
|
||||
|
||||
*uni_name.name = 0x0;
|
||||
exfat_get_uniname_from_ext_entry(sb, &dir, dentry,
|
||||
exfat_get_uniname_from_ext_entry(sb, &clu, i,
|
||||
uni_name.name);
|
||||
exfat_utf16_to_nls(sb, &uni_name,
|
||||
dir_entry->namebuf.lfn,
|
||||
|
|
@ -307,6 +308,10 @@ const struct file_operations exfat_dir_operations = {
|
|||
.llseek = generic_file_llseek,
|
||||
.read = generic_read_dir,
|
||||
.iterate = exfat_iterate,
|
||||
.unlocked_ioctl = exfat_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = exfat_compat_ioctl,
|
||||
#endif
|
||||
.fsync = exfat_file_fsync,
|
||||
};
|
||||
|
||||
|
|
@ -316,7 +321,7 @@ int exfat_alloc_new_dir(struct inode *inode, struct exfat_chain *clu)
|
|||
|
||||
exfat_chain_set(clu, EXFAT_EOF_CLUSTER, 0, ALLOC_NO_FAT_CHAIN);
|
||||
|
||||
ret = exfat_alloc_cluster(inode, 1, clu);
|
||||
ret = exfat_alloc_cluster(inode, 1, clu, IS_DIRSYNC(inode));
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
|
|
@ -917,14 +922,19 @@ enum {
|
|||
};
|
||||
|
||||
/*
|
||||
* return values:
|
||||
* >= 0 : return dir entiry position with the name in dir
|
||||
* -ENOENT : entry with the name does not exist
|
||||
* -EIO : I/O error
|
||||
* @ei: inode info of parent directory
|
||||
* @p_dir: directory structure of parent directory
|
||||
* @num_entries:entry size of p_uniname
|
||||
* @hint_opt: If p_uniname is found, filled with optimized dir/entry
|
||||
* for traversing cluster chain.
|
||||
* @return:
|
||||
* >= 0: file directory entry position where the name exists
|
||||
* -ENOENT: entry with the name does not exist
|
||||
* -EIO: I/O error
|
||||
*/
|
||||
int exfat_find_dir_entry(struct super_block *sb, struct exfat_inode_info *ei,
|
||||
struct exfat_chain *p_dir, struct exfat_uni_name *p_uniname,
|
||||
int num_entries, unsigned int type)
|
||||
int num_entries, unsigned int type, struct exfat_hint *hint_opt)
|
||||
{
|
||||
int i, rewind = 0, dentry = 0, end_eidx = 0, num_ext = 0, len;
|
||||
int order, step, name_len = 0;
|
||||
|
|
@ -1001,6 +1011,8 @@ rewind:
|
|||
|
||||
if (entry_type == TYPE_FILE || entry_type == TYPE_DIR) {
|
||||
step = DIRENT_STEP_FILE;
|
||||
hint_opt->clu = clu.dir;
|
||||
hint_opt->eidx = i;
|
||||
if (type == TYPE_ALL || type == entry_type) {
|
||||
num_ext = ep->dentry.file.num_ext;
|
||||
step = DIRENT_STEP_STRM;
|
||||
|
|
|
|||
24
exfat_fs.h
24
exfat_fs.h
|
|
@ -11,7 +11,7 @@
|
|||
#include <linux/ratelimit.h>
|
||||
#include <linux/nls.h>
|
||||
|
||||
#define EXFAT_VERSION "5.11.1"
|
||||
#define EXFAT_VERSION "5.12.3"
|
||||
|
||||
#define EXFAT_SUPER_MAGIC 0x2011BAB0UL
|
||||
#define EXFAT_ROOT_INO 1
|
||||
|
|
@ -247,6 +247,7 @@ struct exfat_sb_info {
|
|||
unsigned int used_clusters; /* number of used clusters */
|
||||
|
||||
struct mutex s_lock; /* superblock lock */
|
||||
struct mutex bitmap_lock; /* bitmap lock */
|
||||
struct exfat_mount_options options;
|
||||
struct nls_table *nls_io; /* Charset used for input and display */
|
||||
struct ratelimit_state ratelimit;
|
||||
|
|
@ -401,7 +402,7 @@ int exfat_clear_volume_dirty(struct super_block *sb);
|
|||
#define exfat_get_next_cluster(sb, pclu) exfat_ent_get(sb, *(pclu), pclu)
|
||||
|
||||
int exfat_alloc_cluster(struct inode *inode, unsigned int num_alloc,
|
||||
struct exfat_chain *p_chain);
|
||||
struct exfat_chain *p_chain, bool sync_bmap);
|
||||
int exfat_free_cluster(struct inode *inode, struct exfat_chain *p_chain);
|
||||
int exfat_ent_get(struct super_block *sb, unsigned int loc,
|
||||
unsigned int *content);
|
||||
|
|
@ -420,15 +421,24 @@ int exfat_count_num_clusters(struct super_block *sb,
|
|||
/* balloc.c */
|
||||
int exfat_load_bitmap(struct super_block *sb);
|
||||
void exfat_free_bitmap(struct exfat_sb_info *sbi);
|
||||
int exfat_set_bitmap(struct inode *inode, unsigned int clu);
|
||||
void exfat_clear_bitmap(struct inode *inode, unsigned int clu);
|
||||
int exfat_set_bitmap(struct inode *inode, unsigned int clu, bool sync);
|
||||
void exfat_clear_bitmap(struct inode *inode, unsigned int clu, bool sync);
|
||||
unsigned int exfat_find_free_bitmap(struct super_block *sb, unsigned int clu);
|
||||
int exfat_count_used_clusters(struct super_block *sb, unsigned int *ret_count);
|
||||
int exfat_trim_fs(struct inode *inode, struct fstrim_range *range);
|
||||
|
||||
/* file.c */
|
||||
extern const struct file_operations exfat_file_operations;
|
||||
int __exfat_truncate(struct inode *inode, loff_t new_size);
|
||||
void exfat_truncate(struct inode *inode, loff_t size);
|
||||
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 12, 0)
|
||||
int exfat_setattr(struct user_namespace *mnt_userns, struct dentry *dentry,
|
||||
struct iattr *attr);
|
||||
int exfat_getattr(struct user_namespace *mnt_userns, const struct path *path,
|
||||
struct kstat *stat, unsigned int request_mask,
|
||||
unsigned int query_flags);
|
||||
#else
|
||||
int exfat_setattr(struct dentry *dentry, struct iattr *attr);
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
|
||||
int exfat_getattr(const struct path *path, struct kstat *stat,
|
||||
|
|
@ -437,7 +447,11 @@ int exfat_getattr(const struct path *path, struct kstat *stat,
|
|||
int exfat_getattr(struct vfsmount *mnt, struct dentry *dentry,
|
||||
struct kstat *stat);
|
||||
#endif
|
||||
#endif
|
||||
int exfat_file_fsync(struct file *file, loff_t start, loff_t end, int datasync);
|
||||
long exfat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
|
||||
long exfat_compat_ioctl(struct file *filp, unsigned int cmd,
|
||||
unsigned long arg);
|
||||
|
||||
|
||||
/* namei.c */
|
||||
|
|
@ -469,7 +483,7 @@ void exfat_update_dir_chksum_with_entry_set(struct exfat_entry_set_cache *es);
|
|||
int exfat_calc_num_entries(struct exfat_uni_name *p_uniname);
|
||||
int exfat_find_dir_entry(struct super_block *sb, struct exfat_inode_info *ei,
|
||||
struct exfat_chain *p_dir, struct exfat_uni_name *p_uniname,
|
||||
int num_entries, unsigned int type);
|
||||
int num_entries, unsigned int type, struct exfat_hint *hint_opt);
|
||||
int exfat_alloc_new_dir(struct inode *inode, struct exfat_chain *clu);
|
||||
int exfat_find_location(struct super_block *sb, struct exfat_chain *p_dir,
|
||||
int entry, sector_t *sector, int *offset);
|
||||
|
|
|
|||
|
|
@ -77,6 +77,10 @@
|
|||
|
||||
#define EXFAT_FILE_NAME_LEN 15
|
||||
|
||||
#define EXFAT_MIN_SECT_SIZE_BITS 9
|
||||
#define EXFAT_MAX_SECT_SIZE_BITS 12
|
||||
#define EXFAT_MAX_SECT_PER_CLUS_BITS(x) (25 - (x)->sect_size_bits)
|
||||
|
||||
/* EXFAT: Main and Backup Boot Sector (512 bytes) */
|
||||
struct boot_sector {
|
||||
__u8 jmp_boot[BOOTSEC_JUMP_BOOT_LEN];
|
||||
|
|
|
|||
86
fatent.c
86
fatent.c
|
|
@ -159,12 +159,14 @@ int exfat_chain_cont_cluster(struct super_block *sb, unsigned int chain,
|
|||
return 0;
|
||||
}
|
||||
|
||||
int exfat_free_cluster(struct inode *inode, struct exfat_chain *p_chain)
|
||||
/* This function must be called with bitmap_lock held */
|
||||
static int __exfat_free_cluster(struct inode *inode, struct exfat_chain *p_chain)
|
||||
{
|
||||
unsigned int num_clusters = 0;
|
||||
unsigned int clu;
|
||||
struct super_block *sb = inode->i_sb;
|
||||
struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
||||
int cur_cmap_i, next_cmap_i;
|
||||
unsigned int num_clusters = 0;
|
||||
unsigned int clu;
|
||||
|
||||
/* invalid cluster number */
|
||||
if (p_chain->dir == EXFAT_FREE_CLUSTER ||
|
||||
|
|
@ -184,21 +186,51 @@ int exfat_free_cluster(struct inode *inode, struct exfat_chain *p_chain)
|
|||
|
||||
clu = p_chain->dir;
|
||||
|
||||
if (p_chain->flags == ALLOC_NO_FAT_CHAIN) {
|
||||
do {
|
||||
exfat_clear_bitmap(inode, clu);
|
||||
clu++;
|
||||
cur_cmap_i = next_cmap_i =
|
||||
BITMAP_OFFSET_SECTOR_INDEX(sb, CLUSTER_TO_BITMAP_ENT(clu));
|
||||
|
||||
if (p_chain->flags == ALLOC_NO_FAT_CHAIN) {
|
||||
unsigned int last_cluster = p_chain->dir + p_chain->size - 1;
|
||||
do {
|
||||
bool sync = false;
|
||||
|
||||
if (clu < last_cluster)
|
||||
next_cmap_i =
|
||||
BITMAP_OFFSET_SECTOR_INDEX(sb, CLUSTER_TO_BITMAP_ENT(clu+1));
|
||||
|
||||
/* flush bitmap only if index would be changed or for last cluster */
|
||||
if (clu == last_cluster || cur_cmap_i != next_cmap_i) {
|
||||
sync = true;
|
||||
cur_cmap_i = next_cmap_i;
|
||||
}
|
||||
|
||||
exfat_clear_bitmap(inode, clu, (sync && IS_DIRSYNC(inode)));
|
||||
clu++;
|
||||
num_clusters++;
|
||||
} while (num_clusters < p_chain->size);
|
||||
} else {
|
||||
do {
|
||||
exfat_clear_bitmap(inode, clu);
|
||||
bool sync = false;
|
||||
unsigned int n_clu = clu;
|
||||
int err = exfat_get_next_cluster(sb, &n_clu);
|
||||
|
||||
if (exfat_get_next_cluster(sb, &clu))
|
||||
goto dec_used_clus;
|
||||
if (err || n_clu == EXFAT_EOF_CLUSTER)
|
||||
sync = true;
|
||||
else
|
||||
next_cmap_i =
|
||||
BITMAP_OFFSET_SECTOR_INDEX(sb, CLUSTER_TO_BITMAP_ENT(n_clu));
|
||||
|
||||
if (cur_cmap_i != next_cmap_i) {
|
||||
sync = true;
|
||||
cur_cmap_i = next_cmap_i;
|
||||
}
|
||||
|
||||
exfat_clear_bitmap(inode, clu, (sync && IS_DIRSYNC(inode)));
|
||||
clu = n_clu;
|
||||
num_clusters++;
|
||||
|
||||
if (err)
|
||||
goto dec_used_clus;
|
||||
} while (clu != EXFAT_EOF_CLUSTER);
|
||||
}
|
||||
|
||||
|
|
@ -207,6 +239,17 @@ dec_used_clus:
|
|||
return 0;
|
||||
}
|
||||
|
||||
int exfat_free_cluster(struct inode *inode, struct exfat_chain *p_chain)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
mutex_lock(&EXFAT_SB(inode->i_sb)->bitmap_lock);
|
||||
ret = __exfat_free_cluster(inode, p_chain);
|
||||
mutex_unlock(&EXFAT_SB(inode->i_sb)->bitmap_lock);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int exfat_find_last_cluster(struct super_block *sb, struct exfat_chain *p_chain,
|
||||
unsigned int *ret_clu)
|
||||
{
|
||||
|
|
@ -285,7 +328,7 @@ release_bhs:
|
|||
}
|
||||
|
||||
int exfat_alloc_cluster(struct inode *inode, unsigned int num_alloc,
|
||||
struct exfat_chain *p_chain)
|
||||
struct exfat_chain *p_chain, bool sync_bmap)
|
||||
{
|
||||
int ret = -ENOSPC;
|
||||
unsigned int num_clusters = 0, total_cnt;
|
||||
|
|
@ -305,6 +348,8 @@ int exfat_alloc_cluster(struct inode *inode, unsigned int num_alloc,
|
|||
if (num_alloc > total_cnt - sbi->used_clusters)
|
||||
return -ENOSPC;
|
||||
|
||||
mutex_lock(&sbi->bitmap_lock);
|
||||
|
||||
hint_clu = p_chain->dir;
|
||||
/* find new cluster */
|
||||
if (hint_clu == EXFAT_EOF_CLUSTER) {
|
||||
|
|
@ -315,8 +360,10 @@ int exfat_alloc_cluster(struct inode *inode, unsigned int num_alloc,
|
|||
}
|
||||
|
||||
hint_clu = exfat_find_free_bitmap(sb, sbi->clu_srch_ptr);
|
||||
if (hint_clu == EXFAT_EOF_CLUSTER)
|
||||
return -ENOSPC;
|
||||
if (hint_clu == EXFAT_EOF_CLUSTER) {
|
||||
ret = -ENOSPC;
|
||||
goto unlock;
|
||||
}
|
||||
}
|
||||
|
||||
/* check cluster validation */
|
||||
|
|
@ -326,8 +373,10 @@ int exfat_alloc_cluster(struct inode *inode, unsigned int num_alloc,
|
|||
hint_clu = EXFAT_FIRST_CLUSTER;
|
||||
if (p_chain->flags == ALLOC_NO_FAT_CHAIN) {
|
||||
if (exfat_chain_cont_cluster(sb, p_chain->dir,
|
||||
num_clusters))
|
||||
return -EIO;
|
||||
num_clusters)) {
|
||||
ret = -EIO;
|
||||
goto unlock;
|
||||
}
|
||||
p_chain->flags = ALLOC_FAT_CHAIN;
|
||||
}
|
||||
}
|
||||
|
|
@ -347,7 +396,7 @@ int exfat_alloc_cluster(struct inode *inode, unsigned int num_alloc,
|
|||
}
|
||||
|
||||
/* update allocation bitmap */
|
||||
if (exfat_set_bitmap(inode, new_clu)) {
|
||||
if (exfat_set_bitmap(inode, new_clu, sync_bmap)) {
|
||||
ret = -EIO;
|
||||
goto free_cluster;
|
||||
}
|
||||
|
|
@ -377,6 +426,7 @@ int exfat_alloc_cluster(struct inode *inode, unsigned int num_alloc,
|
|||
sbi->used_clusters += num_clusters;
|
||||
|
||||
p_chain->size += num_clusters;
|
||||
mutex_unlock(&sbi->bitmap_lock);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -396,7 +446,9 @@ int exfat_alloc_cluster(struct inode *inode, unsigned int num_alloc,
|
|||
}
|
||||
free_cluster:
|
||||
if (num_clusters)
|
||||
exfat_free_cluster(inode, p_chain);
|
||||
__exfat_free_cluster(inode, p_chain);
|
||||
unlock:
|
||||
mutex_unlock(&sbi->bitmap_lock);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
|||
83
file.c
83
file.c
|
|
@ -8,9 +8,8 @@
|
|||
#include <linux/buffer_head.h>
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
|
||||
#include <linux/cred.h>
|
||||
#else
|
||||
#include <linux/compat.h>
|
||||
#endif
|
||||
#include <linux/compat.h>
|
||||
#include <linux/blkdev.h>
|
||||
|
||||
#include "exfat_raw.h"
|
||||
|
|
@ -292,6 +291,11 @@ write_size:
|
|||
mutex_unlock(&sbi->s_lock);
|
||||
}
|
||||
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 12, 0)
|
||||
int exfat_getattr(struct user_namespace *mnt_uerns, const struct path *path,
|
||||
struct kstat *stat, unsigned int request_mask,
|
||||
unsigned int query_flags)
|
||||
#else
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
|
||||
int exfat_getattr(const struct path *path, struct kstat *stat,
|
||||
unsigned int request_mask, unsigned int query_flags)
|
||||
|
|
@ -299,7 +303,7 @@ int exfat_getattr(const struct path *path, struct kstat *stat,
|
|||
int exfat_getattr(struct vfsmount *mnt, struct dentry *dentry,
|
||||
struct kstat *stat)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
{
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
|
||||
struct inode *inode = d_backing_inode(path->dentry);
|
||||
|
|
@ -308,7 +312,11 @@ int exfat_getattr(struct vfsmount *mnt, struct dentry *dentry,
|
|||
struct inode *inode = d_inode(dentry);
|
||||
#endif
|
||||
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 12, 0)
|
||||
generic_fillattr(&init_user_ns, inode, stat);
|
||||
#else
|
||||
generic_fillattr(inode, stat);
|
||||
#endif
|
||||
exfat_truncate_atime(&stat->atime);
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
|
||||
stat->result_mask |= STATX_BTIME;
|
||||
|
|
@ -319,7 +327,12 @@ int exfat_getattr(struct vfsmount *mnt, struct dentry *dentry,
|
|||
return 0;
|
||||
}
|
||||
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 12, 0)
|
||||
int exfat_setattr(struct user_namespace *mnt_userns, struct dentry *dentry,
|
||||
struct iattr *attr)
|
||||
#else
|
||||
int exfat_setattr(struct dentry *dentry, struct iattr *attr)
|
||||
#endif
|
||||
{
|
||||
struct exfat_sb_info *sbi = EXFAT_SB(dentry->d_sb);
|
||||
struct inode *inode = dentry->d_inode;
|
||||
|
|
@ -345,7 +358,11 @@ int exfat_setattr(struct dentry *dentry, struct iattr *attr)
|
|||
#if ((LINUX_VERSION_CODE < KERNEL_VERSION(4, 2, 0)) && \
|
||||
(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 37))) || \
|
||||
(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 9, 0))
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 12, 0)
|
||||
error = setattr_prepare(&init_user_ns, dentry, attr);
|
||||
#else
|
||||
error = setattr_prepare(dentry, attr);
|
||||
#endif
|
||||
#else
|
||||
error = inode_change_ok(inode, attr);
|
||||
#endif
|
||||
|
|
@ -383,7 +400,11 @@ int exfat_setattr(struct dentry *dentry, struct iattr *attr)
|
|||
up_write(&EXFAT_I(inode)->truncate_lock);
|
||||
}
|
||||
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 12, 0)
|
||||
setattr_copy(&init_user_ns, inode, attr);
|
||||
#else
|
||||
setattr_copy(inode, attr);
|
||||
#endif
|
||||
exfat_truncate_atime(&inode->i_atime);
|
||||
mark_inode_dirty(inode);
|
||||
|
||||
|
|
@ -391,6 +412,54 @@ out:
|
|||
return error;
|
||||
}
|
||||
|
||||
static int exfat_ioctl_fitrim(struct inode *inode, unsigned long arg)
|
||||
{
|
||||
struct request_queue *q = bdev_get_queue(inode->i_sb->s_bdev);
|
||||
struct fstrim_range range;
|
||||
int ret = 0;
|
||||
|
||||
if (!capable(CAP_SYS_ADMIN))
|
||||
return -EPERM;
|
||||
|
||||
if (!blk_queue_discard(q))
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
if (copy_from_user(&range, (struct fstrim_range __user *)arg, sizeof(range)))
|
||||
return -EFAULT;
|
||||
|
||||
range.minlen = max_t(unsigned int, range.minlen,
|
||||
q->limits.discard_granularity);
|
||||
|
||||
ret = exfat_trim_fs(inode, &range);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
if (copy_to_user((struct fstrim_range __user *)arg, &range, sizeof(range)))
|
||||
return -EFAULT;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
long exfat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
struct inode *inode = file_inode(filp);
|
||||
|
||||
switch (cmd) {
|
||||
case FITRIM:
|
||||
return exfat_ioctl_fitrim(inode, arg);
|
||||
default:
|
||||
return -ENOTTY;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
long exfat_compat_ioctl(struct file *filp, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
{
|
||||
return exfat_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
|
||||
}
|
||||
#endif
|
||||
|
||||
int exfat_file_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
|
||||
{
|
||||
struct inode *inode = filp->f_mapping->host;
|
||||
|
|
@ -404,17 +473,25 @@ int exfat_file_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
|
|||
if (err)
|
||||
return err;
|
||||
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 12, 0)
|
||||
return blkdev_issue_flush(inode->i_sb->s_bdev);
|
||||
#else
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0)
|
||||
return blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL);
|
||||
#else
|
||||
return blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL);
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
const struct file_operations exfat_file_operations = {
|
||||
.llseek = generic_file_llseek,
|
||||
.read_iter = generic_file_read_iter,
|
||||
.write_iter = generic_file_write_iter,
|
||||
.unlocked_ioctl = exfat_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = exfat_compat_ioctl,
|
||||
#endif
|
||||
.mmap = generic_file_mmap,
|
||||
.fsync = exfat_file_fsync,
|
||||
.splice_read = generic_file_splice_read,
|
||||
|
|
|
|||
3
inode.c
3
inode.c
|
|
@ -181,7 +181,8 @@ static int exfat_map_cluster(struct inode *inode, unsigned int clu_offset,
|
|||
return -EIO;
|
||||
}
|
||||
|
||||
ret = exfat_alloc_cluster(inode, num_to_be_allocated, &new_clu);
|
||||
ret = exfat_alloc_cluster(inode, num_to_be_allocated, &new_clu,
|
||||
inode_needs_sync(inode));
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
|
|
|
|||
11
misc.c
11
misc.c
|
|
@ -126,6 +126,17 @@ void exfat_set_entry_time(struct exfat_sb_info *sbi, struct timespec *ts,
|
|||
struct tm tm;
|
||||
u16 t, d;
|
||||
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 4, 0)
|
||||
if (ts->tv_sec < EXFAT_MIN_TIMESTAMP_SECS) {
|
||||
ts->tv_sec = EXFAT_MIN_TIMESTAMP_SECS;
|
||||
ts->tv_nsec = 0;
|
||||
}
|
||||
else if (ts->tv_sec > EXFAT_MAX_TIMESTAMP_SECS) {
|
||||
ts->tv_sec = EXFAT_MAX_TIMESTAMP_SECS;
|
||||
ts->tv_nsec = 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 8, 0)
|
||||
time64_to_tm(ts->tv_sec, 0, &tm);
|
||||
#else
|
||||
|
|
|
|||
28
namei.c
28
namei.c
|
|
@ -367,7 +367,7 @@ static int exfat_find_empty_entry(struct inode *inode,
|
|||
exfat_chain_set(&clu, last_clu + 1, 0, p_dir->flags);
|
||||
|
||||
/* allocate a cluster */
|
||||
ret = exfat_alloc_cluster(inode, 1, &clu);
|
||||
ret = exfat_alloc_cluster(inode, 1, &clu, IS_DIRSYNC(inode));
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
|
|
@ -568,8 +568,13 @@ out:
|
|||
return ret;
|
||||
}
|
||||
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 12, 0)
|
||||
static int exfat_create(struct user_namespace *mnt_userns, struct inode *dir,
|
||||
struct dentry *dentry, umode_t mode, bool excl)
|
||||
#else
|
||||
static int exfat_create(struct inode *dir, struct dentry *dentry, umode_t mode,
|
||||
bool excl)
|
||||
#endif
|
||||
{
|
||||
struct super_block *sb = dir->i_sb;
|
||||
struct inode *inode;
|
||||
|
|
@ -641,6 +646,8 @@ static int exfat_find(struct inode *dir, struct qstr *qname,
|
|||
struct exfat_inode_info *ei = EXFAT_I(dir);
|
||||
struct exfat_dentry *ep, *ep2;
|
||||
struct exfat_entry_set_cache *es;
|
||||
/* for optimized dir & entry to prevent long traverse of cluster chain */
|
||||
struct exfat_hint hint_opt;
|
||||
|
||||
if (qname->len == 0)
|
||||
return -ENOENT;
|
||||
|
|
@ -672,7 +679,7 @@ static int exfat_find(struct inode *dir, struct qstr *qname,
|
|||
|
||||
/* search the file name for directories */
|
||||
dentry = exfat_find_dir_entry(sb, ei, &cdir, &uni_name,
|
||||
num_entries, TYPE_ALL);
|
||||
num_entries, TYPE_ALL, &hint_opt);
|
||||
|
||||
if (dentry < 0)
|
||||
return dentry; /* -error value */
|
||||
|
|
@ -681,6 +688,11 @@ static int exfat_find(struct inode *dir, struct qstr *qname,
|
|||
info->entry = dentry;
|
||||
info->num_subdirs = 0;
|
||||
|
||||
/* adjust cdir to the optimized value */
|
||||
cdir.dir = hint_opt.clu;
|
||||
if (cdir.flags & ALLOC_NO_FAT_CHAIN)
|
||||
cdir.size -= dentry / sbi->dentries_per_clu;
|
||||
dentry = hint_opt.eidx;
|
||||
es = exfat_get_dentry_set(sb, &cdir, dentry, ES_2_ENTRIES);
|
||||
if (!es)
|
||||
return -EIO;
|
||||
|
|
@ -900,7 +912,12 @@ unlock:
|
|||
return err;
|
||||
}
|
||||
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 12, 0)
|
||||
static int exfat_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
|
||||
struct dentry *dentry, umode_t mode)
|
||||
#else
|
||||
static int exfat_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
|
||||
#endif
|
||||
{
|
||||
struct super_block *sb = dir->i_sb;
|
||||
struct inode *inode;
|
||||
|
|
@ -1425,6 +1442,12 @@ out:
|
|||
return ret;
|
||||
}
|
||||
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 12, 0)
|
||||
static int exfat_rename(struct user_namespace *mnt_userns,
|
||||
struct inode *old_dir, struct dentry *old_dentry,
|
||||
struct inode *new_dir, struct dentry *new_dentry,
|
||||
unsigned int flags)
|
||||
#else
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 9, 0)
|
||||
static int exfat_rename(struct inode *old_dir, struct dentry *old_dentry,
|
||||
struct inode *new_dir, struct dentry *new_dentry,
|
||||
|
|
@ -1433,6 +1456,7 @@ static int exfat_rename(struct inode *old_dir, struct dentry *old_dentry,
|
|||
static int exfat_rename(struct inode *old_dir, struct dentry *old_dentry,
|
||||
struct inode *new_dir, struct dentry *new_dentry)
|
||||
#endif
|
||||
#endif
|
||||
{
|
||||
struct inode *old_inode, *new_inode;
|
||||
struct super_block *sb = old_dir->i_sb;
|
||||
|
|
|
|||
37
super.c
37
super.c
|
|
@ -224,7 +224,9 @@ static void exfat_destroy_inode(struct inode *inode)
|
|||
{
|
||||
call_rcu(&inode->i_rcu, exfat_i_callback);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
|
||||
static int exfat_remount(struct super_block *sb, int *flags, char *data)
|
||||
{
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 0, 0)
|
||||
|
|
@ -244,6 +246,8 @@ static const struct super_operations exfat_sops = {
|
|||
.free_inode = exfat_free_inode,
|
||||
#else
|
||||
.destroy_inode = exfat_destroy_inode,
|
||||
#endif
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
|
||||
.remount_fs = exfat_remount,
|
||||
#endif
|
||||
.write_inode = exfat_write_inode,
|
||||
|
|
@ -627,8 +631,7 @@ static int exfat_calibrate_blocksize(struct super_block *sb, int logical_sect)
|
|||
{
|
||||
struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
||||
|
||||
if (!is_power_of_2(logical_sect) ||
|
||||
logical_sect < 512 || logical_sect > 4096) {
|
||||
if (!is_power_of_2(logical_sect)) {
|
||||
exfat_err(sb, "bogus logical sector size %u", logical_sect);
|
||||
return -EIO;
|
||||
}
|
||||
|
|
@ -697,6 +700,25 @@ static int exfat_read_boot_sector(struct super_block *sb)
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
/*
|
||||
* sect_size_bits could be at least 9 and at most 12.
|
||||
*/
|
||||
if (p_boot->sect_size_bits < EXFAT_MIN_SECT_SIZE_BITS ||
|
||||
p_boot->sect_size_bits > EXFAT_MAX_SECT_SIZE_BITS) {
|
||||
exfat_err(sb, "bogus sector size bits : %u\n",
|
||||
p_boot->sect_size_bits);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/*
|
||||
* sect_per_clus_bits could be at least 0 and at most 25 - sect_size_bits.
|
||||
*/
|
||||
if (p_boot->sect_per_clus_bits > EXFAT_MAX_SECT_PER_CLUS_BITS(p_boot)) {
|
||||
exfat_err(sb, "bogus sectors bits per cluster : %u\n",
|
||||
p_boot->sect_per_clus_bits);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
sbi->sect_per_clus = 1 << p_boot->sect_per_clus_bits;
|
||||
sbi->sect_per_clus_bits = p_boot->sect_per_clus_bits;
|
||||
sbi->cluster_size_bits = p_boot->sect_per_clus_bits +
|
||||
|
|
@ -723,16 +745,19 @@ static int exfat_read_boot_sector(struct super_block *sb)
|
|||
sbi->used_clusters = EXFAT_CLUSTERS_UNTRACKED;
|
||||
|
||||
/* check consistencies */
|
||||
if (sbi->num_FAT_sectors << p_boot->sect_size_bits <
|
||||
sbi->num_clusters * 4) {
|
||||
if ((u64)sbi->num_FAT_sectors << p_boot->sect_size_bits <
|
||||
(u64)sbi->num_clusters * 4) {
|
||||
exfat_err(sb, "bogus fat length");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (sbi->data_start_sector <
|
||||
sbi->FAT1_start_sector + sbi->num_FAT_sectors * p_boot->num_fats) {
|
||||
(u64)sbi->FAT1_start_sector +
|
||||
(u64)sbi->num_FAT_sectors * p_boot->num_fats) {
|
||||
exfat_err(sb, "bogus data start sector");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (sbi->vol_flags & VOLUME_DIRTY)
|
||||
exfat_warn(sb, "Volume was not properly unmounted. Some data may be corrupt. Please run fsck.");
|
||||
if (sbi->vol_flags & MEDIA_FAILURE)
|
||||
|
|
@ -877,6 +902,7 @@ static int exfat_fill_super(struct super_block *sb, void *data, int silent)
|
|||
return -ENOMEM;
|
||||
|
||||
mutex_init(&sbi->s_lock);
|
||||
mutex_init(&sbi->bitmap_lock);
|
||||
sb->s_fs_info = sbi;
|
||||
ratelimit_state_init(&sbi->ratelimit, DEFAULT_RATELIMIT_INTERVAL,
|
||||
DEFAULT_RATELIMIT_BURST);
|
||||
|
|
@ -1021,6 +1047,7 @@ static int exfat_init_fs_context(struct fs_context *fc)
|
|||
return -ENOMEM;
|
||||
|
||||
mutex_init(&sbi->s_lock);
|
||||
mutex_init(&sbi->bitmap_lock);
|
||||
ratelimit_state_init(&sbi->ratelimit, DEFAULT_RATELIMIT_INTERVAL,
|
||||
DEFAULT_RATELIMIT_BURST);
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue