github.com/cellofellow/gopkg@v0.0.0-20140722061823-eec0544a62ad/database/leveldb.chai2010/src/format.cc (about)

     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::InvalidArgument("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