source: trunk/libtransmission/fdlimit.c @ 12541

Last change on this file since 12541 was 12541, checked in by jordan, 10 years ago

(trunk libT) restore setrlimit(), although in an non-configurable mode.

  • Property svn:keywords set to Date Rev Author Id
File size: 18.5 KB
Line 
1/*
2 * This file Copyright (C) Mnemosyne LLC
3 *
4 * This file is licensed by the GPL version 2. Works owned by the
5 * Transmission project are granted a special exemption to clause 2(b)
6 * so that the bulk of its code can remain under the MIT license.
7 * This exemption does not extend to derived works not owned by
8 * the Transmission project.
9 *
10 * $Id: fdlimit.c 12541 2011-07-11 20:48:06Z jordan $
11 */
12
13#ifdef HAVE_POSIX_FADVISE
14 #ifdef _XOPEN_SOURCE
15  #undef _XOPEN_SOURCE
16 #endif
17 #define _XOPEN_SOURCE 600
18#endif
19
20#include <assert.h>
21#include <errno.h>
22#include <inttypes.h>
23#include <string.h>
24#ifdef SYS_DARWIN
25 #include <fcntl.h>
26#endif
27
28#ifdef HAVE_FALLOCATE64
29  /* FIXME can't find the right #include voodoo to pick up the declaration.. */
30  extern int fallocate64( int fd, int mode, uint64_t offset, uint64_t len );
31#endif
32
33#ifdef HAVE_XFS_XFS_H
34 #include <xfs/xfs.h>
35#endif
36
37#include <sys/types.h>
38#include <sys/stat.h>
39#include <sys/time.h> /* getrlimit */
40#include <sys/resource.h> /* getrlimit */
41#include <fcntl.h> /* O_LARGEFILE posix_fadvise */
42#include <unistd.h> /* lseek(), write(), ftruncate(), pread(), pwrite(), etc */
43
44#include "transmission.h"
45#include "fdlimit.h"
46#include "net.h"
47#include "session.h"
48#include "torrent.h" /* tr_isTorrent() */
49
50#define dbgmsg( ... ) \
51    do { \
52        if( tr_deepLoggingIsActive( ) ) \
53            tr_deepLog( __FILE__, __LINE__, NULL, __VA_ARGS__ ); \
54    } while( 0 )
55
56/***
57****
58****  Local Files
59****
60***/
61
62#ifndef O_LARGEFILE
63 #define O_LARGEFILE 0
64#endif
65
66#ifndef O_BINARY
67 #define O_BINARY 0
68#endif
69
70#ifndef O_SEQUENTIAL
71 #define O_SEQUENTIAL 0
72#endif
73
74
75static bool
76preallocate_file_sparse( int fd, uint64_t length )
77{
78    const char zero = '\0';
79    bool success = 0;
80
81    if( !length )
82        success = true;
83
84#ifdef HAVE_FALLOCATE64
85    if( !success ) /* fallocate64 is always preferred, so try it first */
86        success = !fallocate64( fd, 0, 0, length );
87#endif
88
89    if( !success ) /* fallback: the old-style seek-and-write */
90        success = ( lseek( fd, length-1, SEEK_SET ) != -1 )
91               && ( write( fd, &zero, 1 ) != -1 )
92               && ( ftruncate( fd, length ) != -1 );
93
94    return success;
95}
96
97static bool
98preallocate_file_full( const char * filename, uint64_t length )
99{
100    bool success = 0;
101
102#ifdef WIN32
103
104    HANDLE hFile = CreateFile( filename, GENERIC_WRITE, 0, 0, CREATE_NEW, FILE_FLAG_RANDOM_ACCESS, 0 );
105    if( hFile != INVALID_HANDLE_VALUE )
106    {
107        LARGE_INTEGER li;
108        li.QuadPart = length;
109        success = SetFilePointerEx( hFile, li, NULL, FILE_BEGIN ) && SetEndOfFile( hFile );
110        CloseHandle( hFile );
111    }
112
113#else
114
115    int flags = O_RDWR | O_CREAT | O_LARGEFILE;
116    int fd = open( filename, flags, 0666 );
117    if( fd >= 0 )
118    {
119# ifdef HAVE_FALLOCATE64
120       if( !success )
121       {
122           success = !fallocate64( fd, 0, 0, length );
123       }
124# endif
125# ifdef HAVE_XFS_XFS_H
126        if( !success && platform_test_xfs_fd( fd ) )
127        {
128            xfs_flock64_t fl;
129            fl.l_whence = 0;
130            fl.l_start = 0;
131            fl.l_len = length;
132            success = !xfsctl( NULL, fd, XFS_IOC_RESVSP64, &fl );
133        }
134# endif
135# ifdef SYS_DARWIN
136        if( !success )
137        {
138            fstore_t fst;
139            fst.fst_flags = F_ALLOCATECONTIG;
140            fst.fst_posmode = F_PEOFPOSMODE;
141            fst.fst_offset = 0;
142            fst.fst_length = length;
143            fst.fst_bytesalloc = 0;
144            success = !fcntl( fd, F_PREALLOCATE, &fst );
145        }
146# endif
147# ifdef HAVE_POSIX_FALLOCATE
148        if( !success )
149        {
150            success = !posix_fallocate( fd, 0, length );
151        }
152# endif
153
154        if( !success ) /* if nothing else works, do it the old-fashioned way */
155        {
156            uint8_t buf[ 4096 ];
157            memset( buf, 0, sizeof( buf ) );
158            success = true;
159            while ( success && ( length > 0 ) )
160            {
161                const int thisPass = MIN( length, sizeof( buf ) );
162                success = write( fd, buf, thisPass ) == thisPass;
163                length -= thisPass;
164            }
165        }
166
167        close( fd );
168    }
169
170#endif
171
172    return success;
173}
174
175
176/* portability wrapper for fsync(). */
177int
178tr_fsync( int fd )
179{
180#ifdef WIN32
181    return _commit( fd );
182#else
183    return fsync( fd );
184#endif
185}
186
187
188/* Like pread and pwrite, except that the position is undefined afterwards.
189   And of course they are not thread-safe. */
190
191/* don't use pread/pwrite on old versions of uClibc because they're buggy.
192 * https://trac.transmissionbt.com/ticket/3826 */
193#ifdef __UCLIBC__
194#define TR_UCLIBC_CHECK_VERSION(major,minor,micro) \
195    (__UCLIBC_MAJOR__ > (major) || \
196     (__UCLIBC_MAJOR__ == (major) && __UCLIBC_MINOR__ > (minor)) || \
197     (__UCLIBC_MAJOR__ == (major) && __UCLIBC_MINOR__ == (minor) && \
198      __UCLIBC_SUBLEVEL__ >= (micro)))
199#if !TR_UCLIBC_CHECK_VERSION(0,9,28)
200 #undef HAVE_PREAD
201 #undef HAVE_PWRITE
202#endif
203#endif
204
205#ifdef SYS_DARWIN
206 #define HAVE_PREAD
207 #define HAVE_PWRITE
208#endif
209
210ssize_t
211tr_pread( int fd, void *buf, size_t count, off_t offset )
212{
213#ifdef HAVE_PREAD
214    return pread( fd, buf, count, offset );
215#else
216    const off_t lrc = lseek( fd, offset, SEEK_SET );
217    if( lrc < 0 )
218        return -1;
219    return read( fd, buf, count );
220#endif
221}
222
223ssize_t
224tr_pwrite( int fd, const void *buf, size_t count, off_t offset )
225{
226#ifdef HAVE_PWRITE
227    return pwrite( fd, buf, count, offset );
228#else
229    const off_t lrc = lseek( fd, offset, SEEK_SET );
230    if( lrc < 0 )
231        return -1;
232    return write( fd, buf, count );
233#endif
234}
235
236int
237tr_prefetch( int fd UNUSED, off_t offset UNUSED, size_t count UNUSED )
238{
239#ifdef HAVE_POSIX_FADVISE
240    return posix_fadvise( fd, offset, count, POSIX_FADV_WILLNEED );
241#elif defined(SYS_DARWIN)
242    struct radvisory radv;
243    radv.ra_offset = offset;
244    radv.ra_count = count;
245    return fcntl( fd, F_RDADVISE, &radv );
246#else
247    return 0;
248#endif
249}
250
251void
252tr_set_file_for_single_pass( int fd )
253{
254    if( fd >= 0 )
255    {
256        /* Set hints about the lookahead buffer and caching. It's okay
257           for these to fail silently, so don't let them affect errno */
258        const int err = errno;
259#ifdef HAVE_POSIX_FADVISE
260        posix_fadvise( fd, 0, 0, POSIX_FADV_SEQUENTIAL );
261#endif
262#ifdef SYS_DARWIN
263        fcntl( fd, F_RDAHEAD, 1 );
264        fcntl( fd, F_NOCACHE, 1 );
265#endif
266        errno = err;
267    }
268}
269
270static int
271open_local_file( const char * filename, int flags )
272{
273    const int fd = open( filename, flags, 0666 );
274    tr_set_file_for_single_pass( fd );
275    return fd;
276}
277int
278tr_open_file_for_writing( const char * filename )
279{
280    return open_local_file( filename, O_LARGEFILE|O_BINARY|O_CREAT|O_WRONLY );
281}
282int
283tr_open_file_for_scanning( const char * filename )
284{
285    return open_local_file( filename, O_LARGEFILE|O_BINARY|O_SEQUENTIAL|O_RDONLY );
286}
287
288void
289tr_close_file( int fd )
290{
291#if defined(HAVE_POSIX_FADVISE)
292    /* Set hint about not caching this file.
293       It's okay for this to fail silently, so don't let it affect errno */
294    const int err = errno;
295    posix_fadvise( fd, 0, 0, POSIX_FADV_DONTNEED );
296    errno = err;
297#endif
298#ifdef SYS_DARWIN
299    /* it's unclear to me from the man pages if this actually flushes out the cache,
300     * but it couldn't hurt... */
301    fcntl( fd, F_NOCACHE, 1 );
302#endif
303    close( fd );
304}
305
306/*****
307******
308******
309******
310*****/
311
312struct tr_cached_file
313{
314    bool             is_writable;
315    int              fd;
316    int              torrent_id;
317    tr_file_index_t  file_index;
318    time_t           used_at;
319};
320
321static inline bool
322cached_file_is_open( const struct tr_cached_file * o )
323{
324    assert( o != NULL );
325
326    return o->fd >= 0;
327}
328
329static void
330cached_file_close( struct tr_cached_file * o )
331{
332    assert( cached_file_is_open( o ) );
333
334    tr_close_file( o->fd );
335    o->fd = -1;
336}
337
338/**
339 * returns 0 on success, or an errno value on failure.
340 * errno values include ENOENT if the parent folder doesn't exist,
341 * plus the errno values set by tr_mkdirp() and open().
342 */
343static int
344cached_file_open( struct tr_cached_file  * o,
345                  const char             * existing_dir,
346                  const char             * filename,
347                  bool                     writable,
348                  tr_preallocation_mode    allocation,
349                  uint64_t                 file_size )
350{
351    int flags;
352    struct stat sb;
353    bool alreadyExisted;
354
355    /* confirm that existing_dir, if specified, exists on the disk */
356    if( existing_dir && *existing_dir && stat( existing_dir, &sb ) )
357    {
358        const int err = errno;
359        tr_err( _( "Couldn't open \"%1$s\": %2$s" ), existing_dir, tr_strerror( err ) );
360        return err;
361    }
362
363    /* create subfolders, if any */
364    if( writable )
365    {
366        char * dir = tr_dirname( filename );
367        const int err = tr_mkdirp( dir, 0777 ) ? errno : 0;
368        if( err ) {
369            tr_err( _( "Couldn't create \"%1$s\": %2$s" ), dir, tr_strerror( err ) );
370            tr_free( dir );
371            return err;
372        }
373        tr_free( dir );
374    }
375
376    alreadyExisted = !stat( filename, &sb ) && S_ISREG( sb.st_mode );
377
378    if( writable && !alreadyExisted && ( allocation == TR_PREALLOCATE_FULL ) )
379        if( preallocate_file_full( filename, file_size ) )
380            tr_dbg( "Preallocated file \"%s\"", filename );
381
382    /* open the file */
383    flags = writable ? ( O_RDWR | O_CREAT ) : O_RDONLY;
384    flags |= O_LARGEFILE | O_BINARY | O_SEQUENTIAL;
385    o->fd = open( filename, flags, 0666 );
386
387    if( o->fd == -1 )
388    {
389        const int err = errno;
390        tr_err( _( "Couldn't open \"%1$s\": %2$s" ), filename, tr_strerror( err ) );
391        return err;
392    }
393
394    /* If the file already exists and it's too large, truncate it.
395     * This is a fringe case that happens if a torrent's been updated
396     * and one of the updated torrent's files is smaller.
397     * http://trac.transmissionbt.com/ticket/2228
398     * https://bugs.launchpad.net/ubuntu/+source/transmission/+bug/318249
399     */
400    if( alreadyExisted && ( file_size < (uint64_t)sb.st_size ) )
401    {
402        if( ftruncate( o->fd, file_size ) == -1 )
403        {
404            const int err = errno;
405            tr_err( _( "Couldn't truncate \"%1$s\": %2$s" ), filename, tr_strerror( err ) );
406            return err;
407        }
408    }
409
410    if( writable && !alreadyExisted && ( allocation == TR_PREALLOCATE_SPARSE ) )
411        preallocate_file_sparse( o->fd, file_size );
412
413    /* Many (most?) clients request blocks in ascending order,
414     * so increase the readahead buffer.
415     * Also, disable OS-level caching because "inactive memory" angers users. */
416    tr_set_file_for_single_pass( o->fd );
417
418    return 0;
419}
420
421/***
422****
423***/
424
425struct tr_fileset
426{
427    struct tr_cached_file * begin;
428    const struct tr_cached_file * end;
429};
430
431static void
432fileset_construct( struct tr_fileset * set, int n )
433{
434    struct tr_cached_file * o;
435    const struct tr_cached_file TR_CACHED_FILE_INIT = { 0, -1, 0, 0, 0 };
436
437    set->begin = tr_new( struct tr_cached_file, n );
438    set->end = set->begin + n;
439
440    for( o=set->begin; o!=set->end; ++o )
441        *o = TR_CACHED_FILE_INIT;
442}
443
444static void
445fileset_close_all( struct tr_fileset * set )
446{
447    struct tr_cached_file * o;
448
449    if( set != NULL )
450        for( o=set->begin; o!=set->end; ++o )
451            if( cached_file_is_open( o ) )
452                cached_file_close( o );
453}
454
455static void
456fileset_destruct( struct tr_fileset * set )
457{
458    fileset_close_all( set );
459    tr_free( set->begin );
460    set->end = set->begin = NULL;
461}
462
463static void
464fileset_close_torrent( struct tr_fileset * set, int torrent_id )
465{
466    struct tr_cached_file * o;
467
468    if( set != NULL )
469        for( o=set->begin; o!=set->end; ++o )
470            if( ( o->torrent_id == torrent_id ) && cached_file_is_open( o ) )
471                cached_file_close( o );
472}
473
474static struct tr_cached_file *
475fileset_lookup( struct tr_fileset * set, int torrent_id, tr_file_index_t i )
476{
477    struct tr_cached_file * o;
478
479    if( set != NULL )
480        for( o=set->begin; o!=set->end; ++o )
481            if( ( torrent_id == o->torrent_id ) && ( i == o->file_index ) && cached_file_is_open( o ) )
482                return o;
483
484    return NULL;
485}
486
487static struct tr_cached_file *
488fileset_get_empty_slot( struct tr_fileset * set )
489{
490    struct tr_cached_file * o;
491    struct tr_cached_file * cull;
492
493    /* try to find an unused slot */
494    for( o=set->begin; o!=set->end; ++o )
495        if( !cached_file_is_open( o ) )
496            return o;
497
498    /* all slots are full... recycle the least recently used */
499    for( cull=NULL, o=set->begin; o!=set->end; ++o )
500        if( !cull || o->used_at < cull->used_at )
501            cull = o;
502    cached_file_close( cull );
503    return cull;
504}
505
506/***
507****
508****  Startup / Shutdown
509****
510***/
511
512struct tr_fdInfo
513{
514    int peerCount;
515    struct tr_fileset fileset;
516};
517
518static void
519ensureSessionFdInfoExists( tr_session * session )
520{
521    assert( tr_isSession( session ) );
522
523    if( session->fdInfo == NULL )
524    {
525        struct rlimit limit;
526        struct tr_fdInfo * i;
527        const int FILE_CACHE_SIZE = 32;
528
529        /* Create the local file cache */
530        i = tr_new0( struct tr_fdInfo, 1 );
531        fileset_construct( &i->fileset, FILE_CACHE_SIZE );
532        session->fdInfo = i;
533
534        /* set the open-file limit to the largest safe size wrt FD_SETSIZE */
535        if( !getrlimit( RLIMIT_NOFILE, &limit ) )
536        {
537            const int old_limit = (int) limit.rlim_cur;
538            const int new_limit = MIN( limit.rlim_max, FD_SETSIZE );
539            if( new_limit != old_limit )
540            {
541                limit.rlim_cur = new_limit;
542                setrlimit( RLIMIT_NOFILE, &limit );
543                getrlimit( RLIMIT_NOFILE, &limit );
544                tr_inf( "Changed open file limit from %d to %d", old_limit, (int)limit.rlim_cur );
545            }
546        }
547    }
548}
549
550void
551tr_fdClose( tr_session * session )
552{
553    if( session && session->fdInfo )
554    {
555        struct tr_fdInfo * i = session->fdInfo;
556        fileset_destruct( &i->fileset );
557        tr_free( i );
558        session->fdInfo = NULL;
559    }
560}
561
562/***
563****
564***/
565
566static struct tr_fileset*
567get_fileset( tr_session * session )
568{
569    if( !session )
570        return NULL;
571
572    ensureSessionFdInfoExists( session );
573    return &session->fdInfo->fileset;
574}
575
576void
577tr_fdFileClose( tr_session * s, const tr_torrent * tor, tr_file_index_t i )
578{
579    struct tr_cached_file * o;
580
581    if(( o = fileset_lookup( get_fileset( s ), tr_torrentId( tor ), i )))
582    {
583        /* flush writable files so that their mtimes will be
584         * up-to-date when this function returns to the caller... */
585        if( o->is_writable )
586            tr_fsync( o->fd );
587
588        cached_file_close( o );
589    }
590}
591
592int
593tr_fdFileGetCached( tr_session * s, int torrent_id, tr_file_index_t i, bool writable )
594{
595    struct tr_cached_file * o = fileset_lookup( get_fileset( s ), torrent_id, i );
596
597    if( !o || ( writable && !o->is_writable ) )
598        return -1;
599
600    o->used_at = tr_time( );
601    return o->fd;
602}
603
604#ifdef SYS_DARWIN
605 #define TR_STAT_MTIME(sb) ((sb).st_mtimespec.tv_sec)
606#else
607 #define TR_STAT_MTIME(sb) ((sb).st_mtime)
608#endif
609
610bool
611tr_fdFileGetCachedMTime( tr_session * s, int torrent_id, tr_file_index_t i, time_t * mtime )
612{
613    bool success;
614    struct stat sb;
615    struct tr_cached_file * o = fileset_lookup( get_fileset( s ), torrent_id, i );
616
617    if(( success = ( o != NULL ) && !fstat( o->fd, &sb )))
618        *mtime = TR_STAT_MTIME( sb );
619
620    return success;
621}
622
623void
624tr_fdTorrentClose( tr_session * session, int torrent_id )
625{
626    fileset_close_torrent( get_fileset( session ), torrent_id );
627}
628
629/* returns an fd on success, or a -1 on failure and sets errno */
630int
631tr_fdFileCheckout( tr_session             * session,
632                   int                      torrent_id,
633                   tr_file_index_t          i,
634                   const char             * existing_dir,
635                   const char             * filename,
636                   bool                     writable,
637                   tr_preallocation_mode    allocation,
638                   uint64_t                 file_size )
639{
640    struct tr_fileset * set = get_fileset( session );
641    struct tr_cached_file * o = fileset_lookup( set, torrent_id, i );
642
643    if( o && writable && !o->is_writable )
644        cached_file_close( o ); /* close it so we can reopen in rw mode */
645    else if( !o )
646        o = fileset_get_empty_slot( set );
647
648    if( !cached_file_is_open( o ) )
649    {
650        const int err = cached_file_open( o, existing_dir, filename, writable, allocation, file_size );
651        if( err ) {
652            errno = err;
653            return -1;
654        }
655
656        dbgmsg( "opened '%s' writable %c", filename, writable?'y':'n' );
657        o->is_writable = writable;
658    }
659
660    dbgmsg( "checking out '%s'", filename );
661    o->torrent_id = torrent_id;
662    o->file_index = i;
663    o->used_at = tr_time( );
664    return o->fd;
665}
666
667/***
668****
669****  Sockets
670****
671***/
672
673int
674tr_fdSocketCreate( tr_session * session, int domain, int type )
675{
676    int s = -1;
677    struct tr_fdInfo * gFd;
678    assert( tr_isSession( session ) );
679
680    ensureSessionFdInfoExists( session );
681    gFd = session->fdInfo;
682
683    if( gFd->peerCount < session->peerLimit )
684        if(( s = socket( domain, type, 0 )) < 0 )
685            if( sockerrno != EAFNOSUPPORT )
686                tr_err( _( "Couldn't create socket: %s" ), tr_strerror( sockerrno ) );
687
688    if( s > -1 )
689        ++gFd->peerCount;
690
691    assert( gFd->peerCount >= 0 );
692
693    if( s >= 0 )
694    {
695        static bool buf_logged = false;
696        if( !buf_logged )
697        {
698            int i;
699            socklen_t size = sizeof( int );
700            buf_logged = true;
701            getsockopt( s, SOL_SOCKET, SO_SNDBUF, &i, &size );
702            tr_dbg( "SO_SNDBUF size is %d", i );
703            getsockopt( s, SOL_SOCKET, SO_RCVBUF, &i, &size );
704            tr_dbg( "SO_RCVBUF size is %d", i );
705        }
706    }
707
708    return s;
709}
710
711int
712tr_fdSocketAccept( tr_session * s, int sockfd, tr_address * addr, tr_port * port )
713{
714    int fd;
715    unsigned int len;
716    struct tr_fdInfo * gFd;
717    struct sockaddr_storage sock;
718
719    assert( tr_isSession( s ) );
720    assert( addr );
721    assert( port );
722
723    ensureSessionFdInfoExists( s );
724    gFd = s->fdInfo;
725
726    len = sizeof( struct sockaddr_storage );
727    fd = accept( sockfd, (struct sockaddr *) &sock, &len );
728
729    if( fd >= 0 )
730    {
731        if( ( gFd->peerCount < s->peerLimit )
732            && tr_address_from_sockaddr_storage( addr, port, &sock ) )
733        {
734            ++gFd->peerCount;
735        }
736        else
737        {
738            tr_netCloseSocket( fd );
739            fd = -1;
740        }
741    }
742
743    return fd;
744}
745
746void
747tr_fdSocketClose( tr_session * session, int fd )
748{
749    assert( tr_isSession( session ) );
750
751    if( session->fdInfo != NULL )
752    {
753        struct tr_fdInfo * gFd = session->fdInfo;
754
755        if( fd >= 0 )
756        {
757            tr_netCloseSocket( fd );
758            --gFd->peerCount;
759        }
760
761        assert( gFd->peerCount >= 0 );
762    }
763}
Note: See TracBrowser for help on using the repository browser.