Skip to contentSkip to conversation

btrfs path auto free

PATCH In review Leo Martins 2 participants 5 messages Sep 3, 2024 – Sep 4, 2024 Btrfs file system

lore
Share & tools
lore
#0 lore raw

v4 cover btrfs path auto free

CHANGELOG:
Patch 1/3
- Move BTRFS_PATH_AUTO_FREE macro definition next to btrfs_path struct.

The DEFINE_FREE macro defines a wrapper function for a given memory cleanup function which takes a pointer as an argument and calls the cleanup function with the value of the pointer. The __free macro adds a scoped-based cleanup to a variable, using the __cleanup attribute to specify the cleanup function that should be called when the variable goes out of scope.

Using this cleanup code pattern ensures that memory is properly freed when it's no longer needed, preventing memory leaks and reducing the risk of crashes or other issues caused by incorrect memory management. Even if the code is already memory safe, using this pattern reduces the risk of introducing memory-related bugs in the future

In this series of patches I've added a DEFINE_FREE for btrfs_free_path and created a macro BTRFS_PATH_AUTO_FREE to clearly identify path declarations that will be automatically freed.

I've included some simple examples of where this pattern can be used. The trivial examples are ones where there is one exit path and the only cleanup performed is a call to btrfs_free_path.

Leo Martins (3):
btrfs: DEFINE_FREE for btrfs_free_path
btrfs: BTRFS_PATH_AUTO_FREE in zoned.c
btrfs: BTRFS_PATH_AUTO_FREE in orphan.c

 fs/btrfs/ctree.c  |  2 +-
 fs/btrfs/ctree.h  |  5 +++++
 fs/btrfs/orphan.c | 19 ++++++-------------
 fs/btrfs/zoned.c  | 34 +++++++++++-----------------------
 4 files changed, 23 insertions(+), 37 deletions(-)
Signature · 1 line
2.43.5
#1 lore raw

PATCH v4 1/3 btrfs: DEFINE_FREE for btrfs_free_path

CHANGELOG:
Move BTRFS_PATH_AUTO_FREE macro definition next to btrfs_path struct.

Add a DEFINE_FREE for btrfs_free_path. This defines a function that can be called using the __free attribute. Defined a macro BTRFS_PATH_AUTO_FREE to make the declaration of an auto freeing path very clear.

---
 fs/btrfs/ctree.c | 2 +-
 fs/btrfs/ctree.h | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)
fs/btrfs/ctree.c +1 -1
index 451203055bbfb..f0bdea206d672 100644
@@ -196,7 +196,7 @@ struct btrfs_path *btrfs_alloc_path(void)
 /* this also releases the path */
 void btrfs_free_path(struct btrfs_path *p)
 {
-	if (!p)
+	if (IS_ERR_OR_NULL(p))
 		return;
 	btrfs_release_path(p);
 	kmem_cache_free(btrfs_path_cachep, p);
fs/btrfs/ctree.h +5 -0
index c8568b1a61c43..7a7b051e994ac 100644
@@ -6,6 +6,7 @@
 #ifndef BTRFS_CTREE_H
 #define BTRFS_CTREE_H
 
+#include "linux/cleanup.h"
 #include <linux/pagemap.h>
 #include <linux/spinlock.h>
 #include <linux/rbtree.h>
@@ -84,6 +85,9 @@ struct btrfs_path {
 	unsigned int nowait:1;
 };
 
+#define BTRFS_PATH_AUTO_FREE(path_name) \
+	struct btrfs_path *path_name __free(btrfs_free_path) = NULL;
+
 /*
  * The state of btrfs root
  */
@@ -598,6 +602,7 @@ int btrfs_search_slot_for_read(struct btrfs_root *root,
 void btrfs_release_path(struct btrfs_path *p);
 struct btrfs_path *btrfs_alloc_path(void);
 void btrfs_free_path(struct btrfs_path *p);
+DEFINE_FREE(btrfs_free_path, struct btrfs_path *, btrfs_free_path(_T))
 
 int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 		   struct btrfs_path *path, int slot, int nr);
Signature · 1 line
2.43.5
#2 lore raw

PATCH v4 2/3 btrfs: BTRFS_PATH_AUTO_FREE in zoned.c

In reply to Leo Martins

All cleanup paths lead to btrfs_path_free so path can be defined with the automatic freeing callback.

---
 fs/btrfs/zoned.c | 34 +++++++++++-----------------------
 1 file changed, 11 insertions(+), 23 deletions(-)
fs/btrfs/zoned.c +11 -23
index 66f63e82af793..158bb0b708805 100644
@@ -287,7 +287,7 @@ static int btrfs_get_dev_zones(struct btrfs_device *device, u64 pos,
 /* The emulated zone size is determined from the size of device extent */
 static int calculate_emulated_zone_size(struct btrfs_fs_info *fs_info)
 {
-	struct btrfs_path *path;
+	BTRFS_PATH_AUTO_FREE(path);
 	struct btrfs_root *root = fs_info->dev_root;
 	struct btrfs_key key;
 	struct extent_buffer *leaf;
@@ -304,28 +304,21 @@ static int calculate_emulated_zone_size(struct btrfs_fs_info *fs_info)
 
 	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
 	if (ret < 0)
-		goto out;
+		return ret;
 
 	if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
 		ret = btrfs_next_leaf(root, path);
 		if (ret < 0)
-			goto out;
+			return ret;
 		/* No dev extents at all? Not good */
-		if (ret > 0) {
-			ret = -EUCLEAN;
-			goto out;
-		}
+		if (ret > 0)
+			return -EUCLEAN;
 	}
 
 	leaf = path->nodes[0];
 	dext = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_extent);
 	fs_info->zone_size = btrfs_dev_extent_length(leaf, dext);
-	ret = 0;
-
-out:
-	btrfs_free_path(path);
-
-	return ret;
+	return 0;
 }
 
 int btrfs_get_dev_zone_info_all_devices(struct btrfs_fs_info *fs_info)
@@ -1211,7 +1204,7 @@ static int calculate_alloc_pointer(struct btrfs_block_group *cache,
 {
 	struct btrfs_fs_info *fs_info = cache->fs_info;
 	struct btrfs_root *root;
-	struct btrfs_path *path;
+	BTRFS_PATH_AUTO_FREE(path);
 	struct btrfs_key key;
 	struct btrfs_key found_key;
 	int ret;
@@ -1246,7 +1239,7 @@ static int calculate_alloc_pointer(struct btrfs_block_group *cache,
 	if (!ret)
 		ret = -EUCLEAN;
 	if (ret < 0)
-		goto out;
+		return ret;
 
 	ret = btrfs_previous_extent_item(root, path, cache->start);
 	if (ret) {
@@ -1254,7 +1247,7 @@ static int calculate_alloc_pointer(struct btrfs_block_group *cache,
 			ret = 0;
 			*offset_ret = 0;
 		}
-		goto out;
+		return ret;
 	}
 
 	btrfs_item_key_to_cpu(path->nodes[0], &found_key, path->slots[0]);
@@ -1266,15 +1259,10 @@ static int calculate_alloc_pointer(struct btrfs_block_group *cache,
 
 	if (!(found_key.objectid >= cache->start &&
 	       found_key.objectid + length <= cache->start + cache->length)) {
-		ret = -EUCLEAN;
-		goto out;
+		return -EUCLEAN;
 	}
 	*offset_ret = found_key.objectid + length - cache->start;
-	ret = 0;
-
-out:
-	btrfs_free_path(path);
-	return ret;
+	return 0;
 }
 
 struct zone_info {
Signature · 1 line
2.43.5
#3 lore raw

PATCH v4 3/3 btrfs: BTRFS_PATH_AUTO_FREE in orphan.c

In reply to Leo Martins

All cleanup paths lead to btrfs_path_free so path can be defined with the automatic freeing callback.

---
 fs/btrfs/orphan.c | 19 ++++++-------------
 1 file changed, 6 insertions(+), 13 deletions(-)
fs/btrfs/orphan.c +6 -13
index 6195a2215b8fe..696dbaf26af52 100644
@@ -9,7 +9,7 @@
 int btrfs_insert_orphan_item(struct btrfs_trans_handle *trans,
 			     struct btrfs_root *root, u64 offset)
 {
-	struct btrfs_path *path;
+	BTRFS_PATH_AUTO_FREE(path);
 	struct btrfs_key key;
 	int ret = 0;
 
@@ -23,14 +23,13 @@ int btrfs_insert_orphan_item(struct btrfs_trans_handle *trans,
 
 	ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
 
-	btrfs_free_path(path);
 	return ret;
 }
 
 int btrfs_del_orphan_item(struct btrfs_trans_handle *trans,
 			  struct btrfs_root *root, u64 offset)
 {
-	struct btrfs_path *path;
+	BTRFS_PATH_AUTO_FREE(path);
 	struct btrfs_key key;
 	int ret = 0;
 
@@ -44,15 +43,9 @@ int btrfs_del_orphan_item(struct btrfs_trans_handle *trans,
 
 	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
 	if (ret < 0)
-		goto out;
-	if (ret) { /* JDM: Really? */
-		ret = -ENOENT;
-		goto out;
-	}
+		return ret;
+	if (ret)
+		return -ENOENT;
 
-	ret = btrfs_del_item(trans, root, path);
-
-out:
-	btrfs_free_path(path);
-	return ret;
+	return btrfs_del_item(trans, root, path);
 }
Signature · 1 line
2.43.5
#4 lore raw
In reply to Leo Martins
Quoted 22 lines · Leo Martins

CHANGELOG:
Patch 1/3
- Move BTRFS_PATH_AUTO_FREE macro definition next to btrfs_path struct.

The DEFINE_FREE macro defines a wrapper function for a given memory cleanup function which takes a pointer as an argument and calls the cleanup function with the value of the pointer. The __free macro adds a scoped-based cleanup to a variable, using the __cleanup attribute to specify the cleanup function that should be called when the variable goes out of scope.

Using this cleanup code pattern ensures that memory is properly freed when it's no longer needed, preventing memory leaks and reducing the risk of crashes or other issues caused by incorrect memory management. Even if the code is already memory safe, using this pattern reduces the risk of introducing memory-related bugs in the future

In this series of patches I've added a DEFINE_FREE for btrfs_free_path and created a macro BTRFS_PATH_AUTO_FREE to clearly identify path declarations that will be automatically freed.

Quoted 8 lines

I've included some simple examples of where this pattern can be used. The trivial examples are ones where there is one exit path and the only cleanup performed is a call to btrfs_free_path.

Leo Martins (3):
btrfs: DEFINE_FREE for btrfs_free_path
btrfs: BTRFS_PATH_AUTO_FREE in zoned.c
btrfs: BTRFS_PATH_AUTO_FREE in orphan.c

I've merged the series with some adjustments, we're short on time regarding the next merge window so we may not be able to do one more iteration with the fixes. Thanks.