format.cc 4.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141
  1. // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file. See the AUTHORS file for names of contributors.
  4. #include "table/format.h"
  5. #include "leveldb/env.h"
  6. #include "port/port.h"
  7. #include "table/block.h"
  8. #include "util/coding.h"
  9. #include "util/crc32c.h"
  10. namespace leveldb {
  11. void BlockHandle::EncodeTo(std::string* dst) const {
  12. // Sanity check that all fields have been set
  13. assert(offset_ != ~static_cast<uint64_t>(0));
  14. assert(size_ != ~static_cast<uint64_t>(0));
  15. PutVarint64(dst, offset_);
  16. PutVarint64(dst, size_);
  17. }
  18. Status BlockHandle::DecodeFrom(Slice* input) {
  19. if (GetVarint64(input, &offset_) && GetVarint64(input, &size_)) {
  20. return Status::OK();
  21. } else {
  22. return Status::Corruption("bad block handle");
  23. }
  24. }
  25. void Footer::EncodeTo(std::string* dst) const {
  26. const size_t original_size = dst->size();
  27. metaindex_handle_.EncodeTo(dst);
  28. index_handle_.EncodeTo(dst);
  29. dst->resize(2 * BlockHandle::kMaxEncodedLength); // Padding
  30. PutFixed32(dst, static_cast<uint32_t>(kTableMagicNumber & 0xffffffffu));
  31. PutFixed32(dst, static_cast<uint32_t>(kTableMagicNumber >> 32));
  32. assert(dst->size() == original_size + kEncodedLength);
  33. (void)original_size; // Disable unused variable warning.
  34. }
  35. Status Footer::DecodeFrom(Slice* input) {
  36. const char* magic_ptr = input->data() + kEncodedLength - 8;
  37. const uint32_t magic_lo = DecodeFixed32(magic_ptr);
  38. const uint32_t magic_hi = DecodeFixed32(magic_ptr + 4);
  39. const uint64_t magic = ((static_cast<uint64_t>(magic_hi) << 32) |
  40. (static_cast<uint64_t>(magic_lo)));
  41. if (magic != kTableMagicNumber) {
  42. return Status::Corruption("not an sstable (bad magic number)");
  43. }
  44. Status result = metaindex_handle_.DecodeFrom(input);
  45. if (result.ok()) {
  46. result = index_handle_.DecodeFrom(input);
  47. }
  48. if (result.ok()) {
  49. // We skip over any leftover data (just padding for now) in "input"
  50. const char* end = magic_ptr + 8;
  51. *input = Slice(end, input->data() + input->size() - end);
  52. }
  53. return result;
  54. }
  55. Status ReadBlock(RandomAccessFile* file, const ReadOptions& options,
  56. const BlockHandle& handle, BlockContents* result) {
  57. result->data = Slice();
  58. result->cachable = false;
  59. result->heap_allocated = false;
  60. // Read the block contents as well as the type/crc footer.
  61. // See table_builder.cc for the code that built this structure.
  62. size_t n = static_cast<size_t>(handle.size());
  63. char* buf = new char[n + kBlockTrailerSize];
  64. Slice contents;
  65. Status s = file->Read(handle.offset(), n + kBlockTrailerSize, &contents, buf);
  66. if (!s.ok()) {
  67. delete[] buf;
  68. return s;
  69. }
  70. if (contents.size() != n + kBlockTrailerSize) {
  71. delete[] buf;
  72. return Status::Corruption("truncated block read");
  73. }
  74. // Check the crc of the type and the block contents
  75. const char* data = contents.data(); // Pointer to where Read put the data
  76. if (options.verify_checksums) {
  77. const uint32_t crc = crc32c::Unmask(DecodeFixed32(data + n + 1));
  78. const uint32_t actual = crc32c::Value(data, n + 1);
  79. if (actual != crc) {
  80. delete[] buf;
  81. s = Status::Corruption("block checksum mismatch");
  82. return s;
  83. }
  84. }
  85. switch (data[n]) {
  86. case kNoCompression:
  87. if (data != buf) {
  88. // File implementation gave us pointer to some other data.
  89. // Use it directly under the assumption that it will be live
  90. // while the file is open.
  91. delete[] buf;
  92. result->data = Slice(data, n);
  93. result->heap_allocated = false;
  94. result->cachable = false; // Do not double-cache
  95. } else {
  96. result->data = Slice(buf, n);
  97. result->heap_allocated = true;
  98. result->cachable = true;
  99. }
  100. // Ok
  101. break;
  102. case kSnappyCompression: {
  103. size_t ulength = 0;
  104. if (!port::Snappy_GetUncompressedLength(data, n, &ulength)) {
  105. delete[] buf;
  106. return Status::Corruption("corrupted compressed block contents");
  107. }
  108. char* ubuf = new char[ulength];
  109. if (!port::Snappy_Uncompress(data, n, ubuf)) {
  110. delete[] buf;
  111. delete[] ubuf;
  112. return Status::Corruption("corrupted compressed block contents");
  113. }
  114. delete[] buf;
  115. result->data = Slice(ubuf, ulength);
  116. result->heap_allocated = true;
  117. result->cachable = true;
  118. break;
  119. }
  120. default:
  121. delete[] buf;
  122. return Status::Corruption("bad block type");
  123. }
  124. return Status::OK();
  125. }
  126. } // namespace leveldb