Changeset 11706


Ignore:
Timestamp:
Jan 18, 2011, 11:44:36 PM (11 years ago)
Author:
jordan
Message:

cleanup of who calls the libtransmission thread locking functions.

In some cases we were calling them from deep inside libtransmission, when they should have been called directly from the public-visible API functions: tr_torrentWebSpeeds_KBps(), tr_torrentPeers(), tr_torrentTrackers().

Location:
trunk/libtransmission
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/announcer.c

    r11668 r11706  
    19571957
    19581958    assert( tr_isTorrent( torrent ) );
     1959    assert( tr_torrentIsLocked( torrent ) );
    19591960
    19601961    /* count the trackers... */
  • trunk/libtransmission/peer-mgr.c

    r11704 r11706  
    20662066    Torrent * t = tor->torrentPeers;
    20672067
    2068     assert( t != NULL );
    2069     managerLock( t->manager );
     2068    assert( tr_isTorrent( tor ) );
     2069    assert( tr_torrentIsLocked( tor ) );
     2070
    20702071    ensureMgrTimersExist( t->manager );
    20712072
     
    20742075
    20752076    rechokePulse( 0, 0, t->manager );
    2076     managerUnlock( t->manager );
    20772077}
    20782078
     
    20812081{
    20822082    int i, n;
    2083 
    2084     assert( torrentIsLocked( t ) );
    20852083
    20862084    t->isRunning = FALSE;
     
    21002098tr_peerMgrStopTorrent( tr_torrent * tor )
    21012099{
    2102     Torrent * t = tor->torrentPeers;
    2103 
    2104     managerLock( t->manager );
    2105 
    2106     stopTorrent( t );
    2107 
    2108     managerUnlock( t->manager );
     2100    assert( tr_isTorrent( tor ) );
     2101    assert( tr_torrentIsLocked( tor ) );
     2102
     2103    stopTorrent( tor->torrentPeers );
    21092104}
    21102105
    21112106void
    2112 tr_peerMgrAddTorrent( tr_peerMgr * manager,
    2113                       tr_torrent * tor )
    2114 {
    2115     managerLock( manager );
    2116 
    2117     assert( tor );
     2107tr_peerMgrAddTorrent( tr_peerMgr * manager, tr_torrent * tor )
     2108{
     2109    assert( tr_isTorrent( tor ) );
     2110    assert( tr_torrentIsLocked( tor ) );
    21182111    assert( tor->torrentPeers == NULL );
    21192112
    21202113    tor->torrentPeers = torrentConstructor( manager, tor );
    2121 
    2122     managerUnlock( manager );
    21232114}
    21242115
     
    21262117tr_peerMgrRemoveTorrent( tr_torrent * tor )
    21272118{
    2128     tr_torrentLock( tor );
     2119    assert( tr_isTorrent( tor ) );
     2120    assert( tr_torrentIsLocked( tor ) );
    21292121
    21302122    stopTorrent( tor->torrentPeers );
    21312123    torrentDestructor( tor->torrentPeers );
    2132 
    2133     tr_torrentUnlock( tor );
    21342124}
    21352125
     
    21732163{
    21742164    int i;
    2175     int peerCount;
    21762165    Torrent * t = tor->torrentPeers;
    2177     const tr_peer ** peers;
    2178     tr_bitfield * pieces;
    2179     managerLock( t->manager );
    2180 
    2181     pieces = tr_bitfieldNew( t->tor->info.pieceCount );
    2182     peerCount = tr_ptrArraySize( &t->peers );
    2183     peers = (const tr_peer**) tr_ptrArrayBase( &t->peers );
     2166    const int peerCount = tr_ptrArraySize( &t->peers );
     2167    const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase( &t->peers );
     2168    tr_bitfield * pieces = tr_bitfieldNew( t->tor->info.pieceCount );
     2169
     2170    assert( tr_torrentIsLocked( tor ) );
     2171
    21842172    for( i=0; i<peerCount; ++i )
    21852173        tr_bitsetOr( pieces, &peers[i]->have );
    21862174
    2187     managerUnlock( t->manager );
    21882175    return pieces;
    21892176}
    21902177
    21912178void
    2192 tr_peerMgrTorrentStats( tr_torrent       * tor,
    2193                         int              * setmePeersKnown,
    2194                         int              * setmePeersConnected,
    2195                         int              * setmeSeedsConnected,
    2196                         int              * setmeWebseedsSendingToUs,
    2197                         int              * setmePeersSendingToUs,
    2198                         int              * setmePeersGettingFromUs,
    2199                         int              * setmePeersFrom )
     2179tr_peerMgrTorrentStats( tr_torrent  * tor,
     2180                        int         * setmePeersKnown,
     2181                        int         * setmePeersConnected,
     2182                        int         * setmeSeedsConnected,
     2183                        int         * setmeWebseedsSendingToUs,
     2184                        int         * setmePeersSendingToUs,
     2185                        int         * setmePeersGettingFromUs,
     2186                        int         * setmePeersFrom )
    22002187{
    22012188    int i, size;
     
    22042191    const tr_webseed ** webseeds;
    22052192
    2206     managerLock( t->manager );
     2193    assert( tr_torrentIsLocked( tor ) );
    22072194
    22082195    peers = (const tr_peer **) tr_ptrArrayBase( &t->peers );
     
    22462233        if( tr_webseedIsActive( webseeds[i] ) )
    22472234            ++*setmeWebseedsSendingToUs;
    2248 
    2249     managerUnlock( t->manager );
    22502235}
    22512236
     
    22722257tr_peerMgrWebSpeeds_KBps( const tr_torrent * tor )
    22732258{
     2259    int i;
    22742260    const Torrent * t = tor->torrentPeers;
    2275     const tr_webseed ** webseeds;
    2276     int i;
    2277     int webseedCount;
    2278     double * ret;
    2279     uint64_t now;
    2280 
    2281     assert( t->manager );
    2282     managerLock( t->manager );
    2283 
    2284     webseeds = (const tr_webseed**) tr_ptrArrayBase( &t->webseeds );
    2285     webseedCount = tr_ptrArraySize( &t->webseeds );
     2261    const int webseedCount = tr_ptrArraySize( &t->webseeds );
     2262    const tr_webseed ** webseeds = (const tr_webseed**) tr_ptrArrayBase( &t->webseeds );
     2263    const uint64_t now = tr_time_msec( );
     2264    double * ret = tr_new0( double, webseedCount );
     2265
     2266    assert( tr_isTorrent( tor ) );
     2267    assert( tr_torrentIsLocked( tor ) );
     2268    assert( t->manager != NULL );
    22862269    assert( webseedCount == tor->info.webseedCount );
    2287     ret = tr_new0( double, webseedCount );
    2288     now = tr_time_msec( );
    22892270
    22902271    for( i=0; i<webseedCount; ++i ) {
     
    22962277    }
    22972278
    2298     managerUnlock( t->manager );
    22992279    return ret;
    23002280}
     
    23082288
    23092289struct tr_peer_stat *
    2310 tr_peerMgrPeerStats( const tr_torrent    * tor,
    2311                      int                 * setmeCount )
    2312 {
    2313     int i, size;
     2290tr_peerMgrPeerStats( const tr_torrent * tor, int * setmeCount )
     2291{
     2292    int i;
    23142293    const Torrent * t = tor->torrentPeers;
    2315     const tr_peer ** peers;
    2316     tr_peer_stat * ret;
    2317     uint64_t now_msec;
    2318     time_t now;
    2319 
     2294    const int size = tr_ptrArraySize( &t->peers );
     2295    const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase( &t->peers );
     2296    const uint64_t now_msec = tr_time_msec( );
     2297    const time_t now = tr_time();
     2298    tr_peer_stat * ret = tr_new0( tr_peer_stat, size );
     2299
     2300    assert( tr_isTorrent( tor ) );
     2301    assert( tr_torrentIsLocked( tor ) );
    23202302    assert( t->manager );
    2321     managerLock( t->manager );
    2322 
    2323     size = tr_ptrArraySize( &t->peers );
    2324     peers = (const tr_peer**) tr_ptrArrayBase( &t->peers );
    2325     ret = tr_new0( tr_peer_stat, size );
    2326     now_msec = tr_time_msec( );
    2327     now = tr_time();
    23282303
    23292304    for( i=0; i<size; ++i )
     
    23772352    *setmeCount = size;
    23782353
    2379     managerUnlock( t->manager );
    23802354    return ret;
    23812355}
     
    23892363{
    23902364    int i;
    2391     Torrent * t;
    2392     int peerCount;
     2365    Torrent * t = tor->torrentPeers;
     2366    const int peerCount = tr_ptrArraySize( &t->peers );
    23932367
    23942368    assert( tr_isTorrent( tor ) );
    2395 
    2396     t = tor->torrentPeers;
    2397 
    2398     torrentLock( t );
    2399 
    2400     peerCount = tr_ptrArraySize( &t->peers );
     2369    assert( tr_torrentIsLocked( tor ) );
    24012370
    24022371    for( i=0; i<peerCount; ++i )
     
    24052374        tr_peerMsgsSetInterested( peer->msgs, FALSE );
    24062375    }
    2407 
    2408     torrentUnlock( t );
    24092376}
    24102377
  • trunk/libtransmission/torrent.c

    r11704 r11706  
    13991399tr_torrentWebSpeeds_KBps( const tr_torrent * tor )
    14001400{
    1401     return tr_isTorrent( tor ) ? tr_peerMgrWebSpeeds_KBps( tor ) : NULL;
     1401    double * ret = NULL;
     1402
     1403    if( tr_isTorrent( tor ) )
     1404    {
     1405        tr_torrentLock( tor );
     1406        ret = tr_peerMgrWebSpeeds_KBps( tor );
     1407        tr_torrentUnlock( tor );
     1408    }
     1409
     1410    return ret;
    14021411}
    14031412
    14041413tr_peer_stat *
    1405 tr_torrentPeers( const tr_torrent * tor,
    1406                  int *              peerCount )
     1414tr_torrentPeers( const tr_torrent * tor, int * peerCount )
    14071415{
    14081416    tr_peer_stat * ret = NULL;
    14091417
    14101418    if( tr_isTorrent( tor ) )
     1419    {
     1420        tr_torrentLock( tor );
    14111421        ret = tr_peerMgrPeerStats( tor, peerCount );
     1422        tr_torrentUnlock( tor );
     1423    }
    14121424
    14131425    return ret;
     
    14151427
    14161428void
    1417 tr_torrentPeersFree( tr_peer_stat * peers,
    1418                      int peerCount  UNUSED )
     1429tr_torrentPeersFree( tr_peer_stat * peers, int peerCount UNUSED )
    14191430{
    14201431    tr_free( peers );
     
    14221433
    14231434tr_tracker_stat *
    1424 tr_torrentTrackers( const tr_torrent * torrent,
    1425                     int              * setmeTrackerCount )
    1426 {
    1427     assert( tr_isTorrent( torrent ) );
    1428 
    1429     return tr_announcerStats( torrent, setmeTrackerCount );
    1430 }
    1431 
    1432 void
    1433 tr_torrentTrackersFree( tr_tracker_stat * trackers,
    1434                         int trackerCount )
     1435tr_torrentTrackers( const tr_torrent * torrent, int * setmeTrackerCount )
     1436{
     1437    tr_tracker_stat * ret = NULL;
     1438
     1439    if( tr_isTorrent( torrent ) )
     1440    {
     1441        tr_torrentLock( torrent );
     1442        ret = tr_announcerStats( torrent, setmeTrackerCount );
     1443        tr_torrentUnlock( torrent );
     1444    }
     1445
     1446    return ret;
     1447}
     1448
     1449void
     1450tr_torrentTrackersFree( tr_tracker_stat * trackers, int trackerCount )
    14351451{
    14361452    tr_announcerStatsFree( trackers, trackerCount );
     
    17231739    assert( tr_isTorrent( tor ) );
    17241740
     1741    tr_torrentLock( tor );
     1742
    17251743    tr_verifyRemove( tor );
    17261744    tr_peerMgrStopTorrent( tor );
     
    17321750    if( !tor->isDeleting )
    17331751        tr_torrentSave( tor );
     1752
     1753    tr_torrentUnlock( tor );
    17341754}
    17351755
  • trunk/libtransmission/torrent.h

    r11599 r11706  
    296296{
    297297    tr_sessionLock( tor->session );
     298}
     299
     300static inline tr_bool tr_torrentIsLocked( const tr_torrent * tor )
     301{
     302    return tr_sessionIsLocked( tor->session );
    298303}
    299304
Note: See TracChangeset for help on using the changeset viewer.