|
|
|
// Copyright (c) 2013, Facebook, Inc. All rights reserved.
|
|
|
|
// This source code is licensed under the BSD-style license found in the
|
|
|
|
// LICENSE file in the root directory of this source tree. An additional grant
|
|
|
|
// of patent rights can be found in the PATENTS file in the same directory.
|
|
|
|
//
|
|
|
|
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
|
|
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string>
|
|
|
|
#include "rocksdb/comparator.h"
|
|
|
|
#include "rocksdb/db.h"
|
|
|
|
#include "rocksdb/filter_policy.h"
|
|
|
|
#include "rocksdb/slice.h"
|
|
|
|
#include "rocksdb/slice_transform.h"
|
|
|
|
#include "rocksdb/table.h"
|
|
|
|
#include "rocksdb/types.h"
|
|
|
|
#include "util/coding.h"
|
|
|
|
#include "util/logging.h"
|
|
|
|
|
|
|
|
namespace rocksdb {
|
|
|
|
|
|
|
|
class InternalKey;
|
|
|
|
|
|
|
|
// Value types encoded as the last component of internal keys.
|
|
|
|
// DO NOT CHANGE THESE ENUM VALUES: they are embedded in the on-disk
|
|
|
|
// data structures.
|
|
|
|
// The highest bit of the value type needs to be reserved to SST tables
|
|
|
|
// for them to do more flexible encoding.
|
|
|
|
enum ValueType : unsigned char {
|
|
|
|
kTypeDeletion = 0x0,
|
|
|
|
kTypeValue = 0x1,
|
|
|
|
kTypeMerge = 0x2,
|
|
|
|
// Following types are used only in write ahead logs. They are not used in
|
|
|
|
// memtables or sst files:
|
|
|
|
kTypeLogData = 0x3,
|
|
|
|
kTypeColumnFamilyDeletion = 0x4,
|
|
|
|
kTypeColumnFamilyValue = 0x5,
|
|
|
|
kTypeColumnFamilyMerge = 0x6,
|
|
|
|
kMaxValue = 0x7F
|
|
|
|
};
|
|
|
|
|
|
|
|
// kValueTypeForSeek defines the ValueType that should be passed when
|
|
|
|
// constructing a ParsedInternalKey object for seeking to a particular
|
|
|
|
// sequence number (since we sort sequence numbers in decreasing order
|
|
|
|
// and the value type is embedded as the low 8 bits in the sequence
|
|
|
|
// number in internal keys, we need to use the highest-numbered
|
|
|
|
// ValueType, not the lowest).
|
|
|
|
static const ValueType kValueTypeForSeek = kTypeMerge;
|
|
|
|
|
|
|
|
// We leave eight bits empty at the bottom so a type and sequence#
|
|
|
|
// can be packed together into 64-bits.
|
|
|
|
static const SequenceNumber kMaxSequenceNumber =
|
|
|
|
((0x1ull << 56) - 1);
|
|
|
|
|
|
|
|
struct ParsedInternalKey {
|
|
|
|
Slice user_key;
|
|
|
|
SequenceNumber sequence;
|
|
|
|
ValueType type;
|
|
|
|
|
|
|
|
ParsedInternalKey() { } // Intentionally left uninitialized (for speed)
|
|
|
|
ParsedInternalKey(const Slice& u, const SequenceNumber& seq, ValueType t)
|
|
|
|
: user_key(u), sequence(seq), type(t) { }
|
|
|
|
std::string DebugString(bool hex = false) const;
|
|
|
|
};
|
|
|
|
|
|
|
|
// Return the length of the encoding of "key".
|
|
|
|
inline size_t InternalKeyEncodingLength(const ParsedInternalKey& key) {
|
|
|
|
return key.user_key.size() + 8;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern uint64_t PackSequenceAndType(uint64_t seq, ValueType t);
|
|
|
|
|
|
|
|
// Append the serialization of "key" to *result.
|
|
|
|
extern void AppendInternalKey(std::string* result,
|
|
|
|
const ParsedInternalKey& key);
|
|
|
|
|
|
|
|
// Attempt to parse an internal key from "internal_key". On success,
|
|
|
|
// stores the parsed data in "*result", and returns true.
|
|
|
|
//
|
|
|
|
// On error, returns false, leaves "*result" in an undefined state.
|
|
|
|
extern bool ParseInternalKey(const Slice& internal_key,
|
|
|
|
ParsedInternalKey* result);
|
|
|
|
|
|
|
|
// Returns the user key portion of an internal key.
|
|
|
|
inline Slice ExtractUserKey(const Slice& internal_key) {
|
|
|
|
assert(internal_key.size() >= 8);
|
|
|
|
return Slice(internal_key.data(), internal_key.size() - 8);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline ValueType ExtractValueType(const Slice& internal_key) {
|
|
|
|
assert(internal_key.size() >= 8);
|
|
|
|
const size_t n = internal_key.size();
|
|
|
|
uint64_t num = DecodeFixed64(internal_key.data() + n - 8);
|
|
|
|
unsigned char c = num & 0xff;
|
|
|
|
return static_cast<ValueType>(c);
|
|
|
|
}
|
|
|
|
|
|
|
|
// A comparator for internal keys that uses a specified comparator for
|
|
|
|
// the user key portion and breaks ties by decreasing sequence number.
|
|
|
|
class InternalKeyComparator : public Comparator {
|
|
|
|
private:
|
|
|
|
const Comparator* user_comparator_;
|
|
|
|
std::string name_;
|
|
|
|
public:
|
|
|
|
explicit InternalKeyComparator(const Comparator* c) : user_comparator_(c),
|
|
|
|
name_("rocksdb.InternalKeyComparator:" +
|
|
|
|
std::string(user_comparator_->Name())) {
|
|
|
|
}
|
|
|
|
virtual ~InternalKeyComparator() {}
|
|
|
|
|
|
|
|
virtual const char* Name() const;
|
|
|
|
virtual int Compare(const Slice& a, const Slice& b) const;
|
|
|
|
virtual void FindShortestSeparator(
|
|
|
|
std::string* start,
|
|
|
|
const Slice& limit) const;
|
|
|
|
virtual void FindShortSuccessor(std::string* key) const;
|
|
|
|
|
|
|
|
const Comparator* user_comparator() const { return user_comparator_; }
|
|
|
|
|
|
|
|
int Compare(const InternalKey& a, const InternalKey& b) const;
|
|
|
|
int Compare(const ParsedInternalKey& a, const ParsedInternalKey& b) const;
|
|
|
|
};
|
|
|
|
|
|
|
|
// Modules in this directory should keep internal keys wrapped inside
|
|
|
|
// the following class instead of plain strings so that we do not
|
|
|
|
// incorrectly use string comparisons instead of an InternalKeyComparator.
|
|
|
|
class InternalKey {
|
|
|
|
private:
|
|
|
|
std::string rep_;
|
|
|
|
public:
|
|
|
|
InternalKey() { } // Leave rep_ as empty to indicate it is invalid
|
|
|
|
InternalKey(const Slice& _user_key, SequenceNumber s, ValueType t) {
|
|
|
|
AppendInternalKey(&rep_, ParsedInternalKey(_user_key, s, t));
|
|
|
|
}
|
|
|
|
|
[fix] SIGSEGV when VersionEdit in MANIFEST is corrupted
Summary:
This was reported by our customers in task #4295529.
Cause:
* MANIFEST file contains a VersionEdit, which contains file entries whose 'smallest' and 'largest' internal keys are empty. String with zero characters. Root cause of corruption was not investigated. We should report corruption when this happens. However, we currently SIGSEGV.
Here's what happens:
* VersionEdit encodes zero-strings happily and stores them in smallest and largest InternalKeys. InternalKey::Encode() does assert when `rep_.empty()`, but we don't assert in production environemnts. Also, we should never assert as a result of DB corruption.
* As part of our ConsistencyCheck, we call GetLiveFilesMetaData()
* GetLiveFilesMetadata() calls `file->largest.user_key().ToString()`
* user_key() function does: 1. assert(size > 8) (ooops, no assert), 2. returns `Slice(internal_key.data(), internal_key.size() - 8)`
* since `internal_key.size()` is unsigned int, this call translates to `Slice(whatever, 1298471928561892576182756)`. Bazinga.
Fix:
* VersionEdit checks if InternalKey is valid in `VersionEdit::GetInternalKey()`. If it's invalid, returns corruption.
Lessons learned:
* Always keep in mind that even if you `assert()`, production code will continue execution even if assert fails.
* Never `assert` based on DB corruption. Assert only if the code should guarantee that assert can't fail.
Test Plan: dumped offending manifest. Before: assert. Now: corruption
Reviewers: dhruba, haobo, sdong
Reviewed By: dhruba
CC: leveldb
Differential Revision: https://reviews.facebook.net/D18507
10 years ago
|
|
|
bool Valid() const {
|
|
|
|
ParsedInternalKey parsed;
|
|
|
|
return ParseInternalKey(Slice(rep_), &parsed);
|
|
|
|
}
|
|
|
|
|
|
|
|
void DecodeFrom(const Slice& s) { rep_.assign(s.data(), s.size()); }
|
|
|
|
Slice Encode() const {
|
|
|
|
assert(!rep_.empty());
|
|
|
|
return rep_;
|
|
|
|
}
|
|
|
|
|
|
|
|
Slice user_key() const { return ExtractUserKey(rep_); }
|
|
|
|
|
|
|
|
void SetFrom(const ParsedInternalKey& p) {
|
|
|
|
rep_.clear();
|
|
|
|
AppendInternalKey(&rep_, p);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Clear() { rep_.clear(); }
|
|
|
|
|
|
|
|
std::string DebugString(bool hex = false) const;
|
|
|
|
};
|
|
|
|
|
|
|
|
inline int InternalKeyComparator::Compare(
|
|
|
|
const InternalKey& a, const InternalKey& b) const {
|
|
|
|
return Compare(a.Encode(), b.Encode());
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool ParseInternalKey(const Slice& internal_key,
|
|
|
|
ParsedInternalKey* result) {
|
|
|
|
const size_t n = internal_key.size();
|
|
|
|
if (n < 8) return false;
|
|
|
|
uint64_t num = DecodeFixed64(internal_key.data() + n - 8);
|
|
|
|
unsigned char c = num & 0xff;
|
|
|
|
result->sequence = num >> 8;
|
|
|
|
result->type = static_cast<ValueType>(c);
|
|
|
|
assert(result->type <= ValueType::kMaxValue);
|
|
|
|
result->user_key = Slice(internal_key.data(), n - 8);
|
|
|
|
return (c <= static_cast<unsigned char>(kValueTypeForSeek));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Update the sequence number in the internal key
|
|
|
|
inline void UpdateInternalKey(char* internal_key,
|
|
|
|
const size_t internal_key_size,
|
|
|
|
uint64_t seq, ValueType t) {
|
|
|
|
assert(internal_key_size >= 8);
|
|
|
|
char* seqtype = internal_key + internal_key_size - 8;
|
|
|
|
uint64_t newval = (seq << 8) | t;
|
|
|
|
EncodeFixed64(seqtype, newval);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get the sequence number from the internal key
|
|
|
|
inline uint64_t GetInternalKeySeqno(const Slice& internal_key) {
|
|
|
|
const size_t n = internal_key.size();
|
|
|
|
assert(n >= 8);
|
|
|
|
uint64_t num = DecodeFixed64(internal_key.data() + n - 8);
|
|
|
|
return num >> 8;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// A helper class useful for DBImpl::Get()
|
|
|
|
class LookupKey {
|
|
|
|
public:
|
|
|
|
// Initialize *this for looking up user_key at a snapshot with
|
|
|
|
// the specified sequence number.
|
|
|
|
LookupKey(const Slice& _user_key, SequenceNumber sequence);
|
|
|
|
|
|
|
|
~LookupKey();
|
|
|
|
|
|
|
|
// Return a key suitable for lookup in a MemTable.
|
|
|
|
Slice memtable_key() const { return Slice(start_, end_ - start_); }
|
|
|
|
|
|
|
|
// Return an internal key (suitable for passing to an internal iterator)
|
|
|
|
Slice internal_key() const { return Slice(kstart_, end_ - kstart_); }
|
|
|
|
|
|
|
|
// Return the user key
|
|
|
|
Slice user_key() const { return Slice(kstart_, end_ - kstart_ - 8); }
|
|
|
|
|
|
|
|
private:
|
|
|
|
// We construct a char array of the form:
|
|
|
|
// klength varint32 <-- start_
|
|
|
|
// userkey char[klength] <-- kstart_
|
|
|
|
// tag uint64
|
|
|
|
// <-- end_
|
|
|
|
// The array is a suitable MemTable key.
|
|
|
|
// The suffix starting with "userkey" can be used as an InternalKey.
|
|
|
|
const char* start_;
|
|
|
|
const char* kstart_;
|
|
|
|
const char* end_;
|
|
|
|
char space_[200]; // Avoid allocation for short keys
|
|
|
|
|
|
|
|
// No copying allowed
|
|
|
|
LookupKey(const LookupKey&);
|
|
|
|
void operator=(const LookupKey&);
|
|
|
|
};
|
|
|
|
|
|
|
|
inline LookupKey::~LookupKey() {
|
|
|
|
if (start_ != space_) delete[] start_;
|
|
|
|
}
|
|
|
|
|
|
|
|
class IterKey {
|
|
|
|
public:
|
|
|
|
IterKey() : key_(space_), buf_size_(sizeof(space_)), key_size_(0) {}
|
|
|
|
|
|
|
|
~IterKey() { ResetBuffer(); }
|
|
|
|
|
|
|
|
Slice GetKey() const { return Slice(key_, key_size_); }
|
|
|
|
|
|
|
|
size_t Size() { return key_size_; }
|
|
|
|
|
|
|
|
void Clear() { key_size_ = 0; }
|
|
|
|
|
|
|
|
// Append "non_shared_data" to its back, from "shared_len"
|
|
|
|
// This function is used in Block::Iter::ParseNextKey
|
|
|
|
// shared_len: bytes in [0, shard_len-1] would be remained
|
|
|
|
// non_shared_data: data to be append, its length must be >= non_shared_len
|
|
|
|
void TrimAppend(const size_t shared_len, const char* non_shared_data,
|
|
|
|
const size_t non_shared_len) {
|
|
|
|
assert(shared_len <= key_size_);
|
|
|
|
|
|
|
|
size_t total_size = shared_len + non_shared_len;
|
|
|
|
if (total_size <= buf_size_) {
|
|
|
|
key_size_ = total_size;
|
|
|
|
} else {
|
|
|
|
// Need to allocate space, delete previous space
|
|
|
|
char* p = new char[total_size];
|
|
|
|
memcpy(p, key_, shared_len);
|
|
|
|
|
|
|
|
if (key_ != nullptr && key_ != space_) {
|
|
|
|
delete[] key_;
|
|
|
|
}
|
|
|
|
|
|
|
|
key_ = p;
|
|
|
|
key_size_ = total_size;
|
|
|
|
buf_size_ = total_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(key_ + shared_len, non_shared_data, non_shared_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SetKey(const Slice& key) {
|
|
|
|
size_t size = key.size();
|
|
|
|
EnlargeBufferIfNeeded(size);
|
|
|
|
memcpy(key_, key.data(), size);
|
|
|
|
key_size_ = size;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SetInternalKey(const Slice& key_prefix, const Slice& user_key,
|
|
|
|
SequenceNumber s,
|
|
|
|
ValueType value_type = kValueTypeForSeek) {
|
|
|
|
size_t psize = key_prefix.size();
|
|
|
|
size_t usize = user_key.size();
|
|
|
|
EnlargeBufferIfNeeded(psize + usize + sizeof(uint64_t));
|
|
|
|
if (psize > 0) {
|
|
|
|
memcpy(key_, key_prefix.data(), psize);
|
|
|
|
}
|
|
|
|
memcpy(key_ + psize, user_key.data(), usize);
|
|
|
|
EncodeFixed64(key_ + usize + psize, PackSequenceAndType(s, value_type));
|
|
|
|
key_size_ = psize + usize + sizeof(uint64_t);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SetInternalKey(const Slice& user_key, SequenceNumber s,
|
|
|
|
ValueType value_type = kValueTypeForSeek) {
|
|
|
|
SetInternalKey(Slice(), user_key, s, value_type);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Reserve(size_t size) {
|
|
|
|
EnlargeBufferIfNeeded(size);
|
|
|
|
key_size_ = size;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SetInternalKey(const ParsedInternalKey& parsed_key) {
|
|
|
|
SetInternalKey(Slice(), parsed_key);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SetInternalKey(const Slice& key_prefix,
|
|
|
|
const ParsedInternalKey& parsed_key_suffix) {
|
|
|
|
SetInternalKey(key_prefix, parsed_key_suffix.user_key,
|
|
|
|
parsed_key_suffix.sequence, parsed_key_suffix.type);
|
|
|
|
}
|
|
|
|
|
|
|
|
void EncodeLengthPrefixedKey(const Slice& key) {
|
|
|
|
auto size = key.size();
|
|
|
|
EnlargeBufferIfNeeded(size + VarintLength(size));
|
|
|
|
char* ptr = EncodeVarint32(key_, size);
|
|
|
|
memcpy(ptr, key.data(), size);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
char* key_;
|
|
|
|
size_t buf_size_;
|
|
|
|
size_t key_size_;
|
|
|
|
char space_[32]; // Avoid allocation for short keys
|
|
|
|
|
|
|
|
void ResetBuffer() {
|
|
|
|
if (key_ != nullptr && key_ != space_) {
|
|
|
|
delete[] key_;
|
|
|
|
}
|
|
|
|
key_ = space_;
|
|
|
|
buf_size_ = sizeof(space_);
|
|
|
|
key_size_ = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Enlarge the buffer size if needed based on key_size.
|
|
|
|
// By default, static allocated buffer is used. Once there is a key
|
|
|
|
// larger than the static allocated buffer, another buffer is dynamically
|
|
|
|
// allocated, until a larger key buffer is requested. In that case, we
|
|
|
|
// reallocate buffer and delete the old one.
|
|
|
|
void EnlargeBufferIfNeeded(size_t key_size) {
|
|
|
|
// If size is smaller than buffer size, continue using current buffer,
|
|
|
|
// or the static allocated one, as default
|
|
|
|
if (key_size > buf_size_) {
|
|
|
|
// Need to enlarge the buffer.
|
|
|
|
ResetBuffer();
|
|
|
|
key_ = new char[key_size];
|
|
|
|
buf_size_ = key_size;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// No copying allowed
|
|
|
|
IterKey(const IterKey&) = delete;
|
|
|
|
void operator=(const IterKey&) = delete;
|
|
|
|
};
|
|
|
|
|
|
|
|
class InternalKeySliceTransform : public SliceTransform {
|
|
|
|
public:
|
|
|
|
explicit InternalKeySliceTransform(const SliceTransform* transform)
|
|
|
|
: transform_(transform) {}
|
|
|
|
|
|
|
|
virtual const char* Name() const { return transform_->Name(); }
|
|
|
|
|
|
|
|
virtual Slice Transform(const Slice& src) const {
|
|
|
|
auto user_key = ExtractUserKey(src);
|
|
|
|
return transform_->Transform(user_key);
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual bool InDomain(const Slice& src) const {
|
|
|
|
auto user_key = ExtractUserKey(src);
|
|
|
|
return transform_->InDomain(user_key);
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual bool InRange(const Slice& dst) const {
|
|
|
|
auto user_key = ExtractUserKey(dst);
|
|
|
|
return transform_->InRange(user_key);
|
|
|
|
}
|
|
|
|
|
|
|
|
const SliceTransform* user_prefix_extractor() const { return transform_; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
// Like comparator, InternalKeySliceTransform will not take care of the
|
|
|
|
// deletion of transform_
|
|
|
|
const SliceTransform* const transform_;
|
|
|
|
};
|
|
|
|
|
|
|
|
// Read record from a write batch piece from input.
|
|
|
|
// tag, column_family, key, value and blob are return values. Callers own the
|
|
|
|
// Slice they point to.
|
|
|
|
// Tag is defined as ValueType.
|
|
|
|
// input will be advanced to after the record.
|
|
|
|
extern Status ReadRecordFromWriteBatch(Slice* input, char* tag,
|
|
|
|
uint32_t* column_family, Slice* key,
|
|
|
|
Slice* value, Slice* blob);
|
|
|
|
} // namespace rocksdb
|