btrfs: move btrfs_realloc_node() from ctree.c into defrag.c

[thirdparty/linux.git] / fs / btrfs / defrag.c

diff --git a/fs/btrfs/defrag.c b/fs/btrfs/defrag.c
index dde70f358d6ff937ec37a405258c15333cb8983c..f4f68438fc6975843f2e555793cd4ca535f53959 100644 (file)
--- a/fs/btrfs/defrag.c
+++ b/fs/btrfs/defrag.c
@@ -337,6 +337,111 @@ int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info)
        return 0;
 }
 
+/*
+ * Check if two blocks addresses are close, used by defrag.
+ */
+static bool close_blocks(u64 blocknr, u64 other, u32 blocksize)
+{
+       if (blocknr < other && other - (blocknr + blocksize) < SZ_32K)
+               return true;
+       if (blocknr > other && blocknr - (other + blocksize) < SZ_32K)
+               return true;
+       return false;
+}
+
+/*
+ * Go through all the leaves pointed to by a node and reallocate them so that
+ * disk order is close to key order.
+ */
+static int btrfs_realloc_node(struct btrfs_trans_handle *trans,
+                             struct btrfs_root *root,
+                             struct extent_buffer *parent,
+                             int start_slot, u64 *last_ret,
+                             struct btrfs_key *progress)
+{
+       struct btrfs_fs_info *fs_info = root->fs_info;
+       const u32 blocksize = fs_info->nodesize;
+       const int end_slot = btrfs_header_nritems(parent) - 1;
+       u64 search_start = *last_ret;
+       u64 last_block = 0;
+       int ret = 0;
+       bool progress_passed = false;
+
+       /*
+        * COWing must happen through a running transaction, which always
+        * matches the current fs generation (it's a transaction with a state
+        * less than TRANS_STATE_UNBLOCKED). If it doesn't, then turn the fs
+        * into error state to prevent the commit of any transaction.
+        */
+       if (unlikely(trans->transaction != fs_info->running_transaction ||
+                    trans->transid != fs_info->generation)) {
+               btrfs_abort_transaction(trans, -EUCLEAN);
+               btrfs_crit(fs_info,
+"unexpected transaction when attempting to reallocate parent %llu for root %llu, transaction %llu running transaction %llu fs generation %llu",
+                          parent->start, btrfs_root_id(root), trans->transid,
+                          fs_info->running_transaction->transid,
+                          fs_info->generation);
+               return -EUCLEAN;
+       }
+
+       if (btrfs_header_nritems(parent) <= 1)
+               return 0;
+
+       for (int i = start_slot; i <= end_slot; i++) {
+               struct extent_buffer *cur;
+               struct btrfs_disk_key disk_key;
+               u64 blocknr;
+               u64 other;
+               bool close = true;
+
+               btrfs_node_key(parent, &disk_key, i);
+               if (!progress_passed && btrfs_comp_keys(&disk_key, progress) < 0)
+                       continue;
+
+               progress_passed = true;
+               blocknr = btrfs_node_blockptr(parent, i);
+               if (last_block == 0)
+                       last_block = blocknr;
+
+               if (i > 0) {
+                       other = btrfs_node_blockptr(parent, i - 1);
+                       close = close_blocks(blocknr, other, blocksize);
+               }
+               if (!close && i < end_slot) {
+                       other = btrfs_node_blockptr(parent, i + 1);
+                       close = close_blocks(blocknr, other, blocksize);
+               }
+               if (close) {
+                       last_block = blocknr;
+                       continue;
+               }
+
+               cur = btrfs_read_node_slot(parent, i);
+               if (IS_ERR(cur))
+                       return PTR_ERR(cur);
+               if (search_start == 0)
+                       search_start = last_block;
+
+               btrfs_tree_lock(cur);
+               ret = btrfs_force_cow_block(trans, root, cur, parent, i,
+                                           &cur, search_start,
+                                           min(16 * blocksize,
+                                               (end_slot - i) * blocksize),
+                                           BTRFS_NESTING_COW);
+               if (ret) {
+                       btrfs_tree_unlock(cur);
+                       free_extent_buffer(cur);
+                       break;
+               }
+               search_start = cur->start;
+               last_block = cur->start;
+               *last_ret = search_start;
+               btrfs_tree_unlock(cur);
+               free_extent_buffer(cur);
+       }
+       return ret;
+}
+
 /*
  * Defrag all the leaves in a given btree.
  * Read all the leaves and try to get key order to