Du kannst nicht mehr als 25 Themen auswählen Themen müssen mit entweder einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.

format.cc 4.6KB

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