refactor: explicitly handle release_until() return value

include/dwarfs/writer/internal/chunkable.h

@@ -23,6 +23,7 @@
 
 #include <span>
 #include <string_view>
+#include <system_error>
 
 namespace dwarfs {
 
@@ -39,7 +40,7 @@ class chunkable {
   virtual std::string description() const = 0;
   virtual std::span<uint8_t const> span() const = 0;
   virtual void add_chunk(size_t block, size_t offset, size_t size) = 0;
-  virtual void release_until(size_t offset) = 0;
+  virtual std::error_code release_until(size_t offset) = 0;
 };
 
 } // namespace writer::internal

include/dwarfs/writer/internal/fragment_chunkable.h

@@ -50,7 +50,7 @@ class fragment_chunkable : public chunkable {
   std::string description() const override;
   std::span<uint8_t const> span() const override;
   void add_chunk(size_t block, size_t offset, size_t size) override;
-  void release_until(size_t offset) override;
+  std::error_code release_until(size_t offset) override;
 
  private:
   inode const& ino_;

src/writer/internal/entry.cpp

@@ -264,6 +264,8 @@ void file::scan(mmif* mm, progress& prog,
 
       while (s >= chunk_size) {
         cs.update(mm->as<void>(offset), chunk_size);
+        // release_until() is best-effort, we can ignore the return value
+        // NOLINTNEXTLINE(bugprone-unused-return-value)
         mm->release_until(offset);
         offset += chunk_size;
         s -= chunk_size;

src/writer/internal/fragment_chunkable.cpp

@@ -61,8 +61,8 @@ void fragment_chunkable::add_chunk(size_t block, size_t offset, size_t size) {
   frag_.add_chunk(block, offset, size);
 }
 
-void fragment_chunkable::release_until(size_t offset) {
-  mm_.release_until(offset_ + offset);
+std::error_code fragment_chunkable::release_until(size_t offset) {
+  return mm_.release_until(offset_ + offset);
 }
 
 } // namespace dwarfs::writer::internal

src/writer/internal/inode_manager.cpp

@@ -385,6 +385,8 @@ class inode_ : public inode {
                   size_t chunk_size, T&& scanner) {
     while (size >= chunk_size) {
       std::forward<T>(scanner)(mm->span(offset, chunk_size));
+      // release_until() is best-effort, we can ignore the return value
+      // NOLINTNEXTLINE(bugprone-unused-return-value)
       mm->release_until(offset);
       offset += chunk_size;
       size -= chunk_size;

src/writer/segmenter.cpp

@@ -1071,7 +1071,10 @@ segmenter_<LoggerPolicy, SegmentingPolicy>::append_to_block(
   prog_.filesystem_size += size_in_bytes;
 
   if (block.full()) [[unlikely]] {
-    chkable.release_until(offset_in_bytes + size_in_bytes);
+    if (auto ec = chkable.release_until(offset_in_bytes + size_in_bytes)) {
+      LOG_DEBUG << cfg_.context
+                << "error releasing chunkable: " << ec.message();
+    }
     finish_chunk(chkable);
     block_ready();
   }

test/segmenter_benchmark.cpp

@@ -55,7 +55,7 @@ class bench_chunkable : public dwarfs::writer::internal::chunkable {
   void
   add_chunk(size_t /*block*/, size_t /*offset*/, size_t /*size*/) override {}
 
-  void release_until(size_t /*offset*/) override {}
+  std::error_code release_until(size_t /*offset*/) override { return {}; }
 
  private:
   std::vector<uint8_t> data_;