Changeset 2462


Ignore:
Timestamp:
Jul 23, 2007, 3:00:20 AM (14 years ago)
Author:
charles
Message:

set default torrent ul/dl speed limits from global ul/dl speed. as a side effect, totally decouples fastresume from inout.

Location:
trunk/libtransmission
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/fastresume.c

    r2443 r2462  
    147147}
    148148
    149 void fastResumeSave( const tr_torrent_t * tor )
     149void
     150tr_fastResumeSave( const tr_torrent_t * tor )
    150151{
    151152    char      path[MAX_PATH_LENGTH];
     
    391392        bitfield.bits = walk;
    392393        tr_cpBlockBitfieldSet( tor->completion, &bitfield );
     394/* FIXME: remove the "unchecked pieces" */
    393395    }
    394396
     
    397399}
    398400
    399 static int
     401static uint64_t
    400402fastResumeLoadOld( tr_torrent_t   * tor,
    401403                   tr_bitfield_t  * uncheckedPieces,
    402404                   FILE           * file )
    403405{
     406    uint64_t ret = 0;
     407
    404408    /* Check the size */
    405409    const int size = 4 + FR_PROGRESS_LEN( tor );
     
    423427    fclose( file );
    424428
     429    ret |= TR_FR_PROGRESS;
    425430    tr_inf( "Fast resuming successful (version 0)" );
    426    
    427     return 0;
    428 }
    429 
    430 int
    431 fastResumeLoad( tr_torrent_t   * tor,
    432                 tr_bitfield_t  * uncheckedPieces )
     431
     432    return ret;
     433}
     434
     435static uint64_t
     436fastResumeLoadImpl ( tr_torrent_t   * tor,
     437                     tr_bitfield_t  * uncheckedPieces )
    433438{
    434439    char      path[MAX_PATH_LENGTH];
     
    437442    uint8_t   id;
    438443    uint32_t  len;
    439     int       ret;
     444    uint64_t  ret = 0;
    440445
    441446    assert( tor != NULL );
     
    445450    fastResumeFileName( path, sizeof path, tor, 1 );
    446451    file = fopen( path, "r" );
    447     if( NULL == file )
     452    if( !file )
    448453    {
    449454        if( ENOENT == errno )
     
    451456            fastResumeFileName( path, sizeof path, tor, 0 );
    452457            file = fopen( path, "r" );
    453             if( NULL != file )
     458            if( !file )
    454459            {
    455                 goto good;
     460                fastResumeFileName( path, sizeof path, tor, 1 );
     461                tr_inf( "Couldn't open '%s' for reading", path );
     462                return ret;
    456463            }
    457             fastResumeFileName( path, sizeof path, tor, 1 );
    458464        }
    459         tr_inf( "Could not open '%s' for reading", path );
    460         return 1;
    461     }
    462   good:
     465    }
     466
    463467    tr_dbg( "Resume file '%s' loaded", path );
    464468
     
    473477        tr_inf( "Resume file has version %d, not supported", version );
    474478        fclose( file );
    475         return 1;
    476     }
    477 
    478     ret = 1;
     479        return ret;
     480    }
     481
    479482    /* read each block of data */
    480483    while( 1 == fread( &id, 1, 1, file ) && 1 == fread( &len, 4, 1, file ) )
     
    486489                if( (uint32_t)FR_PROGRESS_LEN( tor ) == len )
    487490                {
    488                     ret = fastResumeLoadProgress( tor, uncheckedPieces, file );
    489 
    490                     if( ret && ( feof(file) || ferror(file) ) )
     491                    const int rret = fastResumeLoadProgress( tor, uncheckedPieces, file );
     492
     493                    if( rret && ( feof(file) || ferror(file) ) )
    491494                    {
    492495                        fclose( file );
    493                         return 1;
     496                        return ret;
    494497                    }
    495498
     499                    ret |= TR_FR_PROGRESS;
    496500                    continue;
    497501                }
     
    503507                if( len == (uint32_t)(2 * tor->info.fileCount) )
    504508                {
    505                     ret = loadPriorities( tor, file );
    506 
    507                     if( ret && ( feof(file) || ferror(file) ) )
     509                    const int rret = loadPriorities( tor, file );
     510
     511                    if( rret && ( feof(file) || ferror(file) ) )
    508512                    {
    509513                        fclose( file );
    510                         return 1;
     514                        return ret;
    511515                    }
    512516
     517                    ret |= TR_FR_PRIORITY;
    513518                    continue;
    514519                }
     
    519524                if( len == FR_SPEED_LEN )
    520525                {
    521                     ret = loadSpeeds( tor, file );
    522 
    523                     if( ret && ( feof(file) || ferror(file) ) )
     526                    const int rret = loadSpeeds( tor, file );
     527
     528                    if( rret && ( feof(file) || ferror(file) ) )
    524529                    {
    525530                        fclose( file );
    526                         return 1;
     531                        return ret;
    527532                    }
    528533
     534                    ret |= TR_FR_SPEEDLIMIT;
    529535                    continue;
    530536                }
     
    538544                    {
    539545                        fclose( file );
    540                         return 1;
     546                        return ret;
    541547                    }
    542548                    tor->downloadedCur = 0;
     549                    ret |= TR_FR_DOWNLOADED;
    543550                    continue;
    544551                }
     
    552559                    {
    553560                        fclose( file );
    554                         return 1;
     561                        return ret;
    555562                    }
     563                    tor->uploadedCur = 0;
     564                    ret |= TR_FR_UPLOADED;
    556565                    continue;
    557566                }
     
    567576                        free( buf );
    568577                        fclose( file );
    569                         return 1;
     578                        return ret;
    570579                    }
    571580                    used = tr_torrentAddCompact( tor, TR_PEER_FROM_CACHE,
     
    574583                            len / 6, used );
    575584                    free( buf );
     585                    ret |= TR_FR_PEERS;
    576586                }
    577587                continue;
     
    587597
    588598    fclose( file );
    589 
    590     if( !ret )
    591     {
    592         tr_inf( "Fast resuming successful" );
    593     }
    594    
    595599    return ret;
    596600}
     601
     602uint64_t
     603tr_fastResumeLoad( tr_torrent_t   * tor,
     604                   tr_bitfield_t  * uncheckedPieces )
     605{
     606    const uint64_t ret = fastResumeLoadImpl( tor, uncheckedPieces );
     607
     608    if( ! ( ret & TR_FR_PROGRESS ) )
     609        tr_bitfieldAddRange( uncheckedPieces, 0, tor->info.pieceCount );
     610
     611    return ret;
     612}
  • trunk/libtransmission/fastresume.h

    r2315 r2462  
    2626#define TR_FAST_RESUME_H
    2727
    28 void fastResumeSave( const tr_torrent_t * tor );
     28void tr_fastResumeSave( const tr_torrent_t * tor );
    2929
    30 int fastResumeLoad( tr_torrent_t   * tor,
    31                     tr_bitfield_t  * uncheckedPieces );
     30enum
     31{
     32  TR_FR_DOWNLOADED   = (1<<0),
     33  TR_FR_UPLOADED     = (1<<1),
     34  TR_FR_PEERS        = (1<<2),
     35  TR_FR_PROGRESS     = (1<<3),
     36  TR_FR_PRIORITY     = (1<<4),
     37  TR_FR_SPEEDLIMIT   = (1<<5)
     38};
     39
     40/**
     41 * Returns a bitwise-or'ed set of the data loaded from fastresume
     42 */
     43uint64_t tr_fastResumeLoad( tr_torrent_t   * tor,
     44                            tr_bitfield_t  * uncheckedPieces );
    3245
    3346#endif
  • trunk/libtransmission/inout.c

    r2348 r2462  
    1313#include <unistd.h>
    1414#include "transmission.h"
    15 #include "fastresume.h"
    1615#include "fdlimit.h"
    1716
     
    212211}
    213212
    214 int
    215 tr_ioCheckFiles( tr_torrent_t * tor, int mode )
    216 {
    217     int i;
    218     tr_bitfield_t * uncheckedPieces = tr_bitfieldNew( tor->info.pieceCount );
    219 
    220     tr_cpReset( tor->completion );
    221 
    222     tr_bitfieldClear( uncheckedPieces );
    223 
    224     if( (mode==TR_RECHECK_FORCE) || fastResumeLoad( tor, uncheckedPieces ) )
    225         tr_bitfieldAddRange( uncheckedPieces, 0, tor->info.pieceCount );
    226 
    227     if( tr_bitfieldIsEmpty( uncheckedPieces ) ) {
    228         tr_bitfieldFree( uncheckedPieces );
    229         return TR_OK;
    230     }
    231 
    232     if( mode == TR_RECHECK_FAST ) {
    233         tr_bitfieldFree( uncheckedPieces );
    234         return TR_ERROR_IO_OTHER;
    235     }
    236 
    237     tr_inf( "Verifying some pieces of \"%s\"", tor->info.name );
    238 
    239     for( i=0; i<tor->info.pieceCount; ++i )
    240     {
    241         if( !tr_bitfieldHas( uncheckedPieces, i ) )
    242             continue;
    243 
    244         tr_dbg ( "Checking piece %d because it's not in fast-resume", i );
    245 
    246         tr_torrentSetHasPiece( tor, i, !checkPiece( tor, i ) );
    247 
    248         tr_bitfieldRem( uncheckedPieces, i );
    249     }
    250 
    251     fastResumeSave( tor );
    252     tr_bitfieldFree( uncheckedPieces );
    253     return TR_OK;
     213void
     214tr_ioCheckFiles( tr_torrent_t * tor )
     215{
     216    if( tor->uncheckedPieces != NULL )
     217    {
     218        int i;
     219        tr_bitfield_t * p = tor->uncheckedPieces;
     220        tor->uncheckedPieces = NULL;
     221
     222        tr_inf( "Verifying some pieces of \"%s\"", tor->info.name );
     223
     224        for( i=0; i<tor->info.pieceCount; ++i )
     225        {
     226            if( !tr_bitfieldHas( p, i ) )
     227                continue;
     228
     229            tr_torrentSetHasPiece( tor, i, !checkPiece( tor, i ) );
     230        }
     231
     232        tr_bitfieldFree( p );
     233        tor->fastResumeDirty = TRUE;
     234    }
    254235}
    255236
     
    259240
    260241tr_io_t*
    261 tr_ioInitFast( tr_torrent_t * tor )
     242tr_ioNew ( tr_torrent_t * tor )
    262243{
    263244    tr_io_t * io = tr_calloc( 1, sizeof( tr_io_t ) );
    264245    io->tor = tor;
    265 
    266     if( tr_ioCheckFiles( tor, TR_RECHECK_FAST ) )
    267     {
    268         tr_free( io );
    269         io = NULL;
    270     }
    271 
    272246    return io;
    273247}
     
    284258        for( i=0; i<info->fileCount; ++i )
    285259            tr_fdFileClose( io->tor->destination, info->files[i].name );
    286 
    287         fastResumeSave( io->tor );
    288260    }
    289261}
     
    297269        tr_free( io );
    298270    }
    299 }
    300 
    301 
    302 /* try to load the fast resume file */
    303 int
    304 tr_ioLoadResume( tr_torrent_t * tor )
    305 {
    306     return tr_ioCheckFiles ( tor, TR_RECHECK_FAST );
    307271}
    308272
  • trunk/libtransmission/inout.h

    r2315 r2462  
    2828typedef struct tr_io_s tr_io_t;
    2929
    30 int       tr_ioLoadResume  ( tr_torrent_t * );
     30void tr_ioCheckFiles  ( tr_torrent_t * );
    3131
    32 
    33 enum
    34 {
    35   TR_RECHECK_FAST,  /* only try the fast resume, even if it's incomplete */
    36   TR_RECHECK_FORCE  /* ignore the fast resume data; recheck from disk */
    37 };
    38 int tr_ioCheckFiles  ( tr_torrent_t *, int recheckMode );
    39 
    40 
    41 tr_io_t * tr_ioInitFast        ( tr_torrent_t * );
     32tr_io_t * tr_ioNew ( tr_torrent_t * );
    4233
    4334/***********************************************************************
  • trunk/libtransmission/internal.h

    r2444 r2462  
    9898#include "inout.h"
    9999#include "ratecontrol.h"
     100#include "utils.h"
    100101
    101102#ifndef TRUE
     
    190191
    191192    volatile char     dieFlag;
    192     volatile char     recheckFlag;
     193    tr_bitfield_t   * uncheckedPieces;
    193194    run_status_t      runStatus;
    194195    cp_status_t       cpStatus;
  • trunk/libtransmission/torrent.c

    r2454 r2462  
    181181{
    182182    int i;
     183    uint64_t loaded;
    183184    char name[512];
     185    tr_bitfield_t * uncheckedPieces;
    184186   
    185187    tor->info.flags |= flags;
     
    232234    tor->error   = TR_OK;
    233235    tor->runStatus = flags & TR_FLAG_PAUSED ? TR_RUN_STOPPED : TR_RUN_RUNNING;
    234     tor->recheckFlag = tr_ioCheckFiles( tor, TR_RECHECK_FAST );
     236
     237    uncheckedPieces = tr_bitfieldNew( tor->info.pieceCount );
     238    loaded = tr_fastResumeLoad( tor, uncheckedPieces );
     239    if( tr_bitfieldIsEmpty( uncheckedPieces ) )
     240        tr_bitfieldFree( uncheckedPieces );
     241    else {
     242        tor->uncheckedPieces = uncheckedPieces;
     243        fprintf( stderr, "torrent %s has %d unchecked pieces\n", tor->info.name, (int)tr_bitfieldCountTrueBits(tor->uncheckedPieces) );
     244    }
     245
     246
     247    if( !(loaded & TR_FR_SPEEDLIMIT ) ) {
     248        int limit, enabled;
     249        tr_getGlobalSpeedLimit( tor->handle, TR_UP, &enabled, &limit );
     250        tr_torrentSetSpeedLimit( tor, TR_UP, limit );
     251        tr_getGlobalSpeedLimit( tor->handle, TR_DOWN, &enabled, &limit );
     252        tr_torrentSetSpeedLimit( tor, TR_DOWN, limit );
     253    }
     254
    235255    tor->cpStatus = tr_cpGetStatus( tor->completion );
    236256
     
    445465#endif
    446466
    447 void tr_torrentSetFolder( tr_torrent_t * tor, const char * path )
     467static void
     468fastResumeSave( tr_torrent_t * tor )
     469{
     470    tr_fastResumeSave( tor );
     471    tor->fastResumeDirty = FALSE;
     472}
     473
     474void
     475tr_torrentSetFolder( tr_torrent_t * tor, const char * path )
    448476{
    449477    tr_free( tor->destination );
    450478    tor->destination = tr_strdup( path );
    451 
    452     if( !tor->ioLoaded )
    453          tor->ioLoaded = tr_ioLoadResume( tor ) == TR_OK;
    454 }
    455 
    456 const char* tr_torrentGetFolder( const tr_torrent_t * tor )
     479    fastResumeSave( tor );
     480}
     481
     482const char*
     483tr_torrentGetFolder( const tr_torrent_t * tor )
    457484{
    458485    return tor->destination;
     
    583610
    584611
    585     if( tor->recheckFlag )
     612    if( tor->uncheckedPieces )
    586613        s->status = TR_STATUS_CHECK_WAIT;
    587614    else switch( tor->runStatus ) {
     
    856883void tr_torrentRecheck( tr_torrent_t * tor )
    857884{
    858     tor->recheckFlag = TRUE;
     885    if( !tor->uncheckedPieces )
     886        tor->uncheckedPieces = tr_bitfieldNew( tor->info.pieceCount );
     887    tr_bitfieldAddRange( tor->uncheckedPieces, 0, tor->info.pieceCount );
    859888}
    860889
     
    9981027        }
    9991028        tr_ioSync( tor->io );
     1029        fastResumeSave( tor );
    10001030    }
    10011031    tr_torrentWriterUnlock( tor );
     
    10231053        if( tor->fastResumeDirty )
    10241054        {
    1025             tor->fastResumeDirty = FALSE;
    10261055            fastResumeSave( tor );
    10271056            recheckCpState( tor );
     
    10391068            tr_ioClose( tor->io );
    10401069            tor->io = NULL;
     1070            fastResumeSave( tor );
    10411071
    10421072            /* close the peers */
     
    10791109
    10801110        /* do we need to check files? */
    1081         if( tor->recheckFlag )
     1111        if( tor->uncheckedPieces )
    10821112        {
    10831113            if( !tr_lockTryLock( &checkFilesLock ) )
     
    10871117                tr_torrentWriterLock( tor );
    10881118                realStatus = tor->runStatus;
    1089                 tor->recheckFlag = FALSE;
    10901119                tor->runStatus = TR_RUN_CHECKING;
    10911120                tr_torrentWriterUnlock( tor );
    10921121
    1093                 tr_ioCheckFiles( tor, TR_RECHECK_FORCE );
     1122                tr_ioCheckFiles( tor );
    10941123                setRunState( tor, realStatus );
    10951124
     
    11181147                *tor->errorString = '\0';
    11191148                tr_torrentResetTransferStats( tor );
    1120                 tor->io = tr_ioInitFast( tor );
    1121                 if( tor->io == NULL ) {
    1122                     tor->recheckFlag = TRUE;
    1123                     continue;
    1124                 }
     1149                tor->io = tr_ioNew( tor );
    11251150                tr_peerIdNew ( tor->peer_id, sizeof(tor->peer_id) );
    11261151                tor->tracker = tr_trackerInit( tor );
Note: See TracChangeset for help on using the changeset viewer.