1// Copyright 2014 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include <dlfcn.h>
6#include <fcntl.h>
7#include <stdlib.h>
8#include <string.h>
9#include <sys/mman.h>
10#include <unistd.h>
11#include <map>
12
13#include "base/compiler_specific.h"
14#include "testing/gtest/include/gtest/gtest.h"
15#include "tools/android/heap_profiler/heap_profiler.h"
16
17namespace {
18
19typedef void* (*AllocatorFn)(size_t);
20typedef int (*FreeFn)(void*, size_t);
21
22const size_t kSize1 = 499 * PAGE_SIZE;
23const size_t kSize2 = 503 * PAGE_SIZE;
24const size_t kSize3 = 509 * PAGE_SIZE;
25
26// The purpose of the four functions below is to create watermarked allocations,
27// so the test fixture can ascertain that the hooks work end-to-end.
28__attribute__((noinline)) void* MallocInner(size_t size) {
29  void* ptr = malloc(size);
30  // The memset below is to avoid tail-call elimination optimizations and ensure
31  // that this function will be part of the stack trace.
32  memset(ptr, 0, size);
33  return ptr;
34}
35
36__attribute__((noinline)) void* MallocOuter(size_t size) {
37  void* ptr = MallocInner(size);
38  memset(ptr, 0, size);
39  return ptr;
40}
41
42__attribute__((noinline)) void* DoMmap(size_t size) {
43  return mmap(
44      0, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
45}
46
47__attribute__((noinline)) void* MmapInner(size_t size) {
48  void* ptr = DoMmap(size);
49  memset(ptr, 0, size);
50  return ptr;
51}
52
53__attribute__((noinline)) void* MmapOuter(size_t size) {
54  void* ptr = MmapInner(size);
55  memset(ptr, 0, size);
56  return ptr;
57}
58
59const HeapStats* GetHeapStats() {
60  HeapStats* const* stats_ptr = reinterpret_cast<HeapStats* const*>(
61      dlsym(RTLD_DEFAULT, "heap_profiler_stats_for_tests"));
62  EXPECT_TRUE(stats_ptr != NULL);
63  const HeapStats* stats = *stats_ptr;
64  EXPECT_TRUE(stats != NULL);
65  EXPECT_EQ(HEAP_PROFILER_MAGIC_MARKER, stats->magic_start);
66  return stats;
67}
68
69bool StackTraceContains(const StacktraceEntry* s, AllocatorFn fn) {
70  // kExpectedFnLen is a gross estimation of the watermark functions' size.
71  // It tries to address the following problem: the addrs in the unwound stack
72  // stack frames will NOT point to the beginning of the functions, but to the
73  // PC after the call to malloc/mmap.
74  const size_t kExpectedFnLen = 16;
75  const uintptr_t fn_addr = reinterpret_cast<uintptr_t>(fn);
76  for (size_t i = 0; i < HEAP_PROFILER_MAX_DEPTH; ++i) {
77    if (s->frames[i] >= fn_addr && s->frames[i] <= fn_addr + kExpectedFnLen)
78      return true;
79  }
80  return false;
81}
82
83const StacktraceEntry* LookupStackTrace(size_t size, AllocatorFn fn) {
84  const HeapStats* stats = GetHeapStats();
85  for (size_t i = 0; i < stats->max_stack_traces; ++i) {
86    const StacktraceEntry* st = &stats->stack_traces[i];
87    if (st->alloc_bytes == size && StackTraceContains(st, fn))
88      return st;
89  }
90  return NULL;
91}
92
93int DoFree(void* addr, size_t /*size, ignored.*/) {
94  free(addr);
95  return 0;
96}
97
98void TestStackTracesWithParams(AllocatorFn outer_fn,
99                               AllocatorFn inner_fn,
100                               FreeFn free_fn) {
101  const HeapStats* stats = GetHeapStats();
102
103  void* m1 = outer_fn(kSize1);
104  void* m2 = inner_fn(kSize2);
105  void* m3 = inner_fn(kSize3);
106  free_fn(m3, kSize3);
107
108  const StacktraceEntry* st1 = LookupStackTrace(kSize1, inner_fn);
109  const StacktraceEntry* st2 = LookupStackTrace(kSize2, inner_fn);
110  const StacktraceEntry* st3 = LookupStackTrace(kSize3, inner_fn);
111
112  EXPECT_TRUE(st1 != NULL);
113  EXPECT_TRUE(StackTraceContains(st1, outer_fn));
114  EXPECT_TRUE(StackTraceContains(st1, inner_fn));
115
116  EXPECT_TRUE(st2 != NULL);
117  EXPECT_FALSE(StackTraceContains(st2, outer_fn));
118  EXPECT_TRUE(StackTraceContains(st2, inner_fn));
119
120  EXPECT_EQ(NULL, st3);
121
122  const size_t total_alloc_start = stats->total_alloc_bytes;
123  const size_t num_stack_traces_start = stats->num_stack_traces;
124
125  free_fn(m1, kSize1);
126  free_fn(m2, kSize2);
127
128  const size_t total_alloc_end = stats->total_alloc_bytes;
129  const size_t num_stack_traces_end = stats->num_stack_traces;
130
131  EXPECT_EQ(kSize1 + kSize2, total_alloc_start - total_alloc_end);
132  EXPECT_EQ(2, num_stack_traces_start - num_stack_traces_end);
133  EXPECT_EQ(NULL, LookupStackTrace(kSize1, inner_fn));
134  EXPECT_EQ(NULL, LookupStackTrace(kSize2, inner_fn));
135  EXPECT_EQ(NULL, LookupStackTrace(kSize3, inner_fn));
136}
137
138TEST(HeapProfilerIntegrationTest, TestMallocStackTraces) {
139  TestStackTracesWithParams(&MallocOuter, &MallocInner, &DoFree);
140}
141
142TEST(HeapProfilerIntegrationTest, TestMmapStackTraces) {
143  TestStackTracesWithParams(&MmapOuter, &MmapInner, &munmap);
144}
145
146// Returns the path of the directory containing the current executable.
147std::string GetExePath() {
148  char buf[1024];
149  ssize_t len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
150  if (len == -1)
151    return std::string();
152  std::string path(buf, len);
153  size_t sep = path.find_last_of('/');
154  if (sep == std::string::npos)
155    return std::string();
156  path.erase(sep);
157  return path;
158}
159
160}  // namespace
161
162int main(int argc, char** argv) {
163  // Re-launch the process itself forcing the preload of the libheap_profiler.
164  char* ld_preload = getenv("LD_PRELOAD");
165  if (ld_preload == NULL || strstr(ld_preload, "libheap_profiler.so") == NULL) {
166    char env_ld_lib_path[256];
167    strlcpy(env_ld_lib_path, "LD_LIBRARY_PATH=", sizeof(env_ld_lib_path));
168    strlcat(env_ld_lib_path, GetExePath().c_str(), sizeof(env_ld_lib_path));
169    char env_ld_preload[] = "LD_PRELOAD=libheap_profiler.so";
170    char* const env[] = {env_ld_preload, env_ld_lib_path, 0};
171    execve("/proc/self/exe", argv, env);
172    // execve() never returns, unless something goes wrong.
173    perror("execve");
174    assert(false);
175  }
176
177  testing::InitGoogleTest(&argc, argv);
178  return RUN_ALL_TESTS();
179}
180