hash_to_hex_algop() returns a static buffer, relieving callers from the
responsibility of freeing memory after use. But the current
implementation uses the same static data for all threads and, thus, is
not thread-safe. We could avoid using this function and its wrappers
in threaded code, but they are sometimes too deep in the call stack to
be noticed or even avoided.
For example, we can take a look at the number of oid_to_hex() calls,
which calls hash_to_hex_algop():
$ git grep 'oid_to_hex(' | wc -l
818
Although these functions don't seem to be causing problems out there for
now (at least not reported), making them thread-safe makes the codebase
more robust against race conditions. We can easily do that replicating
the static buffer in each thread's local storage.
Original-patch-by: Fredrik Kuivinen <frekui@xxxxxxxxx>
Signed-off-by: Matheus Tavares <matheus.bernardino@xxxxxx>
---
hex.c | 45 +++++++++++++++++++++++++++++++++++++++++----
1 file changed, 41 insertions(+), 4 deletions(-)
diff --git a/hex.c b/hex.c
index da51e64929..1094ed25bd 100644
--- a/hex.c
+++ b/hex.c
@@ -136,12 +136,49 @@ char *oid_to_hex_r(char *buffer, const struct object_id *oid)
return hash_to_hex_algop_r(buffer, oid->hash, the_hash_algo);
}
+struct hexbuf_array {
+ int idx;
+ char bufs[4][GIT_MAX_HEXSZ + 1];
+};
+
+#ifdef HAVE_THREADS
+static pthread_key_t hexbuf_array_key;
+static pthread_once_t hexbuf_array_once = PTHREAD_ONCE_INIT;
+
+void init_hexbuf_array_key(void)
+{
+ if (pthread_key_create(&hexbuf_array_key, free))
+ die(_("failed to initialize threads' key for hash to hex conversion"));
+}
+
+#else
+static struct hexbuf_array default_hexbuf_array;
+#endif
+
char *hash_to_hex_algop(const unsigned char *hash, const struct git_hash_algo *algop)
{
- static int bufno;
- static char hexbuffer[4][GIT_MAX_HEXSZ + 1];
- bufno = (bufno + 1) % ARRAY_SIZE(hexbuffer);
- return hash_to_hex_algop_r(hexbuffer[bufno], hash, algop);
+ struct hexbuf_array *ha;
+
+#ifdef HAVE_THREADS
+ void *value;
+
+ if (pthread_once(&hexbuf_array_once, init_hexbuf_array_key))
+ die(_("failed to initialize threads' key for hash to hex conversion"));
+
+ value = pthread_key_getspecific(&hexbuf_array_key);
+ if (value) {
+ ha = (struct hexbuf_array *) value;
+ } else {
+ ha = xmalloc(sizeof(*ha));
+ if (pthread_key_setspecific(&hexbuf_array_key, (void *)ha))
+ die(_("failed to set thread buffer for hash to hex conversion"));
+ }
+#else
+ ha = &default_hexbuf_array;
+#endif
+
+ ha->idx = (ha->idx + 1) % ARRAY_SIZE(ha->bufs);
+ return hash_to_hex_algop_r(ha->bufs[ha->idx], hash, algop);
}
char *hash_to_hex(const unsigned char *hash)
--
2.26.2
