Skip to contentSkip to conversation

exfat: optimize allocation bitmap loading time

PATCH Superseded Namjae Jeon 2 participants 5 messages Aug 1, 2025 – Aug 5, 2025

Subsystems (2)

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore

Namjae Jeon

author maintainer
#0 lore raw

PATCH 1/1 exfat: optimize allocation bitmap loading time

Loading the allocation bitmap is very slow if user set the small cluster size on large partition.

For optimizing it, This patch uses sb_breadahead() read the allocation bitmap. It will improve the mount time.

The following is the result of about 4TB partition(2KB cluster size) on my target.

without patch:
real 0m41.746s
user 0m0.011s
sys 0m0.000s

with patch:
real 0m2.525s
user 0m0.008s
sys 0m0.008s

---
 fs/exfat/balloc.c   | 12 +++++++++++-
 fs/exfat/dir.c      |  1 -
 fs/exfat/exfat_fs.h |  1 +
 3 files changed, 12 insertions(+), 2 deletions(-)
fs/exfat/balloc.c +11 -1
index cc01556c9d9b..c40b73701941 100644
@@ -30,9 +30,11 @@ static int exfat_allocate_bitmap(struct super_block *sb,
 		struct exfat_dentry *ep)
 {
 	struct exfat_sb_info *sbi = EXFAT_SB(sb);
+	struct blk_plug plug;
 	long long map_size;
-	unsigned int i, need_map_size;
+	unsigned int i, j, need_map_size;
 	sector_t sector;
+	unsigned int max_ra_count = EXFAT_MAX_RA_SIZE >> sb->s_blocksize_bits;
 
 	sbi->map_clu = le32_to_cpu(ep->dentry.bitmap.start_clu);
 	map_size = le64_to_cpu(ep->dentry.bitmap.size);
@@ -57,6 +59,14 @@ static int exfat_allocate_bitmap(struct super_block *sb,
 
 	sector = exfat_cluster_to_sector(sbi, sbi->map_clu);
 	for (i = 0; i < sbi->map_sectors; i++) {
+		/* Trigger the next readahead in advance. */
+		if (0 == (i % max_ra_count)) {
+			blk_start_plug(&plug);
+			for (j = i; j < min(max_ra_count, sbi->map_sectors - i) + i; j++)
+				sb_breadahead(sb, sector + j);
+			blk_finish_plug(&plug);
+		}
+
 		sbi->vol_amap[i] = sb_bread(sb, sector + i);
 		if (!sbi->vol_amap[i]) {
 			/* release all buffers and free vol_amap */
fs/exfat/dir.c +0 -1
index ee060e26f51d..e7a8550c0346 100644
@@ -616,7 +616,6 @@ static int exfat_find_location(struct super_block *sb, struct exfat_chain *p_dir
 	return 0;
 }
 
-#define EXFAT_MAX_RA_SIZE     (128*1024)
 static int exfat_dir_readahead(struct super_block *sb, sector_t sec)
 {
 	struct exfat_sb_info *sbi = EXFAT_SB(sb);
fs/exfat/exfat_fs.h +1 -0
index f8ead4d47ef0..d1792d5c9eed 100644
@@ -13,6 +13,7 @@
 #include <uapi/linux/exfat.h>
 
 #define EXFAT_ROOT_INO		1
+#define EXFAT_MAX_RA_SIZE     (128*1024)
 
 /*
  * exfat error flags
Signature · 1 line
2.25.1
#1 lore raw
Quoted 76 lines

Loading the allocation bitmap is very slow if user set the small cluster size on large partition.

For optimizing it, This patch uses sb_breadahead() read the allocation bitmap. It will improve the mount time.

The following is the result of about 4TB partition(2KB cluster size) on my target.

without patch:
real 0m41.746s
user 0m0.011s
sys 0m0.000s

with patch:
real 0m2.525s
user 0m0.008s
sys 0m0.008s

---
 fs/exfat/balloc.c   | 12 +++++++++++-
 fs/exfat/dir.c      |  1 -
 fs/exfat/exfat_fs.h |  1 +
 3 files changed, 12 insertions(+), 2 deletions(-)
fs/exfat/balloc.c +11 -1
index cc01556c9d9b..c40b73701941 100644
@@ -30,9 +30,11 @@ static int exfat_allocate_bitmap(struct super_block *sb,
                struct exfat_dentry *ep)
 {
        struct exfat_sb_info *sbi = EXFAT_SB(sb);
+       struct blk_plug plug;
        long long map_size;
-       unsigned int i, need_map_size;
+       unsigned int i, j, need_map_size;
        sector_t sector;
+       unsigned int max_ra_count = EXFAT_MAX_RA_SIZE >> sb->s_blocksize_bits;
 
        sbi->map_clu = le32_to_cpu(ep->dentry.bitmap.start_clu);
        map_size = le64_to_cpu(ep->dentry.bitmap.size);
@@ -57,6 +59,14 @@ static int exfat_allocate_bitmap(struct super_block *sb,
 
        sector = exfat_cluster_to_sector(sbi, sbi->map_clu);
        for (i = 0; i < sbi->map_sectors; i++) {
+               /* Trigger the next readahead in advance. */
+               if (0 == (i % max_ra_count)) {
+                       blk_start_plug(&plug);
+                       for (j = i; j < min(max_ra_count, sbi->map_sectors - i) + i; j++)
+                               sb_breadahead(sb, sector + j);
+                       blk_finish_plug(&plug);
+               }
+
                sbi->vol_amap[i] = sb_bread(sb, sector + i);
                if (!sbi->vol_amap[i]) {
                        /* release all buffers and free vol_amap */
fs/exfat/dir.c +0 -1
index ee060e26f51d..e7a8550c0346 100644
@@ -616,7 +616,6 @@ static int exfat_find_location(struct super_block *sb, struct exfat_chain *p_dir
        return 0;
 }
 
-#define EXFAT_MAX_RA_SIZE     (128*1024)
 static int exfat_dir_readahead(struct super_block *sb, sector_t sec)
 {
        struct exfat_sb_info *sbi = EXFAT_SB(sb);
fs/exfat/exfat_fs.h +0 -0
index f8ead4d47ef0..d1792d5c9eed 100644

fs/exfat/exfat_fs.h line 16

Quoted 4 lines
fs/exfat/exfat_fs.h +1 -0
@@ -13,6 +13,7 @@
 #include <uapi/linux/exfat.h>
 
 #define EXFAT_ROOT_INO         1
+#define EXFAT_MAX_RA_SIZE     (128*1024)

Why is the max readahead size 128KiB?
If the limit is changed to max_sectors_kb, so that a read request reads as much data as possible, will the performance be better?

author maintainer
#2 lore raw
Quoted 79 lines · On Fri, Aug 1, 2025 at 5:03 PM [email protected] <[email protected]>…
Quoted 79 lines

Loading the allocation bitmap is very slow if user set the small cluster size on large partition.

For optimizing it, This patch uses sb_breadahead() read the allocation bitmap. It will improve the mount time.

The following is the result of about 4TB partition(2KB cluster size) on my target.

without patch:
real 0m41.746s
user 0m0.011s
sys 0m0.000s

with patch:
real 0m2.525s
user 0m0.008s
sys 0m0.008s

---
 fs/exfat/balloc.c   | 12 +++++++++++-
 fs/exfat/dir.c      |  1 -
 fs/exfat/exfat_fs.h |  1 +
 3 files changed, 12 insertions(+), 2 deletions(-)
fs/exfat/balloc.c +11 -1
index cc01556c9d9b..c40b73701941 100644
@@ -30,9 +30,11 @@ static int exfat_allocate_bitmap(struct super_block *sb,
                struct exfat_dentry *ep)
 {
        struct exfat_sb_info *sbi = EXFAT_SB(sb);
+       struct blk_plug plug;
        long long map_size;
-       unsigned int i, need_map_size;
+       unsigned int i, j, need_map_size;
        sector_t sector;
+       unsigned int max_ra_count = EXFAT_MAX_RA_SIZE >> sb->s_blocksize_bits;
 
        sbi->map_clu = le32_to_cpu(ep->dentry.bitmap.start_clu);
        map_size = le64_to_cpu(ep->dentry.bitmap.size);
@@ -57,6 +59,14 @@ static int exfat_allocate_bitmap(struct super_block *sb,
 
        sector = exfat_cluster_to_sector(sbi, sbi->map_clu);
        for (i = 0; i < sbi->map_sectors; i++) {
+               /* Trigger the next readahead in advance. */
+               if (0 == (i % max_ra_count)) {
+                       blk_start_plug(&plug);
+                       for (j = i; j < min(max_ra_count, sbi->map_sectors - i) + i; j++)
+                               sb_breadahead(sb, sector + j);
+                       blk_finish_plug(&plug);
+               }
+
                sbi->vol_amap[i] = sb_bread(sb, sector + i);
                if (!sbi->vol_amap[i]) {
                        /* release all buffers and free vol_amap */
fs/exfat/dir.c +0 -1
index ee060e26f51d..e7a8550c0346 100644
@@ -616,7 +616,6 @@ static int exfat_find_location(struct super_block *sb, struct exfat_chain *p_dir
        return 0;
 }
 
-#define EXFAT_MAX_RA_SIZE     (128*1024)
 static int exfat_dir_readahead(struct super_block *sb, sector_t sec)
 {
        struct exfat_sb_info *sbi = EXFAT_SB(sb);
fs/exfat/exfat_fs.h +0 -0
index f8ead4d47ef0..d1792d5c9eed 100644
@@ -13,6 +13,7 @@
 #include <uapi/linux/exfat.h>
 
Quoted 6 lines

fs/exfat/exfat_fs.h line 16

Quoted 2 lines
fs/exfat/exfat_fs.h +1 -0
 #define EXFAT_ROOT_INO         1
+#define EXFAT_MAX_RA_SIZE     (128*1024)

Why is the max readahead size 128KiB?
If the limit is changed to max_sectors_kb, so that a read request reads as much data as possible, will the performance be better?

This sets an appropriate readahead size for exfat. It's already used elsewhere in exfat.
Getting ->max_sectors_kb from the block layer will result in a layer violation.

Thanks.

#3 lore raw
Quoted 87 lines
Quoted 79 lines · On Fri, Aug 1, 2025 at 5:03 PM [email protected] <[email protected]>…
Quoted 79 lines

Loading the allocation bitmap is very slow if user set the small cluster size on large partition.

For optimizing it, This patch uses sb_breadahead() read the allocation bitmap. It will improve the mount time.

The following is the result of about 4TB partition(2KB cluster size) on my target.

without patch:
real 0m41.746s
user 0m0.011s
sys 0m0.000s

with patch:
real 0m2.525s
user 0m0.008s
sys 0m0.008s

---
 fs/exfat/balloc.c   | 12 +++++++++++-
 fs/exfat/dir.c      |  1 -
 fs/exfat/exfat_fs.h |  1 +
 3 files changed, 12 insertions(+), 2 deletions(-)
fs/exfat/balloc.c +11 -1
index cc01556c9d9b..c40b73701941 100644
@@ -30,9 +30,11 @@ static int exfat_allocate_bitmap(struct super_block *sb,
                struct exfat_dentry *ep)
 {
        struct exfat_sb_info *sbi = EXFAT_SB(sb);
+       struct blk_plug plug;
        long long map_size;
-       unsigned int i, need_map_size;
+       unsigned int i, j, need_map_size;
        sector_t sector;
+       unsigned int max_ra_count = EXFAT_MAX_RA_SIZE >> sb->s_blocksize_bits;
 
        sbi->map_clu = le32_to_cpu(ep->dentry.bitmap.start_clu);
        map_size = le64_to_cpu(ep->dentry.bitmap.size);
@@ -57,6 +59,14 @@ static int exfat_allocate_bitmap(struct super_block *sb,
 
        sector = exfat_cluster_to_sector(sbi, sbi->map_clu);
        for (i = 0; i < sbi->map_sectors; i++) {
+               /* Trigger the next readahead in advance. */
+               if (0 == (i % max_ra_count)) {
+                       blk_start_plug(&plug);
+                       for (j = i; j < min(max_ra_count, sbi->map_sectors - i) + i; j++)
+                               sb_breadahead(sb, sector + j);
+                       blk_finish_plug(&plug);
+               }
+
                sbi->vol_amap[i] = sb_bread(sb, sector + i);
                if (!sbi->vol_amap[i]) {
                        /* release all buffers and free vol_amap */
fs/exfat/dir.c +0 -1
index ee060e26f51d..e7a8550c0346 100644
@@ -616,7 +616,6 @@ static int exfat_find_location(struct super_block *sb, struct exfat_chain *p_dir
        return 0;
 }
 
-#define EXFAT_MAX_RA_SIZE     (128*1024)
 static int exfat_dir_readahead(struct super_block *sb, sector_t sec)
 {
        struct exfat_sb_info *sbi = EXFAT_SB(sb);
fs/exfat/exfat_fs.h +0 -0
index f8ead4d47ef0..d1792d5c9eed 100644
@@ -13,6 +13,7 @@
 #include <uapi/linux/exfat.h>
 
Quoted 6 lines

fs/exfat/exfat_fs.h line 16

Quoted 2 lines
fs/exfat/exfat_fs.h +1 -0
 #define EXFAT_ROOT_INO         1
+#define EXFAT_MAX_RA_SIZE     (128*1024)

Why is the max readahead size 128KiB?
If the limit is changed to max_sectors_kb, so that a read request reads as much data as possible, will the performance be better?

Quoted 3 lines

This sets an appropriate readahead size for exfat. It's already used elsewhere in exfat.
Getting ->max_sectors_kb from the block layer will result in a layer violation.

I checked the code of read ahead, EXFAT_MAX_RA_SIZE is consistent with the default value(VM_READAHEAD_PAGES) of sb->s_bdi->ra_pages.

Is it better to use sb->s_bdi->ra_pages instead?
If so, users can set different values via 'blockdev --setra'.

author maintainer
#4 lore raw
Quoted 92 lines · On Mon, Aug 4, 2025 at 5:57 PM [email protected] <[email protected]>…
Quoted 88 lines
Quoted 79 lines · On Fri, Aug 1, 2025 at 5:03 PM [email protected] <[email protected]>…
Quoted 79 lines

Loading the allocation bitmap is very slow if user set the small cluster size on large partition.

For optimizing it, This patch uses sb_breadahead() read the allocation bitmap. It will improve the mount time.

The following is the result of about 4TB partition(2KB cluster size) on my target.

without patch:
real 0m41.746s
user 0m0.011s
sys 0m0.000s

with patch:
real 0m2.525s
user 0m0.008s
sys 0m0.008s

---
 fs/exfat/balloc.c   | 12 +++++++++++-
 fs/exfat/dir.c      |  1 -
 fs/exfat/exfat_fs.h |  1 +
 3 files changed, 12 insertions(+), 2 deletions(-)
fs/exfat/balloc.c +11 -1
index cc01556c9d9b..c40b73701941 100644
@@ -30,9 +30,11 @@ static int exfat_allocate_bitmap(struct super_block *sb,
                struct exfat_dentry *ep)
 {
        struct exfat_sb_info *sbi = EXFAT_SB(sb);
+       struct blk_plug plug;
        long long map_size;
-       unsigned int i, need_map_size;
+       unsigned int i, j, need_map_size;
        sector_t sector;
+       unsigned int max_ra_count = EXFAT_MAX_RA_SIZE >> sb->s_blocksize_bits;
 
        sbi->map_clu = le32_to_cpu(ep->dentry.bitmap.start_clu);
        map_size = le64_to_cpu(ep->dentry.bitmap.size);
@@ -57,6 +59,14 @@ static int exfat_allocate_bitmap(struct super_block *sb,
 
        sector = exfat_cluster_to_sector(sbi, sbi->map_clu);
        for (i = 0; i < sbi->map_sectors; i++) {
+               /* Trigger the next readahead in advance. */
+               if (0 == (i % max_ra_count)) {
+                       blk_start_plug(&plug);
+                       for (j = i; j < min(max_ra_count, sbi->map_sectors - i) + i; j++)
+                               sb_breadahead(sb, sector + j);
+                       blk_finish_plug(&plug);
+               }
+
                sbi->vol_amap[i] = sb_bread(sb, sector + i);
                if (!sbi->vol_amap[i]) {
                        /* release all buffers and free vol_amap */
fs/exfat/dir.c +0 -1
index ee060e26f51d..e7a8550c0346 100644
@@ -616,7 +616,6 @@ static int exfat_find_location(struct super_block *sb, struct exfat_chain *p_dir
        return 0;
 }
 
-#define EXFAT_MAX_RA_SIZE     (128*1024)
 static int exfat_dir_readahead(struct super_block *sb, sector_t sec)
 {
        struct exfat_sb_info *sbi = EXFAT_SB(sb);
fs/exfat/exfat_fs.h +0 -0
index f8ead4d47ef0..d1792d5c9eed 100644
@@ -13,6 +13,7 @@
 #include <uapi/linux/exfat.h>
 
Quoted 6 lines

fs/exfat/exfat_fs.h line 16

Quoted 2 lines
fs/exfat/exfat_fs.h +1 -0
 #define EXFAT_ROOT_INO         1
+#define EXFAT_MAX_RA_SIZE     (128*1024)

Why is the max readahead size 128KiB?
If the limit is changed to max_sectors_kb, so that a read request reads as much data as possible, will the performance be better?

Quoted 3 lines

This sets an appropriate readahead size for exfat. It's already used elsewhere in exfat.
Getting ->max_sectors_kb from the block layer will result in a layer violation.

Quoted 5 lines

I checked the code of read ahead, EXFAT_MAX_RA_SIZE is consistent with the default value(VM_READAHEAD_PAGES) of sb->s_bdi->ra_pages.

Is it better to use sb->s_bdi->ra_pages instead?
If so, users can set different values via 'blockdev --setra'.

I will change max_ra_count as follows:
max_ra_count = min(sb->s_bdi->ra_pages, sb->s_bdi->io_pages)

                << (PAGE_SHIFT - sb->s_blocksize_bits);

Thanks.