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 19namespace scudo { 20 21extern Checksum HashAlgorithm; 22 23inline 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(__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(__SSE4_2__) || defined(__ARM_FEATURE_CRC32) 46} 47 48namespace Chunk { 49 50// Note that in an ideal world, `State` and `Origin` should be `enum class`, and 51// the associated `UnpackedHeader` fields of their respective enum class type 52// but https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414 prevents it from 53// happening, as it will error, complaining the number of bits is not enough. 54enum Origin : u8 { 55 Malloc = 0, 56 New = 1, 57 NewArray = 2, 58 Memalign = 3, 59}; 60 61enum State : u8 { Available = 0, Allocated = 1, Quarantined = 2 }; 62 63typedef u64 PackedHeader; 64// Update the 'Mask' constants to reflect changes in this structure. 65struct UnpackedHeader { 66 uptr ClassId : 8; 67 u8 State : 2; 68 u8 Origin : 2; 69 uptr SizeOrUnusedBytes : 20; 70 uptr Offset : 16; 71 uptr Checksum : 16; 72}; 73typedef atomic_u64 AtomicPackedHeader; 74static_assert(sizeof(UnpackedHeader) == sizeof(PackedHeader), ""); 75 76// Those constants are required to silence some -Werror=conversion errors when 77// assigning values to the related bitfield variables. 78constexpr uptr ClassIdMask = (1UL << 8) - 1; 79constexpr u8 StateMask = (1U << 2) - 1; 80constexpr u8 OriginMask = (1U << 2) - 1; 81constexpr uptr SizeOrUnusedBytesMask = (1UL << 20) - 1; 82constexpr uptr OffsetMask = (1UL << 16) - 1; 83constexpr uptr ChecksumMask = (1UL << 16) - 1; 84 85constexpr uptr getHeaderSize() { 86 return roundUpTo(sizeof(PackedHeader), 1U << SCUDO_MIN_ALIGNMENT_LOG); 87} 88 89inline AtomicPackedHeader *getAtomicHeader(void *Ptr) { 90 return reinterpret_cast<AtomicPackedHeader *>(reinterpret_cast<uptr>(Ptr) - 91 getHeaderSize()); 92} 93 94inline const AtomicPackedHeader *getConstAtomicHeader(const void *Ptr) { 95 return reinterpret_cast<const AtomicPackedHeader *>( 96 reinterpret_cast<uptr>(Ptr) - getHeaderSize()); 97} 98 99// We do not need a cryptographically strong hash for the checksum, but a CRC 100// type function that can alert us in the event a header is invalid or 101// corrupted. Ideally slightly better than a simple xor of all fields. 102static inline u16 computeHeaderChecksum(u32 Cookie, const void *Ptr, 103 UnpackedHeader *Header) { 104 UnpackedHeader ZeroChecksumHeader = *Header; 105 ZeroChecksumHeader.Checksum = 0; 106 uptr HeaderHolder[sizeof(UnpackedHeader) / sizeof(uptr)]; 107 memcpy(&HeaderHolder, &ZeroChecksumHeader, sizeof(HeaderHolder)); 108 return computeChecksum(Cookie, reinterpret_cast<uptr>(Ptr), HeaderHolder, 109 ARRAY_SIZE(HeaderHolder)); 110} 111 112inline void storeHeader(u32 Cookie, void *Ptr, 113 UnpackedHeader *NewUnpackedHeader) { 114 NewUnpackedHeader->Checksum = 115 computeHeaderChecksum(Cookie, Ptr, NewUnpackedHeader); 116 PackedHeader NewPackedHeader = bit_cast<PackedHeader>(*NewUnpackedHeader); 117 atomic_store_relaxed(getAtomicHeader(Ptr), NewPackedHeader); 118} 119 120inline void loadHeader(u32 Cookie, const void *Ptr, 121 UnpackedHeader *NewUnpackedHeader) { 122 PackedHeader NewPackedHeader = atomic_load_relaxed(getConstAtomicHeader(Ptr)); 123 *NewUnpackedHeader = bit_cast<UnpackedHeader>(NewPackedHeader); 124 if (UNLIKELY(NewUnpackedHeader->Checksum != 125 computeHeaderChecksum(Cookie, Ptr, NewUnpackedHeader))) 126 reportHeaderCorruption(const_cast<void *>(Ptr)); 127} 128 129inline void compareExchangeHeader(u32 Cookie, void *Ptr, 130 UnpackedHeader *NewUnpackedHeader, 131 UnpackedHeader *OldUnpackedHeader) { 132 NewUnpackedHeader->Checksum = 133 computeHeaderChecksum(Cookie, Ptr, NewUnpackedHeader); 134 PackedHeader NewPackedHeader = bit_cast<PackedHeader>(*NewUnpackedHeader); 135 PackedHeader OldPackedHeader = bit_cast<PackedHeader>(*OldUnpackedHeader); 136 if (UNLIKELY(!atomic_compare_exchange_strong( 137 getAtomicHeader(Ptr), &OldPackedHeader, NewPackedHeader, 138 memory_order_relaxed))) 139 reportHeaderRace(Ptr); 140} 141 142inline bool isValid(u32 Cookie, const void *Ptr, 143 UnpackedHeader *NewUnpackedHeader) { 144 PackedHeader NewPackedHeader = atomic_load_relaxed(getConstAtomicHeader(Ptr)); 145 *NewUnpackedHeader = bit_cast<UnpackedHeader>(NewPackedHeader); 146 return NewUnpackedHeader->Checksum == 147 computeHeaderChecksum(Cookie, Ptr, NewUnpackedHeader); 148} 149 150} // namespace Chunk 151 152} // namespace scudo 153 154#endif // SCUDO_CHUNK_H_ 155