1//===-- asan_malloc_linux.cc ----------------------------------------------===//
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 AddressSanitizer, an address sanity checker.
11//
12// Linux-specific malloc interception.
13// We simply define functions like malloc, free, realloc, etc.
14// They will replace the corresponding libc functions automagically.
15//===----------------------------------------------------------------------===//
16
17#include "sanitizer_common/sanitizer_platform.h"
18#if SANITIZER_FREEBSD || SANITIZER_LINUX
19
20#include "sanitizer_common/sanitizer_tls_get_addr.h"
21#include "asan_allocator.h"
22#include "asan_interceptors.h"
23#include "asan_internal.h"
24#include "asan_stack.h"
25
26// ---------------------- Replacement functions ---------------- {{{1
27using namespace __asan;  // NOLINT
28
29INTERCEPTOR(void, free, void *ptr) {
30  GET_STACK_TRACE_FREE;
31  asan_free(ptr, &stack, FROM_MALLOC);
32}
33
34INTERCEPTOR(void, cfree, void *ptr) {
35  GET_STACK_TRACE_FREE;
36  asan_free(ptr, &stack, FROM_MALLOC);
37}
38
39INTERCEPTOR(void*, malloc, uptr size) {
40  GET_STACK_TRACE_MALLOC;
41  return asan_malloc(size, &stack);
42}
43
44INTERCEPTOR(void*, calloc, uptr nmemb, uptr size) {
45  if (UNLIKELY(!asan_inited)) {
46    // Hack: dlsym calls calloc before REAL(calloc) is retrieved from dlsym.
47    const uptr kCallocPoolSize = 1024;
48    static uptr calloc_memory_for_dlsym[kCallocPoolSize];
49    static uptr allocated;
50    uptr size_in_words = ((nmemb * size) + kWordSize - 1) / kWordSize;
51    void *mem = (void*)&calloc_memory_for_dlsym[allocated];
52    allocated += size_in_words;
53    CHECK(allocated < kCallocPoolSize);
54    return mem;
55  }
56  GET_STACK_TRACE_MALLOC;
57  return asan_calloc(nmemb, size, &stack);
58}
59
60INTERCEPTOR(void*, realloc, void *ptr, uptr size) {
61  GET_STACK_TRACE_MALLOC;
62  return asan_realloc(ptr, size, &stack);
63}
64
65INTERCEPTOR(void*, memalign, uptr boundary, uptr size) {
66  GET_STACK_TRACE_MALLOC;
67  return asan_memalign(boundary, size, &stack, FROM_MALLOC);
68}
69
70INTERCEPTOR(void*, aligned_alloc, uptr boundary, uptr size) {
71  GET_STACK_TRACE_MALLOC;
72  return asan_memalign(boundary, size, &stack, FROM_MALLOC);
73}
74
75INTERCEPTOR(void*, __libc_memalign, uptr boundary, uptr size) {
76  GET_STACK_TRACE_MALLOC;
77  void *res = asan_memalign(boundary, size, &stack, FROM_MALLOC);
78  DTLS_on_libc_memalign(res, size * boundary);
79  return res;
80}
81
82INTERCEPTOR(uptr, malloc_usable_size, void *ptr) {
83  GET_CURRENT_PC_BP_SP;
84  (void)sp;
85  return asan_malloc_usable_size(ptr, pc, bp);
86}
87
88// We avoid including malloc.h for portability reasons.
89// man mallinfo says the fields are "long", but the implementation uses int.
90// It doesn't matter much -- we just need to make sure that the libc's mallinfo
91// is not called.
92struct fake_mallinfo {
93  int x[10];
94};
95
96INTERCEPTOR(struct fake_mallinfo, mallinfo, void) {
97  struct fake_mallinfo res;
98  REAL(memset)(&res, 0, sizeof(res));
99  return res;
100}
101
102INTERCEPTOR(int, mallopt, int cmd, int value) {
103  return -1;
104}
105
106INTERCEPTOR(int, posix_memalign, void **memptr, uptr alignment, uptr size) {
107  GET_STACK_TRACE_MALLOC;
108  // Printf("posix_memalign: %zx %zu\n", alignment, size);
109  return asan_posix_memalign(memptr, alignment, size, &stack);
110}
111
112INTERCEPTOR(void*, valloc, uptr size) {
113  GET_STACK_TRACE_MALLOC;
114  return asan_valloc(size, &stack);
115}
116
117INTERCEPTOR(void*, pvalloc, uptr size) {
118  GET_STACK_TRACE_MALLOC;
119  return asan_pvalloc(size, &stack);
120}
121
122INTERCEPTOR(void, malloc_stats, void) {
123  __asan_print_accumulated_stats();
124}
125
126#if SANITIZER_ANDROID
127// Format of __libc_malloc_dispatch has changed in Android L.
128// While we are moving towards a solution that does not depend on bionic
129// internals, here is something to support both K* and L releases.
130struct MallocDebugK {
131  void *(*malloc)(uptr bytes);
132  void (*free)(void *mem);
133  void *(*calloc)(uptr n_elements, uptr elem_size);
134  void *(*realloc)(void *oldMem, uptr bytes);
135  void *(*memalign)(uptr alignment, uptr bytes);
136  uptr (*malloc_usable_size)(void *mem);
137};
138
139struct MallocDebugL {
140  void *(*calloc)(uptr n_elements, uptr elem_size);
141  void (*free)(void *mem);
142  fake_mallinfo (*mallinfo)(void);
143  void *(*malloc)(uptr bytes);
144  uptr (*malloc_usable_size)(void *mem);
145  void *(*memalign)(uptr alignment, uptr bytes);
146  int (*posix_memalign)(void **memptr, uptr alignment, uptr size);
147  void* (*pvalloc)(uptr size);
148  void *(*realloc)(void *oldMem, uptr bytes);
149  void* (*valloc)(uptr size);
150};
151
152ALIGNED(32) const MallocDebugK asan_malloc_dispatch_k = {
153    WRAP(malloc),  WRAP(free),     WRAP(calloc),
154    WRAP(realloc), WRAP(memalign), WRAP(malloc_usable_size)};
155
156ALIGNED(32) const MallocDebugL asan_malloc_dispatch_l = {
157    WRAP(calloc),         WRAP(free),               WRAP(mallinfo),
158    WRAP(malloc),         WRAP(malloc_usable_size), WRAP(memalign),
159    WRAP(posix_memalign), WRAP(pvalloc),            WRAP(realloc),
160    WRAP(valloc)};
161
162namespace __asan {
163void ReplaceSystemMalloc() {
164  void **__libc_malloc_dispatch_p =
165      (void **)AsanDlSymNext("__libc_malloc_dispatch");
166  if (__libc_malloc_dispatch_p) {
167    // Decide on K vs L dispatch format by the presence of
168    // __libc_malloc_default_dispatch export in libc.
169    void *default_dispatch_p = AsanDlSymNext("__libc_malloc_default_dispatch");
170    if (default_dispatch_p)
171      *__libc_malloc_dispatch_p = (void *)&asan_malloc_dispatch_k;
172    else
173      *__libc_malloc_dispatch_p = (void *)&asan_malloc_dispatch_l;
174  }
175}
176}  // namespace __asan
177
178#else  // SANITIZER_ANDROID
179
180namespace __asan {
181void ReplaceSystemMalloc() {
182}
183}  // namespace __asan
184#endif  // SANITIZER_ANDROID
185
186#endif  // SANITIZER_FREEBSD || SANITIZER_LINUX
187