* [PATCH v2 1/5] btrfs: use an on-stack path in btrfs_insert_orphan_item()
2026-08-04 15:44 [PATCH v2 0/5] btrfs: handle -ENOMEM errors in some synchronous dirops without aborting Jeff Layton
@ 2026-08-04 15:44 ` Jeff Layton
2026-08-04 23:18 ` Qu Wenruo
2026-08-04 15:44 ` [PATCH v2 2/5] btrfs: split btrfs_insert_delayed_dir_index() into prealloc and commit phases Jeff Layton
` (3 subsequent siblings)
4 siblings, 1 reply; 13+ messages in thread
From: Jeff Layton @ 2026-08-04 15:44 UTC (permalink / raw)
To: Chris Mason, David Sterba
Cc: Qu Wenruo, linux-btrfs, linux-kernel, kernel-team, Jeff Layton
btrfs_insert_orphan_item() allocated a btrfs_path with btrfs_alloc_path()
which returns -ENOMEM on failure. It is called from btrfs_orphan_add(),
so a path allocation failure there turns a recoverable error into a
transaction abort.
btrfs_path is only ~112 bytes, so allocate it on the stack instead.
Assisted-by: LLM
Suggested-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: Jeff Layton <jlayton@kernel.org>
---
fs/btrfs/orphan.c | 11 +++++------
1 file changed, 5 insertions(+), 6 deletions(-)
diff --git a/fs/btrfs/orphan.c b/fs/btrfs/orphan.c
index 9f3ad124104f..72e1adec39d8 100644
--- a/fs/btrfs/orphan.c
+++ b/fs/btrfs/orphan.c
@@ -9,18 +9,17 @@
int btrfs_insert_orphan_item(struct btrfs_trans_handle *trans,
struct btrfs_root *root, u64 offset)
{
- BTRFS_PATH_AUTO_FREE(path);
+ struct btrfs_path path = { 0 };
struct btrfs_key key;
+ int ret;
key.objectid = BTRFS_ORPHAN_OBJECTID;
key.type = BTRFS_ORPHAN_ITEM_KEY;
key.offset = offset;
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
-
- return btrfs_insert_empty_item(trans, root, path, &key, 0);
+ ret = btrfs_insert_empty_item(trans, root, &path, &key, 0);
+ btrfs_release_path(&path);
+ return ret;
}
int btrfs_del_orphan_item(struct btrfs_trans_handle *trans,
--
2.55.0
^ permalink raw reply related [flat|nested] 13+ messages in thread* Re: [PATCH v2 1/5] btrfs: use an on-stack path in btrfs_insert_orphan_item()
2026-08-04 15:44 ` [PATCH v2 1/5] btrfs: use an on-stack path in btrfs_insert_orphan_item() Jeff Layton
@ 2026-08-04 23:18 ` Qu Wenruo
0 siblings, 0 replies; 13+ messages in thread
From: Qu Wenruo @ 2026-08-04 23:18 UTC (permalink / raw)
To: Jeff Layton, Chris Mason, David Sterba
Cc: linux-btrfs, linux-kernel, kernel-team
在 2026/8/5 01:14, Jeff Layton 写道:
> btrfs_insert_orphan_item() allocated a btrfs_path with btrfs_alloc_path()
> which returns -ENOMEM on failure. It is called from btrfs_orphan_add(),
> so a path allocation failure there turns a recoverable error into a
> transaction abort.
>
> btrfs_path is only ~112 bytes, so allocate it on the stack instead.
>
> Assisted-by: LLM
> Suggested-by: Qu Wenruo <wqu@suse.com>
> Signed-off-by: Jeff Layton <jlayton@kernel.org>
Reviewed-by: Qu Wenruo <wqu@suse.com>
Thanks,
Qu
> ---
> fs/btrfs/orphan.c | 11 +++++------
> 1 file changed, 5 insertions(+), 6 deletions(-)
>
> diff --git a/fs/btrfs/orphan.c b/fs/btrfs/orphan.c
> index 9f3ad124104f..72e1adec39d8 100644
> --- a/fs/btrfs/orphan.c
> +++ b/fs/btrfs/orphan.c
> @@ -9,18 +9,17 @@
> int btrfs_insert_orphan_item(struct btrfs_trans_handle *trans,
> struct btrfs_root *root, u64 offset)
> {
> - BTRFS_PATH_AUTO_FREE(path);
> + struct btrfs_path path = { 0 };
> struct btrfs_key key;
> + int ret;
>
> key.objectid = BTRFS_ORPHAN_OBJECTID;
> key.type = BTRFS_ORPHAN_ITEM_KEY;
> key.offset = offset;
>
> - path = btrfs_alloc_path();
> - if (!path)
> - return -ENOMEM;
> -
> - return btrfs_insert_empty_item(trans, root, path, &key, 0);
> + ret = btrfs_insert_empty_item(trans, root, &path, &key, 0);
> + btrfs_release_path(&path);
> + return ret;
> }
>
> int btrfs_del_orphan_item(struct btrfs_trans_handle *trans,
>
^ permalink raw reply [flat|nested] 13+ messages in thread
* [PATCH v2 2/5] btrfs: split btrfs_insert_delayed_dir_index() into prealloc and commit phases
2026-08-04 15:44 [PATCH v2 0/5] btrfs: handle -ENOMEM errors in some synchronous dirops without aborting Jeff Layton
2026-08-04 15:44 ` [PATCH v2 1/5] btrfs: use an on-stack path in btrfs_insert_orphan_item() Jeff Layton
@ 2026-08-04 15:44 ` Jeff Layton
2026-08-04 23:14 ` Qu Wenruo
2026-08-04 15:44 ` [PATCH v2 3/5] btrfs: pre-allocate delayed dir index before btree modification Jeff Layton
` (2 subsequent siblings)
4 siblings, 1 reply; 13+ messages in thread
From: Jeff Layton @ 2026-08-04 15:44 UTC (permalink / raw)
To: Chris Mason, David Sterba
Cc: Qu Wenruo, linux-btrfs, linux-kernel, kernel-team, Jeff Layton
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@kernel.org>
---
fs/btrfs/delayed-inode.c | 111 +++++++++++++++++++++++++++++++++++++----------
fs/btrfs/delayed-inode.h | 17 ++++++++
2 files changed, 104 insertions(+), 24 deletions(-)
diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index db2ffab0941a..95d2dca80444 100644
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -6,6 +6,7 @@
#include <linux/slab.h>
#include <linux/iversion.h>
+#include <linux/error-injection.h>
#include "ctree.h"
#include "fs.h"
#include "messages.h"
@@ -1469,35 +1470,74 @@ 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;
+}
+ALLOW_ERROR_INJECTION(btrfs_prealloc_delayed_dir_index, ERRNO);
+
+/*
+ * 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 +1546,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 +1564,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: %pe",
- 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, ERR_PTR(ret));
btrfs_release_delayed_item(delayed_item);
@@ -1562,10 +1604,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
^ permalink raw reply related [flat|nested] 13+ messages in thread* Re: [PATCH v2 2/5] btrfs: split btrfs_insert_delayed_dir_index() into prealloc and commit phases
2026-08-04 15:44 ` [PATCH v2 2/5] btrfs: split btrfs_insert_delayed_dir_index() into prealloc and commit phases Jeff Layton
@ 2026-08-04 23:14 ` Qu Wenruo
2026-08-05 11:54 ` Jeff Layton
0 siblings, 1 reply; 13+ messages in thread
From: Qu Wenruo @ 2026-08-04 23:14 UTC (permalink / raw)
To: Jeff Layton, Chris Mason, David Sterba
Cc: linux-btrfs, linux-kernel, kernel-team
在 2026/8/5 01:14, Jeff Layton 写道:
> 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@kernel.org>
> ---
> fs/btrfs/delayed-inode.c | 111 +++++++++++++++++++++++++++++++++++++----------
> fs/btrfs/delayed-inode.h | 17 ++++++++
> 2 files changed, 104 insertions(+), 24 deletions(-)
>
> diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
> index db2ffab0941a..95d2dca80444 100644
> --- a/fs/btrfs/delayed-inode.c
> +++ b/fs/btrfs/delayed-inode.c
> @@ -6,6 +6,7 @@
>
> #include <linux/slab.h>
> #include <linux/iversion.h>
> +#include <linux/error-injection.h>
> #include "ctree.h"
> #include "fs.h"
> #include "messages.h"
> @@ -1469,35 +1470,74 @@ 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)
We can directly return a btrfs_dir_index_prealloc pointer, which reduce
the parameter list.
Otherwise looks good to me.
Reviewed-by: Qu Wenruo <wqu@suse.com>
Thanks,
Qu
^ permalink raw reply [flat|nested] 13+ messages in thread
* Re: [PATCH v2 2/5] btrfs: split btrfs_insert_delayed_dir_index() into prealloc and commit phases
2026-08-04 23:14 ` Qu Wenruo
@ 2026-08-05 11:54 ` Jeff Layton
2026-08-05 22:34 ` Qu Wenruo
0 siblings, 1 reply; 13+ messages in thread
From: Jeff Layton @ 2026-08-05 11:54 UTC (permalink / raw)
To: Qu Wenruo, Chris Mason, David Sterba
Cc: linux-btrfs, linux-kernel, kernel-team
On Wed, 2026-08-05 at 08:44 +0930, 'Qu Wenruo' via Kernel Team wrote:
>
> 在 2026/8/5 01:14, Jeff Layton 写道:
> > 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@kernel.org>
> > ---
> > fs/btrfs/delayed-inode.c | 111 +++++++++++++++++++++++++++++++++++++----------
> > fs/btrfs/delayed-inode.h | 17 ++++++++
> > 2 files changed, 104 insertions(+), 24 deletions(-)
> >
> > diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
> > index db2ffab0941a..95d2dca80444 100644
> > --- a/fs/btrfs/delayed-inode.c
> > +++ b/fs/btrfs/delayed-inode.c
> > @@ -6,6 +6,7 @@
> >
> > #include <linux/slab.h>
> > #include <linux/iversion.h>
> > +#include <linux/error-injection.h>
> > #include "ctree.h"
> > #include "fs.h"
> > #include "messages.h"
> > @@ -1469,35 +1470,74 @@ 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)
>
> We can directly return a btrfs_dir_index_prealloc pointer, which reduce
> the parameter list.
>
...but then we'd have to allocate it separately. It's currently
allocated on the stack by the caller. I think we ought to keep it this
way, but I'm willing to be convinced otherwise.
> Otherwise looks good to me.
>
> Reviewed-by: Qu Wenruo <wqu@suse.com>
>
--
Jeff Layton <jlayton@kernel.org>
^ permalink raw reply [flat|nested] 13+ messages in thread
* Re: [PATCH v2 2/5] btrfs: split btrfs_insert_delayed_dir_index() into prealloc and commit phases
2026-08-05 11:54 ` Jeff Layton
@ 2026-08-05 22:34 ` Qu Wenruo
2026-08-05 22:43 ` Jeff Layton
0 siblings, 1 reply; 13+ messages in thread
From: Qu Wenruo @ 2026-08-05 22:34 UTC (permalink / raw)
To: Jeff Layton, Qu Wenruo, Chris Mason, David Sterba
Cc: linux-btrfs, linux-kernel, kernel-team
在 2026/8/5 21:24, Jeff Layton 写道:
> On Wed, 2026-08-05 at 08:44 +0930, 'Qu Wenruo' via Kernel Team wrote:
>>
>> 在 2026/8/5 01:14, Jeff Layton 写道:
>>> 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@kernel.org>
>>> ---
>>> fs/btrfs/delayed-inode.c | 111 +++++++++++++++++++++++++++++++++++++----------
>>> fs/btrfs/delayed-inode.h | 17 ++++++++
>>> 2 files changed, 104 insertions(+), 24 deletions(-)
>>>
>>> diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
>>> index db2ffab0941a..95d2dca80444 100644
>>> --- a/fs/btrfs/delayed-inode.c
>>> +++ b/fs/btrfs/delayed-inode.c
>>> @@ -6,6 +6,7 @@
>>>
>>> #include <linux/slab.h>
>>> #include <linux/iversion.h>
>>> +#include <linux/error-injection.h>
>>> #include "ctree.h"
>>> #include "fs.h"
>>> #include "messages.h"
>>> @@ -1469,35 +1470,74 @@ 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)
>>
>> We can directly return a btrfs_dir_index_prealloc pointer, which reduce
>> the parameter list.
>>
>
> ...but then we'd have to allocate it separately. It's currently
> allocated on the stack by the caller. I think we ought to keep it this
> way, but I'm willing to be convinced otherwise.
In the end, there are only two callsites using on-stack memory for
prealloc structure, one in btrfs_rename() and one in
btrfs_insert_dir_item().
So it would be not that hard to convert to heap memory based solution.
One thing I found a little weird is related to the lifespan management
of btrfs_dir_index_prealloc.
We have several call sites doing things like:
struct btrfs_dir_index_prealloc prealloc = { };
ret = btrfs_prealloc_delayed_dir_index();
ret = btrfs_add_link(..., prealloc.item ? prealloc : NULL);
prealloc.item = NULL;
Which looks a little weird to me, as we're using item to indicate if the
structure is properly allocated, not the structure itself.
If we go regular heap memory allocation, it would be more
straightforward and more common:
struct btrfs_dir_index_prealloc *prealloc = NULL;
prealloc = btrfs_prealloc_delayed_dir_index();
ret = btrfs_add_link(..., prealloc);
prealloc = NULL;
Feel free to ignore this one, it's mostly preference.
Thanks,
Qu
>
>> Otherwise looks good to me.
>>
>> Reviewed-by: Qu Wenruo <wqu@suse.com>
>>
>
^ permalink raw reply [flat|nested] 13+ messages in thread* Re: [PATCH v2 2/5] btrfs: split btrfs_insert_delayed_dir_index() into prealloc and commit phases
2026-08-05 22:34 ` Qu Wenruo
@ 2026-08-05 22:43 ` Jeff Layton
0 siblings, 0 replies; 13+ messages in thread
From: Jeff Layton @ 2026-08-05 22:43 UTC (permalink / raw)
To: Qu Wenruo, Qu Wenruo, Chris Mason, David Sterba
Cc: linux-btrfs, linux-kernel, kernel-team
On Thu, 2026-08-06 at 08:04 +0930, Qu Wenruo wrote:
>
> 在 2026/8/5 21:24, Jeff Layton 写道:
> > On Wed, 2026-08-05 at 08:44 +0930, 'Qu Wenruo' via Kernel Team wrote:
> > >
> > > 在 2026/8/5 01:14, Jeff Layton 写道:
> > > > 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@kernel.org>
> > > > ---
> > > > fs/btrfs/delayed-inode.c | 111 +++++++++++++++++++++++++++++++++++++----------
> > > > fs/btrfs/delayed-inode.h | 17 ++++++++
> > > > 2 files changed, 104 insertions(+), 24 deletions(-)
> > > >
> > > > diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
> > > > index db2ffab0941a..95d2dca80444 100644
> > > > --- a/fs/btrfs/delayed-inode.c
> > > > +++ b/fs/btrfs/delayed-inode.c
> > > > @@ -6,6 +6,7 @@
> > > >
> > > > #include <linux/slab.h>
> > > > #include <linux/iversion.h>
> > > > +#include <linux/error-injection.h>
> > > > #include "ctree.h"
> > > > #include "fs.h"
> > > > #include "messages.h"
> > > > @@ -1469,35 +1470,74 @@ 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)
> > >
> > > We can directly return a btrfs_dir_index_prealloc pointer, which reduce
> > > the parameter list.
> > >
> >
> > ...but then we'd have to allocate it separately. It's currently
> > allocated on the stack by the caller. I think we ought to keep it this
> > way, but I'm willing to be convinced otherwise.
>
> In the end, there are only two callsites using on-stack memory for
> prealloc structure, one in btrfs_rename() and one in
> btrfs_insert_dir_item().
>
> So it would be not that hard to convert to heap memory based solution.
>
>
> One thing I found a little weird is related to the lifespan management
> of btrfs_dir_index_prealloc.
>
> We have several call sites doing things like:
>
> struct btrfs_dir_index_prealloc prealloc = { };
>
> ret = btrfs_prealloc_delayed_dir_index();
>
> ret = btrfs_add_link(..., prealloc.item ? prealloc : NULL);
> prealloc.item = NULL;
>
> Which looks a little weird to me, as we're using item to indicate if the
> structure is properly allocated, not the structure itself.
>
> If we go regular heap memory allocation, it would be more
> straightforward and more common:
>
> struct btrfs_dir_index_prealloc *prealloc = NULL;
>
> prealloc = btrfs_prealloc_delayed_dir_index();
>
> ret = btrfs_add_link(..., prealloc);
> prealloc = NULL;
>
> Feel free to ignore this one, it's mostly preference.
>
It's a good point. It is more natural to be able to just look and say
"NULL pointer means no prealloc".
OTOH, the entire reason we're doing this is to deal with low-memory
situations. Do we want to add another heap allocation into this
codepath?
Either way, I'll think about it.
Thanks again for the review!
--
Jeff Layton <jlayton@kernel.org>
^ permalink raw reply [flat|nested] 13+ messages in thread
* [PATCH v2 3/5] btrfs: pre-allocate delayed dir index before btree modification
2026-08-04 15:44 [PATCH v2 0/5] btrfs: handle -ENOMEM errors in some synchronous dirops without aborting Jeff Layton
2026-08-04 15:44 ` [PATCH v2 1/5] btrfs: use an on-stack path in btrfs_insert_orphan_item() Jeff Layton
2026-08-04 15:44 ` [PATCH v2 2/5] btrfs: split btrfs_insert_delayed_dir_index() into prealloc and commit phases Jeff Layton
@ 2026-08-04 15:44 ` Jeff Layton
2026-08-04 23:51 ` Qu Wenruo
2026-08-04 15:44 ` [PATCH v2 4/5] btrfs: handle ENOMEM from btrfs_insert_dir_item() without aborting Jeff Layton
2026-08-04 15:44 ` [PATCH v2 5/5] btrfs: pre-allocate delayed dir index for non-overwrite rename Jeff Layton
4 siblings, 1 reply; 13+ messages in thread
From: Jeff Layton @ 2026-08-04 15:44 UTC (permalink / raw)
To: Chris Mason, David Sterba
Cc: Qu Wenruo, linux-btrfs, linux-kernel, kernel-team, Jeff Layton
Move the delayed dir index allocation in btrfs_insert_dir_item() before
the insert_with_overflow() call that modifies the btree. Previously, the
allocations happened after the DIR_ITEM was already inserted, meaning an
ENOMEM failure left the btree in a partially-modified state that could
only be resolved by aborting the transaction.
Add an optional caller-provided btrfs_dir_index_prealloc parameter to
btrfs_insert_dir_item(). When non-NULL, ownership of the prealloc
transfers to btrfs_insert_dir_item(). When NULL, it allocates internally.
All existing callers pass NULL to preserve the current behavior.
Remove the btrfs_insert_delayed_dir_index() wrapper, as there are no
more callers.
Assisted-by: LLM
Suggested-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: Jeff Layton <jlayton@kernel.org>
---
fs/btrfs/delayed-inode.c | 21 ---------------------
fs/btrfs/delayed-inode.h | 5 -----
fs/btrfs/dir-item.c | 30 ++++++++++++++++++++++++------
fs/btrfs/dir-item.h | 5 +++--
fs/btrfs/inode.c | 2 +-
fs/btrfs/transaction.c | 2 +-
6 files changed, 29 insertions(+), 36 deletions(-)
diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index 95d2dca80444..d9de7f269874 100644
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -1608,27 +1608,6 @@ int btrfs_insert_delayed_dir_index_prealloc(struct btrfs_trans_handle *trans,
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 e310a257c9a6..878d70aee2f9 100644
--- a/fs/btrfs/delayed-inode.h
+++ b/fs/btrfs/delayed-inode.h
@@ -115,11 +115,6 @@ struct btrfs_delayed_item {
};
void btrfs_init_delayed_root(struct btrfs_delayed_root *delayed_root);
-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 {
struct btrfs_delayed_node *node;
diff --git a/fs/btrfs/dir-item.c b/fs/btrfs/dir-item.c
index 84f1c64423d3..1b956df2c571 100644
--- a/fs/btrfs/dir-item.c
+++ b/fs/btrfs/dir-item.c
@@ -106,8 +106,11 @@ int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
* Will return 0 or -ENOMEM
*/
int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
- const struct fscrypt_str *name, struct btrfs_inode *dir,
- const struct btrfs_key *location, u8 type, u64 index)
+ const struct fscrypt_str *name,
+ struct btrfs_inode *dir,
+ const struct btrfs_key *location, u8 type,
+ u64 index,
+ struct btrfs_dir_index_prealloc *prealloc)
{
int ret = 0;
int ret2 = 0;
@@ -119,6 +122,8 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
struct btrfs_key key;
struct btrfs_disk_key disk_key;
u32 data_size;
+ const bool need_delayed_index = (root != root->fs_info->tree_root);
+ struct btrfs_dir_index_prealloc local_prealloc;
key.objectid = btrfs_ino(dir);
key.type = BTRFS_DIR_ITEM_KEY;
@@ -130,6 +135,18 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
btrfs_cpu_key_to_disk(&disk_key, location);
+ /* Pre-allocate the delayed dir index before modifying the btree. */
+ if (need_delayed_index && !prealloc) {
+ ret = btrfs_prealloc_delayed_dir_index(dir, name->name,
+ name->len,
+ &local_prealloc);
+ if (ret)
+ return ret;
+ memcpy(local_prealloc.item->data + sizeof(struct btrfs_dir_item),
+ name->name, name->len);
+ prealloc = &local_prealloc;
+ }
+
data_size = sizeof(*dir_item) + name->len;
dir_item = insert_with_overflow(trans, root, path, &key, data_size,
name->name, name->len);
@@ -137,6 +154,8 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
ret = PTR_ERR(dir_item);
if (ret == -EEXIST)
goto second_insert;
+ if (need_delayed_index)
+ btrfs_free_delayed_dir_index_prealloc(trans, prealloc);
goto out_free;
}
@@ -154,15 +173,14 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
write_extent_buffer(leaf, name->name, name_ptr, name->len);
second_insert:
- /* FIXME, use some real flag for selecting the extra index */
- if (root == root->fs_info->tree_root) {
+ if (!need_delayed_index) {
ret = 0;
goto out_free;
}
btrfs_release_path(path);
- ret2 = btrfs_insert_delayed_dir_index(trans, name->name, name->len, dir,
- &disk_key, type, index);
+ ret2 = btrfs_insert_delayed_dir_index_prealloc(trans, dir, prealloc,
+ &disk_key, type, index);
out_free:
if (ret)
return ret;
diff --git a/fs/btrfs/dir-item.h b/fs/btrfs/dir-item.h
index e52174a8baf9..d7a7d0b66f37 100644
--- a/fs/btrfs/dir-item.h
+++ b/fs/btrfs/dir-item.h
@@ -16,9 +16,11 @@ struct btrfs_trans_handle;
int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir_ino,
const struct fscrypt_str *name);
+struct btrfs_dir_index_prealloc;
int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
const struct fscrypt_str *name, struct btrfs_inode *dir,
- const struct btrfs_key *location, u8 type, u64 index);
+ const struct btrfs_key *location, u8 type, u64 index,
+ struct btrfs_dir_index_prealloc *prealloc);
struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
struct btrfs_path *path, u64 dir,
@@ -53,5 +55,4 @@ static inline u64 btrfs_name_hash(const char *name, int len)
{
return crc32c((u32)~1, name, len);
}
-
#endif
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 3c10a0ef0002..3a2dca093c7d 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -6924,7 +6924,7 @@ int btrfs_add_link(struct btrfs_trans_handle *trans,
return ret;
ret = btrfs_insert_dir_item(trans, name, parent_inode, &key,
- btrfs_inode_type(inode), index);
+ btrfs_inode_type(inode), index, NULL);
if (ret == -EEXIST || ret == -EOVERFLOW)
goto fail_dir_item;
else if (unlikely(ret)) {
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index c641099d66e2..6fdfea5d35af 100644
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -1882,7 +1882,7 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
ret = btrfs_insert_dir_item(trans, &fname.disk_name,
parent_inode, &key, BTRFS_FT_DIR,
- index);
+ index, NULL);
if (unlikely(ret)) {
btrfs_abort_transaction(trans, ret);
goto fail;
--
2.55.0
^ permalink raw reply related [flat|nested] 13+ messages in thread* Re: [PATCH v2 3/5] btrfs: pre-allocate delayed dir index before btree modification
2026-08-04 15:44 ` [PATCH v2 3/5] btrfs: pre-allocate delayed dir index before btree modification Jeff Layton
@ 2026-08-04 23:51 ` Qu Wenruo
2026-08-05 12:09 ` Jeff Layton
0 siblings, 1 reply; 13+ messages in thread
From: Qu Wenruo @ 2026-08-04 23:51 UTC (permalink / raw)
To: Jeff Layton, Chris Mason, David Sterba
Cc: linux-btrfs, linux-kernel, kernel-team
在 2026/8/5 01:14, Jeff Layton 写道:
> Move the delayed dir index allocation in btrfs_insert_dir_item() before
> the insert_with_overflow() call that modifies the btree. Previously, the
> allocations happened after the DIR_ITEM was already inserted, meaning an
> ENOMEM failure left the btree in a partially-modified state that could
> only be resolved by aborting the transaction.
>
> Add an optional caller-provided btrfs_dir_index_prealloc parameter to
> btrfs_insert_dir_item(). When non-NULL, ownership of the prealloc
> transfers to btrfs_insert_dir_item(). When NULL, it allocates internally.
> All existing callers pass NULL to preserve the current behavior.
>
> Remove the btrfs_insert_delayed_dir_index() wrapper, as there are no
> more callers.
>
> Assisted-by: LLM
> Suggested-by: Qu Wenruo <wqu@suse.com>
> Signed-off-by: Jeff Layton <jlayton@kernel.org>
> ---
> fs/btrfs/delayed-inode.c | 21 ---------------------
> fs/btrfs/delayed-inode.h | 5 -----
> fs/btrfs/dir-item.c | 30 ++++++++++++++++++++++++------
> fs/btrfs/dir-item.h | 5 +++--
> fs/btrfs/inode.c | 2 +-
> fs/btrfs/transaction.c | 2 +-
> 6 files changed, 29 insertions(+), 36 deletions(-)
>
> diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
> index 95d2dca80444..d9de7f269874 100644
> --- a/fs/btrfs/delayed-inode.c
> +++ b/fs/btrfs/delayed-inode.c
> @@ -1608,27 +1608,6 @@ int btrfs_insert_delayed_dir_index_prealloc(struct btrfs_trans_handle *trans,
> 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 e310a257c9a6..878d70aee2f9 100644
> --- a/fs/btrfs/delayed-inode.h
> +++ b/fs/btrfs/delayed-inode.h
> @@ -115,11 +115,6 @@ struct btrfs_delayed_item {
> };
>
> void btrfs_init_delayed_root(struct btrfs_delayed_root *delayed_root);
> -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 {
> struct btrfs_delayed_node *node;
> diff --git a/fs/btrfs/dir-item.c b/fs/btrfs/dir-item.c
> index 84f1c64423d3..1b956df2c571 100644
> --- a/fs/btrfs/dir-item.c
> +++ b/fs/btrfs/dir-item.c
> @@ -106,8 +106,11 @@ int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
> * Will return 0 or -ENOMEM
> */
> int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
> - const struct fscrypt_str *name, struct btrfs_inode *dir,
> - const struct btrfs_key *location, u8 type, u64 index)
> + const struct fscrypt_str *name,
> + struct btrfs_inode *dir,
> + const struct btrfs_key *location, u8 type,
> + u64 index,
> + struct btrfs_dir_index_prealloc *prealloc)
> {
> int ret = 0;
> int ret2 = 0;
> @@ -119,6 +122,8 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
> struct btrfs_key key;
> struct btrfs_disk_key disk_key;
> u32 data_size;
> + const bool need_delayed_index = (root != root->fs_info->tree_root);
> + struct btrfs_dir_index_prealloc local_prealloc;
>
> key.objectid = btrfs_ino(dir);
> key.type = BTRFS_DIR_ITEM_KEY;
> @@ -130,6 +135,18 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
>
> btrfs_cpu_key_to_disk(&disk_key, location);
>
> + /* Pre-allocate the delayed dir index before modifying the btree. */
> + if (need_delayed_index && !prealloc) {
This is exposed by sashiko.
If we have @prealloc passed in, and before we even hit
insert_with_overflow(), the previous btrfs_alloc_path() failed, we
return -ENOMEM directly, leaking the @prealloc.
> + ret = btrfs_prealloc_delayed_dir_index(dir, name->name,
> + name->len,
> + &local_prealloc);
Sashiko also pointed out that, the preallocation itself doesn't really
utilize name->name.
Thus it may be a good idea to merge the later memcpy() into the
preallocation function.
Thanks,
Qu
> + if (ret)
> + return ret;
> + memcpy(local_prealloc.item->data + sizeof(struct btrfs_dir_item),
> + name->name, name->len);
> + prealloc = &local_prealloc;
> + }
> +
> data_size = sizeof(*dir_item) + name->len;
> dir_item = insert_with_overflow(trans, root, path, &key, data_size,
> name->name, name->len);
> @@ -137,6 +154,8 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
> ret = PTR_ERR(dir_item);
> if (ret == -EEXIST)
> goto second_insert;
> + if (need_delayed_index)
> + btrfs_free_delayed_dir_index_prealloc(trans, prealloc);
> goto out_free;
> }
>
> @@ -154,15 +173,14 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
> write_extent_buffer(leaf, name->name, name_ptr, name->len);
>
> second_insert:
> - /* FIXME, use some real flag for selecting the extra index */
> - if (root == root->fs_info->tree_root) {
> + if (!need_delayed_index) {
> ret = 0;
> goto out_free;
> }
> btrfs_release_path(path);
>
> - ret2 = btrfs_insert_delayed_dir_index(trans, name->name, name->len, dir,
> - &disk_key, type, index);
> + ret2 = btrfs_insert_delayed_dir_index_prealloc(trans, dir, prealloc,
> + &disk_key, type, index);
> out_free:
> if (ret)
> return ret;
> diff --git a/fs/btrfs/dir-item.h b/fs/btrfs/dir-item.h
> index e52174a8baf9..d7a7d0b66f37 100644
> --- a/fs/btrfs/dir-item.h
> +++ b/fs/btrfs/dir-item.h
> @@ -16,9 +16,11 @@ struct btrfs_trans_handle;
>
> int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir_ino,
> const struct fscrypt_str *name);
> +struct btrfs_dir_index_prealloc;
> int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
> const struct fscrypt_str *name, struct btrfs_inode *dir,
> - const struct btrfs_key *location, u8 type, u64 index);
> + const struct btrfs_key *location, u8 type, u64 index,
> + struct btrfs_dir_index_prealloc *prealloc);
> struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
> struct btrfs_root *root,
> struct btrfs_path *path, u64 dir,
> @@ -53,5 +55,4 @@ static inline u64 btrfs_name_hash(const char *name, int len)
> {
> return crc32c((u32)~1, name, len);
> }
> -
> #endif
> diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
> index 3c10a0ef0002..3a2dca093c7d 100644
> --- a/fs/btrfs/inode.c
> +++ b/fs/btrfs/inode.c
> @@ -6924,7 +6924,7 @@ int btrfs_add_link(struct btrfs_trans_handle *trans,
> return ret;
>
> ret = btrfs_insert_dir_item(trans, name, parent_inode, &key,
> - btrfs_inode_type(inode), index);
> + btrfs_inode_type(inode), index, NULL);
> if (ret == -EEXIST || ret == -EOVERFLOW)
> goto fail_dir_item;
> else if (unlikely(ret)) {
> diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
> index c641099d66e2..6fdfea5d35af 100644
> --- a/fs/btrfs/transaction.c
> +++ b/fs/btrfs/transaction.c
> @@ -1882,7 +1882,7 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
>
> ret = btrfs_insert_dir_item(trans, &fname.disk_name,
> parent_inode, &key, BTRFS_FT_DIR,
> - index);
> + index, NULL);
> if (unlikely(ret)) {
> btrfs_abort_transaction(trans, ret);
> goto fail;
>
^ permalink raw reply [flat|nested] 13+ messages in thread* Re: [PATCH v2 3/5] btrfs: pre-allocate delayed dir index before btree modification
2026-08-04 23:51 ` Qu Wenruo
@ 2026-08-05 12:09 ` Jeff Layton
0 siblings, 0 replies; 13+ messages in thread
From: Jeff Layton @ 2026-08-05 12:09 UTC (permalink / raw)
To: Qu Wenruo, Chris Mason, David Sterba
Cc: linux-btrfs, linux-kernel, kernel-team
On Wed, 2026-08-05 at 09:21 +0930, Qu Wenruo wrote:
>
> 在 2026/8/5 01:14, Jeff Layton 写道:
> > Move the delayed dir index allocation in btrfs_insert_dir_item() before
> > the insert_with_overflow() call that modifies the btree. Previously, the
> > allocations happened after the DIR_ITEM was already inserted, meaning an
> > ENOMEM failure left the btree in a partially-modified state that could
> > only be resolved by aborting the transaction.
> >
> > Add an optional caller-provided btrfs_dir_index_prealloc parameter to
> > btrfs_insert_dir_item(). When non-NULL, ownership of the prealloc
> > transfers to btrfs_insert_dir_item(). When NULL, it allocates internally.
> > All existing callers pass NULL to preserve the current behavior.
> >
> > Remove the btrfs_insert_delayed_dir_index() wrapper, as there are no
> > more callers.
> >
> > Assisted-by: LLM
> > Suggested-by: Qu Wenruo <wqu@suse.com>
> > Signed-off-by: Jeff Layton <jlayton@kernel.org>
> > ---
> > fs/btrfs/delayed-inode.c | 21 ---------------------
> > fs/btrfs/delayed-inode.h | 5 -----
> > fs/btrfs/dir-item.c | 30 ++++++++++++++++++++++++------
> > fs/btrfs/dir-item.h | 5 +++--
> > fs/btrfs/inode.c | 2 +-
> > fs/btrfs/transaction.c | 2 +-
> > 6 files changed, 29 insertions(+), 36 deletions(-)
> >
> > diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
> > index 95d2dca80444..d9de7f269874 100644
> > --- a/fs/btrfs/delayed-inode.c
> > +++ b/fs/btrfs/delayed-inode.c
> > @@ -1608,27 +1608,6 @@ int btrfs_insert_delayed_dir_index_prealloc(struct btrfs_trans_handle *trans,
> > 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 e310a257c9a6..878d70aee2f9 100644
> > --- a/fs/btrfs/delayed-inode.h
> > +++ b/fs/btrfs/delayed-inode.h
> > @@ -115,11 +115,6 @@ struct btrfs_delayed_item {
> > };
> >
> > void btrfs_init_delayed_root(struct btrfs_delayed_root *delayed_root);
> > -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 {
> > struct btrfs_delayed_node *node;
> > diff --git a/fs/btrfs/dir-item.c b/fs/btrfs/dir-item.c
> > index 84f1c64423d3..1b956df2c571 100644
> > --- a/fs/btrfs/dir-item.c
> > +++ b/fs/btrfs/dir-item.c
> > @@ -106,8 +106,11 @@ int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
> > * Will return 0 or -ENOMEM
> > */
> > int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
> > - const struct fscrypt_str *name, struct btrfs_inode *dir,
> > - const struct btrfs_key *location, u8 type, u64 index)
> > + const struct fscrypt_str *name,
> > + struct btrfs_inode *dir,
> > + const struct btrfs_key *location, u8 type,
> > + u64 index,
> > + struct btrfs_dir_index_prealloc *prealloc)
> > {
> > int ret = 0;
> > int ret2 = 0;
> > @@ -119,6 +122,8 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
> > struct btrfs_key key;
> > struct btrfs_disk_key disk_key;
> > u32 data_size;
> > + const bool need_delayed_index = (root != root->fs_info->tree_root);
> > + struct btrfs_dir_index_prealloc local_prealloc;
> >
> > key.objectid = btrfs_ino(dir);
> > key.type = BTRFS_DIR_ITEM_KEY;
> > @@ -130,6 +135,18 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
> >
> > btrfs_cpu_key_to_disk(&disk_key, location);
> >
> > + /* Pre-allocate the delayed dir index before modifying the btree. */
> > + if (need_delayed_index && !prealloc) {
>
> This is exposed by sashiko.
>
> If we have @prealloc passed in, and before we even hit
> insert_with_overflow(), the previous btrfs_alloc_path() failed, we
> return -ENOMEM directly, leaking the @prealloc.
>
>
Good catch. It looks like sashiko also flagged some other similar
issues nearby too that we might as well fix while we're in here. I'll
plan to spin up a v3 and resend the series. Thanks very much for the
review so far!
--
Jeff Layton <jlayton@kernel.org>
^ permalink raw reply [flat|nested] 13+ messages in thread
* [PATCH v2 4/5] btrfs: handle ENOMEM from btrfs_insert_dir_item() without aborting
2026-08-04 15:44 [PATCH v2 0/5] btrfs: handle -ENOMEM errors in some synchronous dirops without aborting Jeff Layton
` (2 preceding siblings ...)
2026-08-04 15:44 ` [PATCH v2 3/5] btrfs: pre-allocate delayed dir index before btree modification Jeff Layton
@ 2026-08-04 15:44 ` Jeff Layton
2026-08-04 15:44 ` [PATCH v2 5/5] btrfs: pre-allocate delayed dir index for non-overwrite rename Jeff Layton
4 siblings, 0 replies; 13+ messages in thread
From: Jeff Layton @ 2026-08-04 15:44 UTC (permalink / raw)
To: Chris Mason, David Sterba
Cc: Qu Wenruo, linux-btrfs, linux-kernel, kernel-team, Jeff Layton
Now that btrfs_insert_dir_item() returns -ENOMEM before modifying the
btree (thanks to delayed dir index pre-allocation), callers can handle
ENOMEM gracefully instead of aborting the transaction.
- btrfs_add_link(): add -ENOMEM to the recoverable errors alongside
-EEXIST and -EOVERFLOW.
- btrfs_create_new_inode(): on -ENOMEM from btrfs_add_link(), clear
nlink and orphan the newly-created inode instead of aborting.
This turns a filesystem-killing abort into a graceful -ENOMEM return for
create(), mkdir(), mknod(), symlink(), and link() under memory pressure.
Assisted-by: LLM
Signed-off-by: Jeff Layton <jlayton@kernel.org>
---
fs/btrfs/inode.c | 14 ++++++++++++--
1 file changed, 12 insertions(+), 2 deletions(-)
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 3a2dca093c7d..99e990c592f6 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -6863,7 +6863,17 @@ int btrfs_create_new_inode(struct btrfs_trans_handle *trans,
} else {
ret = btrfs_add_link(trans, BTRFS_I(dir), BTRFS_I(inode), name,
false, BTRFS_I(inode)->dir_index);
- if (unlikely(ret)) {
+ if (ret == -ENOMEM) {
+ clear_nlink(inode);
+ /*
+ * btrfs_orphan_add() aborts the transaction itself if it
+ * fails, so only override ret to -ENOMEM on success.
+ */
+ ret = btrfs_orphan_add(trans, BTRFS_I(inode));
+ if (!ret)
+ ret = -ENOMEM;
+ goto discard;
+ } else if (unlikely(ret)) {
btrfs_abort_transaction(trans, ret);
goto discard;
}
@@ -6925,7 +6935,7 @@ int btrfs_add_link(struct btrfs_trans_handle *trans,
ret = btrfs_insert_dir_item(trans, name, parent_inode, &key,
btrfs_inode_type(inode), index, NULL);
- if (ret == -EEXIST || ret == -EOVERFLOW)
+ if (ret == -EEXIST || ret == -EOVERFLOW || ret == -ENOMEM)
goto fail_dir_item;
else if (unlikely(ret)) {
btrfs_abort_transaction(trans, ret);
--
2.55.0
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH v2 5/5] btrfs: pre-allocate delayed dir index for non-overwrite rename
2026-08-04 15:44 [PATCH v2 0/5] btrfs: handle -ENOMEM errors in some synchronous dirops without aborting Jeff Layton
` (3 preceding siblings ...)
2026-08-04 15:44 ` [PATCH v2 4/5] btrfs: handle ENOMEM from btrfs_insert_dir_item() without aborting Jeff Layton
@ 2026-08-04 15:44 ` Jeff Layton
4 siblings, 0 replies; 13+ messages in thread
From: Jeff Layton @ 2026-08-04 15:44 UTC (permalink / raw)
To: Chris Mason, David Sterba
Cc: Qu Wenruo, linux-btrfs, linux-kernel, kernel-team, Jeff Layton
For rename() without an overwrite target, pre-allocate the delayed
dir index before any btree modifications so that ENOMEM can be returned
before the source is unlinked from the old directory.
Add a prealloc parameter to btrfs_add_link() that allows callers to
pass pre-allocated delayed dir index resources. When provided,
btrfs_add_link() takes ownership: it either passes the prealloc to
btrfs_insert_dir_item() (which commits or frees it), or frees it
on early error. All existing callers pass NULL to preserve the current
behavior.
In btrfs_rename(), when new_inode is NULL (no overwrite), call
btrfs_prealloc_delayed_dir_index() before the first btree modification
and pass the result through to btrfs_add_link(). If the prealloc fails,
-ENOMEM is returned before any btree state has changed.
For overwrite rename (new_inode != NULL), the transaction still aborts
on ENOMEM since earlier unlink operations have already made irreversible
btree modifications.
Assisted-by: LLM
Signed-off-by: Jeff Layton <jlayton@kernel.org>
---
fs/btrfs/btrfs_inode.h | 4 +++-
fs/btrfs/inode.c | 43 +++++++++++++++++++++++++++++++++++--------
fs/btrfs/tree-log.c | 4 ++--
3 files changed, 40 insertions(+), 11 deletions(-)
diff --git a/fs/btrfs/btrfs_inode.h b/fs/btrfs/btrfs_inode.h
index 1082fa92c145..d4280f152027 100644
--- a/fs/btrfs/btrfs_inode.h
+++ b/fs/btrfs/btrfs_inode.h
@@ -525,9 +525,11 @@ int btrfs_set_inode_index(struct btrfs_inode *dir, u64 *index);
int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
struct btrfs_inode *dir, struct btrfs_inode *inode,
const struct fscrypt_str *name);
+struct btrfs_dir_index_prealloc;
int btrfs_add_link(struct btrfs_trans_handle *trans,
struct btrfs_inode *parent_inode, struct btrfs_inode *inode,
- const struct fscrypt_str *name, bool add_backref, u64 index);
+ const struct fscrypt_str *name, bool add_backref, u64 index,
+ struct btrfs_dir_index_prealloc *prealloc);
int btrfs_delete_subvolume(struct btrfs_inode *dir, struct dentry *dentry);
int btrfs_truncate_block(struct btrfs_inode *inode, u64 offset, u64 start, u64 end);
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 99e990c592f6..9f6a631d83a3 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -6862,7 +6862,7 @@ int btrfs_create_new_inode(struct btrfs_trans_handle *trans,
}
} else {
ret = btrfs_add_link(trans, BTRFS_I(dir), BTRFS_I(inode), name,
- false, BTRFS_I(inode)->dir_index);
+ false, BTRFS_I(inode)->dir_index, NULL);
if (ret == -ENOMEM) {
clear_nlink(inode);
/*
@@ -6904,7 +6904,8 @@ int btrfs_create_new_inode(struct btrfs_trans_handle *trans,
*/
int btrfs_add_link(struct btrfs_trans_handle *trans,
struct btrfs_inode *parent_inode, struct btrfs_inode *inode,
- const struct fscrypt_str *name, bool add_backref, u64 index)
+ const struct fscrypt_str *name, bool add_backref, u64 index,
+ struct btrfs_dir_index_prealloc *prealloc)
{
int ret = 0;
struct btrfs_key key;
@@ -6930,11 +6931,14 @@ int btrfs_add_link(struct btrfs_trans_handle *trans,
}
/* Nothing to clean up yet */
- if (ret)
+ if (ret) {
+ if (prealloc)
+ btrfs_free_delayed_dir_index_prealloc(trans, prealloc);
return ret;
+ }
ret = btrfs_insert_dir_item(trans, name, parent_inode, &key,
- btrfs_inode_type(inode), index, NULL);
+ btrfs_inode_type(inode), index, prealloc);
if (ret == -EEXIST || ret == -EOVERFLOW || ret == -ENOMEM)
goto fail_dir_item;
else if (unlikely(ret)) {
@@ -7088,7 +7092,7 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
inode_set_ctime_current(inode);
ret = btrfs_add_link(trans, BTRFS_I(dir), BTRFS_I(inode),
- &fname.disk_name, true, index);
+ &fname.disk_name, true, index, NULL);
if (ret)
goto fail;
@@ -8502,14 +8506,14 @@ static int btrfs_rename_exchange(struct inode *old_dir,
}
ret = btrfs_add_link(trans, BTRFS_I(new_dir), BTRFS_I(old_inode),
- new_name, false, old_idx);
+ new_name, false, old_idx, NULL);
if (unlikely(ret)) {
btrfs_abort_transaction(trans, ret);
goto out_fail;
}
ret = btrfs_add_link(trans, BTRFS_I(old_dir), BTRFS_I(new_inode),
- old_name, false, new_idx);
+ old_name, false, new_idx, NULL);
if (unlikely(ret)) {
btrfs_abort_transaction(trans, ret);
goto out_fail;
@@ -8582,6 +8586,7 @@ static int btrfs_rename(struct mnt_idmap *idmap,
struct inode *new_inode = d_inode(new_dentry);
struct inode *old_inode = d_inode(old_dentry);
struct btrfs_rename_ctx rename_ctx;
+ struct btrfs_dir_index_prealloc prealloc = { };
u64 index = 0;
int ret;
int ret2;
@@ -8705,6 +8710,24 @@ static int btrfs_rename(struct mnt_idmap *idmap,
if (ret)
goto out_fail;
+ /*
+ * When not overwriting an existing entry, pre-allocate the delayed
+ * dir index now so that ENOMEM is returned before any btree
+ * modifications. For the overwrite case, too many btree changes
+ * have already happened by the time btrfs_add_link() is called.
+ */
+ if (!new_inode) {
+ ret = btrfs_prealloc_delayed_dir_index(
+ BTRFS_I(new_dir),
+ new_fname.disk_name.name,
+ new_fname.disk_name.len,
+ &prealloc);
+ if (ret)
+ goto out_fail;
+ memcpy(prealloc.item->data + sizeof(struct btrfs_dir_item),
+ new_fname.disk_name.name, new_fname.disk_name.len);
+ }
+
BTRFS_I(old_inode)->dir_index = 0ULL;
if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
/* force full log commit if subvolume involved. */
@@ -8800,7 +8823,9 @@ static int btrfs_rename(struct mnt_idmap *idmap,
}
ret = btrfs_add_link(trans, BTRFS_I(new_dir), BTRFS_I(old_inode),
- &new_fname.disk_name, false, index);
+ &new_fname.disk_name, false, index,
+ prealloc.item ? &prealloc : NULL);
+ prealloc.item = NULL;
if (unlikely(ret)) {
btrfs_abort_transaction(trans, ret);
goto out_fail;
@@ -8825,6 +8850,8 @@ static int btrfs_rename(struct mnt_idmap *idmap,
}
}
out_fail:
+ if (prealloc.item)
+ btrfs_free_delayed_dir_index_prealloc(trans, &prealloc);
if (logs_pinned) {
btrfs_end_log_trans(root);
btrfs_end_log_trans(dest);
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 7ba7b6098aa5..a043611f82e1 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -1683,7 +1683,7 @@ static noinline int add_inode_ref(struct walk_control *wc)
}
/* insert our name */
- ret = btrfs_add_link(trans, dir, inode, &name, false, ref_index);
+ ret = btrfs_add_link(trans, dir, inode, &name, false, ref_index, NULL);
if (ret) {
btrfs_abort_log_replay(wc, ret,
"failed to add link for inode %llu in dir %llu ref_index %llu name %.*s root %llu",
@@ -2031,7 +2031,7 @@ static noinline int insert_one_name(struct btrfs_trans_handle *trans,
return PTR_ERR(dir);
}
- ret = btrfs_add_link(trans, dir, inode, name, true, index);
+ ret = btrfs_add_link(trans, dir, inode, name, true, index, NULL);
/* FIXME, put inode into FIXUP list */
--
2.55.0
^ permalink raw reply related [flat|nested] 13+ messages in thread