nwrap: Introduce nwrap_mutex_(un)lock() for better debugging

Signed-off-by: Andreas Schneider <asn@samba.org>
Reviewed-by: Stefan Metzmacher <metze@samba.org>

diff --git a/src/nss_wrapper.c b/src/nss_wrapper.c
index 66df98ef3b4ec90afde549f70a709277a5277e46..8d91e86642d5f047ef2de5213974aa9f6c0d4765 100644 (file)
--- a/src/nss_wrapper.c
+++ b/src/nss_wrapper.c
@@ -177,14 +177,6 @@ typedef nss_status_t NSS_STATUS;
 #define NWRAP_INET_ADDRSTRLEN INET_ADDRSTRLEN
 #endif
 
-#define NWRAP_LOCK(m) do { \
-       pthread_mutex_lock(&( m ## _mutex)); \
-} while(0)
-
-#define NWRAP_UNLOCK(m) do { \
-       pthread_mutex_unlock(&( m ## _mutex)); \
-} while(0)
-
 static pthread_mutex_t libc_symbol_binding_mutex = PTHREAD_MUTEX_INITIALIZER;
 static pthread_mutex_t nss_module_symbol_binding_mutex = PTHREAD_MUTEX_INITIALIZER;
 
@@ -203,25 +195,25 @@ static pthread_mutex_t nwrap_sp_global_mutex = PTHREAD_MUTEX_INITIALIZER;
  * nwrap_init() function.
  */
 # define NWRAP_LOCK_ALL do { \
-       NWRAP_LOCK(libc_symbol_binding); \
-       NWRAP_LOCK(nss_module_symbol_binding); \
-       NWRAP_LOCK(nwrap_initialized); \
-       NWRAP_LOCK(nwrap_global); \
-       NWRAP_LOCK(nwrap_gr_global); \
-       NWRAP_LOCK(nwrap_he_global); \
-       NWRAP_LOCK(nwrap_pw_global); \
-       NWRAP_LOCK(nwrap_sp_global); \
+       nwrap_mutex_lock(&libc_symbol_binding_mutex); \
+       nwrap_mutex_lock(&nss_module_symbol_binding_mutex); \
+       nwrap_mutex_lock(&nwrap_initialized_mutex); \
+       nwrap_mutex_lock(&nwrap_global_mutex); \
+       nwrap_mutex_lock(&nwrap_gr_global_mutex); \
+       nwrap_mutex_lock(&nwrap_he_global_mutex); \
+       nwrap_mutex_lock(&nwrap_pw_global_mutex); \
+       nwrap_mutex_lock(&nwrap_sp_global_mutex); \
 } while (0);
 
 # define NWRAP_UNLOCK_ALL do {\
-       NWRAP_UNLOCK(nwrap_sp_global); \
-       NWRAP_UNLOCK(nwrap_pw_global); \
-       NWRAP_UNLOCK(nwrap_he_global); \
-       NWRAP_UNLOCK(nwrap_gr_global); \
-       NWRAP_UNLOCK(nwrap_global); \
-       NWRAP_UNLOCK(nwrap_initialized); \
-       NWRAP_UNLOCK(nss_module_symbol_binding); \
-       NWRAP_UNLOCK(libc_symbol_binding); \
+       nwrap_mutex_unlock(&nwrap_sp_global_mutex); \
+       nwrap_mutex_unlock(&nwrap_pw_global_mutex); \
+       nwrap_mutex_unlock(&nwrap_he_global_mutex); \
+       nwrap_mutex_unlock(&nwrap_gr_global_mutex); \
+       nwrap_mutex_unlock(&nwrap_global_mutex); \
+       nwrap_mutex_unlock(&nwrap_initialized_mutex); \
+       nwrap_mutex_unlock(&nss_module_symbol_binding_mutex); \
+       nwrap_mutex_unlock(&libc_symbol_binding_mutex); \
 } while (0);
 
 static void nwrap_init(void);
@@ -1214,37 +1206,63 @@ static void *_nwrap_bind_symbol(enum nwrap_lib lib, const char *fn_name)
        return func;
 }
 
+#define nwrap_mutex_lock(m) _nwrap_mutex_lock(m, #m, __func__, __LINE__)
+static void _nwrap_mutex_lock(pthread_mutex_t *mutex, const char *name, const char *caller, unsigned line)
+{
+       int ret;
+
+       ret = pthread_mutex_lock(mutex);
+       if (ret != 0) {
+               NWRAP_LOG(NWRAP_LOG_ERROR, "PID(%d):PPID(%d): %s(%u): Couldn't lock pthread mutex(%s) - %s",
+                         getpid(), getppid(), caller, line, name, strerror(ret));
+               abort();
+       }
+}
+
+#define nwrap_mutex_unlock(m) _nwrap_mutex_unlock(m, #m, __func__, __LINE__)
+static void _nwrap_mutex_unlock(pthread_mutex_t *mutex, const char *name, const char *caller, unsigned line)
+{
+       int ret;
+
+       ret = pthread_mutex_unlock(mutex);
+       if (ret != 0) {
+               NWRAP_LOG(NWRAP_LOG_ERROR, "PID(%d):PPID(%d): %s(%u): Couldn't unlock pthread mutex(%s) - %s",
+                         getpid(), getppid(), caller, line, name, strerror(ret));
+               abort();
+       }
+}
+
 #define nwrap_bind_symbol_libc(sym_name) \
-       NWRAP_LOCK(libc_symbol_binding); \
+       nwrap_mutex_lock(&libc_symbol_binding_mutex); \
        if (nwrap_main_global->libc->symbols._libc_##sym_name.obj == NULL) { \
                nwrap_main_global->libc->symbols._libc_##sym_name.obj = \
                        _nwrap_bind_symbol(NWRAP_LIBC, #sym_name); \
        } \
-       NWRAP_UNLOCK(libc_symbol_binding)
+       nwrap_mutex_unlock(&libc_symbol_binding_mutex)
 
 #define nwrap_bind_symbol_libc_posix(sym_name) \
-       NWRAP_LOCK(libc_symbol_binding); \
+       nwrap_mutex_lock(&libc_symbol_binding_mutex); \
        if (nwrap_main_global->libc->symbols._libc_##sym_name.obj == NULL) { \
                nwrap_main_global->libc->symbols._libc_##sym_name.obj = \
                        _nwrap_bind_symbol(NWRAP_LIBC, "__posix_" #sym_name); \
        } \
-       NWRAP_UNLOCK(libc_symbol_binding)
+       nwrap_mutex_unlock(&libc_symbol_binding_mutex)
 
 #define nwrap_bind_symbol_libnsl(sym_name) \
-       NWRAP_LOCK(libc_symbol_binding); \
+       nwrap_mutex_lock(&libc_symbol_binding_mutex); \
        if (nwrap_main_global->libc->symbols._libc_##sym_name.obj == NULL) { \
                nwrap_main_global->libc->symbols._libc_##sym_name.obj = \
                        _nwrap_bind_symbol(NWRAP_LIBNSL, #sym_name); \
        } \
-       NWRAP_UNLOCK(libc_symbol_binding)
+       nwrap_mutex_unlock(&libc_symbol_binding_mutex)
 
 #define nwrap_bind_symbol_libsocket(sym_name) \
-       NWRAP_LOCK(libc_symbol_binding); \
+       nwrap_mutex_lock(&libc_symbol_binding_mutex); \
        if (nwrap_main_global->libc->symbols._libc_##sym_name.obj == NULL) { \
                nwrap_main_global->libc->symbols._libc_##sym_name.obj = \
                        _nwrap_bind_symbol(NWRAP_LIBSOCKET, #sym_name); \
        } \
-       NWRAP_UNLOCK(libc_symbol_binding)
+       nwrap_mutex_unlock(&libc_symbol_binding_mutex)
 
 /* INTERNAL HELPER FUNCTIONS */
 static void nwrap_lines_unload(struct nwrap_cache *const nwrap)
@@ -1716,20 +1734,20 @@ static void *_nwrap_bind_nss_module_symbol(struct nwrap_backend *b,
 }
 
 #define nwrap_nss_module_bind_symbol(sym_name) \
-       NWRAP_LOCK(nss_module_symbol_binding); \
+       nwrap_mutex_lock(&nss_module_symbol_binding_mutex); \
        if (symbols->_nss_##sym_name.obj == NULL) { \
                symbols->_nss_##sym_name.obj = \
                        _nwrap_bind_nss_module_symbol(b, #sym_name); \
        } \
-       NWRAP_UNLOCK(nss_module_symbol_binding)
+       nwrap_mutex_unlock(&nss_module_symbol_binding_mutex)
 
 #define nwrap_nss_module_bind_symbol2(sym_name, alt_name) \
-       NWRAP_LOCK(nss_module_symbol_binding); \
+       nwrap_mutex_lock(&nss_module_symbol_binding_mutex); \
        if (symbols->_nss_##sym_name.obj == NULL) { \
                symbols->_nss_##sym_name.obj = \
                        _nwrap_bind_nss_module_symbol(b, #alt_name); \
        } \
-       NWRAP_UNLOCK(nss_module_symbol_binding)
+       nwrap_mutex_unlock(&nss_module_symbol_binding_mutex)
 
 static struct nwrap_nss_module_symbols *
 nwrap_bind_nss_module_symbols(struct nwrap_backend *b)
@@ -1867,9 +1885,9 @@ static void nwrap_init(void)
        size_t max_hostents_tmp;
        int ok;
 
-       NWRAP_LOCK(nwrap_initialized);
+       nwrap_mutex_lock(&nwrap_initialized_mutex);
        if (nwrap_initialized) {
-               NWRAP_UNLOCK(nwrap_initialized);
+               nwrap_mutex_unlock(&nwrap_initialized_mutex);
                return;
        }
 
@@ -1878,11 +1896,11 @@ static void nwrap_init(void)
         * We don't use NWRAP_(UN)LOCK_ALL macros here because we
         * want to avoid overhead when other threads do their job.
         */
-       NWRAP_LOCK(nwrap_global);
-       NWRAP_LOCK(nwrap_gr_global);
-       NWRAP_LOCK(nwrap_he_global);
-       NWRAP_LOCK(nwrap_pw_global);
-       NWRAP_LOCK(nwrap_sp_global);
+       nwrap_mutex_lock(&nwrap_global_mutex);
+       nwrap_mutex_lock(&nwrap_gr_global_mutex);
+       nwrap_mutex_lock(&nwrap_he_global_mutex);
+       nwrap_mutex_lock(&nwrap_pw_global_mutex);
+       nwrap_mutex_lock(&nwrap_sp_global_mutex);
 
        nwrap_initialized = true;
 
@@ -1961,12 +1979,12 @@ static void nwrap_init(void)
        nwrap_he_global.cache->unload = nwrap_he_unload;
 
        /* We hold all locks here so we can use NWRAP_UNLOCK_ALL. */
-       NWRAP_UNLOCK(nwrap_sp_global);
-       NWRAP_UNLOCK(nwrap_pw_global);
-       NWRAP_UNLOCK(nwrap_he_global);
-       NWRAP_UNLOCK(nwrap_gr_global);
-       NWRAP_UNLOCK(nwrap_global);
-       NWRAP_UNLOCK(nwrap_initialized);
+       nwrap_mutex_unlock(&nwrap_sp_global_mutex);
+       nwrap_mutex_unlock(&nwrap_pw_global_mutex);
+       nwrap_mutex_unlock(&nwrap_he_global_mutex);
+       nwrap_mutex_unlock(&nwrap_gr_global_mutex);
+       nwrap_mutex_unlock(&nwrap_global_mutex);
+       nwrap_mutex_unlock(&nwrap_initialized_mutex);
 }
 
 bool nss_wrapper_enabled(void)