@nxtedition/rocksdb 15.4.1 → 16.0.0

package/deps/rocksdb/rocksdb/file/prefetch_test.cc

@@ -669,7 +669,7 @@ TEST_P(PrefetchTest, ConfigureAutoMaxReadaheadSize) {
     MoveFilesToLevel(level);
   }
   Close();
-  std::vector<int> buff_prefectch_level_count = {0, 0, 0};
+  std::vector<int> buff_prefetch_level_count = {0, 0, 0};
   ASSERT_OK(TryReopen(options));
   {
     auto iter = std::unique_ptr<Iterator>(db_->NewIterator(ReadOptions()));
@@ -707,7 +707,7 @@ TEST_P(PrefetchTest, ConfigureAutoMaxReadaheadSize) {
         iter->Next();
       }
 
-      buff_prefectch_level_count[level] = buff_prefetch_count;
+      buff_prefetch_level_count[level] = buff_prefetch_count;
       if (support_prefetch && !use_direct_io) {
         if (level == 0) {
           ASSERT_FALSE(fs->IsPrefetchCalled());
@@ -728,7 +728,7 @@ TEST_P(PrefetchTest, ConfigureAutoMaxReadaheadSize) {
   }
 
   if (!support_prefetch) {
-    ASSERT_GT(buff_prefectch_level_count[1], buff_prefectch_level_count[2]);
+    ASSERT_GT(buff_prefetch_level_count[1], buff_prefetch_level_count[2]);
   }
 
   SyncPoint::GetInstance()->DisableProcessing();
@@ -814,7 +814,7 @@ TEST_P(PrefetchTest, ConfigureInternalAutoReadaheadSize) {
                                       "{initial_auto_readahead_size=0;}"}}));
           break;
         case 1:
-          // intial_auto_readahead_size and max_auto_readahead_size are set
+          // initial_auto_readahead_size and max_auto_readahead_size are set
           // same so readahead_size remains same.
           ASSERT_OK(db_->SetOptions({{"block_based_table_factory",
                                       "{initial_auto_readahead_size=4096;max_"
@@ -1081,7 +1081,7 @@ TEST_P(PrefetchTest, PrefetchWhenReseek) {
   }
   {
     /*
-     * Reesek keys from Single Data Block.
+     * Reseek keys from Single Data Block.
      */
     auto iter = std::unique_ptr<Iterator>(db_->NewIterator(ReadOptions()));
     iter->Seek(BuildKey(0));
@@ -1116,9 +1116,8 @@ TEST_P(PrefetchTest, PrefetchWhenReseek) {
     ASSERT_TRUE(iter->Valid());
     iter->Seek(BuildKey(1008));
     ASSERT_TRUE(iter->Valid());
-    iter->Seek(
-        BuildKey(996));  // Reseek won't prefetch any data and
-                         // readahead_size will be initiallized to 8*1024.
+    iter->Seek(BuildKey(996));  // Reseek won't prefetch any data and
+                                // readahead_size will be initialized to 8*1024.
     ASSERT_TRUE(iter->Valid());
     iter->Seek(BuildKey(992));
     ASSERT_TRUE(iter->Valid());
@@ -1590,7 +1589,7 @@ INSTANTIATE_TEST_CASE_P(
     ::testing::Combine(
         // Params are as follows -
         // Param 0 - TableOptions::index_shortening
-        // Param 2 - ReadOptinos::auto_readahead_size
+        // Param 2 - ReadOptions::auto_readahead_size
         ::testing::Values(
             BlockBasedTableOptions::IndexShorteningMode::kNoShortening,
             BlockBasedTableOptions::IndexShorteningMode::kShortenSeparators,
@@ -2518,6 +2517,187 @@ TEST_P(PrefetchTest1, SeekParallelizationTest) {
   Close();
 }
 
+TEST_P(PrefetchTest1, PollErrorRecoveryDuringIteration) {
+  // This end-to-end test verifies that Poll() errors during async prefetching
+  // are properly propagated to the iterator. When Poll() fails, the iterator
+  // should stop and return an IOError status.
+  //
+  // With error injection on the 3rd Poll call, the iterator reads ~231 keys
+  // (out of 500) before encountering the error.
+
+  if (mem_env_ || encrypted_env_) {
+    ROCKSDB_GTEST_SKIP("Test requires non-mem or non-encrypted environment");
+    return;
+  }
+
+  const int kNumKeys = 500;
+  std::shared_ptr<MockFS> fs = std::make_shared<MockFS>(
+      FileSystem::Default(), /*support_prefetch=*/false);
+  std::unique_ptr<Env> env(new CompositeEnvWrapper(env_, fs));
+
+  bool use_direct_io = GetParam();
+  Options options;
+  SetGenericOptions(env.get(), use_direct_io, options);
+  options.statistics = CreateDBStatistics();
+  BlockBasedTableOptions table_options;
+  SetBlockBasedTableOptions(table_options);
+  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+
+  Status s = TryReopen(options);
+  if (use_direct_io && (s.IsNotSupported() || s.IsInvalidArgument())) {
+    ROCKSDB_GTEST_SKIP("Direct IO not supported");
+    return;
+  }
+  ASSERT_OK(s);
+
+  // Write keys with known values so we can verify correctness
+  std::map<std::string, std::string> expected_data;
+  {
+    WriteBatch batch;
+    for (int i = 0; i < kNumKeys; i++) {
+      std::string key = BuildKey(i);
+      std::string value = "value_" + std::to_string(i) + "_" +
+                          std::string(100, 'x');  // Make values ~110 bytes
+      ASSERT_OK(batch.Put(key, value));
+      expected_data[key] = value;
+    }
+    ASSERT_OK(db_->Write(WriteOptions(), &batch));
+    ASSERT_OK(Flush());
+  }
+
+  std::string start_key = BuildKey(0);
+  std::string end_key = BuildKey(kNumKeys - 1);
+  Slice least(start_key.data(), start_key.size());
+  Slice greatest(end_key.data(), end_key.size());
+  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), &least, &greatest));
+
+  // Set up callbacks to track async IO and inject Poll errors
+  std::atomic<int> poll_call_count{0};
+  std::atomic<int> poll_error_injected_count{0};
+  bool read_async_called = false;
+
+  SyncPoint::GetInstance()->SetCallBack(
+      "FilePrefetchBuffer::PollIfNeeded:IOStatus", [&](void* arg) {
+        poll_call_count++;
+        int current_count = poll_call_count.load();
+
+        // Inject error on the third Poll call to allow some keys to be read
+        // first
+        if (current_count == 3) {
+          IOStatus* io_s = static_cast<IOStatus*>(arg);
+          *io_s = IOStatus::IOError("Injected Poll error for e2e testing");
+          poll_error_injected_count++;
+          std::cout << "PollErrorRecoveryDuringIteration: Injected error on "
+                       "Poll call #"
+                    << current_count << std::endl;
+        }
+      });
+
+  SyncPoint::GetInstance()->SetCallBack(
+      "UpdateResults::io_uring_result",
+      [&](void* /*arg*/) { read_async_called = true; });
+
+  SyncPoint::GetInstance()->EnableProcessing();
+
+  // Iterate through all keys with async IO enabled
+  ReadOptions ro;
+  ro.async_io = true;
+  ro.adaptive_readahead = true;
+
+  int keys_read = 0;
+  int data_mismatches = 0;
+  Status iter_status;
+  {
+    auto iter = std::unique_ptr<Iterator>(db_->NewIterator(ro));
+    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
+      std::string key = iter->key().ToString();
+      std::string value = iter->value().ToString();
+
+      auto it = expected_data.find(key);
+      if (it == expected_data.end()) {
+        std::cout << "PollErrorRecoveryDuringIteration: Unexpected key: " << key
+                  << std::endl;
+        data_mismatches++;
+      } else if (it->second != value) {
+        std::cout << "PollErrorRecoveryDuringIteration: Value mismatch for key "
+                  << key << std::endl;
+        data_mismatches++;
+      }
+      keys_read++;
+    }
+    iter_status = iter->status();
+  }
+
+  SyncPoint::GetInstance()->DisableProcessing();
+  SyncPoint::GetInstance()->ClearAllCallBacks();
+
+  // Log results
+  std::cout << "PollErrorRecoveryDuringIteration: " << "read_async_called="
+            << read_async_called << ", poll_calls=" << poll_call_count.load()
+            << ", poll_errors_injected=" << poll_error_injected_count.load()
+            << ", keys_read=" << keys_read << ", expected_keys=" << kNumKeys
+            << ", data_mismatches=" << data_mismatches
+            << ", iter_status=" << iter_status.ToString() << std::endl;
+
+  // Verify no data mismatches occurred for keys that were read
+  ASSERT_EQ(data_mismatches, 0)
+      << "Found " << data_mismatches << " data mismatches";
+
+  if (read_async_called) {
+    // Async IO was used - verify Poll error was injected and propagated
+    ASSERT_EQ(poll_call_count.load(), 3)
+        << "Expected exactly 3 Poll calls when error injected on 3rd call";
+    ASSERT_EQ(poll_error_injected_count.load(), 1)
+        << "Expected exactly 1 Poll error to be injected";
+
+    // The iterator should have stopped with an error status
+    ASSERT_TRUE(iter_status.IsIOError())
+        << "Expected iterator to report IOError after Poll failure, got: "
+        << iter_status.ToString();
+
+    std::cout << "PollErrorRecoveryDuringIteration: Successfully verified "
+                 "Poll error was injected and propagated to iterator"
+              << std::endl;
+  } else {
+    // Async IO not supported - iterator should complete successfully
+    ASSERT_OK(iter_status);
+    ASSERT_EQ(keys_read, kNumKeys);
+    std::cout << "PollErrorRecoveryDuringIteration: Async IO (io_uring) not "
+                 "supported on this platform, verified data correctness"
+              << std::endl;
+  }
+
+  // Retry iteration without error injection - verify all data is still readable
+  // This confirms the Poll error didn't corrupt state
+  {
+    int retry_keys_read = 0;
+    int retry_data_mismatches = 0;
+    auto iter = std::unique_ptr<Iterator>(db_->NewIterator(ro));
+    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
+      std::string key = iter->key().ToString();
+      std::string value = iter->value().ToString();
+
+      auto it = expected_data.find(key);
+      if (it == expected_data.end()) {
+        retry_data_mismatches++;
+      } else if (it->second != value) {
+        retry_data_mismatches++;
+      }
+      retry_keys_read++;
+    }
+    ASSERT_OK(iter->status())
+        << "Retry iteration failed: " << iter->status().ToString();
+    ASSERT_EQ(retry_keys_read, kNumKeys)
+        << "Retry should read all " << kNumKeys << " keys";
+    ASSERT_EQ(retry_data_mismatches, 0)
+        << "Retry found " << retry_data_mismatches << " data mismatches";
+    std::cout << "PollErrorRecoveryDuringIteration: Retry succeeded, read all "
+              << retry_keys_read << " keys correctly" << std::endl;
+  }
+
+  Close();
+}
+
 namespace {
 #ifdef GFLAGS
 const int kMaxArgCount = 100;
@@ -3041,7 +3221,11 @@ class FilePrefetchBufferTest : public testing::Test {
     stats_ = CreateDBStatistics();
   }
 
-  void TearDown() override { EXPECT_OK(DestroyDir(env_, test_dir_)); }
+  void TearDown() override {
+    SyncPoint::GetInstance()->DisableProcessing();
+    SyncPoint::GetInstance()->ClearAllCallBacks();
+    EXPECT_OK(DestroyDir(env_, test_dir_));
+  }
 
   void Write(const std::string& fname, const std::string& content) {
     std::unique_ptr<FSWritableFile> f;
@@ -3303,7 +3487,7 @@ TEST_F(FilePrefetchBufferTest, SyncReadaheadStats) {
   ASSERT_EQ(stats->getAndResetTickerCount(PREFETCH_HITS), 1);
   ASSERT_EQ(stats->getAndResetTickerCount(PREFETCH_BYTES_USEFUL), 8192);
 
-  // Now read some data with length doesn't align with aligment and it needs
+  // Now read some data with length doesn't align with alignment and it needs
   // prefetching. Read from 16000 with length 10000 (i.e. requested end offset -
   // 26000).
   ASSERT_TRUE(
@@ -3377,6 +3561,118 @@ TEST_F(FilePrefetchBufferTest, ForCompaction) {
       0);
 }
 
+TEST_F(FilePrefetchBufferTest, PollErrorPropagation) {
+  // This test verifies that Poll() errors in PollIfNeeded are properly
+  // propagated rather than being silently ignored.
+
+  std::string fname = "poll-error-test";
+  Random rand(0);
+  std::string content = rand.RandomString(32768);
+  Write(fname, content);
+
+  FileOptions opts;
+  std::unique_ptr<RandomAccessFileReader> r;
+  Read(fname, opts, &r);
+
+  // Set up readahead params for async prefetching
+  ReadaheadParams readahead_params;
+  readahead_params.initial_readahead_size = 16384;
+  readahead_params.max_readahead_size = 16384;
+
+  FilePrefetchBuffer fpb(readahead_params, /*enable=*/true,
+                         /*track_min_offset=*/false, fs());
+
+  Slice result;
+  // Start an async prefetch to set up async_read_in_progress_ state
+  Status s = fpb.PrefetchAsync(IOOptions(), r.get(), 0, 4096, &result);
+
+  // Skip test on platforms that don't support async IO.
+  if (s.IsNotSupported()) {
+    ROCKSDB_GTEST_SKIP("Async IO not supported on this platform");
+    return;
+  }
+  ASSERT_TRUE(s.IsTryAgain());
+
+  // With the ReadAsync sync fallback, PrefetchAsync returns TryAgain even when
+  // async IO is unavailable (data is read synchronously, but data_found was
+  // false at entry). Detect by checking async_read_in_progress_ on the buffer.
+  {
+    std::vector<std::tuple<uint64_t, size_t, bool>> buf_info(1);
+    fpb.TEST_GetBufferOffsetandSize(buf_info);
+    bool async_read_in_progress = std::get<2>(buf_info[0]);
+    if (!async_read_in_progress) {
+      ROCKSDB_GTEST_SKIP("Async IO not available (sync fallback used)");
+      return;
+    }
+  }
+
+  // Set up SyncPoint to inject Poll error
+  SyncPoint::GetInstance()->SetCallBack(
+      "FilePrefetchBuffer::PollIfNeeded:IOStatus", [&](void* arg) {
+        IOStatus* io_s = static_cast<IOStatus*>(arg);
+        *io_s = IOStatus::IOError("Injected Poll error for testing");
+      });
+  SyncPoint::GetInstance()->EnableProcessing();
+
+  // TryReadFromCache will call PollIfNeeded to complete the async read
+  IOOptions io_opts;
+  io_opts.rate_limiter_priority = Env::IOPriority::IO_LOW;
+  Status read_status;
+  bool found =
+      fpb.TryReadFromCache(io_opts, r.get(), 0, 4096, &result, &read_status);
+
+  // When PollIfNeeded fails:
+  // 1. PrefetchInternal returns the error status
+  // 2. TryReadFromCacheUntracked sets *status to the error and returns false
+  // Therefore: found should be false, and read_status should contain the error
+  ASSERT_FALSE(found) << "Expected TryReadFromCache to return false on Poll "
+                         "error, but it returned true";
+  ASSERT_TRUE(read_status.IsIOError())
+      << "Expected IOError status, got: " << read_status.ToString();
+  ASSERT_TRUE(read_status.ToString().find("Injected Poll error") !=
+              std::string::npos)
+      << "Expected error message to contain 'Injected Poll error', got: "
+      << read_status.ToString();
+
+  SyncPoint::GetInstance()->DisableProcessing();
+  SyncPoint::GetInstance()->ClearAllCallBacks();
+}
+
+TEST_F(FilePrefetchBufferTest, ReadAsyncSyncFallbackOnNotSupported) {
+  std::string fname = "read-async-sync-fallback";
+  Random rand(0);
+  std::string content = rand.RandomString(32768);
+  Write(fname, content);
+
+  FileOptions opts;
+  std::unique_ptr<RandomAccessFileReader> r;
+  Read(fname, opts, &r);
+
+  SyncPoint::GetInstance()->SetCallBack(
+      "RandomAccessFileReader::ReadAsync:InjectStatus", [](void* arg) {
+        *static_cast<IOStatus*>(arg) = IOStatus::NotSupported();
+      });
+  SyncPoint::GetInstance()->EnableProcessing();
+
+  ReadaheadParams readahead_params;
+  readahead_params.initial_readahead_size = 16384;
+  readahead_params.max_readahead_size = 16384;
+  readahead_params.num_buffers = 2;
+
+  FilePrefetchBuffer fpb(readahead_params, /*enable=*/true,
+                         /*track_min_offset=*/false, fs());
+
+  Slice result;
+  Status s;
+  ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 0, 4096, &result, &s));
+  ASSERT_OK(s);
+  ASSERT_EQ(result.size(), 4096);
+  ASSERT_EQ(memcmp(result.data(), content.data(), 4096), 0);
+
+  SyncPoint::GetInstance()->DisableProcessing();
+  SyncPoint::GetInstance()->ClearAllCallBacks();
+}
+
 class FSBufferPrefetchTest
     : public testing::Test,
       public ::testing::WithParamInterface<std::tuple<bool, bool>> {
@@ -3455,7 +3751,11 @@ class FSBufferPrefetchTest
     stats_ = CreateDBStatistics();
   }
 
-  void TearDown() override { EXPECT_OK(DestroyDir(env_, test_dir_)); }
+  void TearDown() override {
+    SyncPoint::GetInstance()->DisableProcessing();
+    SyncPoint::GetInstance()->ClearAllCallBacks();
+    EXPECT_OK(DestroyDir(env_, test_dir_));
+  }
 
   void Write(const std::string& fname, const std::string& content) {
     std::unique_ptr<FSWritableFile> f;
@@ -3542,6 +3842,9 @@ TEST_P(FSBufferPrefetchTest, FSBufferPrefetchStatsInternals) {
       fpb.TryReadFromCache(IOOptions(), r.get(), 0 /* offset */, 4096 /* n */,
                            &result, &s, for_compaction);
   // Platforms that don't have IO uring may not support async IO.
+  // With the ReadAsync sync fallback, s will be OK even when async IO is
+  // unavailable — detect by checking if the second buffer has an async read
+  // in progress.
   if (use_async_prefetch && s.IsNotSupported()) {
     return;
   }
@@ -3555,6 +3858,14 @@ TEST_P(FSBufferPrefetchTest, FSBufferPrefetchStatsInternals) {
   fpb.TEST_GetOverlapBufferOffsetandSize(overlap_buffer_info);
   fpb.TEST_GetBufferOffsetandSize(buffer_info);
   if (use_async_prefetch) {
+    bool async_read_in_progress = std::get<2>(buffer_info[1]);
+    if (!async_read_in_progress) {
+      // Async IO was requested but not available (e.g., no io_uring).
+      // ReadAsync fell back to sync read. Skip async-specific assertions.
+      SyncPoint::GetInstance()->DisableProcessing();
+      SyncPoint::GetInstance()->ClearAllCallBacks();
+      return;
+    }
     // Cut the readahead of 8192 in half.
     // Overlap buffer is not used
     ASSERT_EQ(overlap_buffer_info.first, 0);
@@ -3747,6 +4058,14 @@ TEST_P(FSBufferPrefetchTest, FSBufferPrefetchUnalignedReads) {
   fpb.TEST_GetOverlapBufferOffsetandSize(overlap_buffer_info);
   fpb.TEST_GetBufferOffsetandSize(buffer_info);
   if (use_async_prefetch) {
+    bool async_read_in_progress = std::get<2>(buffer_info[1]);
+    if (!async_read_in_progress) {
+      // Async IO was requested but not available (e.g., no io_uring).
+      // ReadAsync fell back to sync read. Skip async-specific assertions.
+      SyncPoint::GetInstance()->DisableProcessing();
+      SyncPoint::GetInstance()->ClearAllCallBacks();
+      return;
+    }
     // Overlap buffer is not used
     ASSERT_EQ(overlap_buffer_info.first, 0);
     ASSERT_EQ(overlap_buffer_info.second, 0);

package/deps/rocksdb/rocksdb/file/random_access_file_reader.cc

@@ -66,41 +66,53 @@ inline void RecordIOStats(Statistics* stats, Temperature file_temperature,
   }
 
   // record for temperature file
-  if (file_temperature != Temperature::kUnknown) {
-    switch (file_temperature) {
-      case Temperature::kHot:
-        IOSTATS_ADD(file_io_stats_by_temperature.hot_file_bytes_read, size);
-        IOSTATS_ADD(file_io_stats_by_temperature.hot_file_read_count, 1);
-        RecordTick(stats, HOT_FILE_READ_BYTES, size);
-        RecordTick(stats, HOT_FILE_READ_COUNT, 1);
-        break;
-      case Temperature::kWarm:
-        IOSTATS_ADD(file_io_stats_by_temperature.warm_file_bytes_read, size);
-        IOSTATS_ADD(file_io_stats_by_temperature.warm_file_read_count, 1);
-        RecordTick(stats, WARM_FILE_READ_BYTES, size);
-        RecordTick(stats, WARM_FILE_READ_COUNT, 1);
-        break;
-      case Temperature::kCool:
-        IOSTATS_ADD(file_io_stats_by_temperature.cool_file_bytes_read, size);
-        IOSTATS_ADD(file_io_stats_by_temperature.cool_file_read_count, 1);
-        RecordTick(stats, COOL_FILE_READ_BYTES, size);
-        RecordTick(stats, COOL_FILE_READ_COUNT, 1);
-        break;
-      case Temperature::kCold:
-        IOSTATS_ADD(file_io_stats_by_temperature.cold_file_bytes_read, size);
-        IOSTATS_ADD(file_io_stats_by_temperature.cold_file_read_count, 1);
-        RecordTick(stats, COLD_FILE_READ_BYTES, size);
-        RecordTick(stats, COLD_FILE_READ_COUNT, 1);
-        break;
-      case Temperature::kIce:
-        IOSTATS_ADD(file_io_stats_by_temperature.ice_file_bytes_read, size);
-        IOSTATS_ADD(file_io_stats_by_temperature.ice_file_read_count, 1);
-        RecordTick(stats, ICE_FILE_READ_BYTES, size);
-        RecordTick(stats, ICE_FILE_READ_COUNT, 1);
-        break;
-      default:
-        break;
-    }
+  switch (file_temperature) {
+    case Temperature::kHot:
+      IOSTATS_ADD(file_io_stats_by_temperature.hot_file_bytes_read, size);
+      IOSTATS_ADD(file_io_stats_by_temperature.hot_file_read_count, 1);
+      RecordTick(stats, HOT_FILE_READ_BYTES, size);
+      RecordTick(stats, HOT_FILE_READ_COUNT, 1);
+      break;
+    case Temperature::kWarm:
+      IOSTATS_ADD(file_io_stats_by_temperature.warm_file_bytes_read, size);
+      IOSTATS_ADD(file_io_stats_by_temperature.warm_file_read_count, 1);
+      RecordTick(stats, WARM_FILE_READ_BYTES, size);
+      RecordTick(stats, WARM_FILE_READ_COUNT, 1);
+      break;
+    case Temperature::kCool:
+      IOSTATS_ADD(file_io_stats_by_temperature.cool_file_bytes_read, size);
+      IOSTATS_ADD(file_io_stats_by_temperature.cool_file_read_count, 1);
+      RecordTick(stats, COOL_FILE_READ_BYTES, size);
+      RecordTick(stats, COOL_FILE_READ_COUNT, 1);
+      break;
+    case Temperature::kCold:
+      IOSTATS_ADD(file_io_stats_by_temperature.cold_file_bytes_read, size);
+      IOSTATS_ADD(file_io_stats_by_temperature.cold_file_read_count, 1);
+      RecordTick(stats, COLD_FILE_READ_BYTES, size);
+      RecordTick(stats, COLD_FILE_READ_COUNT, 1);
+      break;
+    case Temperature::kIce:
+      IOSTATS_ADD(file_io_stats_by_temperature.ice_file_bytes_read, size);
+      IOSTATS_ADD(file_io_stats_by_temperature.ice_file_read_count, 1);
+      RecordTick(stats, ICE_FILE_READ_BYTES, size);
+      RecordTick(stats, ICE_FILE_READ_COUNT, 1);
+      break;
+    case Temperature::kUnknown:
+      if (is_last_level) {
+        IOSTATS_ADD(file_io_stats_by_temperature.unknown_last_level_bytes_read,
+                    size);
+        IOSTATS_ADD(file_io_stats_by_temperature.unknown_last_level_read_count,
+                    1);
+      } else {
+        IOSTATS_ADD(
+            file_io_stats_by_temperature.unknown_non_last_level_bytes_read,
+            size);
+        IOSTATS_ADD(
+            file_io_stats_by_temperature.unknown_non_last_level_read_count, 1);
+      }
+      break;
+    default:
+      break;
   }
 }
 
@@ -516,6 +528,11 @@ IOStatus RandomAccessFileReader::ReadAsync(
     void** io_handle, IOHandleDeleter* del_fn, AlignedBuf* aligned_buf,
     IODebugContext* dbg) {
   IOStatus s;
+  TEST_SYNC_POINT_CALLBACK("RandomAccessFileReader::ReadAsync:InjectStatus",
+                           &s);
+  if (!s.ok()) {
+    return s;
+  }
   // Create a callback and populate info.
   auto read_async_callback =
       std::bind(&RandomAccessFileReader::ReadAsyncCallback, this,

package/deps/rocksdb/rocksdb/folly.mk

@@ -47,13 +47,13 @@ ifneq ($(strip $(FOLLY_PATH)),)
 	# Add -ldl at the end as gcc resolves a symbol in a library by searching only in libraries specified later
 	# in the command line
 
-	PLATFORM_LDFLAGS += $(FOLLY_PATH)/lib/libfolly.a $(BOOST_PATH)/lib/libboost_context.a $(BOOST_PATH)/lib/libboost_filesystem.a $(BOOST_PATH)/lib/libboost_atomic.a $(BOOST_PATH)/lib/libboost_program_options.a $(BOOST_PATH)/lib/libboost_regex.a $(BOOST_PATH)/lib/libboost_system.a $(BOOST_PATH)/lib/libboost_thread.a $(DBL_CONV_PATH)/lib/libdouble-conversion.a $(LIBEVENT_PATH)/lib/libevent-2.1.so $(LIBSODIUM_PATH)/lib/libsodium.a -ldl
+	PLATFORM_LDFLAGS += $(FOLLY_PATH)/lib/libfolly.a $(BOOST_PATH)/lib/libboost_context.a $(BOOST_PATH)/lib/libboost_filesystem.a $(BOOST_PATH)/lib/libboost_atomic.a $(BOOST_PATH)/lib/libboost_program_options.a $(BOOST_PATH)/lib/libboost_regex.a $(BOOST_PATH)/lib/libboost_system.a $(BOOST_PATH)/lib/libboost_thread.a $(DBL_CONV_PATH)/lib/libdouble-conversion.a $(LIBEVENT_PATH)/lib/libevent.a $(LIBSODIUM_PATH)/lib/libsodium.a -ldl
 ifneq ($(DEBUG_LEVEL),0)
 	PLATFORM_LDFLAGS += $(FMT_LIB_PATH)/libfmtd.a $(GLOG_LIB_PATH)/libglogd.so $(GFLAGS_PATH)/lib/libgflags_debug.so.2.2
 else
 	PLATFORM_LDFLAGS += $(FMT_LIB_PATH)/libfmt.a $(GLOG_LIB_PATH)/libglog.so $(GFLAGS_PATH)/lib/libgflags.so.2.2
 endif
-	PLATFORM_LDFLAGS += -Wl,-rpath=$(LIBEVENT_PATH)/lib -Wl,-rpath=$(GLOG_LIB_PATH) -Wl,-rpath=$(GFLAGS_PATH)/lib
+	PLATFORM_LDFLAGS += -Wl,-rpath=$(GLOG_LIB_PATH) -Wl,-rpath=$(GFLAGS_PATH)/lib
 endif
 	PLATFORM_CCFLAGS += -DUSE_FOLLY -DFOLLY_NO_CONFIG
 	PLATFORM_CXXFLAGS += -DUSE_FOLLY -DFOLLY_NO_CONFIG
@@ -98,7 +98,7 @@ endif  # FMT_SOURCE_PATH
 	PLATFORM_LDFLAGS += -lglog
 endif
 
-FOLLY_COMMIT_HASH = abe68f7e917e8b7a0ee2fe066c972dc98fd35aa1
+FOLLY_COMMIT_HASH = 3b0eed0a128c484a2b077546c3e08c824a311357
 
 # For public CI runs, checkout folly in a way that can build with RocksDB.
 # This is mostly intended as a test-only simulation of Meta-internal folly
@@ -116,10 +116,27 @@ checkout_folly:
 	perl -pi -e 's/(#include <atomic>)/$$1\n#include <cstring>/' third-party/folly/folly/lang/Exception.h
 	@# const mismatch
 	perl -pi -e 's/: environ/: (const char**)(environ)/' third-party/folly/folly/Subprocess.cpp
-	@# Use gnu.org mirrors to improve download speed (ftp.gnu.org is often super slow)
-	cd third-party/folly && perl -pi -e 's/ftp.gnu.org/ftpmirror.gnu.org/' `git grep -l ftp.gnu.org` README.md
+	@# Restore cached downloads and handle unreliable mirrors with fallback
+	@cd third-party/folly && \
+		DOWNLOAD_DIR=`$(PYTHON) build/fbcode_builder/getdeps.py show-inst-dir | sed 's|/installed/.*|/downloads|'` && \
+		mkdir -p "$$DOWNLOAD_DIR" && \
+		CACHE_DIR="/tmp/rocksdb-getdeps-cache" && \
+		mkdir -p "$$CACHE_DIR" && \
+		echo "Restoring cached downloads..." && \
+		if ls "$$CACHE_DIR"/*.tar.gz "$$CACHE_DIR"/*.tar.xz "$$CACHE_DIR"/*.zip >/dev/null 2>&1; then \
+			cp -n "$$CACHE_DIR"/*.tar.gz "$$CACHE_DIR"/*.tar.xz "$$CACHE_DIR"/*.zip "$$DOWNLOAD_DIR/" 2>/dev/null || true; \
+		fi && \
+		echo "Handling known unreliable downloads with fallback mirrors..." && \
+		$(PYTHON) ../../build_tools/getdeps_fallback_mirror.py "$$DOWNLOAD_DIR" "$$CACHE_DIR" build/fbcode_builder/manifests
 	@# NOTE: boost and fmt source will be needed for any build including `USE_FOLLY_LITE` builds as those depend on those headers
 	cd third-party/folly && GETDEPS_USE_WGET=1 $(PYTHON) build/fbcode_builder/getdeps.py fetch boost && GETDEPS_USE_WGET=1 $(PYTHON) build/fbcode_builder/getdeps.py fetch fmt
+	@# Update cache with any new downloads
+	@cd third-party/folly && \
+		DOWNLOAD_DIR=`$(PYTHON) build/fbcode_builder/getdeps.py show-inst-dir | sed 's|/installed/.*|/downloads|'` && \
+		CACHE_DIR="/tmp/rocksdb-getdeps-cache" && \
+		if ls "$$DOWNLOAD_DIR"/*.tar.gz "$$DOWNLOAD_DIR"/*.tar.xz "$$DOWNLOAD_DIR"/*.zip >/dev/null 2>&1; then \
+			cp -n "$$DOWNLOAD_DIR"/*.tar.gz "$$DOWNLOAD_DIR"/*.tar.xz "$$DOWNLOAD_DIR"/*.zip "$$CACHE_DIR/" 2>/dev/null || true; \
+		fi
 
 CXX_M_FLAGS = $(filter -m%, $(CXXFLAGS))
 

package/deps/rocksdb/rocksdb/include/rocksdb/advanced_cache.h

@@ -318,7 +318,7 @@ class Cache : public Customizable {
   // REQUIRES: handle must have been returned by a method on *this.
   virtual bool Release(Handle* handle, bool erase_if_last_ref = false) = 0;
 
-  // Return the object assiciated with a handle returned by a successful
+  // Return the object associated with a handle returned by a successful
   // Lookup(). For historical reasons, this is also known at the "value"
   // associated with the key.
   // REQUIRES: handle must not have been released yet.