ext4: introduce reserved space

Currently in ENOSPC condition when writing into unwritten space, or
punching a hole, we might need to split the extent and grow extent tree.
However since we can not allocate any new metadata blocks we'll have to
zero out unwritten part of extent or punched out part of extent, or in
the worst case return ENOSPC even though use actually does not allocate
any space.

Also in delalloc path we do reserve metadata and data blocks for the
time we're going to write out, however metadata block reservation is
very tricky especially since we expect that logical connectivity implies
physical connectivity, however that might not be the case and hence we
might end up allocating more metadata blocks than previously reserved.
So in future, metadata reservation checks should be removed since we can
not assure that we do not under reserve.

And this is where reserved space comes into the picture. When mounting
the file system we slice off a little bit of the file system space (2%
or 4096 clusters, whichever is smaller) which can be then used for the
cases mentioned above to prevent costly zeroout, or unexpected ENOSPC.

The number of reserved clusters can be set via sysfs, however it can
never be bigger than number of free clusters in the file system.

Note that this patch fixes the failure of xfstest 274 as expected.

Signed-off-by: Lukas Czerner <lczerner@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
Reviewed-by: Carlos Maiolino <cmaiolino@redhat.com>

1 files changed, 18 insertions, 9 deletions

diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index ea607f907232..8b158ae2443b 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -1942,8 +1942,8 @@ prepend:
          * There is no free space in the found leaf.
          * We're gonna add a new leaf in the tree.
          */
-        if (flag & EXT4_GET_BLOCKS_PUNCH_OUT_EXT)
-                flags = EXT4_MB_USE_ROOT_BLOCKS;
+        if (flag & EXT4_GET_BLOCKS_METADATA_NOFAIL)
+                flags = EXT4_MB_USE_RESERVED;
         err = ext4_ext_create_new_leaf(handle, inode, flags, path, newext);
         if (err)
                 goto cleanup;
@@ -2729,12 +2729,14 @@ again:
 
                         /*
                          * Split the extent in two so that 'end' is the last
-                         * block in the first new extent
+                         * block in the first new extent. Also we should not
+                         * fail removing space due to ENOSPC so try to use
+                         * reserved block if that happens.
                          */
                         err = ext4_split_extent_at(handle, inode, path,
-                                                end + 1, split_flag,
-                                                EXT4_GET_BLOCKS_PRE_IO |
-                                                EXT4_GET_BLOCKS_PUNCH_OUT_EXT);
+                                        end + 1, split_flag,
+                                        EXT4_GET_BLOCKS_PRE_IO |
+                                        EXT4_GET_BLOCKS_METADATA_NOFAIL);
 
                         if (err < 0)
                                 goto out;
@@ -3209,7 +3211,8 @@ out:
 static int ext4_ext_convert_to_initialized(handle_t *handle,
                                            struct inode *inode,
                                            struct ext4_map_blocks *map,
-                                           struct ext4_ext_path *path)
+                                           struct ext4_ext_path *path,
+                                           int flags)
 {
         struct ext4_sb_info *sbi;
         struct ext4_extent_header *eh;
@@ -3435,7 +3438,7 @@ static int ext4_ext_convert_to_initialized(handle_t *handle,
         }
 
         allocated = ext4_split_extent(handle, inode, path,
-                                      &split_map, split_flag, 0);
+                                      &split_map, split_flag, flags);
         if (allocated < 0)
                 err = allocated;
 
@@ -3755,6 +3758,12 @@ ext4_ext_handle_uninitialized_extents(handle_t *handle, struct inode *inode,
                   flags, allocated);
         ext4_ext_show_leaf(inode, path);
 
+        /*
+         * When writing into uninitialized space, we should not fail to
+         * allocate metadata blocks for the new extent block if needed.
+         */
+        flags |= EXT4_GET_BLOCKS_METADATA_NOFAIL;
+
         trace_ext4_ext_handle_uninitialized_extents(inode, map, flags,
                                                     allocated, newblock);
 
@@ -3818,7 +3827,7 @@ ext4_ext_handle_uninitialized_extents(handle_t *handle, struct inode *inode,
         }
 
         /* buffered write, writepage time, convert*/
-        ret = ext4_ext_convert_to_initialized(handle, inode, map, path);
+        ret = ext4_ext_convert_to_initialized(handle, inode, map, path, flags);
         if (ret >= 0)
                 ext4_update_inode_fsync_trans(handle, inode, 1);
 out: