rx-rwlocks-no-more-20090110
authorJeffrey Altman <jaltman@your-file-system.com>
Sun, 11 Jan 2009 04:00:07 +0000 (04:00 +0000)
committerJeffrey Altman <jaltman@secure-endpoints.com>
Sun, 11 Jan 2009 04:00:07 +0000 (04:00 +0000)
LICENSE MIT

remove the use of rwlock and restore the use of mutexes.
the rwlocks are actually slower in performance testing.

16 files changed:
src/rx/AIX/rx_kmutex.h
src/rx/FBSD/rx_kmutex.h
src/rx/HPUX/rx_kmutex.h
src/rx/IRIX/rx_kmutex.h
src/rx/LINUX/rx_kmutex.h
src/rx/NBSD/rx_kmutex.h
src/rx/OBSD/rx_kmutex.h
src/rx/SOLARIS/rx_kmutex.h
src/rx/UKERNEL/rx_kmutex.h
src/rx/rx.c
src/rx/rx.h
src/rx/rx_globals.h
src/rx/rx_lwp.h
src/rx/rx_packet.c
src/rx/rx_pthread.c
src/rx/rx_pthread.h

index 7ec8d2f..6b028fe 100644 (file)
 #define CV_SIGNAL(_cv)         e_wakeup_one(_cv)
 #define CV_BROADCAST(_cv)      e_wakeup(_cv)
 typedef simple_lock_data afs_kmutex_t;
-typedef afs_kmutex_t afs_krwlock_t;
 typedef tid_t afs_kcondvar_t;
 
 
-#define RWLOCK_INIT(a, b, c, d) MUTEX_INIT(a,b,c,d)
-#define RWLOCK_DESTROY(l)       MUTEX_DESTROY(l)
-#define RWLOCK_UPLOCK(l) 
-#define RWLOCK_WRLOCK(l)        MUTEX_ENTER(l)
-#define RWLOCK_RDLOCK(l)        MUTEX_ENTER(l)
-#define RWLOCK_TRYWRLOCK(l)     MUTEX_TRYENTER(l)
-#define RWLOCK_TRYRDLOCK(l)     MUTEX_TRYENTER(l)
-#define RWLOCK_UNLOCK(l)        MUTEX_EXIT(l)
-
 #define        LOCK_INIT(a, b)         lock_alloc((void*)(a), LOCK_ALLOC_PIN, 1, 1), \
                                simple_lock_init((void *)(a))
 #define MUTEX_INIT(a,b,c,d)    lock_alloc((void*)(a), LOCK_ALLOC_PIN, 1, 1), \
index 7a006d7..39fe820 100644 (file)
@@ -36,16 +36,6 @@ typedef struct {
     struct proc *owner;
 } afs_kmutex_t;
 
-typedef afs_kmutex_t afs_krwlock_t;
-#define RWLOCK_INIT(a, b, c, d) MUTEX_INIT(a,b,c,d)
-#define RWLOCK_DESTROY(l)       MUTEX_DESTROY(l)
-#define RWLOCK_UPLOCK(l) 
-#define RWLOCK_WRLOCK(l)        MUTEX_ENTER(l)
-#define RWLOCK_RDLOCK(l)        MUTEX_ENTER(l)
-#define RWLOCK_TRYWRLOCK(l)     MUTEX_TRYENTER(l)
-#define RWLOCK_TRYRDLOCK(l)     MUTEX_TRYENTER(l)
-#define RWLOCK_UNLOCK(l)        MUTEX_EXIT(l)
-
 #define MUTEX_INIT(a,b,c,d) \
     do { \
        (a)->owner = 0; \
index 8974fb8..09bd3bd 100644 (file)
@@ -138,16 +138,6 @@ extern void osirx_AssertMine(afs_kmutex_t * lockaddr, char *msg);
 
 #define AFS_RX_ORDER 30
 
-typedef afs_kmutex_t afs_krwlock_t;
-#define RWLOCK_INIT(a, b, c, d) MUTEX_INIT(a,b,c,d)
-#define RWLOCK_DESTROY(l)       MUTEX_DESTROY(l)
-#define RWLOCK_UPLOCK(l) 
-#define RWLOCK_WRLOCK(l)        MUTEX_ENTER(l)
-#define RWLOCK_RDLOCK(l)        MUTEX_ENTER(l)
-#define RWLOCK_TRYWRLOCK(l)     MUTEX_TRYENTER(l)
-#define RWLOCK_TRYRDLOCK(l)     MUTEX_TRYENTER(l)
-#define RWLOCK_UNLOCK(l)        MUTEX_EXIT(l)
-
 #define MUTEX_INIT(a,b,c,d) b_initsema((a), 1, AFS_RX_ORDER, (b))
 #define MUTEX_DESTROY(a)
 
@@ -173,15 +163,6 @@ typedef afs_kmutex_t afs_krwlock_t;
 
 #define osirx_AssertMine(addr, msg)
 
-#define RWLOCK_INIT(a, b, c, d) 
-#define RWLOCK_DESTROY(l)       
-#define RWLOCK_UPLOCK(l) 
-#define RWLOCK_WRLOCK(l)        
-#define RWLOCK_RDLOCK(l)        
-#define RWLOCK_TRYWRLOCK(l)     
-#define RWLOCK_TRYRDLOCK(l)     
-#define RWLOCK_UNLOCK(l)        
-
 #define MUTEX_DESTROY(a)
 #define MUTEX_ENTER(a)
 #define MUTEX_TRYENTER(a) 1
index 155a8d0..63414a7 100644 (file)
@@ -28,7 +28,6 @@
 #define mutex_tryenter(m) cpsema(m)
 #endif /* mutex_tryenter */
 typedef kmutex_t afs_kmutex_t;
-typedef afs_kmutex_t afs_krwlock_t;
 typedef kcondvar_t afs_kcondvar_t;
 
 #ifndef        CV_DEFAULT
@@ -38,15 +37,6 @@ typedef kcondvar_t afs_kcondvar_t;
 #define        MUTEX_DEFAULT   0
 #endif
 
-#define RWLOCK_INIT(a, b, c, d) MUTEX_INIT(a,b,c,d)
-#define RWLOCK_DESTROY(l)       MUTEX_DESTROY(l)
-#define RWLOCK_UPLOCK(l) 
-#define RWLOCK_WRLOCK(l)        MUTEX_ENTER(l)
-#define RWLOCK_RDLOCK(l)        MUTEX_ENTER(l)
-#define RWLOCK_TRYWRLOCK(l)     MUTEX_TRYENTER(l)
-#define RWLOCK_TRYRDLOCK(l)     MUTEX_TRYENTER(l)
-#define RWLOCK_UNLOCK(l)        MUTEX_EXIT(l)
-
 #ifdef AFS_SGI62_ENV
 #define MUTEX_INIT(m, nm, type , a)  mutex_init(m, type, nm)
 #else
index 054087e..6ea4faf 100644 (file)
@@ -49,8 +49,6 @@ typedef struct afs_kmutex {
     int owner;
 } afs_kmutex_t;
 
-typedef afs_kmutex_t afs_krwlock_t;
-
 #ifndef set_current_state
 #define set_current_state(X) current->state=X
 #endif
@@ -70,15 +68,6 @@ MUTEX_ISMINE(afs_kmutex_t * l)
     return l->owner == current->pid;
 }
 
-#define RWLOCK_INIT(a, b, c, d) MUTEX_INIT(a,b,c,d)
-#define RWLOCK_DESTROY(l)       MUTEX_DESTROY(l)
-#define RWLOCK_UPLOCK(l) 
-#define RWLOCK_WRLOCK(l)        MUTEX_ENTER(l)
-#define RWLOCK_RDLOCK(l)        MUTEX_ENTER(l)
-#define RWLOCK_TRYWRLOCK(l)     MUTEX_TRYENTER(l)
-#define RWLOCK_TRYRDLOCK(l)     MUTEX_TRYENTER(l)
-#define RWLOCK_UNLOCK(l)        MUTEX_EXIT(l)
-
 #define MUTEX_INIT(a,b,c,d)    afs_mutex_init(a)
 #define MUTEX_DESTROY(a)
 #define MUTEX_ENTER            afs_mutex_enter
index 193fdd5..7c81966 100644 (file)
@@ -63,18 +63,8 @@ typedef struct {
     struct lock__bsd__ lock;
     thread_t owner;
 } afs_kmutex_t;
-typedef afs_krwlock_t afs_kmutex_t;
 typedef int afs_kcondvar_t;
 
-#define RWLOCK_INIT(a, b, c, d) MUTEX_INIT(a,b,c,d)
-#define RWLOCK_DESTROY(l)       MUTEX_DESTROY(l)
-#define RWLOCK_UPLOCK(l) 
-#define RWLOCK_WRLOCK(l)        MUTEX_ENTER(l)
-#define RWLOCK_RDLOCK(l)        MUTEX_ENTER(l)
-#define RWLOCK_TRYWRLOCK(l)     MUTEX_TRYENTER(l)
-#define RWLOCK_TRYRDLOCK(l)     MUTEX_TRYENTER(l)
-#define RWLOCK_UNLOCK(l)        MUTEX_EXIT(l)
-
 #define osi_rxWakeup(cv)        thread_wakeup((event_t)(cv))
 
 #define LOCK_INIT(a,b) \
index 55efa5f..dfe0c16 100644 (file)
@@ -42,19 +42,9 @@ typedef int afs_kcondvar_t;
 typedef struct {
     struct proc *owner;
 } afs_kmutex_t;
-typedef afs_kmutex_t afs_krwlock_t;
 
 #define        MUTEX_DEFAULT   0
 
-#define RWLOCK_INIT(a, b, c, d) MUTEX_INIT(a,b,c,d)
-#define RWLOCK_DESTROY(l)       MUTEX_DESTROY(l)
-#define RWLOCK_UPLOCK(l) 
-#define RWLOCK_WRLOCK(l)        MUTEX_ENTER(l)
-#define RWLOCK_RDLOCK(l)        MUTEX_ENTER(l)
-#define RWLOCK_TRYWRLOCK(l)     MUTEX_TRYENTER(l)
-#define RWLOCK_TRYRDLOCK(l)     MUTEX_TRYENTER(l)
-#define RWLOCK_UNLOCK(l)        MUTEX_EXIT(l)
-
 #define MUTEX_INIT(a,b,c,d) \
     do { \
        (a)->owner = 0; \
index d56284b..63aa8f4 100644 (file)
@@ -26,7 +26,6 @@
 #include <sys/mutex.h>
 
 typedef kmutex_t afs_kmutex_t;
-typedef afs_kmutex_t afs_krwlock_t;
 typedef kcondvar_t afs_kcondvar_t;
 
 #undef osirx_AssertMine
index ad092a2..38a140b 100644 (file)
 #define RX_ENABLE_LOCKS                1
 
 #define        afs_kmutex_t            usr_mutex_t
-#define        afs_krwlock_t           usr_mutex_t
 #define        afs_kcondvar_t          usr_cond_t
-#define RWLOCK_INIT(a, b, c, d) usr_mutex_init(a)
-#define RWLOCK_DESTROY(l)       usr_mutex_destroy(l)
-#define RWLOCK_UPLOCK(l) 
-#define RWLOCK_WRLOCK(l)        usr_mutex_lock(l)
-#define RWLOCK_RDLOCK(l)        usr_mutex_lock(l)
-#define RWLOCK_TRYWRLOCK(l)     usr_mutex_trylock(l)
-#define RWLOCK_TRYRDLOCK(l)     usr_mutex_trylock(l)
-#define RWLOCK_UNLOCK(l)        usr_mutex_unlock(l)
 #define MUTEX_INIT(A,B,C,D)    usr_mutex_init(A)
 #define MUTEX_ENTER(A)         usr_mutex_lock(A)
 #define MUTEX_TRYENTER(A)      usr_mutex_trylock(A)
index d61d45a..6802c38 100644 (file)
@@ -242,9 +242,9 @@ rxi_InitPthread(void)
               0);
     CV_INIT(&rx_waitingForPackets_cv, "rx_waitingForPackets_cv", CV_DEFAULT,
            0);
-    RWLOCK_INIT(&rx_peerHashTable_lock, "rx_peerHashTable_lock", MUTEX_DEFAULT,
+    MUTEX_INIT(&rx_peerHashTable_lock, "rx_peerHashTable_lock", MUTEX_DEFAULT,
               0);
-    RWLOCK_INIT(&rx_connHashTable_lock, "rx_connHashTable_lock", MUTEX_DEFAULT,
+    MUTEX_INIT(&rx_connHashTable_lock, "rx_connHashTable_lock", MUTEX_DEFAULT,
               0);
     MUTEX_INIT(&rx_serverPool_lock, "rx_serverPool_lock", MUTEX_DEFAULT, 0);
     MUTEX_INIT(&rxi_keyCreate_lock, "rxi_keyCreate_lock", MUTEX_DEFAULT, 0);
@@ -464,9 +464,9 @@ rx_InitHost(u_int host, u_int port)
               0);
     CV_INIT(&rx_waitingForPackets_cv, "rx_waitingForPackets_cv", CV_DEFAULT,
            0);
-    RWLOCK_INIT(&rx_peerHashTable_lock, "rx_peerHashTable_lock", MUTEX_DEFAULT,
+    MUTEX_INIT(&rx_peerHashTable_lock, "rx_peerHashTable_lock", MUTEX_DEFAULT,
               0);
-    RWLOCK_INIT(&rx_connHashTable_lock, "rx_connHashTable_lock", MUTEX_DEFAULT,
+    MUTEX_INIT(&rx_connHashTable_lock, "rx_connHashTable_lock", MUTEX_DEFAULT,
               0);
     MUTEX_INIT(&rx_serverPool_lock, "rx_serverPool_lock", MUTEX_DEFAULT, 0);
 #if defined(AFS_HPUX110_ENV)
@@ -538,7 +538,7 @@ rx_InitHost(u_int host, u_int port)
     rx_SetEpoch(tv.tv_sec);    /* Start time of this package, rxkad
                                 * will provide a randomer value. */
 #endif
-    rx_MutexAdd(rxi_dataQuota, rx_extraQuota, rx_stats_mutex); /* + extra pkts caller asked to rsrv */
+    rx_MutexAdd(rxi_dataQuota, rx_extraQuota, rx_stats_mutex); /* + extra pkts caller asked to rsrv */
     /* *Slightly* random start time for the cid.  This is just to help
      * out with the hashing function at the peer */
     rx_nextCid = ((tv.tv_sec ^ tv.tv_usec) << RX_CIDSHIFT);
@@ -787,7 +787,7 @@ rx_NewConnection(afs_uint32 shost, u_short sport, u_short sservice,
     dpf(("rx_NewConnection(host %x, port %u, service %u, securityObject %x, serviceSecurityIndex %d)\n", ntohl(shost), ntohs(sport), sservice, securityObject, serviceSecurityIndex));
 
     NETPRI;
-    RWLOCK_WRLOCK(&rx_connHashTable_lock);
+    MUTEX_ENTER(&rx_connHashTable_lock);
 
     /* 
      * allocate the connection and all of its clones.
@@ -855,7 +855,7 @@ rx_NewConnection(afs_uint32 shost, u_short sport, u_short sservice,
        rx_MutexIncrement(rx_stats.nClientConns, rx_stats_mutex);
     }
        
-    RWLOCK_UNLOCK(&rx_connHashTable_lock);
+    MUTEX_EXIT(&rx_connHashTable_lock);
     USERPRI;
     return conn;
 }
@@ -894,7 +894,7 @@ rxi_CleanupConnection(struct rx_connection *conn)
      * idle time to now. rxi_ReapConnections will reap it if it's still
      * idle (refCount == 0) after rx_idlePeerTime (60 seconds) have passed.
      */
-    RWLOCK_WRLOCK(&rx_peerHashTable_lock);
+    MUTEX_ENTER(&rx_peerHashTable_lock);
     if (conn->peer->refCount < 2) {
        conn->peer->idleWhen = clock_Sec();
        if (conn->peer->refCount < 1) {
@@ -903,7 +903,7 @@ rxi_CleanupConnection(struct rx_connection *conn)
        }
     }
     conn->peer->refCount--;
-    RWLOCK_UNLOCK(&rx_peerHashTable_lock);
+    MUTEX_EXIT(&rx_peerHashTable_lock);
 
     if (conn->type == RX_SERVER_CONNECTION)
        rx_MutexDecrement(rx_stats.nServerConns, rx_stats_mutex);
@@ -936,7 +936,7 @@ rxi_DestroyConnection(register struct rx_connection *conn)
 {
     register struct rx_connection *tconn, *dtconn;
     
-    RWLOCK_WRLOCK(&rx_connHashTable_lock);
+    MUTEX_ENTER(&rx_connHashTable_lock);
     
     /* destroy any clones that might exist */
     if (!rx_IsClonedConn(conn)) {
@@ -968,12 +968,12 @@ rxi_DestroyConnection(register struct rx_connection *conn)
     /* conn should be at the head of the cleanup list */
     if (conn == rx_connCleanup_list) {
        rx_connCleanup_list = rx_connCleanup_list->next;
-       RWLOCK_UNLOCK(&rx_connHashTable_lock);
+       MUTEX_EXIT(&rx_connHashTable_lock);
        rxi_CleanupConnection(conn);
     }
 #ifdef RX_ENABLE_LOCKS
     else {
-       RWLOCK_UNLOCK(&rx_connHashTable_lock);
+       MUTEX_EXIT(&rx_connHashTable_lock);
     }
 #endif /* RX_ENABLE_LOCKS */
 }
@@ -994,7 +994,9 @@ rxi_DestroyConnectionNoLock(register struct rx_connection *conn)
     if (conn->refCount > 0)
        conn->refCount--;
     else {
-       rx_MutexIncrement(rxi_lowConnRefCount, rx_stats_mutex);
+       MUTEX_ENTER(&rx_stats_mutex);
+       rxi_lowConnRefCount++;
+       MUTEX_EXIT(&rx_stats_mutex);
     }
 
     if ((conn->refCount > 0) || (conn->flags & RX_CONN_BUSY)) {
@@ -1054,7 +1056,7 @@ rxi_DestroyConnectionNoLock(register struct rx_connection *conn)
     if (havecalls) {
        /* Don't destroy the connection if there are any call
         * structures still in use */
-       rx_MutexOr(conn->flags, RX_CONN_DESTROY_ME, conn->conn_data_lock);
+        rx_MutexOr(conn->flags, RX_CONN_DESTROY_ME, conn->conn_data_lock);
        USERPRI;
        return;
     }
@@ -1194,9 +1196,9 @@ rx_NewCall(register struct rx_connection *conn)
 #else
         osi_rxSleep(conn);
 #endif
-       rx_MutexDecrement(conn->makeCallWaiters, conn->conn_data_lock);
+        rx_MutexDecrement(conn->makeCallWaiters, conn->conn_data_lock);
     } else {
-       MUTEX_EXIT(&conn->conn_data_lock);
+        MUTEX_EXIT(&conn->conn_data_lock);
     }
 
     /* search for next free call on this connection or 
@@ -2107,7 +2109,7 @@ rx_Finalize(void)
     }
     rxi_DeleteCachedConnections();
     if (rx_connHashTable) {
-       RWLOCK_WRLOCK(&rx_connHashTable_lock);
+       MUTEX_ENTER(&rx_connHashTable_lock);
        for (conn_ptr = &rx_connHashTable[0], conn_end =
             &rx_connHashTable[rx_hashTableSize]; conn_ptr < conn_end;
             conn_ptr++) {
@@ -2131,11 +2133,11 @@ rx_Finalize(void)
            struct rx_connection *conn;
            conn = rx_connCleanup_list;
            rx_connCleanup_list = rx_connCleanup_list->next;
-           RWLOCK_UNLOCK(&rx_connHashTable_lock);
+           MUTEX_EXIT(&rx_connHashTable_lock);
            rxi_CleanupConnection(conn);
-           RWLOCK_WRLOCK(&rx_connHashTable_lock);
+           MUTEX_ENTER(&rx_connHashTable_lock);
        }
-       RWLOCK_UNLOCK(&rx_connHashTable_lock);
+       MUTEX_EXIT(&rx_connHashTable_lock);
 #endif /* RX_ENABLE_LOCKS */
     }
     rxi_flushtrace();
@@ -2388,7 +2390,7 @@ rxi_SetPeerMtu(register afs_uint32 host, register afs_uint32 port, int mtu)
     struct rx_peer **peer_ptr, **peer_end;
     int hashIndex;
 
-    RWLOCK_RDLOCK(&rx_peerHashTable_lock);
+    MUTEX_ENTER(&rx_peerHashTable_lock);
     if (port == 0) {
        for (peer_ptr = &rx_peerHashTable[0], peer_end =
                 &rx_peerHashTable[rx_hashTableSize]; peer_ptr < peer_end;
@@ -2416,7 +2418,7 @@ rxi_SetPeerMtu(register afs_uint32 host, register afs_uint32 port, int mtu)
            }
        }
     }
-    RWLOCK_UNLOCK(&rx_peerHashTable_lock);
+    MUTEX_EXIT(&rx_peerHashTable_lock);
 }
 
 /* Find the peer process represented by the supplied (host,port)
@@ -2432,7 +2434,7 @@ rxi_FindPeer(register afs_uint32 host, register u_short port,
     register struct rx_peer *pp;
     int hashIndex;
     hashIndex = PEER_HASH(host, port);
-    RWLOCK_RDLOCK(&rx_peerHashTable_lock);
+    MUTEX_ENTER(&rx_peerHashTable_lock);
     for (pp = rx_peerHashTable[hashIndex]; pp; pp = pp->next) {
        if ((pp->host == host) && (pp->port == port))
             break;
@@ -2445,7 +2447,6 @@ rxi_FindPeer(register afs_uint32 host, register u_short port,
            MUTEX_INIT(&pp->peer_lock, "peer_lock", MUTEX_DEFAULT, 0);
            queue_Init(&pp->congestionQueue);
            queue_Init(&pp->rpcStats);
-           RWLOCK_UPLOCK(&rx_peerHashTable_lock);
            pp->next = rx_peerHashTable[hashIndex];
            rx_peerHashTable[hashIndex] = pp;
            rxi_InitPeerParams(pp);
@@ -2457,7 +2458,7 @@ rxi_FindPeer(register afs_uint32 host, register u_short port,
     }
     if (origPeer)
        origPeer->refCount--;
-    RWLOCK_UNLOCK(&rx_peerHashTable_lock);
+    MUTEX_EXIT(&rx_peerHashTable_lock);
     return pp;
 }
 
@@ -2482,7 +2483,7 @@ rxi_FindConnection(osi_socket socket, register afs_int32 host,
     int hashindex, flag, i;
     register struct rx_connection *conn;
     hashindex = CONN_HASH(host, port, cid, epoch, type);
-    RWLOCK_RDLOCK(&rx_connHashTable_lock);
+    MUTEX_ENTER(&rx_connHashTable_lock);
     rxLastConn ? (conn = rxLastConn, flag = 0) : (conn =
                                                  rx_connHashTable[hashindex],
                                                  flag = 1);
@@ -2495,7 +2496,7 @@ rxi_FindConnection(osi_socket socket, register afs_int32 host,
                 * like this, and there seems to be some CM bug that makes this
                 * happen from time to time -- in which case, the fileserver
                 * asserts. */
-               RWLOCK_UNLOCK(&rx_connHashTable_lock);
+               MUTEX_EXIT(&rx_connHashTable_lock);
                return (struct rx_connection *)0;
            }
            if (pp->host == host && pp->port == port)
@@ -2518,23 +2519,26 @@ rxi_FindConnection(osi_socket socket, register afs_int32 host,
     if (!conn) {
        struct rx_service *service;
        if (type == RX_CLIENT_CONNECTION) {
-           RWLOCK_UNLOCK(&rx_connHashTable_lock);
+           MUTEX_EXIT(&rx_connHashTable_lock);
            return (struct rx_connection *)0;
        }
        service = rxi_FindService(socket, serviceId);
        if (!service || (securityIndex >= service->nSecurityObjects)
            || (service->securityObjects[securityIndex] == 0)) {
-           RWLOCK_UNLOCK(&rx_connHashTable_lock);
+           MUTEX_EXIT(&rx_connHashTable_lock);
            return (struct rx_connection *)0;
        }
        conn = rxi_AllocConnection();   /* This bzero's the connection */
        MUTEX_INIT(&conn->conn_call_lock, "conn call lock", MUTEX_DEFAULT, 0);
        MUTEX_INIT(&conn->conn_data_lock, "conn data lock", MUTEX_DEFAULT, 0);
        CV_INIT(&conn->conn_call_cv, "conn call cv", CV_DEFAULT, 0);
+       conn->next = rx_connHashTable[hashindex];
+       rx_connHashTable[hashindex] = conn;
        conn->peer = rxi_FindPeer(host, port, 0, 1);
        conn->type = RX_SERVER_CONNECTION;
        conn->lastSendTime = clock_Sec();       /* don't GC immediately */
        conn->epoch = epoch;
+       conn->cid = cid & RX_CIDMASK;
        /* conn->serial = conn->lastSerial = 0; */
        /* conn->timeout = 0; */
        conn->ackRate = RX_FAST_ACK_RATE;
@@ -2551,10 +2555,6 @@ rxi_FindConnection(osi_socket socket, register afs_int32 host,
            conn->twind[i] = rx_initSendWindow;
            conn->rwind[i] = rx_initReceiveWindow;
        }
-       RWLOCK_UPLOCK(&rx_connHashTable_lock);
-       conn->next = rx_connHashTable[hashindex];
-       rx_connHashTable[hashindex] = conn;
-       conn->cid = cid & RX_CIDMASK;
        /* Notify security object of the new connection */
        RXS_NewConnection(conn->securityObject, conn);
        /* XXXX Connection timeout? */
@@ -2566,7 +2566,7 @@ rxi_FindConnection(osi_socket socket, register afs_int32 host,
     rx_MutexIncrement(conn->refCount, conn->conn_data_lock);
 
     rxLastConn = conn;         /* store this connection as the last conn used */
-    RWLOCK_UNLOCK(&rx_connHashTable_lock);
+    MUTEX_EXIT(&rx_connHashTable_lock);
     return conn;
 }
 
@@ -4249,7 +4249,9 @@ rxi_AttachServerProc(register struct rx_call *call,
            call->flags &= ~RX_CALL_WAIT_PROC;
            if (queue_IsOnQueue(call)) {
                queue_Remove(call);
-               rx_MutexDecrement(rx_nWaiting, rx_stats_mutex);
+               MUTEX_ENTER(&rx_stats_mutex);
+               rx_nWaiting--;
+               MUTEX_EXIT(&rx_stats_mutex);
            }
        }
        call->state = RX_STATE_ACTIVE;
@@ -4742,7 +4744,9 @@ rxi_ResetCall(register struct rx_call *call, register int newcall)
        if (queue_IsOnQueue(call)) {
            queue_Remove(call);
            if (flags & RX_CALL_WAIT_PROC) {
-               rx_MutexDecrement(rx_nWaiting, rx_stats_mutex);
+               MUTEX_ENTER(&rx_stats_mutex);
+               rx_nWaiting--;
+               MUTEX_EXIT(&rx_stats_mutex);
            }
        }
        MUTEX_EXIT(call->call_queue_lock);
@@ -6005,7 +6009,7 @@ rxi_ReapConnections(struct rxevent *unused, void *unused1, void *unused2)
     {
        struct rx_connection **conn_ptr, **conn_end;
        int i, havecalls = 0;
-       RWLOCK_WRLOCK(&rx_connHashTable_lock);
+       MUTEX_ENTER(&rx_connHashTable_lock);
        for (conn_ptr = &rx_connHashTable[0], conn_end =
             &rx_connHashTable[rx_hashTableSize]; conn_ptr < conn_end;
             conn_ptr++) {
@@ -6066,11 +6070,11 @@ rxi_ReapConnections(struct rxevent *unused, void *unused1, void *unused2)
            struct rx_connection *conn;
            conn = rx_connCleanup_list;
            rx_connCleanup_list = rx_connCleanup_list->next;
-           RWLOCK_UNLOCK(&rx_connHashTable_lock);
+           MUTEX_EXIT(&rx_connHashTable_lock);
            rxi_CleanupConnection(conn);
-           RWLOCK_WRLOCK(&rx_connHashTable_lock);
+           MUTEX_ENTER(&rx_connHashTable_lock);
        }
-       RWLOCK_UNLOCK(&rx_connHashTable_lock);
+       MUTEX_EXIT(&rx_connHashTable_lock);
 #endif /* RX_ENABLE_LOCKS */
     }
 
@@ -6080,7 +6084,7 @@ rxi_ReapConnections(struct rxevent *unused, void *unused1, void *unused2)
        struct rx_peer **peer_ptr, **peer_end;
        int code;
        MUTEX_ENTER(&rx_rpc_stats);
-       RWLOCK_RDLOCK(&rx_peerHashTable_lock);
+       MUTEX_ENTER(&rx_peerHashTable_lock);
        for (peer_ptr = &rx_peerHashTable[0], peer_end =
             &rx_peerHashTable[rx_hashTableSize]; peer_ptr < peer_end;
             peer_ptr++) {
@@ -6111,14 +6115,13 @@ rxi_ReapConnections(struct rxevent *unused, void *unused1, void *unused2)
                        rxi_Free(rpc_stat, space);
                        rxi_rpc_peer_stat_cnt -= num_funcs;
                    }
+                   rxi_FreePeer(peer);
                     rx_MutexDecrement(rx_stats.nPeerStructs, rx_stats_mutex);
-                   RWLOCK_UPLOCK(&rx_peerHashTable_lock);
                    if (peer == *peer_ptr) {
                        *peer_ptr = next;
                        prev = next;
                    } else
                        prev->next = next;
-                   rxi_FreePeer(peer);
                } else {
                    if (code) {
                        MUTEX_EXIT(&peer->peer_lock);
@@ -6127,7 +6130,7 @@ rxi_ReapConnections(struct rxevent *unused, void *unused1, void *unused2)
                }
            }
        }
-       RWLOCK_UNLOCK(&rx_peerHashTable_lock);
+       MUTEX_EXIT(&rx_peerHashTable_lock);
        MUTEX_EXIT(&rx_rpc_stats);
     }
 
@@ -6940,7 +6943,7 @@ shutdown_rx(void)
                for (queue_Scan
                     (&peer->rpcStats, rpc_stat, nrpc_stat,
                      rx_interface_stat)) {
-                   int num_funcs;
+                   unsigned int num_funcs;
                    if (!rpc_stat)
                        break;
                    queue_Remove(&rpc_stat->queue_header);
@@ -6966,7 +6969,7 @@ shutdown_rx(void)
     }
     for (i = 0; i < rx_hashTableSize; i++) {
        register struct rx_connection *tc, *ntc;
-       RWLOCK_RDLOCK(&rx_connHashTable_lock);
+       MUTEX_ENTER(&rx_connHashTable_lock);
        for (tc = rx_connHashTable[i]; tc; tc = ntc) {
            ntc = tc->next;
            for (j = 0; j < RX_MAXCALLS; j++) {
@@ -6976,7 +6979,7 @@ shutdown_rx(void)
            }
            rxi_Free(tc, sizeof(*tc));
        }
-       RWLOCK_UNLOCK(&rx_connHashTable_lock);
+       MUTEX_EXIT(&rx_connHashTable_lock);
     }
 
     MUTEX_ENTER(&freeSQEList_lock);
@@ -6990,8 +6993,8 @@ shutdown_rx(void)
     MUTEX_EXIT(&freeSQEList_lock);
     MUTEX_DESTROY(&freeSQEList_lock);
     MUTEX_DESTROY(&rx_freeCallQueue_lock);
-    RWLOCK_DESTROY(&rx_connHashTable_lock);
-    RWLOCK_DESTROY(&rx_peerHashTable_lock);
+    MUTEX_DESTROY(&rx_connHashTable_lock);
+    MUTEX_DESTROY(&rx_peerHashTable_lock);
     MUTEX_DESTROY(&rx_serverPool_lock);
 
     osi_Free(rx_connHashTable,
@@ -7767,7 +7770,7 @@ rx_disablePeerRPCStats(void)
        rx_enable_stats = 0;
     }
 
-    RWLOCK_RDLOCK(&rx_peerHashTable_lock);
+    MUTEX_ENTER(&rx_peerHashTable_lock);
     for (peer_ptr = &rx_peerHashTable[0], peer_end =
         &rx_peerHashTable[rx_hashTableSize]; peer_ptr < peer_end;
         peer_ptr++) {
@@ -7806,7 +7809,7 @@ rx_disablePeerRPCStats(void)
            }
        }
     }
-    RWLOCK_UNLOCK(&rx_peerHashTable_lock);
+    MUTEX_EXIT(&rx_peerHashTable_lock);
     MUTEX_EXIT(&rx_rpc_stats);
 }
 
index 2a3dd09..3f63d04 100644 (file)
@@ -64,6 +64,7 @@
 #endif
 #endif /* KERNEL */
 
+
 /* Configurable parameters */
 #define        RX_IDLE_DEAD_TIME       60      /* default idle dead time */
 #define        RX_MAX_SERVICES         20      /* Maximum number of services that may be installed */
@@ -283,7 +284,6 @@ struct rx_connection {
     afs_uint32 callNumber[RX_MAXCALLS];        /* Current call numbers */
     afs_uint32 rwind[RX_MAXCALLS];
     u_short twind[RX_MAXCALLS];
-    u_short serviceId;         /* To stamp on requests (clients only) */
     afs_uint32 serial;         /* Next outgoing packet serial number */
     afs_uint32 lastSerial;     /* # of last packet received, for computing skew */
     afs_int32 maxSerial;       /* largest serial number seen on incoming packets */
@@ -295,6 +295,7 @@ struct rx_connection {
     int abortCount;            /* count of abort messages sent */
     /* client-- to retransmit the challenge */
     struct rx_service *service;        /* used by servers only */
+    u_short serviceId;         /* To stamp on requests (clients only) */
     afs_uint32 refCount;               /* Reference count */
     u_char flags;              /* Defined below */
     u_char type;               /* Type of connection, defined below */
@@ -312,8 +313,7 @@ struct rx_connection {
     u_short hardDeadTime;      /* hard max for call execution */
     u_short idleDeadTime;      /* max time a call can be idle (no data) */
     u_char ackRate;            /* how many packets between ack requests */
-    u_char spareb;
-    afs_int32 makeCallWaiters; /* how many rx_NewCalls are waiting */
+    u_char makeCallWaiters;    /* how many rx_NewCalls are waiting */
     afs_int32 idleDeadErr;
     int nSpecific;             /* number entries in specific data */
     void **specific;           /* pointer to connection specific data */
index 90583e2..87ef987 100644 (file)
@@ -523,8 +523,8 @@ EXT struct rx_connection **rx_connHashTable;
 EXT struct rx_connection *rx_connCleanup_list GLOBALSINIT(0);
 EXT afs_uint32 rx_hashTableSize GLOBALSINIT(257);      /* Prime number */
 #ifdef RX_ENABLE_LOCKS
-EXT afs_krwlock_t rx_peerHashTable_lock;
-EXT afs_krwlock_t rx_connHashTable_lock;
+EXT afs_kmutex_t rx_peerHashTable_lock;
+EXT afs_kmutex_t rx_connHashTable_lock;
 #endif /* RX_ENABLE_LOCKS */
 
 #define CONN_HASH(host, port, cid, epoch, type) ((((cid)>>RX_CIDSHIFT)%rx_hashTableSize))
index bfeaa03..3b4fe46 100644 (file)
 #define MUTEX_ISMINE(a)
 #define CV_INIT(a,b,c,d)
 #define CV_DESTROY(a)
-#define RWLOCK_INIT(a, b, c, d) 
-#define RWLOCK_DESTROY(l) 
-#define RWLOCK_UPLOCK(l) 
-#define RWLOCK_WRLOCK(l) 
-#define RWLOCK_RDLOCK(l) 
-#define RWLOCK_TRYWRLOCK(l) 1
-#define RWLOCK_TRYRDLOCK(l) 1
-#define RWLOCK_UNLOCK(l) 
 #define osirx_AssertMine(a, b)
 
 #endif /* KERNEL */
index eef2904..d68ce7c 100644 (file)
@@ -1851,7 +1851,7 @@ rxi_ReceiveDebugPacket(register struct rx_packet *ap, osi_socket asocket,
                (void)IOMGR_Poll();
 #endif
 #endif
-               RWLOCK_RDLOCK(&rx_connHashTable_lock);
+               MUTEX_ENTER(&rx_connHashTable_lock);
                /* We might be slightly out of step since we are not 
                 * locking each call, but this is only debugging output.
                 */
@@ -1904,8 +1904,8 @@ rxi_ReceiveDebugPacket(register struct rx_packet *ap, osi_socket asocket,
                                 sizeof(afs_int32); i++)
                                DOHTONL(sparel[i]);
                        }
-                       
-                       RWLOCK_UNLOCK(&rx_connHashTable_lock);
+
+                       MUTEX_EXIT(&rx_connHashTable_lock);
                        rx_packetwrite(ap, 0, sizeof(struct rx_debugConn),
                                       (char *)&tconn);
                        tl = ap->length;
@@ -1916,7 +1916,7 @@ rxi_ReceiveDebugPacket(register struct rx_packet *ap, osi_socket asocket,
                        return ap;
                    }
                }
-               RWLOCK_UNLOCK(&rx_connHashTable_lock);
+               MUTEX_EXIT(&rx_connHashTable_lock);
            }
            /* if we make it here, there are no interesting packets */
            tconn.cid = htonl(0xffffffff);      /* means end */
@@ -1963,8 +1963,7 @@ rxi_ReceiveDebugPacket(register struct rx_packet *ap, osi_socket asocket,
                (void)IOMGR_Poll();
 #endif
 #endif
-               RWLOCK_RDLOCK(&rx_peerHashTable_lock);
-               /* XXX should copy out, then unlock and byteswap */
+               MUTEX_ENTER(&rx_peerHashTable_lock);
                for (tp = rx_peerHashTable[i]; tp; tp = tp->next) {
                    if (tin.index-- <= 0) {
                        tpeer.host = tp->host;
@@ -2000,7 +1999,7 @@ rxi_ReceiveDebugPacket(register struct rx_packet *ap, osi_socket asocket,
                        tpeer.bytesReceived.low =
                            htonl(tp->bytesReceived.low);
 
-                       RWLOCK_UNLOCK(&rx_peerHashTable_lock);
+                       MUTEX_EXIT(&rx_peerHashTable_lock);
                        rx_packetwrite(ap, 0, sizeof(struct rx_debugPeer),
                                       (char *)&tpeer);
                        tl = ap->length;
@@ -2011,7 +2010,7 @@ rxi_ReceiveDebugPacket(register struct rx_packet *ap, osi_socket asocket,
                        return ap;
                    }
                }
-               RWLOCK_UNLOCK(&rx_peerHashTable_lock);
+               MUTEX_EXIT(&rx_peerHashTable_lock);
            }
            /* if we make it here, there are no interesting packets */
            tpeer.host = htonl(0xffffffff);     /* means end */
index a717885..cc27ae4 100644 (file)
@@ -358,7 +358,9 @@ rxi_StartListener(void)
        dpf(("Unable to create Rx event handling thread\n"));
        exit(1);
     }
-    rx_MutexIncrement(rxi_pthread_hinum, rx_stats_mutex);
+    MUTEX_ENTER(&rx_stats_mutex);
+    ++rxi_pthread_hinum;
+    MUTEX_EXIT(&rx_stats_mutex);
     AFS_SIGSET_RESTORE();
 
     assert(pthread_mutex_lock(&listener_mutex) == 0);
@@ -395,7 +397,9 @@ rxi_Listen(osi_socket sock)
        dpf(("Unable to create socket listener thread\n"));
        exit(1);
     }
-    rx_MutexIncrement(rxi_pthread_hinum, rx_stats_mutex);
+    MUTEX_ENTER(&rx_stats_mutex);
+    ++rxi_pthread_hinum;
+    MUTEX_EXIT(&rx_stats_mutex);
     AFS_SIGSET_RESTORE();
     return 0;
 }
index c28dccd..ff53183 100644 (file)
@@ -33,7 +33,6 @@
 #include <pthread.h>
 
 typedef pthread_mutex_t afs_kmutex_t;
-typedef pthread_rwlock_t afs_krwlock_t;
 typedef pthread_cond_t afs_kcondvar_t;
 #ifdef RX_ENABLE_LOCKS
 #define MUTEX_ISMINE(l) (pthread_mutex_trylock(l) == EDEADLK)
@@ -47,7 +46,6 @@ typedef pthread_cond_t afs_kcondvar_t;
 
 #include <pthread.h>
 typedef pthread_mutex_t afs_kmutex_t;
-typedef pthread_rwlock_t afs_krwlock_t;
 typedef pthread_cond_t afs_kcondvar_t;
 
 #if !defined(pthread_yield) && defined(AFS_SUN5_ENV)
@@ -76,10 +74,6 @@ typedef pthread_cond_t afs_kcondvar_t;
 extern void osirx_AssertMine(afs_kmutex_t * lockaddr, char *msg);
 
 #ifdef AFS_PTHREAD_ENV
-#if !defined(PTHREAD_RWLOCK_INITIALIZER) && defined(AFS_DARWIN80_ENV)
-#define PTHREAD_RWLOCK_INITIALIZER {0x2DA8B3B4, {0}}
-#endif
-
 #ifdef MUTEX_INIT
 #undef MUTEX_INIT
 #endif
@@ -130,46 +124,6 @@ extern void osirx_AssertMine(afs_kmutex_t * lockaddr, char *msg);
 #endif
 #define CV_BROADCAST(cv) osi_Assert(pthread_cond_broadcast(cv) == 0)
 
-#ifdef RWLOCK_INIT
-#undef RWLOCK_INIT
-#endif
-#define RWLOCK_INIT(a, b, c, d) osi_Assert(pthread_rwlock_init(a, NULL) == 0)
-
-#ifdef RWLOCK_DESTROY
-#undef RWLOCK_DESTROY
-#endif
-#define RWLOCK_DESTROY(l) osi_Assert(pthread_rwlock_destroy(l) == 0)
-
-#ifdef RWLOCK_UPLOCK
-#undef RWLOCK_UPLOCK
-#endif
-#define RWLOCK_UPLOCK(l) do {osi_Assert(pthread_rwlock_unlock(l) == 0); osi_Assert(pthread_rwlock_wrlock(l) == 0);} while (0)
-
-#ifdef RWLOCK_WRLOCK
-#undef RWLOCK_WRLOCK
-#endif
-#define RWLOCK_WRLOCK(l) osi_Assert(pthread_rwlock_wrlock(l) == 0)
-
-#ifdef RWLOCK_RDLOCK
-#undef RWLOCK_RDLOCK
-#endif
-#define RWLOCK_RDLOCK(l) osi_Assert(pthread_rwlock_rdlock(l) == 0)
-
-#ifdef RWLOCK_TRYWRLOCK
-#undef RWLOCK_TRYWRLOCK
-#endif
-#define RWLOCK_TRYWRLOCK(l) pthread_rwlock_trywrlock(l) ? 0 : 1
-
-#ifdef RWLOCK_TRYRDLOCK
-#undef RWLOCK_TRYRDLOCK
-#endif
-#define RWLOCK_TRYRDLOCK(l) pthread_rwlock_tryrdlock(l) ? 0 : 1
-
-#ifdef RWLOCK_UNLOCK
-#undef RWLOCK_UNLOCK
-#endif
-#define RWLOCK_UNLOCK(l) osi_Assert(pthread_rwlock_unlock(l) == 0)
-
 #endif /* AFS_PTHREAD_ENV */