make iovec_t an alias for span<char>, in preparation for removing it altogether in favour of span

Author: arvidn

examples/connection_tester.cpp

@@ -63,6 +63,7 @@ using namespace lt::detail; // for write_* and read_*
 
 using namespace std::placeholders;
 
+// TODO: this should take a span
 void generate_block(std::uint32_t* buffer, piece_index_t const piece, int start, int length)
 {
 	std::uint32_t fill = (static_cast<int>(piece) << 8) | ((start / 0x4000) & 0xff);
@@ -867,7 +868,8 @@ void generate_data(char const* path, torrent_info const& ti)
 		{
 			generate_block(piece, i, j, 0x4000);
 			int const left_in_piece = ti.piece_size(i) - j;
-			iovec_t const b = { piece, size_t(std::min(left_in_piece, 0x4000))};
+			iovec_t const b = { reinterpret_cast<char*>(piece)
+				, size_t(std::min(left_in_piece, 0x4000))};
 			storage_error error;
 			st->writev(b, i, j, 0, error);
 			if (error)

include/libtorrent/aux_/storage_utils.hpp

@@ -40,10 +40,6 @@ POSSIBILITY OF SUCH DAMAGE.
 #include "libtorrent/units.hpp"
 #include "libtorrent/storage_defs.hpp" // for status_t
 
-#ifndef TORRENT_WINDOWS
-#include <sys/uio.h> // for iovec
-#endif
-
 namespace libtorrent {
 
 	class file_storage;
@@ -52,19 +48,14 @@ namespace libtorrent {
 	struct stat_cache;
 	struct add_torrent_params;
 
-#ifdef TORRENT_WINDOWS
-	struct iovec_t
-	{
-		void* iov_base;
-		size_t iov_len;
-	};
-#else
-	using iovec_t = ::iovec;
-#endif
+	// TODO: 3 remove this typedef, and use span<char const> for disk write
+	// operations
+	using iovec_t = span<char>;
 
 	namespace aux {
 
-	TORRENT_EXTRA_EXPORT int copy_bufs(span<iovec_t const> bufs, int bytes, span<iovec_t> target);
+	TORRENT_EXTRA_EXPORT int copy_bufs(span<iovec_t const> bufs
+		, int bytes, span<iovec_t> target);
 	TORRENT_EXTRA_EXPORT span<iovec_t> advance_bufs(span<iovec_t> bufs, int bytes);
 
 	// this identifies a read or write operation so that readwritev() knows

include/libtorrent/file.hpp

@@ -214,9 +214,6 @@ namespace libtorrent {
 		static bool has_manage_volume_privs;
 #endif
 	};
-
-	TORRENT_EXTRA_EXPORT int bufs_size(span<iovec_t const> bufs);
-
 }
 
 #endif // TORRENT_FILE_HPP_INCLUDED

src/block_cache.cpp

@@ -1272,14 +1272,14 @@ void block_cache::insert_blocks(cached_piece_entry* pe, int block, span<iovec_t
 	for (auto const& buf : iov)
 	{
 		// each iovec buffer has to be the size of a block (or the size of the last block)
-		TORRENT_PIECE_ASSERT(int(buf.iov_len) == std::min(block_size()
+		TORRENT_PIECE_ASSERT(int(buf.size()) == std::min(block_size()
 			, pe->storage->files().piece_size(pe->piece) - block * block_size()), pe);
 
 		// no nullptrs allowed
-		TORRENT_ASSERT(buf.iov_base != nullptr);
+		TORRENT_ASSERT(buf.data() != nullptr);
 
 #ifdef TORRENT_DEBUG_BUFFERS
-		TORRENT_PIECE_ASSERT(is_disk_buffer(static_cast<char*>(buf.iov_base)), pe);
+		TORRENT_PIECE_ASSERT(is_disk_buffer(buf.data()), pe);
 #endif
 
 		if (pe->blocks[block].buf && (flags & blocks_inc_refcount))
@@ -1290,13 +1290,13 @@ void block_cache::insert_blocks(cached_piece_entry* pe, int block, span<iovec_t
 		// either free the block or insert it. Never replace a block
 		if (pe->blocks[block].buf)
 		{
-			free_buffer(static_cast<char*>(buf.iov_base));
+			free_buffer(buf.data());
 		}
 		else
 		{
-			pe->blocks[block].buf = static_cast<char*>(buf.iov_base);
+			pe->blocks[block].buf = buf.data();
 
-			TORRENT_PIECE_ASSERT(buf.iov_base != nullptr, pe);
+			TORRENT_PIECE_ASSERT(buf.data() != nullptr, pe);
 			TORRENT_PIECE_ASSERT(pe->blocks[block].dirty == false, pe);
 			++pe->num_blocks;
 			++m_read_cache_size;

src/disk_buffer_pool.cpp

@@ -195,17 +195,16 @@ namespace libtorrent {
 		std::unique_lock<std::mutex> l(m_pool_mutex);
 		for (auto& i : iov)
 		{
-			i.iov_base = allocate_buffer_impl(l, "pending read");
-			i.iov_len = std::size_t(block_size());
-			if (i.iov_base == nullptr)
+			i = { allocate_buffer_impl(l, "pending read"), std::size_t(block_size())};
+			if (i.data() == nullptr)
 			{
 				// uh oh. We failed to allocate the buffer!
 				// we need to roll back and free all the buffers
 				// we've already allocated
 				for (auto j : iov)
 				{
-					if (j.iov_base == nullptr) break;
-					char* buf = static_cast<char*>(j.iov_base);
+					if (j.data() == nullptr) break;
+					char* buf = j.data();
 					TORRENT_ASSERT(is_disk_buffer(buf, l));
 					free_buffer_impl(buf, l);
 					remove_buffer_in_use(buf);
@@ -222,7 +221,7 @@ namespace libtorrent {
 		std::unique_lock<std::mutex> l(m_pool_mutex);
 		for (auto i : iov)
 		{
-			char* buf = static_cast<char*>(i.iov_base);
+			char* buf = i.data();
 			TORRENT_ASSERT(is_disk_buffer(buf, l));
 			free_buffer_impl(buf, l);
 			remove_buffer_in_use(buf);

src/disk_io_thread.cpp

@@ -631,8 +631,7 @@ namespace libtorrent {
 			TORRENT_UNUSED(locked);
 
 			flushing[num_flushing++] = i + block_base_index;
-			iov[iov_len].iov_base = pe->blocks[i].buf;
-			iov[iov_len].iov_len = aux::numeric_cast<std::size_t>(std::min(block_size, size_left));
+			iov[iov_len] = { pe->blocks[i].buf, aux::numeric_cast<std::size_t>(std::min(block_size, size_left)) };
 			++iov_len;
 			pe->blocks[i].pending = true;
 
@@ -1302,9 +1301,10 @@ namespace libtorrent {
 
 		// if this is the last piece, adjust the size of the
 		// last buffer to match up
-		iov[iov_len - 1].iov_len = aux::numeric_cast<std::size_t>(std::min(int(piece_size - adjusted_offset)
-			- (iov_len - 1) * block_size, block_size));
-		TORRENT_ASSERT(iov[iov_len - 1].iov_len > 0);
+		iov[iov_len - 1] = iov[iov_len - 1].first(aux::numeric_cast<std::size_t>(
+				std::min(int(piece_size - adjusted_offset)
+			- (iov_len - 1) * block_size, block_size)));
+		TORRENT_ASSERT(iov[iov_len - 1].size() > 0);
 
 		// at this point, all the buffers are allocated and iov is initialized
 		// and the blocks have their refcounters incremented, so no other thread
@@ -2162,8 +2162,7 @@ namespace libtorrent {
 		std::uint32_t const file_flags = file_flags_for_job(j
 			, m_settings.get_bool(settings_pack::coalesce_reads));
 
-		iovec_t iov;
-		iov.iov_base = m_disk_cache.allocate_buffer("hashing");
+		iovec_t iov = { m_disk_cache.allocate_buffer("hashing"), 0x4000 };
 		hasher h;
 		int ret = 0;
 		int offset = 0;
@@ -2174,10 +2173,11 @@ namespace libtorrent {
 
 			time_point const start_time = clock_type::now();
 
-			iov.iov_len = aux::numeric_cast<std::size_t>(std::min(block_size, piece_size - offset));
+			iov = iov.first(aux::numeric_cast<std::size_t>(std::min(block_size, piece_size - offset)));
 			ret = j->storage->readv(iov, j->piece
 				, offset, file_flags, j->error);
 			if (ret < 0) break;
+			iov = iov.first(std::size_t(ret));
 
 			if (!j->error.ec)
 			{
@@ -2191,10 +2191,10 @@ namespace libtorrent {
 			}
 
 			offset += block_size;
-			h.update(static_cast<char const*>(iov.iov_base), int(iov.iov_len));
+			h.update(iov);
 		}
 
-		m_disk_cache.free_buffer(static_cast<char*>(iov.iov_base));
+		m_disk_cache.free_buffer(iov.data());
 
 		sha1_hash piece_hash = h.final();
 		std::memcpy(j->d.piece_hash, piece_hash.data(), 20);
@@ -2326,23 +2326,22 @@ namespace libtorrent {
 		int next_locked_block = 0;
 		for (int i = offset / block_size; i < blocks_in_piece; ++i)
 		{
-			iovec_t iov;
-			iov.iov_len = aux::numeric_cast<std::size_t>(std::min(block_size, piece_size - offset));
-
 			if (next_locked_block < num_locked_blocks
 				&& locked_blocks[next_locked_block] == i)
 			{
+				int const len = std::min(block_size, piece_size - offset);
 				++next_locked_block;
 				TORRENT_PIECE_ASSERT(pe->blocks[i].buf, pe);
 				TORRENT_PIECE_ASSERT(offset == i * block_size, pe);
-				offset += int(iov.iov_len);
-				ph->h.update({pe->blocks[i].buf, iov.iov_len});
+				offset += len;
+				ph->h.update({pe->blocks[i].buf, aux::numeric_cast<std::size_t>(len)});
 			}
 			else
 			{
-				iov.iov_base = m_disk_cache.allocate_buffer("hashing");
+				iovec_t const iov = { m_disk_cache.allocate_buffer("hashing")
+					, aux::numeric_cast<std::size_t>(std::min(block_size, piece_size - offset))};
 
-				if (iov.iov_base == nullptr)
+				if (iov.data() == nullptr)
 				{
 					l.lock();
 
@@ -2374,19 +2373,19 @@ namespace libtorrent {
 				{
 					ret = status_t::fatal_disk_error;
 					TORRENT_ASSERT(j->error.ec && j->error.operation != 0);
-					m_disk_cache.free_buffer(static_cast<char*>(iov.iov_base));
+					m_disk_cache.free_buffer(iov.data());
 					break;
 				}
 
 				// treat a short read as an error. The hash will be invalid, the
 				// block cannot be cached and the main thread should skip the rest
 				// of this file
-				if (read_ret != int(iov.iov_len))
+				if (read_ret != int(iov.size()))
 				{
 					ret = status_t::fatal_disk_error;
 					j->error.ec = boost::asio::error::eof;
 					j->error.operation = storage_error::read;
-					m_disk_cache.free_buffer(static_cast<char*>(iov.iov_base));
+					m_disk_cache.free_buffer(iov.data());
 					break;
 				}
 
@@ -2403,8 +2402,8 @@ namespace libtorrent {
 				}
 
 				TORRENT_PIECE_ASSERT(offset == i * block_size, pe);
-				offset += int(iov.iov_len);
-				ph->h.update({static_cast<char const*>(iov.iov_base), iov.iov_len});
+				offset += int(iov.size());
+				ph->h.update(iov);
 
 				l.lock();
 				m_disk_cache.insert_blocks(pe, i, iov, j);