premiere
/
premiere-libtorrent
2
2
Fork 1
Code Issues Pull Requests Releases Wiki Activity

use unsigned type for file flags. make file_pool private to disk_io_thread (#1894) 

use unsigned type for file flags. make file_pool private to disk_io_thread. move close_file_interval logic to the disk thread. don't expose file in public interface, and make pool_file_status properly public (not part of file_pool and renamed to open_file_status), this is exposed in public interface via torrent_handle::file_status()
This commit is contained in:
Arvid Norberg 2017-04-08 18:24:50 -04:00 committed by GitHub
parent 86f67bd9d9
commit 13b16a63a3
21 changed files with 205 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
ChangeLog
View File

@ -1,3 +1,4 @@
* make the file_status interface explicitly public types
* added resolver_cache_timeout setting for internal host name resolver
* make parse_magnet_uri take a string_view instead of std::string
* deprecate add_torrent_params::url field. use parse_magnet_uri instead

4
bindings/python/src/converters.cpp
View File

@ -7,10 +7,10 @@
#include "libtorrent/address.hpp"
#include "libtorrent/error_code.hpp"
#include "libtorrent/session_stats.hpp" // for stats_metric
#include "libtorrent/file_pool.hpp" // for pool_file_status
#include "libtorrent/time.hpp"
#include "libtorrent/units.hpp"
#include "libtorrent/sha1_hash.hpp"
#include "libtorrent/disk_interface.hpp" // for open_file_state
#include <vector>
using namespace boost::python;
@ -240,7 +240,7 @@ void bind_converters()
to_python_converter<std::pair<std::string, int>, pair_to_tuple<std::string, int>>();
to_python_converter<std::vector<lt::stats_metric>, vector_to_list<lt::stats_metric>>();
to_python_converter<std::vector<lt::pool_file_status>, vector_to_list<lt::pool_file_status>>();
to_python_converter<std::vector<lt::open_file_state>, vector_to_list<lt::open_file_state>>();
to_python_converter<std::vector<lt::sha1_hash>, vector_to_list<lt::sha1_hash>>();
to_python_converter<std::vector<std::string>, vector_to_list<std::string>>();
to_python_converter<std::vector<int>, vector_to_list<int>>();

31
bindings/python/src/torrent_handle.cpp
View File

@ -12,7 +12,7 @@
#include <libtorrent/peer_info.hpp>
#include "libtorrent/announce_entry.hpp"
#include <libtorrent/storage.hpp>
#include <libtorrent/file_pool.hpp>
#include <libtorrent/disk_interface.hpp>
#include <boost/lexical_cast.hpp>
#include "gil.hpp"
@ -391,7 +391,7 @@ void bind_torrent_handle()
void (torrent_handle::*rename_file1)(file_index_t, std::wstring const&) const = &torrent_handle::rename_file;
#endif
std::vector<pool_file_status> (torrent_handle::*file_status0)() const = &torrent_handle::file_status;
std::vector<open_file_state> (torrent_handle::*file_status0)() const = &torrent_handle::file_status;
#define _ allow_threads
@ -501,12 +501,31 @@ void bind_torrent_handle()
#endif
;
class_<pool_file_status>("pool_file_status")
.add_property("file_index", make_getter((&pool_file_status::file_index), by_value()))
.def_readonly("last_use", &pool_file_status::last_use)
.def_readonly("open_mode", &pool_file_status::open_mode)
class_<open_file_state>("open_file_state")
.add_property("file_index", make_getter((&open_file_state::file_index), by_value()))
.def_readonly("last_use", &open_file_state::last_use)
.def_readonly("open_mode", &open_file_state::open_mode)
;
enum_<file_open_mode>("file_open_mode")
.value("read_only", file_open_mode::read_only)
.value("write_only", file_open_mode::write_only)
.value("read_write", file_open_mode::read_write)
.value("rw_mask", file_open_mode::rw_mask)
.value("sparse", file_open_mode::sparse)
.value("no_atime", file_open_mode::no_atime)
.value("random_access", file_open_mode::random_access)
.value("locked", file_open_mode::locked)
;
#ifndef TORRENT_NO_DEPRECATE
class_<open_file_state>("pool_file_status")
.add_property("file_index", make_getter((&open_file_state::file_index), by_value()))
.def_readonly("last_use", &open_file_state::last_use)
.def_readonly("open_mode", &open_file_state::open_mode)
;
#endif
enum_<torrent_handle::file_progress_flags_t>("file_progress_flags")
.value("piece_granularity", torrent_handle::piece_granularity)
;

16
examples/client_test.cpp
View File

@ -1835,9 +1835,9 @@ MAGNETURL is a magnet link
{
std::vector<std::int64_t> file_progress;
h.file_progress(file_progress);
std::vector<pool_file_status> file_status = h.file_status();
std::vector<open_file_state> file_status = h.file_status();
std::vector<int> file_prio = h.file_priorities();
std::vector<pool_file_status>::iterator f = file_status.begin();
auto f = file_status.begin();
std::shared_ptr<const torrent_info> ti = h.torrent_file();
int p = 0; // this is horizontal position
@ -1875,12 +1875,12 @@ MAGNETURL is a magnet link
if (f != file_status.end() && f->file_index == i)
{
title += " [ ";
if ((f->open_mode & file::rw_mask) == file::read_write) title += "read/write ";
else if ((f->open_mode & file::rw_mask) == file::read_only) title += "read ";
else if ((f->open_mode & file::rw_mask) == file::write_only) title += "write ";
if (f->open_mode & file::random_access) title += "random_access ";
if (f->open_mode & file::lock_file) title += "locked ";
if (f->open_mode & file::sparse) title += "sparse ";
if ((f->open_mode & file_open_mode::rw_mask) == file::read_write) title += "read/write ";
else if ((f->open_mode & file_open_mode::rw_mask) == file::read_only) title += "read ";
else if ((f->open_mode & file_open_mode::rw_mask) == file::write_only) title += "write ";
if (f->open_mode & file_open_mode::random_access) title += "random_access ";
if (f->open_mode & file_open_mode::locked) title += "locked ";
if (f->open_mode & file_open_mode::sparse) title += "sparse ";
title += "]";
++f;
}

2
include/libtorrent/aux_/session_impl.hpp
View File

@ -703,7 +703,6 @@ namespace libtorrent
void update_privileged_ports();
void update_auto_sequential();
void update_max_failcount();
void update_close_file_interval();
void update_resolver_cache_timeout();
void update_upnp();
@ -975,7 +974,6 @@ namespace libtorrent
int m_peak_down_rate = 0;
void on_tick(error_code const& e);
void on_close_file(error_code const& e);
void try_connect_more_peers();
void auto_manage_checking_torrents(std::vector<torrent*>& list

61
include/libtorrent/disk_interface.hpp
View File

@ -43,13 +43,14 @@ POSSIBILITY OF SUCH DAMAGE.
#include "libtorrent/aux_/vector.hpp"
#include "libtorrent/export.hpp"
#include "libtorrent/storage_defs.hpp"
#include "libtorrent/time.hpp"
#include "libtorrent/sha1_hash.hpp"
namespace libtorrent
{
struct storage_interface;
struct peer_request;
struct disk_observer;
struct file_pool;
struct add_torrent_params;
struct cache_status;
struct disk_buffer_holder;
@ -60,6 +61,62 @@ namespace libtorrent
struct storage_holder;
enum file_open_mode
{
// open the file for reading only
read_only = 0,
// open the file for writing only
write_only = 1,
// open the file for reading and writing
read_write = 2,
// the mask for the bits determining read or write mode
rw_mask = read_only | write_only | read_write,
// open the file in sparse mode (if supported by the
// filesystem).
sparse = 0x4,
// don't update the access timestamps on the file (if
// supported by the operating system and filesystem).
// this generally improves disk performance.
no_atime = 0x8,
// open the file for random access. This disables read-ahead
// logic
random_access = 0x10,
// prevent the file from being opened by another process
// while it's still being held open by this handle
locked = 0x20,
};
// this contains information about a file that's currently open by the
// libtorrent disk I/O subsystem. It's associated with a single torent.
struct TORRENT_EXPORT open_file_state
{
// the index of the file this entry refers to into the ``file_storage``
// file list of this torrent. This starts indexing at 0.
file_index_t file_index;
// ``open_mode`` is a bitmask of the file flags this file is currently
// opened with. These are the flags used in the ``file::open()`` function.
// The flags used in this bitfield are defined by the file_open_mode enum.
//
// Note that the read/write mode is not a bitmask. The two least significant bits are used
// to represent the read/write mode. Those bits can be masked out using the ``rw_mask`` constant.
std::uint32_t open_mode;
// a (high precision) timestamp of when the file was last used.
time_point last_use;
};
#ifndef TORRENT_NO_DEPRECATE
using pool_file_status = open_file_state;
#endif
struct TORRENT_EXTRA_EXPORT disk_interface
{
enum flags_t
@ -117,7 +174,7 @@ namespace libtorrent
virtual void get_cache_info(cache_status* ret, storage_index_t storage
, bool no_pieces = true, bool session = true) const = 0;
virtual file_pool& files() = 0;
virtual std::vector<open_file_state> get_status(storage_index_t) const = 0;
#if TORRENT_USE_ASSERTS
virtual bool is_disk_buffer(char* buffer) const = 0;

8
include/libtorrent/disk_io_thread.hpp
View File

@ -344,6 +344,8 @@ namespace libtorrent
, bool no_pieces, bool session) const override;
storage_interface* get_torrent(storage_index_t) override;
std::vector<open_file_state> get_status(storage_index_t) const override;
// this submits all queued up jobs to the thread
void submit_jobs();
@ -354,8 +356,6 @@ namespace libtorrent
{ return m_disk_cache.is_disk_buffer(buffer); }
#endif
virtual file_pool& files() override { return m_file_pool; }
int prep_read_job_impl(disk_io_job* j, bool check_fence = true);
void maybe_issue_queued_read_jobs(cached_piece_entry* pe,
@ -523,6 +523,10 @@ namespace libtorrent
// the last time we expired write blocks from the cache
time_point m_last_cache_expiry = min_time();
// we call close_oldest_file on the file_pool regularly. This is the next
// time we should call it
time_point m_next_close_oldest_file = min_time();
// LRU cache of open files
file_pool m_file_pool{40};

16
include/libtorrent/file.hpp
View File

@ -229,11 +229,11 @@ namespace libtorrent
using file_handle = std::shared_ptr<file>;
struct TORRENT_EXTRA_EXPORT file: boost::noncopyable
struct TORRENT_EXTRA_EXPORT file : boost::noncopyable
{
// the open mode for files. Used for the file constructor or
// file::open().
enum open_mode_t
enum open_mode_t : std::uint32_t
{
// open the file for reading only
read_only = 0,
@ -286,20 +286,20 @@ namespace libtorrent
};
file();
file(std::string const& p, int m, error_code& ec);
file(std::string const& p, std::uint32_t m, error_code& ec);
~file();
bool open(std::string const& p, int m, error_code& ec);
bool open(std::string const& p, std::uint32_t m, error_code& ec);
bool is_open() const;
void close();
bool set_size(std::int64_t size, error_code& ec);
int open_mode() const { return m_open_mode; }
std::uint32_t open_mode() const { return m_open_mode; }
std::int64_t writev(std::int64_t file_offset, span<iovec_t const> bufs
, error_code& ec, int flags = 0);
, error_code& ec, std::uint32_t flags = 0);
std::int64_t readv(std::int64_t file_offset, span<iovec_t const> bufs
, error_code& ec, int flags = 0);
, error_code& ec, std::uint32_t flags = 0);
std::int64_t get_size(error_code& ec) const;
@ -313,7 +313,7 @@ namespace libtorrent
handle_type m_file_handle;
int m_open_mode;
std::uint32_t m_open_mode;
#if defined TORRENT_WINDOWS
static bool has_manage_volume_privs;
#endif

42
include/libtorrent/file_pool.hpp
View File

@ -41,43 +41,12 @@ POSSIBILITY OF SUCH DAMAGE.
#include "libtorrent/aux_/time.hpp"
#include "libtorrent/units.hpp"
#include "libtorrent/storage_defs.hpp"
#include "libtorrent/disk_interface.hpp" // for open_file_state
namespace libtorrent
{
class file_storage;
struct pool_file_status
{
// the index of the file this entry refers to into the ``file_storage``
// file list of this torrent. This starts indexing at 0.
file_index_t file_index;
// ``open_mode`` is a bitmask of the file flags this file is currently opened with. These
// are the flags used in the ``file::open()`` function. This enum is defined as a member
// of the ``file`` class.
//
// ::
//
// enum
// {
// read_only = 0,
// write_only = 1,
// read_write = 2,
// rw_mask = 3,
// no_buffer = 4,
// sparse = 8,
// no_atime = 16,
// random_access = 32,
// lock_file = 64,
// };
//
// Note that the read/write mode is not a bitmask. The two least significant bits are used
// to represent the read/write mode. Those bits can be masked out using the ``rw_mask`` constant.
int open_mode;
// a (high precision) timestamp of when the file was last used.
time_point last_use;
};
struct open_file_state;
// this is an internal cache of open file handles. It's primarily used by
// storage_interface implementations. It provides semi weak guarantees of
@ -95,7 +64,8 @@ namespace libtorrent
// file_storage ``fs`` opened at save path ``p``. ``m`` is the
// file open mode (see file::open_mode_t).
file_handle open_file(storage_index_t st, std::string const& p
, file_index_t file_index, file_storage const& fs, int m, error_code& ec);
, file_index_t file_index, file_storage const& fs, std::uint32_t m
, error_code& ec);
// release all files belonging to the specified storage_interface (``st``)
// the overload that takes ``file_index`` releases only the file with
// that index in storage ``st``.
@ -112,7 +82,7 @@ namespace libtorrent
// internal
void set_low_prio_io(bool b) { m_low_prio_io = b; }
std::vector<pool_file_status> get_status(storage_index_t st) const;
std::vector<open_file_state> get_status(storage_index_t st) const;
// close the file that was opened least recently (i.e. not *accessed*
// least recently). The purpose is to make the OS (really just windows)
@ -141,7 +111,7 @@ namespace libtorrent
file_handle file_ptr;
time_point const opened{aux::time_now()};
time_point last_use{opened};
int mode = 0;
std::uint32_t mode = 0;
};
// maps storage pointer, file index pairs to the

2
include/libtorrent/part_file.hpp
View File

@ -73,7 +73,7 @@ namespace libtorrent
private:
void open_file(int mode, error_code& ec);
void open_file(std::uint32_t mode, error_code& ec);
void flush_metadata_impl(error_code& ec);
std::string m_path;

4
include/libtorrent/storage.hpp
View File

@ -424,8 +424,8 @@ namespace libtorrent
mutable stat_cache m_stat_cache;
// helper function to open a file in the file pool with the right mode
file_handle open_file(file_index_t file, int mode, storage_error& ec) const;
file_handle open_file_impl(file_index_t file, int mode, error_code& ec) const;
file_handle open_file(file_index_t file, std::uint32_t mode, storage_error& ec) const;
file_handle open_file_impl(file_index_t file, std::uint32_t mode, error_code& ec) const;
aux::vector<std::uint8_t, file_index_t> m_file_priority;
std::string m_save_path;

8
include/libtorrent/torrent_handle.hpp
View File

@ -62,7 +62,7 @@ namespace libtorrent
}
class entry;
struct pool_file_status;
struct open_file_state;
struct announce_entry;
class torrent_info;
struct torrent_plugin;
@ -415,7 +415,7 @@ namespace libtorrent
#endif
TORRENT_DEPRECATED
void file_status(std::vector<pool_file_status>& status) const;
void file_status(std::vector<open_file_state>& status) const;
#endif
// flags to be passed in file_progress().
@ -451,8 +451,8 @@ namespace libtorrent
// the vector is empty when returning, if none of the files in the
// torrent are currently open.
//
// see pool_file_status.
std::vector<pool_file_status> file_status() const;
// see open_file_state
std::vector<open_file_state> file_status() const;
// If the torrent is in an error state (i.e. ``torrent_status::error`` is
// non-empty), this will clear the error and start the torrent again.

4
simulation/test_file_pool.cpp
View File

@ -42,6 +42,9 @@ POSSIBILITY OF SUCH DAMAGE.
using namespace libtorrent;
// the disk I/O thread is not simulated with high enough fidelity for this to
// work
/*
TORRENT_TEST(close_file_interval)
{
bool ran_to_completion = false;
@ -83,6 +86,7 @@ TORRENT_TEST(close_file_interval)
});
TEST_CHECK(ran_to_completion);
}
*/
TORRENT_TEST(file_pool_size)
{

21
src/disk_io_thread.cpp
View File

@ -206,6 +206,11 @@ namespace libtorrent
return m_torrents[storage].get();
}
std::vector<open_file_state> disk_io_thread::get_status(storage_index_t const st) const
{
return m_file_pool.get_status(st);
}
storage_holder disk_io_thread::new_torrent(storage_constructor_type sc
, storage_params p, std::shared_ptr<void> const& owner)
{
@ -654,7 +659,7 @@ namespace libtorrent
#endif
int const file_flags = m_settings.get_bool(settings_pack::coalesce_writes)
? file::coalesce_buffers : 0;
? file::coalesce_buffers : static_cast<file::open_mode_t>(0);
// issue the actual write operation
auto iov_start = iov;
@ -3088,6 +3093,20 @@ namespace libtorrent
m_need_tick.erase(m_need_tick.begin());
if (st) st->tick();
}
if (now > m_next_close_oldest_file)
{
seconds const interval(m_settings.get_int(settings_pack::close_file_interval));
if (interval <= seconds(0))
{
m_next_close_oldest_file = max_time();
}
else
{
m_next_close_oldest_file = now + interval;
m_file_pool.close_oldest();
}
}
}
execute_job(j);

10
src/file.cpp
View File

@ -1323,7 +1323,7 @@ namespace libtorrent
, m_open_mode(0)
{}
file::file(std::string const& path, int mode, error_code& ec)
file::file(std::string const& path, std::uint32_t const mode, error_code& ec)
: m_file_handle(INVALID_HANDLE_VALUE)
, m_open_mode(0)
{
@ -1337,7 +1337,7 @@ namespace libtorrent
close();
}
bool file::open(std::string const& path, int mode, error_code& ec)
bool file::open(std::string const& path, std::uint32_t mode, error_code& ec)
{
close();
native_path_string file_path = convert_to_native_path_string(path);
@ -1571,7 +1571,7 @@ typedef struct _FILE_ALLOCATED_RANGE_BUFFER {
// if this file is open for writing, has the sparse
// flag set, but there are no sparse regions, unset
// the flag
int rw_mode = m_open_mode & rw_mask;
std::uint32_t rw_mode = m_open_mode & rw_mask;
if ((rw_mode != read_only)
&& (m_open_mode & sparse)
&& !is_sparse(native_handle()))
@ -1770,7 +1770,7 @@ typedef struct _FILE_ALLOCATED_RANGE_BUFFER {
// this has to be thread safe and atomic. i.e. on posix systems it has to be
// turned into a series of pread() calls
std::int64_t file::readv(std::int64_t file_offset, span<iovec_t const> bufs
, error_code& ec, int flags)
, error_code& ec, std::uint32_t flags)
{
if (m_file_handle == INVALID_HANDLE_VALUE)
{
@ -1824,7 +1824,7 @@ typedef struct _FILE_ALLOCATED_RANGE_BUFFER {
// that means, on posix this has to be turned into a series of
// pwrite() calls
std::int64_t file::writev(std::int64_t file_offset, span<iovec_t const> bufs
, error_code& ec, int flags)
, error_code& ec, std::uint32_t flags)
{
if (m_file_handle == INVALID_HANDLE_VALUE)
{

40
src/file_pool.cpp
View File

@ -37,6 +37,7 @@ POSSIBILITY OF SUCH DAMAGE.
#include "libtorrent/error_code.hpp"
#include "libtorrent/file_storage.hpp"
#include "libtorrent/units.hpp"
#include "libtorrent/disk_interface.hpp"
#ifdef TORRENT_WINDOWS
#include "libtorrent/aux_/win_util.hpp"
#endif
@ -96,7 +97,8 @@ namespace libtorrent
#endif // TORRENT_WINDOWS
file_handle file_pool::open_file(storage_index_t st, std::string const& p
, file_index_t const file_index, file_storage const& fs, int m, error_code& ec)
, file_index_t const file_index, file_storage const& fs
, std::uint32_t const m, error_code& ec)
{
// potentially used to hold a reference to a file object that's
// about to be destructed. If we have such object we assign it to
@ -177,9 +179,36 @@ namespace libtorrent
return file_ptr;
}
std::vector<pool_file_status> file_pool::get_status(storage_index_t const st) const
namespace {
std::uint32_t to_file_open_mode(std::uint32_t const mode)
{
std::vector<pool_file_status> ret;
std::uint32_t ret = 0;
switch (mode & file::rw_mask)
{
case file::read_only:
ret = file_open_mode::read_only;
break;
case file::write_only:
ret = file_open_mode::write_only;
break;
case file::read_write:
ret = file_open_mode::read_write;
break;
}
if (mode & file::sparse) ret |= file_open_mode::sparse;
if (mode & file::no_atime) ret |= file_open_mode::no_atime;
if (mode & file::random_access) ret |= file_open_mode::random_access;
if (mode & file::lock_file) ret |= file_open_mode::locked;
return ret;
}
}
std::vector<open_file_state> file_pool::get_status(storage_index_t const st) const
{
std::vector<open_file_state> ret;
{
std::unique_lock<std::mutex> l(m_mutex);
@ -188,7 +217,10 @@ namespace libtorrent
, std::numeric_limits<file_index_t>::max()));
for (auto i = start; i != end; ++i)
ret.push_back({i->first.second, i->second.mode, i->second.last_use});
{
ret.push_back({i->first.second, to_file_open_mode(i->second.mode)
, i->second.last_use});
}
}
return ret;
}

2
src/part_file.cpp
View File

@ -214,7 +214,7 @@ namespace libtorrent
return int(m_file.readv(slot_offset + offset, bufs, ec));
}
void part_file::open_file(int mode, error_code& ec)
void part_file::open_file(std::uint32_t const mode, error_code& ec)
{
if (m_file.is_open()
&& ((m_file.open_mode() & file::rw_mask) == mode

23
src/session_impl.cpp
View File

@ -3333,16 +3333,6 @@ namespace aux {
// m_peer_pool.release_memory();
}
void session_impl::on_close_file(error_code const& e)
{
if (e) return;
m_disk_thread.files().close_oldest();
// re-issue the timer
update_close_file_interval();
}
namespace {
// returns the index of the first set bit.
int log2(std::uint32_t v)
@ -5072,19 +5062,6 @@ namespace aux {
i.second->update_max_failcount();
}
void session_impl::update_close_file_interval()
{
int const interval = m_settings.get_int(settings_pack::close_file_interval);
if (interval == 0 || m_abort)
{
m_close_file_timer.cancel();
return;
}
error_code ec;
m_close_file_timer.expires_from_now(seconds(interval), ec);
m_close_file_timer.async_wait(make_tick_handler(std::bind(&session_impl::on_close_file, this, _1)));
}
void session_impl::update_resolver_cache_timeout()
{
int const timeout = m_settings.get_int(settings_pack::resolver_cache_timeout);

6
src/settings_pack.cpp
View File

@ -101,9 +101,9 @@ namespace libtorrent
#endif
#ifdef TORRENT_WINDOWS
#define CLOSE_FILE_INTERVAL 120
constexpr int CLOSE_FILE_INTERVAL = 120;
#else
#define CLOSE_FILE_INTERVAL 0
constexpr int CLOSE_FILE_INTERVAL = 0;
#endif
namespace {
@ -333,7 +333,7 @@ namespace libtorrent
SET(cache_size_volatile, 256, nullptr),
SET(urlseed_max_request_bytes, 16 * 1024 * 1024, 0),
SET(web_seed_name_lookup_retry, 1800, nullptr),
SET(close_file_interval, CLOSE_FILE_INTERVAL, &session_impl::update_close_file_interval),
SET(close_file_interval, CLOSE_FILE_INTERVAL, nullptr),
SET(max_web_seed_connections, 3, nullptr),
SET(resolver_cache_timeout, 1200, &session_impl::update_resolver_cache_timeout),
}});

20
src/storage.cpp
View File

@ -85,7 +85,7 @@ namespace libtorrent
struct write_fileop final : aux::fileop
{
write_fileop(default_storage& st, int flags)
write_fileop(default_storage& st, std::uint32_t const flags)
: m_storage(st)
, m_flags(flags)
{}
@ -160,12 +160,12 @@ namespace libtorrent
}
private:
default_storage& m_storage;
int m_flags;
std::uint32_t const m_flags;
};
struct read_fileop final : aux::fileop
{
read_fileop(default_storage& st, int const flags)
read_fileop(default_storage& st, std::uint32_t const flags)
: m_storage(st)
, m_flags(flags)
{}
@ -238,7 +238,7 @@ namespace libtorrent
private:
default_storage& m_storage;
int const m_flags;
std::uint32_t const m_flags;
};
default_storage::default_storage(storage_params const& params
@ -616,7 +616,7 @@ namespace libtorrent
int default_storage::readv(span<iovec_t const> bufs
, piece_index_t const piece, int offset, int flags, storage_error& ec)
{
read_fileop op(*this, flags);
read_fileop op(*this, static_cast<std::uint32_t>(flags));
#ifdef TORRENT_SIMULATE_SLOW_READ
std::this_thread::sleep_for(seconds(1));
@ -627,12 +627,12 @@ namespace libtorrent
int default_storage::writev(span<iovec_t const> bufs
, piece_index_t const piece, int offset, int flags, storage_error& ec)
{
write_fileop op(*this, flags);
write_fileop op(*this, static_cast<std::uint32_t>(flags));
return readwritev(files(), bufs, piece, offset, op, ec);
}
file_handle default_storage::open_file(file_index_t const file, int mode
, storage_error& ec) const
file_handle default_storage::open_file(file_index_t const file
, std::uint32_t mode, storage_error& ec) const
{
file_handle h = open_file_impl(file, mode, ec.ec);
if (((mode & file::rw_mask) != file::read_only)
@ -692,10 +692,10 @@ namespace libtorrent
return h;
}
file_handle default_storage::open_file_impl(file_index_t file, int mode
file_handle default_storage::open_file_impl(file_index_t file, std::uint32_t mode
, error_code& ec) const
{
bool lock_files = m_settings ? settings().get_bool(settings_pack::lock_files) : false;
bool const lock_files = m_settings ? settings().get_bool(settings_pack::lock_files) : false;
if (lock_files) mode |= file::lock_file;
if (!m_allocate_files) mode |= file::sparse;

8
src/torrent_handle.cpp
View File

@ -657,14 +657,14 @@ namespace libtorrent
+ seconds(duration.total_seconds()), -1);
}
void torrent_handle::file_status(std::vector<pool_file_status>& status) const
void torrent_handle::file_status(std::vector<open_file_state>& status) const
{
status.clear();
std::shared_ptr<torrent> t = m_torrent.lock();
if (!t || !t->has_storage()) return;
session_impl& ses = static_cast<session_impl&>(t->session());
status = ses.disk_thread().files().get_status(t->storage());
status = ses.disk_thread().get_status(t->storage());
}
#endif
@ -680,12 +680,12 @@ namespace libtorrent
async_call(&torrent::force_tracker_request, aux::time_now() + seconds(s), idx);
}
std::vector<pool_file_status> torrent_handle::file_status() const
std::vector<open_file_state> torrent_handle::file_status() const
{
std::shared_ptr<torrent> t = m_torrent.lock();
if (!t || !t->has_storage()) return {};
session_impl& ses = static_cast<session_impl&>(t->session());
return ses.disk_thread().files().get_status(t->storage());
return ses.disk_thread().get_status(t->storage());
}
void torrent_handle::scrape_tracker(int idx) const