ext4: add support for extent pre-caching

Add a new fiemap flag which forces the all of the extents in an inode
to be cached in the extent_status tree.  This is critically important
when using AIO to a preallocated file, since if we need to read in
blocks from the extent tree, the io_submit(2) system call becomes
synchronous, and the AIO is no longer "A", which is bad.

In addition, for most files which have an external leaf tree block,
the cost of caching the information in the extent status tree will be
less than caching the entire 4k block in the buffer cache.  So it is
generally a win to keep the extent information cached.

Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>

1 files changed, 51 insertions, 21 deletions

diff --git a/fs/ext4/extents_status.c b/fs/ext4/extents_status.c
index 1dc5df016e25..0e88a367b535 100644
--- a/fs/ext4/extents_status.c
+++ b/fs/ext4/extents_status.c
@@ -710,11 +710,8 @@ void ext4_es_cache_extent(struct inode *inode, ext4_lblk_t lblk,
         write_lock(&EXT4_I(inode)->i_es_lock);
 
         es = __es_tree_search(&EXT4_I(inode)->i_es_tree.root, lblk);
-        if (es && ((es->es_lblk <= lblk) || (es->es_lblk <= end)))
-                goto out;
-
-        __es_insert_extent(inode, &newes);
-out:
+        if (!es || es->es_lblk > end)
+                __es_insert_extent(inode, &newes);
         write_unlock(&EXT4_I(inode)->i_es_lock);
 }
 
@@ -930,6 +927,12 @@ static int ext4_inode_touch_time_cmp(void *priv, struct list_head *a,
         eia = list_entry(a, struct ext4_inode_info, i_es_lru);
         eib = list_entry(b, struct ext4_inode_info, i_es_lru);
 
+        if (ext4_test_inode_state(&eia->vfs_inode, EXT4_STATE_EXT_PRECACHED) &&
+            !ext4_test_inode_state(&eib->vfs_inode, EXT4_STATE_EXT_PRECACHED))
+                return 1;
+        if (!ext4_test_inode_state(&eia->vfs_inode, EXT4_STATE_EXT_PRECACHED) &&
+            ext4_test_inode_state(&eib->vfs_inode, EXT4_STATE_EXT_PRECACHED))
+                return -1;
         if (eia->i_touch_when == eib->i_touch_when)
                 return 0;
         if (time_after(eia->i_touch_when, eib->i_touch_when))
@@ -943,21 +946,13 @@ static int __ext4_es_shrink(struct ext4_sb_info *sbi, int nr_to_scan,
 {
         struct ext4_inode_info *ei;
         struct list_head *cur, *tmp;
-        LIST_HEAD(skiped);
+        LIST_HEAD(skipped);
         int ret, nr_shrunk = 0;
+        int retried = 0, skip_precached = 1, nr_skipped = 0;
 
         spin_lock(&sbi->s_es_lru_lock);
 
-        /*
-         * If the inode that is at the head of LRU list is newer than
-         * last_sorted time, that means that we need to sort this list.
-         */
-        ei = list_first_entry(&sbi->s_es_lru, struct ext4_inode_info, i_es_lru);
-        if (sbi->s_es_last_sorted < ei->i_touch_when) {
-                list_sort(NULL, &sbi->s_es_lru, ext4_inode_touch_time_cmp);
-                sbi->s_es_last_sorted = jiffies;
-        }
-
+retry:
         list_for_each_safe(cur, tmp, &sbi->s_es_lru) {
                 /*
                  * If we have already reclaimed all extents from extent
@@ -968,9 +963,16 @@ static int __ext4_es_shrink(struct ext4_sb_info *sbi, int nr_to_scan,
 
                 ei = list_entry(cur, struct ext4_inode_info, i_es_lru);
 
-                /* Skip the inode that is newer than the last_sorted time */
-                if (sbi->s_es_last_sorted < ei->i_touch_when) {
-                        list_move_tail(cur, &skiped);
+                /*
+                 * Skip the inode that is newer than the last_sorted
+                 * time.  Normally we try hard to avoid shrinking
+                 * precached inodes, but we will as a last resort.
+                 */
+                if ((sbi->s_es_last_sorted < ei->i_touch_when) ||
+                    (skip_precached && ext4_test_inode_state(&ei->vfs_inode,
+                                                EXT4_STATE_EXT_PRECACHED))) {
+                        nr_skipped++;
+                        list_move_tail(cur, &skipped);
                         continue;
                 }
 
@@ -990,11 +992,33 @@ static int __ext4_es_shrink(struct ext4_sb_info *sbi, int nr_to_scan,
         }
 
         /* Move the newer inodes into the tail of the LRU list. */
-        list_splice_tail(&skiped, &sbi->s_es_lru);
+        list_splice_tail(&skipped, &sbi->s_es_lru);
+        INIT_LIST_HEAD(&skipped);
+
+        /*
+         * If we skipped any inodes, and we weren't able to make any
+         * forward progress, sort the list and try again.
+         */
+        if ((nr_shrunk == 0) && nr_skipped && !retried) {
+                retried++;
+                list_sort(NULL, &sbi->s_es_lru, ext4_inode_touch_time_cmp);
+                sbi->s_es_last_sorted = jiffies;
+                ei = list_first_entry(&sbi->s_es_lru, struct ext4_inode_info,
+                                      i_es_lru);
+                /*
+                 * If there are no non-precached inodes left on the
+                 * list, start releasing precached extents.
+                 */
+                if (ext4_test_inode_state(&ei->vfs_inode,
+                                          EXT4_STATE_EXT_PRECACHED))
+                        skip_precached = 0;
+                goto retry;
+        }
+
         spin_unlock(&sbi->s_es_lru_lock);
 
         if (locked_ei && nr_shrunk == 0)
-                nr_shrunk = __es_try_to_reclaim_extents(ei, nr_to_scan);
+                nr_shrunk = __es_try_to_reclaim_extents(locked_ei, nr_to_scan);
 
         return nr_shrunk;
 }
@@ -1069,10 +1093,16 @@ static int __es_try_to_reclaim_extents(struct ext4_inode_info *ei,
         struct rb_node *node;
         struct extent_status *es;
         int nr_shrunk = 0;
+        static DEFINE_RATELIMIT_STATE(_rs, DEFAULT_RATELIMIT_INTERVAL,
+                                      DEFAULT_RATELIMIT_BURST);
 
         if (ei->i_es_lru_nr == 0)
                 return 0;
 
+        if (ext4_test_inode_state(inode, EXT4_STATE_EXT_PRECACHED) &&
+            __ratelimit(&_rs))
+                ext4_warning(inode->i_sb, "forced shrink of precached extents");
+
         node = rb_first(&tree->root);
         while (node != NULL) {
                 es = rb_entry(node, struct extent_status, rb_node);