1 //===-- memprof_interceptors.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 MemProfiler, a memory profiler.
10 //
11 // Intercept various libc functions.
12 //===----------------------------------------------------------------------===//
13
14 #include "memprof_interceptors.h"
15 #include "memprof_allocator.h"
16 #include "memprof_internal.h"
17 #include "memprof_mapping.h"
18 #include "memprof_stack.h"
19 #include "memprof_stats.h"
20 #include "sanitizer_common/sanitizer_libc.h"
21 #include "sanitizer_common/sanitizer_posix.h"
22
23 namespace __memprof {
24
25 #define MEMPROF_READ_STRING(s, n) MEMPROF_READ_RANGE((s), (n))
26
MaybeRealStrnlen(const char * s,uptr maxlen)27 static inline uptr MaybeRealStrnlen(const char *s, uptr maxlen) {
28 #if SANITIZER_INTERCEPT_STRNLEN
29 if (REAL(strnlen)) {
30 return REAL(strnlen)(s, maxlen);
31 }
32 #endif
33 return internal_strnlen(s, maxlen);
34 }
35
SetThreadName(const char * name)36 void SetThreadName(const char *name) {
37 MemprofThread *t = GetCurrentThread();
38 if (t)
39 memprofThreadRegistry().SetThreadName(t->tid(), name);
40 }
41
OnExit()42 int OnExit() {
43 // FIXME: ask frontend whether we need to return failure.
44 return 0;
45 }
46
47 } // namespace __memprof
48
49 // ---------------------- Wrappers ---------------- {{{1
50 using namespace __memprof;
51
52 DECLARE_REAL_AND_INTERCEPTOR(void *, malloc, uptr)
53 DECLARE_REAL_AND_INTERCEPTOR(void, free, void *)
54
55 #define MEMPROF_INTERCEPTOR_ENTER(ctx, func) \
56 ctx = 0; \
57 (void)ctx;
58
59 #define COMMON_INTERCEPT_FUNCTION(name) MEMPROF_INTERCEPT_FUNC(name)
60 #define COMMON_INTERCEPT_FUNCTION_VER(name, ver) \
61 MEMPROF_INTERCEPT_FUNC_VER(name, ver)
62 #define COMMON_INTERCEPT_FUNCTION_VER_UNVERSIONED_FALLBACK(name, ver) \
63 MEMPROF_INTERCEPT_FUNC_VER_UNVERSIONED_FALLBACK(name, ver)
64 #define COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, size) \
65 MEMPROF_WRITE_RANGE(ptr, size)
66 #define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, size) \
67 MEMPROF_READ_RANGE(ptr, size)
68 #define COMMON_INTERCEPTOR_ENTER(ctx, func, ...) \
69 MEMPROF_INTERCEPTOR_ENTER(ctx, func); \
70 do { \
71 if (memprof_init_is_running) \
72 return REAL(func)(__VA_ARGS__); \
73 ENSURE_MEMPROF_INITED(); \
74 } while (false)
75 #define COMMON_INTERCEPTOR_DIR_ACQUIRE(ctx, path) \
76 do { \
77 } while (false)
78 #define COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd) \
79 do { \
80 } while (false)
81 #define COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd) \
82 do { \
83 } while (false)
84 #define COMMON_INTERCEPTOR_FD_SOCKET_ACCEPT(ctx, fd, newfd) \
85 do { \
86 } while (false)
87 #define COMMON_INTERCEPTOR_SET_THREAD_NAME(ctx, name) SetThreadName(name)
88 // Should be memprofThreadRegistry().SetThreadNameByUserId(thread, name)
89 // But memprof does not remember UserId's for threads (pthread_t);
90 // and remembers all ever existed threads, so the linear search by UserId
91 // can be slow.
92 #define COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name) \
93 do { \
94 } while (false)
95 #define COMMON_INTERCEPTOR_BLOCK_REAL(name) REAL(name)
96 #define COMMON_INTERCEPTOR_ON_DLOPEN(filename, flag) \
97 do { \
98 CheckNoDeepBind(filename, flag); \
99 } while (false)
100 #define COMMON_INTERCEPTOR_ON_EXIT(ctx) OnExit()
101 #define COMMON_INTERCEPTOR_LIBRARY_LOADED(filename, handle)
102 #define COMMON_INTERCEPTOR_LIBRARY_UNLOADED()
103 #define COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED (!memprof_inited)
104 #define COMMON_INTERCEPTOR_GET_TLS_RANGE(begin, end) \
105 if (MemprofThread *t = GetCurrentThread()) { \
106 *begin = t->tls_begin(); \
107 *end = t->tls_end(); \
108 } else { \
109 *begin = *end = 0; \
110 }
111
112 #define COMMON_INTERCEPTOR_MEMMOVE_IMPL(ctx, to, from, size) \
113 do { \
114 MEMPROF_INTERCEPTOR_ENTER(ctx, memmove); \
115 MEMPROF_MEMMOVE_IMPL(to, from, size); \
116 } while (false)
117
118 #define COMMON_INTERCEPTOR_MEMCPY_IMPL(ctx, to, from, size) \
119 do { \
120 MEMPROF_INTERCEPTOR_ENTER(ctx, memcpy); \
121 MEMPROF_MEMCPY_IMPL(to, from, size); \
122 } while (false)
123
124 #define COMMON_INTERCEPTOR_MEMSET_IMPL(ctx, block, c, size) \
125 do { \
126 MEMPROF_INTERCEPTOR_ENTER(ctx, memset); \
127 MEMPROF_MEMSET_IMPL(block, c, size); \
128 } while (false)
129
130 #include "sanitizer_common/sanitizer_common_interceptors.inc"
131
132 #define COMMON_SYSCALL_PRE_READ_RANGE(p, s) MEMPROF_READ_RANGE(p, s)
133 #define COMMON_SYSCALL_PRE_WRITE_RANGE(p, s) MEMPROF_WRITE_RANGE(p, s)
134 #define COMMON_SYSCALL_POST_READ_RANGE(p, s) \
135 do { \
136 (void)(p); \
137 (void)(s); \
138 } while (false)
139 #define COMMON_SYSCALL_POST_WRITE_RANGE(p, s) \
140 do { \
141 (void)(p); \
142 (void)(s); \
143 } while (false)
144 #include "sanitizer_common/sanitizer_common_syscalls.inc"
145
146 struct ThreadStartParam {
147 atomic_uintptr_t t;
148 atomic_uintptr_t is_registered;
149 };
150
memprof_thread_start(void * arg)151 static thread_return_t THREAD_CALLING_CONV memprof_thread_start(void *arg) {
152 ThreadStartParam *param = reinterpret_cast<ThreadStartParam *>(arg);
153 MemprofThread *t = nullptr;
154 while ((t = reinterpret_cast<MemprofThread *>(
155 atomic_load(¶m->t, memory_order_acquire))) == nullptr)
156 internal_sched_yield();
157 SetCurrentThread(t);
158 return t->ThreadStart(GetTid(), ¶m->is_registered);
159 }
160
INTERCEPTOR(int,pthread_create,void * thread,void * attr,void * (* start_routine)(void *),void * arg)161 INTERCEPTOR(int, pthread_create, void *thread, void *attr,
162 void *(*start_routine)(void *), void *arg) {
163 EnsureMainThreadIDIsCorrect();
164 GET_STACK_TRACE_THREAD;
165 int detached = 0;
166 if (attr)
167 REAL(pthread_attr_getdetachstate)(attr, &detached);
168 ThreadStartParam param;
169 atomic_store(¶m.t, 0, memory_order_relaxed);
170 atomic_store(¶m.is_registered, 0, memory_order_relaxed);
171 int result;
172 {
173 // Ignore all allocations made by pthread_create: thread stack/TLS may be
174 // stored by pthread for future reuse even after thread destruction, and
175 // the linked list it's stored in doesn't even hold valid pointers to the
176 // objects, the latter are calculated by obscure pointer arithmetic.
177 result = REAL(pthread_create)(thread, attr, memprof_thread_start, ¶m);
178 }
179 if (result == 0) {
180 u32 current_tid = GetCurrentTidOrInvalid();
181 MemprofThread *t = MemprofThread::Create(start_routine, arg, current_tid,
182 &stack, detached);
183 atomic_store(¶m.t, reinterpret_cast<uptr>(t), memory_order_release);
184 // Wait until the MemprofThread object is initialized and the
185 // ThreadRegistry entry is in "started" state.
186 while (atomic_load(¶m.is_registered, memory_order_acquire) == 0)
187 internal_sched_yield();
188 }
189 return result;
190 }
191
INTERCEPTOR(int,pthread_join,void * t,void ** arg)192 INTERCEPTOR(int, pthread_join, void *t, void **arg) {
193 return real_pthread_join(t, arg);
194 }
195
196 DEFINE_REAL_PTHREAD_FUNCTIONS
197
198 INTERCEPTOR(char *, index, const char *string, int c)
199 ALIAS(WRAPPER_NAME(strchr));
200
201 // For both strcat() and strncat() we need to check the validity of |to|
202 // argument irrespective of the |from| length.
INTERCEPTOR(char *,strcat,char * to,const char * from)203 INTERCEPTOR(char *, strcat, char *to, const char *from) {
204 void *ctx;
205 MEMPROF_INTERCEPTOR_ENTER(ctx, strcat);
206 ENSURE_MEMPROF_INITED();
207 uptr from_length = REAL(strlen)(from);
208 MEMPROF_READ_RANGE(from, from_length + 1);
209 uptr to_length = REAL(strlen)(to);
210 MEMPROF_READ_STRING(to, to_length);
211 MEMPROF_WRITE_RANGE(to + to_length, from_length + 1);
212 return REAL(strcat)(to, from);
213 }
214
INTERCEPTOR(char *,strncat,char * to,const char * from,uptr size)215 INTERCEPTOR(char *, strncat, char *to, const char *from, uptr size) {
216 void *ctx;
217 MEMPROF_INTERCEPTOR_ENTER(ctx, strncat);
218 ENSURE_MEMPROF_INITED();
219 uptr from_length = MaybeRealStrnlen(from, size);
220 uptr copy_length = Min(size, from_length + 1);
221 MEMPROF_READ_RANGE(from, copy_length);
222 uptr to_length = REAL(strlen)(to);
223 MEMPROF_READ_STRING(to, to_length);
224 MEMPROF_WRITE_RANGE(to + to_length, from_length + 1);
225 return REAL(strncat)(to, from, size);
226 }
227
INTERCEPTOR(char *,strcpy,char * to,const char * from)228 INTERCEPTOR(char *, strcpy, char *to, const char *from) {
229 void *ctx;
230 MEMPROF_INTERCEPTOR_ENTER(ctx, strcpy);
231 if (memprof_init_is_running) {
232 return REAL(strcpy)(to, from);
233 }
234 ENSURE_MEMPROF_INITED();
235 uptr from_size = REAL(strlen)(from) + 1;
236 MEMPROF_READ_RANGE(from, from_size);
237 MEMPROF_WRITE_RANGE(to, from_size);
238 return REAL(strcpy)(to, from);
239 }
240
INTERCEPTOR(char *,strdup,const char * s)241 INTERCEPTOR(char *, strdup, const char *s) {
242 void *ctx;
243 MEMPROF_INTERCEPTOR_ENTER(ctx, strdup);
244 if (UNLIKELY(!memprof_inited))
245 return internal_strdup(s);
246 ENSURE_MEMPROF_INITED();
247 uptr length = REAL(strlen)(s);
248 MEMPROF_READ_RANGE(s, length + 1);
249 GET_STACK_TRACE_MALLOC;
250 void *new_mem = memprof_malloc(length + 1, &stack);
251 REAL(memcpy)(new_mem, s, length + 1);
252 return reinterpret_cast<char *>(new_mem);
253 }
254
INTERCEPTOR(char *,__strdup,const char * s)255 INTERCEPTOR(char *, __strdup, const char *s) {
256 void *ctx;
257 MEMPROF_INTERCEPTOR_ENTER(ctx, strdup);
258 if (UNLIKELY(!memprof_inited))
259 return internal_strdup(s);
260 ENSURE_MEMPROF_INITED();
261 uptr length = REAL(strlen)(s);
262 MEMPROF_READ_RANGE(s, length + 1);
263 GET_STACK_TRACE_MALLOC;
264 void *new_mem = memprof_malloc(length + 1, &stack);
265 REAL(memcpy)(new_mem, s, length + 1);
266 return reinterpret_cast<char *>(new_mem);
267 }
268
INTERCEPTOR(char *,strncpy,char * to,const char * from,uptr size)269 INTERCEPTOR(char *, strncpy, char *to, const char *from, uptr size) {
270 void *ctx;
271 MEMPROF_INTERCEPTOR_ENTER(ctx, strncpy);
272 ENSURE_MEMPROF_INITED();
273 uptr from_size = Min(size, MaybeRealStrnlen(from, size) + 1);
274 MEMPROF_READ_RANGE(from, from_size);
275 MEMPROF_WRITE_RANGE(to, size);
276 return REAL(strncpy)(to, from, size);
277 }
278
INTERCEPTOR(long,strtol,const char * nptr,char ** endptr,int base)279 INTERCEPTOR(long, strtol, const char *nptr, char **endptr, int base) {
280 void *ctx;
281 MEMPROF_INTERCEPTOR_ENTER(ctx, strtol);
282 ENSURE_MEMPROF_INITED();
283 char *real_endptr;
284 long result = REAL(strtol)(nptr, &real_endptr, base);
285 StrtolFixAndCheck(ctx, nptr, endptr, real_endptr, base);
286 return result;
287 }
288
INTERCEPTOR(int,atoi,const char * nptr)289 INTERCEPTOR(int, atoi, const char *nptr) {
290 void *ctx;
291 MEMPROF_INTERCEPTOR_ENTER(ctx, atoi);
292 ENSURE_MEMPROF_INITED();
293 char *real_endptr;
294 // "man atoi" tells that behavior of atoi(nptr) is the same as
295 // strtol(nptr, 0, 10), i.e. it sets errno to ERANGE if the
296 // parsed integer can't be stored in *long* type (even if it's
297 // different from int). So, we just imitate this behavior.
298 int result = REAL(strtol)(nptr, &real_endptr, 10);
299 FixRealStrtolEndptr(nptr, &real_endptr);
300 MEMPROF_READ_STRING(nptr, (real_endptr - nptr) + 1);
301 return result;
302 }
303
INTERCEPTOR(long,atol,const char * nptr)304 INTERCEPTOR(long, atol, const char *nptr) {
305 void *ctx;
306 MEMPROF_INTERCEPTOR_ENTER(ctx, atol);
307 ENSURE_MEMPROF_INITED();
308 char *real_endptr;
309 long result = REAL(strtol)(nptr, &real_endptr, 10);
310 FixRealStrtolEndptr(nptr, &real_endptr);
311 MEMPROF_READ_STRING(nptr, (real_endptr - nptr) + 1);
312 return result;
313 }
314
INTERCEPTOR(long long,strtoll,const char * nptr,char ** endptr,int base)315 INTERCEPTOR(long long, strtoll, const char *nptr, char **endptr, int base) {
316 void *ctx;
317 MEMPROF_INTERCEPTOR_ENTER(ctx, strtoll);
318 ENSURE_MEMPROF_INITED();
319 char *real_endptr;
320 long long result = REAL(strtoll)(nptr, &real_endptr, base);
321 StrtolFixAndCheck(ctx, nptr, endptr, real_endptr, base);
322 return result;
323 }
324
INTERCEPTOR(long long,atoll,const char * nptr)325 INTERCEPTOR(long long, atoll, const char *nptr) {
326 void *ctx;
327 MEMPROF_INTERCEPTOR_ENTER(ctx, atoll);
328 ENSURE_MEMPROF_INITED();
329 char *real_endptr;
330 long long result = REAL(strtoll)(nptr, &real_endptr, 10);
331 FixRealStrtolEndptr(nptr, &real_endptr);
332 MEMPROF_READ_STRING(nptr, (real_endptr - nptr) + 1);
333 return result;
334 }
335
336 // ---------------------- InitializeMemprofInterceptors ---------------- {{{1
337 namespace __memprof {
InitializeMemprofInterceptors()338 void InitializeMemprofInterceptors() {
339 static bool was_called_once;
340 CHECK(!was_called_once);
341 was_called_once = true;
342 InitializeCommonInterceptors();
343
344 // Intercept str* functions.
345 MEMPROF_INTERCEPT_FUNC(strcat);
346 MEMPROF_INTERCEPT_FUNC(strcpy);
347 MEMPROF_INTERCEPT_FUNC(strncat);
348 MEMPROF_INTERCEPT_FUNC(strncpy);
349 MEMPROF_INTERCEPT_FUNC(strdup);
350 MEMPROF_INTERCEPT_FUNC(__strdup);
351 MEMPROF_INTERCEPT_FUNC(index);
352
353 MEMPROF_INTERCEPT_FUNC(atoi);
354 MEMPROF_INTERCEPT_FUNC(atol);
355 MEMPROF_INTERCEPT_FUNC(strtol);
356 MEMPROF_INTERCEPT_FUNC(atoll);
357 MEMPROF_INTERCEPT_FUNC(strtoll);
358
359 // Intercept threading-related functions
360 MEMPROF_INTERCEPT_FUNC(pthread_create);
361 MEMPROF_INTERCEPT_FUNC(pthread_join);
362
363 InitializePlatformInterceptors();
364
365 VReport(1, "MemProfiler: libc interceptors initialized\n");
366 }
367
368 } // namespace __memprof
369