@nxtedition/rocksdb 13.5.7 → 13.5.9

package/deps/rocksdb/rocksdb/db/log_reader.cc

@@ -24,7 +24,10 @@ Reader::Reporter::~Reporter() = default;
 
 Reader::Reader(std::shared_ptr<Logger> info_log,
                std::unique_ptr<SequentialFileReader>&& _file,
-               Reporter* reporter, bool checksum, uint64_t log_num)
+               Reporter* reporter, bool checksum, uint64_t log_num,
+               bool track_and_verify_wals, bool stop_replay_for_corruption,
+               uint64_t min_wal_number_to_keep,
+               const PredecessorWALInfo& observed_predecessor_wal_info)
     : info_log_(info_log),
       file_(std::move(_file)),
       reporter_(reporter),
@@ -37,13 +40,17 @@ Reader::Reader(std::shared_ptr<Logger> info_log,
       last_record_offset_(0),
       end_of_buffer_offset_(0),
       log_number_(log_num),
+      track_and_verify_wals_(track_and_verify_wals),
+      stop_replay_for_corruption_(stop_replay_for_corruption),
+      min_wal_number_to_keep_(min_wal_number_to_keep),
+      observed_predecessor_wal_info_(observed_predecessor_wal_info),
       recycled_(false),
       first_record_read_(false),
       compression_type_(kNoCompression),
       compression_type_record_read_(false),
       uncompress_(nullptr),
       hash_state_(nullptr),
-      uncompress_hash_state_(nullptr){}
+      uncompress_hash_state_(nullptr) {}
 
 Reader::~Reader() {
   delete[] backing_store_;
@@ -65,6 +72,9 @@ Reader::~Reader() {
 //
 // TODO krad: Evaluate if we need to move to a more strict mode where we
 // restrict the inconsistency to only the last log
+// TODO (hx235): move `wal_recovery_mode` to be a member data like other
+// information (e.g, `stop_replay_for_corruption`) to decide whether to
+// check for and surface corruption in `ReadRecord()`
 bool Reader::ReadRecord(Slice* record, std::string* scratch,
                         WALRecoveryMode wal_recovery_mode,
                         uint64_t* record_checksum) {
@@ -88,7 +98,7 @@ bool Reader::ReadRecord(Slice* record, std::string* scratch,
   while (true) {
     uint64_t physical_record_offset = end_of_buffer_offset_ - buffer_.size();
     size_t drop_size = 0;
-    const unsigned int record_type =
+    const uint8_t record_type =
         ReadPhysicalRecord(&fragment, &drop_size, record_checksum);
     switch (record_type) {
       case kFullType:
@@ -185,6 +195,23 @@ bool Reader::ReadRecord(Slice* record, std::string* scratch,
         }
         break;
       }
+      case kPredecessorWALInfoType:
+      case kRecyclePredecessorWALInfoType: {
+        prospective_record_offset = physical_record_offset;
+        scratch->clear();
+        last_record_offset_ = prospective_record_offset;
+
+        PredecessorWALInfo recorded_predecessor_wal_info;
+        Status s = recorded_predecessor_wal_info.DecodeFrom(&fragment);
+        if (!s.ok()) {
+          ReportCorruption(fragment.size(),
+                           "could not decode PredecessorWALInfoType record");
+        } else {
+          MaybeVerifyPredecessorWALInfo(wal_recovery_mode, fragment,
+                                        recorded_predecessor_wal_info);
+        }
+        break;
+      }
       case kUserDefinedTimestampSizeType:
       case kRecyclableUserDefinedTimestampSizeType: {
         if (in_fragmented_record && !scratch->empty()) {
@@ -313,11 +340,13 @@ bool Reader::ReadRecord(Slice* record, std::string* scratch,
         break;
 
       default: {
-        std::string reason =
-            "unknown record type " + std::to_string(record_type);
-        ReportCorruption(
-            (fragment.size() + (in_fragmented_record ? scratch->size() : 0)),
-            reason.c_str());
+        if ((record_type & kRecordTypeSafeIgnoreMask) == 0) {
+          std::string reason =
+              "unknown record type " + std::to_string(record_type);
+          ReportCorruption(
+              (fragment.size() + (in_fragmented_record ? scratch->size() : 0)),
+              reason.c_str());
+        }
         in_fragmented_record = false;
         scratch->clear();
         break;
@@ -327,6 +356,61 @@ bool Reader::ReadRecord(Slice* record, std::string* scratch,
   return false;
 }
 
+void Reader::MaybeVerifyPredecessorWALInfo(
+    WALRecoveryMode wal_recovery_mode, Slice fragment,
+    const PredecessorWALInfo& recorded_predecessor_wal_info) {
+  if (!track_and_verify_wals_ ||
+      wal_recovery_mode == WALRecoveryMode::kSkipAnyCorruptedRecords ||
+      stop_replay_for_corruption_) {
+    return;
+  }
+  assert(recorded_predecessor_wal_info.IsInitialized());
+  uint64_t recorded_predecessor_log_number =
+      recorded_predecessor_wal_info.GetLogNumber();
+
+  // This is the first WAL recovered thus with no predecessor WAL info has been
+  // initialized
+  if (!observed_predecessor_wal_info_.IsInitialized()) {
+    if (recorded_predecessor_log_number >= min_wal_number_to_keep_) {
+      std::string reason = "Missing WAL of log number " +
+                           std::to_string(recorded_predecessor_log_number);
+      ReportCorruption(fragment.size(), reason.c_str(),
+                       recorded_predecessor_log_number);
+    }
+  } else {
+    if (observed_predecessor_wal_info_.GetLogNumber() !=
+        recorded_predecessor_log_number) {
+      std::string reason = "Missing WAL of log number " +
+                           std::to_string(recorded_predecessor_log_number);
+      ReportCorruption(fragment.size(), reason.c_str(),
+                       recorded_predecessor_log_number);
+    } else if (observed_predecessor_wal_info_.GetLastSeqnoRecorded() !=
+               recorded_predecessor_wal_info.GetLastSeqnoRecorded()) {
+      std::string reason =
+          "Mismatched last sequence number recorded in the WAL of log number " +
+          std::to_string(recorded_predecessor_log_number) + ". Recorded " +
+          std::to_string(recorded_predecessor_wal_info.GetLastSeqnoRecorded()) +
+          ". Observed " +
+          std::to_string(
+              observed_predecessor_wal_info_.GetLastSeqnoRecorded()) +
+          ". (Last sequence number equal to 0 indicates no WAL records)";
+      ReportCorruption(fragment.size(), reason.c_str(),
+                       recorded_predecessor_log_number);
+    } else if (observed_predecessor_wal_info_.GetSizeBytes() !=
+               recorded_predecessor_wal_info.GetSizeBytes()) {
+      std::string reason =
+          "Mismatched size of the WAL of log number " +
+          std::to_string(recorded_predecessor_log_number) + ". Recorded " +
+          std::to_string(recorded_predecessor_wal_info.GetSizeBytes()) +
+          " bytes. Observed " +
+          std::to_string(observed_predecessor_wal_info_.GetSizeBytes()) +
+          " bytes.";
+      ReportCorruption(fragment.size(), reason.c_str(),
+                       recorded_predecessor_log_number);
+    }
+  }
+}
+
 uint64_t Reader::LastRecordOffset() { return last_record_offset_; }
 
 uint64_t Reader::LastRecordEnd() {
@@ -403,13 +487,15 @@ void Reader::UnmarkEOFInternal() {
   }
 }
 
-void Reader::ReportCorruption(size_t bytes, const char* reason) {
-  ReportDrop(bytes, Status::Corruption(reason));
+void Reader::ReportCorruption(size_t bytes, const char* reason,
+                              uint64_t log_number) {
+  ReportDrop(bytes, Status::Corruption(reason), log_number);
 }
 
-void Reader::ReportDrop(size_t bytes, const Status& reason) {
+void Reader::ReportDrop(size_t bytes, const Status& reason,
+                        uint64_t log_number) {
   if (reporter_ != nullptr) {
-    reporter_->Corruption(bytes, reason);
+    reporter_->Corruption(bytes, reason, log_number);
   }
 }
 
@@ -419,7 +505,7 @@ void Reader::ReportOldLogRecord(size_t bytes) {
   }
 }
 
-bool Reader::ReadMore(size_t* drop_size, int* error) {
+bool Reader::ReadMore(size_t* drop_size, uint8_t* error) {
   if (!eof_ && !read_error_) {
     // Last read was a full read, so this is a trailer to skip
     buffer_.clear();
@@ -460,15 +546,15 @@ bool Reader::ReadMore(size_t* drop_size, int* error) {
   }
 }
 
-unsigned int Reader::ReadPhysicalRecord(Slice* result, size_t* drop_size,
-                                        uint64_t* fragment_checksum) {
+uint8_t Reader::ReadPhysicalRecord(Slice* result, size_t* drop_size,
+                                   uint64_t* fragment_checksum) {
   while (true) {
     // We need at least the minimum header size
     if (buffer_.size() < static_cast<size_t>(kHeaderSize)) {
       // the default value of r is meaningless because ReadMore will overwrite
       // it if it returns false; in case it returns true, the return value will
       // not be used anyway
-      int r = kEof;
+      uint8_t r = kEof;
       if (!ReadMore(drop_size, &r)) {
         return r;
       }
@@ -479,12 +565,13 @@ unsigned int Reader::ReadPhysicalRecord(Slice* result, size_t* drop_size,
     const char* header = buffer_.data();
     const uint32_t a = static_cast<uint32_t>(header[4]) & 0xff;
     const uint32_t b = static_cast<uint32_t>(header[5]) & 0xff;
-    const unsigned int type = header[6];
+    const uint8_t type = static_cast<uint8_t>(header[6]);
     const uint32_t length = a | (b << 8);
     int header_size = kHeaderSize;
     const bool is_recyclable_type =
         ((type >= kRecyclableFullType && type <= kRecyclableLastType) ||
-         type == kRecyclableUserDefinedTimestampSizeType);
+         type == kRecyclableUserDefinedTimestampSizeType ||
+         type == kRecyclePredecessorWALInfoType);
     if (is_recyclable_type) {
       header_size = kRecyclableHeaderSize;
       if (first_record_read_ && !recycled_) {
@@ -494,7 +581,7 @@ unsigned int Reader::ReadPhysicalRecord(Slice* result, size_t* drop_size,
       recycled_ = true;
       // We need enough for the larger header
       if (buffer_.size() < static_cast<size_t>(kRecyclableHeaderSize)) {
-        int r = kEof;
+        uint8_t r = kEof;
         if (!ReadMore(drop_size, &r)) {
           return r;
         }
@@ -549,6 +636,8 @@ unsigned int Reader::ReadPhysicalRecord(Slice* result, size_t* drop_size,
     buffer_.remove_prefix(header_size + length);
 
     if (!uncompress_ || type == kSetCompressionType ||
+        type == kPredecessorWALInfoType ||
+        type == kRecyclePredecessorWALInfoType ||
         type == kUserDefinedTimestampSizeType ||
         type == kRecyclableUserDefinedTimestampSizeType) {
       *result = Slice(header + header_size, length);
@@ -638,7 +727,9 @@ Status Reader::UpdateRecordedTimestampSize(
 }
 
 bool FragmentBufferedReader::ReadRecord(Slice* record, std::string* scratch,
-                                        WALRecoveryMode /*unused*/,
+                                        WALRecoveryMode wal_recovery_mode
+
+                                        ,
                                         uint64_t* /* checksum */) {
   assert(record != nullptr);
   assert(scratch != nullptr);
@@ -651,7 +742,7 @@ bool FragmentBufferedReader::ReadRecord(Slice* record, std::string* scratch,
   uint64_t prospective_record_offset = 0;
   uint64_t physical_record_offset = end_of_buffer_offset_ - buffer_.size();
   size_t drop_size = 0;
-  unsigned int fragment_type_or_err = 0;  // Initialize to make compiler happy
+  uint8_t fragment_type_or_err = 0;  // Initialize to make compiler happy
   Slice fragment;
   while (TryReadFragment(&fragment, &drop_size, &fragment_type_or_err)) {
     switch (fragment_type_or_err) {
@@ -728,7 +819,24 @@ bool FragmentBufferedReader::ReadRecord(Slice* record, std::string* scratch,
         }
         break;
       }
+      case kPredecessorWALInfoType:
+      case kRecyclePredecessorWALInfoType: {
+        fragments_.clear();
+        prospective_record_offset = physical_record_offset;
+        last_record_offset_ = prospective_record_offset;
+        in_fragmented_record_ = false;
 
+        PredecessorWALInfo recorded_predecessor_wal_info;
+        Status s = recorded_predecessor_wal_info.DecodeFrom(&fragment);
+        if (!s.ok()) {
+          ReportCorruption(fragment.size(),
+                           "could not decode PredecessorWALInfoType record");
+        } else {
+          MaybeVerifyPredecessorWALInfo(wal_recovery_mode, fragment,
+                                        recorded_predecessor_wal_info);
+        }
+        break;
+      }
       case kUserDefinedTimestampSizeType:
       case kRecyclableUserDefinedTimestampSizeType: {
         if (in_fragmented_record_ && !scratch->empty()) {
@@ -781,11 +889,13 @@ bool FragmentBufferedReader::ReadRecord(Slice* record, std::string* scratch,
         break;
 
       default: {
-        std::string reason =
-            "unknown record type " + std::to_string(fragment_type_or_err);
-        ReportCorruption(
-            fragment.size() + (in_fragmented_record_ ? fragments_.size() : 0),
-            reason.c_str());
+        if ((fragment_type_or_err & kRecordTypeSafeIgnoreMask) == 0) {
+          std::string reason =
+              "unknown record type " + std::to_string(fragment_type_or_err);
+          ReportCorruption(
+              fragment.size() + (in_fragmented_record_ ? fragments_.size() : 0),
+              reason.c_str());
+        }
         in_fragmented_record_ = false;
         fragments_.clear();
         break;
@@ -803,7 +913,7 @@ void FragmentBufferedReader::UnmarkEOF() {
   UnmarkEOFInternal();
 }
 
-bool FragmentBufferedReader::TryReadMore(size_t* drop_size, int* error) {
+bool FragmentBufferedReader::TryReadMore(size_t* drop_size, uint8_t* error) {
   if (!eof_ && !read_error_) {
     // Last read was a full read, so this is a trailer to skip
     buffer_.clear();
@@ -844,15 +954,15 @@ bool FragmentBufferedReader::TryReadMore(size_t* drop_size, int* error) {
 }
 
 // return true if the caller should process the fragment_type_or_err.
-bool FragmentBufferedReader::TryReadFragment(
-    Slice* fragment, size_t* drop_size, unsigned int* fragment_type_or_err) {
+bool FragmentBufferedReader::TryReadFragment(Slice* fragment, size_t* drop_size,
+                                             uint8_t* fragment_type_or_err) {
   assert(fragment != nullptr);
   assert(drop_size != nullptr);
   assert(fragment_type_or_err != nullptr);
 
   while (buffer_.size() < static_cast<size_t>(kHeaderSize)) {
     size_t old_size = buffer_.size();
-    int error = kEof;
+    uint8_t error = kEof;
     if (!TryReadMore(drop_size, &error)) {
       *fragment_type_or_err = error;
       return false;
@@ -863,11 +973,12 @@ bool FragmentBufferedReader::TryReadFragment(
   const char* header = buffer_.data();
   const uint32_t a = static_cast<uint32_t>(header[4]) & 0xff;
   const uint32_t b = static_cast<uint32_t>(header[5]) & 0xff;
-  const unsigned int type = header[6];
+  const uint8_t type = static_cast<uint8_t>(header[6]);
   const uint32_t length = a | (b << 8);
   int header_size = kHeaderSize;
   if ((type >= kRecyclableFullType && type <= kRecyclableLastType) ||
-      type == kRecyclableUserDefinedTimestampSizeType) {
+      type == kRecyclableUserDefinedTimestampSizeType ||
+      type == kRecyclePredecessorWALInfoType) {
     if (first_record_read_ && !recycled_) {
       // A recycled log should have started with a recycled record
       *fragment_type_or_err = kBadRecord;
@@ -877,7 +988,7 @@ bool FragmentBufferedReader::TryReadFragment(
     header_size = kRecyclableHeaderSize;
     while (buffer_.size() < static_cast<size_t>(kRecyclableHeaderSize)) {
       size_t old_size = buffer_.size();
-      int error = kEof;
+      uint8_t error = kEof;
       if (!TryReadMore(drop_size, &error)) {
         *fragment_type_or_err = error;
         return false;
@@ -894,7 +1005,7 @@ bool FragmentBufferedReader::TryReadFragment(
 
   while (header_size + length > buffer_.size()) {
     size_t old_size = buffer_.size();
-    int error = kEof;
+    uint8_t error = kEof;
     if (!TryReadMore(drop_size, &error)) {
       *fragment_type_or_err = error;
       return false;
@@ -923,6 +1034,8 @@ bool FragmentBufferedReader::TryReadFragment(
   buffer_.remove_prefix(header_size + length);
 
   if (!uncompress_ || type == kSetCompressionType ||
+      type == kPredecessorWALInfoType ||
+      type == kRecyclePredecessorWALInfoType ||
       type == kUserDefinedTimestampSizeType ||
       type == kRecyclableUserDefinedTimestampSizeType) {
     *fragment = Slice(header + header_size, length);

package/deps/rocksdb/rocksdb/db/log_reader.h

@@ -10,6 +10,7 @@
 #pragma once
 #include <stdint.h>
 
+#include <cstdint>
 #include <memory>
 #include <unordered_map>
 #include <vector>
@@ -44,7 +45,8 @@ class Reader {
 
     // Some corruption was detected.  "size" is the approximate number
     // of bytes dropped due to the corruption.
-    virtual void Corruption(size_t bytes, const Status& status) = 0;
+    virtual void Corruption(size_t bytes, const Status& status,
+                            uint64_t log_number = kMaxSequenceNumber) = 0;
 
     virtual void OldLogRecord(size_t /*bytes*/) {}
   };
@@ -57,9 +59,15 @@ class Reader {
   // live while this Reader is in use.
   //
   // If "checksum" is true, verify checksums if available.
+  // TODO(hx235): seperate WAL related parameters from general `Reader`
+  // parameters
   Reader(std::shared_ptr<Logger> info_log,
          std::unique_ptr<SequentialFileReader>&& file, Reporter* reporter,
-         bool checksum, uint64_t log_num);
+         bool checksum, uint64_t log_num, bool track_and_verify_wals = false,
+         bool stop_replay_for_corruption = false,
+         uint64_t min_wal_number_to_keep = std::numeric_limits<uint64_t>::max(),
+         const PredecessorWALInfo& observed_predecessor_wal_info =
+             PredecessorWALInfo());
   // No copying allowed
   Reader(const Reader&) = delete;
   void operator=(const Reader&) = delete;
@@ -147,6 +155,17 @@ class Reader {
   // which log number this is
   uint64_t const log_number_;
 
+  // See `Optinos::track_and_verify_wals`
+  bool track_and_verify_wals_;
+  // Below variables are used for WAL verification
+  // TODO(hx235): To revise `stop_replay_for_corruption_` inside `LogReader`
+  // since we have `observed_predecessor_wal_info_` to verify against the
+  // `recorded_predecessor_wal_info_` recorded in current WAL. If there is no
+  // WAL hole, we can revise `stop_replay_for_corruption_` to be false.
+  bool stop_replay_for_corruption_;
+  uint64_t min_wal_number_to_keep_;
+  PredecessorWALInfo observed_predecessor_wal_info_;
+
   // Whether this is a recycled log file
   bool recycled_;
 
@@ -171,7 +190,7 @@ class Reader {
   UnorderedMap<uint32_t, size_t> recorded_cf_to_ts_sz_;
 
   // Extend record types with the following special values
-  enum {
+  enum : uint8_t {
     kEof = kMaxRecordType + 1,
     // Returned whenever we find an invalid physical record.
     // Currently there are three situations in which this happens:
@@ -192,24 +211,30 @@ class Reader {
   // If WAL compressioned is enabled, fragment_checksum is the checksum of the
   // fragment computed from the orginal buffer containinng uncompressed
   // fragment.
-  unsigned int ReadPhysicalRecord(Slice* result, size_t* drop_size,
-                                  uint64_t* fragment_checksum = nullptr);
+  uint8_t ReadPhysicalRecord(Slice* result, size_t* drop_size,
+                             uint64_t* fragment_checksum = nullptr);
 
   // Read some more
-  bool ReadMore(size_t* drop_size, int* error);
+  bool ReadMore(size_t* drop_size, uint8_t* error);
 
   void UnmarkEOFInternal();
 
   // Reports dropped bytes to the reporter.
   // buffer_ must be updated to remove the dropped bytes prior to invocation.
-  void ReportCorruption(size_t bytes, const char* reason);
-  void ReportDrop(size_t bytes, const Status& reason);
+  void ReportCorruption(size_t bytes, const char* reason,
+                        uint64_t log_number = kMaxSequenceNumber);
+  void ReportDrop(size_t bytes, const Status& reason,
+                  uint64_t log_number = kMaxSequenceNumber);
   void ReportOldLogRecord(size_t bytes);
 
   void InitCompression(const CompressionTypeRecord& compression_record);
 
   Status UpdateRecordedTimestampSize(
       const std::vector<std::pair<uint32_t, size_t>>& cf_to_ts_sz);
+
+  void MaybeVerifyPredecessorWALInfo(
+      WALRecoveryMode wal_recovery_mode, Slice fragment,
+      const PredecessorWALInfo& recorded_predecessor_wal_info);
 };
 
 class FragmentBufferedReader : public Reader {
@@ -217,7 +242,11 @@ class FragmentBufferedReader : public Reader {
   FragmentBufferedReader(std::shared_ptr<Logger> info_log,
                          std::unique_ptr<SequentialFileReader>&& _file,
                          Reporter* reporter, bool checksum, uint64_t log_num)
-      : Reader(info_log, std::move(_file), reporter, checksum, log_num),
+      : Reader(info_log, std::move(_file), reporter, checksum, log_num,
+               false /*verify_and_track_wals*/,
+               false /*stop_replay_for_corruption*/,
+               std::numeric_limits<uint64_t>::max() /*min_wal_number_to_keep*/,
+               PredecessorWALInfo() /*observed_predecessor_wal_info*/),
         fragments_(),
         in_fragmented_record_(false) {}
   ~FragmentBufferedReader() override {}
@@ -232,9 +261,9 @@ class FragmentBufferedReader : public Reader {
   bool in_fragmented_record_;
 
   bool TryReadFragment(Slice* result, size_t* drop_size,
-                       unsigned int* fragment_type_or_err);
+                       uint8_t* fragment_type_or_err);
 
-  bool TryReadMore(size_t* drop_size, int* error);
+  bool TryReadMore(size_t* drop_size, uint8_t* error);
 
   // No copy allowed
   FragmentBufferedReader(const FragmentBufferedReader&);

package/deps/rocksdb/rocksdb/db/log_test.cc

@@ -129,7 +129,8 @@ class LogTest
     std::string message_;
 
     ReportCollector() : dropped_bytes_(0) {}
-    void Corruption(size_t bytes, const Status& status) override {
+    void Corruption(size_t bytes, const Status& status,
+                    uint64_t /*log_number*/ = kMaxSequenceNumber) override {
       dropped_bytes_ += bytes;
       message_.append(status.ToString());
     }
@@ -436,6 +437,17 @@ TEST_P(LogTest, BadRecordType) {
   ASSERT_EQ("OK", MatchError("unknown record type"));
 }
 
+TEST_P(LogTest, IgnorableRecordType) {
+  Write("foo");
+  // Type is stored in header[6]
+  SetByte(6, static_cast<char>(kRecordTypeSafeIgnoreMask + 100));
+  FixChecksum(0, 3, false);
+  ASSERT_EQ("EOF", Read());
+  // The new type has value 129 and masked to be ignorable if unknown
+  ASSERT_EQ(0U, DroppedBytes());
+  ASSERT_EQ("", ReportMessage());
+}
+
 TEST_P(LogTest, TruncatedTrailingRecordIsIgnored) {
   Write("foo");
   ShrinkSize(4);  // Drop all payload as well as a header byte
@@ -454,7 +466,7 @@ TEST_P(LogTest, TruncatedTrailingRecordIsNotIgnored) {
   Write("foo");
   ShrinkSize(4);  // Drop all payload as well as a header byte
   ASSERT_EQ("EOF", Read(WALRecoveryMode::kAbsoluteConsistency));
-  // Truncated last record is ignored, not treated as an error
+  // Truncated last record is not ignored, treated as an error
   ASSERT_GT(DroppedBytes(), 0U);
   ASSERT_EQ("OK", MatchError("Corruption: truncated header"));
 }
@@ -814,7 +826,8 @@ class RetriableLogTest : public ::testing::TestWithParam<int> {
     std::string message_;
 
     ReportCollector() : dropped_bytes_(0) {}
-    void Corruption(size_t bytes, const Status& status) override {
+    void Corruption(size_t bytes, const Status& status,
+                    uint64_t /*log_number*/ = kMaxSequenceNumber) override {
       dropped_bytes_ += bytes;
       message_.append(status.ToString());
     }