Changeset 3254

Timestamp:

Oct 1, 2007, 3:17:15 PM (15 years ago)

Author:

charles

Message:

simplify libT locks now that it's (more-or-less) single-threaded. fix deadlocks. make tr_locks nestable.

Location:

trunk/libtransmission

Files:

• internal.h (modified) (3 diffs)
• makemeta.c (modified) (1 diff)
• peer-mgr.c (modified) (15 diffs)
• platform.c (modified) (6 diffs)
• platform.h (modified) (1 diff)
• shared.c (modified) (7 diffs)
• shared.h (modified) (1 diff)
• torrent.c (modified) (8 diffs)
• transmission.c (modified) (7 diffs)

trunk/libtransmission/internal.h

@@ -140 +140 @@
     run_status_t               runStatusToSave;
     cp_status_t                cpStatus;
-    struct tr_lock           * lock;
 
     struct tr_tracker        * tracker;
@@ -189 +188 @@
     struct tr_shared         * shared;
 
+    struct tr_lock           * lock;
+
     tr_handle_status           stats[2];
     int                        statCur;
@@ -198 +199 @@
 };
 
-#endif
+void tr_globalLock       ( struct tr_handle * );
+void tr_globalUnlock     ( struct tr_handle * );
+int  tr_globalIsLocked   ( const struct tr_handle * );
+
+
+#endif

trunk/libtransmission/makemeta.c

@@ -416 +416 @@
     static tr_lock * lock = NULL;
 
-    tr_sharedLock( h->shared );
+    tr_globalLock( h );
     if( !lock )
          lock = tr_lockNew( );
-    tr_sharedUnlock( h->shared );
+    tr_globalUnlock( h );
 
     return lock;

trunk/libtransmission/peer-mgr.c

@@ -30 +30 @@
 #include "ptrarray.h"
 #include "ratecontrol.h"
+#include "shared.h"
 #include "trevent.h"
 #include "utils.h"
-
-#include "pthread.h"
 
 enum
@@ -107 +106 @@
     int connectionCount;
     tr_ptrArray * handshakes; /* in-process */
-    tr_lock * lock;
-    pthread_t lockThread;
 };
 
@@ -118 +115 @@
 managerLock( struct tr_peerMgr * manager )
 {
-    assert( manager->lockThread != pthread_self() );
-    tr_lockLock( manager->lock );
-    manager->lockThread = pthread_self();
+    tr_globalLock( manager->handle );
 }
 static void
 managerUnlock( struct tr_peerMgr * manager )
 {
-    assert( manager->lockThread == pthread_self() );
-    manager->lockThread = 0;
-    tr_lockUnlock( manager->lock );
+    tr_globalUnlock( manager->handle );
 }
 static void
@@ -142 +135 @@
 torrentIsLocked( const Torrent * t )
 {
-    return ( t != NULL )
-        && ( t->manager != NULL )
-        && ( t->manager->lockThread != 0 )
-        && ( t->manager->lockThread == pthread_self( ) );
+    return ( t != NULL ) 
+        && ( tr_globalIsLocked( t->manager->handle ) );
 }
 
@@ -436 +427 @@
     m->torrents = tr_ptrArrayNew( );
     m->handshakes = tr_ptrArrayNew( );
-    m->lock = tr_lockNew( );
     return m;
 }
@@ -449 +439 @@
 
     managerUnlock( manager );
-    tr_lockFree( manager->lock );
     tr_free( manager );
 }
@@ -483 +472 @@
     uint32_t peerCount;
     uint32_t fastAllowed;
-    uint32_t random;
+    uint8_t random;
 };
 
@@ -505 +494 @@
 
     /* otherwise go with our random seed */
-    return tr_compareUint32( a->random, b->random );
+    return tr_compareUint8( a->random, b->random );
 }
 
@@ -557 +546 @@
             setme->peerCount = 0;
             setme->fastAllowed = 0;
-            setme->random = tr_rand( UINT32_MAX );
+            setme->random = tr_rand( UINT8_MAX );
             /* FIXME */
 //            setme->fastAllowed = tr_bitfieldHas( t->tor->allowedList, i);
@@ -820 +809 @@
     Torrent * t = (Torrent *) vt;
     const tr_peermsgs_event * e = (const tr_peermsgs_event *) vevent;
-    const int needLock = !torrentIsLocked( t );
-
-    if( needLock )
-        torrentLock( t );
+
+    torrentLock( t );
 
     switch( e->eventType )
@@ -862 +849 @@
     }
 
-    if( needLock )
-        torrentUnlock( t );
+    torrentUnlock( t );
 }
 
@@ -965 +951 @@
     tr_handshake * handshake;
 
-    assert( manager->lockThread!=0 );
     assert( io != NULL );
 
@@ -1092 +1077 @@
 {
     const Torrent * t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
-    const int isLocked = torrentIsLocked( t );
     int i, peerCount;
     const tr_peer ** peers;
@@ -1098 +1082 @@
     tr_pex * walk;
 
-    if( !isLocked )
-        torrentLock( (Torrent*)t );
+    torrentLock( (Torrent*)t );
 
     peers = (const tr_peer **) tr_ptrArrayPeek( t->peers, &peerCount );
@@ -1121 +1104 @@
     *setme_pex = pex;
 
-    if( !isLocked )
-        torrentUnlock( (Torrent*)t );
+    torrentUnlock( (Torrent*)t );
 
     return peerCount;

trunk/libtransmission/platform.c

@@ -57 +57 @@
 ***/
 
+#ifdef __BEOS__
+typedef thread_id tr_thread_id;
+#elif defined(WIN32)
+typedef DWORD tr_thread_id;
+#else
+typedef pthread_t tr_thread_id;
+#endif
+
+static tr_thread_id
+tr_getCurrentThread( void )
+{
+#ifdef __BEOS__
+    return find_thread( NULL );
+#elif defined(WIN32)
+    return GetCurrentThreadId();
+#else
+    return pthread_self( );
+#endif
+}
+
+static int
+tr_areThreadsEqual( tr_thread_id a, tr_thread_id b )
+{
+#ifdef __BEOS__
+    return a == b;
+#elif defined(WIN32)
+    return a == b;
+#else
+    return pthread_equal( a, b );
+#endif
+}
+
 struct tr_thread
 {
@@ -73 +105 @@
 
 };
+
+int
+tr_amInThread ( const tr_thread * t )
+{
+    return tr_areThreadsEqual( tr_getCurrentThread(), t->thread );
+}
 
 #ifdef WIN32
@@ -123 +161 @@
     return t;
 }
-
-int
-tr_amInThread ( const tr_thread * t )
-{
-#ifdef __BEOS__
-    return find_thread(NULL) == t->thread;
-#elif defined(WIN32)
-    return GetCurrentThreadId() == t->thread_id;
-#else
-    return pthread_equal( t->thread, pthread_self( ) );
-#endif
-}
     
 void
@@ -164 +190 @@
 struct tr_lock
 {
+    uint32_t depth;
 #ifdef __BEOS__
     sem_id lock;
+    thread_id lockThread;
 #elif defined(WIN32)
     CRITICAL_SECTION lock;
+    DWORD lockThread;
 #else
     pthread_mutex_t lock;
+    pthread_t lockThread;
 #endif
 };
@@ -217 +247 @@
 tr_lockLock( tr_lock * l )
 {
-#ifdef __BEOS__
-    acquire_sem( l->lock );
-#elif defined(WIN32)
-    EnterCriticalSection( &l->lock );
-#else
-    pthread_mutex_lock( &l->lock );
-#endif
+    tr_thread_id currentThread = tr_getCurrentThread( );
+    if( l->lockThread == currentThread )
+    {
+        ++l->depth;
+    }
+    else
+    {
+#ifdef __BEOS__
+        acquire_sem( l->lock );
+#elif defined(WIN32)
+        EnterCriticalSection( &l->lock );
+#else
+        pthread_mutex_lock( &l->lock );
+#endif
+        l->lockThread = tr_getCurrentThread( );
+        l->depth = 1;
+    }
+}
+
+int
+tr_lockHave( const tr_lock * l )
+{
+    return ( l->depth > 0 )
+        && ( l->lockThread == tr_getCurrentThread() );
 }
 
@@ -229 +276 @@
 tr_lockUnlock( tr_lock * l )
 {
-#ifdef __BEOS__
-    release_sem( l->lock );
-#elif defined(WIN32)
-    LeaveCriticalSection( &l->lock );
-#else
-    pthread_mutex_unlock( &l->lock );
-#endif
+    assert( tr_lockHave( l ) );
+
+    if( !--l->depth )
+    {
+        l->lockThread = 0;
+#ifdef __BEOS__
+        release_sem( l->lock );
+#elif defined(WIN32)
+        LeaveCriticalSection( &l->lock );
+#else
+        pthread_mutex_unlock( &l->lock );
+#endif
+    }
 }
 

trunk/libtransmission/platform.h

@@ -42 +42 @@
 void         tr_lockLock       ( tr_lock * );
 void         tr_lockUnlock     ( tr_lock * );
+int          tr_lockHave       ( const tr_lock * );
 
 tr_cond *    tr_condNew       ( void );

trunk/libtransmission/shared.c

@@ -45 +45 @@
 {
     tr_handle    * h;
-    tr_lock      * lock;
     tr_timer     * pulseTimer;
 
@@ -76 +75 @@
 
     s->h          = h;
-    s->lock       = tr_lockNew( );
     s->publicPort = -1;
     s->bindPort   = -1;
@@ -97 +95 @@
 
     tr_netClose( s->bindSocket );
-    tr_lockFree( s->lock );
     tr_natpmpClose( s->natpmp );
     tr_upnpClose( s->upnp );
     free( s );
-}
-
-/**
-***
-**/
-
-void tr_sharedLock( tr_shared * s )
-{
-    tr_lockLock( s->lock );
-}
-void tr_sharedUnlock( tr_shared * s )
-{
-    tr_lockUnlock( s->lock );
 }
 
@@ -129 +113 @@
 #endif
 
-    tr_sharedLock( s );
+    tr_globalLock( s->h );
 
     if( port == s->bindPort )
     {
-        tr_sharedUnlock( s );
+        tr_globalUnlock( s->h );
         return;
     }
@@ -166 +150 @@
     }
 
-    tr_sharedUnlock( s );
+    tr_globalUnlock( s->h );
 }
 
@@ -238 +222 @@
     tr_shared * s = vs;
 
-    tr_sharedLock( s );
+    tr_globalLock( s->h );
 
     /* NAT-PMP and UPnP pulses */
@@ -250 +234 @@
     AcceptPeers( s );
 
-    tr_sharedUnlock( s );
+    tr_globalUnlock( s->h );
 
     return TRUE;

trunk/libtransmission/shared.h

@@ -40 +40 @@
 
 /***********************************************************************
- * tr_sharedLock, tr_sharedUnlock
- ***********************************************************************
- * Gets / releases exclusive access to ressources used by the shared
- * thread
- **********************************************************************/
-void          tr_sharedLock           ( tr_shared * );
-void          tr_sharedUnlock         ( tr_shared * );
-
-/***********************************************************************
  * tr_sharedSetPort
  ***********************************************************************

trunk/libtransmission/torrent.c

@@ -91 +91 @@
 tr_torrentLock( const tr_torrent * tor )
 {
-    tr_lockLock ( (tr_lock*)tor->lock );
+    tr_globalLock( tor->handle );
 }
 
@@ -97 +97 @@
 tr_torrentUnlock( const tr_torrent * tor )
 {
-    tr_lockUnlock ( (tr_lock*)tor->lock );
+    tr_globalUnlock( tor->handle );
 }
 
@@ -300 +300 @@
     tor->info.flags |= flags;
 
-    tr_sharedLock( h->shared );
+    tr_globalLock( h );
 
     tor->destination = tr_strdup( destination );
@@ -356 +356 @@
     tr_torrentInitFilePieces( tor );
 
-    tor->lock = tr_lockNew( );
-
     tor->upload         = tr_rcInit();
     tor->download       = tr_rcInit();
@@ -365 +363 @@
                                   info->hash, SHA_DIGEST_LENGTH,
                                   NULL );
- 
-    tr_sharedUnlock( h->shared );
 
     tr_peerMgrAddTorrent( h->peerMgr, tor );
@@ -408 +404 @@
     tor->trackerSubscription = tr_trackerSubscribe( tor->tracker, onTrackerResponse, tor );
 
-    tr_sharedLock( h->shared );
     tor->next = h->torrentList;
     h->torrentList = tor;
     h->torrentCount++;
-    tr_sharedUnlock( h->shared );
+
+    tr_globalUnlock( h );
 
     tr_ioRecheckAdd( tor, recheckDoneCB, tor->runStatus );
@@ -1000 +996 @@
     assert( tor->runStatus == TR_RUN_STOPPED );
 
-    tr_sharedLock( h->shared );
+    tr_globalLock( h );
 
     tr_peerMgrRemoveTorrent( h->peerMgr, tor->info.hash );
 
-    tr_lockFree( tor->lock );
     tr_cpClose( tor->completion );
 
@@ -1035 +1030 @@
     tr_free( tor );
 
-    tr_sharedUnlock( h->shared );
+    tr_globalUnlock( h );
 }
 

trunk/libtransmission/transmission.c

@@ -122 +122 @@
         return NULL;
 
+    h->lock = tr_lockNew( );
+
     h->encryptionMode = TR_ENCRYPTION_PREFERRED;
 
@@ -152 +154 @@
 
     return h;
+}
+
+/***
+****
+***/
+
+void
+tr_globalLock( struct tr_handle * handle )
+{
+    tr_lockLock( handle->lock );
+}
+
+void
+tr_globalUnlock( struct tr_handle * handle )
+{
+    tr_lockUnlock( handle->lock );
+}
+
+int
+tr_globalIsLocked( const struct tr_handle * handle )
+{
+    return tr_lockHave( handle->lock );
 }
 
@@ -174 +198 @@
 void tr_natTraversalEnable( tr_handle * h, int enable )
 {
-    tr_sharedLock( h->shared );
+    tr_globalLock( h );
     tr_sharedTraversalEnable( h->shared, enable );
-    tr_sharedUnlock( h->shared );
+    tr_globalUnlock( h );
 }
 
@@ -186 +210 @@
     s = &h->stats[h->statCur];
 
-    tr_sharedLock( h->shared );
+    tr_globalLock( h );
 
     s->natTraversalStatus = tr_sharedTraversalStatus( h->shared );
     s->publicPort = tr_sharedGetPublicPort( h->shared );
 
-    tr_sharedUnlock( h->shared );
+    tr_globalUnlock( h );
 
     return s;
@@ -242 +266 @@
     *dl = 0.0;
     *ul = 0.0;
-    tr_sharedLock( h->shared );
+    tr_globalLock( h );
     for( tor = h->torrentList; tor; tor = tor->next )
     {
@@ -251 +275 @@
         tr_torrentUnlock( tor );
     }
-    tr_sharedUnlock( h->shared );
+    tr_globalUnlock( h );
 }
 
@@ -301 +325 @@
     }
 
+    tr_lockFree( h->lock );
     free( h->tag );
     free( h );