Skip to contentSkip to conversation

commit-reach: plug minor memory leak after using is_descendant_of()

PATCH In review René Scharfe 3 participants 3 messages Jun 19, 2020

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 commit-reach: plug minor memory leak after using is_descendant_of()

ref_newer() builds a commit_list to pass a single potential ancestor to is_descendant_of(). The latter leaves the list intact. Release the allocated memory after the call.

---
We could allocate the commit_list on the stack, which would simplify such glue code quite a bit. That would be dangerous in case is_descendant_of() or some other function that is handed such a list tries to consume/free() it. How can we be tell a function is safe to be given a stack-allocated list? Perhaps by marking its argument as const. Or by converting all functions to arrays.

 commit-reach.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
commit-reach.c +4 -1
index 4ca7e706a1..6bba16e7b5 100644
@@ -396,6 +396,7 @@ int ref_newer(const struct object_id *new_oid, const struct object_id *old_oid)
 	struct object *o;
 	struct commit *old_commit, *new_commit;
 	struct commit_list *old_commit_list = NULL;
+	int ret;
 
 	/*
 	 * Both new_commit and old_commit must be commit-ish and new_commit is descendant of
@@ -417,7 +418,9 @@ int ref_newer(const struct object_id *new_oid, const struct object_id *old_oid)
 		return 0;
 
 	commit_list_insert(old_commit, &old_commit_list);
-	return is_descendant_of(new_commit, old_commit_list);
+	ret = is_descendant_of(new_commit, old_commit_list);
+	free_commit_list(old_commit_list);
+	return ret;
 }
 
 /*

--
2.27.0

#1 lore raw
Quoted 3 lines · René Scharfe

ref_newer() builds a commit_list to pass a single potential ancestor to is_descendant_of(). The latter leaves the list intact. Release the allocated memory after the call.

Looks obviously correct.

Quoted 7 lines

---
We could allocate the commit_list on the stack, which would simplify such glue code quite a bit. That would be dangerous in case is_descendant_of() or some other function that is handed such a list tries to consume/free() it. How can we be tell a function is safe to be given a stack-allocated list? Perhaps by marking its argument as const. Or by converting all functions to arrays.

Yeah, if we're not worried about the performance implications of the extra allocation, I think it's better to err on the side of safety.

I do agree that if we consistently passed an array (and length), some of these functions would get less awkward. I tried a few years ago to convert many of the commit_list uses to arrays, but it was a bit of a yak shave, since often they get lists from callers, who get it from rev_info, etc. And some of those callers _do_ like having lists, because they want to do O(1) splicing, etc.

-Peff

#2 lore raw
Quoted 7 lines · Jeff King
Quoted 3 lines · René Scharfe

ref_newer() builds a commit_list to pass a single potential ancestor to is_descendant_of(). The latter leaves the list intact. Release the allocated memory after the call.

Looks obviously correct.

I concur, thanks!

Quoted 11 lines
Quoted 7 lines

---
We could allocate the commit_list on the stack, which would simplify such glue code quite a bit. That would be dangerous in case is_descendant_of() or some other function that is handed such a list tries to consume/free() it. How can we be tell a function is safe to be given a stack-allocated list? Perhaps by marking its argument as const. Or by converting all functions to arrays.

Yeah, if we're not worried about the performance implications of the extra allocation, I think it's better to err on the side of safety.

Quoted 6 lines

I do agree that if we consistently passed an array (and length), some of these functions would get less awkward. I tried a few years ago to convert many of the commit_list uses to arrays, but it was a bit of a yak shave, since often they get lists from callers, who get it from rev_info, etc. And some of those callers _do_ like having lists, because they want to do O(1) splicing, etc.

Yeah, this constant parameter-conversion between the different methods in commit-reach.c is certainly unfortunate, but persists due to historical reasons that Peff mentions.

Thanks,
-Stolee