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