btrfs: don't log unnecessary boundary keys when logging directory

Before we start to log dir index keys from a leaf, we check if there is a
previous index key, which normally is at the end of a leaf that was not
changed in the current transaction. Then we log that key and set the start
of logged range (item of type BTRFS_DIR_LOG_INDEX_KEY) to the offset of
that key. This is to ensure that if there were deleted index keys between
that key and the first key we are going to log, those deletions are
replayed in case we need to replay to the log after a power failure.
However we really don't need to log that previous key, we can just set the
start of the logged range to that key's offset plus 1. This achieves the
same and avoids logging one dir index key.

The same logic is performed when we finish logging the index keys of a
leaf and we find that the next leaf has index keys and was not changed in
the current transaction. We are logging the first key of that next leaf
and use its offset as the end of range we log. This is just to ensure that
if there were deleted index keys between the last index key we logged and
the first key of that next leaf, those index keys are deleted if we end
up replaying the log. However that is not necessary, we can avoid logging
that first index key of the next leaf and instead set the end of the
logged range to match the offset of that index key minus 1.

So avoid logging those index keys at the boundaries and adjust the start
and end offsets of the logged ranges as described above.

This patch is part of a patchset comprised of the following patches:

  1/4 btrfs: don't log unnecessary boundary keys when logging directory
  2/4 btrfs: put initial index value of a directory in a constant
  3/4 btrfs: stop copying old dir items when logging a directory
  4/4 btrfs: stop trying to log subdirectories created in past transactions

Performance test results are listed in the changelog of patch 3/4.

Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index be4f45e..8386e41 100644 (file)
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -3906,17 +3906,18 @@ static noinline int log_dir_items(struct btrfs_trans_handle *trans,
        ret = btrfs_previous_item(root, path, ino, BTRFS_DIR_INDEX_KEY);
        if (ret == 0) {
                struct btrfs_key tmp;
+
                btrfs_item_key_to_cpu(path->nodes[0], &tmp, path->slots[0]);
-               if (tmp.type == BTRFS_DIR_INDEX_KEY) {
-                       first_offset = tmp.offset;
-                       ret = overwrite_item(trans, log, dst_path,
-                                            path->nodes[0], path->slots[0],
-                                            &tmp);
-                       if (ret) {
-                               err = ret;
-                               goto done;
-                       }
-               }
+               /*
+                * The dir index key before the first one we found that needs to
+                * be logged might be in a previous leaf, and there might be a
+                * gap between these keys, meaning that we had deletions that
+                * happened. So the key range item we log (key type
+                * BTRFS_DIR_LOG_INDEX_KEY) must cover a range that starts at the
+                * previous key's offset plus 1, so that those deletes are replayed.
+                */
+               if (tmp.type == BTRFS_DIR_INDEX_KEY)
+                       first_offset = tmp.offset + 1;
        }
        btrfs_release_path(path);
 
@@ -3964,14 +3965,16 @@ search:
                        goto done;
                }
                if (btrfs_header_generation(path->nodes[0]) != trans->transid) {
-                       ctx->last_dir_item_offset = min_key.offset;
-                       ret = overwrite_item(trans, log, dst_path,
-                                            path->nodes[0], path->slots[0],
-                                            &min_key);
-                       if (ret)
-                               err = ret;
-                       else
-                               last_offset = min_key.offset;
+                       /*
+                        * The next leaf was not changed in the current transaction
+                        * and has at least one dir index key.
+                        * We check for the next key because there might have been
+                        * one or more deletions between the last key we logged and
+                        * that next key. So the key range item we log (key type
+                        * BTRFS_DIR_LOG_INDEX_KEY) must end at the next key's
+                        * offset minus 1, so that those deletes are replayed.
+                        */
+                       last_offset = min_key.offset - 1;
                        goto done;
                }
                if (need_resched()) {