[PATCH 1/4] btrfs: split btrfs_insert_delayed_dir_index() into prealloc and commit phases
From: Jeff Layton
Date: Fri Jul 17 2026 - 12:53:33 EST
Split btrfs_insert_delayed_dir_index() into three functions using a new
btrfs_dir_index_prealloc struct to bundle the pre-allocated resources:
- btrfs_prealloc_delayed_dir_index(): performs the two GFP_NOFS
allocations (delayed node + delayed item) that can fail with -ENOMEM.
- btrfs_insert_delayed_dir_index_prealloc(): populates the item data,
inserts into the rb-tree, and reserves metadata space. Cannot fail
with -ENOMEM since all allocations were done in the prealloc step.
- btrfs_free_delayed_dir_index_prealloc(): frees pre-allocated
resources when the caller's btree insertion fails.
The original btrfs_insert_delayed_dir_index() is refactored into a thin
wrapper that calls the prealloc and commit functions.
This split allows callers to move the fallible memory allocations before
the point of no return (the DIR_ITEM btree insertion), so that -ENOMEM
can be returned cleanly without aborting the transaction.
Assisted-by: LLM
Signed-off-by: Jeff Layton <jlayton@xxxxxxxxxx>
---
fs/btrfs/delayed-inode.c | 109 ++++++++++++++++++++++++++++++++++++-----------
fs/btrfs/delayed-inode.h | 17 ++++++++
2 files changed, 102 insertions(+), 24 deletions(-)
diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index 09795439b9fb..9d7343934eea 100644
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -1469,35 +1469,73 @@ static void btrfs_release_dir_index_item_space(struct btrfs_trans_handle *trans)
trans->bytes_reserved -= bytes;
}
-/* Will return 0, -ENOMEM or -EEXIST (index number collision, unexpected). */
-int btrfs_insert_delayed_dir_index(struct btrfs_trans_handle *trans,
- const char *name, int name_len,
- struct btrfs_inode *dir,
- const struct btrfs_disk_key *disk_key, u8 flags,
- u64 index)
+/*
+ * Pre-allocate a delayed node and delayed item for a dir index insertion.
+ * Call this before modifying the btree so that ENOMEM can be returned
+ * before any on-disk state has changed.
+ *
+ * Returns 0 on success, -ENOMEM on allocation failure.
+ */
+int btrfs_prealloc_delayed_dir_index(struct btrfs_inode *dir,
+ const char *name, int name_len,
+ struct btrfs_dir_index_prealloc *prealloc)
+{
+ struct btrfs_delayed_node *node;
+ struct btrfs_delayed_item *item;
+
+ node = btrfs_get_or_create_delayed_node(dir, &prealloc->tracker);
+ if (IS_ERR(node))
+ return PTR_ERR(node);
+
+ item = btrfs_alloc_delayed_item(sizeof(struct btrfs_dir_item) + name_len,
+ node, BTRFS_DELAYED_INSERTION_ITEM);
+ if (!item) {
+ btrfs_release_delayed_node(node, &prealloc->tracker);
+ return -ENOMEM;
+ }
+
+ prealloc->node = node;
+ prealloc->item = item;
+ return 0;
+}
+
+/*
+ * Free resources from btrfs_prealloc_delayed_dir_index() when the btree
+ * insertion failed and we will not commit the delayed dir index.
+ */
+void btrfs_free_delayed_dir_index_prealloc(struct btrfs_trans_handle *trans,
+ struct btrfs_dir_index_prealloc *prealloc)
{
+ btrfs_release_delayed_item(prealloc->item);
+ btrfs_release_dir_index_item_space(trans);
+ btrfs_release_delayed_node(prealloc->node, &prealloc->tracker);
+}
+
+/*
+ * Commit a pre-allocated delayed dir index item. The delayed node and item
+ * must have been returned by btrfs_prealloc_delayed_dir_index(). This
+ * populates the item, adds it to the delayed node's rb-tree, and reserves
+ * metadata space. It cannot fail with ENOMEM.
+ *
+ * Will return 0 or -EEXIST (index number collision, unexpected).
+ */
+int btrfs_insert_delayed_dir_index_prealloc(struct btrfs_trans_handle *trans,
+ struct btrfs_inode *dir,
+ struct btrfs_dir_index_prealloc *prealloc,
+ const struct btrfs_disk_key *disk_key,
+ u8 flags, u64 index)
+{
+ struct btrfs_delayed_node *delayed_node = prealloc->node;
+ struct btrfs_ref_tracker *tracker = &prealloc->tracker;
+ struct btrfs_delayed_item *delayed_item = prealloc->item;
struct btrfs_fs_info *fs_info = trans->fs_info;
const unsigned int leaf_data_size = BTRFS_LEAF_DATA_SIZE(fs_info);
- struct btrfs_delayed_node *delayed_node;
- struct btrfs_ref_tracker delayed_node_tracker;
- struct btrfs_delayed_item *delayed_item;
+ const int name_len = delayed_item->data_len - sizeof(struct btrfs_dir_item);
struct btrfs_dir_item *dir_item;
bool reserve_leaf_space;
u32 data_len;
int ret;
- delayed_node = btrfs_get_or_create_delayed_node(dir, &delayed_node_tracker);
- if (IS_ERR(delayed_node))
- return PTR_ERR(delayed_node);
-
- delayed_item = btrfs_alloc_delayed_item(sizeof(*dir_item) + name_len,
- delayed_node,
- BTRFS_DELAYED_INSERTION_ITEM);
- if (!delayed_item) {
- ret = -ENOMEM;
- goto release_node;
- }
-
delayed_item->index = index;
dir_item = (struct btrfs_dir_item *)delayed_item->data;
@@ -1506,7 +1544,7 @@ int btrfs_insert_delayed_dir_index(struct btrfs_trans_handle *trans,
btrfs_set_stack_dir_data_len(dir_item, 0);
btrfs_set_stack_dir_name_len(dir_item, name_len);
btrfs_set_stack_dir_flags(dir_item, flags);
- memcpy((char *)(dir_item + 1), name, name_len);
+ /* Name was already copied into delayed_item->data by the caller. */
data_len = delayed_item->data_len + sizeof(struct btrfs_item);
@@ -1524,7 +1562,9 @@ int btrfs_insert_delayed_dir_index(struct btrfs_trans_handle *trans,
if (unlikely(ret)) {
btrfs_err(trans->fs_info,
"error adding delayed dir index item, name: %.*s, index: %llu, root: %llu, dir: %llu, dir->index_cnt: %llu, delayed_node->index_cnt: %llu, error: %d",
- name_len, name, index, btrfs_root_id(delayed_node->root),
+ name_len,
+ (const char *)(dir_item + 1),
+ index, btrfs_root_id(delayed_node->root),
delayed_node->inode_id, dir->index_cnt,
delayed_node->index_cnt, ret);
btrfs_release_delayed_item(delayed_item);
@@ -1562,10 +1602,31 @@ int btrfs_insert_delayed_dir_index(struct btrfs_trans_handle *trans,
mutex_unlock(&delayed_node->mutex);
release_node:
- btrfs_release_delayed_node(delayed_node, &delayed_node_tracker);
+ btrfs_release_delayed_node(delayed_node, tracker);
return ret;
}
+/* Will return 0, -ENOMEM or -EEXIST (index number collision, unexpected). */
+int btrfs_insert_delayed_dir_index(struct btrfs_trans_handle *trans,
+ const char *name, int name_len,
+ struct btrfs_inode *dir,
+ const struct btrfs_disk_key *disk_key, u8 flags,
+ u64 index)
+{
+ struct btrfs_dir_index_prealloc prealloc;
+ int ret;
+
+ ret = btrfs_prealloc_delayed_dir_index(dir, name, name_len, &prealloc);
+ if (ret)
+ return ret;
+
+ memcpy(prealloc.item->data + sizeof(struct btrfs_dir_item), name,
+ name_len);
+
+ return btrfs_insert_delayed_dir_index_prealloc(trans, dir, &prealloc,
+ disk_key, flags, index);
+}
+
static bool btrfs_delete_delayed_insertion_item(struct btrfs_delayed_node *node,
u64 index)
{
diff --git a/fs/btrfs/delayed-inode.h b/fs/btrfs/delayed-inode.h
index fc752863f89b..e310a257c9a6 100644
--- a/fs/btrfs/delayed-inode.h
+++ b/fs/btrfs/delayed-inode.h
@@ -121,6 +121,23 @@ int btrfs_insert_delayed_dir_index(struct btrfs_trans_handle *trans,
const struct btrfs_disk_key *disk_key, u8 flags,
u64 index);
+struct btrfs_dir_index_prealloc {
+ struct btrfs_delayed_node *node;
+ struct btrfs_ref_tracker tracker;
+ struct btrfs_delayed_item *item;
+};
+
+int btrfs_prealloc_delayed_dir_index(struct btrfs_inode *dir,
+ const char *name, int name_len,
+ struct btrfs_dir_index_prealloc *prealloc);
+void btrfs_free_delayed_dir_index_prealloc(struct btrfs_trans_handle *trans,
+ struct btrfs_dir_index_prealloc *prealloc);
+int btrfs_insert_delayed_dir_index_prealloc(struct btrfs_trans_handle *trans,
+ struct btrfs_inode *dir,
+ struct btrfs_dir_index_prealloc *prealloc,
+ const struct btrfs_disk_key *disk_key,
+ u8 flags, u64 index);
+
int btrfs_delete_delayed_dir_index(struct btrfs_trans_handle *trans,
struct btrfs_inode *dir, u64 index);
--
2.55.0