@nxtedition/rocksdb 7.1.14 → 7.1.16

package/deps/rocksdb/rocksdb/tools/trace_analyzer_tool.cc

@@ -101,7 +101,7 @@ DEFINE_bool(convert_to_human_readable_trace, false,
             "You can specify 'no_key' to reduce the size, if key is not "
             "needed in the next step.\n"
             "File name: <prefix>_human_readable_trace.txt\n"
-            "Format:[type_id cf_id value_size time_in_micorsec <key>].");
+            "Format:[<key> type_id cf_id value_size time_in_micorsec].");
 DEFINE_bool(output_qps_stats, false,
             "Output the query per second(qps) statistics \n"
             "For the overall qps, it will contain all qps of each query type. "

package/deps/rocksdb/rocksdb/util/autovector.h

@@ -299,6 +299,16 @@ class autovector {
   }
 
   template <class... Args>
+#if _LIBCPP_STD_VER > 14
+  reference emplace_back(Args&&... args) {
+    if (num_stack_items_ < kSize) {
+      return *(new ((void*)(&values_[num_stack_items_++]))
+          value_type(std::forward<Args>(args)...));
+    } else {
+      return vect_.emplace_back(std::forward<Args>(args)...);
+    }
+  }
+#else
   void emplace_back(Args&&... args) {
     if (num_stack_items_ < kSize) {
       new ((void*)(&values_[num_stack_items_++]))
@@ -307,6 +317,8 @@ class autovector {
       vect_.emplace_back(std::forward<Args>(args)...);
     }
   }
+#endif
+
 
   void pop_back() {
     assert(!empty());

package/deps/rocksdb/rocksdb/util/rate_limiter_test.cc

@@ -344,9 +344,10 @@ TEST_F(RateLimiterTest, Rate) {
     }
   }
 
-  // This can fail in heavily loaded CI environments
+  // This can fail due to slow execution speed, like when using valgrind or in
+  // heavily loaded CI environments
   bool skip_minimum_rate_check =
-#if defined(CIRCLECI) && defined(OS_MACOSX)
+#if (defined(CIRCLECI) && defined(OS_MACOSX)) || defined(ROCKSDB_VALGRIND_RUN)
       true;
 #else
       getenv("SANDCASTLE");

package/deps/rocksdb/rocksdb/util/stderr_logger.cc

@@ -0,0 +1,30 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//
+//  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).
+
+#include "util/stderr_logger.h"
+
+#include "port/sys_time.h"
+
+namespace ROCKSDB_NAMESPACE {
+StderrLogger::~StderrLogger() {}
+
+void StderrLogger::Logv(const char* format, va_list ap) {
+  const uint64_t thread_id = Env::Default()->GetThreadID();
+
+  port::TimeVal now_tv;
+  port::GetTimeOfDay(&now_tv, nullptr);
+  const time_t seconds = now_tv.tv_sec;
+  struct tm t;
+  port::LocalTimeR(&seconds, &t);
+  fprintf(stderr, "%04d/%02d/%02d-%02d:%02d:%02d.%06d %llx ", t.tm_year + 1900,
+          t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec,
+          static_cast<int>(now_tv.tv_usec),
+          static_cast<long long unsigned int>(thread_id));
+
+  vfprintf(stderr, format, ap);
+  fprintf(stderr, "\n");
+}
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/util/stderr_logger.h

@@ -1,4 +1,5 @@
-//  Copyright (c) 2016-present, Facebook, Inc.  All rights reserved.
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//
 //  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).
@@ -8,7 +9,6 @@
 #include <stdarg.h>
 #include <stdio.h>
 
-#include "port/sys_time.h"
 #include "rocksdb/env.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -19,26 +19,13 @@ class StderrLogger : public Logger {
   explicit StderrLogger(const InfoLogLevel log_level = InfoLogLevel::INFO_LEVEL)
       : Logger(log_level) {}
 
+  ~StderrLogger() override;
+
   // Brings overloaded Logv()s into scope so they're not hidden when we override
   // a subset of them.
   using Logger::Logv;
 
-  virtual void Logv(const char* format, va_list ap) override {
-    const uint64_t thread_id = Env::Default()->GetThreadID();
-
-    port::TimeVal now_tv;
-    port::GetTimeOfDay(&now_tv, nullptr);
-    const time_t seconds = now_tv.tv_sec;
-    struct tm t;
-    port::LocalTimeR(&seconds, &t);
-    fprintf(stderr, "%04d/%02d/%02d-%02d:%02d:%02d.%06d %llx ",
-            t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min,
-            t.tm_sec, static_cast<int>(now_tv.tv_usec),
-            static_cast<long long unsigned int>(thread_id));
-
-    vfprintf(stderr, format, ap);
-    fprintf(stderr, "\n");
-  }
+  virtual void Logv(const char* format, va_list ap) override;
 };
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/util/timer.h

@@ -187,10 +187,9 @@ class Timer {
     return ret;
   }
 
-  bool TEST_HasVaildTask(const std::string& func_name) const {
+  void TEST_OverrideTimer(SystemClock* clock) {
     InstrumentedMutexLock l(&mutex_);
-    auto it = map_.find(func_name);
-    return it != map_.end() && it->second->IsValid();
+    clock_ = clock;
   }
 #endif  // NDEBUG
 

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

@@ -2083,6 +2083,10 @@ TEST_F(BackupEngineTest, ShareTableFilesWithChecksumsOldFileNaming) {
       });
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
 
+  // Corrupting the table properties corrupts the unique id.
+  // Ignore the unique id recorded in the manifest.
+  options_.verify_sst_unique_id_in_manifest = false;
+
   OpenDBAndBackupEngine(true, false, kShareWithChecksum);
   FillDB(db_.get(), 0, keys_iteration);
   CloseDBAndBackupEngine();
@@ -2984,9 +2988,12 @@ TEST_F(BackupEngineTest, ReadOnlyBackupEngine) {
   DestroyDBWithoutCheck(dbname_, options_);
   OpenDBAndBackupEngine(true);
   FillDB(db_.get(), 0, 100);
-  ASSERT_OK(backup_engine_->CreateNewBackup(db_.get(), true));
+  // Also test read-only DB with CreateNewBackup and flush=true (no flush)
+  CloseAndReopenDB(/*read_only*/ true);
+  ASSERT_OK(backup_engine_->CreateNewBackup(db_.get(), /*flush*/ true));
+  CloseAndReopenDB(/*read_only*/ false);
   FillDB(db_.get(), 100, 200);
-  ASSERT_OK(backup_engine_->CreateNewBackup(db_.get(), true));
+  ASSERT_OK(backup_engine_->CreateNewBackup(db_.get(), /*flush*/ true));
   CloseDBAndBackupEngine();
   DestroyDBWithoutCheck(dbname_, options_);
 

package/deps/rocksdb/rocksdb/utilities/blob_db/blob_db_impl.cc

@@ -1165,7 +1165,7 @@ Status BlobDBImpl::DecompressSlice(const Slice& compressed_value,
     UncompressionContext context(compression_type);
     UncompressionInfo info(context, UncompressionDict::GetEmptyDict(),
                            compression_type);
-    Status s = UncompressBlockContentsForCompressionType(
+    Status s = UncompressBlockData(
         info, compressed_value.data(), compressed_value.size(), &contents,
         kBlockBasedTableVersionFormat, *(cfh->cfd()->ioptions()));
     if (!s.ok()) {

package/deps/rocksdb/rocksdb/utilities/blob_db/blob_dump_tool.cc

@@ -213,7 +213,7 @@ Status BlobDumpTool::DumpRecord(DisplayType show_key, DisplayType show_blob,
     UncompressionContext context(compression);
     UncompressionInfo info(context, UncompressionDict::GetEmptyDict(),
                            compression);
-    s = UncompressBlockContentsForCompressionType(
+    s = UncompressBlockData(
         info, slice.data() + key_size, static_cast<size_t>(value_size),
         &contents, 2 /*compress_format_version*/, ImmutableOptions(Options()));
     if (!s.ok()) {

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

@@ -175,33 +175,33 @@ CacheDumperImpl::DumpOneBlockCallBack() {
     // Step 4: if the block should not be filter out, write the block to the
     // CacheDumpWriter
     if (!filter_out && block_start != nullptr) {
-      char* buffer = new char[block_len];
-      memcpy(buffer, block_start, block_len);
-      WriteCacheBlock(type, key, (void*)buffer, block_len)
+      WriteBlock(type, key, Slice(block_start, block_len))
           .PermitUncheckedError();
-      delete[] buffer;
     }
   };
 }
-// Write the raw block to the writer. It takes the timestamp of the block being
-// copied from block cache, block type, key, block pointer, raw block size and
-// the block checksum as the input. When writing the raw block, we first create
-// the dump unit and encoude it to a string. Then, we calculate the checksum of
-// the how dump unit string and store it in the dump unit metadata.
+
+// Write the block to the writer. It takes the timestamp of the
+// block being copied from block cache, block type, key, block pointer,
+// block size and block checksum as the input. When writing the dumper raw
+// block, we first create the dump unit and encoude it to a string. Then,
+// we calculate the checksum of the whole dump unit string and store it in
+// the dump unit metadata.
 // First, we write the metadata first, which is a fixed size string. Then, we
 // Append the dump unit string to the writer.
-IOStatus CacheDumperImpl::WriteRawBlock(uint64_t timestamp,
-                                        CacheDumpUnitType type,
-                                        const Slice& key, void* value,
-                                        size_t len, uint32_t checksum) {
-  // First, serilize the block information in a string
+IOStatus CacheDumperImpl::WriteBlock(CacheDumpUnitType type, const Slice& key,
+                                     const Slice& value) {
+  uint64_t timestamp = clock_->NowMicros();
+  uint32_t value_checksum = crc32c::Value(value.data(), value.size());
+
+  // First, serialize the block information in a string
   DumpUnit dump_unit;
   dump_unit.timestamp = timestamp;
   dump_unit.key = key;
   dump_unit.type = type;
-  dump_unit.value_len = len;
-  dump_unit.value = value;
-  dump_unit.value_checksum = checksum;
+  dump_unit.value_len = value.size();
+  dump_unit.value = const_cast<char*>(value.data());
+  dump_unit.value_checksum = value_checksum;
   std::string encoded_data;
   CacheDumperHelper::EncodeDumpUnit(dump_unit, &encoded_data);
 
@@ -212,19 +212,19 @@ IOStatus CacheDumperImpl::WriteRawBlock(uint64_t timestamp,
   unit_meta.sequence_num = sequence_num_;
   sequence_num_++;
   unit_meta.dump_unit_checksum =
-      crc32c::Value(encoded_data.c_str(), encoded_data.size());
-  unit_meta.dump_unit_size = static_cast<uint64_t>(encoded_data.size());
+      crc32c::Value(encoded_data.data(), encoded_data.size());
+  unit_meta.dump_unit_size = encoded_data.size();
   std::string encoded_meta;
   CacheDumperHelper::EncodeDumpUnitMeta(unit_meta, &encoded_meta);
 
   // We write the metadata first.
   assert(writer_ != nullptr);
-  IOStatus io_s = writer_->WriteMetadata(Slice(encoded_meta));
+  IOStatus io_s = writer_->WriteMetadata(encoded_meta);
   if (!io_s.ok()) {
     return io_s;
   }
   // followed by the dump unit.
-  return writer_->WritePacket(Slice(encoded_data));
+  return writer_->WritePacket(encoded_data);
 }
 
 // Before we write any block, we write the header first to store the cache dump
@@ -238,38 +238,18 @@ IOStatus CacheDumperImpl::WriteHeader() {
     << "RocksDB Version: " << kMajorVersion << "." << kMinorVersion << "\t"
     << "Format: dump_unit_metadata <sequence_number, dump_unit_checksum, "
        "dump_unit_size>, dump_unit <timestamp, key, block_type, "
-       "block_size, raw_block, raw_block_checksum> cache_value\n";
+       "block_size, block_data, block_checksum> cache_value\n";
   std::string header_value(s.str());
   CacheDumpUnitType type = CacheDumpUnitType::kHeader;
-  uint64_t timestamp = clock_->NowMicros();
-  uint32_t header_checksum =
-      crc32c::Value(header_value.c_str(), header_value.size());
-  return WriteRawBlock(timestamp, type, Slice(header_key),
-                       (void*)header_value.c_str(), header_value.size(),
-                       header_checksum);
-}
-
-// Write the block dumped from cache
-IOStatus CacheDumperImpl::WriteCacheBlock(const CacheDumpUnitType type,
-                                          const Slice& key, void* value,
-                                          size_t len) {
-  uint64_t timestamp = clock_->NowMicros();
-  uint32_t value_checksum = crc32c::Value((char*)value, len);
-  return WriteRawBlock(timestamp, type, key, value, len, value_checksum);
+  return WriteBlock(type, header_key, header_value);
 }
 
 // Write the footer after all the blocks are stored to indicate the ending.
 IOStatus CacheDumperImpl::WriteFooter() {
   std::string footer_key = "footer";
-  std::ostringstream s;
   std::string footer_value("cache dump completed");
   CacheDumpUnitType type = CacheDumpUnitType::kFooter;
-  uint64_t timestamp = clock_->NowMicros();
-  uint32_t footer_checksum =
-      crc32c::Value(footer_value.c_str(), footer_value.size());
-  return WriteRawBlock(timestamp, type, Slice(footer_key),
-                       (void*)footer_value.c_str(), footer_value.size(),
-                       footer_checksum);
+  return WriteBlock(type, footer_key, footer_value);
 }
 
 // This is the main function to restore the cache entries to secondary cache.
@@ -309,9 +289,10 @@ IOStatus CacheDumpedLoaderImpl::RestoreCacheEntriesToSecondaryCache() {
     if (!io_s.ok()) {
       break;
     }
-    // create the raw_block_content based on the information in the dump_unit
-    BlockContents raw_block_contents(
-        Slice((char*)dump_unit.value, dump_unit.value_len));
+    // Create the uncompressed_block based on the information in the dump_unit
+    // (There is no block trailer here compatible with block-based SST file.)
+    BlockContents uncompressed_block(
+        Slice(static_cast<char*>(dump_unit.value), dump_unit.value_len));
     Cache::CacheItemHelper* helper = nullptr;
     Statistics* statistics = nullptr;
     Status s = Status::OK();
@@ -323,7 +304,7 @@ IOStatus CacheDumpedLoaderImpl::RestoreCacheEntriesToSecondaryCache() {
             BlockType::kFilter);
         std::unique_ptr<ParsedFullFilterBlock> block_holder;
         block_holder.reset(BlocklikeTraits<ParsedFullFilterBlock>::Create(
-            std::move(raw_block_contents), toptions_.read_amp_bytes_per_bit,
+            std::move(uncompressed_block), toptions_.read_amp_bytes_per_bit,
             statistics, false, toptions_.filter_policy.get()));
         if (helper != nullptr) {
           s = secondary_cache_->Insert(dump_unit.key,
@@ -335,7 +316,7 @@ IOStatus CacheDumpedLoaderImpl::RestoreCacheEntriesToSecondaryCache() {
         helper = BlocklikeTraits<Block>::GetCacheItemHelper(BlockType::kData);
         std::unique_ptr<Block> block_holder;
         block_holder.reset(BlocklikeTraits<Block>::Create(
-            std::move(raw_block_contents), toptions_.read_amp_bytes_per_bit,
+            std::move(uncompressed_block), toptions_.read_amp_bytes_per_bit,
             statistics, false, toptions_.filter_policy.get()));
         if (helper != nullptr) {
           s = secondary_cache_->Insert(dump_unit.key,
@@ -347,7 +328,7 @@ IOStatus CacheDumpedLoaderImpl::RestoreCacheEntriesToSecondaryCache() {
         helper = BlocklikeTraits<Block>::GetCacheItemHelper(BlockType::kIndex);
         std::unique_ptr<Block> block_holder;
         block_holder.reset(BlocklikeTraits<Block>::Create(
-            std::move(raw_block_contents), 0, statistics, false,
+            std::move(uncompressed_block), 0, statistics, false,
             toptions_.filter_policy.get()));
         if (helper != nullptr) {
           s = secondary_cache_->Insert(dump_unit.key,
@@ -360,7 +341,7 @@ IOStatus CacheDumpedLoaderImpl::RestoreCacheEntriesToSecondaryCache() {
             BlockType::kFilterPartitionIndex);
         std::unique_ptr<Block> block_holder;
         block_holder.reset(BlocklikeTraits<Block>::Create(
-            std::move(raw_block_contents), toptions_.read_amp_bytes_per_bit,
+            std::move(uncompressed_block), toptions_.read_amp_bytes_per_bit,
             statistics, false, toptions_.filter_policy.get()));
         if (helper != nullptr) {
           s = secondary_cache_->Insert(dump_unit.key,
@@ -436,7 +417,7 @@ IOStatus CacheDumpedLoaderImpl::ReadHeader(std::string* data,
   if (!io_s.ok()) {
     return io_s;
   }
-  uint32_t unit_checksum = crc32c::Value(data->c_str(), data->size());
+  uint32_t unit_checksum = crc32c::Value(data->data(), data->size());
   if (unit_checksum != header_meta.dump_unit_checksum) {
     return IOStatus::Corruption("Read header unit corrupted!");
   }
@@ -461,7 +442,7 @@ IOStatus CacheDumpedLoaderImpl::ReadCacheBlock(std::string* data,
   if (!io_s.ok()) {
     return io_s;
   }
-  uint32_t unit_checksum = crc32c::Value(data->c_str(), data->size());
+  uint32_t unit_checksum = crc32c::Value(data->data(), data->size());
   if (unit_checksum != unit_meta.dump_unit_checksum) {
     return IOStatus::Corruption(
         "Checksum does not match! Read dumped unit corrupted!");

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

@@ -75,7 +75,7 @@ struct DumpUnit {
   // Pointer to the block. Note that, in the dump process, it points to a memory
   // buffer copied from cache block. The buffer is freed when we process the
   // next block. In the load process, we use an std::string to store the
-  // serilized dump_unit read from the reader. So it points to the memory
+  // serialized dump_unit read from the reader. So it points to the memory
   // address of the begin of the block in this string.
   void* value;
 
@@ -103,14 +103,9 @@ class CacheDumperImpl : public CacheDumper {
   IOStatus DumpCacheEntriesToWriter() override;
 
  private:
-  IOStatus WriteRawBlock(uint64_t timestamp, CacheDumpUnitType type,
-                         const Slice& key, void* value, size_t len,
-                         uint32_t checksum);
-
+  IOStatus WriteBlock(CacheDumpUnitType type, const Slice& key,
+                      const Slice& value);
   IOStatus WriteHeader();
-
-  IOStatus WriteCacheBlock(const CacheDumpUnitType type, const Slice& key,
-                           void* value, size_t len);
   IOStatus WriteFooter();
   bool ShouldFilterOut(const Slice& key);
   std::function<void(const Slice&, void*, size_t, Cache::DeleterFn)>
@@ -166,7 +161,7 @@ class ToFileCacheDumpWriter : public CacheDumpWriter {
 
   ~ToFileCacheDumpWriter() { Close().PermitUncheckedError(); }
 
-  // Write the serilized metadata to the file
+  // Write the serialized metadata to the file
   virtual IOStatus WriteMetadata(const Slice& metadata) override {
     assert(file_writer_ != nullptr);
     std::string prefix;
@@ -179,7 +174,7 @@ class ToFileCacheDumpWriter : public CacheDumpWriter {
     return io_s;
   }
 
-  // Write the serilized data to the file
+  // Write the serialized data to the file
   virtual IOStatus WritePacket(const Slice& data) override {
     assert(file_writer_ != nullptr);
     std::string prefix;
@@ -284,7 +279,7 @@ class FromFileCacheDumpReader : public CacheDumpReader {
 // The cache dump and load helper class
 class CacheDumperHelper {
  public:
-  // serilize the dump_unit_meta to a string, it is fixed 16 bytes size.
+  // serialize the dump_unit_meta to a string, it is fixed 16 bytes size.
   static void EncodeDumpUnitMeta(const DumpUnitMeta& meta, std::string* data) {
     assert(data);
     PutFixed32(data, static_cast<uint32_t>(meta.sequence_num));
@@ -292,7 +287,7 @@ class CacheDumperHelper {
     PutFixed64(data, meta.dump_unit_size);
   }
 
-  // Serilize the dump_unit to a string.
+  // Serialize the dump_unit to a string.
   static void EncodeDumpUnit(const DumpUnit& dump_unit, std::string* data) {
     assert(data);
     PutFixed64(data, dump_unit.timestamp);
@@ -304,7 +299,7 @@ class CacheDumperHelper {
                            Slice((char*)dump_unit.value, dump_unit.value_len));
   }
 
-  // Deserilize the dump_unit_meta from a string
+  // Deserialize the dump_unit_meta from a string
   static Status DecodeDumpUnitMeta(const std::string& encoded_data,
                                    DumpUnitMeta* unit_meta) {
     assert(unit_meta != nullptr);
@@ -323,7 +318,7 @@ class CacheDumperHelper {
     return Status::OK();
   }
 
-  // Deserilize the dump_unit from a string.
+  // Deserialize the dump_unit from a string.
   static Status DecodeDumpUnit(const std::string& encoded_data,
                                DumpUnit* dump_unit) {
     assert(dump_unit != nullptr);

package/deps/rocksdb/rocksdb/utilities/debug.cc

@@ -78,11 +78,9 @@ Status GetAllKeyVersions(DB* db, ColumnFamilyHandle* cfh, Slice begin_key,
   DBImpl* idb = static_cast<DBImpl*>(db->GetRootDB());
   auto icmp = InternalKeyComparator(idb->GetOptions(cfh).comparator);
   ReadOptions read_options;
-  ReadRangeDelAggregator range_del_agg(&icmp,
-                                       kMaxSequenceNumber /* upper_bound */);
   Arena arena;
-  ScopedArenaIterator iter(idb->NewInternalIterator(
-      read_options, &arena, &range_del_agg, kMaxSequenceNumber, cfh));
+  ScopedArenaIterator iter(
+      idb->NewInternalIterator(read_options, &arena, kMaxSequenceNumber, cfh));
 
   if (!begin_key.empty()) {
     InternalKey ikey;

package/deps/rocksdb/rocksdb/utilities/fault_injection_fs.cc

@@ -240,6 +240,7 @@ IOStatus TestFSWritableFile::PositionedAppend(
 
 IOStatus TestFSWritableFile::Close(const IOOptions& options,
                                    IODebugContext* dbg) {
+  MutexLock l(&mutex_);
   if (!fs_->IsFilesystemActive()) {
     return fs_->GetError();
   }
@@ -271,6 +272,7 @@ IOStatus TestFSWritableFile::Close(const IOOptions& options,
 }
 
 IOStatus TestFSWritableFile::Flush(const IOOptions&, IODebugContext*) {
+  MutexLock l(&mutex_);
   if (!fs_->IsFilesystemActive()) {
     return fs_->GetError();
   }
@@ -282,6 +284,7 @@ IOStatus TestFSWritableFile::Flush(const IOOptions&, IODebugContext*) {
 
 IOStatus TestFSWritableFile::Sync(const IOOptions& options,
                                   IODebugContext* dbg) {
+  MutexLock l(&mutex_);
   if (!fs_->IsFilesystemActive()) {
     return fs_->GetError();
   }
@@ -302,6 +305,7 @@ IOStatus TestFSWritableFile::Sync(const IOOptions& options,
 IOStatus TestFSWritableFile::RangeSync(uint64_t offset, uint64_t nbytes,
                                        const IOOptions& options,
                                        IODebugContext* dbg) {
+  MutexLock l(&mutex_);
   if (!fs_->IsFilesystemActive()) {
     return fs_->GetError();
   }

package/deps/rocksdb/rocksdb/utilities/fault_injection_fs.h

@@ -97,7 +97,7 @@ class TestFSWritableFile : public FSWritableFile {
   };
 
  private:
-  FSFileState state_;
+  FSFileState state_;  // Need protection by mutex_
   FileOptions file_opts_;
   std::unique_ptr<FSWritableFile> target_;
   bool writable_file_opened_;

package/deps/rocksdb/rocksdb/utilities/fault_injection_secondary_cache.cc

@@ -87,17 +87,18 @@ Status FaultInjectionSecondaryCache::Insert(
 std::unique_ptr<SecondaryCacheResultHandle>
 FaultInjectionSecondaryCache::Lookup(const Slice& key,
                                      const Cache::CreateCallback& create_cb,
-                                     bool wait, bool& is_in_sec_cache) {
+                                     bool wait, bool advise_erase,
+                                     bool& is_in_sec_cache) {
   ErrorContext* ctx = GetErrorContext();
   if (base_is_compressed_sec_cache_) {
     if (ctx->rand.OneIn(prob_)) {
       return nullptr;
     } else {
-      return base_->Lookup(key, create_cb, wait, is_in_sec_cache);
+      return base_->Lookup(key, create_cb, wait, advise_erase, is_in_sec_cache);
     }
   } else {
     std::unique_ptr<SecondaryCacheResultHandle> hdl =
-        base_->Lookup(key, create_cb, wait, is_in_sec_cache);
+        base_->Lookup(key, create_cb, wait, advise_erase, is_in_sec_cache);
     if (wait && ctx->rand.OneIn(prob_)) {
       hdl.reset();
     }

package/deps/rocksdb/rocksdb/utilities/fault_injection_secondary_cache.h

@@ -36,7 +36,9 @@ class FaultInjectionSecondaryCache : public SecondaryCache {
 
   std::unique_ptr<SecondaryCacheResultHandle> Lookup(
       const Slice& key, const Cache::CreateCallback& create_cb, bool wait,
-      bool& is_in_sec_cache) override;
+      bool advise_erase, bool& is_in_sec_cache) override;
+
+  bool SupportForceErase() const override { return base_->SupportForceErase(); }
 
   void Erase(const Slice& key) override;
 

package/deps/rocksdb/rocksdb/utilities/option_change_migration/option_change_migration.cc

@@ -35,18 +35,26 @@ Status OpenDb(const Options& options, const std::string& dbname,
   return s;
 }
 
+// l0_file_size specifies size of file on L0. Files will be range partitioned
+// after a full compaction so they are likely qualified to put on L0. If
+// left as 0, the files are compacted in a single file and put to L0. Otherwise,
+// will try to compact the files as size l0_file_size.
 Status CompactToLevel(const Options& options, const std::string& dbname,
-                      int dest_level, bool need_reopen) {
+                      int dest_level, uint64_t l0_file_size, bool need_reopen) {
   std::unique_ptr<DB> db;
   Options no_compact_opts = GetNoCompactionOptions(options);
   if (dest_level == 0) {
+    if (l0_file_size == 0) {
+      // Single file.
+      l0_file_size = 999999999999999;
+    }
     // L0 has strict sequenceID requirements to files to it. It's safer
     // to only put one compacted file to there.
     // This is only used for converting to universal compaction with
     // only one level. In this case, compacting to one file is also
     // optimal.
-    no_compact_opts.target_file_size_base = 999999999999999;
-    no_compact_opts.max_compaction_bytes = 999999999999999;
+    no_compact_opts.target_file_size_base = l0_file_size;
+    no_compact_opts.max_compaction_bytes = l0_file_size;
   }
   Status s = OpenDb(no_compact_opts, dbname, &db);
   if (!s.ok()) {
@@ -98,7 +106,8 @@ Status MigrateToUniversal(std::string dbname, const Options& old_opts,
       }
     }
     if (need_compact) {
-      return CompactToLevel(old_opts, dbname, new_opts.num_levels - 1, true);
+      return CompactToLevel(old_opts, dbname, new_opts.num_levels - 1,
+                            /*l0_file_size=*/0, true);
     }
     return Status::OK();
   }
@@ -119,7 +128,7 @@ Status MigrateToLevelBase(std::string dbname, const Options& old_opts,
     // multiplier from 4 to 8, with the same data, we will have fewer
     // levels. Unless we issue a full comaction, the LSM tree may stuck
     // with more levels than needed and it won't recover automatically.
-    return CompactToLevel(opts, dbname, 1, true);
+    return CompactToLevel(opts, dbname, 1, /*l0_file_size=*/0, true);
   } else {
     // Compact everything to the last level to guarantee it can be safely
     // opened.
@@ -127,11 +136,13 @@ Status MigrateToLevelBase(std::string dbname, const Options& old_opts,
       return Status::OK();
     } else if (new_opts.num_levels > old_opts.num_levels) {
       // Dynamic level mode requires data to be put in the last level first.
-      return CompactToLevel(new_opts, dbname, new_opts.num_levels - 1, false);
+      return CompactToLevel(new_opts, dbname, new_opts.num_levels - 1,
+                            /*l0_file_size=*/0, false);
     } else {
       Options opts = old_opts;
       opts.target_file_size_base = new_opts.target_file_size_base;
-      return CompactToLevel(opts, dbname, new_opts.num_levels - 1, true);
+      return CompactToLevel(opts, dbname, new_opts.num_levels - 1,
+                            /*l0_file_size=*/0, true);
     }
   }
 }
@@ -150,7 +161,14 @@ Status OptionChangeMigration(std::string dbname, const Options& old_opts,
     return MigrateToLevelBase(dbname, old_opts, new_opts);
   } else if (new_opts.compaction_style ==
              CompactionStyle::kCompactionStyleFIFO) {
-    return CompactToLevel(old_opts, dbname, 0, true);
+    uint64_t l0_file_size = 0;
+    if (new_opts.compaction_options_fifo.max_table_files_size > 0) {
+      // Create at least 8 files when max_table_files_size hits, so that the DB
+      // doesn't just disappear. This in fact violates the FIFO condition, but
+      // otherwise, the migrated DB is unlikley to be usable.
+      l0_file_size = new_opts.compaction_options_fifo.max_table_files_size / 8;
+    }
+    return CompactToLevel(old_opts, dbname, 0, l0_file_size, true);
   } else {
     return Status::NotSupported(
         "Do not how to migrate to this compaction style");