1 /*
2 * Copyright (c) 2023-2024 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 "dfx_ark.h"
17
18 #include <algorithm>
19 #include <cstdio>
20 #include <cstdlib>
21 #include <dlfcn.h>
22 #include <pthread.h>
23
24 #include "dfx_define.h"
25 #include "dfx_log.h"
26 #include "string_util.h"
27
28 namespace OHOS {
29 namespace HiviewDFX {
30 namespace {
31 #undef LOG_DOMAIN
32 #undef LOG_TAG
33 #define LOG_DOMAIN 0xD002D11
34 #define LOG_TAG "DfxArk"
35
36 const char ARK_LIB_NAME[] = "libark_jsruntime.so";
37 }
38
GetLibArkHandle()39 bool DfxArk::GetLibArkHandle()
40 {
41 if (handle_ != nullptr) {
42 return true;
43 }
44 handle_ = dlopen(ARK_LIB_NAME, RTLD_LAZY);
45 if (handle_ == nullptr) {
46 DFXLOGU("Failed to load library(%{public}s).", dlerror());
47 return false;
48 }
49 return true;
50 }
51
Instance()52 DfxArk& DfxArk::Instance()
53 {
54 static DfxArk instance;
55 return instance;
56 }
57
58 template <typename FuncName>
DlsymArkFunc(const char * funcName,FuncName & dlsymFuncName)59 void DfxArk::DlsymArkFunc(const char* funcName, FuncName& dlsymFuncName)
60 {
61 std::unique_lock<std::mutex> lock(arkMutex_);
62 do {
63 if (dlsymFuncName != nullptr) {
64 break;
65 }
66 if (!GetLibArkHandle()) {
67 break;
68 }
69 (dlsymFuncName) = reinterpret_cast<FuncName>(dlsym(handle_, (funcName)));
70 if (dlsymFuncName == nullptr) {
71 DFXLOGE("Failed to dlsym(%{public}s), error: %{public}s", funcName, dlerror());
72 break;
73 }
74 } while (false);
75 }
76
ArkCreateJsSymbolExtractor(uintptr_t * extractorPtr)77 int DfxArk::ArkCreateJsSymbolExtractor(uintptr_t* extractorPtr)
78 {
79 if (arkCreateJsSymbolExtractorFn_ != nullptr) {
80 return arkCreateJsSymbolExtractorFn_(extractorPtr);
81 }
82
83 const char* arkFuncName = "ark_create_js_symbol_extractor";
84 DlsymArkFunc(arkFuncName, arkCreateJsSymbolExtractorFn_);
85
86 if (arkCreateJsSymbolExtractorFn_ != nullptr) {
87 return arkCreateJsSymbolExtractorFn_(extractorPtr);
88 }
89 return -1;
90 }
91
ArkDestoryJsSymbolExtractor(uintptr_t extractorPtr)92 int DfxArk::ArkDestoryJsSymbolExtractor(uintptr_t extractorPtr)
93 {
94 if (arkDestoryJsSymbolExtractorFn_ != nullptr) {
95 return arkDestoryJsSymbolExtractorFn_(extractorPtr);
96 }
97
98 const char* arkFuncName = "ark_destory_js_symbol_extractor";
99 DlsymArkFunc(arkFuncName, arkDestoryJsSymbolExtractorFn_);
100
101 if (arkDestoryJsSymbolExtractorFn_ != nullptr) {
102 return arkDestoryJsSymbolExtractorFn_(extractorPtr);
103 }
104 return -1;
105 }
106
ArkCreateLocal()107 int DfxArk::ArkCreateLocal()
108 {
109 if (arkCreateLocalFn_ != nullptr) {
110 return arkCreateLocalFn_();
111 }
112
113 const char* arkFuncName = "ark_create_local";
114 DlsymArkFunc(arkFuncName, arkCreateLocalFn_);
115
116 if (arkCreateLocalFn_ != nullptr) {
117 return arkCreateLocalFn_();
118 }
119 return -1;
120 }
121
ArkDestroyLocal()122 int DfxArk::ArkDestroyLocal()
123 {
124 if (arkDestroyLocalFn_ != nullptr) {
125 return arkDestroyLocalFn_();
126 }
127
128 const char* arkFuncName = "ark_destroy_local";
129 DlsymArkFunc(arkFuncName, arkDestroyLocalFn_);
130
131 if (arkDestroyLocalFn_ != nullptr) {
132 return arkDestroyLocalFn_();
133 }
134 return -1;
135 }
136
ParseArkFileInfo(uintptr_t byteCodePc,uintptr_t mapBase,const char * name,uintptr_t extractorPtr,JsFunction * jsFunction)137 int DfxArk::ParseArkFileInfo(uintptr_t byteCodePc, uintptr_t mapBase, const char* name,
138 uintptr_t extractorPtr, JsFunction *jsFunction)
139 {
140 if (parseArkFileInfoFn_ != nullptr) {
141 return parseArkFileInfoFn_(byteCodePc, mapBase, name, extractorPtr, jsFunction);
142 }
143
144 const char* arkFuncName = "ark_parse_js_file_info";
145 DlsymArkFunc(arkFuncName, parseArkFileInfoFn_);
146
147 if (parseArkFileInfoFn_ != nullptr) {
148 return parseArkFileInfoFn_(byteCodePc, mapBase, name, extractorPtr, jsFunction);
149 }
150 return -1;
151 }
152
ParseArkFrameInfoLocal(uintptr_t byteCodePc,uintptr_t mapBase,uintptr_t offset,JsFunction * jsFunction)153 int DfxArk::ParseArkFrameInfoLocal(uintptr_t byteCodePc, uintptr_t mapBase,
154 uintptr_t offset, JsFunction *jsFunction)
155 {
156 if (parseArkFrameInfoLocalFn_ != nullptr) {
157 return parseArkFrameInfoLocalFn_(byteCodePc, mapBase, offset, jsFunction);
158 }
159
160 const char* arkFuncName = "ark_parse_js_frame_info_local";
161 DlsymArkFunc(arkFuncName, parseArkFrameInfoLocalFn_);
162
163 if (parseArkFrameInfoLocalFn_ != nullptr) {
164 return parseArkFrameInfoLocalFn_(byteCodePc, mapBase, offset, jsFunction);
165 }
166 return -1;
167 }
168
ParseArkFrameInfo(uintptr_t byteCodePc,uintptr_t mapBase,uintptr_t loadOffset,uint8_t * data,uint64_t dataSize,uintptr_t extractorPtr,JsFunction * jsFunction)169 int DfxArk::ParseArkFrameInfo(uintptr_t byteCodePc, uintptr_t mapBase, uintptr_t loadOffset,
170 uint8_t *data, uint64_t dataSize, uintptr_t extractorPtr, JsFunction *jsFunction)
171 {
172 if (parseArkFrameInfoFn_ != nullptr) {
173 return parseArkFrameInfoFn_(byteCodePc, mapBase, loadOffset, data, dataSize,
174 extractorPtr, jsFunction);
175 }
176
177 const char* arkFuncName = "ark_parse_js_frame_info";
178 DlsymArkFunc(arkFuncName, parseArkFrameInfoFn_);
179
180 if (parseArkFrameInfoFn_ != nullptr) {
181 return parseArkFrameInfoFn_(byteCodePc, mapBase, loadOffset, data, dataSize,
182 extractorPtr, jsFunction);
183 }
184 return -1;
185 }
186
StepArkFrame(void * obj,OHOS::HiviewDFX::ReadMemFunc readMemFn,OHOS::HiviewDFX::ArkStepParam * arkParam)187 int DfxArk::StepArkFrame(void *obj, OHOS::HiviewDFX::ReadMemFunc readMemFn,
188 OHOS::HiviewDFX::ArkStepParam* arkParam)
189 {
190 if (stepArkFn_ != nullptr) {
191 return stepArkFn_(obj, readMemFn, arkParam);
192 }
193
194 const char* arkFuncName = "step_ark";
195 DlsymArkFunc(arkFuncName, stepArkFn_);
196
197 if (stepArkFn_ != nullptr) {
198 return stepArkFn_(obj, readMemFn, arkParam);
199 }
200 return -1;
201 }
202
StepArkFrameWithJit(OHOS::HiviewDFX::ArkUnwindParam * arkParam)203 int DfxArk::StepArkFrameWithJit(OHOS::HiviewDFX::ArkUnwindParam* arkParam)
204 {
205 if (stepArkWithJitFn_ != nullptr) {
206 return stepArkWithJitFn_(arkParam);
207 }
208
209 const char* const arkFuncName = "step_ark_with_record_jit";
210 DlsymArkFunc(arkFuncName, stepArkWithJitFn_);
211
212 if (stepArkWithJitFn_ != nullptr) {
213 return stepArkWithJitFn_(arkParam);
214 }
215 return -1;
216 }
217
JitCodeWriteFile(void * ctx,OHOS::HiviewDFX::ReadMemFunc readMemFn,int fd,const uintptr_t * const jitCodeArray,const size_t jitSize)218 int DfxArk::JitCodeWriteFile(void* ctx, OHOS::HiviewDFX::ReadMemFunc readMemFn, int fd,
219 const uintptr_t* const jitCodeArray, const size_t jitSize)
220 {
221 if (jitCodeWriteFileFn_ != nullptr) {
222 return jitCodeWriteFileFn_(ctx, readMemFn, fd, jitCodeArray, jitSize);
223 }
224
225 const char* const arkFuncName = "ark_write_jit_code";
226 DlsymArkFunc(arkFuncName, jitCodeWriteFileFn_);
227
228 if (jitCodeWriteFileFn_ != nullptr) {
229 return jitCodeWriteFileFn_(ctx, readMemFn, fd, jitCodeArray, jitSize);
230 }
231 return -1;
232 }
233 } // namespace HiviewDFX
234 } // namespace OHOS
235