1 //===-- chunk.h -------------------------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef SCUDO_CHUNK_H_ 10 #define SCUDO_CHUNK_H_ 11 12 #include "platform.h" 13 14 #include "atomic_helpers.h" 15 #include "checksum.h" 16 #include "common.h" 17 #include "report.h" 18 19 namespace scudo { 20 21 extern Checksum HashAlgorithm; 22 23 inline u16 computeChecksum(u32 Seed, uptr Value, uptr *Array, uptr ArraySize) { 24 // If the hardware CRC32 feature is defined here, it was enabled everywhere, 25 // as opposed to only for crc32_hw.cpp. This means that other hardware 26 // specific instructions were likely emitted at other places, and as a result 27 // there is no reason to not use it here. 28 #if defined(__CRC32__) || defined(__SSE4_2__) || defined(__ARM_FEATURE_CRC32) 29 u32 Crc = static_cast<u32>(CRC32_INTRINSIC(Seed, Value)); 30 for (uptr I = 0; I < ArraySize; I++) 31 Crc = static_cast<u32>(CRC32_INTRINSIC(Crc, Array[I])); 32 return static_cast<u16>(Crc ^ (Crc >> 16)); 33 #else 34 if (HashAlgorithm == Checksum::HardwareCRC32) { 35 u32 Crc = computeHardwareCRC32(Seed, Value); 36 for (uptr I = 0; I < ArraySize; I++) 37 Crc = computeHardwareCRC32(Crc, Array[I]); 38 return static_cast<u16>(Crc ^ (Crc >> 16)); 39 } else { 40 u16 Checksum = computeBSDChecksum(static_cast<u16>(Seed), Value); 41 for (uptr I = 0; I < ArraySize; I++) 42 Checksum = computeBSDChecksum(Checksum, Array[I]); 43 return Checksum; 44 } 45 #endif // defined(__CRC32__) || defined(__SSE4_2__) || 46 // defined(__ARM_FEATURE_CRC32) 47 } 48 49 namespace Chunk { 50 51 // Note that in an ideal world, `State` and `Origin` should be `enum class`, and 52 // the associated `UnpackedHeader` fields of their respective enum class type 53 // but https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414 prevents it from 54 // happening, as it will error, complaining the number of bits is not enough. 55 enum Origin : u8 { 56 Malloc = 0, 57 New = 1, 58 NewArray = 2, 59 Memalign = 3, 60 }; 61 62 enum State : u8 { Available = 0, Allocated = 1, Quarantined = 2 }; 63 64 typedef u64 PackedHeader; 65 // Update the 'Mask' constants to reflect changes in this structure. 66 struct UnpackedHeader { 67 uptr ClassId : 8; 68 u8 State : 2; 69 // Origin if State == Allocated, or WasZeroed otherwise. 70 u8 OriginOrWasZeroed : 2; 71 uptr SizeOrUnusedBytes : 20; 72 uptr Offset : 16; 73 uptr Checksum : 16; 74 }; 75 typedef atomic_u64 AtomicPackedHeader; 76 static_assert(sizeof(UnpackedHeader) == sizeof(PackedHeader), ""); 77 78 // Those constants are required to silence some -Werror=conversion errors when 79 // assigning values to the related bitfield variables. 80 constexpr uptr ClassIdMask = (1UL << 8) - 1; 81 constexpr u8 StateMask = (1U << 2) - 1; 82 constexpr u8 OriginMask = (1U << 2) - 1; 83 constexpr uptr SizeOrUnusedBytesMask = (1UL << 20) - 1; 84 constexpr uptr OffsetMask = (1UL << 16) - 1; 85 constexpr uptr ChecksumMask = (1UL << 16) - 1; 86 87 constexpr uptr getHeaderSize() { 88 return roundUp(sizeof(PackedHeader), 1U << SCUDO_MIN_ALIGNMENT_LOG); 89 } 90 91 inline AtomicPackedHeader *getAtomicHeader(void *Ptr) { 92 return reinterpret_cast<AtomicPackedHeader *>(reinterpret_cast<uptr>(Ptr) - 93 getHeaderSize()); 94 } 95 96 inline const AtomicPackedHeader *getConstAtomicHeader(const void *Ptr) { 97 return reinterpret_cast<const AtomicPackedHeader *>( 98 reinterpret_cast<uptr>(Ptr) - getHeaderSize()); 99 } 100 101 // We do not need a cryptographically strong hash for the checksum, but a CRC 102 // type function that can alert us in the event a header is invalid or 103 // corrupted. Ideally slightly better than a simple xor of all fields. 104 static inline u16 computeHeaderChecksum(u32 Cookie, const void *Ptr, 105 UnpackedHeader *Header) { 106 UnpackedHeader ZeroChecksumHeader = *Header; 107 ZeroChecksumHeader.Checksum = 0; 108 uptr HeaderHolder[sizeof(UnpackedHeader) / sizeof(uptr)]; 109 memcpy(&HeaderHolder, &ZeroChecksumHeader, sizeof(HeaderHolder)); 110 return computeChecksum(Cookie, reinterpret_cast<uptr>(Ptr), HeaderHolder, 111 ARRAY_SIZE(HeaderHolder)); 112 } 113 114 inline void storeHeader(u32 Cookie, void *Ptr, 115 UnpackedHeader *NewUnpackedHeader) { 116 NewUnpackedHeader->Checksum = 117 computeHeaderChecksum(Cookie, Ptr, NewUnpackedHeader); 118 PackedHeader NewPackedHeader = bit_cast<PackedHeader>(*NewUnpackedHeader); 119 atomic_store_relaxed(getAtomicHeader(Ptr), NewPackedHeader); 120 } 121 122 inline void loadHeader(u32 Cookie, const void *Ptr, 123 UnpackedHeader *NewUnpackedHeader) { 124 PackedHeader NewPackedHeader = atomic_load_relaxed(getConstAtomicHeader(Ptr)); 125 *NewUnpackedHeader = bit_cast<UnpackedHeader>(NewPackedHeader); 126 if (UNLIKELY(NewUnpackedHeader->Checksum != 127 computeHeaderChecksum(Cookie, Ptr, NewUnpackedHeader))) 128 reportHeaderCorruption(const_cast<void *>(Ptr)); 129 } 130 131 inline bool isValid(u32 Cookie, const void *Ptr, 132 UnpackedHeader *NewUnpackedHeader) { 133 PackedHeader NewPackedHeader = atomic_load_relaxed(getConstAtomicHeader(Ptr)); 134 *NewUnpackedHeader = bit_cast<UnpackedHeader>(NewPackedHeader); 135 return NewUnpackedHeader->Checksum == 136 computeHeaderChecksum(Cookie, Ptr, NewUnpackedHeader); 137 } 138 139 } // namespace Chunk 140 141 } // namespace scudo 142 143 #endif // SCUDO_CHUNK_H_ 144