1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "symbols_file_test.h"
17
18 #include <gmock/gmock.h>
19 #include <gtest/gtest.h>
20 #include <hilog/log.h>
21 #include <random>
22 #include <unistd.h>
23
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Developtools {
28 namespace HiPerf {
29 class SymbolsFileTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
32 static void TearDownTestCase(void);
33 void SetUp();
34 void TearDown();
35 void CheckSymbols(const std::unique_ptr<SymbolsFile> &symbolsFile) const;
36 void PrintSymbols(const std::vector<DfxSymbol> &symbol) const;
37 bool KptrRestrict() const;
38
LoadSymbols(SymbolsFileType symbolsFileType)39 std::unique_ptr<SymbolsFile> LoadSymbols(SymbolsFileType symbolsFileType)
40 {
41 std::unique_ptr<SymbolsFile> symbolsFile = SymbolsFile::CreateSymbolsFile(symbolsFileType);
42 EXPECT_EQ(symbolsFile->setSymbolsFilePath(PATH_RESOURCE_TEST_DATA), true);
43 return symbolsFile;
44 }
45
TestLoadSymbols(SymbolsFileType symbolsFileType,const std::string & path)46 bool TestLoadSymbols(SymbolsFileType symbolsFileType, const std::string &path)
47 {
48 std::unique_ptr<SymbolsFile> symbolsFile = SymbolsFile::CreateSymbolsFile(symbolsFileType);
49 EXPECT_EQ(symbolsFile->setSymbolsFilePath(PATH_RESOURCE_TEST_DATA), true);
50 return symbolsFile->LoadSymbols(nullptr, path);
51 }
52 std::default_random_engine rnd_;
53 };
54
SetUpTestCase()55 void SymbolsFileTest::SetUpTestCase() {}
56
TearDownTestCase()57 void SymbolsFileTest::TearDownTestCase() {}
58
SetUp()59 void SymbolsFileTest::SetUp() {}
60
TearDown()61 void SymbolsFileTest::TearDown() {}
62
KptrRestrict() const63 bool SymbolsFileTest::KptrRestrict() const
64 {
65 std::ifstream inputString(KPTR_RESTRICT, std::ios::in);
66 if (inputString) {
67 string kptrRestrict = "1";
68 inputString >> kptrRestrict;
69 if (kptrRestrict == "0") {
70 return false;
71 }
72 }
73 return true;
74 }
75
CheckSymbols(const std::unique_ptr<SymbolsFile> & symbolsFile) const76 void SymbolsFileTest::CheckSymbols(const std::unique_ptr<SymbolsFile> &symbolsFile) const
77 {
78 auto symbols = symbolsFile->GetSymbols();
79 EXPECT_EQ(symbols.empty(), false);
80 ASSERT_GE(symbols.size(), 1u);
81 PrintSymbols(symbols);
82
83 // first is 0
84 EXPECT_EQ(symbolsFile->GetSymbolWithVaddr(0x0).funcVaddr_, 0u);
85
86 // last is IsValid
87 EXPECT_EQ(symbolsFile->GetSymbolWithVaddr(std::numeric_limits<uint64_t>::max()).IsValid(),
88 true);
89
90 for (uint64_t pos = 0; pos < symbols.size(); ++pos) {
91 uint64_t vaddr = symbols[pos].funcVaddr_;
92 EXPECT_EQ(symbolsFile->GetSymbolWithVaddr(vaddr).funcVaddr_, vaddr);
93 }
94 for (auto symbol : symbols) {
95 if (symbol.name_.find("_Z") != std::string::npos) {
96 EXPECT_NE(symbol.demangle_.find("_Z"), 0u);
97 }
98 }
99 }
100
PrintSymbols(const std::vector<DfxSymbol> & symbols) const101 void SymbolsFileTest::PrintSymbols(const std::vector<DfxSymbol> &symbols) const
102 {
103 size_t printNumber = 15;
104 if (printNumber > symbols.size())
105 printNumber = symbols.size();
106
107 printf("first %zu:\n", printNumber);
108 for (size_t i = 0; i < printNumber; i++) {
109 printf("%s\n", symbols[i].ToDebugString().c_str());
110 }
111 if (printNumber < symbols.size()) {
112 printf("last %zu:\n", printNumber);
113 for (size_t i = printNumber; i > 0; i--) {
114 printf("%s\n", symbols[symbols.size() - i].ToDebugString().c_str());
115 }
116 }
117 }
118
119 /**
120 * @tc.name: setSymbolsFilePath
121 * @tc.desc:
122 * @tc.type: FUNC
123 */
124 HWTEST_F(SymbolsFileTest, setSymbolsFilePath, TestSize.Level1)
125 {
126 auto symbolsFile = SymbolsFile::CreateSymbolsFile(SYMBOL_UNKNOW_FILE);
127 EXPECT_EQ(symbolsFile->setSymbolsFilePath(PATH_DATA_TEMP), true);
128 EXPECT_EQ(symbolsFile->setSymbolsFilePath(PATH_NOT_EXISTS), false);
129 EXPECT_EQ(symbolsFile->setSymbolsFilePath(PATH_DATA_TEMP_WINDOS), false);
130 EXPECT_EQ(symbolsFile->setSymbolsFilePath(PATH_ILLEGAL), false);
131 EXPECT_EQ(symbolsFile->setSymbolsFilePath(PATH_RESOURCE_TEST_DATA), true);
132 EXPECT_EQ(symbolsFile->setSymbolsFilePath(PATH_RESOURCE_TEST_DATA_NO_ENDPATH), true);
133 }
134
135 /**
136 * @tc.name: setSymbolsFilePath
137 * @tc.desc:
138 * @tc.type: FUNC
139 */
140 HWTEST_F(SymbolsFileTest, setSymbolsFilePathVectorSuccess, TestSize.Level1)
141 {
142 auto symbolsFile = SymbolsFile::CreateSymbolsFile(SYMBOL_UNKNOW_FILE);
143 std::vector<std::string> symbolsSearchPaths;
144
145 symbolsSearchPaths.clear();
146 symbolsSearchPaths.push_back(PATH_DATA_TEMP);
147 EXPECT_EQ(symbolsFile->setSymbolsFilePath(symbolsSearchPaths), true);
148
149 symbolsSearchPaths.clear();
150 symbolsSearchPaths.push_back(PATH_DATA_TEMP);
151 symbolsSearchPaths.push_back(PATH_DATA_TEMP);
152 EXPECT_EQ(symbolsFile->setSymbolsFilePath(symbolsSearchPaths), true);
153
154 symbolsSearchPaths.clear();
155 symbolsSearchPaths.push_back(PATH_DATA_TEMP);
156 symbolsSearchPaths.push_back(PATH_DATA_TEMP);
157 symbolsSearchPaths.push_back(PATH_DATA_TEMP);
158 EXPECT_EQ(symbolsFile->setSymbolsFilePath(symbolsSearchPaths), true);
159 }
160
161 /**
162 * @tc.name: setSymbolsFilePath
163 * @tc.desc:
164 * @tc.type: FUNC
165 */
166 HWTEST_F(SymbolsFileTest, setSymbolsFilePathVectorFailed, TestSize.Level1)
167 {
168 auto symbolsFile = SymbolsFile::CreateSymbolsFile(SYMBOL_UNKNOW_FILE);
169 std::vector<std::string> symbolsSearchPaths;
170
171 symbolsSearchPaths.clear();
172 symbolsSearchPaths.push_back(PATH_NOT_EXISTS);
173 EXPECT_EQ(symbolsFile->setSymbolsFilePath(symbolsSearchPaths), false);
174
175 symbolsSearchPaths.clear();
176 symbolsSearchPaths.push_back(PATH_NOT_EXISTS);
177 symbolsSearchPaths.push_back(PATH_NOT_EXISTS);
178 EXPECT_EQ(symbolsFile->setSymbolsFilePath(symbolsSearchPaths), false);
179
180 symbolsSearchPaths.clear();
181 symbolsSearchPaths.push_back(PATH_NOT_EXISTS);
182 symbolsSearchPaths.push_back(PATH_NOT_EXISTS);
183 symbolsSearchPaths.push_back(PATH_NOT_EXISTS);
184 EXPECT_EQ(symbolsFile->setSymbolsFilePath(symbolsSearchPaths), false);
185 }
186
187 /**
188 * @tc.name: setSymbolsFilePath
189 * @tc.desc:
190 * @tc.type: FUNC
191 */
192 HWTEST_F(SymbolsFileTest, setSymbolsFilePathVectorMixSucessed, TestSize.Level1)
193 {
194 auto symbolsFile = SymbolsFile::CreateSymbolsFile(SYMBOL_UNKNOW_FILE);
195 std::vector<std::string> symbolsSearchPaths;
196
197 symbolsSearchPaths.clear();
198 symbolsSearchPaths.push_back(PATH_DATA_TEMP);
199 symbolsSearchPaths.push_back(PATH_NOT_EXISTS);
200 EXPECT_EQ(symbolsFile->setSymbolsFilePath(symbolsSearchPaths), true);
201
202 symbolsSearchPaths.clear();
203 symbolsSearchPaths.push_back(PATH_DATA_TEMP);
204 symbolsSearchPaths.push_back(PATH_NOT_EXISTS);
205 symbolsSearchPaths.push_back(PATH_DATA_TEMP);
206 symbolsSearchPaths.push_back(PATH_NOT_EXISTS);
207 EXPECT_EQ(symbolsFile->setSymbolsFilePath(symbolsSearchPaths), true);
208
209 symbolsSearchPaths.clear();
210 symbolsSearchPaths.push_back(PATH_DATA_TEMP);
211 symbolsSearchPaths.push_back(PATH_NOT_EXISTS);
212 symbolsSearchPaths.push_back(PATH_DATA_TEMP);
213 symbolsSearchPaths.push_back(PATH_NOT_EXISTS);
214 symbolsSearchPaths.push_back(PATH_DATA_TEMP);
215 symbolsSearchPaths.push_back(PATH_NOT_EXISTS);
216 EXPECT_EQ(symbolsFile->setSymbolsFilePath(symbolsSearchPaths), true);
217 }
218
TestLoadSymbols(SymbolsFileType symbolsFileType,const std::string & path)219 bool TestLoadSymbols(SymbolsFileType symbolsFileType, const std::string &path)
220 {
221 std::unique_ptr<SymbolsFile> symbolsFile = SymbolsFile::CreateSymbolsFile(symbolsFileType);
222 EXPECT_EQ(symbolsFile->setSymbolsFilePath(PATH_RESOURCE_TEST_DATA), true);
223 return symbolsFile->LoadSymbols(nullptr, path);
224 }
225
226 /**
227 * @tc.name: SymbolsFile Default Virtual
228 * @tc.desc:
229 * @tc.type: FUNC
230 */
231 HWTEST_F(SymbolsFileTest, SymbolsFileDefaultVirtual, TestSize.Level1)
232 {
233 std::unique_ptr<SymbolsFile> symbolsFile = SymbolsFile::CreateSymbolsFile(SYMBOL_UNKNOW_FILE);
234 uint64_t value = 0;
235 ASSERT_EQ(symbolsFile->LoadDebugInfo(), false);
236 EXPECT_EQ(symbolsFile->GetSectionInfo("", value, value, value), false);
237 #ifndef __arm__
238 EXPECT_EQ(symbolsFile->GetHDRSectionInfo(value, value, value), false);
239 #endif
240 }
241
242 /**
243 * @tc.name: LoaderKernelSymbols
244 * @tc.desc:
245 * @tc.type: FUNC
246 */
247 HWTEST_F(SymbolsFileTest, LoadKernelSymbols, TestSize.Level1)
248 {
249 if (access("/sys/kernel/notes", F_OK) == 0) {
250 // read from kernel runtime
251 std::unique_ptr<SymbolsFile> symbolsFile = SymbolsFile::CreateSymbolsFile(SYMBOL_KERNEL_FILE);
252 ScopeDebugLevel tempLogLevel(LEVEL_VERBOSE);
253 ASSERT_EQ(symbolsFile->LoadSymbols(), true);
254
255 const std::vector<DfxSymbol> &symbols = symbolsFile->GetSymbols();
256 EXPECT_EQ(symbols.empty(), false);
257
258 std::string modulesMap = ReadFileToString("/proc/modules");
259 int lines = std::count(modulesMap.begin(), modulesMap.end(), '\n');
260 if (lines < 0) {
261 return;
262 }
263 std::set<std::string> modulesCount;
264 for (auto &symbol : symbols) {
265 if (symbol.module_.length()) {
266 modulesCount.emplace(symbol.module_);
267 }
268 }
269
270 // add [kernel.kallsyms]
271 if (modulesCount.size() != lines + 1u) {
272 printf("warn: modulesCount != lines + 1\n");
273 }
274 if (HasFailure()) {
275 for (auto &module : modulesCount) {
276 printf("%s\n", module.c_str());
277 }
278 }
279
280 // try vmlinux
281 EXPECT_EQ(TestLoadSymbols(SYMBOL_KERNEL_FILE, TEST_FILE_VMLINUX), true);
282 EXPECT_EQ(TestLoadSymbols(SYMBOL_KERNEL_FILE, TEST_FILE_VMLINUX_STRIPPED), true);
283 EXPECT_EQ(TestLoadSymbols(SYMBOL_KERNEL_FILE, TEST_FILE_VMLINUX_STRIPPED_NOBUILDID), true);
284 // will be load from runtime, still return true
285 EXPECT_EQ(TestLoadSymbols(SYMBOL_KERNEL_FILE, TEST_FILE_VMLINUX_STRIPPED_BROKEN), true);
286 } else {
287 printf("cannot access /sys/kernel/notes\n");
288 }
289 }
290
291 /**
292 * @tc.name: LoaderElfSymbols
293 * @tc.desc:
294 * @tc.type: FUNC
295 */
296 HWTEST_F(SymbolsFileTest, LoadElfSymbols, TestSize.Level1)
297 {
298 auto symbolsElfLoader = SymbolsFile::CreateSymbolsFile(SYMBOL_ELF_FILE);
299 auto symbolsElfStrippedLoader = SymbolsFile::CreateSymbolsFile(SYMBOL_ELF_FILE);
300 ScopeDebugLevel tempLogLevel(LEVEL_VERBOSE);
301
302 EXPECT_EQ(symbolsElfLoader->LoadSymbols(), false);
303
304 ASSERT_EQ(symbolsElfLoader->setSymbolsFilePath(PATH_RESOURCE_TEST_DATA), true);
305 EXPECT_EQ(symbolsElfLoader->LoadSymbols(nullptr, TEST_FILE_ELF), true);
306 if (HasFailure()) {
307 PrintSymbols(symbolsElfLoader->GetSymbols());
308 }
309
310 ASSERT_EQ(symbolsElfStrippedLoader->setSymbolsFilePath(PATH_RESOURCE_TEST_DATA), true);
311 EXPECT_EQ(symbolsElfStrippedLoader->LoadSymbols(nullptr, TEST_FILE_ELF_STRIPPED), true);
312 if (HasFailure()) {
313 PrintSymbols(symbolsElfStrippedLoader->GetSymbols());
314 }
315 EXPECT_GT(symbolsElfLoader->GetSymbols().size(), symbolsElfStrippedLoader->GetSymbols().size());
316
317 ASSERT_EQ(symbolsElfStrippedLoader->setSymbolsFilePath(PATH_RESOURCE_TEST_DATA), true);
318 EXPECT_EQ(symbolsElfStrippedLoader->LoadSymbols(nullptr, TEST_FILE_ELF), true);
319 if (HasFailure()) {
320 PrintSymbols(symbolsElfStrippedLoader->GetSymbols());
321 }
322
323 // no symbols not means failed.
324 EXPECT_EQ(TestLoadSymbols(SYMBOL_ELF_FILE, TEST_FILE_ELF_STRIPPED), true);
325
326 // no build id not means failed.
327 EXPECT_EQ(TestLoadSymbols(SYMBOL_ELF_FILE, TEST_FILE_ELF_STRIPPED_NOBUILDID), true);
328
329 EXPECT_EQ(TestLoadSymbols(SYMBOL_ELF_FILE, TEST_FILE_ELF_STRIPPED_BROKEN), false);
330 }
331
332 /**
333 * @tc.name: GetSymbolWithVaddr
334 * @tc.desc:
335 * @tc.type: FUNC
336 */
337 HWTEST_F(SymbolsFileTest, GetSymbolWithVaddr, TestSize.Level1)
338 {
339 if (access("/sys/kernel/notes", F_OK) == 0) {
340 auto symbols = SymbolsFile::CreateSymbolsFile(SYMBOL_KERNEL_FILE);
341 if ((0 == getuid())) {
342 HLOGD("in root mode");
343 EXPECT_EQ(symbols->LoadSymbols(), true);
344 CheckSymbols(symbols);
345 } else {
346 EXPECT_EQ(symbols->LoadSymbols(), true);
347 if (!KptrRestrict()) {
348 HLOGD("NOT KptrRestrict");
349 if (!symbols->GetSymbols().empty()) {
350 CheckSymbols(symbols);
351 } else {
352 printf("we found this issue in linux-5.10\n");
353 }
354 } else {
355 HLOGD("KptrRestrict");
356 ASSERT_EQ(symbols->GetSymbols().empty(), true);
357 }
358 }
359 } else {
360 printf("cannot access /sys/kernel/notes\n");
361 }
362 }
363
364 /**
365 * @tc.name: GetSymbolWithVaddr
366 * @tc.desc:
367 * @tc.type: FUNC
368 */
369 HWTEST_F(SymbolsFileTest, GetSymbolWithVaddr2, TestSize.Level1)
370 {
371 auto elfSymbols = SymbolsFile::CreateSymbolsFile(SYMBOL_ELF_FILE);
372 ASSERT_EQ(elfSymbols->setSymbolsFilePath(PATH_RESOURCE_TEST_DATA), true);
373 EXPECT_EQ(elfSymbols->LoadSymbols(nullptr, TEST_FILE_ELF), true);
374 ASSERT_EQ(elfSymbols->GetSymbols().empty(), false);
375
376 /*
377 part of elf32_test's symbols
378 vaddr(hex) size(dec) name
379 00001000 0 _init
380 00001030 0
381 00001320 58 _start
382 00001512 27 main
383 0000145d 124 TestGlobalChildFunction
384 000014d9 57 TestGlobalParentFunction
385 // last one
386 00001b38 0 _fini
387
388 part of elf_test's symbols
389 vaddr(hex) size(dec) name
390 0000000000002000 0 _init
391 0000000000002020 0
392 00000000000022f0 47 _start
393 0000000000002478 15 main
394 00000000000023d9 110 TestGlobalChildFunction
395 0000000000002447 49 TestGlobalParentFunction
396 //last one
397 0000000000002aa8 0 _fini
398 */
399 #ifdef __arm__
400 ScopeDebugLevel tempLogLevel(LEVEL_MUCH, true);
401 EXPECT_EQ(elfSymbols->GetSymbolWithVaddr(0x00001320).GetName(), "_start");
402 EXPECT_EQ(elfSymbols->GetSymbolWithVaddr(0x00001359).GetName(), "_start");
403 EXPECT_EQ(elfSymbols->GetSymbolWithVaddr(0x00001512).GetName(), "main");
404 EXPECT_EQ(elfSymbols->GetSymbolWithVaddr(0x0000152c).GetName(), "main");
405 EXPECT_EQ(elfSymbols->GetSymbolWithVaddr(0x0000145d).GetName(), "TestGlobalChildFunction");
406 EXPECT_EQ(elfSymbols->GetSymbolWithVaddr(0x000014d9).GetName(), "TestGlobalParentFunction");
407 #else
408 EXPECT_EQ(elfSymbols->GetSymbolWithVaddr(0x000022f0).GetName(), "_start");
409 EXPECT_EQ(elfSymbols->GetSymbolWithVaddr(0x0000231e).GetName(), "_start");
410 EXPECT_EQ(elfSymbols->GetSymbolWithVaddr(0x00002478).GetName(), "main");
411 EXPECT_EQ(elfSymbols->GetSymbolWithVaddr(0x00002486).GetName(), "main");
412 EXPECT_EQ(elfSymbols->GetSymbolWithVaddr(0x000023d9).GetName(), "TestGlobalChildFunction");
413 EXPECT_EQ(elfSymbols->GetSymbolWithVaddr(0x00002447).GetName(), "TestGlobalParentFunction");
414 #endif
415 if (HasFailure()) {
416 PrintSymbols(elfSymbols->GetSymbols());
417 }
418 }
419
420 /**
421 * @tc.name: GetSymbolWithVaddr
422 * @tc.desc:
423 * @tc.type: FUNC
424 */
425 HWTEST_F(SymbolsFileTest, GetSymbolWithVaddrFullMatch, TestSize.Level1)
426 {
427 auto elfSymbols = SymbolsFile::CreateSymbolsFile(SYMBOL_ELF_FILE);
428 ASSERT_EQ(elfSymbols->setSymbolsFilePath(PATH_RESOURCE_TEST_DATA), true);
429 if (elfSymbols->LoadSymbols(nullptr, TEST_SYMBOLS_FILE_ELF)) {
430 ASSERT_EQ(elfSymbols->GetSymbols().empty(), false);
431 /*
432 nm -C --defined-only symbols_file_test_elf64
433 addr = 1000 mangle name = _init
434 addr = 1040 mangle name = _start
435 addr = 1070 mangle name = deregister_tm_clones
436 addr = 10a0 mangle name = register_tm_clones
437 addr = 10e0 mangle name = __do_global_dtors_aux
438 addr = 1120 mangle name = frame_dummy
439 addr = 1129 mangle name = main
440 addr = 1140 mangle name = __libc_csu_init
441 addr = 11b0 mangle name = __libc_csu_fini
442
443 //last one
444 addr = 11b8 mangle name = _fini
445
446 nm -C --defined-only symbols_file_test_elf32
447 00001000 t _init
448 00001070 T _start
449 000010c0 t deregister_tm_clones
450 00001100 t register_tm_clones
451 00001150 t __do_global_dtors_aux
452 000011a0 t frame_dummy
453 000011ad T main
454 000011d0 T __libc_csu_init
455 00001240 T __libc_csu_fini
456
457 // last one
458 0000124c T _fini
459 */
460 #ifdef __arm__
461 enum SymbolAddr : uint64_t {
462 PLT = 0X1030U,
463 START = 0X1070U,
464 THUNK_AX = 0X10B0U,
465 DEREG = 0X10C0U,
466 REG = 0X1100U,
467 AUX = 0X1150U,
468 FRAME = 0X11A0U,
469 THUNK_DX = 0X11A9U,
470 MAIN = 0X11ADU,
471 THUNK_BX = 0X11C5U,
472 CSU_INIT = 0X11D0U,
473 CSU_FINI = 0X1240U,
474 THUNK_BP = 0X1245U,
475 };
476 #else
477 enum SymbolAddr : uint64_t {
478 PLT = 0X1020U,
479 START = 0X1040U,
480 DEREG = 0X1070U,
481 REG = 0X10A0U,
482 AUX = 0X10E0U,
483 FRAME = 0X1120U,
484 MAIN = 0X1129U,
485 CSU_INIT = 0X1140U,
486 CSU_FINI = 0X11B0U,
487 };
488 #endif
489 #ifdef __arm__
490 for (uint64_t addr = SymbolAddr::START; addr < SymbolAddr::THUNK_AX; ++addr) {
491 #else
492 for (uint64_t addr = SymbolAddr::START; addr < SymbolAddr::START; ++addr) {
493 #endif
494 if (elfSymbols->GetSymbolWithVaddr(addr).IsValid()) {
495 EXPECT_EQ(elfSymbols->GetSymbolWithVaddr(addr).demangle_, "_start");
496 }
497 }
498 for (uint64_t addr = SymbolAddr::DEREG; addr < SymbolAddr::REG; ++addr) {
499 if (elfSymbols->GetSymbolWithVaddr(addr).IsValid()) {
500 EXPECT_EQ(elfSymbols->GetSymbolWithVaddr(addr).demangle_, "deregister_tm_clones");
501 }
502 }
503 for (uint64_t addr = SymbolAddr::REG; addr < SymbolAddr::AUX; ++addr) {
504 if (elfSymbols->GetSymbolWithVaddr(addr).IsValid()) {
505 EXPECT_EQ(elfSymbols->GetSymbolWithVaddr(addr).demangle_, "register_tm_clones");
506 }
507 }
508 for (uint64_t addr = SymbolAddr::AUX; addr < SymbolAddr::FRAME; ++addr) {
509 if (elfSymbols->GetSymbolWithVaddr(addr).IsValid()) {
510 EXPECT_EQ(elfSymbols->GetSymbolWithVaddr(addr).demangle_, "__do_global_dtors_aux");
511 }
512 }
513 #ifdef __arm__
514 for (uint64_t addr = SymbolAddr::FRAME; addr < SymbolAddr::THUNK_DX; ++addr) {
515 #else
516 for (uint64_t addr = SymbolAddr::FRAME; addr < SymbolAddr::MAIN; ++addr) {
517 #endif
518 if (elfSymbols->GetSymbolWithVaddr(addr).IsValid()) {
519 EXPECT_EQ(elfSymbols->GetSymbolWithVaddr(addr).demangle_, "frame_dummy");
520 }
521 }
522 #ifdef __arm__
523 for (uint64_t addr = SymbolAddr::MAIN; addr < SymbolAddr::THUNK_BX; ++addr) {
524 #else
525 for (uint64_t addr = SymbolAddr::MAIN; addr < SymbolAddr::CSU_INIT; ++addr) {
526 #endif
527 if (elfSymbols->GetSymbolWithVaddr(addr).IsValid()) {
528 EXPECT_EQ(elfSymbols->GetSymbolWithVaddr(addr).demangle_, "main");
529 }
530 }
531 for (uint64_t addr = SymbolAddr::CSU_INIT; addr < SymbolAddr::CSU_FINI; ++addr) {
532 if (elfSymbols->GetSymbolWithVaddr(addr).IsValid()) {
533 EXPECT_EQ(elfSymbols->GetSymbolWithVaddr(addr).demangle_, "__libc_csu_init");
534 }
535 }
536 if (HasFailure()) {
537 PrintSymbols(elfSymbols->GetSymbols());
538 }
539 }
540 }
541
542 /**
543 * @tc.name: GetVaddrInSymbols
544 * @tc.desc:
545 * @tc.type: FUNC
546 */
547 HWTEST_F(SymbolsFileTest, GetVaddrInSymbols, TestSize.Level1)
548 {
549 /*
550 00200000-002c5000 r--p 00000000 08:02 46400311
551 002c5000-00490000 r-xp 000c5000 08:02 4640031
552
553 [14] .text PROGBITS 00000000002c5000 000c5000
554
555 if ip is 0x46e6ab
556 1. find the map range is 002c5000-00490000
557 2. ip - map start(002c5000) = map section offset
558 3. map section offset + map page offset(000c5000) = elf file offset
559 4. elf file offset - exec file offset(000c5000)
560 = ip offset (ip always in exec file offset)
561 5. ip offset + exec begin vaddr(2c5000) = virtual ip in elf
562 */
563 auto elfSymbols = SymbolsFile::CreateSymbolsFile(SYMBOL_ELF_FILE);
564 elfSymbols->textExecVaddrFileOffset_ = 0x000c5000;
565 elfSymbols->textExecVaddr_ = 0x002c5000;
566
567 // most easy case
568 EXPECT_EQ(elfSymbols->GetVaddrInSymbols(0x002c5123, 0x002c5000, 0x000c5000), 0x002c5123U);
569
570 // ip and map both change
571 EXPECT_EQ(elfSymbols->GetVaddrInSymbols(0xFF2c5123, 0xFF2c5000, 0x000c5000), 0x002c5123U);
572 EXPECT_EQ(elfSymbols->GetVaddrInSymbols(0x00000123, 0x00000000, 0x000c5000), 0x002c5123U);
573
574 // map page and offset change
575 EXPECT_EQ(elfSymbols->GetVaddrInSymbols(0x002ca123, 0x002c5000, 0x000c0000), 0x002c5123U);
576 EXPECT_EQ(elfSymbols->GetVaddrInSymbols(0x002c4123, 0x002c5000, 0x000c6000), 0x002c5123U);
577
578 // kernel dont care offset
579 auto kernelSymbols = SymbolsFile::CreateSymbolsFile(SYMBOL_KERNEL_FILE);
580 EXPECT_EQ(kernelSymbols->GetVaddrInSymbols(0x001234, 0x002c5000, 0x000c5000), 0x001234U);
581 }
582
583 /**
584 * @tc.name: FindSymbolFile
585 * @tc.desc:
586 * @tc.type: FUNC
587 */
588 HWTEST_F(SymbolsFileTest, FindSymbolFile, TestSize.Level1)
589 {
590 auto symbols = SymbolsFile::CreateSymbolsFile(SYMBOL_ELF_FILE);
591
592 std::vector<std::string> symbolsFileSearchPaths;
593 std::string symboleFilePath;
594
595 symboleFilePath = TEST_FILE_VMLINUX;
596 EXPECT_EQ(symbols->FindSymbolFile(symbolsFileSearchPaths, symboleFilePath).empty(), true);
597
598 symbolsFileSearchPaths.emplace_back(PATH_RESOURCE_TEST_DATA);
599 EXPECT_EQ(symbols->FindSymbolFile(symbolsFileSearchPaths, symboleFilePath).empty(), false);
600
601 symbolsFileSearchPaths.clear();
602 EXPECT_EQ(symbols->FindSymbolFile(symbolsFileSearchPaths, symboleFilePath).empty(), true);
603
604 symboleFilePath = PATH_RESOURCE_TEST_DATA + TEST_FILE_VMLINUX;
605 EXPECT_EQ(symbols->FindSymbolFile(symbolsFileSearchPaths, symboleFilePath).empty(), false);
606
607 symbolsFileSearchPaths.emplace_back(PATH_RESOURCE_TEST_DATA);
608 EXPECT_EQ(symbols->FindSymbolFile(symbolsFileSearchPaths, symboleFilePath).empty(), false);
609
610 symboleFilePath = TEST_FILE_ELF;
611 EXPECT_EQ(symbols->FindSymbolFile(symbolsFileSearchPaths, symboleFilePath).empty(), false);
612
613 symbolsFileSearchPaths.clear();
614 EXPECT_EQ(symbols->FindSymbolFile(symbolsFileSearchPaths, symboleFilePath).empty(), true);
615 }
616
617 /**
618 * @tc.name: GetBuildId
619 * @tc.desc:
620 * @tc.type: FUNC
621 */
622 HWTEST_F(SymbolsFileTest, GetBuildId, TestSize.Level1)
623 {
624 std::unique_ptr<SymbolsFile> symbolsFile = SymbolsFile::CreateSymbolsFile(SYMBOL_ELF_FILE);
625 // empty elf
626 EXPECT_EQ(symbolsFile->GetBuildId().empty(), true);
627 // set search path
628 ASSERT_EQ(symbolsFile->setSymbolsFilePath(PATH_RESOURCE_TEST_DATA), true);
629
630 symbolsFile = SymbolsFile::CreateSymbolsFile(SYMBOL_ELF_FILE);
631 ASSERT_EQ(symbolsFile->setSymbolsFilePath(PATH_RESOURCE_TEST_DATA), true);
632 // kernel elf
633 EXPECT_EQ(symbolsFile->LoadSymbols(nullptr, TEST_FILE_VMLINUX), true);
634 EXPECT_EQ(symbolsFile->GetBuildId().empty(), false);
635
636 symbolsFile = SymbolsFile::CreateSymbolsFile(SYMBOL_ELF_FILE);
637 ASSERT_EQ(symbolsFile->setSymbolsFilePath(PATH_RESOURCE_TEST_DATA), true);
638 // stripped elf
639 EXPECT_EQ(symbolsFile->LoadSymbols(nullptr, TEST_FILE_ELF), true);
640 EXPECT_EQ(symbolsFile->GetBuildId().empty(), false);
641
642 symbolsFile = SymbolsFile::CreateSymbolsFile(SYMBOL_ELF_FILE);
643 ASSERT_EQ(symbolsFile->setSymbolsFilePath(PATH_RESOURCE_TEST_DATA), true);
644 // stripped elf
645 EXPECT_EQ(symbolsFile->LoadSymbols(nullptr, TEST_FILE_ELF_STRIPPED), true);
646 EXPECT_EQ(symbolsFile->GetBuildId().empty(), false);
647 }
648
649 struct SectionInfo {
650 const std::string name;
651 uint64_t addr;
652 uint64_t size;
653 uint64_t offset;
654 };
655
656 /**
657 * @tc.name: GetSectionInfo
658 * @tc.desc:
659 * @tc.type: FUNC
660 */
661 HWTEST_F(SymbolsFileTest, GetSectionInfo, TestSize.Level1)
662 {
663 std::unique_ptr<SymbolsFile> symbolsFile =
664 SymbolsFile::CreateSymbolsFile(SYMBOL_ELF_FILE, TEST_FILE_ELF_FULL_PATH);
665 ASSERT_EQ(symbolsFile->LoadDebugInfo(), true);
666 ASSERT_EQ(symbolsFile->LoadSymbols(), true);
667
668 /*
669 from readelf -e elf32_test
670 32bit
671 [Nr] Name Type Addr Off Size ES Flg Lk Inf Al
672 [ 0] NULL 00000000 000000 000000 00 0 0 0
673 [ 1] .interp PROGBITS 000001b4 0001b4 000013 00 A 0 0 1
674 [ 2] .note.gnu.build-i NOTE 000001c8 0001c8 000024 00 A 0 0 4
675 [16] .text PROGBITS 00001320 001320 000818 00 AX 0 0 16
676 [19] .eh_frame_hdr PROGBITS 00002034 002034 0000dc 00 A 0 0 4
677 [20] .eh_frame PROGBITS 00002110 002110 0003a0 00 A 0 0 4
678 [29] .symtab SYMTAB 00000000 003034 000710 10 30 50 4
679 [30] .strtab STRTAB 00000000 003744 000c3d 00 0 0 1
680 [31] .shstrtab STRTAB 00000000 004381 00012a 00 0 0 1
681
682 from readelf -e elf_test
683 64bit
684 Section Headers:
685 [Nr] Name Type Address Offset
686 Size EntSize Flags Link Info Align
687 [ 0] NULL 0000000000000000 00000000
688 0000000000000000 0000000000000000 0 0 0
689 [ 1] .interp PROGBITS 0000000000000318 00000318
690 000000000000001c 0000000000000000 A 0 0 1
691 [ 2] .note.gnu.propert NOTE 0000000000000338 00000338
692 0000000000000020 0000000000000000 A 0 0 8
693 [16] .text PROGBITS 00000000000022f0 000022f0
694 00000000000007b5 0000000000000000 AX 0 0 16
695 [19] .eh_frame_hdr PROGBITS 0000000000003034 00003034
696 00000000000000bc 0000000000000000 A 0 0 4
697 [20] .eh_frame PROGBITS 00000000000030f0 000030f0
698 0000000000000320 0000000000000000 A 0 0 8
699 [29] .symtab SYMTAB 0000000000000000 00004040
700 00000000000009f0 0000000000000018 30 50 8
701 [30] .strtab STRTAB 0000000000000000 00004a30
702 0000000000000bbb 0000000000000000 0 0 1
703 [31] .shstrtab STRTAB 0000000000000000 000055eb
704 000000000000012c 0000000000000000 0 0 1
705 */
706 #ifdef __arm__
707 const std::vector<SectionInfo> sectionCheckList = {
708 {".note.gnu.build-id", 0x000001c8, 0x000024, 0x0001c8},
709 {".text", 0x00001320, 0x000818, 0x001320},
710 {".eh_frame_hdr", 0x00002034, 0x0000dc, 0x002034},
711 {".eh_frame", 0x00002110, 0x0003a0, 0x002110},
712 {".symtab", 0x00000000, 0x000710, 0x003034},
713 {".strtab", 0x00000000, 0x000c3d, 0x003744},
714 };
715 #else
716 const std::vector<SectionInfo> sectionCheckList = {
717 {".note.gnu.build-id", 0x0000000000000358, 0x0000000000000024, 0x00000358},
718 {".text", 0x00000000000022f0, 0x00000000000007b5, 0x000022f0},
719 {".eh_frame_hdr", 0x0000000000003034, 0x00000000000000bc, 0x00003034},
720 {".eh_frame", 0x00000000000030f0, 0x0000000000000320, 0x000030f0},
721 {".symtab", 0x00000000, 0x00000000000009f0, 0x00004040},
722 {".strtab", 0x00000000, 0x0000000000000bbb, 0x00004a30},
723 };
724 #endif
725 for (SectionInfo info : sectionCheckList) {
726 uint64_t addr;
727 uint64_t size;
728 uint64_t offset;
729 EXPECT_EQ(symbolsFile->GetSectionInfo(info.name, addr, size, offset), true);
730 EXPECT_EQ(addr, info.addr);
731 EXPECT_EQ(size, info.size);
732 EXPECT_EQ(offset, info.offset);
733 if (HasFailure()) {
734 printf("SectionInfo check failed at '%s', %" PRIx64 ",%" PRIx64 ",%" PRIx64 "\n",
735 info.name.c_str(), info.addr, info.size, info.offset);
736 }
737 }
738 }
739
740 #ifndef __arm__
741 /**
742 * @tc.name: GetHDRSectionInfo
743 * @tc.desc:
744 * @tc.type: FUNC
745 */
746 HWTEST_F(SymbolsFileTest, GetHDRSectionInfo, TestSize.Level1)
747 {
748 std::unique_ptr<SymbolsFile> symbolsFile =
749 SymbolsFile::CreateSymbolsFile(SYMBOL_ELF_FILE, TEST_FILE_ELF_FULL_PATH);
750
751 ASSERT_EQ(symbolsFile->LoadSymbols(), true);
752 ASSERT_EQ(symbolsFile->LoadDebugInfo(), true);
753
754 uint64_t ehFrameHdrElfOffset;
755 uint64_t fdeTableElfOffset;
756 uint64_t fdeTableSize;
757
758 /*
759 readelf -e elf32_test | grep .eh_frame_hdr
760 [19] .eh_frame_hdr PROGBITS 00002034 002034 0000dc 00 A 0 0 4
761
762 readelf --debug-dump=frames elf32_test | grep FDE | wc -l
763 26
764
765 readelf -e elf_test | grep .eh_frame_hdr
766 [19] .eh_frame_hdr PROGBITS 0000000000003034 00003034
767
768 readelf --debug-dump=frames elf_test | grep FDE | wc -l
769 22
770 */
771 symbolsFile->GetHDRSectionInfo(ehFrameHdrElfOffset, fdeTableElfOffset, fdeTableSize);
772
773 EXPECT_EQ(ehFrameHdrElfOffset, 0x00003034u);
774 EXPECT_EQ(fdeTableSize, 22U);
775 }
776
777 /**
778 * @tc.name: GetHDRSectionInfo
779 * @tc.desc:
780 * @tc.type: FUNC
781 */
782 HWTEST_F(SymbolsFileTest, GetHDRSectionInfoStripped, TestSize.Level1)
783 {
784 std::unique_ptr<SymbolsFile> symbolsFile = SymbolsFile::CreateSymbolsFile(
785 SYMBOL_ELF_FILE, PATH_RESOURCE_TEST_DATA + TEST_FILE_ELF_STRIPPED_NOEFHDR);
786
787 ASSERT_EQ(symbolsFile->LoadDebugInfo(), true);
788
789 uint64_t ehFrameHdrElfOffset;
790 uint64_t fdeTableElfOffset;
791 uint64_t fdeTableSize;
792
793 symbolsFile->GetHDRSectionInfo(ehFrameHdrElfOffset, fdeTableElfOffset, fdeTableSize);
794 uint64_t addr = 0;
795 uint64_t size = 0;
796 uint64_t offset = 0;
797 EXPECT_EQ(symbolsFile->GetSectionInfo(EH_FRAME_HR, addr, size, offset), false);
798 EXPECT_EQ(offset, 0U);
799 EXPECT_EQ(size, 0U);
800 EXPECT_EQ(addr, 0U);
801 }
802 #endif
803
804 /**
805 * @tc.name: CreateSymbolsFile
806 * @tc.desc:
807 * @tc.type: FUNC
808 */
809 HWTEST_F(SymbolsFileTest, CreateSymbolsFile, TestSize.Level1)
810 {
811 EXPECT_NE(SymbolsFile::CreateSymbolsFile(), nullptr);
812 EXPECT_NE(SymbolsFile::CreateSymbolsFile(SYMBOL_KERNEL_FILE), nullptr);
813 EXPECT_NE(SymbolsFile::CreateSymbolsFile(SYMBOL_KERNEL_MODULE_FILE), nullptr);
814 EXPECT_NE(SymbolsFile::CreateSymbolsFile(SYMBOL_KERNEL_THREAD_FILE), nullptr);
815 EXPECT_NE(SymbolsFile::CreateSymbolsFile(SYMBOL_ELF_FILE), nullptr);
816 EXPECT_NE(SymbolsFile::CreateSymbolsFile(SYMBOL_JAVA_FILE), nullptr);
817 EXPECT_NE(SymbolsFile::CreateSymbolsFile(SYMBOL_JS_FILE), nullptr);
818 EXPECT_NE(SymbolsFile::CreateSymbolsFile(SYMBOL_HAP_FILE), nullptr);
819 EXPECT_NE(SymbolsFile::CreateSymbolsFile(SYMBOL_UNKNOW_FILE), nullptr);
820 EXPECT_NE(SymbolsFile::CreateSymbolsFile(SymbolsFileType(-1)), nullptr);
821 EXPECT_EQ(SymbolsFile::CreateSymbolsFile(SymbolsFileType(-2))->symbolFileType_,
822 SYMBOL_UNKNOW_FILE);
823
824 EXPECT_EQ(SymbolsFile::CreateSymbolsFile(KERNEL_MMAP_NAME)->symbolFileType_,
825 SYMBOL_KERNEL_FILE);
826 EXPECT_EQ(SymbolsFile::CreateSymbolsFile(TEST_FILE_ELF_FULL_PATH)->symbolFileType_,
827 SYMBOL_ELF_FILE);
828 }
829
830 /**
831 * @tc.name: LoadSymbolsFromSaved
832 * @tc.desc:
833 * @tc.type: FUNC
834 */
835 HWTEST_F(SymbolsFileTest, LoadSymbolsFromSaved, TestSize.Level1)
836 {
837 SymbolFileStruct sfs;
838 for (unsigned int type = 0; type < SYMBOL_UNKNOW_FILE; type++) {
839 sfs.filePath_ = std::to_string(rnd_());
840 sfs.symbolType_ = type;
841 sfs.textExecVaddrFileOffset_ = rnd_();
842 sfs.textExecVaddr_ = rnd_();
843 sfs.buildId_ = std::to_string(rnd_());
844 int nameIndex = 0;
845 // after LoadSymbolsFromSaved it will sort from low to high
846 // so we make a order item to test
847 constexpr int rndMax = 10000;
848 std::uniform_int_distribution<int> rndLimi(0, rndMax);
849 sfs.symbolStructs_.emplace_back(rndLimi(rnd_) + nameIndex * rndMax, rnd_(),
850 std::to_string(nameIndex));
851 nameIndex++;
852 sfs.symbolStructs_.emplace_back(rndLimi(rnd_) + nameIndex * rndMax, rnd_(),
853 std::to_string(nameIndex));
854 nameIndex++;
855 sfs.symbolStructs_.emplace_back(rndLimi(rnd_) + nameIndex * rndMax, rnd_(),
856 std::to_string(nameIndex));
857 nameIndex++;
858
859 // setup the min vaddr
860
861 std::unique_ptr<SymbolsFile> symbolsFile = SymbolsFile::LoadSymbolsFromSaved(sfs);
862
863 EXPECT_EQ(symbolsFile->filePath_, sfs.filePath_);
864 EXPECT_EQ(symbolsFile->symbolFileType_, sfs.symbolType_);
865 EXPECT_EQ(symbolsFile->textExecVaddr_, sfs.textExecVaddr_);
866 EXPECT_EQ(symbolsFile->textExecVaddrFileOffset_, sfs.textExecVaddrFileOffset_);
867 EXPECT_EQ(symbolsFile->GetBuildId(), sfs.buildId_);
868 EXPECT_EQ(symbolsFile->GetSymbols().size(), sfs.symbolStructs_.size());
869
870 for (DfxSymbol symbol : symbolsFile->GetSymbols()) {
871 SymbolStruct symbolStruct = sfs.symbolStructs_.front();
872 EXPECT_EQ(symbol.funcVaddr_, symbolStruct.vaddr_);
873 EXPECT_EQ(symbol.size_, symbolStruct.len_);
874 EXPECT_EQ(symbol.name_, symbolStruct.symbolName_);
875 sfs.symbolStructs_.erase(sfs.symbolStructs_.begin());
876 }
877 }
878 }
879
880 /**
881 * @tc.name: exportSymbolToFileFormatMatched
882 * @tc.desc:
883 * @tc.type: FUNC
884 */
885 HWTEST_F(SymbolsFileTest, exportSymbolToFileFormatMatched, TestSize.Level1)
886 {
887 for (int type = 0; type < SYMBOL_UNKNOW_FILE; type++) {
888 auto symbolsFile = SymbolsFile::CreateSymbolsFile();
889 symbolsFile->filePath_ = std::to_string(rnd_());
890 symbolsFile->symbolFileType_ = static_cast<SymbolsFileType>(type);
891 symbolsFile->textExecVaddrFileOffset_ = rnd_();
892 symbolsFile->buildId_ = std::to_string(rnd_());
893 int nameIndex = 0;
894 // after LoadSymbolsFromSaved it will sort from low to high
895 // so we make a order item to test
896 constexpr int rndMax = 10000;
897 std::uniform_int_distribution<int> rndLimi(0, rndMax);
898 symbolsFile->symbols_.emplace_back(rndLimi(rnd_) + nameIndex * rndMax, rnd_(),
899 std::to_string(nameIndex), symbolsFile->filePath_);
900 nameIndex++;
901 symbolsFile->symbols_.emplace_back(rndLimi(rnd_) + nameIndex * rndMax, rnd_(),
902 std::to_string(nameIndex), symbolsFile->filePath_);
903 nameIndex++;
904 symbolsFile->symbols_.emplace_back(rndLimi(rnd_) + nameIndex * rndMax, rnd_(),
905 std::to_string(nameIndex), symbolsFile->filePath_);
906 nameIndex++;
907
908 // setup the min vaddr
909 symbolsFile->textExecVaddr_ = std::numeric_limits<uint64_t>::max();
910
911 for (auto &symbol : symbolsFile->symbols_) {
912 symbolsFile->textExecVaddr_ = std::min(symbol.funcVaddr_, symbolsFile->textExecVaddr_);
913 }
914
915 // access last one to make it as matched.
916 uint64_t matchedVaddr = symbolsFile->symbols_.back().funcVaddr_;
917 auto symbol = symbolsFile->GetSymbolWithVaddr(matchedVaddr);
918 EXPECT_EQ(symbol.funcVaddr_, matchedVaddr);
919 if (HasFailure()) {
920 PrintSymbols(symbolsFile->GetSymbols());
921 }
922
923 SymbolFileStruct sfs {};
924 symbolsFile->ExportSymbolToFileFormat(sfs);
925
926 EXPECT_EQ(symbolsFile->symbolFileType_, sfs.symbolType_);
927 EXPECT_EQ(symbolsFile->textExecVaddrFileOffset_, sfs.textExecVaddrFileOffset_);
928 EXPECT_EQ(symbolsFile->GetBuildId(), sfs.buildId_);
929
930 // matched one should be remove
931 EXPECT_EQ(sfs.symbolStructs_.size(), 1u);
932 for (SymbolStruct symbolStruct : sfs.symbolStructs_) {
933 // nomore found for matched vaddr
934 EXPECT_EQ(symbolStruct.vaddr_, matchedVaddr);
935 }
936 }
937 }
938
939 /**
940 * @tc.name: UpdateBuildIdIfMatch
941 * @tc.desc:
942 * @tc.type: FUNC
943 */
944 HWTEST_F(SymbolsFileTest, UpdateBuildIdIfMatch, TestSize.Level1)
945 {
946 auto file = SymbolsFile::CreateSymbolsFile();
947 file->buildId_ = "123";
948 file->UpdateBuildIdIfMatch("456");
949 EXPECT_STREQ(file->buildId_.c_str(), "123");
950 EXPECT_STRNE(file->buildId_.c_str(), "456");
951 }
952 } // namespace HiPerf
953 } // namespace Developtools
954 } // namespace OHOS
955