1//===-- hwasan.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// This file is a part of HWAddressSanitizer.
10//
11// Private Hwasan header.
12//===----------------------------------------------------------------------===//
13
14#ifndef HWASAN_H
15#define HWASAN_H
16
17#include "sanitizer_common/sanitizer_flags.h"
18#include "sanitizer_common/sanitizer_internal_defs.h"
19#include "sanitizer_common/sanitizer_stacktrace.h"
20#include "hwasan_interface_internal.h"
21#include "hwasan_flags.h"
22#include "ubsan/ubsan_platform.h"
23
24#ifndef HWASAN_REPLACE_OPERATORS_NEW_AND_DELETE
25# define HWASAN_REPLACE_OPERATORS_NEW_AND_DELETE 1
26#endif
27
28#ifndef HWASAN_CONTAINS_UBSAN
29# define HWASAN_CONTAINS_UBSAN CAN_SANITIZE_UB
30#endif
31
32#ifndef HWASAN_WITH_INTERCEPTORS
33#define HWASAN_WITH_INTERCEPTORS 0
34#endif
35
36typedef u8 tag_t;
37
38// TBI (Top Byte Ignore) feature of AArch64: bits [63:56] are ignored in address
39// translation and can be used to store a tag.
40const unsigned kAddressTagShift = 56;
41const uptr kAddressTagMask = 0xFFUL << kAddressTagShift;
42
43// Minimal alignment of the shadow base address. Determines the space available
44// for threads and stack histories. This is an ABI constant.
45const unsigned kShadowBaseAlignment = 32;
46
47const unsigned kRecordAddrBaseTagShift = 3;
48const unsigned kRecordFPShift = 48;
49const unsigned kRecordFPLShift = 4;
50const unsigned kRecordFPModulus = 1 << (64 - kRecordFPShift + kRecordFPLShift);
51
52static inline tag_t GetTagFromPointer(uptr p) {
53  return p >> kAddressTagShift;
54}
55
56static inline uptr UntagAddr(uptr tagged_addr) {
57  return tagged_addr & ~kAddressTagMask;
58}
59
60static inline void *UntagPtr(const void *tagged_ptr) {
61  return reinterpret_cast<void *>(
62      UntagAddr(reinterpret_cast<uptr>(tagged_ptr)));
63}
64
65static inline uptr AddTagToPointer(uptr p, tag_t tag) {
66  return (p & ~kAddressTagMask) | ((uptr)tag << kAddressTagShift);
67}
68
69namespace __hwasan {
70
71extern int hwasan_inited;
72extern bool hwasan_init_is_running;
73extern int hwasan_report_count;
74
75bool ProtectRange(uptr beg, uptr end);
76bool InitShadow();
77void InitPrctl();
78void InitThreads();
79void MadviseShadow();
80char *GetProcSelfMaps();
81void InitializeInterceptors();
82
83void HwasanAllocatorInit();
84void HwasanAllocatorThreadFinish();
85
86void *hwasan_malloc(uptr size, StackTrace *stack);
87void *hwasan_calloc(uptr nmemb, uptr size, StackTrace *stack);
88void *hwasan_realloc(void *ptr, uptr size, StackTrace *stack);
89void *hwasan_reallocarray(void *ptr, uptr nmemb, uptr size, StackTrace *stack);
90void *hwasan_valloc(uptr size, StackTrace *stack);
91void *hwasan_pvalloc(uptr size, StackTrace *stack);
92void *hwasan_aligned_alloc(uptr alignment, uptr size, StackTrace *stack);
93void *hwasan_memalign(uptr alignment, uptr size, StackTrace *stack);
94int hwasan_posix_memalign(void **memptr, uptr alignment, uptr size,
95                        StackTrace *stack);
96void hwasan_free(void *ptr, StackTrace *stack);
97
98void InstallTrapHandler();
99void InstallAtExitHandler();
100
101void EnterSymbolizer();
102void ExitSymbolizer();
103bool IsInSymbolizer();
104
105struct SymbolizerScope {
106  SymbolizerScope() { EnterSymbolizer(); }
107  ~SymbolizerScope() { ExitSymbolizer(); }
108};
109
110// Returns a "chained" origin id, pointing to the given stack trace followed by
111// the previous origin id.
112u32 ChainOrigin(u32 id, StackTrace *stack);
113
114const int STACK_TRACE_TAG_POISON = StackTrace::TAG_CUSTOM + 1;
115
116#define GET_MALLOC_STACK_TRACE                                            \
117  BufferedStackTrace stack;                                               \
118  if (hwasan_inited)                                                      \
119    stack.Unwind(StackTrace::GetCurrentPc(), GET_CURRENT_FRAME(),         \
120                 nullptr, common_flags()->fast_unwind_on_malloc,          \
121                 common_flags()->malloc_context_size)
122
123#define GET_FATAL_STACK_TRACE_PC_BP(pc, bp)              \
124  BufferedStackTrace stack;                              \
125  if (hwasan_inited)                                     \
126    stack.Unwind(pc, bp, nullptr, common_flags()->fast_unwind_on_fatal)
127
128#define GET_FATAL_STACK_TRACE_HERE \
129  GET_FATAL_STACK_TRACE_PC_BP(StackTrace::GetCurrentPc(), GET_CURRENT_FRAME())
130
131#define PRINT_CURRENT_STACK_CHECK() \
132  {                                 \
133    GET_FATAL_STACK_TRACE_HERE;     \
134    stack.Print();                  \
135  }
136
137class ScopedThreadLocalStateBackup {
138 public:
139  ScopedThreadLocalStateBackup() { Backup(); }
140  ~ScopedThreadLocalStateBackup() { Restore(); }
141  void Backup();
142  void Restore();
143 private:
144  u64 va_arg_overflow_size_tls;
145};
146
147void HwasanTSDInit();
148void HwasanTSDThreadInit();
149
150void HwasanOnDeadlySignal(int signo, void *info, void *context);
151
152void UpdateMemoryUsage();
153
154void AppendToErrorMessageBuffer(const char *buffer);
155
156void AndroidTestTlsSlot();
157
158}  // namespace __hwasan
159
160#define HWASAN_MALLOC_HOOK(ptr, size)       \
161  do {                                    \
162    if (&__sanitizer_malloc_hook) {       \
163      __sanitizer_malloc_hook(ptr, size); \
164    }                                     \
165    RunMallocHooks(ptr, size);            \
166  } while (false)
167#define HWASAN_FREE_HOOK(ptr)       \
168  do {                            \
169    if (&__sanitizer_free_hook) { \
170      __sanitizer_free_hook(ptr); \
171    }                             \
172    RunFreeHooks(ptr);            \
173  } while (false)
174
175#if HWASAN_WITH_INTERCEPTORS && defined(__aarch64__)
176// For both bionic and glibc __sigset_t is an unsigned long.
177typedef unsigned long __hw_sigset_t;
178// Setjmp and longjmp implementations are platform specific, and hence the
179// interception code is platform specific too.  As yet we've only implemented
180// the interception for AArch64.
181typedef unsigned long long __hw_register_buf[22];
182struct __hw_jmp_buf_struct {
183  // NOTE: The machine-dependent definition of `__sigsetjmp'
184  // assume that a `__hw_jmp_buf' begins with a `__hw_register_buf' and that
185  // `__mask_was_saved' follows it.  Do not move these members or add others
186  // before it.
187  __hw_register_buf __jmpbuf; // Calling environment.
188  int __mask_was_saved;       // Saved the signal mask?
189  __hw_sigset_t __saved_mask; // Saved signal mask.
190};
191typedef struct __hw_jmp_buf_struct __hw_jmp_buf[1];
192typedef struct __hw_jmp_buf_struct __hw_sigjmp_buf[1];
193#endif // HWASAN_WITH_INTERCEPTORS && __aarch64__
194
195#endif  // HWASAN_H
196