src/leveldb/table/format.cc

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