ext4: track all extent status in extent status tree

By recording the phycisal block and status, extent status tree is able
to track the status of every extents.  When we call _map_blocks
functions to lookup an extent or create a new written/unwritten/delayed
extent, this extent will be inserted into extent status tree.

We don't load all extents from disk in alloc_inode() because it costs
too much memory, and if a file is opened and closed frequently it will
takes too much time to load all extent information.  So currently when
we create/lookup an extent, this extent will be inserted into extent
status tree.  Hence, the extent status tree may not comprehensively
contain all of the extents found in the file.

Here a condition we need to take care is that an extent might contains
unwritten and delayed status simultaneously because an extent is delayed
allocated and could be allocated by fallocate.  At this time we need to
keep delayed status because later we need to update delayed reservation
space using it.

Signed-off-by: Zheng Liu <wenqing.lz@taobao.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
Cc: Jan kara <jack@suse.cz>

1 files changed, 15 insertions, 5 deletions

diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index cae8ae3c1746..be0b1b3eed97 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -2076,8 +2076,18 @@ static int ext4_fill_fiemap_extents(struct inode *inode,
                         break;
                 }
 
-                /* This is possible iff next == next_del == EXT_MAX_BLOCKS */
-                if (next == next_del) {
+                /*
+                 * This is possible iff next == next_del == EXT_MAX_BLOCKS.
+                 * we need to check next == EXT_MAX_BLOCKS because it is
+                 * possible that an extent is with unwritten and delayed
+                 * status due to when an extent is delayed allocated and
+                 * is allocated by fallocate status tree will track both of
+                 * them in a extent.
+                 *
+                 * So we could return a unwritten and delayed extent, and
+                 * its block is equal to 'next'.
+                 */
+                if (next == next_del && next == EXT_MAX_BLOCKS) {
                         flags |= FIEMAP_EXTENT_LAST;
                         if (unlikely(next_del != EXT_MAX_BLOCKS ||
                                      next != EXT_MAX_BLOCKS)) {
@@ -3522,9 +3532,9 @@ out:
  *
  * Return 1 if there is a delalloc block in the range, otherwise 0.
  */
-static int ext4_find_delalloc_range(struct inode *inode,
-                                    ext4_lblk_t lblk_start,
-                                    ext4_lblk_t lblk_end)
+int ext4_find_delalloc_range(struct inode *inode,
+                             ext4_lblk_t lblk_start,
+                             ext4_lblk_t lblk_end)
 {
         struct extent_status es;