1 files changed, 117 insertions, 0 deletions
diff --git a/storage/rocksdb/rocksdb/util/file_checksum_helper.h b/storage/rocksdb/rocksdb/util/file_checksum_helper.h
new file mode 100644
index 00000000..7ad9ea73
--- /dev/null
+++ b/storage/rocksdb/rocksdb/util/file_checksum_helper.h
@@ -0,0 +1,117 @@
+//  Copyright (c) 2011-present, Facebook, Inc.  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 <cassert>
+#include <unordered_map>
+#include "port/port.h"
+#include "rocksdb/file_checksum.h"
+#include "rocksdb/status.h"
+#include "util/crc32c.h"
+#include "util/string_util.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+// This is the class to generate the file checksum based on Crc32. It
+// will be used as the default checksum method for SST file checksum
+class FileChecksumFuncCrc32c : public FileChecksumFunc {
+ public:
+  std::string Extend(const std::string& init_checksum, const char* data,
+                     size_t n) override {
+    assert(data != nullptr);
+    uint32_t checksum_value = StringToUint32(init_checksum);
+    return Uint32ToString(crc32c::Extend(checksum_value, data, n));
+  }
+
+  std::string Value(const char* data, size_t n) override {
+    assert(data != nullptr);
+    return Uint32ToString(crc32c::Value(data, n));
+  }
+
+  std::string ProcessChecksum(const std::string& checksum) override {
+    uint32_t checksum_value = StringToUint32(checksum);
+    return Uint32ToString(crc32c::Mask(checksum_value));
+  }
+
+  const char* Name() const override { return "FileChecksumCrc32c"; }
+
+  // Convert a uint32_t type data into a 4 bytes string.
+  static std::string Uint32ToString(uint32_t v) {
+    std::string s;
+    if (port::kLittleEndian) {
+      s.append(reinterpret_cast<char*>(&v), sizeof(v));
+    } else {
+      char buf[sizeof(v)];
+      buf[0] = v & 0xff;
+      buf[1] = (v >> 8) & 0xff;
+      buf[2] = (v >> 16) & 0xff;
+      buf[3] = (v >> 24) & 0xff;
+      s.append(buf, sizeof(v));
+    }
+    size_t i = 0, j = s.size() - 1;
+    while (i < j) {
+      char tmp = s[i];
+      s[i] = s[j];
+      s[j] = tmp;
+      ++i;
+      --j;
+    }
+    return s;
+  }
+
+  // Convert a 4 bytes size string into a uint32_t type data.
+  static uint32_t StringToUint32(std::string s) {
+    assert(s.size() == sizeof(uint32_t));
+    size_t i = 0, j = s.size() - 1;
+    while (i < j) {
+      char tmp = s[i];
+      s[i] = s[j];
+      s[j] = tmp;
+      ++i;
+      --j;
+    }
+    uint32_t v = 0;
+    if (port::kLittleEndian) {
+      memcpy(&v, s.c_str(), sizeof(uint32_t));
+    } else {
+      const char* buf = s.c_str();
+      v |= static_cast<uint32_t>(buf[0]);
+      v |= (static_cast<uint32_t>(buf[1]) << 8);
+      v |= (static_cast<uint32_t>(buf[2]) << 16);
+      v |= (static_cast<uint32_t>(buf[3]) << 24);
+    }
+    return v;
+  }
+};
+
+// The default implementaion of FileChecksumList
+class FileChecksumListImpl : public FileChecksumList {
+ public:
+  FileChecksumListImpl() {}
+  void reset() override;
+
+  size_t size() const override;
+
+  Status GetAllFileChecksums(
+      std::vector<uint64_t>* file_numbers, std::vector<std::string>* checksums,
+      std::vector<std::string>* checksum_func_names) override;
+
+  Status SearchOneFileChecksum(uint64_t file_number, std::string* checksum,
+                               std::string* checksum_func_name) override;
+
+  Status InsertOneFileChecksum(uint64_t file_number,
+                               const std::string& checksum,
+                               const std::string& checksum_func_name) override;
+
+  Status RemoveOneFileChecksum(uint64_t file_number) override;
+
+ private:
+  // Key is the file number, the first portion of the value is checksum, the
+  // second portion of the value is checksum function name.
+  std::unordered_map<uint64_t, std::pair<std::string, std::string>>
+      checksum_map_;
+};
+
+}  // namespace ROCKSDB_NAMESPACE