raise the max piece size to 512 MiB and fix check when loading torrents

ChangeLog

@@ -1,3 +1,4 @@
+ * raise the max piece size to 512 MiB and fix check when loading torrents
  * back-port fix last_upload and last_download resume data fields to use posix time
  * back-port treat CGNAT address range as local IPs
 

include/libtorrent/block_cache.hpp

@@ -235,40 +235,36 @@ namespace aux {
  // bitfield
  std::uint16_t blocks_in_piece = 0;
 
- // this is the number of threads that are currently holding
- // a reference to this piece. A piece may not be removed from
- // the cache while this is > 0
- std::uint8_t piece_refcount = 0;
-
- // 8 bytes padding
-
- // ---- 64 bit boundary ----
+ // the number of blocks in the cache for this piece
+ std::uint16_t num_blocks = 0;
 
  // the number of dirty blocks in this piece
- std::uint32_t num_dirty:14;
+ std::uint16_t num_dirty = 0;
 
- // the number of blocks in the cache for this piece
- std::uint32_t num_blocks:14;
+ // this is the number of threads that are currently holding
+ // a reference to this piece. A piece may not be removed from
+ // the cache while this is > 0
+ std::uint16_t piece_refcount:8;
 
  // while we have an outstanding async hash operation
  // working on this piece, 'hashing' is set to 1
  // When the operation returns, this is set to 0.
- std::uint32_t hashing:1;
+ std::uint16_t hashing:1;
 
  // if we've completed at least one hash job on this
  // piece, and returned it. This is set to one
- std::uint32_t hashing_done:1;
+ std::uint16_t hashing_done:1;
 
  // if this is true, whenever refcount hits 0,
  // this piece should be deleted from the cache
  // (not just demoted)
- std::uint32_t marked_for_deletion:1;
+ std::uint16_t marked_for_deletion:1;
 
  // this is set to true once we flush blocks past
  // the hash cursor. Once this happens, there's
  // no point in keeping cache blocks around for
  // it in avoid_readback mode
- std::uint32_t need_readback:1;
+ std::uint16_t need_readback:1;
 
  // indicates which LRU list this piece is chained into
  enum cache_state_t

include/libtorrent/piece_picker.hpp

@@ -97,9 +97,9 @@ namespace libtorrent {
  // priority factor
  prio_factor = 3,
  // max blocks per piece
- // there are counters in downloading_piece that only have 15 bits to
+ // there are counters in downloading_piece that only have 16 bits to
  // count blocks per piece, that's restricting this
- max_blocks_per_piece = (1 << 15) - 1
+ max_blocks_per_piece = (1 << 16) - 1
  };
 
  struct block_info

src/block_cache.cpp

@@ -292,8 +292,7 @@ static_assert(int(job_action_name.size()) == static_cast<int>(job_action_t::num_
 #endif
 
 cached_piece_entry::cached_piece_entry()
- : num_dirty(0)
- , num_blocks(0)
+ : piece_refcount(0)
  , hashing(0)
  , hashing_done(0)
  , marked_for_deletion(false)
@@ -790,7 +789,7 @@ bool block_cache::blocks_flushed(cached_piece_entry* pe, int const* flushed, int
 
  m_write_cache_size -= num_flushed;
  m_read_cache_size += num_flushed;
- pe->num_dirty -= num_flushed;
+ pe->num_dirty = aux::numeric_cast<std::uint16_t>(pe->num_dirty - num_flushed);
 
  update_cache_state(pe);
  return maybe_free_piece(pe);

src/torrent_info.cpp

@@ -1027,11 +1027,16 @@ namespace {
 
  // extract piece length
  std::int64_t piece_length = info.dict_find_int_value("piece length", -1);
- if (piece_length <= 0 || piece_length > std::numeric_limits<int>::max())
+ if (piece_length <= 0)
  {
  ec = errors::torrent_missing_piece_length;
  return false;
  }
+ if (piece_length > std::numeric_limits<int>::max())
+ {
+ ec = errors::invalid_piece_size;
+ return false;
+ }
  file_storage files;
  files.set_piece_length(static_cast<int>(piece_length));
 

test/test_torrent.cpp

@@ -167,7 +167,7 @@ void test_running_torrent(std::shared_ptr<torrent_info> info, std::int64_t file_
  TEST_CHECK(h.get_file_priorities() == prio);
 }
 
-void test_large_piece_size(int const size)
+void test_large_piece_size(std::int64_t const size)
 {
  entry torrent;
  entry& info = torrent["info"];
@@ -179,7 +179,15 @@ void test_large_piece_size(int const size)
  std::vector<char> buf;
  bencode(std::back_inserter(buf), torrent);
  add_torrent_params atp;
- atp.ti = std::make_shared<torrent_info>(buf, from_span);
+ try
+ {
+ atp.ti = std::make_shared<torrent_info>(buf, from_span);
+ }
+ catch (lt::system_error const& e)
+ {
+ TEST_CHECK(e.code() == error_code(lt::errors::invalid_piece_size));
+ return;
+ }
  atp.save_path = ".";
 
  lt::session ses;
@@ -212,9 +220,9 @@ TORRENT_TEST(long_names)
 
 TORRENT_TEST(large_piece_size)
 {
- test_large_piece_size(32768 * 16 * 1024);
- test_large_piece_size(65536 * 16 * 1024);
- test_large_piece_size(65537 * 16 * 1024);
+ test_large_piece_size(0x40000000 + 0x4000);
+ test_large_piece_size(0x80000000);
+ test_large_piece_size(0x100000000);
 }
 
 TORRENT_TEST(total_wanted)