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_tls_get_addr.h"
20 
21 #if !SANITIZER_FUCHSIA
22 
23 using namespace __hwasan;
24 
25 struct DlsymAlloc : public DlSymAllocator<DlsymAlloc> {
26   static bool UseImpl() { return !hwasan_inited; }
27 };
28 
29 extern "C" {
30 
31 SANITIZER_INTERFACE_ATTRIBUTE
32 int __sanitizer_posix_memalign(void **memptr, uptr alignment, uptr size) {
33   GET_MALLOC_STACK_TRACE;
34   CHECK_NE(memptr, 0);
35   int res = hwasan_posix_memalign(memptr, alignment, size, &stack);
36   return res;
37 }
38 
39 SANITIZER_INTERFACE_ATTRIBUTE
40 void *__sanitizer_memalign(uptr alignment, uptr size) {
41   GET_MALLOC_STACK_TRACE;
42   return hwasan_memalign(alignment, size, &stack);
43 }
44 
45 SANITIZER_INTERFACE_ATTRIBUTE
46 void *__sanitizer_aligned_alloc(uptr alignment, uptr size) {
47   GET_MALLOC_STACK_TRACE;
48   return hwasan_aligned_alloc(alignment, size, &stack);
49 }
50 
51 SANITIZER_INTERFACE_ATTRIBUTE
52 void *__sanitizer___libc_memalign(uptr alignment, uptr size) {
53   GET_MALLOC_STACK_TRACE;
54   void *ptr = hwasan_memalign(alignment, size, &stack);
55   if (ptr)
56     DTLS_on_libc_memalign(ptr, size);
57   return ptr;
58 }
59 
60 SANITIZER_INTERFACE_ATTRIBUTE
61 void *__sanitizer_valloc(uptr size) {
62   GET_MALLOC_STACK_TRACE;
63   return hwasan_valloc(size, &stack);
64 }
65 
66 SANITIZER_INTERFACE_ATTRIBUTE
67 void *__sanitizer_pvalloc(uptr size) {
68   GET_MALLOC_STACK_TRACE;
69   return hwasan_pvalloc(size, &stack);
70 }
71 
72 SANITIZER_INTERFACE_ATTRIBUTE
73 void __sanitizer_free(void *ptr) {
74   if (!ptr)
75     return;
76   if (DlsymAlloc::PointerIsMine(ptr))
77     return DlsymAlloc::Free(ptr);
78   GET_MALLOC_STACK_TRACE;
79   hwasan_free(ptr, &stack);
80 }
81 
82 SANITIZER_INTERFACE_ATTRIBUTE
83 void __sanitizer_cfree(void *ptr) {
84   if (!ptr)
85     return;
86   if (DlsymAlloc::PointerIsMine(ptr))
87     return DlsymAlloc::Free(ptr);
88   GET_MALLOC_STACK_TRACE;
89   hwasan_free(ptr, &stack);
90 }
91 
92 SANITIZER_INTERFACE_ATTRIBUTE
93 uptr __sanitizer_malloc_usable_size(const void *ptr) {
94   return __sanitizer_get_allocated_size(ptr);
95 }
96 
97 SANITIZER_INTERFACE_ATTRIBUTE
98 struct __sanitizer_struct_mallinfo __sanitizer_mallinfo() {
99   __sanitizer_struct_mallinfo sret;
100   internal_memset(&sret, 0, sizeof(sret));
101   return sret;
102 }
103 
104 SANITIZER_INTERFACE_ATTRIBUTE
105 int __sanitizer_mallopt(int cmd, int value) { return 0; }
106 
107 SANITIZER_INTERFACE_ATTRIBUTE
108 void __sanitizer_malloc_stats(void) {
109   // FIXME: implement, but don't call REAL(malloc_stats)!
110 }
111 
112 SANITIZER_INTERFACE_ATTRIBUTE
113 void *__sanitizer_calloc(uptr nmemb, uptr size) {
114   if (DlsymAlloc::Use())
115     return DlsymAlloc::Callocate(nmemb, size);
116   GET_MALLOC_STACK_TRACE;
117   return hwasan_calloc(nmemb, size, &stack);
118 }
119 
120 SANITIZER_INTERFACE_ATTRIBUTE
121 void *__sanitizer_realloc(void *ptr, uptr size) {
122   if (DlsymAlloc::Use() || DlsymAlloc::PointerIsMine(ptr))
123     return DlsymAlloc::Realloc(ptr, size);
124   GET_MALLOC_STACK_TRACE;
125   return hwasan_realloc(ptr, size, &stack);
126 }
127 
128 SANITIZER_INTERFACE_ATTRIBUTE
129 void *__sanitizer_reallocarray(void *ptr, uptr nmemb, uptr size) {
130   GET_MALLOC_STACK_TRACE;
131   return hwasan_reallocarray(ptr, nmemb, size, &stack);
132 }
133 
134 SANITIZER_INTERFACE_ATTRIBUTE
135 void *__sanitizer_malloc(uptr size) {
136   if (UNLIKELY(!hwasan_init_is_running))
137     ENSURE_HWASAN_INITED();
138   if (DlsymAlloc::Use())
139     return DlsymAlloc::Allocate(size);
140   GET_MALLOC_STACK_TRACE;
141   return hwasan_malloc(size, &stack);
142 }
143 
144 }  // extern "C"
145 
146 #if HWASAN_WITH_INTERCEPTORS
147 #  define INTERCEPTOR_ALIAS(RET, FN, ARGS...)                                 \
148     extern "C" SANITIZER_INTERFACE_ATTRIBUTE RET WRAP(FN)(ARGS)               \
149         ALIAS("__sanitizer_" #FN);                                            \
150     extern "C" SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE RET FN( \
151         ARGS) ALIAS("__sanitizer_" #FN)
152 
153 INTERCEPTOR_ALIAS(int, posix_memalign, void **memptr, SIZE_T alignment,
154                   SIZE_T size);
155 INTERCEPTOR_ALIAS(void *, aligned_alloc, SIZE_T alignment, SIZE_T size);
156 INTERCEPTOR_ALIAS(void *, __libc_memalign, SIZE_T alignment, SIZE_T size);
157 INTERCEPTOR_ALIAS(void *, valloc, SIZE_T size);
158 INTERCEPTOR_ALIAS(void, free, void *ptr);
159 INTERCEPTOR_ALIAS(uptr, malloc_usable_size, const void *ptr);
160 INTERCEPTOR_ALIAS(void *, calloc, SIZE_T nmemb, SIZE_T size);
161 INTERCEPTOR_ALIAS(void *, realloc, void *ptr, SIZE_T size);
162 INTERCEPTOR_ALIAS(void *, reallocarray, void *ptr, SIZE_T nmemb, SIZE_T size);
163 INTERCEPTOR_ALIAS(void *, malloc, SIZE_T size);
164 
165 #  if !SANITIZER_FREEBSD && !SANITIZER_NETBSD
166 INTERCEPTOR_ALIAS(void *, memalign, SIZE_T alignment, SIZE_T size);
167 INTERCEPTOR_ALIAS(void *, pvalloc, SIZE_T size);
168 INTERCEPTOR_ALIAS(void, cfree, void *ptr);
169 INTERCEPTOR_ALIAS(__sanitizer_struct_mallinfo, mallinfo);
170 INTERCEPTOR_ALIAS(int, mallopt, int cmd, int value);
171 INTERCEPTOR_ALIAS(void, malloc_stats, void);
172 #  endif
173 #endif  // #if HWASAN_WITH_INTERCEPTORS
174 
175 #endif  // SANITIZER_FUCHSIA
176