* [PATCH] ext4: Allocate entire range in zero range
@ 2015-02-18 14:35 Lukas Czerner
0 siblings, 0 replies; 6+ messages in thread
From: Lukas Czerner @ 2015-02-18 14:35 UTC (permalink / raw)
To: linux-ext4; +Cc: Lukas Czerner
Currently there is a bug in zero range code which causes zero range
calls to only allocate block aligned portion of the range, while
ignoring the rest in some cases.
In some cases, namely if the end of the range is past isize, we do
attempt to preallocate the last nonaligned block. However this might
cause kernel to BUG() in some carefully designed zero range requests on
setups where page size > block size.
Fix this problem by first preallocating the entire range, including the
nonaligned edges and converting the written extents to unwritten in the
next step. This approach will also give us the advantage of having the
range to be as linearly contiguous as possible.
Signed-off-by: Lukas Czerner <lczerner@redhat.com>
---
fs/ext4/extents.c | 31 +++++++++++++++++++------------
1 file changed, 19 insertions(+), 12 deletions(-)
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index bed4308..aa52242 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -4803,12 +4803,6 @@ static long ext4_zero_range(struct file *file, loff_t offset,
else
max_blocks -= lblk;
- flags = EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT |
- EXT4_GET_BLOCKS_CONVERT_UNWRITTEN |
- EXT4_EX_NOCACHE;
- if (mode & FALLOC_FL_KEEP_SIZE)
- flags |= EXT4_GET_BLOCKS_KEEP_SIZE;
-
mutex_lock(&inode->i_mutex);
/*
@@ -4825,15 +4819,28 @@ static long ext4_zero_range(struct file *file, loff_t offset,
ret = inode_newsize_ok(inode, new_size);
if (ret)
goto out_mutex;
- /*
- * If we have a partial block after EOF we have to allocate
- * the entire block.
- */
- if (partial_end)
- max_blocks += 1;
}
+ flags = EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT;
+ if (mode & FALLOC_FL_KEEP_SIZE)
+ flags |= EXT4_GET_BLOCKS_KEEP_SIZE;
+
+ /* Preallocate the range including the unaligned edges */
+ if (partial_begin || partial_end) {
+ ret = ext4_alloc_file_blocks(file,
+ round_down(offset, 1 << blkbits) >> blkbits,
+ (round_up((offset + len), 1 << blkbits) -
+ round_down(offset, 1 << blkbits)) >> blkbits,
+ new_size, flags, mode);
+ if (ret)
+ goto out_mutex;
+
+ }
+
+ /* Zero range excluding the unaligned edges */
if (max_blocks > 0) {
+ flags |= (EXT4_GET_BLOCKS_CONVERT_UNWRITTEN |
+ EXT4_EX_NOCACHE);
/* Now release the pages and zero block aligned part of pages*/
truncate_pagecache_range(inode, start, end - 1);
--
1.8.3.1
^ permalink raw reply related [flat|nested] 6+ messages in thread
* Re: [PATCH] ext4: Allocate entire range in zero range
2015-02-18 16:49 Lukas Czerner
2015-02-19 0:49 ` Dave Chinner
2015-03-05 11:43 ` Lukáš Czerner
@ 2015-04-03 4:11 ` Theodore Ts'o
2 siblings, 0 replies; 6+ messages in thread
From: Theodore Ts'o @ 2015-04-03 4:11 UTC (permalink / raw)
To: Lukas Czerner; +Cc: linux-ext4
On Wed, Feb 18, 2015 at 05:49:28PM +0100, Lukas Czerner wrote:
> Currently there is a bug in zero range code which causes zero range
> calls to only allocate block aligned portion of the range, while
> ignoring the rest in some cases.
>
> In some cases, namely if the end of the range is past isize, we do
> attempt to preallocate the last nonaligned block. However this might
> cause kernel to BUG() in some carefully designed zero range requests on
> setups where page size > block size.
>
> Fix this problem by first preallocating the entire range, including the
> nonaligned edges and converting the written extents to unwritten in the
> next step. This approach will also give us the advantage of having the
> range to be as linearly contiguous as possible.
>
> Signed-off-by: Lukas Czerner <lczerner@redhat.com>
Thanks, applied. Apologies for the delay.
- Ted
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH] ext4: Allocate entire range in zero range
2015-02-18 16:49 Lukas Czerner
2015-02-19 0:49 ` Dave Chinner
@ 2015-03-05 11:43 ` Lukáš Czerner
2015-04-03 4:11 ` Theodore Ts'o
2 siblings, 0 replies; 6+ messages in thread
From: Lukáš Czerner @ 2015-03-05 11:43 UTC (permalink / raw)
To: linux-ext4; +Cc: esandeen, tytso
Eric, can I get some review on this one ?
Ted, I think this is quite critical, could you please ACK this one
so we know whether it's going in or not ?
Thanks!
-Lukas
On Wed, 18 Feb 2015, Lukas Czerner wrote:
> Date: Wed, 18 Feb 2015 17:49:28 +0100
> From: Lukas Czerner <lczerner@redhat.com>
> To: linux-ext4@vger.kernel.org
> Cc: Lukas Czerner <lczerner@redhat.com>
> Subject: [PATCH] ext4: Allocate entire range in zero range
>
> Currently there is a bug in zero range code which causes zero range
> calls to only allocate block aligned portion of the range, while
> ignoring the rest in some cases.
>
> In some cases, namely if the end of the range is past isize, we do
> attempt to preallocate the last nonaligned block. However this might
> cause kernel to BUG() in some carefully designed zero range requests on
> setups where page size > block size.
>
> Fix this problem by first preallocating the entire range, including the
> nonaligned edges and converting the written extents to unwritten in the
> next step. This approach will also give us the advantage of having the
> range to be as linearly contiguous as possible.
>
> Signed-off-by: Lukas Czerner <lczerner@redhat.com>
> ---
> fs/ext4/extents.c | 31 +++++++++++++++++++------------
> 1 file changed, 19 insertions(+), 12 deletions(-)
>
> diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
> index bed4308..aa52242 100644
> --- a/fs/ext4/extents.c
> +++ b/fs/ext4/extents.c
> @@ -4803,12 +4803,6 @@ static long ext4_zero_range(struct file *file, loff_t offset,
> else
> max_blocks -= lblk;
>
> - flags = EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT |
> - EXT4_GET_BLOCKS_CONVERT_UNWRITTEN |
> - EXT4_EX_NOCACHE;
> - if (mode & FALLOC_FL_KEEP_SIZE)
> - flags |= EXT4_GET_BLOCKS_KEEP_SIZE;
> -
> mutex_lock(&inode->i_mutex);
>
> /*
> @@ -4825,15 +4819,28 @@ static long ext4_zero_range(struct file *file, loff_t offset,
> ret = inode_newsize_ok(inode, new_size);
> if (ret)
> goto out_mutex;
> - /*
> - * If we have a partial block after EOF we have to allocate
> - * the entire block.
> - */
> - if (partial_end)
> - max_blocks += 1;
> }
>
> + flags = EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT;
> + if (mode & FALLOC_FL_KEEP_SIZE)
> + flags |= EXT4_GET_BLOCKS_KEEP_SIZE;
> +
> + /* Preallocate the range including the unaligned edges */
> + if (partial_begin || partial_end) {
> + ret = ext4_alloc_file_blocks(file,
> + round_down(offset, 1 << blkbits) >> blkbits,
> + (round_up((offset + len), 1 << blkbits) -
> + round_down(offset, 1 << blkbits)) >> blkbits,
> + new_size, flags, mode);
> + if (ret)
> + goto out_mutex;
> +
> + }
> +
> + /* Zero range excluding the unaligned edges */
> if (max_blocks > 0) {
> + flags |= (EXT4_GET_BLOCKS_CONVERT_UNWRITTEN |
> + EXT4_EX_NOCACHE);
>
> /* Now release the pages and zero block aligned part of pages*/
> truncate_pagecache_range(inode, start, end - 1);
>
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH] ext4: Allocate entire range in zero range
2015-02-19 0:49 ` Dave Chinner
@ 2015-02-19 11:31 ` Lukas Czerner
0 siblings, 0 replies; 6+ messages in thread
From: Lukas Czerner @ 2015-02-19 11:31 UTC (permalink / raw)
To: Dave Chinner; +Cc: linux-ext4
Hi Dave,
yes I am planning to send a regression test for this case as well.
Thanks!
-Lukas
----- Original Message -----
From: "Dave Chinner" <david@fromorbit.com>
To: "Lukas Czerner" <lczerner@redhat.com>
Cc: linux-ext4@vger.kernel.org
Sent: Thursday, February 19, 2015 1:49:35 AM
Subject: Re: [PATCH] ext4: Allocate entire range in zero range
On Wed, Feb 18, 2015 at 05:49:28PM +0100, Lukas Czerner wrote:
> Currently there is a bug in zero range code which causes zero range
> calls to only allocate block aligned portion of the range, while
> ignoring the rest in some cases.
>
> In some cases, namely if the end of the range is past isize, we do
> attempt to preallocate the last nonaligned block. However this might
> cause kernel to BUG() in some carefully designed zero range requests on
> setups where page size > block size.
Is there a regression test you could write to exercise these casesi
in future?
Cheers,
Dave.
--
Dave Chinner
david@fromorbit.com
--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH] ext4: Allocate entire range in zero range
2015-02-18 16:49 Lukas Czerner
@ 2015-02-19 0:49 ` Dave Chinner
2015-02-19 11:31 ` Lukas Czerner
2015-03-05 11:43 ` Lukáš Czerner
2015-04-03 4:11 ` Theodore Ts'o
2 siblings, 1 reply; 6+ messages in thread
From: Dave Chinner @ 2015-02-19 0:49 UTC (permalink / raw)
To: Lukas Czerner; +Cc: linux-ext4
On Wed, Feb 18, 2015 at 05:49:28PM +0100, Lukas Czerner wrote:
> Currently there is a bug in zero range code which causes zero range
> calls to only allocate block aligned portion of the range, while
> ignoring the rest in some cases.
>
> In some cases, namely if the end of the range is past isize, we do
> attempt to preallocate the last nonaligned block. However this might
> cause kernel to BUG() in some carefully designed zero range requests on
> setups where page size > block size.
Is there a regression test you could write to exercise these casesi
in future?
Cheers,
Dave.
--
Dave Chinner
david@fromorbit.com
^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH] ext4: Allocate entire range in zero range
@ 2015-02-18 16:49 Lukas Czerner
2015-02-19 0:49 ` Dave Chinner
` (2 more replies)
0 siblings, 3 replies; 6+ messages in thread
From: Lukas Czerner @ 2015-02-18 16:49 UTC (permalink / raw)
To: linux-ext4; +Cc: Lukas Czerner
Currently there is a bug in zero range code which causes zero range
calls to only allocate block aligned portion of the range, while
ignoring the rest in some cases.
In some cases, namely if the end of the range is past isize, we do
attempt to preallocate the last nonaligned block. However this might
cause kernel to BUG() in some carefully designed zero range requests on
setups where page size > block size.
Fix this problem by first preallocating the entire range, including the
nonaligned edges and converting the written extents to unwritten in the
next step. This approach will also give us the advantage of having the
range to be as linearly contiguous as possible.
Signed-off-by: Lukas Czerner <lczerner@redhat.com>
---
fs/ext4/extents.c | 31 +++++++++++++++++++------------
1 file changed, 19 insertions(+), 12 deletions(-)
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index bed4308..aa52242 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -4803,12 +4803,6 @@ static long ext4_zero_range(struct file *file, loff_t offset,
else
max_blocks -= lblk;
- flags = EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT |
- EXT4_GET_BLOCKS_CONVERT_UNWRITTEN |
- EXT4_EX_NOCACHE;
- if (mode & FALLOC_FL_KEEP_SIZE)
- flags |= EXT4_GET_BLOCKS_KEEP_SIZE;
-
mutex_lock(&inode->i_mutex);
/*
@@ -4825,15 +4819,28 @@ static long ext4_zero_range(struct file *file, loff_t offset,
ret = inode_newsize_ok(inode, new_size);
if (ret)
goto out_mutex;
- /*
- * If we have a partial block after EOF we have to allocate
- * the entire block.
- */
- if (partial_end)
- max_blocks += 1;
}
+ flags = EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT;
+ if (mode & FALLOC_FL_KEEP_SIZE)
+ flags |= EXT4_GET_BLOCKS_KEEP_SIZE;
+
+ /* Preallocate the range including the unaligned edges */
+ if (partial_begin || partial_end) {
+ ret = ext4_alloc_file_blocks(file,
+ round_down(offset, 1 << blkbits) >> blkbits,
+ (round_up((offset + len), 1 << blkbits) -
+ round_down(offset, 1 << blkbits)) >> blkbits,
+ new_size, flags, mode);
+ if (ret)
+ goto out_mutex;
+
+ }
+
+ /* Zero range excluding the unaligned edges */
if (max_blocks > 0) {
+ flags |= (EXT4_GET_BLOCKS_CONVERT_UNWRITTEN |
+ EXT4_EX_NOCACHE);
/* Now release the pages and zero block aligned part of pages*/
truncate_pagecache_range(inode, start, end - 1);
--
1.8.3.1
^ permalink raw reply related [flat|nested] 6+ messages in thread
end of thread, other threads:[~2015-04-03 4:11 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2015-02-18 14:35 [PATCH] ext4: Allocate entire range in zero range Lukas Czerner
2015-02-18 16:49 Lukas Czerner
2015-02-19 0:49 ` Dave Chinner
2015-02-19 11:31 ` Lukas Czerner
2015-03-05 11:43 ` Lukáš Czerner
2015-04-03 4:11 ` Theodore Ts'o
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.