mirror of
https://github.com/facebook/rocksdb.git
synced 2024-11-30 22:41:48 +00:00
54cb9c77d9
Summary: The following are risks associated with pointer-to-pointer reinterpret_cast: * Can produce the "wrong result" (crash or memory corruption). IIRC, in theory this can happen for any up-cast or down-cast for a non-standard-layout type, though in practice would only happen for multiple inheritance cases (where the base class pointer might be "inside" the derived object). We don't use multiple inheritance a lot, but we do. * Can mask useful compiler errors upon code change, including converting between unrelated pointer types that you are expecting to be related, and converting between pointer and scalar types unintentionally. I can only think of some obscure cases where static_cast could be troublesome when it compiles as a replacement: * Going through `void*` could plausibly cause unnecessary or broken pointer arithmetic. Suppose we have `struct Derived: public Base1, public Base2`. If we have `Derived*` -> `void*` -> `Base2*` -> `Derived*` through reinterpret casts, this could plausibly work (though technical UB) assuming the `Base2*` is not dereferenced. Changing to static cast could introduce breaking pointer arithmetic. * Unnecessary (but safe) pointer arithmetic could arise in a case like `Derived*` -> `Base2*` -> `Derived*` where before the Base2 pointer might not have been dereferenced. This could potentially affect performance. With some light scripting, I tried replacing pointer-to-pointer reinterpret_casts with static_cast and kept the cases that still compile. Most occurrences of reinterpret_cast have successfully been changed (except for java/ and third-party/). 294 changed, 257 remain. A couple of related interventions included here: * Previously Cache::Handle was not actually derived from in the implementations and just used as a `void*` stand-in with reinterpret_cast. Now there is a relationship to allow static_cast. In theory, this could introduce pointer arithmetic (as described above) but is unlikely without multiple inheritance AND non-empty Cache::Handle. * Remove some unnecessary casts to void* as this is allowed to be implicit (for better or worse). Most of the remaining reinterpret_casts are for converting to/from raw bytes of objects. We could consider better idioms for these patterns in follow-up work. I wish there were a way to implement a template variant of static_cast that would only compile if no pointer arithmetic is generated, but best I can tell, this is not possible. AFAIK the best you could do is a dynamic check that the void* conversion after the static cast is unchanged. Pull Request resolved: https://github.com/facebook/rocksdb/pull/12308 Test Plan: existing tests, CI Reviewed By: ltamasi Differential Revision: D53204947 Pulled By: pdillinger fbshipit-source-id: 9de23e618263b0d5b9820f4e15966876888a16e2
65 lines
2.5 KiB
C++
65 lines
2.5 KiB
C++
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
|
// This source code is licensed under both the GPLv2 (found in the
|
|
// COPYING file in the root directory) and Apache 2.0 License
|
|
// (found in the LICENSE.Apache file in the root 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.
|
|
#include "table/block_based/reader_common.h"
|
|
|
|
#include "monitoring/perf_context_imp.h"
|
|
#include "rocksdb/table.h"
|
|
#include "table/format.h"
|
|
#include "util/coding.h"
|
|
#include "util/crc32c.h"
|
|
#include "util/string_util.h"
|
|
|
|
namespace ROCKSDB_NAMESPACE {
|
|
void ForceReleaseCachedEntry(void* arg, void* h) {
|
|
Cache* cache = static_cast<Cache*>(arg);
|
|
Cache::Handle* handle = static_cast<Cache::Handle*>(h);
|
|
cache->Release(handle, true /* erase_if_last_ref */);
|
|
}
|
|
|
|
// WART: this is specific to block-based table
|
|
Status VerifyBlockChecksum(const Footer& footer, const char* data,
|
|
size_t block_size, const std::string& file_name,
|
|
uint64_t offset) {
|
|
PERF_TIMER_GUARD(block_checksum_time);
|
|
|
|
assert(footer.GetBlockTrailerSize() == 5);
|
|
ChecksumType type = footer.checksum_type();
|
|
|
|
// After block_size bytes is compression type (1 byte), which is part of
|
|
// the checksummed section.
|
|
size_t len = block_size + 1;
|
|
// And then the stored checksum value (4 bytes).
|
|
uint32_t stored = DecodeFixed32(data + len);
|
|
|
|
uint32_t computed = ComputeBuiltinChecksum(type, data, len);
|
|
|
|
// Unapply context to 'stored' rather than apply to 'computed, for people
|
|
// who might look for reference crc value in error message
|
|
uint32_t modifier =
|
|
ChecksumModifierForContext(footer.base_context_checksum(), offset);
|
|
stored -= modifier;
|
|
|
|
if (stored == computed) {
|
|
return Status::OK();
|
|
} else {
|
|
// Unmask for people who might look for reference crc value
|
|
if (type == kCRC32c) {
|
|
stored = crc32c::Unmask(stored);
|
|
computed = crc32c::Unmask(computed);
|
|
}
|
|
return Status::Corruption(
|
|
"block checksum mismatch: stored" +
|
|
std::string(modifier ? "(context removed)" : "") + " = " +
|
|
std::to_string(stored) + ", computed = " + std::to_string(computed) +
|
|
", type = " + std::to_string(type) + " in " + file_name + " offset " +
|
|
std::to_string(offset) + " size " + std::to_string(block_size));
|
|
}
|
|
}
|
|
} // namespace ROCKSDB_NAMESPACE
|