1 /*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <elf.h>
18 #include <errno.h>
19 #include <signal.h>
20 #include <stdint.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <sys/mman.h>
24 #include <sys/ptrace.h>
25 #include <sys/types.h>
26 #include <time.h>
27 #include <unistd.h>
28
29 #include <vector>
30
31 #include <android-base/file.h>
32 #include <android-base/test_utils.h>
33 #include <gtest/gtest.h>
34
35 #include <unwindstack/Memory.h>
36
37 #include "MemoryFake.h"
38 #include "Symbols.h"
39
40 namespace unwindstack {
41
42 template <typename TypeParam>
43 class SymbolsTest : public ::testing::Test {
44 protected:
SetUp()45 void SetUp() override { memory_.Clear(); }
46
InitSym(TypeParam * sym,uint32_t st_value,uint32_t st_size,uint32_t st_name)47 void InitSym(TypeParam* sym, uint32_t st_value, uint32_t st_size, uint32_t st_name) {
48 memset(sym, 0, sizeof(*sym));
49 sym->st_info = STT_FUNC;
50 sym->st_value = st_value;
51 sym->st_size = st_size;
52 sym->st_name = st_name;
53 sym->st_shndx = SHN_COMMON;
54 }
55
56 MemoryFake memory_;
57 };
58 TYPED_TEST_CASE_P(SymbolsTest);
59
TYPED_TEST_P(SymbolsTest,function_bounds_check)60 TYPED_TEST_P(SymbolsTest, function_bounds_check) {
61 Symbols symbols(0x1000, sizeof(TypeParam), sizeof(TypeParam), 0x2000, 0x100);
62
63 TypeParam sym;
64 this->InitSym(&sym, 0x5000, 0x10, 0x40);
65 uint64_t offset = 0x1000;
66 this->memory_.SetMemory(offset, &sym, sizeof(sym));
67
68 std::string fake_name("fake_function");
69 this->memory_.SetMemory(0x2040, fake_name.c_str(), fake_name.size() + 1);
70
71 std::string name;
72 uint64_t func_offset;
73 ASSERT_TRUE(symbols.GetName<TypeParam>(0x5000, 0, &this->memory_, &name, &func_offset));
74 ASSERT_EQ("fake_function", name);
75 ASSERT_EQ(0U, func_offset);
76
77 name.clear();
78 ASSERT_TRUE(symbols.GetName<TypeParam>(0x500f, 0, &this->memory_, &name, &func_offset));
79 ASSERT_EQ("fake_function", name);
80 ASSERT_EQ(0xfU, func_offset);
81
82 // Check one before and one after the function.
83 ASSERT_FALSE(symbols.GetName<TypeParam>(0x4fff, 0, &this->memory_, &name, &func_offset));
84 ASSERT_FALSE(symbols.GetName<TypeParam>(0x5010, 0, &this->memory_, &name, &func_offset));
85 }
86
TYPED_TEST_P(SymbolsTest,no_symbol)87 TYPED_TEST_P(SymbolsTest, no_symbol) {
88 Symbols symbols(0x1000, sizeof(TypeParam), sizeof(TypeParam), 0x2000, 0x100);
89
90 TypeParam sym;
91 this->InitSym(&sym, 0x5000, 0x10, 0x40);
92 uint64_t offset = 0x1000;
93 this->memory_.SetMemory(offset, &sym, sizeof(sym));
94
95 std::string fake_name("fake_function");
96 this->memory_.SetMemory(0x2040, fake_name.c_str(), fake_name.size() + 1);
97
98 // First verify that we can get the name.
99 std::string name;
100 uint64_t func_offset;
101 ASSERT_TRUE(symbols.GetName<TypeParam>(0x5000, 0, &this->memory_, &name, &func_offset));
102 ASSERT_EQ("fake_function", name);
103 ASSERT_EQ(0U, func_offset);
104
105 // Now modify the info field so it's no longer a function.
106 sym.st_info = 0;
107 this->memory_.SetMemory(offset, &sym, sizeof(sym));
108 // Clear the cache to force the symbol data to be re-read.
109 symbols.ClearCache();
110 ASSERT_FALSE(symbols.GetName<TypeParam>(0x5000, 0, &this->memory_, &name, &func_offset));
111
112 // Set the function back, and set the shndx to UNDEF.
113 sym.st_info = STT_FUNC;
114 sym.st_shndx = SHN_UNDEF;
115 this->memory_.SetMemory(offset, &sym, sizeof(sym));
116 // Clear the cache to force the symbol data to be re-read.
117 symbols.ClearCache();
118 ASSERT_FALSE(symbols.GetName<TypeParam>(0x5000, 0, &this->memory_, &name, &func_offset));
119 }
120
TYPED_TEST_P(SymbolsTest,multiple_entries)121 TYPED_TEST_P(SymbolsTest, multiple_entries) {
122 Symbols symbols(0x1000, sizeof(TypeParam) * 3, sizeof(TypeParam), 0x2000, 0x500);
123
124 TypeParam sym;
125 uint64_t offset = 0x1000;
126 std::string fake_name;
127
128 this->InitSym(&sym, 0x5000, 0x10, 0x40);
129 this->memory_.SetMemory(offset, &sym, sizeof(sym));
130 fake_name = "function_one";
131 this->memory_.SetMemory(0x2040, fake_name.c_str(), fake_name.size() + 1);
132 offset += sizeof(sym);
133
134 this->InitSym(&sym, 0x3004, 0x200, 0x100);
135 this->memory_.SetMemory(offset, &sym, sizeof(sym));
136 fake_name = "function_two";
137 this->memory_.SetMemory(0x2100, fake_name.c_str(), fake_name.size() + 1);
138 offset += sizeof(sym);
139
140 this->InitSym(&sym, 0xa010, 0x20, 0x230);
141 this->memory_.SetMemory(offset, &sym, sizeof(sym));
142 fake_name = "function_three";
143 this->memory_.SetMemory(0x2230, fake_name.c_str(), fake_name.size() + 1);
144
145 std::string name;
146 uint64_t func_offset;
147 ASSERT_TRUE(symbols.GetName<TypeParam>(0x3005, 0, &this->memory_, &name, &func_offset));
148 ASSERT_EQ("function_two", name);
149 ASSERT_EQ(1U, func_offset);
150
151 name.clear();
152 ASSERT_TRUE(symbols.GetName<TypeParam>(0x5004, 0, &this->memory_, &name, &func_offset));
153 ASSERT_EQ("function_one", name);
154 ASSERT_EQ(4U, func_offset);
155
156 name.clear();
157 ASSERT_TRUE(symbols.GetName<TypeParam>(0xa011, 0, &this->memory_, &name, &func_offset));
158 ASSERT_EQ("function_three", name);
159 ASSERT_EQ(1U, func_offset);
160
161 // Reget some of the others to verify getting one function name doesn't
162 // affect any of the next calls.
163 name.clear();
164 ASSERT_TRUE(symbols.GetName<TypeParam>(0x5008, 0, &this->memory_, &name, &func_offset));
165 ASSERT_EQ("function_one", name);
166 ASSERT_EQ(8U, func_offset);
167
168 name.clear();
169 ASSERT_TRUE(symbols.GetName<TypeParam>(0x3008, 0, &this->memory_, &name, &func_offset));
170 ASSERT_EQ("function_two", name);
171 ASSERT_EQ(4U, func_offset);
172
173 name.clear();
174 ASSERT_TRUE(symbols.GetName<TypeParam>(0xa01a, 0, &this->memory_, &name, &func_offset));
175 ASSERT_EQ("function_three", name);
176 ASSERT_EQ(0xaU, func_offset);
177 }
178
TYPED_TEST_P(SymbolsTest,multiple_entries_nonstandard_size)179 TYPED_TEST_P(SymbolsTest, multiple_entries_nonstandard_size) {
180 uint64_t entry_size = sizeof(TypeParam) + 5;
181 Symbols symbols(0x1000, entry_size * 3, entry_size, 0x2000, 0x500);
182
183 TypeParam sym;
184 uint64_t offset = 0x1000;
185 std::string fake_name;
186
187 this->InitSym(&sym, 0x5000, 0x10, 0x40);
188 this->memory_.SetMemory(offset, &sym, sizeof(sym));
189 fake_name = "function_one";
190 this->memory_.SetMemory(0x2040, fake_name.c_str(), fake_name.size() + 1);
191 offset += entry_size;
192
193 this->InitSym(&sym, 0x3004, 0x200, 0x100);
194 this->memory_.SetMemory(offset, &sym, sizeof(sym));
195 fake_name = "function_two";
196 this->memory_.SetMemory(0x2100, fake_name.c_str(), fake_name.size() + 1);
197 offset += entry_size;
198
199 this->InitSym(&sym, 0xa010, 0x20, 0x230);
200 this->memory_.SetMemory(offset, &sym, sizeof(sym));
201 fake_name = "function_three";
202 this->memory_.SetMemory(0x2230, fake_name.c_str(), fake_name.size() + 1);
203
204 std::string name;
205 uint64_t func_offset;
206 ASSERT_TRUE(symbols.GetName<TypeParam>(0x3005, 0, &this->memory_, &name, &func_offset));
207 ASSERT_EQ("function_two", name);
208 ASSERT_EQ(1U, func_offset);
209
210 name.clear();
211 ASSERT_TRUE(symbols.GetName<TypeParam>(0x5004, 0, &this->memory_, &name, &func_offset));
212 ASSERT_EQ("function_one", name);
213 ASSERT_EQ(4U, func_offset);
214
215 name.clear();
216 ASSERT_TRUE(symbols.GetName<TypeParam>(0xa011, 0, &this->memory_, &name, &func_offset));
217 ASSERT_EQ("function_three", name);
218 ASSERT_EQ(1U, func_offset);
219 }
220
TYPED_TEST_P(SymbolsTest,load_bias)221 TYPED_TEST_P(SymbolsTest, load_bias) {
222 Symbols symbols(0x1000, sizeof(TypeParam), sizeof(TypeParam), 0x2000, 0x100);
223
224 TypeParam sym;
225 this->InitSym(&sym, 0x5000, 0x10, 0x40);
226 uint64_t offset = 0x1000;
227 this->memory_.SetMemory(offset, &sym, sizeof(sym));
228
229 std::string fake_name("fake_function");
230 this->memory_.SetMemory(0x2040, fake_name.c_str(), fake_name.size() + 1);
231
232 // Set a non-zero load_bias that should be a valid function offset.
233 std::string name;
234 uint64_t func_offset;
235 ASSERT_TRUE(symbols.GetName<TypeParam>(0x5004, 0x1000, &this->memory_, &name, &func_offset));
236 ASSERT_EQ("fake_function", name);
237 ASSERT_EQ(4U, func_offset);
238
239 // Set a flag that should cause the load_bias to be ignored.
240 sym.st_shndx = SHN_ABS;
241 this->memory_.SetMemory(offset, &sym, sizeof(sym));
242 // Clear the cache to force the symbol data to be re-read.
243 symbols.ClearCache();
244 ASSERT_FALSE(symbols.GetName<TypeParam>(0x5004, 0x1000, &this->memory_, &name, &func_offset));
245 }
246
TYPED_TEST_P(SymbolsTest,symtab_value_out_of_bounds)247 TYPED_TEST_P(SymbolsTest, symtab_value_out_of_bounds) {
248 Symbols symbols_end_at_100(0x1000, sizeof(TypeParam) * 2, sizeof(TypeParam), 0x2000, 0x100);
249 Symbols symbols_end_at_200(0x1000, sizeof(TypeParam) * 2, sizeof(TypeParam), 0x2000, 0x200);
250
251 TypeParam sym;
252 uint64_t offset = 0x1000;
253
254 this->InitSym(&sym, 0x5000, 0x10, 0xfb);
255 this->memory_.SetMemory(offset, &sym, sizeof(sym));
256 offset += sizeof(sym);
257
258 this->InitSym(&sym, 0x3000, 0x10, 0x100);
259 this->memory_.SetMemory(offset, &sym, sizeof(sym));
260
261 // Put the name across the end of the tab.
262 std::string fake_name("fake_function");
263 this->memory_.SetMemory(0x20fb, fake_name.c_str(), fake_name.size() + 1);
264
265 std::string name;
266 uint64_t func_offset;
267 // Verify that we can get the function name properly for both entries.
268 ASSERT_TRUE(symbols_end_at_200.GetName<TypeParam>(0x5000, 0, &this->memory_, &name, &func_offset));
269 ASSERT_EQ("fake_function", name);
270 ASSERT_EQ(0U, func_offset);
271 ASSERT_TRUE(symbols_end_at_200.GetName<TypeParam>(0x3000, 0, &this->memory_, &name, &func_offset));
272 ASSERT_EQ("function", name);
273 ASSERT_EQ(0U, func_offset);
274
275 // Now use the symbol table that ends at 0x100.
276 ASSERT_FALSE(
277 symbols_end_at_100.GetName<TypeParam>(0x5000, 0, &this->memory_, &name, &func_offset));
278 ASSERT_FALSE(
279 symbols_end_at_100.GetName<TypeParam>(0x3000, 0, &this->memory_, &name, &func_offset));
280 }
281
282 // Verify the entire func table is cached.
TYPED_TEST_P(SymbolsTest,symtab_read_cached)283 TYPED_TEST_P(SymbolsTest, symtab_read_cached) {
284 Symbols symbols(0x1000, 3 * sizeof(TypeParam), sizeof(TypeParam), 0xa000, 0x1000);
285
286 TypeParam sym;
287 uint64_t offset = 0x1000;
288
289 // Make sure that these entries are not in ascending order.
290 this->InitSym(&sym, 0x5000, 0x10, 0x100);
291 this->memory_.SetMemory(offset, &sym, sizeof(sym));
292 offset += sizeof(sym);
293
294 this->InitSym(&sym, 0x2000, 0x300, 0x200);
295 this->memory_.SetMemory(offset, &sym, sizeof(sym));
296 offset += sizeof(sym);
297
298 this->InitSym(&sym, 0x1000, 0x100, 0x300);
299 this->memory_.SetMemory(offset, &sym, sizeof(sym));
300 offset += sizeof(sym);
301
302 // Do call that should cache all of the entries (except the string data).
303 std::string name;
304 uint64_t func_offset;
305 ASSERT_FALSE(symbols.GetName<TypeParam>(0x6000, 0, &this->memory_, &name, &func_offset));
306 this->memory_.Clear();
307 ASSERT_FALSE(symbols.GetName<TypeParam>(0x6000, 0, &this->memory_, &name, &func_offset));
308
309 // Clear the memory and only put the symbol data string data in memory.
310 this->memory_.Clear();
311
312 std::string fake_name;
313 fake_name = "first_entry";
314 this->memory_.SetMemory(0xa100, fake_name.c_str(), fake_name.size() + 1);
315 fake_name = "second_entry";
316 this->memory_.SetMemory(0xa200, fake_name.c_str(), fake_name.size() + 1);
317 fake_name = "third_entry";
318 this->memory_.SetMemory(0xa300, fake_name.c_str(), fake_name.size() + 1);
319
320 ASSERT_TRUE(symbols.GetName<TypeParam>(0x5001, 0, &this->memory_, &name, &func_offset));
321 ASSERT_EQ("first_entry", name);
322 ASSERT_EQ(1U, func_offset);
323
324 ASSERT_TRUE(symbols.GetName<TypeParam>(0x2002, 0, &this->memory_, &name, &func_offset));
325 ASSERT_EQ("second_entry", name);
326 ASSERT_EQ(2U, func_offset);
327
328 ASSERT_TRUE(symbols.GetName<TypeParam>(0x1003, 0, &this->memory_, &name, &func_offset));
329 ASSERT_EQ("third_entry", name);
330 ASSERT_EQ(3U, func_offset);
331 }
332
TYPED_TEST_P(SymbolsTest,get_global)333 TYPED_TEST_P(SymbolsTest, get_global) {
334 uint64_t start_offset = 0x1000;
335 uint64_t str_offset = 0xa000;
336 Symbols symbols(start_offset, 4 * sizeof(TypeParam), sizeof(TypeParam), str_offset, 0x1000);
337
338 TypeParam sym;
339 memset(&sym, 0, sizeof(sym));
340 sym.st_shndx = SHN_COMMON;
341 sym.st_info = STT_OBJECT | (STB_GLOBAL << 4);
342 sym.st_name = 0x100;
343 this->memory_.SetMemory(start_offset, &sym, sizeof(sym));
344 this->memory_.SetMemory(str_offset + 0x100, "global_0");
345
346 start_offset += sizeof(sym);
347 memset(&sym, 0, sizeof(sym));
348 sym.st_shndx = SHN_COMMON;
349 sym.st_info = STT_FUNC;
350 sym.st_name = 0x200;
351 sym.st_value = 0x10000;
352 sym.st_size = 0x100;
353 this->memory_.SetMemory(start_offset, &sym, sizeof(sym));
354 this->memory_.SetMemory(str_offset + 0x200, "function_0");
355
356 start_offset += sizeof(sym);
357 memset(&sym, 0, sizeof(sym));
358 sym.st_shndx = SHN_COMMON;
359 sym.st_info = STT_OBJECT | (STB_GLOBAL << 4);
360 sym.st_name = 0x300;
361 this->memory_.SetMemory(start_offset, &sym, sizeof(sym));
362 this->memory_.SetMemory(str_offset + 0x300, "global_1");
363
364 start_offset += sizeof(sym);
365 memset(&sym, 0, sizeof(sym));
366 sym.st_shndx = SHN_COMMON;
367 sym.st_info = STT_FUNC;
368 sym.st_name = 0x400;
369 sym.st_value = 0x12000;
370 sym.st_size = 0x100;
371 this->memory_.SetMemory(start_offset, &sym, sizeof(sym));
372 this->memory_.SetMemory(str_offset + 0x400, "function_1");
373
374 uint64_t offset;
375 EXPECT_TRUE(symbols.GetGlobal<TypeParam>(&this->memory_, "global_0", &offset));
376 EXPECT_TRUE(symbols.GetGlobal<TypeParam>(&this->memory_, "global_1", &offset));
377 EXPECT_TRUE(symbols.GetGlobal<TypeParam>(&this->memory_, "global_0", &offset));
378 EXPECT_TRUE(symbols.GetGlobal<TypeParam>(&this->memory_, "global_1", &offset));
379
380 EXPECT_FALSE(symbols.GetGlobal<TypeParam>(&this->memory_, "function_0", &offset));
381 EXPECT_FALSE(symbols.GetGlobal<TypeParam>(&this->memory_, "function_1", &offset));
382
383 std::string name;
384 EXPECT_TRUE(symbols.GetName<TypeParam>(0x10002, 0, &this->memory_, &name, &offset));
385 EXPECT_EQ("function_0", name);
386 EXPECT_EQ(2U, offset);
387
388 EXPECT_TRUE(symbols.GetName<TypeParam>(0x12004, 0, &this->memory_, &name, &offset));
389 EXPECT_EQ("function_1", name);
390 EXPECT_EQ(4U, offset);
391 }
392
393 REGISTER_TYPED_TEST_CASE_P(SymbolsTest, function_bounds_check, no_symbol, multiple_entries,
394 multiple_entries_nonstandard_size, load_bias, symtab_value_out_of_bounds,
395 symtab_read_cached, get_global);
396
397 typedef ::testing::Types<Elf32_Sym, Elf64_Sym> SymbolsTestTypes;
398 INSTANTIATE_TYPED_TEST_CASE_P(, SymbolsTest, SymbolsTestTypes);
399
400 } // namespace unwindstack
401