@nxtedition/rocksdb 15.4.1 → 15.5.0

package/deps/rocksdb/rocksdb/env/fs_posix.cc

@@ -674,7 +674,7 @@ class PosixFileSystem : public FileSystem {
 
   IOStatus GetFileSize(const std::string& fname, const IOOptions& /*opts*/,
                        uint64_t* size, IODebugContext* /*dbg*/) override {
-    struct stat sbuf {};
+    struct stat sbuf{};
     if (stat(fname.c_str(), &sbuf) != 0) {
       *size = 0;
       return IOError("while stat a file for size", fname, errno);
@@ -981,7 +981,7 @@ class PosixFileSystem : public FileSystem {
   // file size. However this API only works on opened file.
   IOStatus GetFileSizeOnOpenedFile(const int fd, const std::string& name,
                                    uint64_t* size) {
-    struct stat sb {};
+    struct stat sb{};
     *size = 0;
     // Get file information using fstat
     if (fstat(fd, &sb) == -1) {
@@ -1129,25 +1129,7 @@ class PosixFileSystem : public FileSystem {
         // Reset cqe data to catch any stray reuse of it
         static_cast<struct io_uring_cqe*>(cqe)->user_data = 0xd5d5d5d5d5d5d5d5;
 
-        FSReadRequest req;
-        req.scratch = posix_handle->scratch;
-        req.offset = posix_handle->offset;
-        req.len = posix_handle->len;
-
-        size_t finished_len = 0;
-        size_t bytes_read = 0;
-        bool read_again = false;
-        UpdateResult(cqe, "", req.len, posix_handle->iov.iov_len,
-                     true /*async_read*/, posix_handle->use_direct_io,
-                     posix_handle->alignment, finished_len, &req, bytes_read,
-                     read_again);
-        posix_handle->is_finished = true;
-        io_uring_cqe_seen(iu, cqe);
-        posix_handle->cb(req, posix_handle->cb_arg);
-
-        (void)finished_len;
-        (void)bytes_read;
-        (void)read_again;
+        FinalizeAsyncRead(iu, cqe, posix_handle);
 
         if (static_cast<Posix_IOHandle*>(io_handles[i]) == posix_handle) {
           break;
@@ -1188,6 +1170,11 @@ class PosixFileSystem : public FileSystem {
         return IOStatus::IOError("");
       }
 
+      // Mark this handle as being aborted. This is used when processing
+      // completions to distinguish between aborted handles (expect 2
+      // completions: original + cancel) and non-aborted handles (expect 1).
+      posix_handle->is_being_aborted = true;
+
       // Prepare the cancel request.
       struct io_uring_sqe* sqe;
       sqe = io_uring_get_sqe(iu);
@@ -1234,6 +1221,14 @@ class PosixFileSystem : public FileSystem {
         }
         posix_handle->req_count++;
 
+        if (!posix_handle->is_being_aborted) {
+          // This is a completion for a handle NOT being aborted.
+          // It only has 1 outstanding request (the original read), so we
+          // should finalize it now.
+          FinalizeAsyncRead(iu, cqe, posix_handle);
+          continue;
+        }
+
         // Reset cqe data to catch any stray reuse of it
         static_cast<struct io_uring_cqe*>(cqe)->user_data = 0xd5d5d5d5d5d5d5d5;
         io_uring_cqe_seen(iu, cqe);
@@ -1247,16 +1242,23 @@ class PosixFileSystem : public FileSystem {
         // - And finally, if the request to cancel wasn't
         //   found, the cancel request is completed with -ENOENT.
         //
-        // Every handle has to wait for 2 requests completion: original one and
-        // the cancel request which is tracked by PosixHandle::req_count.
-        if (posix_handle->req_count == 2 &&
-            static_cast<Posix_IOHandle*>(io_handles[i]) == posix_handle) {
+        // Every handle being aborted has to wait for 2 requests completion:
+        // original one and the cancel request which is tracked by
+        // PosixHandle::req_count.
+        // Note: We must mark is_finished and invoke the callback for ANY handle
+        // that reaches req_count == 2, not just the one we're currently waiting
+        // for (io_handles[i]). Otherwise, if completions arrive out of order,
+        // we consume another handle's completions without marking it finished,
+        // causing an infinite hang when we later wait for that handle.
+        if (posix_handle->req_count == 2) {
           posix_handle->is_finished = true;
           FSReadRequest req;
           req.status = IOStatus::Aborted();
           posix_handle->cb(req, posix_handle->cb_arg);
 
-          break;
+          if (static_cast<Posix_IOHandle*>(io_handles[i]) == posix_handle) {
+            break;
+          }
         }
       }
     }
@@ -1272,7 +1274,7 @@ class PosixFileSystem : public FileSystem {
   void SupportedOps(int64_t& supported_ops) override {
     supported_ops = 0;
 #if defined(ROCKSDB_IOURING_PRESENT)
-    if (IsIOUringEnabled()) {
+    if (IsIOUringEnabled() && thread_local_async_read_io_urings_) {
       // Underlying FS supports async_io
       supported_ops |= (1 << FSSupportedOps::kAsyncIO);
     }
@@ -1338,9 +1340,8 @@ PosixFileSystem::PosixFileSystem()
       page_size_(getpagesize()),
       allow_non_owner_access_(true) {
 #if defined(ROCKSDB_IOURING_PRESENT)
-  // Test whether IOUring is supported, and if it does, create a managing
-  // object for thread local point so that in the future thread-local
-  // io_uring can be created.
+  // Test whether IOUring is supported with the same flags that ReadAsync and
+  // MultiRead will use at runtime.
   struct io_uring* new_io_uring = CreateIOUring();
   if (new_io_uring != nullptr) {
     thread_local_async_read_io_urings_.reset(new ThreadLocalPtr(DeleteIOUring));

package/deps/rocksdb/rocksdb/env/io_posix.cc

@@ -610,7 +610,7 @@ PosixRandomAccessFile::PosixRandomAccessFile(
 PosixRandomAccessFile::~PosixRandomAccessFile() { close(fd_); }
 
 IOStatus PosixRandomAccessFile::GetFileSize(uint64_t* result) {
-  struct stat sbuf {};
+  struct stat sbuf{};
   if (fstat(fd_, &sbuf) != 0) {
     *result = 0;
     return IOError("While fstat with fd " + std::to_string(fd_), filename_,
@@ -755,10 +755,7 @@ IOStatus PosixRandomAccessFile::MultiRead(FSReadRequest* reqs, size_t num_reqs,
     iu = static_cast<struct io_uring*>(
         thread_local_multi_read_io_urings_->Get());
     if (iu == nullptr) {
-      unsigned int flags = 0;
-      flags |= IORING_SETUP_SINGLE_ISSUER;
-      flags |= IORING_SETUP_DEFER_TASKRUN;
-      iu = CreateIOUring(flags);
+      iu = CreateIOUring();
       if (iu != nullptr) {
         thread_local_multi_read_io_urings_->Reset(iu);
       }
@@ -1090,10 +1087,7 @@ IOStatus PosixRandomAccessFile::ReadAsync(
     iu = static_cast<struct io_uring*>(
         thread_local_async_read_io_urings_->Get());
     if (iu == nullptr) {
-      unsigned int flags = 0;
-      flags |= IORING_SETUP_SINGLE_ISSUER;
-      flags |= IORING_SETUP_DEFER_TASKRUN;
-      iu = CreateIOUring(flags);
+      iu = CreateIOUring();
       if (iu != nullptr) {
         thread_local_async_read_io_urings_->Reset(iu);
       }
@@ -1946,7 +1940,10 @@ IOStatus PosixDirectory::FsyncWithDirOptions(
   assert(fd_ >= 0);  // Check use after close
   IOStatus s = IOStatus::OK();
 #ifndef OS_AIX
-  if (is_btrfs_) {
+  bool test_is_btrfs = is_btrfs_;
+  TEST_SYNC_POINT_CALLBACK("PosixDirectory::FsyncWithDirOptions:ForceBtrfs",
+                           &test_is_btrfs);
+  if (test_is_btrfs) {
     // skip dir fsync for new file creation, which is not needed for btrfs
     if (dir_fsync_options.reason == DirFsyncOptions::kNewFileSynced) {
       return s;
@@ -1965,7 +1962,7 @@ IOStatus PosixDirectory::FsyncWithDirOptions(
       } else if (fsync(fd) < 0) {
         s = IOError("While fsync renaming file", new_name, errno);
       }
-      if (close(fd) < 0) {
+      if (fd >= 0 && close(fd) < 0) {
         s = IOError("While closing file after fsync", new_name, errno);
       }
       return s;

package/deps/rocksdb/rocksdb/env/io_posix.h

@@ -127,6 +127,7 @@ struct Posix_IOHandle {
         use_direct_io(_use_direct_io),
         alignment(_alignment),
         is_finished(false),
+        is_being_aborted(false),
         req_count(0) {}
 
   struct iovec iov;
@@ -139,6 +140,10 @@ struct Posix_IOHandle {
   bool use_direct_io;
   size_t alignment;
   bool is_finished;
+  // is_being_aborted is set by AbortIO when a cancel request is submitted.
+  // Used to distinguish between aborted handles (expect 2 completions) and
+  // non-aborted handles (expect 1 completion) when processing completions.
+  bool is_being_aborted;
   // req_count is used by AbortIO API to keep track of number of requests.
   uint32_t req_count;
 };
@@ -197,6 +202,27 @@ inline void UpdateResult(struct io_uring_cqe* cqe, const std::string& file_name,
   (void)len;
 #endif
 }
+
+// Finalize a completed async read request.
+// Processes the CQE result, marks the handle as finished, and invokes the
+// callback. This is shared between Poll and AbortIO (for non-aborted handles).
+inline void FinalizeAsyncRead(struct io_uring* iu, struct io_uring_cqe* cqe,
+                              Posix_IOHandle* posix_handle) {
+  FSReadRequest req;
+  req.scratch = posix_handle->scratch;
+  req.offset = posix_handle->offset;
+  req.len = posix_handle->len;
+
+  size_t finished_len = 0;
+  size_t bytes_read = 0;
+  bool read_again = false;
+  UpdateResult(cqe, "", req.len, posix_handle->iov.iov_len, true /*async_read*/,
+               posix_handle->use_direct_io, posix_handle->alignment,
+               finished_len, &req, bytes_read, read_again);
+  posix_handle->is_finished = true;
+  io_uring_cqe_seen(iu, cqe);
+  posix_handle->cb(req, posix_handle->cb_arg);
+}
 #endif
 
 #ifdef OS_LINUX
@@ -307,8 +333,11 @@ inline void DeleteIOUring(void* p) {
   delete iu;
 }
 
-inline struct io_uring* CreateIOUring(unsigned int flags = 0) {
+inline struct io_uring* CreateIOUring() {
   struct io_uring* new_io_uring = new struct io_uring;
+  unsigned int flags = 0;
+  flags |= IORING_SETUP_SINGLE_ISSUER;
+  flags |= IORING_SETUP_DEFER_TASKRUN;
   int ret = io_uring_queue_init(kIoUringDepth, new_io_uring, flags);
   if (ret) {
     delete new_io_uring;

package/deps/rocksdb/rocksdb/env/io_posix_test.cc

@@ -3,11 +3,13 @@
 // COPYING file in the root directory) and Apache 2.0 License
 // (found in the LICENSE.Apache file in the root directory).
 
+#include "test_util/sync_point.h"
 #include "test_util/testharness.h"
 #include "util/random.h"
 
 #ifdef ROCKSDB_LIB_IO_POSIX
 #include "env/io_posix.h"
+#include "rocksdb/file_system.h"
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -174,6 +176,47 @@ TEST_F(PosixWritableFileTest, SeekAfterExtend) {
   ASSERT_OK(fs->DeleteFile(path, IOOptions(), nullptr));
 }
 
+#ifdef OS_LINUX
+class PosixDirectoryTest : public testing::Test {};
+
+TEST_F(PosixDirectoryTest, BtrfsFsyncFailedOpenDoesNotCloseInvalidFd) {
+  // When FsyncWithDirOptions is called with kFileRenamed on a btrfs filesystem
+  // and open() fails, close(-1) should not be called. Without the fix,
+  // close(-1) is called which is POSIX undefined behavior and overwrites the
+  // meaningful open error with a misleading "While closing file after fsync".
+  std::shared_ptr<FileSystem> fs = FileSystem::Default();
+  std::string dir_path =
+      test::PerThreadDBPath("PosixDirectoryTest_BtrfsFsyncFailedOpen");
+  ASSERT_OK(fs->CreateDirIfMissing(dir_path, IOOptions(), nullptr));
+
+  std::unique_ptr<FSDirectory> dir;
+  ASSERT_OK(fs->NewDirectory(dir_path, IOOptions(), &dir, nullptr));
+
+  // Force the btrfs code path via sync point
+  SyncPoint::GetInstance()->SetCallBack(
+      "PosixDirectory::FsyncWithDirOptions:ForceBtrfs",
+      [](void* arg) { *static_cast<bool*>(arg) = true; });
+  SyncPoint::GetInstance()->EnableProcessing();
+
+  // Call FsyncWithDirOptions with a non-existent file for rename sync.
+  // open() will fail since the file doesn't exist.
+  DirFsyncOptions opts(std::string(dir_path + "/nonexistent_file"));
+  IOStatus s = dir->FsyncWithDirOptions(IOOptions(), nullptr, opts);
+
+  // Should get an error about open failing, NOT about closing
+  ASSERT_TRUE(s.IsIOError());
+  // The error message should mention "open", not "closing"
+  ASSERT_TRUE(s.ToString().find("open") != std::string::npos);
+  ASSERT_TRUE(s.ToString().find("closing") == std::string::npos);
+
+  SyncPoint::GetInstance()->DisableProcessing();
+  SyncPoint::GetInstance()->ClearAllCallBacks();
+
+  ASSERT_OK(dir->Close(IOOptions(), nullptr));
+  ASSERT_OK(fs->DeleteDir(dir_path, IOOptions(), nullptr));
+}
+#endif
+
 }  // namespace ROCKSDB_NAMESPACE
 #endif
 

package/deps/rocksdb/rocksdb/file/delete_scheduler.cc

@@ -351,7 +351,7 @@ void DeleteScheduler::BackgroundEmptyTrash() {
           auto iter = pending_files_in_buckets_.find(bucket.value());
           assert(iter != pending_files_in_buckets_.end());
           if (iter != pending_files_in_buckets_.end()) {
-            pending_files_in_bucket = iter->second--;
+            pending_files_in_bucket = --iter->second;
           }
         }
       }

package/deps/rocksdb/rocksdb/file/delete_scheduler_test.cc

@@ -7,6 +7,7 @@
 
 #include <atomic>
 #include <cinttypes>
+#include <future>
 #include <thread>
 #include <vector>
 
@@ -856,6 +857,113 @@ TEST_F(DeleteSchedulerTest,
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
 }
 
+TEST_F(DeleteSchedulerTest, BucketSignalOnSingleFileCompletion) {
+  // Test that WaitForEmptyTrashBucket wakes up correctly when a single file
+  // in a bucket is deleted. This requires the pre-decrement fix: with
+  // post-decrement, the pending count is checked before it reaches zero,
+  // so the signal is never fired for the bucket, causing a hang.
+  //
+  // Strategy:
+  // 1. Block the background thread inside DeleteTrashFile for file 0 (mu_ is
+  //    NOT held at this point, since it's unlocked before calling
+  //    DeleteTrashFile).
+  // 2. Start WaitForEmptyTrashBucket(bucket0) on another thread. Since mu_ is
+  //    free, it acquires mu_, sees bucket0's pending count == 1, enters
+  //    cv_.Wait() (which releases mu_).
+  // 3. Unblock file 0's deletion. The background thread completes
+  //    DeleteTrashFile, re-acquires mu_, decrements the bucket counter. With
+  //    the post-decrement bug, pending_files_in_bucket gets 1 (old value),
+  //    so cv_.SignalAll() is NOT called. The wait thread stays stuck.
+  // 4. Also block file 1 inside DeleteTrashFile to keep pending_files_ > 0,
+  //    preventing the global pending_files_ == 0 check from triggering a
+  //    signal.
+  // 5. Assert the wait thread times out (bug) or completes (fix).
+  rate_bytes_per_sec_ = 1024 * 1024;  // 1 MB / s
+  NewDeleteScheduler();
+
+  std::atomic<int> delete_calls{0};
+  std::atomic<bool> unblock_file0{false};
+  std::atomic<bool> unblock_file1{false};
+
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
+      "DeleteScheduler::DeleteTrashFile:DeleteFile", [&](void* /*arg*/) {
+        int n = delete_calls.fetch_add(1) + 1;
+        if (n == 1) {
+          // Block file 0's deletion until we've set up the wait thread
+          while (!unblock_file0.load()) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+          }
+        } else if (n == 2) {
+          // Block file 1's deletion to keep pending_files_ > 0
+          while (!unblock_file1.load()) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+          }
+        }
+      });
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
+
+  // Bucket 0: single file
+  std::optional<int32_t> bucket0 = delete_scheduler_->NewTrashBucket();
+  ASSERT_TRUE(bucket0.has_value());
+  std::string file0 =
+      NewDummyFile("bucket_signal_file0.data", 1024, 0, /*track=*/false);
+  ASSERT_OK(delete_scheduler_->DeleteUnaccountedFile(file0, "",
+                                                     /*force_bg=*/false,
+                                                     bucket0));
+
+  // Bucket 1: single file (keeps pending_files_ > 0 when bucket 0 empties)
+  std::optional<int32_t> bucket1 = delete_scheduler_->NewTrashBucket();
+  ASSERT_TRUE(bucket1.has_value());
+  std::string file1 =
+      NewDummyFile("bucket_signal_file1.data", 1024, 0, /*track=*/false);
+  ASSERT_OK(delete_scheduler_->DeleteUnaccountedFile(file1, "",
+                                                     /*force_bg=*/false,
+                                                     bucket1));
+
+  // Wait for the background thread to reach the DeleteFile syncpoint for
+  // file 0. At this point mu_ is NOT held by the background thread.
+  while (delete_calls.load() < 1) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+  }
+
+  // Start waiting for bucket 0 on another thread. Since the background thread
+  // doesn't hold mu_, this thread acquires mu_, sees iter->second == 1,
+  // and enters cv_.Wait() (releasing mu_).
+  std::atomic<bool> wait_done{false};
+  auto wait_future = std::async(std::launch::async, [&]() {
+    delete_scheduler_->WaitForEmptyTrashBucket(bucket0.value());
+    wait_done.store(true);
+  });
+
+  // Give the wait thread time to enter cv_.Wait(). We need it to be blocked
+  // in cv_.Wait() before unblocking the background thread.
+  std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+  // Unblock file 0's deletion. The background thread will:
+  // - Complete DeleteTrashFile, re-acquire mu_
+  // - Decrement pending_files_ (2 -> 1) and bucket0 counter (1 -> 0)
+  // - With bug (post-decrement): pending_files_in_bucket = 1, no signal fired
+  // - With fix (pre-decrement): pending_files_in_bucket = 0, signal fired
+  // Then it moves to file 1 and blocks at the second DeleteFile syncpoint.
+  unblock_file0.store(true);
+
+  // Check if WaitForEmptyTrashBucket returns within 5 seconds.
+  // With the bug: no signal fired, wait thread stays stuck -> timeout
+  // With the fix: signal fired, wait thread wakes up -> completes quickly
+  auto status = wait_future.wait_for(std::chrono::seconds(5));
+  ASSERT_EQ(status, std::future_status::ready)
+      << "WaitForEmptyTrashBucket(bucket0) timed out - bucket signal not fired";
+
+  // Unblock file 1 and wait for bucket 1
+  unblock_file1.store(true);
+  delete_scheduler_->WaitForEmptyTrashBucket(bucket1.value());
+
+  ASSERT_EQ(0, delete_scheduler_->GetTotalTrashSize());
+  ASSERT_GE(delete_calls.load(), 2);
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
+}
+
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

package/deps/rocksdb/rocksdb/file/file_prefetch_buffer.cc

@@ -160,6 +160,18 @@ Status FilePrefetchBuffer::ReadAsync(BufferInfo* buf, const IOOptions& opts,
       RecordTick(stats_, PREFETCH_BYTES, read_len);
     }
     buf->async_read_in_progress_ = true;
+  } else if (s.IsNotSupported()) {
+    // Async IO is not available (e.g., io_uring failed to initialize).
+    // Fall back to synchronous read so the buffer is populated inline
+    // and callers proceed transparently.
+    s = reader->Read(opts, start_offset, read_len, &result,
+                     buf->buffer_.BufferStart(), /*aligned_buf=*/nullptr);
+    if (s.ok()) {
+      buf->buffer_.Size(buf->CurrentSize() + result.size());
+      if (usage_ == FilePrefetchBufferUsage::kUserScanPrefetch) {
+        RecordTick(stats_, PREFETCH_BYTES, read_len);
+      }
+    }
   }
   return s;
 }
@@ -351,7 +363,7 @@ void FilePrefetchBuffer::ClearOutdatedData(uint64_t offset, size_t length) {
   assert(IsBufferQueueEmpty() || buf->IsOffsetInBuffer(offset));
 }
 
-void FilePrefetchBuffer::PollIfNeeded(uint64_t offset, size_t length) {
+Status FilePrefetchBuffer::PollIfNeeded(uint64_t offset, size_t length) {
   BufferInfo* buf = GetFirstBuffer();
 
   if (buf->async_read_in_progress_ && fs_ != nullptr) {
@@ -362,7 +374,16 @@ void FilePrefetchBuffer::PollIfNeeded(uint64_t offset, size_t length) {
       std::vector<void*> handles;
       handles.emplace_back(buf->io_handle_);
       StopWatch sw(clock_, stats_, POLL_WAIT_MICROS);
-      fs_->Poll(handles, 1).PermitUncheckedError();
+      IOStatus io_s = fs_->Poll(handles, 1);
+      // Allow tests to inject Poll errors
+      TEST_SYNC_POINT_CALLBACK("FilePrefetchBuffer::PollIfNeeded:IOStatus",
+                               &io_s);
+      if (!io_s.ok()) {
+        // On Poll failure, clean up the handle and abort.
+        // DestroyAndClearIOHandle also sets async_read_in_progress_ to false.
+        DestroyAndClearIOHandle(buf);
+        return io_s;
+      }
     }
 
     // Reset and Release io_handle after the Poll API as request has been
@@ -373,6 +394,7 @@ void FilePrefetchBuffer::PollIfNeeded(uint64_t offset, size_t length) {
   // Always call outdated data after Poll as Buffers might be out of sync w.r.t
   // offset and length.
   ClearOutdatedData(offset, length);
+  return Status::OK();
 }
 
 // ReadAheadSizeTuning API calls readaheadsize_cb_
@@ -511,7 +533,10 @@ Status FilePrefetchBuffer::HandleOverlappingAsyncData(
   // by Seek, but the next access is at another offset.
   if (buf->async_read_in_progress_ &&
       buf->IsOffsetInBufferWithAsyncProgress(offset)) {
-    PollIfNeeded(offset, length);
+    Status poll_status = PollIfNeeded(offset, length);
+    if (!poll_status.ok()) {
+      return poll_status;
+    }
   }
 
   if (IsBufferQueueEmpty() || NumBuffersAllocated() == 1) {
@@ -646,7 +671,10 @@ Status FilePrefetchBuffer::PrefetchInternal(const IOOptions& opts,
       return s;
     }
   } else {
-    PollIfNeeded(tmp_offset, tmp_length);
+    Status poll_status = PollIfNeeded(tmp_offset, tmp_length);
+    if (!poll_status.ok()) {
+      return poll_status;
+    }
   }
 
   AllocateBufferIfEmpty();

package/deps/rocksdb/rocksdb/file/file_prefetch_buffer.h

@@ -93,8 +93,8 @@ struct BufferInfo {
   //
   // For example - if end offset of previous buffer was 100 and because of
   // readahead_size optimization, end_offset was trimmed to 60. Then for next
-  // prefetch call, start_offset should be intialized to 100 i.e  start_offset =
-  // buf->initial_end_offset_.
+  // prefetch call, start_offset should be initialized to 100 i.e  start_offset
+  // = buf->initial_end_offset_.
   uint64_t initial_end_offset_ = 0;
 
   bool IsDataBlockInBuffer(uint64_t offset, size_t length) {
@@ -155,7 +155,7 @@ enum class FilePrefetchBufferUsage {
 // When reusing the file system allocated buffer, overlap_buf_ is used if the
 // main buffer only contains part of the requested data. It is returned to
 // the caller after the remaining data is fetched.
-// If num_buffers_ > 1, then the data is prefetched asynchronosuly in the
+// If num_buffers_ > 1, then the data is prefetched asynchronously in the
 // buffers whenever the data is consumed from the buffers and that buffer is
 // freed.
 // If num_buffers > 1, then requested data can be overlapping between 2 buffers.
@@ -431,7 +431,7 @@ class FilePrefetchBuffer {
   void ClearOutdatedData(uint64_t offset, size_t len);
 
   // It calls Poll API to check for any pending asynchronous request.
-  void PollIfNeeded(uint64_t offset, size_t len);
+  Status PollIfNeeded(uint64_t offset, size_t len);
 
   Status PrefetchInternal(const IOOptions& opts, RandomAccessFileReader* reader,
                           uint64_t offset, size_t length, size_t readahead_size,

package/deps/rocksdb/rocksdb/file/file_util.cc

@@ -178,7 +178,8 @@ IOStatus GenerateOneFileChecksum(
     std::string* file_checksum_func_name,
     size_t verify_checksums_readahead_size, bool /*allow_mmap_reads*/,
     std::shared_ptr<IOTracer>& io_tracer, RateLimiter* rate_limiter,
-    const ReadOptions& read_options, Statistics* stats, SystemClock* clock) {
+    const ReadOptions& read_options, Statistics* stats, SystemClock* clock,
+    const FileOptions& file_options) {
   if (checksum_factory == nullptr) {
     return IOStatus::InvalidArgument("Checksum factory is invalid");
   }
@@ -218,7 +219,12 @@ IOStatus GenerateOneFileChecksum(
   std::unique_ptr<RandomAccessFileReader> reader;
   {
     std::unique_ptr<FSRandomAccessFile> r_file;
-    io_s = fs->NewRandomAccessFile(file_path, FileOptions(), &r_file, nullptr);
+    FileOptions fopts = file_options;
+    if (fopts.file_checksum.empty()) {
+      // No expected checksum is known — this is a from-scratch computation.
+      fopts.file_checksum_func_name = kNoFileChecksumFuncName;
+    }
+    io_s = fs->NewRandomAccessFile(file_path, fopts, &r_file, nullptr);
     if (!io_s.ok()) {
       return io_s;
     }

package/deps/rocksdb/rocksdb/file/file_util.h

@@ -83,7 +83,8 @@ IOStatus GenerateOneFileChecksum(
     std::string* file_checksum_func_name,
     size_t verify_checksums_readahead_size, bool allow_mmap_reads,
     std::shared_ptr<IOTracer>& io_tracer, RateLimiter* rate_limiter,
-    const ReadOptions& read_options, Statistics* stats, SystemClock* clock);
+    const ReadOptions& read_options, Statistics* stats, SystemClock* clock,
+    const FileOptions& file_options);
 
 inline IOStatus PrepareIOFromReadOptions(const ReadOptions& ro,
                                          SystemClock* clock, IOOptions& opts,