Merge pull request libgit2#6563 from libgit2/pks/test-allocator

tests: add allocator with limited number of bytes

Author: ethomson

include/git2/sys/alloc.h

@@ -24,47 +24,13 @@ typedef struct {
 	/** Allocate `n` bytes of memory */
 	void * GIT_CALLBACK(gmalloc)(size_t n, const char *file, int line);
 
-	/**
-	 * Allocate memory for an array of `nelem` elements, where each element
-	 * has a size of `elsize`. Returned memory shall be initialized to
-	 * all-zeroes
-	 */
-	void * GIT_CALLBACK(gcalloc)(size_t nelem, size_t elsize, const char *file, int line);
-
-	/** Allocate memory for the string `str` and duplicate its contents. */
-	char * GIT_CALLBACK(gstrdup)(const char *str, const char *file, int line);
-
-	/**
-	 * Equivalent to the `gstrdup` function, but only duplicating at most
-	 * `n + 1` bytes
-	 */
-	char * GIT_CALLBACK(gstrndup)(const char *str, size_t n, const char *file, int line);
-
-	/**
-	 * Equivalent to `gstrndup`, but will always duplicate exactly `n` bytes
-	 * of `str`. Thus, out of bounds reads at `str` may happen.
-	 */
-	char * GIT_CALLBACK(gsubstrdup)(const char *str, size_t n, const char *file, int line);
-
 	/**
 	 * This function shall deallocate the old object `ptr` and return a
 	 * pointer to a new object that has the size specified by `size`. In
 	 * case `ptr` is `NULL`, a new array shall be allocated.
 	 */
 	void * GIT_CALLBACK(grealloc)(void *ptr, size_t size, const char *file, int line);
 
-	/**
-	 * This function shall be equivalent to `grealloc`, but allocating
-	 * `neleme * elsize` bytes.
-	 */
-	void * GIT_CALLBACK(greallocarray)(void *ptr, size_t nelem, size_t elsize, const char *file, int line);
-
-	/**
-	 * This function shall allocate a new array of `nelem` elements, where
-	 * each element has a size of `elsize` bytes.
-	 */
-	void * GIT_CALLBACK(gmallocarray)(size_t nelem, size_t elsize, const char *file, int line);
-
 	/**
 	 * This function shall free the memory pointed to by `ptr`. In case
 	 * `ptr` is `NULL`, this shall be a no-op.

src/libgit2/threadstate.c

@@ -75,10 +75,23 @@ git_threadstate *git_threadstate_get(void)
 	if ((threadstate = git_tlsdata_get(tls_key)) != NULL)
 		return threadstate;
 
-	if ((threadstate = git__calloc(1, sizeof(git_threadstate))) == NULL ||
-	    git_str_init(&threadstate->error_buf, 0) < 0)
+	/*
+	 * Avoid git__malloc here, since if it fails, it sets an error
+	 * message, which requires thread state, which would allocate
+	 * here, which would fail, which would set an error message...
+	 */
+
+	if ((threadstate = git__allocator.gmalloc(sizeof(git_threadstate),
+			__FILE__, __LINE__)) == NULL)
 		return NULL;
 
+	memset(threadstate, 0, sizeof(git_threadstate));
+
+	if (git_str_init(&threadstate->error_buf, 0) < 0) {
+		git__allocator.gfree(threadstate);
+		return NULL;
+	}
+
 	git_tlsdata_set(tls_key, threadstate);
 	return threadstate;
 }

src/util/alloc.c

@@ -15,16 +15,75 @@
 /* Fail any allocation until git_libgit2_init is called. */
 git_allocator git__allocator = {
 	git_failalloc_malloc,
-	git_failalloc_calloc,
-	git_failalloc_strdup,
-	git_failalloc_strndup,
-	git_failalloc_substrdup,
 	git_failalloc_realloc,
-	git_failalloc_reallocarray,
-	git_failalloc_mallocarray,
 	git_failalloc_free
 };
 
+void *git__calloc(size_t nelem, size_t elsize)
+{
+	size_t newsize;
+	void *ptr;
+
+	if (GIT_MULTIPLY_SIZET_OVERFLOW(&newsize, nelem, elsize))
+		return NULL;
+
+	if ((ptr = git__malloc(newsize)))
+		memset(ptr, 0, newsize);
+
+	return ptr;
+}
+
+void *git__reallocarray(void *ptr, size_t nelem, size_t elsize)
+{
+	size_t newsize;
+
+	if (GIT_MULTIPLY_SIZET_OVERFLOW(&newsize, nelem, elsize))
+		return NULL;
+
+	return git__realloc(ptr, newsize);
+}
+
+void *git__mallocarray(size_t nelem, size_t elsize)
+{
+	return git__reallocarray(NULL, nelem, elsize);
+}
+
+char *git__strdup(const char *str)
+{
+	size_t len = strlen(str) + 1;
+	void *ptr = git__malloc(len);
+
+	if (ptr)
+		memcpy(ptr, str, len);
+
+	return ptr;
+}
+
+char *git__strndup(const char *str, size_t n)
+{
+	size_t len = p_strnlen(str, n);
+	char *ptr = git__malloc(len + 1);
+
+	if (ptr) {
+		memcpy(ptr, str, len);
+		ptr[len] = '\0';
+	}
+
+	return ptr;
+}
+
+char *git__substrdup(const char *str, size_t n)
+{
+	char *ptr = git__malloc(n + 1);
+
+	if (ptr) {
+		memcpy(ptr, str, n);
+		ptr[n] = '\0';
+	}
+
+	return ptr;
+}
+
 static int setup_default_allocator(void)
 {
 #if defined(GIT_WIN32_LEAKCHECK)

src/util/alloc.h

@@ -10,17 +10,42 @@
 
 #include "git2/sys/alloc.h"
 
+#include "git2_util.h"
+
 extern git_allocator git__allocator;
 
-#define git__malloc(len)                      git__allocator.gmalloc(len, __FILE__, __LINE__)
-#define git__calloc(nelem, elsize)            git__allocator.gcalloc(nelem, elsize, __FILE__, __LINE__)
-#define git__strdup(str)                      git__allocator.gstrdup(str, __FILE__, __LINE__)
-#define git__strndup(str, n)                  git__allocator.gstrndup(str, n, __FILE__, __LINE__)
-#define git__substrdup(str, n)                git__allocator.gsubstrdup(str, n, __FILE__, __LINE__)
-#define git__realloc(ptr, size)               git__allocator.grealloc(ptr, size, __FILE__, __LINE__)
-#define git__reallocarray(ptr, nelem, elsize) git__allocator.greallocarray(ptr, nelem, elsize, __FILE__, __LINE__)
-#define git__mallocarray(nelem, elsize)       git__allocator.gmallocarray(nelem, elsize, __FILE__, __LINE__)
-#define git__free                             git__allocator.gfree
+GIT_INLINE(void *) git__malloc(size_t len)
+{
+	void *p = git__allocator.gmalloc(len, __FILE__, __LINE__);
+
+	if (!p)
+		git_error_set_oom();
+
+	return p;
+}
+
+GIT_INLINE(void *) git__realloc(void *ptr, size_t size)
+{
+	void *p = git__allocator.grealloc(ptr, size, __FILE__, __LINE__);
+
+	if (!p)
+		git_error_set_oom();
+
+	return p;
+}
+
+GIT_INLINE(void) git__free(void *ptr)
+{
+	git__allocator.gfree(ptr);
+}
+
+extern void *git__calloc(size_t nelem, size_t elsize);
+extern void *git__mallocarray(size_t nelem, size_t elsize);
+extern void *git__reallocarray(void *ptr, size_t nelem, size_t elsize);
+
+extern char *git__strdup(const char *str);
+extern char *git__strndup(const char *str, size_t n);
+extern char *git__substrdup(const char *str, size_t n);
 
 /**
  * This function is being called by our global setup routines to

src/util/allocators/failalloc.c

@@ -16,45 +16,6 @@ void *git_failalloc_malloc(size_t len, const char *file, int line)
 	return NULL;
 }
 
-void *git_failalloc_calloc(size_t nelem, size_t elsize, const char *file, int line)
-{
-	GIT_UNUSED(nelem);
-	GIT_UNUSED(elsize);
-	GIT_UNUSED(file);
-	GIT_UNUSED(line);
-
-	return NULL;
-}
-
-char *git_failalloc_strdup(const char *str, const char *file, int line)
-{
-	GIT_UNUSED(str);
-	GIT_UNUSED(file);
-	GIT_UNUSED(line);
-
-	return NULL;
-}
-
-char *git_failalloc_strndup(const char *str, size_t n, const char *file, int line)
-{
-	GIT_UNUSED(str);
-	GIT_UNUSED(n);
-	GIT_UNUSED(file);
-	GIT_UNUSED(line);
-
-	return NULL;
-}
-
-char *git_failalloc_substrdup(const char *start, size_t n, const char *file, int line)
-{
-	GIT_UNUSED(start);
-	GIT_UNUSED(n);
-	GIT_UNUSED(file);
-	GIT_UNUSED(line);
-
-	return NULL;
-}
-
 void *git_failalloc_realloc(void *ptr, size_t size, const char *file, int line)
 {
 	GIT_UNUSED(ptr);
@@ -65,27 +26,6 @@ void *git_failalloc_realloc(void *ptr, size_t size, const char *file, int line)
 	return NULL;
 }
 
-void *git_failalloc_reallocarray(void *ptr, size_t nelem, size_t elsize, const char *file, int line)
-{
-	GIT_UNUSED(ptr);
-	GIT_UNUSED(nelem);
-	GIT_UNUSED(elsize);
-	GIT_UNUSED(file);
-	GIT_UNUSED(line);
-
-	return NULL;
-}
-
-void *git_failalloc_mallocarray(size_t nelem, size_t elsize, const char *file, int line)
-{
-	GIT_UNUSED(nelem);
-	GIT_UNUSED(elsize);
-	GIT_UNUSED(file);
-	GIT_UNUSED(line);
-
-	return NULL;
-}
-
 void git_failalloc_free(void *ptr)
 {
 	GIT_UNUSED(ptr);

src/util/allocators/failalloc.h

@@ -11,13 +11,7 @@
 #include "git2_util.h"
 
 extern void *git_failalloc_malloc(size_t len, const char *file, int line);
-extern void *git_failalloc_calloc(size_t nelem, size_t elsize, const char *file, int line);
-extern char *git_failalloc_strdup(const char *str, const char *file, int line);
-extern char *git_failalloc_strndup(const char *str, size_t n, const char *file, int line);
-extern char *git_failalloc_substrdup(const char *start, size_t n, const char *file, int line);
 extern void *git_failalloc_realloc(void *ptr, size_t size, const char *file, int line);
-extern void *git_failalloc_reallocarray(void *ptr, size_t nelem, size_t elsize, const char *file, int line);
-extern void *git_failalloc_mallocarray(size_t nelem, size_t elsize, const char *file, int line);
 extern void git_failalloc_free(void *ptr);
 
 #endif