make locking a compile-time setting

Author: QuietMisdreavus

CMakeLists.txt

@@ -18,6 +18,7 @@ option(CMARK_TESTS "Build cmark-gfm tests and enable testing" ON)
 option(CMARK_STATIC "Build static libcmark-gfm library" ON)
 option(CMARK_SHARED "Build shared libcmark-gfm library" ON)
 option(CMARK_LIB_FUZZER "Build libFuzzer fuzzing harness" OFF)
+option(CMARK_THREADING "Add locks around static accesses via pthreads" OFF)
 
 add_subdirectory(src)
 add_subdirectory(extensions)

extensions/core-extensions.c

@@ -1,6 +1,3 @@
-#include <pthread.h>
-#include <stdatomic.h>
-
 #include "cmark-gfm-core-extensions.h"
 #include "autolink.h"
 #include "mutex.h"
@@ -11,19 +8,17 @@
 #include "registry.h"
 #include "plugin.h"
 
-static pthread_mutex_t extensions_lock;
-static atomic_int extensions_latch = 0;
+CMARK_DEFINE_LOCK(extensions);
 
 static int core_extensions_registration(cmark_plugin *plugin) {
-  initialize_mutex_once(&extensions_lock, &extensions_latch);
-  pthread_mutex_lock(&extensions_lock);
+  CMARK_INITIALIZE_AND_LOCK(extensions);
   cmark_plugin_register_syntax_extension(plugin, create_table_extension());
   cmark_plugin_register_syntax_extension(plugin,
                                          create_strikethrough_extension());
   cmark_plugin_register_syntax_extension(plugin, create_autolink_extension());
   cmark_plugin_register_syntax_extension(plugin, create_tagfilter_extension());
   cmark_plugin_register_syntax_extension(plugin, create_tasklist_extension());
-  pthread_mutex_unlock(&extensions_lock);
+  CMARK_UNLOCK(extensions);
   return 1;
 }
 
@@ -32,11 +27,10 @@ static atomic_int registered_latch = 0;
 static _Atomic int registered = 0;
 
 void cmark_gfm_core_extensions_ensure_registered(void) {
-  initialize_mutex_once(&registered_lock, &registered_latch);
-  pthread_mutex_lock(&registered_lock);
+  CMARK_INITIALIZE_AND_LOCK(extensions);
   if (!registered) {
     cmark_register_plugin(core_extensions_registration);
     registered = 1;
   }
-  pthread_mutex_unlock(&registered_lock);
+  CMARK_UNLOCK(extensions);
 }

src/arena.c

@@ -1,14 +1,11 @@
-#include <pthread.h>
-#include <stdatomic.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
 #include "cmark-gfm.h"
 #include "cmark-gfm-extension_api.h"
 #include "mutex.h"
 
-static pthread_mutex_t arena_lock;
-static atomic_int arena_latch = 0;
+CMARK_DEFINE_LOCK(arena)
 
 static struct arena_chunk {
   size_t sz, used;
@@ -30,13 +27,12 @@ static struct arena_chunk *alloc_arena_chunk(size_t sz, struct arena_chunk *prev
 }
 
 void cmark_arena_push(void) {
-  initialize_mutex_once(&arena_lock, &arena_latch);
-  pthread_mutex_lock(&arena_lock);
+  CMARK_INITIALIZE_AND_LOCK(arena);
   if (!A)
     return;
   A->push_point = 1;
   A = alloc_arena_chunk(10240, A);
-  pthread_mutex_unlock(&arena_lock);
+  CMARK_UNLOCK(arena);
 }
 
 int cmark_arena_pop(void) {
@@ -77,8 +73,7 @@ static void *arena_calloc(size_t nmem, size_t size) {
   const size_t align = sizeof(size_t) - 1;
   sz = (sz + align) & ~align;
 
-  // the arena lock will have already been set up by a previous call to init_arena
-  pthread_mutex_lock(&arena_lock);
+  CMARK_INITIALIZE_AND_LOCK(arena);
 
   if (sz > A->sz) {
     A->prev = alloc_arena_chunk(sz, A->prev);
@@ -90,7 +85,7 @@ static void *arena_calloc(size_t nmem, size_t size) {
   void *ptr = (uint8_t *) A->ptr + A->used;
   A->used += sz;
 
-  pthread_mutex_unlock(&arena_lock);
+  CMARK_UNLOCK(arena);
 
   *((size_t *) ptr) = sz - sizeof(size_t);
   return (uint8_t *) ptr + sizeof(size_t);

src/config.h.in

@@ -17,6 +17,8 @@ extern "C" {
 
 #cmakedefine HAVE___ATTRIBUTE__
 
+#cmakedefine CMARK_THREADING
+
 #ifdef HAVE___ATTRIBUTE__
   #define CMARK_ATTRIBUTE(list) __attribute__ (list)
 #else

src/include/cmark-gfm_config.h

@@ -17,6 +17,8 @@ extern "C" {
 
 #define HAVE___ATTRIBUTE__
 
+#define CMARK_THREADING
+
 #ifdef HAVE___ATTRIBUTE__
   #define CMARK_ATTRIBUTE(list) __attribute__ (list)
 #else

src/include/mutex.h

@@ -1,11 +1,13 @@
 #ifndef CMARK_MUTEX_H
 #define CMARK_MUTEX_H
 
+#include "cmark-gfm_config.h"
+
+#ifdef CMARK_THREADING
+
 #include <pthread.h>
 #include <stdatomic.h>
 
-#include "cmark-gfm_config.h"
-
 static CMARK_INLINE void initialize_mutex_once(pthread_mutex_t *m, atomic_int *latch) {
   int expected = 0;
 
@@ -14,4 +16,22 @@ static CMARK_INLINE void initialize_mutex_once(pthread_mutex_t *m, atomic_int *l
   }
 }
 
-#endif
+#define CMARK_DEFINE_LOCK(NAME) \
+static pthread_mutex_t NAME##_lock; \
+static atomic_int NAME##_latch = 0;
+
+#define CMARK_INITIALIZE_AND_LOCK(NAME) \
+initialize_mutex_once(&NAME##_lock, &NAME##_latch); \
+pthread_mutex_lock(&NAME##_lock);
+
+#define CMARK_UNLOCK(NAME) pthread_mutex_unlock(&NAME##_lock);
+
+#else // no threading support
+
+#define CMARK_DEFINE_LOCK(NAME)
+#define CMARK_INITIALIZE_AND_LOCK(NAME)
+#define CMARK_UNLOCK(NAME)
+
+#endif // CMARK_THREADING
+
+#endif // CMARK_MUTEX_H

src/inlines.c

@@ -1,8 +1,6 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <pthread.h>
-#include <stdatomic.h>
 
 #include "cmark_ctype.h"
 #include "cmark-gfm_config.h"
@@ -69,8 +67,7 @@ typedef struct subject{
 // Extensions may populate this.
 static int8_t SKIP_CHARS[256];
 
-pthread_mutex_t chars_lock;
-static atomic_int chars_latch = 0;
+CMARK_DEFINE_LOCK(chars);
 
 static CMARK_INLINE bool S_is_line_end_char(char c) {
   return (c == '\n' || c == '\r');
@@ -411,8 +408,7 @@ static int scan_delims(subject *subj, unsigned char c, bool *can_open,
   } else {
     before_char_pos = subj->pos - 1;
 
-    initialize_mutex_once(&chars_lock, &chars_latch);
-    pthread_mutex_lock(&chars_lock);
+    CMARK_INITIALIZE_AND_LOCK(chars);
 
     // walk back to the beginning of the UTF_8 sequence:
     while ((peek_at(subj, before_char_pos) >> 6 == 2 || SKIP_CHARS[peek_at(subj, before_char_pos)]) && before_char_pos > 0) {
@@ -424,7 +420,7 @@ static int scan_delims(subject *subj, unsigned char c, bool *can_open,
       before_char = 10;
     }
 
-    pthread_mutex_unlock(&chars_lock);
+    CMARK_UNLOCK(chars);
   }
 
   if (c == '\'' || c == '"') {
@@ -442,8 +438,7 @@ static int scan_delims(subject *subj, unsigned char c, bool *can_open,
   } else {
     after_char_pos = subj->pos;
 
-    initialize_mutex_once(&chars_lock, &chars_latch);
-    pthread_mutex_lock(&chars_lock);
+    CMARK_INITIALIZE_AND_LOCK(chars);
 
     while (SKIP_CHARS[peek_at(subj, after_char_pos)] && after_char_pos < subj->input.len) {
       after_char_pos += 1;
@@ -454,7 +449,7 @@ static int scan_delims(subject *subj, unsigned char c, bool *can_open,
       after_char = 10;
     }
 
-    pthread_mutex_unlock(&chars_lock);
+    CMARK_UNLOCK(chars);
   }
 
   left_flanking = numdelims > 0 && !cmark_utf8proc_is_space(after_char) &&
@@ -1382,21 +1377,19 @@ static bufsize_t subject_find_special_char(subject *subj, int options) {
 }
 
 void cmark_inlines_add_special_character(unsigned char c, bool emphasis) {
-  initialize_mutex_once(&chars_lock, &chars_latch);
-  pthread_mutex_lock(&chars_lock);
+  CMARK_INITIALIZE_AND_LOCK(chars);
   SPECIAL_CHARS[c] = 1;
   if (emphasis)
     SKIP_CHARS[c] = 1;
-  pthread_mutex_unlock(&chars_lock);
+  CMARK_UNLOCK(chars);
 }
 
 void cmark_inlines_remove_special_character(unsigned char c, bool emphasis) {
-  initialize_mutex_once(&chars_lock, &chars_latch);
-  pthread_mutex_lock(&chars_lock);
+  CMARK_INITIALIZE_AND_LOCK(chars);
   SPECIAL_CHARS[c] = 0;
   if (emphasis)
     SKIP_CHARS[c] = 0;
-  pthread_mutex_unlock(&chars_lock);
+  CMARK_UNLOCK(chars);
 }
 
 static cmark_node *try_extensions(cmark_parser *parser,

src/registry.c

@@ -1,4 +1,3 @@
-#include <stdatomic.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
@@ -14,8 +13,7 @@ extern cmark_mem CMARK_DEFAULT_MEM_ALLOCATOR;
 
 static cmark_llist *syntax_extensions = NULL;
 
-static pthread_mutex_t extensions_lock;
-static atomic_int extensions_latch = 0;
+CMARK_DEFINE_LOCK(extensions);
 
 void cmark_register_plugin(cmark_plugin_init_func reg_fn) {
   cmark_plugin *plugin = cmark_plugin_new();
@@ -28,22 +26,20 @@ void cmark_register_plugin(cmark_plugin_init_func reg_fn) {
   cmark_llist *syntax_extensions_list = cmark_plugin_steal_syntax_extensions(plugin),
               *it;
 
-  initialize_mutex_once(&extensions_lock, &extensions_latch);
-  pthread_mutex_lock(&extensions_lock);
+  CMARK_INITIALIZE_AND_LOCK(extensions);
 
   for (it = syntax_extensions_list; it; it = it->next) {
     syntax_extensions = cmark_llist_append(&CMARK_DEFAULT_MEM_ALLOCATOR, syntax_extensions, it->data);
   }
 
-  pthread_mutex_unlock(&extensions_lock);
+  CMARK_UNLOCK(extensions);
 
   cmark_llist_free(&CMARK_DEFAULT_MEM_ALLOCATOR, syntax_extensions_list);
   cmark_plugin_free(plugin);
 }
 
 void cmark_release_plugins(void) {
-  initialize_mutex_once(&extensions_lock, &extensions_latch);
-  pthread_mutex_lock(&extensions_lock);
+  CMARK_INITIALIZE_AND_LOCK(extensions);
 
   if (syntax_extensions) {
     cmark_llist_free_full(
@@ -53,30 +49,28 @@ void cmark_release_plugins(void) {
     syntax_extensions = NULL;
   }
 
-  pthread_mutex_unlock(&extensions_lock);
+  CMARK_UNLOCK(extensions);
 }
 
 cmark_llist *cmark_list_syntax_extensions(cmark_mem *mem) {
   cmark_llist *it;
   cmark_llist *res = NULL;
 
-  initialize_mutex_once(&extensions_lock, &extensions_latch);
-  pthread_mutex_lock(&extensions_lock);
+  CMARK_INITIALIZE_AND_LOCK(extensions);
 
   for (it = syntax_extensions; it; it = it->next) {
     res = cmark_llist_append(mem, res, it->data);
   }
 
-  pthread_mutex_unlock(&extensions_lock);
+  CMARK_UNLOCK(extensions);
   return res;
 }
 
 cmark_syntax_extension *cmark_find_syntax_extension(const char *name) {
   cmark_llist *tmp;
   cmark_syntax_extension *res = NULL;
 
-  initialize_mutex_once(&extensions_lock, &extensions_latch);
-  pthread_mutex_lock(&extensions_lock);
+  CMARK_INITIALIZE_AND_LOCK(extensions);
 
   for (tmp = syntax_extensions; tmp; tmp = tmp->next) {
     cmark_syntax_extension *ext = (cmark_syntax_extension *) tmp->data;
@@ -86,6 +80,6 @@ cmark_syntax_extension *cmark_find_syntax_extension(const char *name) {
     }
   }
 
-  pthread_mutex_unlock(&extensions_lock);
+  CMARK_UNLOCK(extensions);
   return res;
 }