1 /*
2 * Copyright (C) 2018 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 <string.h>
19
20 #include <memory>
21 #include <vector>
22
23 #include <gtest/gtest.h>
24
25 #include <unwindstack/Elf.h>
26 #include <unwindstack/JitDebug.h>
27 #include <unwindstack/MapInfo.h>
28 #include <unwindstack/Maps.h>
29 #include <unwindstack/Memory.h>
30
31 #include "ElfFake.h"
32 #include "MemoryFake.h"
33
34 namespace unwindstack {
35
36 class JitDebugTest : public ::testing::Test {
37 protected:
SetUp()38 void SetUp() override {
39 memory_ = new MemoryFake;
40 process_memory_.reset(memory_);
41
42 jit_debug_.reset(new JitDebug(process_memory_));
43 jit_debug_->SetArch(ARCH_ARM);
44
45 maps_.reset(
46 new BufferMaps("1000-4000 ---s 00000000 00:00 0\n"
47 "4000-6000 r--s 00000000 00:00 0\n"
48 "6000-8000 -w-s 00000000 00:00 0\n"
49 "a000-c000 --xp 00000000 00:00 0\n"
50 "c000-f000 rwxp 00000000 00:00 0\n"
51 "f000-11000 r-xp 00000000 00:00 0\n"
52 "12000-14000 r-xp 00000000 00:00 0\n"
53 "100000-110000 rw-p 0000000 00:00 0\n"
54 "200000-210000 rw-p 0000000 00:00 0\n"));
55 ASSERT_TRUE(maps_->Parse());
56
57 MapInfo* map_info = maps_->Get(3);
58 ASSERT_TRUE(map_info != nullptr);
59 MemoryFake* memory = new MemoryFake;
60 ElfFake* elf = new ElfFake(memory);
61 elf->FakeSetValid(true);
62 ElfInterfaceFake* interface = new ElfInterfaceFake(memory);
63 elf->FakeSetInterface(interface);
64 interface->FakeSetGlobalVariable("__jit_debug_descriptor", 0x800);
65 map_info->elf.reset(elf);
66
67 map_info = maps_->Get(5);
68 ASSERT_TRUE(map_info != nullptr);
69 memory = new MemoryFake;
70 elf = new ElfFake(memory);
71 elf->FakeSetValid(true);
72 interface = new ElfInterfaceFake(memory);
73 elf->FakeSetInterface(interface);
74 interface->FakeSetGlobalVariable("__jit_debug_descriptor", 0x800);
75 map_info->elf.reset(elf);
76
77 map_info = maps_->Get(6);
78 ASSERT_TRUE(map_info != nullptr);
79 memory = new MemoryFake;
80 elf = new ElfFake(memory);
81 elf->FakeSetValid(true);
82 interface = new ElfInterfaceFake(memory);
83 elf->FakeSetInterface(interface);
84 interface->FakeSetGlobalVariable("__jit_debug_descriptor", 0x800);
85 map_info->elf.reset(elf);
86 }
87
88 template <typename EhdrType, typename ShdrType>
CreateElf(uint64_t offset,uint8_t class_type,uint8_t machine_type,uint32_t pc,uint32_t size)89 void CreateElf(uint64_t offset, uint8_t class_type, uint8_t machine_type, uint32_t pc,
90 uint32_t size) {
91 EhdrType ehdr;
92 memset(&ehdr, 0, sizeof(ehdr));
93 uint64_t sh_offset = sizeof(ehdr);
94 memcpy(ehdr.e_ident, ELFMAG, SELFMAG);
95 ehdr.e_ident[EI_CLASS] = class_type;
96 ehdr.e_machine = machine_type;
97 ehdr.e_shstrndx = 1;
98 ehdr.e_shoff = sh_offset;
99 ehdr.e_shentsize = sizeof(ShdrType);
100 ehdr.e_shnum = 3;
101 memory_->SetMemory(offset, &ehdr, sizeof(ehdr));
102
103 ShdrType shdr;
104 memset(&shdr, 0, sizeof(shdr));
105 shdr.sh_type = SHT_NULL;
106 memory_->SetMemory(offset + sh_offset, &shdr, sizeof(shdr));
107
108 sh_offset += sizeof(shdr);
109 memset(&shdr, 0, sizeof(shdr));
110 shdr.sh_type = SHT_STRTAB;
111 shdr.sh_name = 1;
112 shdr.sh_offset = 0x500;
113 shdr.sh_size = 0x100;
114 memory_->SetMemory(offset + sh_offset, &shdr, sizeof(shdr));
115 memory_->SetMemory(offset + 0x500, ".debug_frame");
116
117 sh_offset += sizeof(shdr);
118 memset(&shdr, 0, sizeof(shdr));
119 shdr.sh_type = SHT_PROGBITS;
120 shdr.sh_name = 0;
121 shdr.sh_addr = 0x600;
122 shdr.sh_offset = 0x600;
123 shdr.sh_size = 0x200;
124 memory_->SetMemory(offset + sh_offset, &shdr, sizeof(shdr));
125
126 // Now add a single cie/fde.
127 uint64_t dwarf_offset = offset + 0x600;
128 if (class_type == ELFCLASS32) {
129 // CIE 32 information.
130 memory_->SetData32(dwarf_offset, 0xfc);
131 memory_->SetData32(dwarf_offset + 0x4, 0xffffffff);
132 memory_->SetData8(dwarf_offset + 0x8, 1);
133 memory_->SetData8(dwarf_offset + 0x9, '\0');
134 memory_->SetData8(dwarf_offset + 0xa, 0x4);
135 memory_->SetData8(dwarf_offset + 0xb, 0x4);
136 memory_->SetData8(dwarf_offset + 0xc, 0x1);
137
138 // FDE 32 information.
139 memory_->SetData32(dwarf_offset + 0x100, 0xfc);
140 memory_->SetData32(dwarf_offset + 0x104, 0);
141 memory_->SetData32(dwarf_offset + 0x108, pc);
142 memory_->SetData32(dwarf_offset + 0x10c, size);
143 } else {
144 // CIE 64 information.
145 memory_->SetData32(dwarf_offset, 0xffffffff);
146 memory_->SetData64(dwarf_offset + 4, 0xf4);
147 memory_->SetData64(dwarf_offset + 0xc, 0xffffffffffffffffULL);
148 memory_->SetData8(dwarf_offset + 0x14, 1);
149 memory_->SetData8(dwarf_offset + 0x15, '\0');
150 memory_->SetData8(dwarf_offset + 0x16, 0x4);
151 memory_->SetData8(dwarf_offset + 0x17, 0x4);
152 memory_->SetData8(dwarf_offset + 0x18, 0x1);
153
154 // FDE 64 information.
155 memory_->SetData32(dwarf_offset + 0x100, 0xffffffff);
156 memory_->SetData64(dwarf_offset + 0x104, 0xf4);
157 memory_->SetData64(dwarf_offset + 0x10c, 0);
158 memory_->SetData64(dwarf_offset + 0x114, pc);
159 memory_->SetData64(dwarf_offset + 0x11c, size);
160 }
161 }
162
163 void WriteDescriptor32(uint64_t addr, uint32_t entry);
164 void WriteDescriptor64(uint64_t addr, uint64_t entry);
165 void WriteEntry32Pack(uint64_t addr, uint32_t prev, uint32_t next, uint32_t elf_addr,
166 uint64_t elf_size);
167 void WriteEntry32Pad(uint64_t addr, uint32_t prev, uint32_t next, uint32_t elf_addr,
168 uint64_t elf_size);
169 void WriteEntry64(uint64_t addr, uint64_t prev, uint64_t next, uint64_t elf_addr,
170 uint64_t elf_size);
171
172 std::shared_ptr<Memory> process_memory_;
173 MemoryFake* memory_;
174 std::unique_ptr<JitDebug> jit_debug_;
175 std::unique_ptr<BufferMaps> maps_;
176 };
177
WriteDescriptor32(uint64_t addr,uint32_t entry)178 void JitDebugTest::WriteDescriptor32(uint64_t addr, uint32_t entry) {
179 // Format of the 32 bit JITDescriptor structure:
180 // uint32_t version
181 memory_->SetData32(addr, 1);
182 // uint32_t action_flag
183 memory_->SetData32(addr + 4, 0);
184 // uint32_t relevant_entry
185 memory_->SetData32(addr + 8, 0);
186 // uint32_t first_entry
187 memory_->SetData32(addr + 12, entry);
188 }
189
WriteDescriptor64(uint64_t addr,uint64_t entry)190 void JitDebugTest::WriteDescriptor64(uint64_t addr, uint64_t entry) {
191 // Format of the 64 bit JITDescriptor structure:
192 // uint32_t version
193 memory_->SetData32(addr, 1);
194 // uint32_t action_flag
195 memory_->SetData32(addr + 4, 0);
196 // uint64_t relevant_entry
197 memory_->SetData64(addr + 8, 0);
198 // uint64_t first_entry
199 memory_->SetData64(addr + 16, entry);
200 }
201
WriteEntry32Pack(uint64_t addr,uint32_t prev,uint32_t next,uint32_t elf_addr,uint64_t elf_size)202 void JitDebugTest::WriteEntry32Pack(uint64_t addr, uint32_t prev, uint32_t next, uint32_t elf_addr,
203 uint64_t elf_size) {
204 // Format of the 32 bit JITCodeEntry structure:
205 // uint32_t next
206 memory_->SetData32(addr, next);
207 // uint32_t prev
208 memory_->SetData32(addr + 4, prev);
209 // uint32_t symfile_addr
210 memory_->SetData32(addr + 8, elf_addr);
211 // uint64_t symfile_size
212 memory_->SetData64(addr + 12, elf_size);
213 }
214
WriteEntry32Pad(uint64_t addr,uint32_t prev,uint32_t next,uint32_t elf_addr,uint64_t elf_size)215 void JitDebugTest::WriteEntry32Pad(uint64_t addr, uint32_t prev, uint32_t next, uint32_t elf_addr,
216 uint64_t elf_size) {
217 // Format of the 32 bit JITCodeEntry structure:
218 // uint32_t next
219 memory_->SetData32(addr, next);
220 // uint32_t prev
221 memory_->SetData32(addr + 4, prev);
222 // uint32_t symfile_addr
223 memory_->SetData32(addr + 8, elf_addr);
224 // uint32_t pad
225 memory_->SetData32(addr + 12, 0);
226 // uint64_t symfile_size
227 memory_->SetData64(addr + 16, elf_size);
228 }
229
WriteEntry64(uint64_t addr,uint64_t prev,uint64_t next,uint64_t elf_addr,uint64_t elf_size)230 void JitDebugTest::WriteEntry64(uint64_t addr, uint64_t prev, uint64_t next, uint64_t elf_addr,
231 uint64_t elf_size) {
232 // Format of the 64 bit JITCodeEntry structure:
233 // uint64_t next
234 memory_->SetData64(addr, next);
235 // uint64_t prev
236 memory_->SetData64(addr + 8, prev);
237 // uint64_t symfile_addr
238 memory_->SetData64(addr + 16, elf_addr);
239 // uint64_t symfile_size
240 memory_->SetData64(addr + 24, elf_size);
241 }
242
TEST_F(JitDebugTest,get_elf_invalid)243 TEST_F(JitDebugTest, get_elf_invalid) {
244 Elf* elf = jit_debug_->GetElf(maps_.get(), 0x1500);
245 ASSERT_TRUE(elf == nullptr);
246 }
247
TEST_F(JitDebugTest,get_elf_no_global_variable)248 TEST_F(JitDebugTest, get_elf_no_global_variable) {
249 maps_.reset(new BufferMaps(""));
250 Elf* elf = jit_debug_->GetElf(maps_.get(), 0x1500);
251 ASSERT_TRUE(elf == nullptr);
252 }
253
TEST_F(JitDebugTest,get_elf_no_valid_descriptor_in_memory)254 TEST_F(JitDebugTest, get_elf_no_valid_descriptor_in_memory) {
255 CreateElf<Elf32_Ehdr, Elf32_Shdr>(0x4000, ELFCLASS32, EM_ARM, 0x1500, 0x200);
256
257 Elf* elf = jit_debug_->GetElf(maps_.get(), 0x1500);
258 ASSERT_TRUE(elf == nullptr);
259 }
260
TEST_F(JitDebugTest,get_elf_no_valid_code_entry)261 TEST_F(JitDebugTest, get_elf_no_valid_code_entry) {
262 CreateElf<Elf32_Ehdr, Elf32_Shdr>(0x4000, ELFCLASS32, EM_ARM, 0x1500, 0x200);
263
264 WriteDescriptor32(0xf800, 0x200000);
265
266 Elf* elf = jit_debug_->GetElf(maps_.get(), 0x1500);
267 ASSERT_TRUE(elf == nullptr);
268 }
269
TEST_F(JitDebugTest,get_elf_invalid_descriptor_first_entry)270 TEST_F(JitDebugTest, get_elf_invalid_descriptor_first_entry) {
271 CreateElf<Elf32_Ehdr, Elf32_Shdr>(0x4000, ELFCLASS32, EM_ARM, 0x1500, 0x200);
272
273 WriteDescriptor32(0xf800, 0);
274
275 Elf* elf = jit_debug_->GetElf(maps_.get(), 0x1500);
276 ASSERT_TRUE(elf == nullptr);
277 }
278
TEST_F(JitDebugTest,get_elf_invalid_descriptor_version)279 TEST_F(JitDebugTest, get_elf_invalid_descriptor_version) {
280 CreateElf<Elf32_Ehdr, Elf32_Shdr>(0x4000, ELFCLASS32, EM_ARM, 0x1500, 0x200);
281
282 WriteDescriptor32(0xf800, 0x20000);
283 // Set the version to an invalid value.
284 memory_->SetData32(0xf800, 2);
285
286 Elf* elf = jit_debug_->GetElf(maps_.get(), 0x1500);
287 ASSERT_TRUE(elf == nullptr);
288 }
289
TEST_F(JitDebugTest,get_elf_32)290 TEST_F(JitDebugTest, get_elf_32) {
291 CreateElf<Elf32_Ehdr, Elf32_Shdr>(0x4000, ELFCLASS32, EM_ARM, 0x1500, 0x200);
292
293 WriteDescriptor32(0xf800, 0x200000);
294 WriteEntry32Pad(0x200000, 0, 0, 0x4000, 0x1000);
295
296 Elf* elf = jit_debug_->GetElf(maps_.get(), 0x1500);
297 ASSERT_TRUE(elf != nullptr);
298
299 // Clear the memory and verify all of the data is cached.
300 memory_->Clear();
301 Elf* elf2 = jit_debug_->GetElf(maps_.get(), 0x1500);
302 ASSERT_TRUE(elf2 != nullptr);
303 EXPECT_EQ(elf, elf2);
304 }
305
TEST_F(JitDebugTest,get_multiple_jit_debug_descriptors_valid)306 TEST_F(JitDebugTest, get_multiple_jit_debug_descriptors_valid) {
307 CreateElf<Elf32_Ehdr, Elf32_Shdr>(0x4000, ELFCLASS32, EM_ARM, 0x1500, 0x200);
308 CreateElf<Elf32_Ehdr, Elf32_Shdr>(0x5000, ELFCLASS32, EM_ARM, 0x2000, 0x300);
309
310 WriteDescriptor32(0xf800, 0x200000);
311 WriteEntry32Pad(0x200000, 0, 0, 0x4000, 0x1000);
312 WriteDescriptor32(0x12800, 0x201000);
313 WriteEntry32Pad(0x201000, 0, 0, 0x5000, 0x1000);
314
315 ASSERT_TRUE(jit_debug_->GetElf(maps_.get(), 0x1500) != nullptr);
316 ASSERT_TRUE(jit_debug_->GetElf(maps_.get(), 0x2000) == nullptr);
317
318 // Now clear the descriptor entry for the first one.
319 WriteDescriptor32(0xf800, 0);
320 jit_debug_.reset(new JitDebug(process_memory_));
321 jit_debug_->SetArch(ARCH_ARM);
322
323 ASSERT_TRUE(jit_debug_->GetElf(maps_.get(), 0x1500) == nullptr);
324 ASSERT_TRUE(jit_debug_->GetElf(maps_.get(), 0x2000) != nullptr);
325 }
326
TEST_F(JitDebugTest,get_elf_x86)327 TEST_F(JitDebugTest, get_elf_x86) {
328 CreateElf<Elf32_Ehdr, Elf32_Shdr>(0x4000, ELFCLASS32, EM_ARM, 0x1500, 0x200);
329
330 WriteDescriptor32(0xf800, 0x200000);
331 WriteEntry32Pack(0x200000, 0, 0, 0x4000, 0x1000);
332
333 jit_debug_->SetArch(ARCH_X86);
334 Elf* elf = jit_debug_->GetElf(maps_.get(), 0x1500);
335 ASSERT_TRUE(elf != nullptr);
336
337 // Clear the memory and verify all of the data is cached.
338 memory_->Clear();
339 Elf* elf2 = jit_debug_->GetElf(maps_.get(), 0x1500);
340 ASSERT_TRUE(elf2 != nullptr);
341 EXPECT_EQ(elf, elf2);
342 }
343
TEST_F(JitDebugTest,get_elf_64)344 TEST_F(JitDebugTest, get_elf_64) {
345 CreateElf<Elf64_Ehdr, Elf64_Shdr>(0x4000, ELFCLASS64, EM_AARCH64, 0x1500, 0x200);
346
347 WriteDescriptor64(0xf800, 0x200000);
348 WriteEntry64(0x200000, 0, 0, 0x4000, 0x1000);
349
350 jit_debug_->SetArch(ARCH_ARM64);
351 Elf* elf = jit_debug_->GetElf(maps_.get(), 0x1500);
352 ASSERT_TRUE(elf != nullptr);
353
354 // Clear the memory and verify all of the data is cached.
355 memory_->Clear();
356 Elf* elf2 = jit_debug_->GetElf(maps_.get(), 0x1500);
357 ASSERT_TRUE(elf2 != nullptr);
358 EXPECT_EQ(elf, elf2);
359 }
360
TEST_F(JitDebugTest,get_elf_multiple_entries)361 TEST_F(JitDebugTest, get_elf_multiple_entries) {
362 CreateElf<Elf32_Ehdr, Elf32_Shdr>(0x4000, ELFCLASS32, EM_ARM, 0x1500, 0x200);
363 CreateElf<Elf32_Ehdr, Elf32_Shdr>(0x5000, ELFCLASS32, EM_ARM, 0x2300, 0x400);
364
365 WriteDescriptor32(0xf800, 0x200000);
366 WriteEntry32Pad(0x200000, 0, 0x200100, 0x4000, 0x1000);
367 WriteEntry32Pad(0x200100, 0x200100, 0, 0x5000, 0x1000);
368
369 Elf* elf_2 = jit_debug_->GetElf(maps_.get(), 0x2400);
370 ASSERT_TRUE(elf_2 != nullptr);
371
372 Elf* elf_1 = jit_debug_->GetElf(maps_.get(), 0x1600);
373 ASSERT_TRUE(elf_1 != nullptr);
374
375 // Clear the memory and verify all of the data is cached.
376 memory_->Clear();
377 EXPECT_EQ(elf_1, jit_debug_->GetElf(maps_.get(), 0x1500));
378 EXPECT_EQ(elf_1, jit_debug_->GetElf(maps_.get(), 0x16ff));
379 EXPECT_EQ(elf_2, jit_debug_->GetElf(maps_.get(), 0x2300));
380 EXPECT_EQ(elf_2, jit_debug_->GetElf(maps_.get(), 0x26ff));
381 EXPECT_EQ(nullptr, jit_debug_->GetElf(maps_.get(), 0x1700));
382 EXPECT_EQ(nullptr, jit_debug_->GetElf(maps_.get(), 0x2700));
383 }
384
TEST_F(JitDebugTest,get_elf_search_libs)385 TEST_F(JitDebugTest, get_elf_search_libs) {
386 CreateElf<Elf32_Ehdr, Elf32_Shdr>(0x4000, ELFCLASS32, EM_ARM, 0x1500, 0x200);
387
388 WriteDescriptor32(0xf800, 0x200000);
389 WriteEntry32Pad(0x200000, 0, 0, 0x4000, 0x1000);
390
391 // Only search a given named list of libs.
392 std::vector<std::string> libs{"libart.so"};
393 jit_debug_.reset(new JitDebug(process_memory_, libs));
394 jit_debug_->SetArch(ARCH_ARM);
395 EXPECT_TRUE(jit_debug_->GetElf(maps_.get(), 0x1500) == nullptr);
396
397 // Change the name of the map that includes the value and verify this works.
398 MapInfo* map_info = maps_->Get(5);
399 map_info->name = "/system/lib/libart.so";
400 jit_debug_.reset(new JitDebug(process_memory_, libs));
401 // Make sure that clearing our copy of the libs doesn't affect the
402 // JitDebug object.
403 libs.clear();
404 jit_debug_->SetArch(ARCH_ARM);
405 EXPECT_TRUE(jit_debug_->GetElf(maps_.get(), 0x1500) != nullptr);
406 }
407
408 } // namespace unwindstack
409