mirror of
https://github.com/Zygo/bees.git
synced 2025-05-17 21:35:45 +02:00
7f660f50b8
The Linux kernel's btrfs headers are better than the libbtrfs-dev headers: - the libbtrfs-dev headers have C++ language compatibility issues - upstream version in Linux kernel is more accurate and up to date - macros in libbtrfs-dev's ctree.h hide information that would enable bees to perform runtime buffer length checking - enum types whose presence cannot be detected with #ifdef When accessing members of metadata items from the filesystem, we want to verify that the member we are accessing is within the boundaries of the item that was retrieved; otherwise, a memory access violation may occur or garbage may be returned to the caller. A simple C++ template, given a pointer to a structure member and a buffer, can determine that the buffer contains enough bytes to safely access a struct member. This was implemented back in 2016, but left unused due to ctree.h issues. Some btrfs metadata structures have variable length despite using a fixed-size in-memory structure. The members that appear earliest in the structure contain information about which following members of the structure are used. The item stored in the filesystem is truncated after the last used member, and all following members must not be accessed. 'btrfs_stack_*' accessor macros obscure the memory boundaries of the members they access, which makes it impossible for a C++ template to verify the memory access. If the template checks the length of the entire structure, it will find an access violation for variable-length metadata items because the item is rarely large enough for the entire structure. Get rid of all the libbtrfs-dev accessor macros and reimplement them with the necessary buffer length checks. Signed-off-by: Zygo Blaxell <bees@furryterror.org>
59 lines
1.2 KiB
C++
59 lines
1.2 KiB
C++
#ifndef CRUCIBLE_ENDIAN_H
|
|
#define CRUCIBLE_ENDIAN_H
|
|
|
|
#include <cstdint>
|
|
|
|
#include <endian.h>
|
|
|
|
namespace crucible {
|
|
|
|
template<class T>
|
|
struct le_to_cpu_helper {
|
|
T operator()(const T v);
|
|
};
|
|
|
|
template<> struct le_to_cpu_helper<uint64_t> {
|
|
uint64_t operator()(const uint64_t v) { return le64toh(v); }
|
|
};
|
|
|
|
#if __SIZEOF_LONG__ == 8
|
|
// uint64_t is unsigned long on LP64 platforms
|
|
template<> struct le_to_cpu_helper<unsigned long long> {
|
|
unsigned long long operator()(const unsigned long long v) { return le64toh(v); }
|
|
};
|
|
#endif
|
|
|
|
template<> struct le_to_cpu_helper<uint32_t> {
|
|
uint32_t operator()(const uint32_t v) { return le32toh(v); }
|
|
};
|
|
|
|
template<> struct le_to_cpu_helper<uint16_t> {
|
|
uint16_t operator()(const uint16_t v) { return le64toh(v); }
|
|
};
|
|
|
|
template<> struct le_to_cpu_helper<uint8_t> {
|
|
uint8_t operator()(const uint8_t v) { return v; }
|
|
};
|
|
|
|
template<class T>
|
|
T
|
|
le_to_cpu(const T v)
|
|
{
|
|
return le_to_cpu_helper<T>()(v);
|
|
}
|
|
|
|
template<class T>
|
|
T
|
|
get_unaligned(const void *const p)
|
|
{
|
|
struct not_aligned {
|
|
T v;
|
|
} __attribute__((packed));
|
|
const not_aligned *const nap = reinterpret_cast<const not_aligned*>(p);
|
|
return nap->v;
|
|
}
|
|
|
|
}
|
|
|
|
#endif // CRUCIBLE_ENDIAN_H
|