RE: [PATCH] exfat: optimize dir-cache

Sungjong Seo
2020-06-01T12:08:55Z

> 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