Make xmalloc and xrealloc thread-safe

By providing a hook for the routine responsible for trying to free some
memory on malloc failure, we can ensure that the  called routine is
protected by the appropriate locks when threads are in play.

The obvious offender here was pack-objects which was calling xmalloc()
within threads while release_pack_memory() is not thread safe.

Signed-off-by: Nicolas Pitre <nico@fluxnic.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin-pack-objects.c b/builtin-pack-objects.c
index 539e75d56f7a33fdb1971b51ee0681c43e9662b0..0ecc198422620780740f9589e3771eaee0f8ffd6 100644 (file)
--- a/builtin-pack-objects.c
+++ b/builtin-pack-objects.c
@@ -1549,6 +1549,13 @@ static void find_deltas(struct object_entry **list, unsigned *list_size,
 
 #ifndef NO_PTHREADS
 
 
 #ifndef NO_PTHREADS
 

+static void try_to_free_from_threads(size_t size)
+{
+       read_lock();
+       release_pack_memory(size, -1);
+       read_unlock();
+}
+

 /*
  * The main thread waits on the condition that (at least) one of the workers
  * has stopped working (which is indicated in the .working member of
 /*
  * The main thread waits on the condition that (at least) one of the workers
  * has stopped working (which is indicated in the .working member of


@@ -1583,10 +1590,12 @@ static void init_threaded_search(void)
        pthread_mutex_init(&cache_mutex, NULL);
        pthread_mutex_init(&progress_mutex, NULL);
        pthread_cond_init(&progress_cond, NULL);
        pthread_mutex_init(&cache_mutex, NULL);
        pthread_mutex_init(&progress_mutex, NULL);
        pthread_cond_init(&progress_cond, NULL);

+       set_try_to_free_routine(try_to_free_from_threads);

 }
 
 static void cleanup_threaded_search(void)
 {
 }
 
 static void cleanup_threaded_search(void)
 {

+       set_try_to_free_routine(NULL);

        pthread_cond_destroy(&progress_cond);
        pthread_mutex_destroy(&read_mutex);
        pthread_mutex_destroy(&cache_mutex);
        pthread_cond_destroy(&progress_cond);
        pthread_mutex_destroy(&read_mutex);
        pthread_mutex_destroy(&cache_mutex);

diff --git a/git-compat-util.h b/git-compat-util.h
index a3c45373669cd8482c04d5815862ed36a153572d..1c171db8b1fb46c5230280b0ebd872c8f23cf7c0 100644 (file)
--- a/git-compat-util.h
+++ b/git-compat-util.h
@@ -346,6 +346,8 @@ static inline char *gitstrchrnul(const char *s, int c)
 
 extern void release_pack_memory(size_t, int);
 
 
 extern void release_pack_memory(size_t, int);
 

+extern void set_try_to_free_routine(void (*routine)(size_t));
+

 extern char *xstrdup(const char *str);
 extern void *xmalloc(size_t size);
 extern void *xmallocz(size_t size);
 extern char *xstrdup(const char *str);
 extern void *xmalloc(size_t size);
 extern void *xmallocz(size_t size);

diff --git a/wrapper.c b/wrapper.c
index 9c71b21242773f52ca560d7e5e5e52123674d334..62edb57338ccd1ae56b86649ec07d88c251576da 100644 (file)
--- a/wrapper.c
+++ b/wrapper.c
@@ -3,11 +3,23 @@
  */
 #include "cache.h"
 
  */
 #include "cache.h"
 

+static void try_to_free_builtin(size_t size)
+{
+       release_pack_memory(size, -1);
+}
+
+static void (*try_to_free_routine)(size_t size) = try_to_free_builtin;
+
+void set_try_to_free_routine(void (*routine)(size_t))
+{
+       try_to_free_routine = (routine) ? routine : try_to_free_builtin;
+}
+

 char *xstrdup(const char *str)
 {
        char *ret = strdup(str);
        if (!ret) {
 char *xstrdup(const char *str)
 {
        char *ret = strdup(str);
        if (!ret) {

-               release_pack_memory(strlen(str) + 1, -1);
+               try_to_free_routine(strlen(str) + 1);

                ret = strdup(str);
                if (!ret)
                        die("Out of memory, strdup failed");
                ret = strdup(str);
                if (!ret)
                        die("Out of memory, strdup failed");


@@ -21,7 +33,7 @@ void *xmalloc(size_t size)
        if (!ret && !size)
                ret = malloc(1);
        if (!ret) {
        if (!ret && !size)
                ret = malloc(1);
        if (!ret) {

-               release_pack_memory(size, -1);
+               try_to_free_routine(size);

                ret = malloc(size);
                if (!ret && !size)
                        ret = malloc(1);
                ret = malloc(size);
                if (!ret && !size)
                        ret = malloc(1);


@@ -67,7 +79,7 @@ void *xrealloc(void *ptr, size_t size)
        if (!ret && !size)
                ret = realloc(ptr, 1);
        if (!ret) {
        if (!ret && !size)
                ret = realloc(ptr, 1);
        if (!ret) {

-               release_pack_memory(size, -1);
+               try_to_free_routine(size);

                ret = realloc(ptr, size);
                if (!ret && !size)
                        ret = realloc(ptr, 1);
                ret = realloc(ptr, size);
                if (!ret && !size)
                        ret = realloc(ptr, 1);


@@ -83,7 +95,7 @@ void *xcalloc(size_t nmemb, size_t size)
        if (!ret && (!nmemb || !size))
                ret = calloc(1, 1);
        if (!ret) {
        if (!ret && (!nmemb || !size))
                ret = calloc(1, 1);
        if (!ret) {

-               release_pack_memory(nmemb * size, -1);
+               try_to_free_routine(nmemb * size);

                ret = calloc(nmemb, size);
                if (!ret && (!nmemb || !size))
                        ret = calloc(1, 1);
                ret = calloc(nmemb, size);
                if (!ret && (!nmemb || !size))
                        ret = calloc(1, 1);