@nxtedition/rocksdb 7.0.4 → 7.0.7

package/deps/rocksdb/rocksdb/table/block_based/partitioned_filter_block_test.cc

@@ -161,8 +161,7 @@ class PartitionedFilterBlockTest
   }
 
   void VerifyReader(PartitionedFilterBlockBuilder* builder,
-                    PartitionedIndexBuilder* pib, bool empty = false,
-                    const SliceTransform* prefix_extractor = nullptr) {
+                    PartitionedIndexBuilder* pib, bool empty = false) {
     std::unique_ptr<PartitionedFilterBlockReader> reader(
         NewReader(builder, pib));
     // Querying added keys
@@ -170,31 +169,31 @@ class PartitionedFilterBlockTest
     for (auto key : keys) {
       auto ikey = InternalKey(key, 0, ValueType::kTypeValue);
       const Slice ikey_slice = Slice(*ikey.rep());
-      ASSERT_TRUE(reader->KeyMayMatch(key, prefix_extractor, kNotValid, !no_io,
-                                      &ikey_slice, /*get_context=*/nullptr,
+      ASSERT_TRUE(reader->KeyMayMatch(key, !no_io, &ikey_slice,
+                                      /*get_context=*/nullptr,
                                       /*lookup_context=*/nullptr));
     }
     {
       // querying a key twice
       auto ikey = InternalKey(keys[0], 0, ValueType::kTypeValue);
       const Slice ikey_slice = Slice(*ikey.rep());
-      ASSERT_TRUE(reader->KeyMayMatch(
-          keys[0], prefix_extractor, kNotValid, !no_io, &ikey_slice,
-          /*get_context=*/nullptr, /*lookup_context=*/nullptr));
+      ASSERT_TRUE(reader->KeyMayMatch(keys[0], !no_io, &ikey_slice,
+                                      /*get_context=*/nullptr,
+                                      /*lookup_context=*/nullptr));
     }
     // querying missing keys
     for (auto key : missing_keys) {
       auto ikey = InternalKey(key, 0, ValueType::kTypeValue);
       const Slice ikey_slice = Slice(*ikey.rep());
       if (empty) {
-        ASSERT_TRUE(reader->KeyMayMatch(
-            key, prefix_extractor, kNotValid, !no_io, &ikey_slice,
-            /*get_context=*/nullptr, /*lookup_context=*/nullptr));
+        ASSERT_TRUE(reader->KeyMayMatch(key, !no_io, &ikey_slice,
+                                        /*get_context=*/nullptr,
+                                        /*lookup_context=*/nullptr));
       } else {
         // assuming a good hash function
-        ASSERT_FALSE(reader->KeyMayMatch(
-            key, prefix_extractor, kNotValid, !no_io, &ikey_slice,
-            /*get_context=*/nullptr, /*lookup_context=*/nullptr));
+        ASSERT_FALSE(reader->KeyMayMatch(key, !no_io, &ikey_slice,
+                                         /*get_context=*/nullptr,
+                                         /*lookup_context=*/nullptr));
       }
     }
   }
@@ -343,20 +342,20 @@ TEST_P(PartitionedFilterBlockTest, SamePrefixInMultipleBlocks) {
   for (auto key : pkeys) {
     auto ikey = InternalKey(key, 0, ValueType::kTypeValue);
     const Slice ikey_slice = Slice(*ikey.rep());
-    ASSERT_TRUE(reader->PrefixMayMatch(
-        prefix_extractor->Transform(key), prefix_extractor.get(), kNotValid,
-        /*no_io=*/false, &ikey_slice, /*get_context=*/nullptr,
-        /*lookup_context=*/nullptr));
+    ASSERT_TRUE(reader->PrefixMayMatch(prefix_extractor->Transform(key),
+                                       /*no_io=*/false, &ikey_slice,
+                                       /*get_context=*/nullptr,
+                                       /*lookup_context=*/nullptr));
   }
   // Non-existent keys but with the same prefix
   const std::string pnonkeys[4] = {"p-key9", "p-key11", "p-key21", "p-key31"};
   for (auto key : pnonkeys) {
     auto ikey = InternalKey(key, 0, ValueType::kTypeValue);
     const Slice ikey_slice = Slice(*ikey.rep());
-    ASSERT_TRUE(reader->PrefixMayMatch(
-        prefix_extractor->Transform(key), prefix_extractor.get(), kNotValid,
-        /*no_io=*/false, &ikey_slice, /*get_context=*/nullptr,
-        /*lookup_context=*/nullptr));
+    ASSERT_TRUE(reader->PrefixMayMatch(prefix_extractor->Transform(key),
+                                       /*no_io=*/false, &ikey_slice,
+                                       /*get_context=*/nullptr,
+                                       /*lookup_context=*/nullptr));
   }
 }
 
@@ -391,10 +390,10 @@ TEST_P(PartitionedFilterBlockTest, PrefixInWrongPartitionBug) {
     auto prefix = prefix_extractor->Transform(key);
     auto ikey = InternalKey(prefix, 0, ValueType::kTypeValue);
     const Slice ikey_slice = Slice(*ikey.rep());
-    ASSERT_TRUE(reader->PrefixMayMatch(
-        prefix, prefix_extractor.get(), kNotValid,
-        /*no_io=*/false, &ikey_slice, /*get_context=*/nullptr,
-        /*lookup_context=*/nullptr));
+    ASSERT_TRUE(reader->PrefixMayMatch(prefix,
+                                       /*no_io=*/false, &ikey_slice,
+                                       /*get_context=*/nullptr,
+                                       /*lookup_context=*/nullptr));
   }
 }
 

package/deps/rocksdb/rocksdb/table/block_fetcher.cc

@@ -285,7 +285,6 @@ IOStatus BlockFetcher::ReadBlockContents() {
     switch (block_type_) {
       case BlockType::kFilter:
       case BlockType::kFilterPartitionIndex:
-      case BlockType::kDeprecatedFilter:
         PERF_COUNTER_ADD(filter_block_read_count, 1);
         break;
 

package/deps/rocksdb/rocksdb/table/get_context.h

@@ -53,7 +53,6 @@ struct GetContextStats {
   // MultiGet stats.
   uint64_t num_filter_read = 0;
   uint64_t num_index_read = 0;
-  uint64_t num_data_read = 0;
   uint64_t num_sst_read = 0;
 };
 

package/deps/rocksdb/rocksdb/table/table_test.cc

@@ -3524,11 +3524,10 @@ TEST_P(BlockBasedTableTest, InvalidOptions) {
 }
 
 TEST_P(BlockBasedTableTest, BlockReadCountTest) {
-  // bloom_filter_type = 0 -- block-based filter (not available in public API)
   // bloom_filter_type = 1 -- full filter using use_block_based_builder=false
   // bloom_filter_type = 2 -- full filter using use_block_based_builder=true
   //                          because of API change to hide block-based filter
-  for (int bloom_filter_type = 0; bloom_filter_type <= 2; ++bloom_filter_type) {
+  for (int bloom_filter_type = 1; bloom_filter_type <= 2; ++bloom_filter_type) {
     for (int index_and_filter_in_cache = 0; index_and_filter_in_cache < 2;
          ++index_and_filter_in_cache) {
       Options options;
@@ -3537,22 +3536,8 @@ TEST_P(BlockBasedTableTest, BlockReadCountTest) {
       BlockBasedTableOptions table_options = GetBlockBasedTableOptions();
       table_options.block_cache = NewLRUCache(1, 0);
       table_options.cache_index_and_filter_blocks = index_and_filter_in_cache;
-      if (bloom_filter_type == 0) {
-#ifndef ROCKSDB_LITE
-        // Use back-door way of enabling obsolete block-based Bloom
-        ASSERT_OK(FilterPolicy::CreateFromString(
-            ConfigOptions(),
-            "rocksdb.internal.DeprecatedBlockBasedBloomFilter:10",
-            &table_options.filter_policy));
-#else
-        // Skip this case in LITE build
-        continue;
-#endif
-      } else {
-        // Public API
-        table_options.filter_policy.reset(
-            NewBloomFilterPolicy(10, bloom_filter_type == 2));
-      }
+      table_options.filter_policy.reset(
+          NewBloomFilterPolicy(10, bloom_filter_type == 2));
       options.table_factory.reset(new BlockBasedTableFactory(table_options));
       std::vector<std::string> keys;
       stl_wrappers::KVMap kvmap;

package/deps/rocksdb/rocksdb/tools/db_bench_tool.cc

@@ -1605,9 +1605,6 @@ DEFINE_double(cuckoo_hash_ratio, 0.9, "Hash ratio for Cuckoo SST table.");
 DEFINE_bool(use_hash_search, false, "if use kHashSearch "
             "instead of kBinarySearch. "
             "This is valid if only we use BlockTable");
-DEFINE_bool(use_block_based_filter, false, "if use kBlockBasedFilter "
-            "instead of kFullFilter for filter block. "
-            "This is valid if only we use BlockTable");
 DEFINE_string(merge_operator, "", "The merge operator to use with the database."
               "If a new merge operator is specified, be sure to use fresh"
               " database The possible merge operators are defined in"
@@ -4525,19 +4522,6 @@ class Benchmark {
           table_options->filter_policy = BlockBasedTableOptions().filter_policy;
         } else if (FLAGS_bloom_bits == 0) {
           table_options->filter_policy.reset();
-        } else if (FLAGS_use_block_based_filter) {
-          // Use back-door way of enabling obsolete block-based Bloom
-          Status s = FilterPolicy::CreateFromString(
-              ConfigOptions(),
-              "rocksdb.internal.DeprecatedBlockBasedBloomFilter:" +
-                  std::to_string(FLAGS_bloom_bits),
-              &table_options->filter_policy);
-          if (!s.ok()) {
-            fprintf(stderr,
-                    "failure creating obsolete block-based filter: %s\n",
-                    s.ToString().c_str());
-            exit(1);
-          }
         } else {
           table_options->filter_policy.reset(
               FLAGS_use_ribbon_filter ? NewRibbonFilterPolicy(FLAGS_bloom_bits)
@@ -4578,6 +4562,9 @@ class Benchmark {
         options.rate_limiter.reset(NewGenericRateLimiter(
             FLAGS_rate_limiter_bytes_per_sec,
             FLAGS_rate_limiter_refill_period_us, 10 /* fairness */,
+            // TODO: replace this with a more general FLAG for deciding
+            // RateLimiter::Mode as now we also rate-limit foreground reads e.g,
+            // Get()/MultiGet()
             FLAGS_rate_limit_bg_reads ? RateLimiter::Mode::kReadsOnly
                                       : RateLimiter::Mode::kWritesOnly,
             FLAGS_rate_limiter_auto_tuned));

package/deps/rocksdb/rocksdb/tools/ldb_cmd.cc

@@ -1306,7 +1306,7 @@ void DumpManifestFile(Options options, std::string file, bool verbose, bool hex,
   ImmutableDBOptions immutable_db_options(options);
   VersionSet versions(dbname, &immutable_db_options, sopt, tc.get(), &wb, &wc,
                       /*block_cache_tracer=*/nullptr, /*io_tracer=*/nullptr,
-                      /*db_session_id*/ "");
+                      /*db_id*/ "", /*db_session_id*/ "");
   Status s = versions.DumpManifest(options, file, verbose, hex, json);
   if (!s.ok()) {
     fprintf(stderr, "Error in processing file %s %s\n", file.c_str(),
@@ -1448,7 +1448,7 @@ Status GetLiveFilesChecksumInfoFromVersionSet(Options options,
   ImmutableDBOptions immutable_db_options(options);
   VersionSet versions(dbname, &immutable_db_options, sopt, tc.get(), &wb, &wc,
                       /*block_cache_tracer=*/nullptr, /*io_tracer=*/nullptr,
-                      /*db_session_id*/ "");
+                      /*db_id*/ "", /*db_session_id*/ "");
   std::vector<std::string> cf_name_list;
   s = versions.ListColumnFamilies(&cf_name_list, db_path,
                                   immutable_db_options.fs.get());
@@ -2255,7 +2255,7 @@ Status ReduceDBLevelsCommand::GetOldNumOfLevels(Options& opt,
   WriteBufferManager wb(opt.db_write_buffer_size);
   VersionSet versions(db_path_, &db_options, soptions, tc.get(), &wb, &wc,
                       /*block_cache_tracer=*/nullptr, /*io_tracer=*/nullptr,
-                      /*db_session_id*/ "");
+                      /*db_id*/ "", /*db_session_id*/ "");
   std::vector<ColumnFamilyDescriptor> dummy;
   ColumnFamilyDescriptor dummy_descriptor(kDefaultColumnFamilyName,
                                           ColumnFamilyOptions(opt));

package/deps/rocksdb/rocksdb/tools/ldb_cmd_test.cc

@@ -208,7 +208,7 @@ class FileChecksumTestHelper {
     WriteBufferManager wb(options_.db_write_buffer_size);
     ImmutableDBOptions immutable_db_options(options_);
     VersionSet versions(dbname_, &immutable_db_options, sopt, tc.get(), &wb,
-                        &wc, nullptr, nullptr, "");
+                        &wc, nullptr, nullptr, "", "");
     std::vector<std::string> cf_name_list;
     Status s;
     s = versions.ListColumnFamilies(&cf_name_list, dbname_,

package/deps/rocksdb/rocksdb/util/bloom_test.cc

@@ -69,207 +69,6 @@ static int NextLength(int length) {
   return length;
 }
 
-class BlockBasedBloomTest : public testing::Test {
- private:
-  std::unique_ptr<const DeprecatedBlockBasedBloomFilterPolicy> policy_;
-  std::string filter_;
-  std::vector<std::string> keys_;
-
- public:
-  BlockBasedBloomTest() { ResetPolicy(); }
-
-  void Reset() {
-    keys_.clear();
-    filter_.clear();
-  }
-
-  void ResetPolicy(double bits_per_key) {
-    policy_.reset(new DeprecatedBlockBasedBloomFilterPolicy(bits_per_key));
-    Reset();
-  }
-
-  void ResetPolicy() { ResetPolicy(FLAGS_bits_per_key); }
-
-  void Add(const Slice& s) {
-    keys_.push_back(s.ToString());
-  }
-
-  void Build() {
-    std::vector<Slice> key_slices;
-    for (size_t i = 0; i < keys_.size(); i++) {
-      key_slices.push_back(Slice(keys_[i]));
-    }
-    filter_.clear();
-    DeprecatedBlockBasedBloomFilterPolicy::CreateFilter(
-        &key_slices[0], static_cast<int>(key_slices.size()),
-        policy_->GetWholeBitsPerKey(), &filter_);
-    keys_.clear();
-    if (kVerbose >= 2) DumpFilter();
-  }
-
-  size_t FilterSize() const {
-    return filter_.size();
-  }
-
-  Slice FilterData() const { return Slice(filter_); }
-
-  void DumpFilter() {
-    fprintf(stderr, "F(");
-    for (size_t i = 0; i+1 < filter_.size(); i++) {
-      const unsigned int c = static_cast<unsigned int>(filter_[i]);
-      for (int j = 0; j < 8; j++) {
-        fprintf(stderr, "%c", (c & (1 <<j)) ? '1' : '.');
-      }
-    }
-    fprintf(stderr, ")\n");
-  }
-
-  bool Matches(const Slice& s) {
-    if (!keys_.empty()) {
-      Build();
-    }
-    return DeprecatedBlockBasedBloomFilterPolicy::KeyMayMatch(s, filter_);
-  }
-
-  double FalsePositiveRate() {
-    char buffer[sizeof(int)];
-    int result = 0;
-    for (int i = 0; i < 10000; i++) {
-      if (Matches(Key(i + 1000000000, buffer))) {
-        result++;
-      }
-    }
-    return result / 10000.0;
-  }
-};
-
-TEST_F(BlockBasedBloomTest, EmptyFilter) {
-  ASSERT_TRUE(! Matches("hello"));
-  ASSERT_TRUE(! Matches("world"));
-}
-
-TEST_F(BlockBasedBloomTest, Small) {
-  Add("hello");
-  Add("world");
-  ASSERT_TRUE(Matches("hello"));
-  ASSERT_TRUE(Matches("world"));
-  ASSERT_TRUE(! Matches("x"));
-  ASSERT_TRUE(! Matches("foo"));
-}
-
-TEST_F(BlockBasedBloomTest, VaryingLengths) {
-  char buffer[sizeof(int)];
-
-  // Count number of filters that significantly exceed the false positive rate
-  int mediocre_filters = 0;
-  int good_filters = 0;
-
-  for (int length = 1; length <= 10000; length = NextLength(length)) {
-    Reset();
-    for (int i = 0; i < length; i++) {
-      Add(Key(i, buffer));
-    }
-    Build();
-
-    ASSERT_LE(FilterSize(), (size_t)((length * FLAGS_bits_per_key / 8) + 40))
-        << length;
-
-    // All added keys must match
-    for (int i = 0; i < length; i++) {
-      ASSERT_TRUE(Matches(Key(i, buffer)))
-          << "Length " << length << "; key " << i;
-    }
-
-    // Check false positive rate
-    double rate = FalsePositiveRate();
-    if (kVerbose >= 1) {
-      fprintf(stderr, "False positives: %5.2f%% @ length = %6d ; bytes = %6d\n",
-              rate*100.0, length, static_cast<int>(FilterSize()));
-    }
-    if (FLAGS_bits_per_key == 10) {
-      ASSERT_LE(rate, 0.02);  // Must not be over 2%
-      if (rate > 0.0125) {
-        mediocre_filters++;  // Allowed, but not too often
-      } else {
-        good_filters++;
-      }
-    }
-  }
-  if (FLAGS_bits_per_key == 10 && kVerbose >= 1) {
-    fprintf(stderr, "Filters: %d good, %d mediocre\n",
-            good_filters, mediocre_filters);
-  }
-  ASSERT_LE(mediocre_filters, good_filters/5);
-}
-
-// Ensure the implementation doesn't accidentally change in an
-// incompatible way
-TEST_F(BlockBasedBloomTest, Schema) {
-  char buffer[sizeof(int)];
-
-  ResetPolicy(8);  // num_probes = 5
-  for (int key = 0; key < 87; key++) {
-    Add(Key(key, buffer));
-  }
-  Build();
-  ASSERT_EQ(BloomHash(FilterData()), 3589896109U);
-
-  ResetPolicy(9);  // num_probes = 6
-  for (int key = 0; key < 87; key++) {
-    Add(Key(key, buffer));
-  }
-  Build();
-  ASSERT_EQ(BloomHash(FilterData()), 969445585U);
-
-  ResetPolicy(11);  // num_probes = 7
-  for (int key = 0; key < 87; key++) {
-    Add(Key(key, buffer));
-  }
-  Build();
-  ASSERT_EQ(BloomHash(FilterData()), 1694458207U);
-
-  ResetPolicy(10);  // num_probes = 6
-  for (int key = 0; key < 87; key++) {
-    Add(Key(key, buffer));
-  }
-  Build();
-  ASSERT_EQ(BloomHash(FilterData()), 2373646410U);
-
-  ResetPolicy(10);
-  for (int key = /*CHANGED*/ 1; key < 87; key++) {
-    Add(Key(key, buffer));
-  }
-  Build();
-  ASSERT_EQ(BloomHash(FilterData()), 1908442116U);
-
-  ResetPolicy(10);
-  for (int key = 1; key < /*CHANGED*/ 88; key++) {
-    Add(Key(key, buffer));
-  }
-  Build();
-  ASSERT_EQ(BloomHash(FilterData()), 3057004015U);
-
-  // With new fractional bits_per_key, check that we are rounding to
-  // whole bits per key for old Bloom filters.
-  ResetPolicy(9.5);  // Treated as 10
-  for (int key = 1; key < 88; key++) {
-    Add(Key(key, buffer));
-  }
-  Build();
-  ASSERT_EQ(BloomHash(FilterData()), /*SAME*/ 3057004015U);
-
-  ResetPolicy(10.499);  // Treated as 10
-  for (int key = 1; key < 88; key++) {
-    Add(Key(key, buffer));
-  }
-  Build();
-  ASSERT_EQ(BloomHash(FilterData()), /*SAME*/ 3057004015U);
-
-  ResetPolicy();
-}
-
-// Different bits-per-byte
-
 class FullBloomTest : public testing::TestWithParam<std::string> {
  protected:
   BlockBasedTableOptions table_options_;

package/deps/rocksdb/rocksdb/util/distributed_mutex.h

@@ -0,0 +1,48 @@
+//  Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+
+#pragma once
+
+#include "rocksdb/rocksdb_namespace.h"
+
+// This file declares a wrapper around the efficient folly DistributedMutex
+// that falls back on a standard mutex when not available. See
+// https://github.com/facebook/folly/blob/main/folly/synchronization/DistributedMutex.h
+// for benefits and limitations.
+
+// At the moment, only scoped locking is supported using DMutexLock
+// RAII wrapper, because lock/unlock APIs will vary.
+
+#ifdef USE_FOLLY
+
+#include <folly/synchronization/DistributedMutex.h>
+
+namespace ROCKSDB_NAMESPACE {
+
+class DMutex : public folly::DistributedMutex {
+ public:
+  static const char* kName() { return "folly::DistributedMutex"; }
+
+  explicit DMutex(bool IGNORED_adaptive = false) { (void)IGNORED_adaptive; }
+
+  // currently no-op
+  void AssertHeld() {}
+};
+using DMutexLock = std::lock_guard<folly::DistributedMutex>;
+
+}  // namespace ROCKSDB_NAMESPACE
+
+#else
+
+#include "port/port.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+using DMutex = port::Mutex;
+using DMutexLock = std::lock_guard<DMutex>;
+
+}  // namespace ROCKSDB_NAMESPACE
+
+#endif

package/deps/rocksdb/rocksdb/util/filter_bench.cc

@@ -84,8 +84,8 @@ DEFINE_bool(new_builder, false,
 
 DEFINE_uint32(impl, 0,
               "Select filter implementation. Without -use_plain_table_bloom:"
-              "0 = legacy full Bloom filter, 1 = block-based Bloom filter, "
-              "2 = format_version 5 Bloom filter, 3 = Ribbon128 filter. With "
+              "0 = legacy full Bloom filter, "
+              "1 = format_version 5 Bloom filter, 2 = Ribbon128 filter. With "
               "-use_plain_table_bloom: 0 = no locality, 1 = locality.");
 
 DEFINE_bool(net_includes_hashing, false,
@@ -358,13 +358,9 @@ void FilterBench::Go() {
           "-impl must currently be >= 0 and <= 1 for Plain table");
     }
   } else {
-    if (FLAGS_impl == 1) {
+    if (FLAGS_impl > 2) {
       throw std::runtime_error(
-          "Block-based filter not currently supported by filter_bench");
-    }
-    if (FLAGS_impl > 3) {
-      throw std::runtime_error(
-          "-impl must currently be 0, 2, or 3 for Block-based table");
+          "-impl must currently be >= 0 and <= 2 for Block-based table");
     }
   }
 
@@ -603,7 +599,7 @@ double FilterBench::RandomQueryTest(uint32_t inside_threshold, bool dry_run,
 
   auto dry_run_hash_fn = DryRunNoHash;
   if (!FLAGS_net_includes_hashing) {
-    if (FLAGS_impl < 2 || FLAGS_use_plain_table_bloom) {
+    if (FLAGS_impl == 0 || FLAGS_use_plain_table_bloom) {
       dry_run_hash_fn = DryRunHash32;
     } else {
       dry_run_hash_fn = DryRunHash64;
@@ -728,8 +724,6 @@ double FilterBench::RandomQueryTest(uint32_t inside_threshold, bool dry_run,
           } else {
             may_match = info.full_block_reader_->KeyMayMatch(
                 batch_slices[i],
-                /*prefix_extractor=*/nullptr,
-                /*block_offset=*/ROCKSDB_NAMESPACE::kNotValid,
                 /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                 /*get_context=*/nullptr,
                 /*lookup_context=*/nullptr);

package/deps/rocksdb/rocksdb/utilities/backup/backup_engine.cc

@@ -296,6 +296,9 @@ class BackupEngineImpl {
     }
   };
 
+  // TODO: deprecate this function once we migrate all BackupEngine's rate
+  // limiting to lower-level ones (i.e, ones in file access wrapper level like
+  // `WritableFileWriter`)
   static void LoopRateLimitRequestHelper(const size_t total_bytes_to_request,
                                          RateLimiter* rate_limiter,
                                          const Env::IOPriority pri,

package/deps/rocksdb/rocksdb/utilities/cache_dump_load_impl.cc

@@ -139,11 +139,6 @@ CacheDumperImpl::DumpOneBlockCallBack() {
         block_start = (static_cast<Block*>(value))->data();
         block_len = (static_cast<Block*>(value))->size();
         break;
-      case CacheEntryRole::kDeprecatedFilterBlock:
-        type = CacheDumpUnitType::kDeprecatedFilterBlock;
-        block_start = (static_cast<BlockContents*>(value))->data.data();
-        block_len = (static_cast<BlockContents*>(value))->data.size();
-        break;
       case CacheEntryRole::kFilterBlock:
         type = CacheDumpUnitType::kFilter;
         block_start = (static_cast<ParsedFullFilterBlock*>(value))
@@ -163,6 +158,10 @@ CacheDumperImpl::DumpOneBlockCallBack() {
         block_start = (static_cast<Block*>(value))->data();
         block_len = (static_cast<Block*>(value))->size();
         break;
+      case CacheEntryRole::kDeprecatedFilterBlock:
+        // Obsolete
+        filter_out = true;
+        break;
       case CacheEntryRole::kMisc:
         filter_out = true;
         break;
@@ -322,22 +321,6 @@ IOStatus CacheDumpedLoaderImpl::RestoreCacheEntriesToSecondaryCache() {
     // according to the block type, get the helper callback function and create
     // the corresponding block
     switch (dump_unit.type) {
-      case CacheDumpUnitType::kDeprecatedFilterBlock: {
-        helper = BlocklikeTraits<BlockContents>::GetCacheItemHelper(
-            BlockType::kDeprecatedFilter);
-        std::unique_ptr<BlockContents> block_holder;
-        block_holder.reset(BlocklikeTraits<BlockContents>::Create(
-            std::move(raw_block_contents), 0, statistics, false,
-            toptions_.filter_policy.get()));
-        // Insert the block to secondary cache.
-        // Note that, if we cannot get the correct helper callback, the block
-        // will not be inserted.
-        if (helper != nullptr) {
-          s = secondary_cache_->Insert(dump_unit.key,
-                                       (void*)(block_holder.get()), helper);
-        }
-        break;
-      }
       case CacheDumpUnitType::kFilter: {
         helper = BlocklikeTraits<ParsedFullFilterBlock>::GetCacheItemHelper(
             BlockType::kFilter);
@@ -390,6 +373,9 @@ IOStatus CacheDumpedLoaderImpl::RestoreCacheEntriesToSecondaryCache() {
       }
       case CacheDumpUnitType::kFooter:
         break;
+      case CacheDumpUnitType::kDeprecatedFilterBlock:
+        // Obsolete
+        break;
       default:
         continue;
     }

package/deps/rocksdb/rocksdb/utilities/cache_dump_load_impl.h

@@ -36,7 +36,7 @@ enum CacheDumpUnitType : unsigned char {
   kHashIndexMetadata = 9,
   kMetaIndex = 10,
   kIndex = 11,
-  kDeprecatedFilterBlock = 12,
+  kDeprecatedFilterBlock = 12,  // OBSOLETE / DEPRECATED
   kFilterMetaBlock = 13,
   kBlockTypeMax,
 };

package/deps/rocksdb/rocksdb/utilities/checkpoint/checkpoint_test.cc

@@ -915,6 +915,51 @@ TEST_F(CheckpointTest, CheckpointWithDbPath) {
   delete checkpoint;
 }
 
+TEST_F(CheckpointTest, PutRaceWithCheckpointTrackedWalSync) {
+  // Repro for a race condition where a user write comes in after the checkpoint
+  // syncs WAL for `track_and_verify_wals_in_manifest` but before the
+  // corresponding MANIFEST update. With the bug, that scenario resulted in an
+  // unopenable DB with error "Corruption: Size mismatch: WAL ...".
+  Options options = CurrentOptions();
+  std::unique_ptr<FaultInjectionTestEnv> fault_env(
+      new FaultInjectionTestEnv(env_));
+  options.env = fault_env.get();
+  options.track_and_verify_wals_in_manifest = true;
+  Reopen(options);
+
+  ASSERT_OK(Put("key1", "val1"));
+
+  SyncPoint::GetInstance()->SetCallBack(
+      "DBImpl::SyncWAL:BeforeMarkLogsSynced:1",
+      [this](void* /* arg */) { ASSERT_OK(Put("key2", "val2")); });
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
+
+  std::unique_ptr<Checkpoint> checkpoint;
+  {
+    Checkpoint* checkpoint_ptr;
+    ASSERT_OK(Checkpoint::Create(db_, &checkpoint_ptr));
+    checkpoint.reset(checkpoint_ptr);
+  }
+
+  ASSERT_OK(checkpoint->CreateCheckpoint(snapshot_name_));
+
+  // Ensure callback ran.
+  ASSERT_EQ("val2", Get("key2"));
+
+  Close();
+
+  // Simulate full loss of unsynced data. This drops "key2" -> "val2" from the
+  // DB WAL.
+  fault_env->DropUnsyncedFileData();
+
+  // Before the bug fix, reopening the DB would fail because the MANIFEST's
+  // AddWal entry indicated the WAL should be synced through "key2" -> "val2".
+  Reopen(options);
+
+  // Need to close before `fault_env` goes out of scope.
+  Close();
+}
+
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {