rx-afs-kmutex-kcondvar-20090113

LICENSE BSD

The rx_pthread.h defines afs_kcondvar_t and afs_kmutex_t but
their use throughout the rx library is inconsistent.  Sometimes
they are used, other times pthread_cond_t and pthread_mutex_t.

This commit ensures that afs_kmutex_t and afs_kcondvar_t are
used consistently.

diff --git a/src/rx/rx.c b/src/rx/rx.c
index 11b02b8..73caae9 100644 (file)
--- a/src/rx/rx.c
+++ b/src/rx/rx.c
@@ -164,75 +164,55 @@ static unsigned int rxi_rpc_process_stat_cnt;
  * to ease NT porting
  */
 
-extern pthread_mutex_t rx_stats_mutex;
-extern pthread_mutex_t rx_waiting_mutex;
-extern pthread_mutex_t rx_quota_mutex;
-extern pthread_mutex_t rx_pthread_mutex;
-extern pthread_mutex_t rx_packets_mutex;
-extern pthread_mutex_t des_init_mutex;
-extern pthread_mutex_t des_random_mutex;
-extern pthread_mutex_t rx_clock_mutex;
-extern pthread_mutex_t rxi_connCacheMutex;
-extern pthread_mutex_t rx_event_mutex;
-extern pthread_mutex_t osi_malloc_mutex;
-extern pthread_mutex_t event_handler_mutex;
-extern pthread_mutex_t listener_mutex;
-extern pthread_mutex_t rx_if_init_mutex;
-extern pthread_mutex_t rx_if_mutex;
-extern pthread_mutex_t rxkad_client_uid_mutex;
-extern pthread_mutex_t rxkad_random_mutex;
-
-extern pthread_cond_t rx_event_handler_cond;
-extern pthread_cond_t rx_listener_cond;
-
-static pthread_mutex_t epoch_mutex;
-static pthread_mutex_t rx_init_mutex;
-static pthread_mutex_t rx_debug_mutex;
-static pthread_mutex_t rx_rpc_stats;
+extern afs_kmutex_t rx_stats_mutex;
+extern afs_kmutex_t rx_waiting_mutex;
+extern afs_kmutex_t rx_quota_mutex;
+extern afs_kmutex_t rx_pthread_mutex;
+extern afs_kmutex_t rx_packets_mutex;
+extern afs_kmutex_t des_init_mutex;
+extern afs_kmutex_t des_random_mutex;
+extern afs_kmutex_t rx_clock_mutex;
+extern afs_kmutex_t rxi_connCacheMutex;
+extern afs_kmutex_t rx_event_mutex;
+extern afs_kmutex_t osi_malloc_mutex;
+extern afs_kmutex_t event_handler_mutex;
+extern afs_kmutex_t listener_mutex;
+extern afs_kmutex_t rx_if_init_mutex;
+extern afs_kmutex_t rx_if_mutex;
+extern afs_kmutex_t rxkad_client_uid_mutex;
+extern afs_kmutex_t rxkad_random_mutex;
+
+extern afs_kcondvar_t rx_event_handler_cond;
+extern afs_kcondvar_t rx_listener_cond;
+
+static afs_kmutex_t epoch_mutex;
+static afs_kmutex_t rx_init_mutex;
+static afs_kmutex_t rx_debug_mutex;
+static afs_kmutex_t rx_rpc_stats;
 
 static void
 rxi_InitPthread(void)
 {
-    assert(pthread_mutex_init(&rx_clock_mutex, (const pthread_mutexattr_t *)0)
-          == 0);
-    assert(pthread_mutex_init(&rx_stats_mutex, (const pthread_mutexattr_t *)0)
-          == 0);
-    assert(pthread_mutex_init(&rx_waiting_mutex, (const pthread_mutexattr_t *)0)
-          == 0);
-    assert(pthread_mutex_init(&rx_quota_mutex, (const pthread_mutexattr_t *)0)
-          == 0);
-    assert(pthread_mutex_init(&rx_pthread_mutex, (const pthread_mutexattr_t *)0)
-          == 0);
-    assert(pthread_mutex_init(&rx_packets_mutex, (const pthread_mutexattr_t *)0)
-          == 0);
-    assert(pthread_mutex_init
-          (&rxi_connCacheMutex, (const pthread_mutexattr_t *)0) == 0);
-    assert(pthread_mutex_init(&rx_init_mutex, (const pthread_mutexattr_t *)0)
-          == 0);
-    assert(pthread_mutex_init(&epoch_mutex, (const pthread_mutexattr_t *)0) ==
-          0);
-    assert(pthread_mutex_init(&rx_event_mutex, (const pthread_mutexattr_t *)0)
-          == 0);
-    assert(pthread_mutex_init(&des_init_mutex, (const pthread_mutexattr_t *)0)
-          == 0);
-    assert(pthread_mutex_init
-          (&des_random_mutex, (const pthread_mutexattr_t *)0) == 0);
-    assert(pthread_mutex_init
-          (&osi_malloc_mutex, (const pthread_mutexattr_t *)0) == 0);
-    assert(pthread_mutex_init
-          (&event_handler_mutex, (const pthread_mutexattr_t *)0) == 0);
-    assert(pthread_mutex_init(&listener_mutex, (const pthread_mutexattr_t *)0)
-          == 0);
-    assert(pthread_mutex_init
-          (&rx_if_init_mutex, (const pthread_mutexattr_t *)0) == 0);
-    assert(pthread_mutex_init(&rx_if_mutex, (const pthread_mutexattr_t *)0) ==
-          0);
-    assert(pthread_mutex_init
-          (&rxkad_client_uid_mutex, (const pthread_mutexattr_t *)0) == 0);
-    assert(pthread_mutex_init
-          (&rxkad_random_mutex, (const pthread_mutexattr_t *)0) == 0);
-    assert(pthread_mutex_init(&rx_debug_mutex, (const pthread_mutexattr_t *)0)
-          == 0);
+    MUTEX_INIT(&rx_clock_mutex, "clock", MUTEX_DEFAULT, 0);
+    MUTEX_INIT(&rx_stats_mutex, "stats", MUTEX_DEFAULT, 0);
+    MUTEX_INIT(&rx_waiting_mutex, "waiting", MUTEX_DEFAULT, 0);
+    MUTEX_INIT(&rx_quota_mutex, "quota", MUTEX_DEFAULT, 0);
+    MUTEX_INIT(&rx_pthread_mutex, "pthread", MUTEX_DEFAULT, 0);
+    MUTEX_INIT(&rx_packets_mutex, "packets", MUTEX_DEFAULT, 0);
+    MUTEX_INIT(&epoch_mutex, "epoch", MUTEX_DEFAULT, 0);
+    MUTEX_INIT(&rx_init_mutex, "init", MUTEX_DEFAULT, 0);
+    MUTEX_INIT(&rx_event_mutex, "event", MUTEX_DEFAULT, 0);
+    MUTEX_INIT(&des_init_mutex, "des", MUTEX_DEFAULT, 0);
+    MUTEX_INIT(&des_random_mutex, "random", MUTEX_DEFAULT, 0);
+    MUTEX_INIT(&osi_malloc_mutex, "malloc", MUTEX_DEFAULT, 0);
+    MUTEX_INIT(&event_handler_mutex, "event handler", MUTEX_DEFAULT, 0);
+    MUTEX_INIT(&rxi_connCacheMutex, "conn cache", MUTEX_DEFAULT, 0);
+    MUTEX_INIT(&listener_mutex, "listener", MUTEX_DEFAULT, 0);
+    MUTEX_INIT(&rx_if_init_mutex, "if init", MUTEX_DEFAULT, 0);
+    MUTEX_INIT(&rx_if_mutex, "if", MUTEX_DEFAULT, 0);
+    MUTEX_INIT(&rxkad_client_uid_mutex, "uid", MUTEX_DEFAULT, 0);
+    MUTEX_INIT(&rxkad_random_mutex, "rxkad random", MUTEX_DEFAULT, 0);
+    MUTEX_INIT(&rx_debug_mutex, "debug", MUTEX_DEFAULT, 0);
 
     assert(pthread_cond_init
           (&rx_event_handler_cond, (const pthread_condattr_t *)0) == 0);
@@ -403,8 +383,8 @@ struct rx_serverQueueEntry *rx_waitingForPacket = 0;
  * rx_epoch
  */
 
-#define LOCK_EPOCH assert(pthread_mutex_lock(&epoch_mutex)==0)
-#define UNLOCK_EPOCH assert(pthread_mutex_unlock(&epoch_mutex)==0)
+#define LOCK_EPOCH MUTEX_ENTER(&epoch_mutex)
+#define UNLOCK_EPOCH MUTEX_EXIT(&epoch_mutex)
 #else
 #define LOCK_EPOCH
 #define UNLOCK_EPOCH
@@ -434,8 +414,8 @@ int rxinit_status = 1;
  * rxinit_status
  */
 
-#define LOCK_RX_INIT assert(pthread_mutex_lock(&rx_init_mutex)==0)
-#define UNLOCK_RX_INIT assert(pthread_mutex_unlock(&rx_init_mutex)==0)
+#define LOCK_RX_INIT MUTEX_ENTER(&rx_init_mutex)
+#define UNLOCK_RX_INIT MUTEX_EXIT(&rx_init_mutex)
 #else
 #define LOCK_RX_INIT
 #define UNLOCK_RX_INIT
@@ -6617,8 +6597,8 @@ rx_PrintPeerStats(FILE * file, struct rx_peer *peer)
  * counter
  */
 
-#define LOCK_RX_DEBUG assert(pthread_mutex_lock(&rx_debug_mutex)==0)
-#define UNLOCK_RX_DEBUG assert(pthread_mutex_unlock(&rx_debug_mutex)==0)
+#define LOCK_RX_DEBUG MUTEX_ENTER(&rx_debug_mutex)
+#define UNLOCK_RX_DEBUG MUTEX_EXIT(&rx_debug_mutex)
 #else
 #define LOCK_RX_DEBUG
 #define UNLOCK_RX_DEBUG

diff --git a/src/rx/rx_conncache.c b/src/rx/rx_conncache.c
index 5af237b..407bff6 100644 (file)
--- a/src/rx/rx_conncache.c
+++ b/src/rx/rx_conncache.c
@@ -49,9 +49,9 @@ static struct rx_queue rxi_connectionCache = { &rxi_connectionCache,
  * rxi_connectionCache
  */
 
-pthread_mutex_t rxi_connCacheMutex;
-#define LOCK_CONN_CACHE assert(pthread_mutex_lock(&rxi_connCacheMutex)==0)
-#define UNLOCK_CONN_CACHE assert(pthread_mutex_unlock(&rxi_connCacheMutex)==0)
+afs_kmutex_t rxi_connCacheMutex;
+#define LOCK_CONN_CACHE MUTEX_ENTER(&rxi_connCacheMutex)
+#define UNLOCK_CONN_CACHE MUTEX_EXIT(&rxi_connCacheMutex)
 #else
 #define LOCK_CONN_CACHE
 #define UNLOCK_CONN_CACHE

diff --git a/src/rx/rx_event.c b/src/rx/rx_event.c
index 594b2ce..2f8f27e 100644 (file)
--- a/src/rx/rx_event.c
+++ b/src/rx/rx_event.c
@@ -111,9 +111,9 @@ afs_kmutex_t rxevent_lock;
  */
 
 #include <assert.h>
-pthread_mutex_t rx_event_mutex;
-#define LOCK_EV_INIT assert(pthread_mutex_lock(&rx_event_mutex)==0)
-#define UNLOCK_EV_INIT assert(pthread_mutex_unlock(&rx_event_mutex)==0)
+afs_kmutex_t rx_event_mutex;
+#define LOCK_EV_INIT MUTEX_ENTER(&rx_event_mutex)
+#define UNLOCK_EV_INIT MUTEX_EXIT(&rx_event_mutex)
 #else
 #define LOCK_EV_INIT
 #define UNLOCK_EV_INIT

diff --git a/src/rx/rx_misc.c b/src/rx/rx_misc.c
index 2800658..d58885e 100644 (file)
--- a/src/rx/rx_misc.c
+++ b/src/rx/rx_misc.c
@@ -107,9 +107,9 @@ ntoh_syserr_conv(int code)
  */
 
 #include <assert.h>
-pthread_mutex_t osi_malloc_mutex;
-#define LOCK_MALLOC_STATS assert(pthread_mutex_lock(&osi_malloc_mutex)==0)
-#define UNLOCK_MALLOC_STATS assert(pthread_mutex_unlock(&osi_malloc_mutex)==0)
+afs_kmutex_t osi_malloc_mutex;
+#define LOCK_MALLOC_STATS MUTEX_ENTER(&osi_malloc_mutex);
+#define UNLOCK_MALLOC_STATS MUTEX_EXIT(&osi_malloc_mutex);
 #else
 #define LOCK_MALLOC_STATS
 #define UNLOCK_MALLOC_STATS

diff --git a/src/rx/rx_prototypes.h b/src/rx/rx_prototypes.h
index 048ce7f..5f99d2b 100644 (file)
--- a/src/rx/rx_prototypes.h
+++ b/src/rx/rx_prototypes.h
@@ -596,8 +596,8 @@ extern void rx_FlushWrite(struct rx_call *call);
 
 /* rx_user.c */
 #ifdef AFS_PTHREAD_ENV
-extern pthread_mutex_t rx_if_init_mutex;
-extern pthread_mutex_t rx_if_mutex;
+extern afs_kmutex_t rx_if_init_mutex;
+extern afs_kmutex_t rx_if_mutex;
 #endif
 extern osi_socket rxi_GetUDPSocket(u_short port);
 extern void osi_AssertFailU(const char *expr, const char *file, int line);

diff --git a/src/rx/rx_pthread.c b/src/rx/rx_pthread.c
index 028365e..c7e96ef 100644 (file)
--- a/src/rx/rx_pthread.c
+++ b/src/rx/rx_pthread.c
@@ -66,12 +66,12 @@ static void *rx_ListenerProc(void *);
  * This thread is also responsible for keeping time.
  */
 static pthread_t event_handler_thread;
-pthread_cond_t rx_event_handler_cond;
-pthread_mutex_t event_handler_mutex;
-pthread_cond_t rx_listener_cond;
-pthread_mutex_t listener_mutex;
+afs_kcondvar_t rx_event_handler_cond;
+afs_kmutex_t event_handler_mutex;
+afs_kcondvar_t rx_listener_cond;
+afs_kmutex_t listener_mutex;
 static int listeners_started = 0;
-pthread_mutex_t rx_clock_mutex;
+afs_kmutex_t rx_clock_mutex;
 struct clock rxi_clockNow;
 
 /*
@@ -151,20 +151,20 @@ event_handler(void *argp)
     struct timespec rx_pthread_next_event_time = { 0, 0 };
     int error;
 
-    assert(pthread_mutex_lock(&event_handler_mutex) == 0);
+    MUTEX_ENTER(&event_handler_mutex);
 
     for (;;) {
        struct clock cv;
        struct clock next;
 
-       assert(pthread_mutex_unlock(&event_handler_mutex) == 0);
+       MUTEX_EXIT(&event_handler_mutex);
 
        next.sec = 30;          /* Time to sleep if there are no events scheduled */
        next.usec = 0;
        clock_GetTime(&cv);
        rxevent_RaiseEvents(&next);
 
-       assert(pthread_mutex_lock(&event_handler_mutex) == 0);
+       MUTEX_ENTER(&event_handler_mutex);
        if (rx_pthread_event_rescheduled) {
            rx_pthread_event_rescheduled = 0;
            continue;
@@ -174,9 +174,7 @@ event_handler(void *argp)
        rx_pthread_next_event_time.tv_sec = cv.sec;
        rx_pthread_next_event_time.tv_nsec = cv.usec * 1000;
        rx_pthread_n_event_waits++;
-       error = pthread_cond_timedwait
-           (&rx_event_handler_cond, &event_handler_mutex,
-            &rx_pthread_next_event_time);
+       error = CV_TIMEDWAIT(&rx_event_handler_cond, &event_handler_mutex, &rx_pthread_next_event_time);
         if (error == 0) {
            rx_pthread_n_event_woken++;
         } 
@@ -204,10 +202,10 @@ event_handler(void *argp)
 void
 rxi_ReScheduleEvents(void)
 {
-    assert(pthread_mutex_lock(&event_handler_mutex) == 0);
-    pthread_cond_signal(&rx_event_handler_cond);
+    MUTEX_ENTER(&event_handler_mutex);
+    CV_SIGNAL(&rx_event_handler_cond);
     rx_pthread_event_rescheduled = 1;
-    assert(pthread_mutex_unlock(&event_handler_mutex) == 0);
+    MUTEX_EXIT(&event_handler_mutex);
 }
 
 
@@ -220,11 +218,11 @@ rxi_ListenerProc(osi_socket sock, int *tnop, struct rx_call **newcallp)
     u_short port;
     register struct rx_packet *p = (struct rx_packet *)0;
 
-    assert(pthread_mutex_lock(&listener_mutex) == 0);
+    MUTEX_ENTER(&listener_mutex);
     while (!listeners_started) {
-       assert(pthread_cond_wait(&rx_listener_cond, &listener_mutex) == 0);
+       CV_WAIT(&rx_listener_cond, &listener_mutex);
     }
-    assert(pthread_mutex_unlock(&listener_mutex) == 0);
+    MUTEX_EXIT(&listener_mutex);
 
     for (;;) {
        /*
@@ -305,9 +303,9 @@ rx_ServerProc(void * dummy)
      */
     MUTEX_ENTER(&rx_pthread_mutex);
     threadID = ++rxi_pthread_hinum;
-    MUTEX_EXIT(&rx_pthread_mutex);
     if (rxi_fcfs_thread_num == 0 && rxi_fcfs_thread_num != threadID)
        rxi_fcfs_thread_num = threadID;
+    MUTEX_EXIT(&rx_pthread_mutex);
     ++rxi_availProcs;
     MUTEX_EXIT(&rx_quota_mutex);
 
@@ -365,10 +363,10 @@ rxi_StartListener(void)
     MUTEX_EXIT(&rx_pthread_mutex);
     AFS_SIGSET_RESTORE();
 
-    assert(pthread_mutex_lock(&listener_mutex) == 0);
-    assert(pthread_cond_broadcast(&rx_listener_cond) == 0);
+    MUTEX_ENTER(&listener_mutex);
+    CV_BROADCAST(&rx_listener_cond);
     listeners_started = 1;
-    assert(pthread_mutex_unlock(&listener_mutex) == 0);
+    MUTEX_EXIT(&listener_mutex);
 
 }
 

diff --git a/src/rx/rx_pthread.h b/src/rx/rx_pthread.h
index ff53183..a50cbf0 100644 (file)
--- a/src/rx/rx_pthread.h
+++ b/src/rx/rx_pthread.h
@@ -114,6 +114,11 @@ extern void osirx_AssertMine(afs_kmutex_t * lockaddr, char *msg);
 #endif
 #define CV_WAIT(cv, l) osi_Assert(pthread_cond_wait(cv, l) == 0)
 
+#ifdef CV_TIMEDWAIT
+#undef CV_TIMEDWAIT
+#endif
+#define CV_TIMEDWAIT(cv, l, t) pthread_cond_timedwait(cv, l, t)
+
 #ifdef CV_SIGNAL
 #undef CV_SIGNAL
 #endif

diff --git a/src/rx/rx_user.c b/src/rx/rx_user.c
index c9a9793..ddb0b72 100644 (file)
--- a/src/rx/rx_user.c
+++ b/src/rx/rx_user.c
@@ -60,9 +60,9 @@ RCSID
  * Inited
  */
 
-pthread_mutex_t rx_if_init_mutex;
-#define LOCK_IF_INIT assert(pthread_mutex_lock(&rx_if_init_mutex)==0)
-#define UNLOCK_IF_INIT assert(pthread_mutex_unlock(&rx_if_init_mutex)==0)
+afs_kmutex_t rx_if_init_mutex;
+#define LOCK_IF_INIT MUTEX_ENTER(&rx_if_init_mutex)
+#define UNLOCK_IF_INIT MUTEX_EXIT(&rx_if_init_mutex)
 
 /*
  * The rx_if_mutex mutex protects the following global variables:
@@ -71,9 +71,9 @@ pthread_mutex_t rx_if_init_mutex;
  * myNetMasks
  */
 
-pthread_mutex_t rx_if_mutex;
-#define LOCK_IF assert(pthread_mutex_lock(&rx_if_mutex)==0)
-#define UNLOCK_IF assert(pthread_mutex_unlock(&rx_if_mutex)==0)
+afs_kmutex_t rx_if_mutex;
+#define LOCK_IF MUTEX_ENTER(&rx_if_mutex)
+#define UNLOCK_IF MUTEX_EXIT(&rx_if_mutex)
 #else
 #define LOCK_IF_INIT
 #define UNLOCK_IF_INIT