1//===-- hwasan_allocation_functions.cpp -----------------------------------===//
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// Definitions for __sanitizer allocation functions.
12//
13//===----------------------------------------------------------------------===//
14
15#include "hwasan.h"
16#include "interception/interception.h"
17#include "sanitizer_common/sanitizer_allocator_dlsym.h"
18#include "sanitizer_common/sanitizer_allocator_interface.h"
19#include "sanitizer_common/sanitizer_mallinfo.h"
20#include "sanitizer_common/sanitizer_platform_interceptors.h"
21
22using namespace __hwasan;
23
24struct DlsymAlloc : public DlSymAllocator<DlsymAlloc> {
25 static bool UseImpl() { return !hwasan_inited; }
26 static void OnAllocate(const void *ptr, uptr size) {
27# if CAN_SANITIZE_LEAKS
28 // Suppress leaks from dlerror(). Previously dlsym hack on global array was
29 // used by leak sanitizer as a root region.
30 __lsan_register_root_region(ptr, size);
31# endif
32 }
33 static void OnFree(const void *ptr, uptr size) {
34# if CAN_SANITIZE_LEAKS
35 __lsan_unregister_root_region(ptr, size);
36# endif
37 }
38};
39
40extern "C" {
41
42SANITIZER_INTERFACE_ATTRIBUTE
43int __sanitizer_posix_memalign(void **memptr, uptr alignment, uptr size) {
44 GET_MALLOC_STACK_TRACE;
45 CHECK_NE(memptr, 0);
46 int res = hwasan_posix_memalign(memptr, alignment, size, stack: &stack);
47 return res;
48}
49
50SANITIZER_INTERFACE_ATTRIBUTE
51void *__sanitizer_memalign(uptr alignment, uptr size) {
52 GET_MALLOC_STACK_TRACE;
53 return hwasan_memalign(alignment, size, stack: &stack);
54}
55
56SANITIZER_INTERFACE_ATTRIBUTE
57void *__sanitizer_aligned_alloc(uptr alignment, uptr size) {
58 GET_MALLOC_STACK_TRACE;
59 return hwasan_aligned_alloc(alignment, size, stack: &stack);
60}
61
62SANITIZER_INTERFACE_ATTRIBUTE
63void *__sanitizer___libc_memalign(uptr alignment, uptr size) {
64 GET_MALLOC_STACK_TRACE;
65 return hwasan_memalign(alignment, size, stack: &stack);
66}
67
68SANITIZER_INTERFACE_ATTRIBUTE
69void *__sanitizer_valloc(uptr size) {
70 GET_MALLOC_STACK_TRACE;
71 return hwasan_valloc(size, stack: &stack);
72}
73
74SANITIZER_INTERFACE_ATTRIBUTE
75void *__sanitizer_pvalloc(uptr size) {
76 GET_MALLOC_STACK_TRACE;
77 return hwasan_pvalloc(size, stack: &stack);
78}
79
80SANITIZER_INTERFACE_ATTRIBUTE
81void __sanitizer_free(void *ptr) {
82 if (!ptr)
83 return;
84 if (DlsymAlloc::PointerIsMine(ptr))
85 return DlsymAlloc::Free(ptr);
86 GET_MALLOC_STACK_TRACE;
87 hwasan_free(ptr, stack: &stack);
88}
89
90SANITIZER_INTERFACE_ATTRIBUTE
91void __sanitizer_cfree(void *ptr) {
92 if (!ptr)
93 return;
94 if (DlsymAlloc::PointerIsMine(ptr))
95 return DlsymAlloc::Free(ptr);
96 GET_MALLOC_STACK_TRACE;
97 hwasan_free(ptr, stack: &stack);
98}
99
100#if SANITIZER_INTERCEPT_FREE_SIZED
101SANITIZER_INTERFACE_ATTRIBUTE
102void __sanitizer_free_sized(void* ptr, uptr size) {
103 if (!ptr)
104 return;
105 if (DlsymAlloc::PointerIsMine(ptr))
106 return DlsymAlloc::Free(ptr);
107 GET_MALLOC_STACK_TRACE;
108 hwasan_free(ptr, stack: &stack);
109}
110#endif
111
112#if SANITIZER_INTERCEPT_FREE_ALIGNED_SIZED
113SANITIZER_INTERFACE_ATTRIBUTE
114void __sanitizer_free_aligned_sized(void* ptr, uptr alignment, uptr size) {
115 if (!ptr)
116 return;
117 if (DlsymAlloc::PointerIsMine(ptr))
118 return DlsymAlloc::Free(ptr);
119 GET_MALLOC_STACK_TRACE;
120 hwasan_free(ptr, stack: &stack);
121}
122#endif
123
124SANITIZER_INTERFACE_ATTRIBUTE
125uptr __sanitizer_malloc_usable_size(const void *ptr) {
126 return __sanitizer_get_allocated_size(p: ptr);
127}
128
129SANITIZER_INTERFACE_ATTRIBUTE
130struct __sanitizer_struct_mallinfo __sanitizer_mallinfo() {
131 __sanitizer_struct_mallinfo sret;
132 internal_memset(s: &sret, c: 0, n: sizeof(sret));
133 return sret;
134}
135
136SANITIZER_INTERFACE_ATTRIBUTE
137int __sanitizer_mallopt(int cmd, int value) { return 0; }
138
139SANITIZER_INTERFACE_ATTRIBUTE
140void __sanitizer_malloc_stats(void) {
141 // FIXME: implement, but don't call REAL(malloc_stats)!
142}
143
144SANITIZER_INTERFACE_ATTRIBUTE
145void *__sanitizer_calloc(uptr nmemb, uptr size) {
146 if (DlsymAlloc::Use())
147 return DlsymAlloc::Callocate(nmemb, size);
148 GET_MALLOC_STACK_TRACE;
149 return hwasan_calloc(nmemb, size, stack: &stack);
150}
151
152SANITIZER_INTERFACE_ATTRIBUTE
153void *__sanitizer_realloc(void *ptr, uptr size) {
154 if (DlsymAlloc::Use() || DlsymAlloc::PointerIsMine(ptr))
155 return DlsymAlloc::Realloc(ptr, new_size: size);
156 GET_MALLOC_STACK_TRACE;
157 return hwasan_realloc(ptr, size, stack: &stack);
158}
159
160SANITIZER_INTERFACE_ATTRIBUTE
161void *__sanitizer_reallocarray(void *ptr, uptr nmemb, uptr size) {
162 GET_MALLOC_STACK_TRACE;
163 return hwasan_reallocarray(ptr, nmemb, size, stack: &stack);
164}
165
166SANITIZER_INTERFACE_ATTRIBUTE
167void *__sanitizer_malloc(uptr size) {
168 if (UNLIKELY(!hwasan_init_is_running))
169 ENSURE_HWASAN_INITED();
170 if (DlsymAlloc::Use())
171 return DlsymAlloc::Allocate(size_in_bytes: size);
172 GET_MALLOC_STACK_TRACE;
173 return hwasan_malloc(size, stack: &stack);
174}
175
176} // extern "C"
177
178#if HWASAN_WITH_INTERCEPTORS || SANITIZER_FUCHSIA
179#if SANITIZER_FUCHSIA
180// Fuchsia does not use WRAP/wrappers used for the interceptor infrastructure.
181# define INTERCEPTOR_ALIAS(RET, FN, ARGS...) \
182 extern "C" SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE RET FN( \
183 ARGS) ALIAS(__sanitizer_##FN)
184#else
185# define INTERCEPTOR_ALIAS(RET, FN, ARGS...) \
186 extern "C" SANITIZER_INTERFACE_ATTRIBUTE RET WRAP(FN)(ARGS) \
187 ALIAS(__sanitizer_##FN); \
188 extern "C" SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE RET FN( \
189 ARGS) ALIAS(__sanitizer_##FN)
190#endif
191
192INTERCEPTOR_ALIAS(int, posix_memalign, void **memptr, SIZE_T alignment,
193 SIZE_T size);
194INTERCEPTOR_ALIAS(void *, aligned_alloc, SIZE_T alignment, SIZE_T size);
195INTERCEPTOR_ALIAS(void *, __libc_memalign, SIZE_T alignment, SIZE_T size);
196INTERCEPTOR_ALIAS(void *, valloc, SIZE_T size);
197INTERCEPTOR_ALIAS(void, free, void *ptr);
198# if SANITIZER_INTERCEPT_FREE_SIZED
199INTERCEPTOR_ALIAS(void, free_sized, void* ptr, SIZE_T size);
200# endif
201# if SANITIZER_INTERCEPT_FREE_ALIGNED_SIZED
202INTERCEPTOR_ALIAS(void, free_aligned_sized, void* ptr, SIZE_T alignment,
203 SIZE_T size);
204# endif
205INTERCEPTOR_ALIAS(uptr, malloc_usable_size, const void *ptr);
206INTERCEPTOR_ALIAS(void *, calloc, SIZE_T nmemb, SIZE_T size);
207INTERCEPTOR_ALIAS(void *, realloc, void *ptr, SIZE_T size);
208INTERCEPTOR_ALIAS(void *, reallocarray, void *ptr, SIZE_T nmemb, SIZE_T size);
209INTERCEPTOR_ALIAS(void *, malloc, SIZE_T size);
210
211# if !SANITIZER_FREEBSD && !SANITIZER_NETBSD
212INTERCEPTOR_ALIAS(void *, memalign, SIZE_T alignment, SIZE_T size);
213INTERCEPTOR_ALIAS(void *, pvalloc, SIZE_T size);
214INTERCEPTOR_ALIAS(void, cfree, void *ptr);
215INTERCEPTOR_ALIAS(__sanitizer_struct_mallinfo, mallinfo,);
216INTERCEPTOR_ALIAS(int, mallopt, int cmd, int value);
217INTERCEPTOR_ALIAS(void, malloc_stats, void);
218# endif
219#endif // #if HWASAN_WITH_INTERCEPTORS
220