1 //===-- hwasan.h ------------------------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file is a part of HWAddressSanitizer.
11 //
12 // Private Hwasan header.
13 //===----------------------------------------------------------------------===//
14
15 #ifndef HWASAN_H
16 #define HWASAN_H
17
18 #include "sanitizer_common/sanitizer_flags.h"
19 #include "sanitizer_common/sanitizer_internal_defs.h"
20 #include "sanitizer_common/sanitizer_stacktrace.h"
21 #include "hwasan_interface_internal.h"
22 #include "hwasan_flags.h"
23 #include "ubsan/ubsan_platform.h"
24
25 #ifndef HWASAN_REPLACE_OPERATORS_NEW_AND_DELETE
26 # define HWASAN_REPLACE_OPERATORS_NEW_AND_DELETE 1
27 #endif
28
29 #ifndef HWASAN_CONTAINS_UBSAN
30 # define HWASAN_CONTAINS_UBSAN CAN_SANITIZE_UB
31 #endif
32
33 #ifndef HWASAN_WITH_INTERCEPTORS
34 #define HWASAN_WITH_INTERCEPTORS 0
35 #endif
36
37 typedef u8 tag_t;
38
39 // TBI (Top Byte Ignore) feature of AArch64: bits [63:56] are ignored in address
40 // translation and can be used to store a tag.
41 const unsigned kAddressTagShift = 56;
42 const uptr kAddressTagMask = 0xFFUL << kAddressTagShift;
43
44 // Minimal alignment of the shadow base address. Determines the space available
45 // for threads and stack histories. This is an ABI constant.
46 const unsigned kShadowBaseAlignment = 32;
47
GetTagFromPointer(uptr p)48 static inline tag_t GetTagFromPointer(uptr p) {
49 return p >> kAddressTagShift;
50 }
51
UntagAddr(uptr tagged_addr)52 static inline uptr UntagAddr(uptr tagged_addr) {
53 return tagged_addr & ~kAddressTagMask;
54 }
55
UntagPtr(const void * tagged_ptr)56 static inline void *UntagPtr(const void *tagged_ptr) {
57 return reinterpret_cast<void *>(
58 UntagAddr(reinterpret_cast<uptr>(tagged_ptr)));
59 }
60
AddTagToPointer(uptr p,tag_t tag)61 static inline uptr AddTagToPointer(uptr p, tag_t tag) {
62 return (p & ~kAddressTagMask) | ((uptr)tag << kAddressTagShift);
63 }
64
65 namespace __hwasan {
66
67 extern int hwasan_inited;
68 extern bool hwasan_init_is_running;
69 extern int hwasan_report_count;
70
71 bool ProtectRange(uptr beg, uptr end);
72 bool InitShadow();
73 void InitThreads();
74 void MadviseShadow();
75 char *GetProcSelfMaps();
76 void InitializeInterceptors();
77
78 void HwasanAllocatorInit();
79 void HwasanAllocatorThreadFinish();
80
81 void *hwasan_malloc(uptr size, StackTrace *stack);
82 void *hwasan_calloc(uptr nmemb, uptr size, StackTrace *stack);
83 void *hwasan_realloc(void *ptr, uptr size, StackTrace *stack);
84 void *hwasan_valloc(uptr size, StackTrace *stack);
85 void *hwasan_pvalloc(uptr size, StackTrace *stack);
86 void *hwasan_aligned_alloc(uptr alignment, uptr size, StackTrace *stack);
87 void *hwasan_memalign(uptr alignment, uptr size, StackTrace *stack);
88 int hwasan_posix_memalign(void **memptr, uptr alignment, uptr size,
89 StackTrace *stack);
90 void hwasan_free(void *ptr, StackTrace *stack);
91
92 void InstallTrapHandler();
93 void InstallAtExitHandler();
94
95 const char *GetStackOriginDescr(u32 id, uptr *pc);
96 const char *GetStackFrameDescr(uptr pc);
97
98 void EnterSymbolizer();
99 void ExitSymbolizer();
100 bool IsInSymbolizer();
101
102 struct SymbolizerScope {
SymbolizerScopeSymbolizerScope103 SymbolizerScope() { EnterSymbolizer(); }
~SymbolizerScopeSymbolizerScope104 ~SymbolizerScope() { ExitSymbolizer(); }
105 };
106
107 void GetStackTrace(BufferedStackTrace *stack, uptr max_s, uptr pc, uptr bp,
108 void *context, bool request_fast_unwind);
109
110 // Returns a "chained" origin id, pointing to the given stack trace followed by
111 // the previous origin id.
112 u32 ChainOrigin(u32 id, StackTrace *stack);
113
114 const int STACK_TRACE_TAG_POISON = StackTrace::TAG_CUSTOM + 1;
115
116 #define GET_MALLOC_STACK_TRACE \
117 BufferedStackTrace stack; \
118 if (hwasan_inited) \
119 GetStackTrace(&stack, common_flags()->malloc_context_size, \
120 StackTrace::GetCurrentPc(), GET_CURRENT_FRAME(), nullptr, \
121 common_flags()->fast_unwind_on_malloc)
122
123 #define GET_FATAL_STACK_TRACE_PC_BP(pc, bp) \
124 BufferedStackTrace stack; \
125 if (hwasan_inited) \
126 GetStackTrace(&stack, kStackTraceMax, pc, bp, nullptr, \
127 common_flags()->fast_unwind_on_fatal)
128
129 #define GET_FATAL_STACK_TRACE_HERE \
130 GET_FATAL_STACK_TRACE_PC_BP(StackTrace::GetCurrentPc(), GET_CURRENT_FRAME())
131
132 #define PRINT_CURRENT_STACK_CHECK() \
133 { \
134 GET_FATAL_STACK_TRACE_HERE; \
135 stack.Print(); \
136 }
137
138 class ScopedThreadLocalStateBackup {
139 public:
ScopedThreadLocalStateBackup()140 ScopedThreadLocalStateBackup() { Backup(); }
~ScopedThreadLocalStateBackup()141 ~ScopedThreadLocalStateBackup() { Restore(); }
142 void Backup();
143 void Restore();
144 private:
145 u64 va_arg_overflow_size_tls;
146 };
147
148 void HwasanTSDInit();
149 void HwasanTSDThreadInit();
150
151 void HwasanOnDeadlySignal(int signo, void *info, void *context);
152
153 void UpdateMemoryUsage();
154
155 void AppendToErrorMessageBuffer(const char *buffer);
156
157 void AndroidTestTlsSlot();
158
159 } // namespace __hwasan
160
161 #define HWASAN_MALLOC_HOOK(ptr, size) \
162 do { \
163 if (&__sanitizer_malloc_hook) { \
164 __sanitizer_malloc_hook(ptr, size); \
165 } \
166 RunMallocHooks(ptr, size); \
167 } while (false)
168 #define HWASAN_FREE_HOOK(ptr) \
169 do { \
170 if (&__sanitizer_free_hook) { \
171 __sanitizer_free_hook(ptr); \
172 } \
173 RunFreeHooks(ptr); \
174 } while (false)
175
176 #endif // HWASAN_H
177