lkml.org 
[lkml]   [2020]   [Jun]   [1]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    From
    SubjectRE: [PATCH] exfat: optimize dir-cache
    Date
    > Optimize directory access based on exfat_entry_set_cache.
    > - Hold bh instead of copied d-entry.
    > - Modify bh->data directly instead of the copied d-entry.
    > - Write back the retained bh instead of rescanning the d-entry-set.
    > And
    > - Remove unused cache related definitions.
    >
    > Signed-off-by: Tetsuhiro Kohada
    > <kohada.tetsuhiro@dc.mitsubishielectric.co.jp>

    Reviewed-by: Sungjong Seo <sj1557.seo@samsung.com>

    > ---
    > fs/exfat/dir.c | 197 +++++++++++++++++---------------------------
    > fs/exfat/exfat_fs.h | 27 +++---
    > fs/exfat/file.c | 15 ++--
    > fs/exfat/inode.c | 53 +++++-------
    > fs/exfat/namei.c | 14 ++--
    > 5 files changed, 124 insertions(+), 182 deletions(-)
    >
    > diff --git a/fs/exfat/dir.c b/fs/exfat/dir.c index
    > b5a237c33d50..2902d285bf20 100644
    > --- a/fs/exfat/dir.c
    > +++ b/fs/exfat/dir.c
    > @@ -32,35 +32,30 @@ static void exfat_get_uniname_from_ext_entry(struct
    > super_block *sb,
    > struct exfat_chain *p_dir, int entry, unsigned short
    > *uniname) {
    > int i;
    > - struct exfat_dentry *ep;
    > struct exfat_entry_set_cache *es;
    >
    > - es = exfat_get_dentry_set(sb, p_dir, entry, ES_ALL_ENTRIES, &ep);
    > + es = exfat_get_dentry_set(sb, p_dir, entry, ES_ALL_ENTRIES);
    > if (!es)
    > return;
    >
    > - if (es->num_entries < 3)
    > - goto free_es;
    > -
    > - ep += 2;
    > -
    > /*
    > * First entry : file entry
    > * Second entry : stream-extension entry
    > * Third entry : first file-name entry
    > * So, the index of first file-name dentry should start from 2.
    > */
    > - for (i = 2; i < es->num_entries; i++, ep++) {
    > + for (i = 2; i < es->num_entries; i++) {
    > + struct exfat_dentry *ep = exfat_get_dentry_cached(es, i);
    > +
    > /* end of name entry */
    > if (exfat_get_entry_type(ep) != TYPE_EXTEND)
    > - goto free_es;
    > + break;
    >
    > exfat_extract_uni_name(ep, uniname);
    > uniname += EXFAT_FILE_NAME_LEN;
    > }
    >
    > -free_es:
    > - kfree(es);
    > + exfat_free_dentry_set(es, false);
    > }
    >
    > /* read a directory entry from the opened directory */ @@ -590,62 +585,33
    > @@ int exfat_remove_entries(struct inode *inode, struct exfat_chain
    *p_dir,
    > return 0;
    > }
    >
    > -int exfat_update_dir_chksum_with_entry_set(struct super_block *sb,
    > - struct exfat_entry_set_cache *es, int sync)
    > +void exfat_update_dir_chksum_with_entry_set(struct
    > +exfat_entry_set_cache *es)
    > {
    > - struct exfat_sb_info *sbi = EXFAT_SB(sb);
    > - struct buffer_head *bh;
    > - sector_t sec = es->sector;
    > - unsigned int off = es->offset;
    > - int chksum_type = CS_DIR_ENTRY, i, num_entries = es->num_entries;
    > - unsigned int buf_off = (off - es->offset);
    > - unsigned int remaining_byte_in_sector, copy_entries, clu;
    > + int chksum_type = CS_DIR_ENTRY, i;
    > unsigned short chksum = 0;
    > + struct exfat_dentry *ep;
    >
    > - for (i = 0; i < num_entries; i++) {
    > - chksum = exfat_calc_chksum_2byte(&es->entries[i],
    > DENTRY_SIZE,
    > - chksum, chksum_type);
    > + for (i = 0; i < es->num_entries; i++) {
    > + ep = exfat_get_dentry_cached(es, i);
    > + chksum = exfat_calc_chksum_2byte(ep, DENTRY_SIZE, chksum,
    > + chksum_type);
    > chksum_type = CS_DEFAULT;
    > }
    > + ep = exfat_get_dentry_cached(es, 0);
    > + ep->dentry.file.checksum = cpu_to_le16(chksum);
    > + es->modified = true;
    > +}
    >
    > - es->entries[0].dentry.file.checksum = cpu_to_le16(chksum);
    > +void exfat_free_dentry_set(struct exfat_entry_set_cache *es, int sync)
    > +{
    > + int i;
    >
    > - while (num_entries) {
    > - /* write per sector base */
    > - remaining_byte_in_sector = (1 << sb->s_blocksize_bits) -
    off;
    > - copy_entries = min_t(int,
    > - EXFAT_B_TO_DEN(remaining_byte_in_sector),
    > - num_entries);
    > - bh = sb_bread(sb, sec);
    > - if (!bh)
    > - goto err_out;
    > - memcpy(bh->b_data + off,
    > - (unsigned char *)&es->entries[0] + buf_off,
    > - EXFAT_DEN_TO_B(copy_entries));
    > - exfat_update_bh(sb, bh, sync);
    > - brelse(bh);
    > - num_entries -= copy_entries;
    > -
    > - if (num_entries) {
    > - /* get next sector */
    > - if (exfat_is_last_sector_in_cluster(sbi, sec)) {
    > - clu = exfat_sector_to_cluster(sbi, sec);
    > - if (es->alloc_flag == ALLOC_NO_FAT_CHAIN)
    > - clu++;
    > - else if (exfat_get_next_cluster(sb, &clu))
    > - goto err_out;
    > - sec = exfat_cluster_to_sector(sbi, clu);
    > - } else {
    > - sec++;
    > - }
    > - off = 0;
    > - buf_off += EXFAT_DEN_TO_B(copy_entries);
    > - }
    > + for (i = 0; i < es->num_bh; i++) {
    > + if (es->modified)
    > + exfat_update_bh(es->sb, es->bh[i], sync);
    > + brelse(es->bh[i]);
    > }
    > -
    > - return 0;
    > -err_out:
    > - return -EIO;
    > + kfree(es);
    > }
    >
    > static int exfat_walk_fat_chain(struct super_block *sb, @@ -820,34
    > +786,40 @@ static bool exfat_validate_entry(unsigned int type,
    > }
    > }
    >
    > +struct exfat_dentry *exfat_get_dentry_cached(
    > + struct exfat_entry_set_cache *es, int num) {
    > + int off = es->start_off + num * DENTRY_SIZE;
    > + struct buffer_head *bh = es->bh[EXFAT_B_TO_BLK(off, es->sb)];
    > + char *p = bh->b_data + EXFAT_BLK_OFFSET(off, es->sb);
    > +
    > + return (struct exfat_dentry *)p;
    > +}
    > +
    > /*
    > * Returns a set of dentries for a file or dir.
    > *
    > - * Note that this is a copy (dump) of dentries so that user should
    > - * call write_entry_set() to apply changes made in this entry set
    > - * to the real device.
    > + * Note It provides a direct pointer to bh->data via
    > exfat_get_dentry_cached().
    > + * User should call exfat_get_dentry_set() after setting 'modified' to
    > + apply
    > + * changes made in this entry set to the real device.
    > *
    > * in:
    > * sb+p_dir+entry: indicates a file/dir
    > * type: specifies how many dentries should be included.
    > - * out:
    > - * file_ep: will point the first dentry(= file dentry) on success
    > * return:
    > * pointer of entry set on success,
    > * NULL on failure.
    > */
    > struct exfat_entry_set_cache *exfat_get_dentry_set(struct super_block
    *sb,
    > - struct exfat_chain *p_dir, int entry, unsigned int type,
    > - struct exfat_dentry **file_ep)
    > + struct exfat_chain *p_dir, int entry, unsigned int type)
    > {
    > - int ret;
    > + int ret, i, num_bh;
    > unsigned int off, byte_offset, clu = 0;
    > - unsigned int entry_type;
    > sector_t sec;
    > struct exfat_sb_info *sbi = EXFAT_SB(sb);
    > struct exfat_entry_set_cache *es;
    > - struct exfat_dentry *ep, *pos;
    > - unsigned char num_entries;
    > + struct exfat_dentry *ep;
    > + int num_entries;
    > enum exfat_validate_dentry_mode mode = ES_MODE_STARTED;
    > struct buffer_head *bh;
    >
    > @@ -861,11 +833,18 @@ struct exfat_entry_set_cache
    > *exfat_get_dentry_set(struct super_block *sb,
    > if (ret)
    > return NULL;
    >
    > + es = kzalloc(sizeof(*es), GFP_KERNEL);
    > + if (!es)
    > + return NULL;
    > + es->sb = sb;
    > + es->modified = false;
    > +
    > /* byte offset in cluster */
    > byte_offset = EXFAT_CLU_OFFSET(byte_offset, sbi);
    >
    > /* byte offset in sector */
    > off = EXFAT_BLK_OFFSET(byte_offset, sb);
    > + es->start_off = off;
    >
    > /* sector offset in cluster */
    > sec = EXFAT_B_TO_BLK(byte_offset, sb); @@ -873,72 +852,46 @@ struct
    > exfat_entry_set_cache *exfat_get_dentry_set(struct super_block *sb,
    >
    > bh = sb_bread(sb, sec);
    > if (!bh)
    > - return NULL;
    > -
    > - ep = (struct exfat_dentry *)(bh->b_data + off);
    > - entry_type = exfat_get_entry_type(ep);
    > + goto free_es;
    > + es->bh[es->num_bh++] = bh;
    >
    > - if (entry_type != TYPE_FILE && entry_type != TYPE_DIR)
    > - goto release_bh;
    > + ep = exfat_get_dentry_cached(es, 0);
    > + if (!exfat_validate_entry(exfat_get_entry_type(ep), &mode))
    > + goto free_es;
    >
    > num_entries = type == ES_ALL_ENTRIES ?
    > ep->dentry.file.num_ext + 1 : type;
    > - es = kmalloc(struct_size(es, entries, num_entries), GFP_KERNEL);
    > - if (!es)
    > - goto release_bh;
    > -
    > es->num_entries = num_entries;
    > - es->sector = sec;
    > - es->offset = off;
    > - es->alloc_flag = p_dir->flags;
    > -
    > - pos = &es->entries[0];
    > -
    > - while (num_entries) {
    > - if (!exfat_validate_entry(exfat_get_entry_type(ep), &mode))
    > - goto free_es;
    >
    > - /* copy dentry */
    > - memcpy(pos, ep, sizeof(struct exfat_dentry));
    > -
    > - if (--num_entries == 0)
    > - break;
    > -
    > - if (((off + DENTRY_SIZE) & (sb->s_blocksize - 1)) <
    > - (off & (sb->s_blocksize - 1))) {
    > - /* get the next sector */
    > - if (exfat_is_last_sector_in_cluster(sbi, sec)) {
    > - if (es->alloc_flag == ALLOC_NO_FAT_CHAIN)
    > - clu++;
    > - else if (exfat_get_next_cluster(sb, &clu))
    > - goto free_es;
    > - sec = exfat_cluster_to_sector(sbi, clu);
    > - } else {
    > - sec++;
    > - }
    > -
    > - brelse(bh);
    > - bh = sb_bread(sb, sec);
    > - if (!bh)
    > + num_bh = EXFAT_B_TO_BLK_ROUND_UP(off + num_entries * DENTRY_SIZE,
    > sb);
    > + for (i = 1; i < num_bh; i++) {
    > + /* get the next sector */
    > + if (exfat_is_last_sector_in_cluster(sbi, sec)) {
    > + if (p_dir->flags == ALLOC_NO_FAT_CHAIN)
    > + clu++;
    > + else if (exfat_get_next_cluster(sb, &clu))
    > goto free_es;
    > - off = 0;
    > - ep = (struct exfat_dentry *)bh->b_data;
    > + sec = exfat_cluster_to_sector(sbi, clu);
    > } else {
    > - ep++;
    > - off += DENTRY_SIZE;
    > + sec++;
    > }
    > - pos++;
    > +
    > + bh = sb_bread(sb, sec);
    > + if (!bh)
    > + goto free_es;
    > + es->bh[es->num_bh++] = bh;
    > }
    >
    > - if (file_ep)
    > - *file_ep = &es->entries[0];
    > - brelse(bh);
    > + /* validiate cached dentries */
    > + for (i = 1; i < num_entries; i++) {
    > + ep = exfat_get_dentry_cached(es, i);
    > + if (!exfat_validate_entry(exfat_get_entry_type(ep), &mode))
    > + goto free_es;
    > + }
    > return es;
    >
    > free_es:
    > - kfree(es);
    > -release_bh:
    > - brelse(bh);
    > + exfat_free_dentry_set(es, false);
    > return NULL;
    > }
    >
    > diff --git a/fs/exfat/exfat_fs.h b/fs/exfat/exfat_fs.h index
    > 294aa7792bc3..5caad1380818 100644
    > --- a/fs/exfat/exfat_fs.h
    > +++ b/fs/exfat/exfat_fs.h
    > @@ -71,10 +71,8 @@ enum {
    > #define MAX_NAME_LENGTH 255 /* max len of file name
    excluding
    > NULL */
    > #define MAX_VFSNAME_BUF_SIZE ((MAX_NAME_LENGTH + 1) *
    > MAX_CHARSET_SIZE)
    >
    > -#define FAT_CACHE_SIZE 128
    > -#define FAT_CACHE_HASH_SIZE 64
    > -#define BUF_CACHE_SIZE 256
    > -#define BUF_CACHE_HASH_SIZE 64
    > +/* Enough size to hold 256 dentry (even 512 Byte sector) */
    > +#define DIR_CACHE_SIZE (256*sizeof(struct
    exfat_dentry)/512+1)
    >
    > #define EXFAT_HINT_NONE -1
    > #define EXFAT_MIN_SUBDIR 2
    > @@ -170,14 +168,12 @@ struct exfat_hint { };
    >
    > struct exfat_entry_set_cache {
    > - /* sector number that contains file_entry */
    > - sector_t sector;
    > - /* byte offset in the sector */
    > - unsigned int offset;
    > - /* flag in stream entry. 01 for cluster chain, 03 for contig. */
    > - int alloc_flag;
    > + struct super_block *sb;
    > + bool modified;
    > + unsigned int start_off;
    > + int num_bh;
    > + struct buffer_head *bh[DIR_CACHE_SIZE];
    > unsigned int num_entries;
    > - struct exfat_dentry entries[];
    > };
    >
    > struct exfat_dir_entry {
    > @@ -451,8 +447,7 @@ int exfat_remove_entries(struct inode *inode, struct
    > exfat_chain *p_dir,
    > int entry, int order, int num_entries); int
    > exfat_update_dir_chksum(struct inode *inode, struct exfat_chain *p_dir,
    > int entry);
    > -int exfat_update_dir_chksum_with_entry_set(struct super_block *sb,
    > - struct exfat_entry_set_cache *es, int sync);
    > +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,
    > @@ -463,9 +458,11 @@ int exfat_find_location(struct super_block *sb,
    > struct exfat_chain *p_dir, struct exfat_dentry *exfat_get_dentry(struct
    > super_block *sb,
    > struct exfat_chain *p_dir, int entry, struct buffer_head
    > **bh,
    > sector_t *sector);
    > +struct exfat_dentry *exfat_get_dentry_cached(
    > + struct exfat_entry_set_cache *es, int num);
    > struct exfat_entry_set_cache *exfat_get_dentry_set(struct super_block
    *sb,
    > - struct exfat_chain *p_dir, int entry, unsigned int type,
    > - struct exfat_dentry **file_ep);
    > + struct exfat_chain *p_dir, int entry, unsigned int type);
    > void
    > +exfat_free_dentry_set(struct exfat_entry_set_cache *es, int sync);
    > int exfat_count_dir_entries(struct super_block *sb, struct exfat_chain
    > *p_dir);
    >
    > /* inode.c */
    > diff --git a/fs/exfat/file.c b/fs/exfat/file.c index
    > 84f3d31a3a55..8e3f0eef45d7 100644
    > --- a/fs/exfat/file.c
    > +++ b/fs/exfat/file.c
    > @@ -96,11 +96,9 @@ int __exfat_truncate(struct inode *inode, loff_t
    > new_size)
    > unsigned int num_clusters_new, num_clusters_phys;
    > unsigned int last_clu = EXFAT_FREE_CLUSTER;
    > struct exfat_chain clu;
    > - struct exfat_dentry *ep, *ep2;
    > struct super_block *sb = inode->i_sb;
    > struct exfat_sb_info *sbi = EXFAT_SB(sb);
    > struct exfat_inode_info *ei = EXFAT_I(inode);
    > - struct exfat_entry_set_cache *es = NULL;
    > int evict = (ei->dir.dir == DIR_DELETED) ? 1 : 0;
    >
    > /* check if the given file ID is opened */ @@ -153,12 +151,15 @@
    > int __exfat_truncate(struct inode *inode, loff_t new_size)
    > /* update the directory entry */
    > if (!evict) {
    > struct timespec64 ts;
    > + struct exfat_dentry *ep, *ep2;
    > + struct exfat_entry_set_cache *es;
    >
    > es = exfat_get_dentry_set(sb, &(ei->dir), ei->entry,
    > - ES_ALL_ENTRIES, &ep);
    > + ES_ALL_ENTRIES);
    > if (!es)
    > return -EIO;
    > - ep2 = ep + 1;
    > + ep = exfat_get_dentry_cached(es, 0);
    > + ep2 = exfat_get_dentry_cached(es, 1);
    >
    > ts = current_time(inode);
    > exfat_set_entry_time(sbi, &ts,
    > @@ -185,10 +186,8 @@ int __exfat_truncate(struct inode *inode, loff_t
    > new_size)
    > ep2->dentry.stream.start_clu = EXFAT_FREE_CLUSTER;
    > }
    >
    > - if (exfat_update_dir_chksum_with_entry_set(sb, es,
    > - inode_needs_sync(inode)))
    > - return -EIO;
    > - kfree(es);
    > + exfat_update_dir_chksum_with_entry_set(es);
    > + exfat_free_dentry_set(es, inode_needs_sync(inode));
    > }
    >
    > /* cut off from the FAT chain */
    > diff --git a/fs/exfat/inode.c b/fs/exfat/inode.c index
    > 3f367d081cd6..ef7cf7a6d187 100644
    > --- a/fs/exfat/inode.c
    > +++ b/fs/exfat/inode.c
    > @@ -19,7 +19,6 @@
    >
    > static int __exfat_write_inode(struct inode *inode, int sync) {
    > - int ret = -EIO;
    > unsigned long long on_disk_size;
    > struct exfat_dentry *ep, *ep2;
    > struct exfat_entry_set_cache *es = NULL; @@ -43,11 +42,11 @@ static
    > int __exfat_write_inode(struct inode *inode, int sync)
    > exfat_set_vol_flags(sb, VOL_DIRTY);
    >
    > /* get the directory entry of given file or directory */
    > - es = exfat_get_dentry_set(sb, &(ei->dir), ei->entry, ES_ALL_ENTRIES,
    > - &ep);
    > + es = exfat_get_dentry_set(sb, &(ei->dir), ei->entry,
    > ES_ALL_ENTRIES);
    > if (!es)
    > return -EIO;
    > - ep2 = ep + 1;
    > + ep = exfat_get_dentry_cached(es, 0);
    > + ep2 = exfat_get_dentry_cached(es, 1);
    >
    > ep->dentry.file.attr = cpu_to_le16(exfat_make_attr(inode));
    >
    > @@ -77,9 +76,9 @@ static int __exfat_write_inode(struct inode *inode, int
    > sync)
    > ep2->dentry.stream.valid_size = cpu_to_le64(on_disk_size);
    > ep2->dentry.stream.size = ep2->dentry.stream.valid_size;
    >
    > - ret = exfat_update_dir_chksum_with_entry_set(sb, es, sync);
    > - kfree(es);
    > - return ret;
    > + exfat_update_dir_chksum_with_entry_set(es);
    > + exfat_free_dentry_set(es, sync);
    > + return 0;
    > }
    >
    > int exfat_write_inode(struct inode *inode, struct writeback_control *wbc)
    > @@ -110,8 +109,6 @@ static int exfat_map_cluster(struct inode *inode,
    > unsigned int clu_offset,
    > int ret, modified = false;
    > unsigned int last_clu;
    > struct exfat_chain new_clu;
    > - struct exfat_dentry *ep;
    > - struct exfat_entry_set_cache *es = NULL;
    > struct super_block *sb = inode->i_sb;
    > struct exfat_sb_info *sbi = EXFAT_SB(sb);
    > struct exfat_inode_info *ei = EXFAT_I(inode); @@ -222,34 +219,28 @@
    > static int exfat_map_cluster(struct inode *inode, unsigned int clu_offset,
    > num_clusters += num_to_be_allocated;
    > *clu = new_clu.dir;
    >
    > - if (ei->dir.dir != DIR_DELETED) {
    > + if (ei->dir.dir != DIR_DELETED && modified) {
    > + struct exfat_dentry *ep;
    > + struct exfat_entry_set_cache *es;
    > +
    > es = exfat_get_dentry_set(sb, &(ei->dir), ei->entry,
    > - ES_ALL_ENTRIES, &ep);
    > + ES_ALL_ENTRIES);
    > if (!es)
    > return -EIO;
    > /* get stream entry */
    > - ep++;
    > + ep = exfat_get_dentry_cached(es, 1);
    >
    > /* update directory entry */
    > - if (modified) {
    > - if (ep->dentry.stream.flags != ei->flags)
    > - ep->dentry.stream.flags = ei->flags;
    > -
    > - if (le32_to_cpu(ep->dentry.stream.start_clu)
    !=
    > - ei->start_clu)
    > - ep->dentry.stream.start_clu =
    > - cpu_to_le32(ei->start_clu);
    > -
    > - ep->dentry.stream.valid_size =
    > - cpu_to_le64(i_size_read(inode));
    > - ep->dentry.stream.size =
    > - ep->dentry.stream.valid_size;
    > - }
    > -
    > - if (exfat_update_dir_chksum_with_entry_set(sb, es,
    > - inode_needs_sync(inode)))
    > - return -EIO;
    > - kfree(es);
    > + ep->dentry.stream.flags = ei->flags;
    > + ep->dentry.stream.start_clu =
    > + cpu_to_le32(ei->start_clu);
    > + ep->dentry.stream.valid_size =
    > + cpu_to_le64(i_size_read(inode));
    > + ep->dentry.stream.size =
    > + ep->dentry.stream.valid_size;
    > +
    > + exfat_update_dir_chksum_with_entry_set(es);
    > + exfat_free_dentry_set(es, inode_needs_sync(inode));
    >
    > } /* end of if != DIR_DELETED */
    >
    > diff --git a/fs/exfat/namei.c b/fs/exfat/namei.c index
    > 48f4df883f3b..5b0f35329d63 100644
    > --- a/fs/exfat/namei.c
    > +++ b/fs/exfat/namei.c
    > @@ -600,8 +600,6 @@ static int exfat_find(struct inode *dir, struct qstr
    > *qname,
    > int ret, dentry, num_entries, count;
    > struct exfat_chain cdir;
    > struct exfat_uni_name uni_name;
    > - struct exfat_dentry *ep, *ep2;
    > - struct exfat_entry_set_cache *es = NULL;
    > struct super_block *sb = dir->i_sb;
    > struct exfat_sb_info *sbi = EXFAT_SB(sb);
    > struct exfat_inode_info *ei = EXFAT_I(dir); @@ -660,10 +658,14 @@
    > static int exfat_find(struct inode *dir, struct qstr *qname,
    >
    > info->num_subdirs = count;
    > } else {
    > - es = exfat_get_dentry_set(sb, &cdir, dentry, ES_2_ENTRIES,
    > &ep);
    > + struct exfat_dentry *ep, *ep2;
    > + struct exfat_entry_set_cache *es;
    > +
    > + es = exfat_get_dentry_set(sb, &cdir, dentry, ES_2_ENTRIES);
    > if (!es)
    > return -EIO;
    > - ep2 = ep + 1;
    > + ep = exfat_get_dentry_cached(es, 0);
    > + ep2 = exfat_get_dentry_cached(es, 1);
    >
    > info->type = exfat_get_entry_type(ep);
    > info->attr = le16_to_cpu(ep->dentry.file.attr);
    > @@ -681,7 +683,7 @@ static int exfat_find(struct inode *dir, struct qstr
    > *qname,
    > exfat_fs_error(sb,
    > "non-zero size file starts with zero cluster
    > (size : %llu, p_dir : %u, entry : 0x%08x)",
    > i_size_read(dir), ei->dir.dir, ei->entry);
    > - kfree(es);
    > + exfat_free_dentry_set(es, false);
    > return -EIO;
    > }
    >
    > @@ -700,7 +702,7 @@ static int exfat_find(struct inode *dir, struct qstr
    > *qname,
    > ep->dentry.file.access_time,
    > ep->dentry.file.access_date,
    > 0);
    > - kfree(es);
    > + exfat_free_dentry_set(es, false);
    >
    > if (info->type == TYPE_DIR) {
    > exfat_chain_set(&cdir, info->start_clu,
    > --
    > 2.25.0


    \
     
     \ /
      Last update: 2020-06-01 14:09    [W:5.966 / U:0.488 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site