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