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 #define HILOG_TAG "CallStack"
16
17 #include "callstack.h"
18
19 #include <string>
20 #if HAVE_LIBUNWIND
21 #include <libunwind.h>
22 extern "C" {
23 #include <libunwind_i.h>
24 }
25 #endif
26
27 #include "register.h"
28 #ifdef target_cpu_arm
29 // reg size is int (unw_word_t)
30 #define UNW_WORD_PFLAG "x"
31 #else
32 // reg size is long (unw_word_t)
33 #define UNW_WORD_PFLAG "zx"
34 #endif
35 namespace OHOS {
36 namespace Developtools {
37 namespace HiPerf {
38 #if HAVE_LIBUNWIND
39 const std::map<unw_error_t, const std::string> UNW_ERROR_MAP = {
40 {UNW_ESUCCESS, std::to_string(UNW_ESUCCESS)},
41 {UNW_EUNSPEC, std::to_string(UNW_EUNSPEC)},
42 {UNW_ENOMEM, std::to_string(UNW_ENOMEM)},
43 {UNW_EBADREG, std::to_string(UNW_EBADREG)},
44 {UNW_EREADONLYREG, std::to_string(UNW_EREADONLYREG)},
45 {UNW_ESTOPUNWIND, std::to_string(UNW_ESTOPUNWIND)},
46 {UNW_EINVALIDIP, std::to_string(UNW_EINVALIDIP)},
47 {UNW_EBADFRAME, std::to_string(UNW_EBADFRAME)},
48 {UNW_EINVAL, std::to_string(UNW_EINVAL)},
49 {UNW_EBADVERSION, std::to_string(UNW_EBADVERSION)},
50 {UNW_ENOINFO, std::to_string(UNW_ENOINFO)},
51 };
GetUnwErrorName(int error)52 const std::string CallStack::GetUnwErrorName(int error)
53 {
54 if (UNW_ERROR_MAP.count(static_cast<unw_error_t>(-error)) > 0) {
55 return UNW_ERROR_MAP.at(static_cast<unw_error_t>(-error));
56 } else {
57 return "UNKNOW_UNW_ERROR";
58 }
59 }
60
dumpUDI(unw_dyn_info_t & di)61 void CallStack::dumpUDI(unw_dyn_info_t &di)
62 {
63 HLOGV("unwind_table info: ");
64 HLOGV(" di.start_ip: 0x%016" UNW_WORD_PFLAG "", di.start_ip);
65 HLOGV(" di.end_ip: 0x%016" UNW_WORD_PFLAG "", di.end_ip);
66 HLOGV(" di.u.rti.segbase: 0x%016" UNW_WORD_PFLAG "", di.u.rti.segbase);
67 HLOGV(" di.u.rti.table_data: 0x%016" UNW_WORD_PFLAG "", di.u.rti.table_data);
68 HLOGV(" di.u.rti.table_len: 0x%016" UNW_WORD_PFLAG "", di.u.rti.table_len);
69 }
70
fillUDI(unw_dyn_info_t & di,SymbolsFile & symbolsFile,const MemMapItem & mmap,const VirtualThread & thread)71 bool CallStack::fillUDI(unw_dyn_info_t &di, SymbolsFile &symbolsFile, const MemMapItem &mmap,
72 const VirtualThread &thread)
73 {
74 di.start_ip = mmap.begin_;
75 di.end_ip = mmap.end_;
76 #ifndef target_cpu_arm
77 uint64_t fdeTableElfOffset, fdeTableSize, ehFrameHdrElfOffset;
78 if ((UNW_INFO_FORMAT_REMOTE_TABLE == di.format) &&
79 symbolsFile.GetHDRSectionInfo(ehFrameHdrElfOffset, fdeTableElfOffset, fdeTableSize)) {
80 /*
81 unw_word_t name_ptr; // addr. of table name (e.g., library name)
82 unw_word_t segbase; // segment base
83 unw_word_t table_len; // must be a multiple of sizeof(unw_word_t)!
84 unw_word_t table_data;
85 */
86 /*
87 all the rti addr is offset of the elf file
88 begin - page offset = elf file base addr in vaddr user space
89 begin - page offset + elf offset = vaddr in real word.(for this thread)
90 */
91
92 // segbase is file offset .
93 /*
94 00200000-00344000 r--p 00000000 08:02 46404365
95 00344000-005c4000 r-xp 00143000 08:02 46404365
96
97 LOAD 0x00000000001439c0 0x00000000003449c0 0x00000000003449c0
98 0x000000000027f3c0 0x000000000027f3c0 R E 0x1000
99
100 GNU_EH_FRAME 0x00000000000f3248 0x00000000002f3248 0x00000000002f3248
101 0x000000000000bb04 0x000000000000bb04 R 0x4
102
103 */
104 const MemMapItem *ehFrameMmap = thread.FindMapByFileInfo(mmap.name_, ehFrameHdrElfOffset);
105
106 if (ehFrameMmap == nullptr) {
107 HLOGE("no ehframe mmap found.");
108 return false;
109 }
110
111 di.u.rti.segbase = ehFrameMmap->begin_ + ehFrameHdrElfOffset - ehFrameMmap->pageoffset_;
112 di.u.rti.table_data = ehFrameMmap->begin_ + fdeTableElfOffset - ehFrameMmap->pageoffset_;
113 di.u.rti.table_len = fdeTableSize / sizeof(unw_word_t);
114
115 HLOGV(" map pageoffset: 0x%016" PRIx64 "", mmap.pageoffset_);
116 HLOGV(" ehFrameHdrElfOffset: 0x%016" PRIx64 "", ehFrameHdrElfOffset);
117 HLOGV(" fdeTableElfOffset: 0x%016" PRIx64 "", fdeTableElfOffset);
118 HLOGV(" fdeTableSize: 0x%016" PRIx64 "", fdeTableSize);
119 return true;
120 } else {
121 HLOGD("SymbolsFile::GetHDRSectionInfo() failed");
122 }
123 #else
124 uint64_t SectionVaddr, SectionSize, SectionFileOffset;
125 if ((UNW_INFO_FORMAT_ARM_EXIDX == di.format) &&
126 symbolsFile.GetSectionInfo(ARM_EXIDX, SectionVaddr, SectionSize, SectionFileOffset)) {
127 const MemMapItem *targetMmap = thread.FindMapByFileInfo(mmap.name_, SectionFileOffset);
128 if (targetMmap == nullptr) {
129 HLOGE("no debug mmap found.");
130 return false;
131 }
132 HLOGV(" begin: %" PRIx64 " offset:%" PRIx64 "", targetMmap->begin_,
133 targetMmap->pageoffset_);
134
135 di.u.rti.table_data = targetMmap->begin_ + SectionFileOffset - targetMmap->pageoffset_;
136 di.u.rti.table_len = SectionSize;
137 HLOGV(" SectionName: %s", std::string(ARM_EXIDX).c_str());
138 HLOGV(" SectionVaddrt: 0x%016" PRIx64 "", SectionVaddr);
139 HLOGV(" SectionFileOffset 0x%016" PRIx64 "", SectionFileOffset);
140 HLOGV(" SectionSize: 0x%016" PRIx64 "", SectionSize);
141
142 // GetSectionInfo return true, but SectionVaddr || SectionSize is 0 ???
143 HLOG_ASSERT(SectionVaddr != 0 && SectionSize != 0);
144 return true;
145 } else {
146 HLOGD("SymbolsFile::GetSectionInfo() failed");
147 }
148 #endif
149 return false;
150 }
151
152 /*
153 https://www.nongnu.org/libunwind/man/libunwind-dynamic(3).html
154 */
FindUnwindTable(SymbolsFile * symbolsFile,const MemMapItem & mmap,UnwindInfo * unwindInfoPtr,unw_addr_space_t as,unw_word_t ip,unw_proc_info_t * pi,int need_unwind_info,void * arg)155 int CallStack::FindUnwindTable(SymbolsFile *symbolsFile, const MemMapItem &mmap,
156 UnwindInfo *unwindInfoPtr, unw_addr_space_t as, unw_word_t ip,
157 unw_proc_info_t *pi, int need_unwind_info, void *arg)
158 {
159 HLOGM("try search debug info at %s", symbolsFile->filePath_.c_str());
160 auto &dynInfoProcessMap = unwindInfoPtr->callStack.unwindDynInfoMap_;
161 // all the thread in same process have same mmap and symbols
162 if (dynInfoProcessMap.find(unwindInfoPtr->thread.pid_) == dynInfoProcessMap.end()) {
163 dynInfoProcessMap.emplace(unwindInfoPtr->thread.pid_, dsoUnwDynInfoMap {});
164 }
165 dsoUnwDynInfoMap &dynFileMap = dynInfoProcessMap[unwindInfoPtr->thread.pid_];
166 // find use dso name as key
167 if (dynFileMap.find(symbolsFile->filePath_) == dynFileMap.end()) {
168 unw_dyn_info_t newdi;
169 if (memset_s(&newdi, sizeof(unw_dyn_info_t), 0, sizeof(unw_dyn_info_t)) != EOK) {
170 HLOGE("memset_s() failed");
171 return -UNW_EUNSPEC;
172 }
173 #ifdef target_cpu_arm
174 // arm use .ARM.exidx , not use ehframe
175 newdi.format = UNW_INFO_FORMAT_ARM_EXIDX;
176 #else
177 // otherwise we use EH FRAME
178 newdi.format = UNW_INFO_FORMAT_REMOTE_TABLE;
179 #endif
180 if (fillUDI(newdi, *symbolsFile, mmap, unwindInfoPtr->thread)) {
181 dumpUDI(newdi);
182 // we make a option empty value first
183 std::optional<unw_dyn_info_t> &odi = dynFileMap[symbolsFile->filePath_];
184 odi = newdi;
185 } else {
186 HLOGV("fillUDI failed()");
187 return -UNW_EUNSPEC;
188 }
189 }
190
191 HLOG_ASSERT(dynInfoProcessMap.find(unwindInfoPtr->thread.pid_) != dynInfoProcessMap.end());
192 HLOG_ASSERT_MESSAGE(dynFileMap.find(symbolsFile->filePath_) != dynFileMap.end(), "%s",
193 symbolsFile->filePath_.c_str());
194 std::optional<unw_dyn_info_t> &odi =
195 dynInfoProcessMap.at(unwindInfoPtr->thread.pid_).at(symbolsFile->filePath_);
196
197 if (odi.has_value()) {
198 unw_dyn_info_t &di = odi.value();
199 /*
200 we don't use dwarf_search_unwind_table
201 because in arm it will search two function:
202 1 arm_search_unwind_table first
203 2 dwarf_search_unwind_table
204
205 see libunwind_i.h for arm
206 define tdep_search_unwind_table UNW_OBJ(search_unwind_table)
207
208 */
209 int ret = static_cast<unw_error_t>(
210 tdep_search_unwind_table(as, ip, &di, pi, need_unwind_info, arg));
211
212 HLOGM("search_unwind_table ret %d:%s", ret, GetUnwErrorName(ret).c_str());
213
214 if (UNW_ESUCCESS != ret) {
215 if (UNW_ENOINFO != ret) {
216 HLOGW("search_unwind_table ret error %d:%s", ret, GetUnwErrorName(ret).c_str());
217 }
218 return -UNW_EUNSPEC;
219 } else {
220 return UNW_ESUCCESS;
221 }
222 } else {
223 HLOGW("no debug info found for thread %d:%s", unwindInfoPtr->thread.tid_,
224 unwindInfoPtr->thread.name_.c_str());
225 return -UNW_EUNSPEC;
226 }
227 }
228
FindProcInfo(unw_addr_space_t as,unw_word_t ip,unw_proc_info_t * pi,int need_unwind_info,void * arg)229 int CallStack::FindProcInfo(unw_addr_space_t as, unw_word_t ip, unw_proc_info_t *pi,
230 int need_unwind_info, void *arg)
231 {
232 UnwindInfo *unwindInfoPtr = static_cast<UnwindInfo *>(arg);
233
234 HLOGM("need_unwind_info ret %d ip %" UNW_WORD_PFLAG "", need_unwind_info, ip);
235 const MemMapItem *mmap = unwindInfoPtr->thread.FindMapByAddr(ip);
236 if (mmap != nullptr) {
237 SymbolsFile *symbolsFile = unwindInfoPtr->thread.FindSymbolsFileByMap(*mmap);
238 if (symbolsFile != nullptr) {
239 return FindUnwindTable(symbolsFile, *mmap, unwindInfoPtr, as, ip, pi, need_unwind_info,
240 arg);
241 } else {
242 HLOGW("no symbols file found for thread %d:%s", unwindInfoPtr->thread.tid_,
243 unwindInfoPtr->thread.name_.c_str());
244 }
245 } else {
246 HLOGE("ip 0x%016" UNW_WORD_PFLAG " not found in thread %d:%s", ip,
247 unwindInfoPtr->thread.tid_, unwindInfoPtr->thread.name_.c_str());
248 }
249
250 return -UNW_EUNSPEC;
251 }
252
ReadVirtualThreadMemory(UnwindInfo & unwindInfoPtr,unw_word_t addr,unw_word_t * data)253 bool CallStack::ReadVirtualThreadMemory(UnwindInfo &unwindInfoPtr, unw_word_t addr,
254 unw_word_t *data)
255 {
256 auto process = unwindInfoPtr.callStack.porcessMemoryMap_.find(unwindInfoPtr.thread.pid_);
257 if (process != unwindInfoPtr.callStack.porcessMemoryMap_.end()) {
258 auto memory = process->second.find(addr);
259 if (memory != process->second.end()) {
260 *data = memory->second;
261 return true;
262 }
263 }
264
265 if (unwindInfoPtr.thread.ReadRoMemory(addr, (uint8_t *)data, sizeof(unw_word_t))) {
266 unwindInfoPtr.callStack.porcessMemoryMap_[unwindInfoPtr.thread.pid_][addr] = *data;
267 return true;
268 } else {
269 return false;
270 }
271 }
272
AccessMem(unw_addr_space_t as,unw_word_t addr,unw_word_t * valuePoint,int writeOperation,void * arg)273 int CallStack::AccessMem([[maybe_unused]] unw_addr_space_t as, unw_word_t addr,
274 unw_word_t *valuePoint, int writeOperation, void *arg)
275 {
276 UnwindInfo *unwindInfoPtr = static_cast<UnwindInfo *>(arg);
277 *valuePoint = 0;
278 HLOGDUMMY("try access addr 0x%" UNW_WORD_PFLAG " ", addr);
279 HLOG_ASSERT(writeOperation == 0);
280
281 /* Check overflow. */
282 if (addr + sizeof(unw_word_t) < addr) {
283 HLOGE("address overfolw at 0x%" UNW_WORD_PFLAG " increase 0x%zu", addr, sizeof(unw_word_t));
284 return -UNW_EUNSPEC;
285 }
286
287 if (addr < unwindInfoPtr->callStack.stackPoint_ or
288 addr + sizeof(unw_word_t) >= unwindInfoPtr->callStack.stackEnd_) {
289 if (ReadVirtualThreadMemory(*unwindInfoPtr, addr, valuePoint)) {
290 HLOGM("access_mem addr %p get val 0x%" UNW_WORD_PFLAG ", from mmap",
291 reinterpret_cast<void *>(addr), *valuePoint);
292 } else {
293 HLOGW("access_mem addr %p failed, from mmap, ", reinterpret_cast<void *>(addr));
294 HLOGW("stack range 0x%" PRIx64 " - 0x%" PRIx64 "(0x%" PRIx64 ")",
295 unwindInfoPtr->callStack.stackPoint_, unwindInfoPtr->callStack.stackEnd_,
296 unwindInfoPtr->callStack.stackEnd_ - unwindInfoPtr->callStack.stackPoint_);
297 return -UNW_EUNSPEC;
298 }
299 } else {
300 size_t stackOffset = addr - unwindInfoPtr->callStack.stackPoint_;
301 *valuePoint = *(unw_word_t *)&unwindInfoPtr->callStack.stack_[stackOffset];
302 HLOGM("access_mem addr %p val %" UNW_WORD_PFLAG ", from stack offset %zu",
303 reinterpret_cast<void *>(addr), *valuePoint, stackOffset);
304 }
305
306 return UNW_ESUCCESS;
307 }
308
AccessReg(unw_addr_space_t as,unw_regnum_t regnum,unw_word_t * valuePoint,int writeOperation,void * arg)309 int CallStack::AccessReg([[maybe_unused]] unw_addr_space_t as, unw_regnum_t regnum,
310 unw_word_t *valuePoint, int writeOperation, void *arg)
311 {
312 UnwindInfo *unwindInfoPtr = static_cast<UnwindInfo *>(arg);
313 uint64_t val;
314 int perfRegIndex = LibunwindRegIdToPerfReg(regnum);
315 if (perfRegIndex < 0) {
316 HLOGE("can't read reg %d", perfRegIndex);
317 return perfRegIndex;
318 }
319 /* Don't support write, I suspect we don't need it. */
320 if (writeOperation) {
321 HLOGE("access_reg %d", regnum);
322 return -UNW_EINVAL;
323 }
324
325 if (unwindInfoPtr->callStack.regsNum_ == 0) {
326 return -UNW_EUNSPEC;
327 }
328
329 if (!RegisterGetValue(val, unwindInfoPtr->callStack.regs_, static_cast<size_t>(perfRegIndex),
330 unwindInfoPtr->callStack.regsNum_)) {
331 HLOGE("can't read reg %d", perfRegIndex);
332 return -UNW_EUNSPEC;
333 }
334
335 *valuePoint = (unw_word_t)val;
336 HLOGM("reg %d:%s, val 0x%" UNW_WORD_PFLAG "", regnum, RegisterGetName(static_cast<size_t>(perfRegIndex)).c_str(),
337 *valuePoint);
338 return UNW_ESUCCESS;
339 }
340
PutUnwindInfo(unw_addr_space_t as,unw_proc_info_t * pi,void * arg)341 void CallStack::PutUnwindInfo([[maybe_unused]] unw_addr_space_t as,
342 [[maybe_unused]] unw_proc_info_t *pi, [[maybe_unused]] void *arg)
343 {
344 }
345
AccessFpreg(unw_addr_space_t as,unw_regnum_t num,unw_fpreg_t * val,int writeOperation,void * arg)346 int CallStack::AccessFpreg([[maybe_unused]] unw_addr_space_t as, [[maybe_unused]] unw_regnum_t num,
347 [[maybe_unused]] unw_fpreg_t *val, [[maybe_unused]] int writeOperation,
348 [[maybe_unused]] void *arg)
349 {
350 return -UNW_EINVAL;
351 }
352
GetDynInfoListAaddr(unw_addr_space_t as,unw_word_t * dil_vaddr,void * arg)353 int CallStack::GetDynInfoListAaddr([[maybe_unused]] unw_addr_space_t as,
354 [[maybe_unused]] unw_word_t *dil_vaddr,
355 [[maybe_unused]] void *arg)
356 {
357 return -UNW_ENOINFO;
358 }
359
Resume(unw_addr_space_t as,unw_cursor_t * cu,void * arg)360 int CallStack::Resume([[maybe_unused]] unw_addr_space_t as, [[maybe_unused]] unw_cursor_t *cu,
361 [[maybe_unused]] void *arg)
362 {
363 return -UNW_EINVAL;
364 }
365
getProcName(unw_addr_space_t as,unw_word_t addr,char * bufp,size_t buf_len,unw_word_t * offp,void * arg)366 int CallStack::getProcName([[maybe_unused]] unw_addr_space_t as, [[maybe_unused]] unw_word_t addr,
367 [[maybe_unused]] char *bufp, [[maybe_unused]] size_t buf_len,
368 [[maybe_unused]] unw_word_t *offp, [[maybe_unused]] void *arg)
369 {
370 return -UNW_EINVAL;
371 }
372
UnwindStep(unw_cursor_t & c,std::vector<CallFrame> & callStack,size_t maxStackLevel)373 void CallStack::UnwindStep(unw_cursor_t &c, std::vector<CallFrame> &callStack, size_t maxStackLevel)
374 {
375 while (callStack.size() < maxStackLevel) {
376 int ret = unw_step(&c);
377 if (ret > 0) {
378 unw_word_t ip, sp;
379 unw_get_reg(&c, UNW_REG_IP, &ip);
380 unw_get_reg(&c, UNW_REG_SP, &sp);
381
382 if (ip == 0) {
383 HLOGD("ip == 0 something is wrong. break");
384 break;
385 }
386
387 /*
388 * Decrement the IP for any non-activation frames.
389 * this is required to properly find the srcline
390 * for caller frames.
391 * See also the documentation for dwfl_frame_pc(),
392 * which this code tries to replicate.
393 */
394 if (unw_is_signal_frame(&c) <= 0) {
395 --ip;
396 }
397 HLOGV("unwind:%zu: ip 0x%" UNW_WORD_PFLAG " sp 0x%" UNW_WORD_PFLAG "", callStack.size(),
398 ip, sp);
399 if (callStack.back().ip_ == ip && callStack.back().sp_ == sp) {
400 HLOGW("we found a same frame, stop here");
401 break;
402 }
403 callStack.emplace_back(ip, sp);
404 } else {
405 HLOGV("no more frame step found. ret %d:%s", ret, GetUnwErrorName(ret).c_str());
406 break;
407 }
408 }
409 }
410 #endif
411
GetIpSP(uint64_t & ip,uint64_t & sp,const u64 * regs,size_t regNum) const412 bool CallStack::GetIpSP(uint64_t &ip, uint64_t &sp, const u64 *regs, size_t regNum) const
413 {
414 if (regNum > 0) {
415 if (!RegisterGetSPValue(sp, arch_, regs, regNum)) {
416 HLOGW("unable get sp");
417 return false;
418 }
419 if (!RegisterGetIPValue(ip, arch_, regs, regNum)) {
420 HLOGW("unable get ip");
421 return false;
422 }
423 if (ip != 0) {
424 return true;
425 }
426 } else {
427 HLOGW("reg size is 0");
428 return false;
429 }
430 return false;
431 }
432
433 #if HAVE_LIBUNWIND
DoUnwind(const VirtualThread & thread,std::vector<CallFrame> & callStack,size_t maxStackLevel)434 bool CallStack::DoUnwind(const VirtualThread &thread, std::vector<CallFrame> &callStack,
435 size_t maxStackLevel)
436 {
437 unw_addr_space_t addr_space;
438 UnwindInfo unwindInfo = {
439 .thread = thread,
440 .callStack = *this,
441 };
442 unw_cursor_t c;
443 if (unwindAddrSpaceMap_.count(thread.tid_) == 0) {
444 addr_space = unw_create_addr_space(&accessors_, 0);
445 if (!addr_space) {
446 HLOGE("Can't create unwind vaddress space.");
447 return false;
448 }
449 unwindAddrSpaceMap_.emplace(thread.tid_, addr_space);
450 unw_set_caching_policy(addr_space, UNW_CACHE_GLOBAL);
451 unw_flush_cache(addr_space, 0, 0);
452 } else {
453 addr_space = unwindAddrSpaceMap_.at(thread.tid_);
454 }
455
456 int ret = unw_init_remote(&c, addr_space, &unwindInfo);
457 if (ret) {
458 HLOGE("unwind error %d:%s see unw_error_t.", ret, GetUnwErrorName(ret).c_str());
459 return false;
460 } else {
461 UnwindStep(c, callStack, maxStackLevel);
462 }
463 return true;
464 }
465 #endif
466
UnwindCallStack(const VirtualThread & thread,bool abi32,u64 * regs,u64 regsNum,const u8 * stack,u64 stackSize,std::vector<CallFrame> & callStack,size_t maxStackLevel)467 bool CallStack::UnwindCallStack(const VirtualThread &thread, bool abi32, u64 *regs, u64 regsNum,
468 const u8 *stack, u64 stackSize, std::vector<CallFrame> &callStack,
469 size_t maxStackLevel)
470 {
471 regs_ = regs;
472 regsNum_ = regsNum;
473 stack_ = stack;
474 stackSize_ = stackSize;
475
476 arch_ = GetArchTypeFromABI(abi32);
477 UpdateRegForABI(arch_, regs_);
478 if (!RegisterGetSPValue(stackPoint_, arch_, regs_, regsNum_)) {
479 HLOGE("RegisterGetSPValue failed");
480 return false;
481 } else {
482 stackEnd_ = stackPoint_ + stackSize_;
483 }
484
485 #if HAVE_LIBUNWIND
486 uint64_t ip, sp;
487 if (!GetIpSP(ip, sp, regs_, regsNum_)) {
488 HLOGW("unable get sp or sp , unable unwind");
489 return false;
490 } else {
491 if (ip != 0) {
492 HLOGV("unwind:%zu: ip 0x%" PRIx64 " sp 0x%" PRIx64 "", callStack.size(), ip, sp);
493 callStack.emplace_back(ip, sp);
494 }
495 }
496
497 /*
498 * If we need more than one entry, do the DWARF
499 * unwind itself.
500 */
501 if (maxStackLevel - 1 > 0) {
502 return DoUnwind(thread, callStack, maxStackLevel);
503 }
504 #endif
505 return true;
506 }
507
LogFrame(const std::string msg,const std::vector<CallFrame> & frames)508 void CallStack::LogFrame(const std::string msg, const std::vector<CallFrame> &frames)
509 {
510 HLOGM("%s", msg.c_str());
511 int level = 0;
512 for (auto frame : frames) {
513 HLOGM("%d:%s", level++, frame.ToString().c_str());
514 }
515 }
516
517 /*
518 we should have CallStack cache for each thread
519 end begin
520 0. A -> B -> C -> E -> F
521 1. C -> E -> F
522 2. B -> C
523 3. A -> B -> C
524 4. B -> G -> H
525 5. J -> C
526
527 0 is our cache
528 1 2 3... is from record
529
530 use expandLimit to setup how may frame match is needs
531
532 */
DoExpandCallStack(std::vector<CallFrame> & newCallFrames,const std::vector<CallFrame> & cachedCallFrames,size_t expandLimit)533 size_t CallStack::DoExpandCallStack(std::vector<CallFrame> &newCallFrames,
534 const std::vector<CallFrame> &cachedCallFrames,
535 size_t expandLimit)
536 {
537 int maxCycle = 0;
538
539 if (expandLimit == 0 or newCallFrames.size() < expandLimit or
540 cachedCallFrames.size() < expandLimit) {
541 HLOGM("expandLimit %zu not match new %zu cache %zu", expandLimit, newCallFrames.size(),
542 cachedCallFrames.size());
543 return 0; // size not enough
544 }
545
546 // called (Stack Buttom) , this will NOT change when compare
547 // in case1 newIt -> C
548 // in case2 newIt -> B
549 const auto newIt = newCallFrames.end() - expandLimit;
550
551 HLOGM("try find new call chain bottom %s for limit %zu", newIt->ToString().c_str(),
552 expandLimit);
553
554 // first frame search, from called - > caller
555 // for case 2 it should found B
556 size_t distances = expandLimit - 1;
557 auto cachedIt = find(cachedCallFrames.begin(), cachedCallFrames.end(), *newIt);
558 if (cachedIt == cachedCallFrames.end()) {
559 HLOGM("not found in first search");
560 }
561
562 // cache frame found
563 while (std::distance(cachedIt, cachedCallFrames.end()) >= signed(expandLimit)) {
564 HLOG_ASSERT_MESSAGE(maxCycle++ < MAX_CALL_FRAME_EXPAND_CYCLE, "MAX_UNWIND_CYCLE = %d reach",
565 MAX_CALL_FRAME_EXPAND_CYCLE);
566
567 if (std::equal(newIt, newIt + expandLimit, cachedIt)) {
568 HLOGM("match %s + %zu", newIt->ToString().c_str(), expandLimit);
569 cachedIt += expandLimit; // in while we check the boundary safe
570 if (cachedIt == cachedCallFrames.end()) {
571 // same but no more need expand
572 break;
573 }
574
575 // expand the frame and make some log ?
576 LogFrame("newCallStack:", newCallFrames);
577 LogFrame("cachedCallStack:", cachedCallFrames);
578
579 newCallFrames.insert(newCallFrames.end(), cachedIt, cachedCallFrames.end());
580 auto expands = std::distance(cachedIt, cachedCallFrames.end());
581 HLOGV("merge callstack increse to %zu (+%zd) ", newCallFrames.size(), expands);
582 // we done the deal
583 return expands;
584 } else {
585 // quick search next same farme again
586 cachedIt++;
587 if (cachedIt != cachedCallFrames.end()) {
588 HLOGM("search next");
589 cachedIt = find(cachedIt, cachedCallFrames.end(), *newIt);
590 }
591 }
592 }
593 HLOGM("cachedIt distance %zd , need %zd", std::distance(cachedCallFrames.begin(), cachedIt),
594 distances);
595 return 0u; // nothing expand
596 }
597
ExpandCallStack(pid_t tid,std::vector<CallFrame> & callFrames,size_t expandLimit)598 size_t CallStack::ExpandCallStack(pid_t tid, std::vector<CallFrame> &callFrames, size_t expandLimit)
599 {
600 size_t expand = 0u;
601 if (expandLimit == 0) {
602 return expand; // nothing need to do
603 } else if (callFrames.size() < expandLimit) {
604 HLOGM("new callstack is too small, skip it");
605 return expand;
606 }
607 if (!cachedCallFramesMap_.count(tid)) {
608 cachedCallFramesMap_[tid].reserve(MAX_CALL_FRAME_EXPAND_CACHE_SIZE);
609 }
610 if (callFrames.size() >= 1u) {
611 // get top (Earliest caller)
612 HashList<uint64_t, std::vector<CallFrame>> &cachedCallFrames = cachedCallFramesMap_[tid];
613 HLOGV("find call stack frames in cache size %zu", cachedCallFrames.size());
614 // compare
615 using namespace std::rel_ops; // enable complement comparing operators
616 for (auto itr = cachedCallFrames.begin(); itr < cachedCallFrames.end(); ++itr) {
617 // each cached callstack
618 /*
619 stack 2 1 0
620 cache A -> B -> C
621 new B -> C
622 check:
623 1 if new B == cache C
624 2 if new B == cache B
625 3 if new C == new C (if limit > 0)
626 4 insert A after B in new stack
627 */
628 const std::vector<CallFrame> &cachedCallStack = *itr;
629 if (cachedCallStack.size() < expandLimit) {
630 HLOGM("cache callstack is too small, skip it");
631 continue; // check next
632 }
633 expand = DoExpandCallStack(callFrames, cachedCallStack, expandLimit);
634 if (expand > 0) {
635 break;
636 }
637 }
638 // add new one in to cache cachedCallFrames.
639 // further optimization can be done by caching pointer which avoids copying
640 // vector
641 cachedCallFrames[callFrames[0].ip_] = callFrames;
642 }
643 HLOGM("expand %zu", expand);
644 return expand;
645 }
646
CallStack()647 CallStack::CallStack() {}
648
~CallStack()649 CallStack::~CallStack()
650 {
651 #if HAVE_LIBUNWIND
652 for (auto &pair : unwindAddrSpaceMap_) {
653 unw_destroy_addr_space(pair.second);
654 }
655 #endif
656 }
657 } // namespace HiPerf
658 } // namespace Developtools
659 } // namespace OHOS
660