ext4: fix free clusters calculation in bigalloc filesystem
PATCH 1/1 ext4: fix free clusters calculation in bigalloc filesystem
ext4_has_free_clusters() should tell us whether there is enough free clusters to allocate, however number of free clusters in the file system is converted to blocks using EXT4_C2B() which is not only wrong use of the macro (we should have used EXT4_NUM_B2C) but it's also completely wrong concept since everything else is in cluster units.
Moreover when calculating number of root clusters we should be using macro EXT4_NUM_B2C() instead of EXT4_C2B() otherwise the result will usually be off by one.
As a result number of free clusters is much bigger than it should have been and ext4_has_free_clusters() would return 1 even if there is really not enough free clusters available.
Fix this by removing the EXT4_C2B() conversion of free clusters and using EXT4_NUM_B2C() when calculating number of root clusters. This bug affects number of xfstests tests covering file system ENOSPC situation handling. With this patch most of the ENOSPC problems with bigalloc file system disappear, especially the errors caused by delayed allocation not having enough space when the actual allocation is finally requested.
--- fs/ext4/balloc.c | 4 ++-- 1 files changed, 2 insertions(+), 2 deletions(-)
fs/ext4/balloc.c +2 -2
@@ -482,11 +482,11 @@ static int ext4_has_free_clusters(struct ext4_sb_info *sbi, free_clusters =percpu_counter_read_positive (fcc); dirty_clusters =percpu_counter_read_positive (dcc); - root_clusters =EXT4_B2C (sbi,ext4_r_blocks_count (sbi->s_es)); + root_clusters =EXT4_NUM_B2C (sbi,ext4_r_blocks_count (sbi->s_es));if (free_clusters - (nclusters + root_clusters + dirty_clusters) <EXT4_FREECLUSTERS_WATERMARK ) { - free_clusters =EXT4_C2B (sbi,percpu_counter_sum_positive (fcc)); + free_clusters =percpu_counter_sum_positive (fcc); dirty_clusters =percpu_counter_sum_positive (dcc); }/* Check whether we have space after accounting for current
Signature · 1 line
1.7.7.6
PATCH 1/1 ext4: fix overhead calculation in bigalloc filesystem (Re: ... )
Quoted 14 lines · Lukas Czerner
ext4_has_free_clusters()should tell us whether there is enough free clusters to allocate, however number of free clusters in the file system is converted to blocks usingEXT4_C2B()which is not only wrong use of the macro (we should have usedEXT4_NUM_B2C) but it's also completely wrong concept since everything else is in cluster units.Moreover when calculating number of root clusters we should be using macro
EXT4_NUM_B2C()instead ofEXT4_C2B()otherwise the result will usually be off by one.As a result number of free clusters is much bigger than it should have been and
ext4_has_free_clusters()would return 1 even if there is really not enough free clusters available.
Quoted 8 lines
Fix this by removing the
EXT4_C2B()conversion of free clusters and usingEXT4_NUM_B2C()when calculating number of root clusters. This bug affects number of xfstests tests covering file system ENOSPC situation handling. With this patch most of the ENOSPC problems with bigalloc file system disappear, especially the errors caused by delayed allocation not having enough space when the actual allocation is finally requested.Signed-off-by Lukas Czerner <[email protected]>
Great! Thanks for fixing it. After applied this patch, xfstests #15 with bigalloc and delalloc won't cause a failure. You can add
BTW, xfstests (204, 219, 233, 235, 273, and 274) still cause failures in my test environment, and I still get a warning message which looks like:
kernel: EXT4-fs (sda2): ext4_da_update_reserve_space: ino 3658, allocated 1 with only 0 reserved metadata blocks
kernel:
kernel: ------------[ cut here ]------------
kernel: WARNING: at fs/ext4/inode.c:362 ext4_da_update_reserve_space+0x10f/0x21b [ext4]()
kernel: Hardware name: OptiPlex 780
kernel: Modules linked in: ext4 jbd2 crc16 cpufreq_ondemand ipv6 dm_mirror dm_region_hash dm_log dm_mod parport_pc parport cspkr i2c_i801 i2c_core serio_raw sg ehci_pci ehci_hcd button e1000e ext3 jbd sd_mod ahci libahci libata scsi_mod uhci_hcd
kernel: Pid: 2628, comm: 2372.fsstress.b Tainted: G W 3.8.0+ #7
kernel: Call Trace:
kernel: [<ffffffff82031d68>] warn_slowpath_common+0x85/0x9d
kernel: [<ffffffff82031d9a>] warn_slowpath_null+0x1a/0x1c
kernel: [<ffffffffa0200240>] ext4_da_update_reserve_space+0x10f/0x21b [ext4]
kernel: [<ffffffffa02277cd>] ext4_ext_map_blocks+0xd83/0xf66 [ext4]
kernel: [<ffffffff820ba4a8>] ? release_pages+0x169/0x178
kernel: [<ffffffff820ba011>] ? pagevec_lookup_tag+0x25/0x2e
kernel: [<ffffffffa02018d3>] ? write_cache_pages_da+0x107/0x3c4 [ext4]
kernel: [<ffffffffa0200c36>] ext4_map_blocks+0x135/0x1ef [ext4]
kernel: [<ffffffffa0201451>] mpage_da_map_and_submit+0x111/0x3d8 [ext4]
kernel: [<ffffffffa0201f0e>] ext4_da_writepages+0x37e/0x526 [ext4]
kernel: [<ffffffff820b86d9>] do_writepages+0x20/0x29
kernel: [<ffffffff820b13da>] __filemap_fdatawrite_range+0x50/0x52
kernel: [<ffffffff820b19a5>] filemap_fdatawrite+0x1f/0x21
kernel: [<ffffffff820b19c4>] filemap_write_and_wait+0x1d/0x38
kernel: [<ffffffff820fc4a9>] do_vfs_ioctl+0x2db/0x47f
kernel: [<ffffffff820fc6ab>] sys_ioctl+0x5e/0x82
kernel: [<ffffffff82386942>] system_call_fastpath+0x16/0x1b
kernel: ---[ end trace d96610456f905628 ]---
It is easy to trigger this warning when running xfstests #127 or #225.
Moreover, it seems that there still has an improvement in ext4_calculate_overhead(). I paste the patch here.
Regards,
- Zheng
Subject: [PATCH] ext4: fix overhead calculation in bigalloc filesystem
From: Zheng Liu <[email protected]>
ext4_calculate_overhead() should compute the overhead and stash it in sbi->s_overhead. But we miss use EXT4_B2C() to calculate the number of clusters before first_data_block and the number of journal blocks. This commit use EXT4_NUM_B2C() instead of EXT4_B2C() to calculate the overhead.
--- fs/ext4/super.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
fs/ext4/super.c +2 -2
@@ -3219,7 +3219,7 @@ int ext4_calculate_overhead(struct super_block *sb)/* * All of the blocks before first_data_block are overhead */ - overhead =EXT4_B2C (sbi,le32_to_cpu (es->s_first_data_block)); + overhead =EXT4_NUM_B2C (sbi,le32_to_cpu (es->s_first_data_block));/* * Add the overhead found in each block group
@@ -3235,7 +3235,7 @@ int ext4_calculate_overhead(struct super_block *sb) }/* Add the journal blocks as well */ if (sbi->s_journal) - overhead +=EXT4_B2C (sbi, sbi->s_journal->j_maxlen); + overhead +=EXT4_NUM_B2C (sbi, sbi->s_journal->j_maxlen); sbi->s_overhead = overhead;smp_wmb ();
Signature · 1 line
1.7.12.rc2.18.g61b472e
Re: [PATCH] ext4: fix overhead calculation in bigalloc filesystem (Re: ... )
Quoted 70 lines · Zheng Liu
Date: Thu, 21 Feb 2013 20:15:45 +0800
From: Zheng Liu <[email protected]>
To: Lukas Czerner <[email protected]>
Cc: [email protected], Theodore Ts'o <[email protected]>
Subject: [PATCH] ext4: fix overhead calculation in bigalloc filesystem (Re:... )Quoted 14 lines · Lukas Czerner
ext4_has_free_clusters()should tell us whether there is enough free clusters to allocate, however number of free clusters in the file system is converted to blocks usingEXT4_C2B()which is not only wrong use of the macro (we should have usedEXT4_NUM_B2C) but it's also completely wrong concept since everything else is in cluster units.Moreover when calculating number of root clusters we should be using macro
EXT4_NUM_B2C()instead ofEXT4_C2B()otherwise the result will usually be off by one.As a result number of free clusters is much bigger than it should have been and
ext4_has_free_clusters()would return 1 even if there is really not enough free clusters available.Quoted 8 lines
Fix this by removing the
EXT4_C2B()conversion of free clusters and usingEXT4_NUM_B2C()when calculating number of root clusters. This bug affects number of xfstests tests covering file system ENOSPC situation handling. With this patch most of the ENOSPC problems with bigalloc file system disappear, especially the errors caused by delayed allocation not having enough space when the actual allocation is finally requested.Signed-off-by Lukas Czerner <[email protected]>Great! Thanks for fixing it. After applied this patch, xfstests #15 with bigalloc and delalloc won't cause a failure. You can add
Reviewed-and-tested-by Zheng Liu <[email protected]>BTW, xfstests (204, 219, 233, 235, 273, and 274) still cause failures in my test environment, and I still get a warning message which looks like:
kernel: EXT4-fs (sda2):
ext4_da_update_reserve_space: ino 3658, allocated 1 with only 0 reserved metadata blocks
kernel:
kernel: ------------[ cut here ]------------
kernel: WARNING: atfs/ext4/inode.c:362ext4_da_update_reserve_space+0x10f/0x21b[ext4]()
kernel: Hardware name: OptiPlex 780
kernel: Modules linked in: ext4 jbd2 crc16cpufreq_ondemandipv6dm_mirrordm_region_hashdm_logdm_modparport_pcparport cspkri2c_i801i2c_coreserio_rawsgehci_pciehci_hcdbutton e1000e ext3 jbdsd_modahci libahci libatascsi_moduhci_hcd
kernel: Pid: 2628, comm: 2372.fsstress.b Tainted: G W 3.8.0+ #7
kernel: Call Trace:
kernel: [<ffffffff82031d68>]warn_slowpath_common+0x85/0x9d
kernel: [<ffffffff82031d9a>]warn_slowpath_null+0x1a/0x1c
kernel: [<ffffffffa0200240>]ext4_da_update_reserve_space+0x10f/0x21b[ext4]
kernel: [<ffffffffa02277cd>]ext4_ext_map_blocks+0xd83/0xf66[ext4]
kernel: [<ffffffff820ba4a8>] ?release_pages+0x169/0x178
kernel: [<ffffffff820ba011>] ?pagevec_lookup_tag+0x25/0x2e
kernel: [<ffffffffa02018d3>] ?write_cache_pages_da+0x107/0x3c4[ext4]
kernel: [<ffffffffa0200c36>]ext4_map_blocks+0x135/0x1ef[ext4]
kernel: [<ffffffffa0201451>]mpage_da_map_and_submit+0x111/0x3d8[ext4]
kernel: [<ffffffffa0201f0e>]ext4_da_writepages+0x37e/0x526[ext4]
kernel: [<ffffffff820b86d9>]do_writepages+0x20/0x29
kernel: [<ffffffff820b13da>]__filemap_fdatawrite_range+0x50/0x52
kernel: [<ffffffff820b19a5>]filemap_fdatawrite+0x1f/0x21
kernel: [<ffffffff820b19c4>]filemap_write_and_wait+0x1d/0x38
kernel: [<ffffffff820fc4a9>]do_vfs_ioctl+0x2db/0x47f
kernel: [<ffffffff820fc6ab>]sys_ioctl+0x5e/0x82
kernel: [<ffffffff82386942>]system_call_fastpath+0x16/0x1b
kernel: ---[ end traced96610456f905628]---
Quoted 7 lines
It is easy to trigger this warning when running xfstests #127 or #225.
Moreover, it seems that there still has an improvement in
ext4_calculate_overhead(). I paste the patch here.Regards,
- Zheng
Hi Zheng,
thanks for the review. I know about the other issues and I'm trying to resolve those as well. Right now I have a patch which includes the changes ext4_calculate_overhead() you've described below and more, but even with this I still see some problems remaining.
Hopefully will send another patch soon.
Thanks!
-Lukas
Quoted 40 lines
Subject: [PATCH] ext4: fix overhead calculation in bigalloc filesystem
From: Zheng Liu <[email protected]>
ext4_calculate_overhead()should compute the overhead and stash it insbi->s_overhead. But we miss useEXT4_B2C()to calculate the number of clusters beforefirst_data_blockand the number of journal blocks. This commit useEXT4_NUM_B2C()instead ofEXT4_B2C()to calculate the overhead.Signed-off-by Zheng Liu <[email protected]>Cc "Theodore Ts'o" <[email protected]>--- fs/ext4/super.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)fs/ext4/super.c +2
-2@@ -3219,7 +3219,7 @@ int ext4_calculate_overhead(struct super_block *sb)/* * All of the blocks before first_data_block are overhead */ - overhead =EXT4_B2C (sbi,le32_to_cpu (es->s_first_data_block)); + overhead =EXT4_NUM_B2C (sbi,le32_to_cpu (es->s_first_data_block));/* * Add the overhead found in each block group @@ -3235,7 +3235,7 @@ int ext4_calculate_overhead(struct super_block *sb) }/* Add the journal blocks as well */ if (sbi->s_journal) - overhead +=EXT4_B2C (sbi, sbi->s_journal->j_maxlen); + overhead +=EXT4_NUM_B2C (sbi, sbi->s_journal->j_maxlen); sbi->s_overhead = overhead;smp_wmb ();
Re: [PATCH] ext4: fix overhead calculation in bigalloc filesystem (Re: ... )
On Thu, 21 Feb 2013, Lukáš Czerner wrote:
..snip...
Quoted 30 lines
Hi Zheng,
thanks for the review. I know about the other issues and I'm trying to resolve those as well. Right now I have a patch which includes the changes
ext4_calculate_overhead()you've described below and more, but even with this I still see some problems remaining.Hopefully will send another patch soon.
Thanks!
-LukasQuoted 17 lines
Subject: [PATCH] ext4: fix overhead calculation in bigalloc filesystem
From: Zheng Liu <[email protected]>
ext4_calculate_overhead()should compute the overhead and stash it insbi->s_overhead. But we miss useEXT4_B2C()to calculate the number of clusters beforefirst_data_blockand the number of journal blocks. This commit useEXT4_NUM_B2C()instead ofEXT4_B2C()to calculate the overhead.Signed-off-by Zheng Liu <[email protected]>Cc "Theodore Ts'o" <[email protected]>--- fs/ext4/super.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
Quoted 10 lines
fs/ext4/super.c int ext4_calculate_overhead(struct super_block *sb) · line 3222
Quoted 10 lines
fs/ext4/super.c +1
-1@@ -3219,7 +3219,7 @@ int ext4_calculate_overhead(struct super_block *sb)/* * All of the blocks before first_data_block are overhead */ - overhead =EXT4_B2C (sbi,le32_to_cpu (es->s_first_data_block)); + overhead =EXT4_NUM_B2C (sbi,le32_to_cpu (es->s_first_data_block));
...except this. I do not think this is right because we do not skip the first cluster right ? We're still using it, but we can never use the block before es->s_first_data_block. Please correct me if I am wrong.
Quoted 9 lines
fs/ext4/super.c int ext4_calculate_overhead(struct super_block *sb) · line 3238
Quoted 9 lines
fs/ext4/super.c +1
-1/* * Add the overhead found in each block group @@ -3235,7 +3235,7 @@ int ext4_calculate_overhead(struct super_block *sb) }/* Add the journal blocks as well */ if (sbi->s_journal) - overhead +=EXT4_B2C (sbi, sbi->s_journal->j_maxlen); + overhead +=EXT4_NUM_B2C (sbi, sbi->s_journal->j_maxlen);
This I already have in my patch I'm testing right now. And as I said there are other places where we misuse EXT4_B2C().
-Lukas
Quoted 5 lines
Quoted 4 lines
fs/ext4/super.c +0
-0sbi->s_overhead = overhead;smp_wmb ();
Re: [PATCH] ext4: fix overhead calculation in bigalloc filesystem (Re: ... )
Quoted 42 lines · Lukáš Czerner
Date: Thu, 21 Feb 2013 13:50:03 +0100 (CET)
From: Lukáš Czerner <[email protected]>
To: Lukáš Czerner <[email protected]>
Cc: Zheng Liu <[email protected]>, [email protected],
Theodore Ts'o <[email protected]>
Subject: Re: [PATCH] ext4: fix overhead calculation in bigalloc filesystem(Re: ... )On Thu, 21 Feb 2013, Lukáš Czerner wrote:
..snip...
Quoted 30 lines
Hi Zheng,
thanks for the review. I know about the other issues and I'm trying to resolve those as well. Right now I have a patch which includes the changes
ext4_calculate_overhead()you've described below and more, but even with this I still see some problems remaining.Hopefully will send another patch soon.
Thanks!
-LukasQuoted 17 lines
Subject: [PATCH] ext4: fix overhead calculation in bigalloc filesystem
From: Zheng Liu <[email protected]>
ext4_calculate_overhead()should compute the overhead and stash it insbi->s_overhead. But we miss useEXT4_B2C()to calculate the number of clusters beforefirst_data_blockand the number of journal blocks. This commit useEXT4_NUM_B2C()instead ofEXT4_B2C()to calculate the overhead.Signed-off-by Zheng Liu <[email protected]>Cc "Theodore Ts'o" <[email protected]>--- fs/ext4/super.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
Quoted 15 lines
Quoted 10 lines
fs/ext4/super.c int ext4_calculate_overhead(struct super_block *sb) · line 3222
Quoted 10 lines
fs/ext4/super.c +1
-1@@ -3219,7 +3219,7 @@ int ext4_calculate_overhead(struct super_block *sb)/* * All of the blocks before first_data_block are overhead */ - overhead =EXT4_B2C (sbi,le32_to_cpu (es->s_first_data_block)); + overhead =EXT4_NUM_B2C (sbi,le32_to_cpu (es->s_first_data_block));...except this. I do not think this is right because we do not skip the first cluster right ? We're still using it, but we can never use the block before
es->s_first_data_block. Please correct me if I am wrong.
moreover we do not allow bigalloc file system with block size < 4k.
Quoted 23 lines
Quoted 11 lines
fs/ext4/super.c int ext4_calculate_overhead(struct super_block *sb) · line 3238
Quoted 11 lines
fs/ext4/super.c +1
-1/* * Add the overhead found in each block group @@ -3235,7 +3235,7 @@ int ext4_calculate_overhead(struct super_block *sb) }/* Add the journal blocks as well */ if (sbi->s_journal) - overhead +=EXT4_B2C (sbi, sbi->s_journal->j_maxlen); + overhead +=EXT4_NUM_B2C (sbi, sbi->s_journal->j_maxlen);This I already have in my patch I'm testing right now. And as I said there are other places where we misuse
EXT4_B2C().-Lukas
Quoted 5 lines
Quoted 4 lines
fs/ext4/super.c +0
-0sbi->s_overhead = overhead;smp_wmb ();
Re: [PATCH] ext4: fix overhead calculation in bigalloc filesystem (Re: ... )
Quoted 44 lines · Lukáš Czerner
Quoted 42 lines · Lukáš Czerner
Date: Thu, 21 Feb 2013 13:50:03 +0100 (CET)
From: Lukáš Czerner <[email protected]>
To: Lukáš Czerner <[email protected]>
Cc: Zheng Liu <[email protected]>, [email protected],
Theodore Ts'o <[email protected]>
Subject: Re: [PATCH] ext4: fix overhead calculation in bigalloc filesystem(Re: ... )On Thu, 21 Feb 2013, Lukáš Czerner wrote:
..snip...
Quoted 30 lines
Hi Zheng,
thanks for the review. I know about the other issues and I'm trying to resolve those as well. Right now I have a patch which includes the changes
ext4_calculate_overhead()you've described below and more, but even with this I still see some problems remaining.Hopefully will send another patch soon.
Thanks!
-LukasQuoted 17 lines
Subject: [PATCH] ext4: fix overhead calculation in bigalloc filesystem
From: Zheng Liu <[email protected]>
ext4_calculate_overhead()should compute the overhead and stash it insbi->s_overhead. But we miss useEXT4_B2C()to calculate the number of clusters beforefirst_data_blockand the number of journal blocks. This commit useEXT4_NUM_B2C()instead ofEXT4_B2C()to calculate the overhead.Signed-off-by Zheng Liu <[email protected]>Cc "Theodore Ts'o" <[email protected]>--- fs/ext4/super.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
Quoted 15 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
fs/ext4/super.c +0
-0@@ -3219,7 +3219,7 @@ int ext4_calculate_overhead(struct super_block *sb)/* * All of the blocks before first_data_block are overhead Quoted 8 lines
Quoted 3 lines
fs/ext4/super.c int ext4_calculate_overhead(struct super_block *sb) · line 3222
Quoted 3 lines
fs/ext4/super.c +1
-1*/ - overhead =EXT4_B2C (sbi,le32_to_cpu (es->s_first_data_block)); + overhead =EXT4_NUM_B2C (sbi,le32_to_cpu (es->s_first_data_block));...except this. I do not think this is right because we do not skip the first cluster right ? We're still using it, but we can never use the block before
es->s_first_data_block. Please correct me if I am wrong.
Yes, I think you are right.
Quoted 2 lines
moreover we do not allow bigalloc file system with block size < 4k.
No, we allow user to use bigalloc with block size < 4k, such as:
mkfs.ext4 -b 1024 -C 4096 -O bigalloc ${dev}This command formats a bigalloc filesystem with blocksize = 1k and clustersize = 4k, at least in e2fsprogs 1.42.7 it works well.
Quoted 16 lines
Quoted 16 lines
Quoted 4 lines
Quoted 4 lines
Quoted 8 lines
fs/ext4/super.c int ext4_calculate_overhead(struct super_block *sb) · line 3238
Quoted 8 lines
fs/ext4/super.c +1
-1/* * Add the overhead found in each block group @@ -3235,7 +3235,7 @@ int ext4_calculate_overhead(struct super_block *sb) }/* Add the journal blocks as well */ if (sbi->s_journal) - overhead +=EXT4_B2C (sbi, sbi->s_journal->j_maxlen); + overhead +=EXT4_NUM_B2C (sbi, sbi->s_journal->j_maxlen);This I already have in my patch I'm testing right now. And as I said there are other places where we misuse
EXT4_B2C().
Quoted 8 lines
Quoted 8 lines
-Lukas
Quoted 5 lines
Quoted 4 lines
fs/ext4/super.c +0
-0sbi->s_overhead = overhead;smp_wmb ();
--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH] ext4: fix overhead calculation in bigalloc filesystem (Re: ... )
On Thu, 21 Feb 2013, Zheng Liu wrote:
..snip..
Quoted 14 lines
Quoted 10 lines
Quoted 10 lines
Quoted 5 lines
fs/ext4/super.c int ext4_calculate_overhead(struct super_block *sb) · line 3222
Quoted 5 lines
fs/ext4/super.c +1
-1/* * All of the blocks before first_data_block are overhead */ - overhead =EXT4_B2C (sbi,le32_to_cpu (es->s_first_data_block)); + overhead =EXT4_NUM_B2C (sbi,le32_to_cpu (es->s_first_data_block));...except this. I do not think this is right because we do not skip the first cluster right ? We're still using it, but we can never use the block before
es->s_first_data_block. Please correct me if I am wrong.Yes, I think you are right.
Quoted 1 line
Quoted 9 lines
Quoted 1 line
moreover we do not allow bigalloc file system with block size < 4k.
No, we allow user to use bigalloc with block size < 4k, such as:
mkfs.ext4 -b 1024 -C 4096 -O bigalloc ${dev}This command formats a bigalloc filesystem with blocksize = 1k and clustersize = 4k, at least in e2fsprogs 1.42.7 it works well.
Ok, i was pretty sure that we do not allow that, it's good to know. Also, does it make any sense ? I do not think so, and I would really consider the fact that we allow that as a bug. We should not allow that otherwise it unnecessarily extending the test matrix.
What people think about restricting bigalloc _only_ for 4k block size file systems ?
Thanks!
-Lukas
Re: [PATCH] ext4: fix overhead calculation in bigalloc filesystem (Re: ... )
Quoted 28 lines · Lukáš Czerner
On Thu, 21 Feb 2013, Zheng Liu wrote:
..snip..
Quoted 14 lines
Quoted 10 lines
Quoted 10 lines
Quoted 5 lines
fs/ext4/super.c int ext4_calculate_overhead(struct super_block *sb) · line 3222
Quoted 5 lines
fs/ext4/super.c +1
-1/* * All of the blocks before first_data_block are overhead */ - overhead =EXT4_B2C (sbi,le32_to_cpu (es->s_first_data_block)); + overhead =EXT4_NUM_B2C (sbi,le32_to_cpu (es->s_first_data_block));...except this. I do not think this is right because we do not skip the first cluster right ? We're still using it, but we can never use the block before
es->s_first_data_block. Please correct me if I am wrong.Yes, I think you are right.
Quoted 1 line
Quoted 9 lines
Quoted 1 line
moreover we do not allow bigalloc file system with block size < 4k.
No, we allow user to use bigalloc with block size < 4k, such as:
mkfs.ext4 -b 1024 -C 4096 -O bigalloc ${dev}This command formats a bigalloc filesystem with blocksize = 1k and clustersize = 4k, at least in e2fsprogs 1.42.7 it works well.
Quoted 7 lines
Ok, i was pretty sure that we do not allow that, it's good to know. Also, does it make any sense ? I do not think so, and I would really consider the fact that we allow that as a bug. We should not allow that otherwise it unnecessarily extending the test matrix.
What people think about restricting bigalloc _only_ for 4k block size file systems ?
I agree with you that we should forbid user to use bigalloc feature with block size = 1k or 2k because I guess no one really use it, at least in Taobao we always use bigalloc feature with block size = 4k.
FWIW, recently I am considering whether we could remove 'data=journal' and 'data=writeback' mode. 'data=journal' mode hurts performance dramatically. Further, 'data=writeback' seems also useless, especially after we have 'no journal' feature. TBH, these modes are lack of tests. Maybe this is a crazy idea in my mind.
Regards,
- Zheng
--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Theodore Ts'o
maintainerRe: [PATCH] ext4: fix overhead calculation in bigalloc filesystem (Re: ... )
Quoted 4 lines · Zheng Liu
I agree with you that we should forbid user to use bigalloc feature with block size = 1k or 2k because I guess no one really use it, at least in Taobao we always use bigalloc feature with block size = 4k.
The main reason why file systems with 1k or 2k (with or without bigalloc) is that it's useful is that it's a good way of testing what happens on an architecture with a 16k page size and a 4k blocksize. I am regularly testing with a 1k blocksize because it catches problems that would otherwise only show up on PowerPC or Intanium platforms. I'm not testing with bigalloc plus 1k block size, though, I admit.
Quoted 5 lines
FWIW, recently I am considering whether we could remove 'data=journal' and 'data=writeback' mode. 'data=journal' mode hurts performance dramatically. Further, 'data=writeback' seems also useless, especially after we have 'no journal' feature. TBH, these modes are lack of tests. Maybe this is a crazy idea in my mind.
As far as data=writeback and data=ordered are concerned, the only difference is a single call to ext4_jbd2_file_end() in ext4_ordered_write_end(). In fact, it looks like we could do something like the following attached patch to simplify the code and improve code coverage from a testing perspective. (Note: patch not yet tested!)
As far as "data=journalled", it's a bit more complicated but I do have a sentimental attachment to it, since it's something which no other file system has. I have been regularly testing it, and it's something which has been pretty stable for quite a while now.
If there was a mode that I'd be tempted to get rid of, it would be the combined data=ordered/data=writeback modes. The main reason why we keep it is because of a concern of buggy applications that depend on the implied fsync() of data=ordered mode at each commit. However, ext4 has been around for long enough that I think most of the buggy applications have been fixed by now. And of course, those buggy applications will lose in the same way when they are using btrfs and xfs. Something to consider....
- Ted
commit d075b5c3031752a4c41642ff505c3302e5321940
Author: Theodore Ts'o <[email protected]> Date: Thu Feb 21 23:04:59 2013 -0500
ext4: collapse handling of data=ordered and data=writeback codepaths
The only difference between how we handle data=ordered and data=writeback is a single call to ext4_jbd2_file_inode(). Eliminate code duplication by factoring out redundant the code paths.
fs/ext4/ext4.h +1 -0
@@ -1373,6 +1373,7 @@ enum {EXT4_STATE_DIOREAD_LOCK ,/* Disable support for dio read nolocking */ EXT4_STATE_MAY_INLINE_DATA ,/* may have in-inode data */ + EXT4_STATE_ORDERED_MODE, /* data=ordered mode */ };#define EXT4_INODE_BIT_FNS (name, field, offset) \
fs/ext4/inode.c +28 -95
173 lines not on this page · raw message
Re: [PATCH] ext4: fix overhead calculation in bigalloc filesystem (Re: ... )
Quoted 12 lines · Theodore Ts'o
Date: Thu, 21 Feb 2013 23:05:44 -0500
From: Theodore Ts'o <[email protected]>
To: Lukáš Czerner <[email protected]>, [email protected]
Subject: Re: [PATCH] ext4: fix overhead calculation in bigalloc filesystem(Re: ... )Quoted 4 lines · Zheng Liu
I agree with you that we should forbid user to use bigalloc feature with block size = 1k or 2k because I guess no one really use it, at least in Taobao we always use bigalloc feature with block size = 4k.
Quoted 6 lines
The main reason why file systems with 1k or 2k (with or without bigalloc) is that it's useful is that it's a good way of testing what happens on an architecture with a 16k page size and a 4k blocksize. I am regularly testing with a 1k blocksize because it catches problems that would otherwise only show up on PowerPC or Intanium platforms. I'm not testing with bigalloc plus 1k block size, though, I admit.
I agree having block size smaller than 4k is useful not only for testing purposes. However in my opinion with bigalloc it is entirely unnecessary to allow those sizes.
-Lukas
Quoted 236 lines
Quoted 6 lines
FWIW, recently I am considering whether we could remove 'data=journal' and 'data=writeback' mode. 'data=journal' mode hurts performance dramatically. Further, 'data=writeback' seems also useless, especially after we have 'no journal' feature. TBH, these modes are lack of tests. Maybe this is a crazy idea in my mind.
As far as data=writeback and data=ordered are concerned, the only difference is a single call to
ext4_jbd2_file_end()inext4_ordered_write_end(). In fact, it looks like we could do something like the following attached patch to simplify the code and improve code coverage from a testing perspective. (Note: patch not yet tested!)As far as "data=journalled", it's a bit more complicated but I do have a sentimental attachment to it, since it's something which no other file system has. I have been regularly testing it, and it's something which has been pretty stable for quite a while now.
If there was a mode that I'd be tempted to get rid of, it would be the combined data=ordered/data=writeback modes. The main reason why we keep it is because of a concern of buggy applications that depend on the implied
fsync()of data=ordered mode at each commit. However, ext4 has been around for long enough that I think most of the buggy applications have been fixed by now. And of course, those buggy applications will lose in the same way when they are using btrfs and xfs. Something to consider....- Ted
commit
d075b5c3031752a4c41642ff505c3302e5321940Author: Theodore Ts'o <[email protected]> Date: Thu Feb 21 23:04:59 2013 -0500ext4: collapse handling of data=ordered and data=writeback codepaths
The only difference between how we handle data=ordered and data=writeback is a single call to
ext4_jbd2_file_inode(). Eliminate code duplication by factoring out redundant the code paths.Signed-off-by "Theodore Ts'o" <[email protected]>fs/ext4/ext4.h +1
-0@@ -1373,6 +1373,7 @@ enum {EXT4_STATE_DIOREAD_LOCK ,/* Disable support for dio read nolocking */ EXT4_STATE_MAY_INLINE_DATA ,/* may have in-inode data */ + EXT4_STATE_ORDERED_MODE, /* data=ordered mode */ };#define EXT4_INODE_BIT_FNS (name, field, offset) \fs/ext4/inode.c +28
-95@@ -1055,77 +1055,36 @@ static int ext4_generic_write_end(struct file *file,* ext4 never places buffers on inode->i_mapping->private_list. metadata * buffers are managed internally. */ -static int ext4_ordered_write_end (struct file *file, -struct address_space *mapping, -loff_t pos,unsigned len,unsigned copied, -struct page *page,void *fsdata) +static int ext4_write_end (struct file *file, +struct address_space *mapping, +loff_t pos,unsigned len,unsigned copied, +struct page *page,void *fsdata) {handle_t *handle =ext4_journal_current_handle ();struct inode *inode = mapping->host;int ret =0 , ret2;trace_ext4_ordered_write_end (inode, pos, len, copied); - ret =ext4_jbd2_file_inode (handle, inode); - -if (ret ==0 ) { - ret2 =ext4_generic_write_end (file, mapping, pos, len, copied, - page, fsdata); - copied = ret2; -if (pos + len > inode->i_size &&ext4_can_truncate (inode)) -/* if we have allocated more blocks and copied -* less. We will have blocks allocated outside -* inode->i_size. So truncate them -*/ -ext4_orphan_add (handle, inode); -if (ret2 <0 ) - ret = ret2; - }else { -unlock_page (page); -page_cache_release (page); - } - - ret2 =ext4_journal_stop (handle); -if (!ret) - ret = ret2; - -if (pos + len > inode->i_size) { -ext4_truncate_failed_write (inode); -/* -* If truncate failed early the inode might still be -* on the orphan list; we need to make sure the inode -* is removed from the orphan list in that case. -*/ -if (inode->i_nlink) -ext4_orphan_del (NULL , inode); +if (ext4_test_inode_state (inode,EXT4_STATE_ORDERED_MODE )) { + ret =ext4_jbd2_file_inode (handle, inode); +if (ret) { +unlock_page (page); +page_cache_release (page); + goto errout; + } } - -return ret ? ret : copied; -} - -static int ext4_writeback_write_end (struct file *file, -struct address_space *mapping, -loff_t pos,unsigned len,unsigned copied, -struct page *page,void *fsdata) -{ -handle_t *handle =ext4_journal_current_handle (); -struct inode *inode = mapping->host; -int ret =0 , ret2; - -trace_ext4_writeback_write_end (inode, pos, len, copied); - ret2 =ext4_generic_write_end (file, mapping, pos, len, copied, - page, fsdata); - copied = ret2; + copied =ext4_generic_write_end (file, mapping, pos, len, copied, + page, fsdata); +if (copied <0 ) + ret = copied;if (pos + len > inode->i_size &&ext4_can_truncate (inode))/* if we have allocated more blocks and copied * less. We will have blocks allocated outside * inode->i_size. So truncate them */ ext4_orphan_add (handle, inode); - -if (ret2 <0 ) - ret = ret2; - +errout: ret2 =ext4_journal_stop (handle);if (!ret) ret = ret2;@@ -2656,18 +2615,9 @@ static int ext4_da_write_end(struct file *file,unsigned long start, end;int write_mode = (int )(unsigned long )fsdata; -if (write_mode ==FALL_BACK_TO_NONDELALLOC ) { -switch (ext4_inode_journal_mode (inode)) { -case EXT4_INODE_ORDERED_DATA_MODE : -return ext4_ordered_write_end (file, mapping, pos, - len, copied, page, fsdata); -case EXT4_INODE_WRITEBACK_DATA_MODE : -return ext4_writeback_write_end (file, mapping, pos, - len, copied, page, fsdata); -default : -BUG (); - } - } +if (write_mode ==FALL_BACK_TO_NONDELALLOC ) +return ext4_write_end (file, mapping, pos, + len, copied, page, fsdata);trace_ext4_da_write_end (inode, pos, len, copied); start = pos & (PAGE_CACHE_SIZE -1 );@@ -3172,27 +3122,12 @@ static int ext4_journalled_set_page_dirty(struct page *page)return __set_page_dirty_nobuffers (page); } -static const struct address_space_operations ext4_ordered_aops = { +static const struct address_space_operations ext4_aops = { .readpage = ext4_readpage, .readpages = ext4_readpages, .writepage = ext4_writepage, .write_begin = ext4_write_begin, - .write_end = ext4_ordered_write_end, - .bmap = ext4_bmap, - .invalidatepage = ext4_invalidatepage, - .releasepage = ext4_releasepage, - .direct_IO = ext4_direct_IO, - .migratepage = buffer_migrate_page, - .is_partially_uptodate = block_is_partially_uptodate, - .error_remove_page = generic_error_remove_page, -}; - -static const struct address_space_operations ext4_writeback_aops = { - .readpage = ext4_readpage, - .readpages = ext4_readpages, - .writepage = ext4_writepage, - .write_begin = ext4_write_begin, - .write_end = ext4_writeback_write_end, + .write_end = ext4_write_end, .bmap = ext4_bmap, .invalidatepage = ext4_invalidatepage, .releasepage = ext4_releasepage,@@ -3237,23 +3172,21 @@ void ext4_set_aops(struct inode *inode) {switch (ext4_inode_journal_mode (inode)) {case EXT4_INODE_ORDERED_DATA_MODE : -if (test_opt (inode->i_sb,DELALLOC )) - inode->i_mapping->a_ops = &ext4_da_aops; -else - inode->i_mapping->a_ops = &ext4_ordered_aops; +ext4_set_inode_state (inode,EXT4_STATE_ORDERED_MODE );break ;case EXT4_INODE_WRITEBACK_DATA_MODE : -if (test_opt (inode->i_sb,DELALLOC )) - inode->i_mapping->a_ops = &ext4_da_aops; -else - inode->i_mapping->a_ops = &ext4_writeback_aops; +ext4_clear_inode_state (inode,EXT4_STATE_ORDERED_MODE );break ;case EXT4_INODE_JOURNAL_DATA_MODE : inode->i_mapping->a_ops = &ext4_journalled_aops; -break ; +return ;default :BUG (); } +if (test_opt (inode->i_sb,DELALLOC )) + inode->i_mapping->a_ops = &ext4_da_aops; +else + inode->i_mapping->a_ops = &ext4_aops; }
Zheng Liu
Reviewed-byRe: [PATCH] ext4: fix overhead calculation in bigalloc filesystem (Re: ... )
In reply to Theodore Ts'oQuoted 26 lines · Theodore Ts'o
Quoted 4 lines · Zheng Liu
I agree with you that we should forbid user to use bigalloc feature with block size = 1k or 2k because I guess no one really use it, at least in Taobao we always use bigalloc feature with block size = 4k.
The main reason why file systems with 1k or 2k (with or without bigalloc) is that it's useful is that it's a good way of testing what happens on an architecture with a 16k page size and a 4k blocksize. I am regularly testing with a 1k blocksize because it catches problems that would otherwise only show up on PowerPC or Intanium platforms. I'm not testing with bigalloc plus 1k block size, though, I admit.
Quoted 5 lines
FWIW, recently I am considering whether we could remove 'data=journal' and 'data=writeback' mode. 'data=journal' mode hurts performance dramatically. Further, 'data=writeback' seems also useless, especially after we have 'no journal' feature. TBH, these modes are lack of tests. Maybe this is a crazy idea in my mind.
As far as data=writeback and data=ordered are concerned, the only difference is a single call to
ext4_jbd2_file_end()inext4_ordered_write_end(). In fact, it looks like we could do something like the following attached patch to simplify the code and improve code coverage from a testing perspective. (Note: patch not yet tested!)
Quoted 4 lines
As far as "data=journalled", it's a bit more complicated but I do have a sentimental attachment to it, since it's something which no other file system has. I have been regularly testing it, and it's something which has been pretty stable for quite a while now.
Indeed, it seems that other file systems don't have this feature AFAIK.
Quoted 9 lines
If there was a mode that I'd be tempted to get rid of, it would be the combined data=ordered/data=writeback modes. The main reason why we keep it is because of a concern of buggy applications that depend on the implied
fsync()of data=ordered mode at each commit. However, ext4 has been around for long enough that I think most of the buggy applications have been fixed by now. And of course, those buggy applications will lose in the same way when they are using btrfs and xfs. Something to consider....
IMHO, the application shouldn't depend on a kernel feature. So maybe it is time to highlight this buggy usage.
Quoted 7 lines
- Ted
commit
d075b5c3031752a4c41642ff505c3302e5321940Author: Theodore Ts'o <[email protected]> Date: Thu Feb 21 23:04:59 2013 -0500
Quoted 7 lines
ext4: collapse handling of data=ordered and data=writeback codepaths
The only difference between how we handle data=ordered and data=writeback is a single call to
ext4_jbd2_file_inode(). Eliminate code duplication by factoring out redundant the code paths.Signed-off-by "Theodore Ts'o" <[email protected]>
Just one minor comment below. Otherwise the patch looks good to me, and it can pass in xfstests with 'data=ordered' and 'data=writeback'.
Quoted 25 lines
fs/ext4/ext4.h +1
-0@@ -1373,6 +1373,7 @@ enum {EXT4_STATE_DIOREAD_LOCK ,/* Disable support for dio read nolocking */ EXT4_STATE_MAY_INLINE_DATA ,/* may have in-inode data */ + EXT4_STATE_ORDERED_MODE, /* data=ordered mode */ };#define EXT4_INODE_BIT_FNS (name, field, offset) \fs/ext4/inode.c +0
-4@@ -1055,77 +1055,36 @@ static int ext4_generic_write_end(struct file *file,* ext4 never places buffers on inode->i_mapping->private_list. metadata * buffers are managed internally. */ -static int ext4_ordered_write_end (struct file *file, -struct address_space *mapping, -loff_t pos,unsigned len,unsigned copied, -struct page *page,void *fsdata)
fs/ext4/inode.c static int ext4_generic_write_end(struct file *file, · line 1067
Quoted 10 lines
fs/ext4/inode.c +4
-0+static int ext4_write_end (struct file *file, +struct address_space *mapping, +loff_t pos,unsigned len,unsigned copied, +struct page *page,void *fsdata) {handle_t *handle =ext4_journal_current_handle ();struct inode *inode = mapping->host;int ret =0 , ret2;trace_ext4_ordered_write_end (inode, pos, len, copied);
Here this function needs to be renamed with trace_ext4_write_end().
Regards,
- Zheng
Quoted 163 lines
fs/ext4/inode.c +24
-92- ret =ext4_jbd2_file_inode (handle, inode); - -if (ret ==0 ) { - ret2 =ext4_generic_write_end (file, mapping, pos, len, copied, - page, fsdata); - copied = ret2; -if (pos + len > inode->i_size &&ext4_can_truncate (inode)) -/* if we have allocated more blocks and copied -* less. We will have blocks allocated outside -* inode->i_size. So truncate them -*/ -ext4_orphan_add (handle, inode); -if (ret2 <0 ) - ret = ret2; - }else { -unlock_page (page); -page_cache_release (page); - } - - ret2 =ext4_journal_stop (handle); -if (!ret) - ret = ret2; - -if (pos + len > inode->i_size) { -ext4_truncate_failed_write (inode); -/* -* If truncate failed early the inode might still be -* on the orphan list; we need to make sure the inode -* is removed from the orphan list in that case. -*/ -if (inode->i_nlink) -ext4_orphan_del (NULL , inode); +if (ext4_test_inode_state (inode,EXT4_STATE_ORDERED_MODE )) { + ret =ext4_jbd2_file_inode (handle, inode); +if (ret) { +unlock_page (page); +page_cache_release (page); + goto errout; + } } - -return ret ? ret : copied; -} - -static int ext4_writeback_write_end (struct file *file, -struct address_space *mapping, -loff_t pos,unsigned len,unsigned copied, -struct page *page,void *fsdata) -{ -handle_t *handle =ext4_journal_current_handle (); -struct inode *inode = mapping->host; -int ret =0 , ret2; - -trace_ext4_writeback_write_end (inode, pos, len, copied); - ret2 =ext4_generic_write_end (file, mapping, pos, len, copied, - page, fsdata); - copied = ret2; + copied =ext4_generic_write_end (file, mapping, pos, len, copied, + page, fsdata); +if (copied <0 ) + ret = copied;if (pos + len > inode->i_size &&ext4_can_truncate (inode))/* if we have allocated more blocks and copied * less. We will have blocks allocated outside * inode->i_size. So truncate them */ ext4_orphan_add (handle, inode); - -if (ret2 <0 ) - ret = ret2; - +errout: ret2 =ext4_journal_stop (handle);if (!ret) ret = ret2;@@ -2656,18 +2615,9 @@ static int ext4_da_write_end(struct file *file,unsigned long start, end;int write_mode = (int )(unsigned long )fsdata; -if (write_mode ==FALL_BACK_TO_NONDELALLOC ) { -switch (ext4_inode_journal_mode (inode)) { -case EXT4_INODE_ORDERED_DATA_MODE : -return ext4_ordered_write_end (file, mapping, pos, - len, copied, page, fsdata); -case EXT4_INODE_WRITEBACK_DATA_MODE : -return ext4_writeback_write_end (file, mapping, pos, - len, copied, page, fsdata); -default : -BUG (); - } - } +if (write_mode ==FALL_BACK_TO_NONDELALLOC ) +return ext4_write_end (file, mapping, pos, + len, copied, page, fsdata);trace_ext4_da_write_end (inode, pos, len, copied); start = pos & (PAGE_CACHE_SIZE -1 );@@ -3172,27 +3122,12 @@ static int ext4_journalled_set_page_dirty(struct page *page)return __set_page_dirty_nobuffers (page); } -static const struct address_space_operations ext4_ordered_aops = { +static const struct address_space_operations ext4_aops = { .readpage = ext4_readpage, .readpages = ext4_readpages, .writepage = ext4_writepage, .write_begin = ext4_write_begin, - .write_end = ext4_ordered_write_end, - .bmap = ext4_bmap, - .invalidatepage = ext4_invalidatepage, - .releasepage = ext4_releasepage, - .direct_IO = ext4_direct_IO, - .migratepage = buffer_migrate_page, - .is_partially_uptodate = block_is_partially_uptodate, - .error_remove_page = generic_error_remove_page, -}; - -static const struct address_space_operations ext4_writeback_aops = { - .readpage = ext4_readpage, - .readpages = ext4_readpages, - .writepage = ext4_writepage, - .write_begin = ext4_write_begin, - .write_end = ext4_writeback_write_end, + .write_end = ext4_write_end, .bmap = ext4_bmap, .invalidatepage = ext4_invalidatepage, .releasepage = ext4_releasepage,@@ -3237,23 +3172,21 @@ void ext4_set_aops(struct inode *inode) {switch (ext4_inode_journal_mode (inode)) {case EXT4_INODE_ORDERED_DATA_MODE : -if (test_opt (inode->i_sb,DELALLOC )) - inode->i_mapping->a_ops = &ext4_da_aops; -else - inode->i_mapping->a_ops = &ext4_ordered_aops; +ext4_set_inode_state (inode,EXT4_STATE_ORDERED_MODE );break ;case EXT4_INODE_WRITEBACK_DATA_MODE : -if (test_opt (inode->i_sb,DELALLOC )) - inode->i_mapping->a_ops = &ext4_da_aops; -else - inode->i_mapping->a_ops = &ext4_writeback_aops; +ext4_clear_inode_state (inode,EXT4_STATE_ORDERED_MODE );break ;case EXT4_INODE_JOURNAL_DATA_MODE : inode->i_mapping->a_ops = &ext4_journalled_aops; -break ; +return ;default :BUG (); } +if (test_opt (inode->i_sb,DELALLOC )) + inode->i_mapping->a_ops = &ext4_da_aops; +else + inode->i_mapping->a_ops = &ext4_aops; } --To unsubscribe from this list: send the line "unsubscribe linux-ext4" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Theodore Ts'o
maintainerRe: [PATCH] ext4: fix overhead calculation in bigalloc filesystem (Re: ... )
Quoted 11 lines · Zheng Liu
Quoted 8 lines
If there was a mode that I'd be tempted to get rid of, it would be the combined data=ordered/data=writeback modes. The main reason why we keep it is because of a concern of buggy applications that depend on the implied
fsync()of data=ordered mode at each commit. However, ext4 has been around for long enough that I think most of the buggy applications have been fixed by now. And of course, those buggy applications will lose in the same way when they are using btrfs and xfs. Something to consider....IMHO, the application shouldn't depend on a kernel feature. So maybe it is time to highlight this buggy usage.
Oh, agreed. The question is how many people want us to keep the ext3 semantics to support those buggy applications. To the extent that distros are considering using ext4 to support ext3 file systems, there might be a desire to maintain (as closely as possible) ext3 semantics, even those that support buggy applications. The primary problem is that the when comes down to application developers versus file system
developers, the application developers vastly outnumber us. :-)
Quoted 2 lines
Just one minor comment below. Otherwise the patch looks good to me, and it can pass in xfstests with 'data=ordered' and 'data=writeback'.
I hadn't bothered testing it yet because I'm focused on testing and cleaning up the set of patches for the merge window --- and this change is clearly for the next merge window. Thanks for testing it!
Quoted 3 lines
Quoted 1 line
trace_ext4_ordered_write_end(inode, pos, len, copied);Here this function needs to be renamed with
trace_ext4_write_end().
Yes, agreed.
I also need to get rid of trace_ext4_writeback_write_end() in include/trace/events/ext4.h.
The other thing that needs to be done --- probably in a separate commit, just to make things easier to review for correctness, is now that we've folded ext4_writeback_write_end() and ext4_ordered_write_end() into a single function, we now have a single user of ext4_generic_write_end(), so we can now fold ext4_generic_write_end() into ext4_write_end().
- Ted
Re: [PATCH] ext4: fix overhead calculation in bigalloc filesystem (Re: ... )
Quoted 13 lines · Theodore Ts'o
Quoted 11 lines · Zheng Liu
Quoted 8 lines
If there was a mode that I'd be tempted to get rid of, it would be the combined data=ordered/data=writeback modes. The main reason why we keep it is because of a concern of buggy applications that depend on the implied
fsync()of data=ordered mode at each commit. However, ext4 has been around for long enough that I think most of the buggy applications have been fixed by now. And of course, those buggy applications will lose in the same way when they are using btrfs and xfs. Something to consider....IMHO, the application shouldn't depend on a kernel feature. So maybe it is time to highlight this buggy usage.
Quoted 7 lines
Oh, agreed. The question is how many people want us to keep the ext3 semantics to support those buggy applications. To the extent that distros are considering using ext4 to support ext3 file systems, there might be a desire to maintain (as closely as possible) ext3 semantics, even those that support buggy applications. The primary problem is that the when comes down to application developers versus file system
developers, the application developers vastly outnumber us. :-)
Yes, as file system developers we always need to meet the application developers' requirement. So it seems that we still need to keep it in ext4. :-)
Quoted 7 lines
Quoted 3 lines
Just one minor comment below. Otherwise the patch looks good to me, and it can pass in xfstests with 'data=ordered' and 'data=writeback'.
I hadn't bothered testing it yet because I'm focused on testing and cleaning up the set of patches for the merge window --- and this change is clearly for the next merge window. Thanks for testing it!
I guess you are busy testing patches for the merge window. One thing I need to let you know is this patch [1]. I really think it should be applied for this merge window because it fixes a security hole due to my fault. As commit log describes, a non-privilege user could cause system crash using a truncate(1) command. So please check it.
1. http://www.spinics.net/lists/linux-ext4/msg36784.html
Quoted 10 lines
Quoted 4 lines
Quoted 2 lines
trace_ext4_ordered_write_end(inode, pos, len, copied);Here this function needs to be renamed with
trace_ext4_write_end().Yes, agreed.
I also need to get rid of
trace_ext4_writeback_write_end()ininclude/trace/events/ext4.h.
Quoted 6 lines
The other thing that needs to be done --- probably in a separate commit, just to make things easier to review for correctness, is now that we've folded
ext4_writeback_write_end()andext4_ordered_write_end()into a single function, we now have a single user ofext4_generic_write_end(), so we can now foldext4_generic_write_end()intoext4_write_end().
Yes, we can take a close look at in next merge window.
Thanks,
- Zheng
PATCH 1/1 ext4: fold ext4_generic_write_end into ext4_write_end
In reply to Theodore Ts'oFrom: Zheng Liu <[email protected]>
After collpasing the handling of data ordered and data writeback codepath, ext4_generic_write_end has only one caller that is ext4_write_end. So we fold it into ext4_write_end.
---
This commit is against dev-test branch of ext4.
Regards,
- Zheng
fs/ext4/inode.c | 67 +++++++++++++++++++++++---------------------------------- 1 file changed, 27 insertions(+), 40 deletions(-)
fs/ext4/inode.c +27 -37
@@ -997,14 +997,32 @@ static int write_end_fn(handle_t *handle, struct buffer_head *bh)return ext4_handle_dirty_metadata (handle,NULL , bh); } -static int ext4_generic_write_end (struct file *file, -struct address_space *mapping, -loff_t pos,unsigned len,unsigned copied, -struct page *page,void *fsdata) +/* +* We need to pick up the new inode size which generic_commit_write gave us +* `file' can be NULL - eg, when called from page_symlink(). +* +* ext4 never places buffers on inode->i_mapping->private_list. metadata +* buffers are managed internally. +*/ +static int ext4_write_end (struct file *file, +struct address_space *mapping, +loff_t pos,unsigned len,unsigned copied, +struct page *page,void *fsdata) { -int i_size_changed =0 ; -struct inode *inode = mapping->host;handle_t *handle =ext4_journal_current_handle (); +struct inode *inode = mapping->host; +int ret =0 , ret2; +int i_size_changed =0 ; + +trace_ext4_write_end (inode, pos, len, copied); +if (ext4_test_inode_state (inode,EXT4_STATE_ORDERED_MODE )) { + ret =ext4_jbd2_file_inode (handle, inode); +if (ret) { +unlock_page (page); +page_cache_release (page); + goto errout; + } + }if (ext4_has_inline_data (inode)) copied = ext4_write_inline_data_end(inode, pos, len,
@@ -1015,7 +1033,7 @@ static int ext4_generic_write_end(struct file *file,/* * No need to use i_size_read() here, the i_size -* cannot change under us because we hold i_mutex. +* cannot change under us because we hole i_mutex. * * But it's important to update i_size while still holding page lock: * page writeout could otherwise come in and zero beyond i_size.
@@ -1025,10 +1043,10 @@ static int ext4_generic_write_end(struct file *file, i_size_changed =1 ; } -if (pos + copied >EXT4_I (inode)->i_disksize) { +if (pos + copied >EXT4_I (inode)->i_disksize) {/* We need to mark inode dirty even if * new_i_size is less that inode->i_size -* bu greater than i_disksize.(hint delalloc) +* but greater than i_disksize. (hint delalloc) */ ext4_update_i_disksize (inode, (pos + copied)); i_size_changed =1 ;
@@ -1045,37 +1063,6 @@ static int ext4_generic_write_end(struct file *file,if (i_size_changed)ext4_mark_inode_dirty (handle, inode); -return copied; -} - -/* -* We need to pick up the new inode size which generic_commit_write gave us -* `file' can be NULL - eg, when called from page_symlink(). -* -* ext4 never places buffers on inode->i_mapping->private_list. metadata -* buffers are managed internally. -*/ -static int ext4_write_end (struct file *file, -struct address_space *mapping, -loff_t pos,unsigned len,unsigned copied, -struct page *page,void *fsdata) -{ -handle_t *handle =ext4_journal_current_handle (); -struct inode *inode = mapping->host; -int ret =0 , ret2; - -trace_ext4_write_end (inode, pos, len, copied); -if (ext4_test_inode_state (inode,EXT4_STATE_ORDERED_MODE )) { - ret =ext4_jbd2_file_inode (handle, inode); -if (ret) { -unlock_page (page); -page_cache_release (page); - goto errout; - } - }
Re: [PATCH] ext4: fold ext4_generic_write_end into ext4_write_end
Quoted 8 lines · Zheng Liu
From: Zheng Liu <[email protected]>
After collpasing the handling of data ordered and data writeback codepath,
ext4_generic_write_endhas only one caller that isext4_write_end. So we fold it intoext4_write_end.Signed-off-by Zheng Liu <[email protected]>Cc "Theodore Ts'o" <[email protected]>
Applied, thanks.
- Ted
Re: [PATCH] ext4: fix overhead calculation in bigalloc filesystem (Re: ... )
In reply to Lukáš CzernerOn Thu, Feb 21, 2013 at 01:40:34PM +0100, Lukáš Czerner wrote:
[snip]
Quoted 9 lines
Hi Zheng,
thanks for the review. I know about the other issues and I'm trying to resolve those as well. Right now I have a patch which includes the changes
ext4_calculate_overhead()you've described below and more, but even with this I still see some problems remaining.Hopefully will send another patch soon.
Yeah, we will get a lot of xfstests failures about bigalloc feature when bigalloc and delalloc are enabled simultaneouly. So that would be great if we could fix these problems. Looking forward your patch. :-)
Regards,
- Zheng
Quoted 37 lines
Quoted 37 lines
Subject: [PATCH] ext4: fix overhead calculation in bigalloc filesystem
From: Zheng Liu <[email protected]>
ext4_calculate_overhead()should compute the overhead and stash it insbi->s_overhead. But we miss useEXT4_B2C()to calculate the number of clusters beforefirst_data_blockand the number of journal blocks. This commit useEXT4_NUM_B2C()instead ofEXT4_B2C()to calculate the overhead.Signed-off-by Zheng Liu <[email protected]>Cc "Theodore Ts'o" <[email protected]>--- fs/ext4/super.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)fs/ext4/super.c +2
-2@@ -3219,7 +3219,7 @@ int ext4_calculate_overhead(struct super_block *sb)/* * All of the blocks before first_data_block are overhead */ - overhead =EXT4_B2C (sbi,le32_to_cpu (es->s_first_data_block)); + overhead =EXT4_NUM_B2C (sbi,le32_to_cpu (es->s_first_data_block));/* * Add the overhead found in each block group @@ -3235,7 +3235,7 @@ int ext4_calculate_overhead(struct super_block *sb) }/* Add the journal blocks as well */ if (sbi->s_journal) - overhead +=EXT4_B2C (sbi, sbi->s_journal->j_maxlen); + overhead +=EXT4_NUM_B2C (sbi, sbi->s_journal->j_maxlen);
Quoted 3 lines
fs/ext4/super.c int ext4_calculate_overhead(struct super_block *sb) · line 3241
Quoted 3 lines
fs/ext4/super.c +0
-0sbi->s_overhead = overhead;smp_wmb ();
--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Theodore Ts'o
maintainerQuoted 4 lines · Lukas Czerner
Moreover when calculating number of root clusters we should be using macro
EXT4_NUM_B2C()instead ofEXT4_C2B()otherwise the result will usually be off by one.
That should be "instead of EXT4_B2C()", and I don't think this is true, since the number of blocks should always be a multiple of the cluster ratio. So the use of EXT4_B2C() is a bit of an optimization (it avoids an add and mask operation), but it's probably not a measurable optimizatoin in practice.
- Ted
Quoted 13 lines · Theodore Ts'o
Date: Fri, 22 Feb 2013 00:10:48 -0500
From: Theodore Ts'o <[email protected]>
To: Lukas Czerner <[email protected]>
Cc: [email protected]
Subject: Re: [PATCH] ext4: fix free clusters calculation in bigalloc
filesystemQuoted 4 lines · Lukas Czerner
Moreover when calculating number of root clusters we should be using macro
EXT4_NUM_B2C()instead ofEXT4_C2B()otherwise the result will usually be off by one.
Quoted 7 lines
That should be "instead of
EXT4_B2C()", and I don't think this is true, since the number of blocks should always be a multiple of the cluster ratio. So the use ofEXT4_B2C()is a bit of an optimization (it avoids an add and mask operation), but it's probably not a measurable optimizatoin in practice.- Ted
Oh right it was EXT4_B2C(), I'll update the description. Even though it should always be a multiple of cluster ratio it's really bad precedence for the use of EXT4_B2C() since it is confusing enough as it is with blocks/clusters.
I'll resend.
-Lukas
PATCH v2 1/1 ext4: fix free clusters calculation in bigalloc filesystem
In reply to Lukas Czernerext4_has_free_clusters() should tell us whether there is enough free clusters to allocate, however number of free clusters in the file system is converted to blocks using EXT4_C2B() which is not only wrong use of the macro (we should have used EXT4_NUM_B2C) but it's also completely wrong concept since everything else is in cluster units.
Moreover when calculating number of root clusters we should be using macro EXT4_NUM_B2C() instead of EXT4_B2C() otherwise the result might be off by one. However r_blocks_count should always be a multiple of the cluster ratio so doing a plain bit shift should be enough here. We avoid using EXT4_B2C() because it's confusing.
As a result of the first problem number of free clusters is much bigger than it should have been and ext4_has_free_clusters() would return 1 even if there is really not enough free clusters available.
Fix this by removing the EXT4_C2B() conversion of free clusters and using bit shift when calculating number of root clusters. This bug affects number of xfstests tests covering file system ENOSPC situation handling. With this patch most of the ENOSPC problems with bigalloc file system disappear, especially the errors caused by delayed allocation not having enough space when the actual allocation is finally requested.
---
v2: update description, use just bit shift to calculate root_clusters
fs/ext4/balloc.c | 9 +++++++-- 1 files changed, 7 insertions(+), 2 deletions(-)
fs/ext4/balloc.c +7 -2
@@ -482,11 +482,16 @@ static int ext4_has_free_clusters(struct ext4_sb_info *sbi, free_clusters =percpu_counter_read_positive (fcc); dirty_clusters =percpu_counter_read_positive (dcc); - root_clusters =EXT4_B2C (sbi,ext4_r_blocks_count (sbi->s_es)); + +/* +* r_blocks_count should always be multiple of the cluster ratio so +* we are safe to do a plane bit shift only. +*/ + root_clusters =ext4_r_blocks_count (sbi->s_es) >> sbi->s_cluster_bits;if (free_clusters - (nclusters + root_clusters + dirty_clusters) <EXT4_FREECLUSTERS_WATERMARK ) { - free_clusters =EXT4_C2B (sbi,percpu_counter_sum_positive (fcc)); + free_clusters =percpu_counter_sum_positive (fcc); dirty_clusters =percpu_counter_sum_positive (dcc); }/* Check whether we have space after accounting for current
Signature · 1 line
1.7.7.6