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 #include "appfreeze_inner.h"
16
17 #include <sys/time.h>
18
19 #include "ability_manager_client.h"
20 #include "ability_state.h"
21 #include "appfreeze_manager.h"
22 #include "app_recovery.h"
23 #include "exit_reason.h"
24 #include "ffrt.h"
25 #include "freeze_util.h"
26 #include "hilog_tag_wrapper.h"
27 #include "hitrace_meter.h"
28 #include "parameter.h"
29 #include "xcollie/watchdog.h"
30 #include "time_util.h"
31
32 namespace OHOS {
33 using AbilityRuntime::FreezeUtil;
34 namespace AppExecFwk {
35 namespace {
36 constexpr char EVENT_UID[] = "UID";
37 constexpr char EVENT_PID[] = "PID";
38 constexpr char EVENT_MESSAGE[] = "MSG";
39 constexpr char EVENT_PACKAGE_NAME[] = "PACKAGE_NAME";
40 constexpr char EVENT_PROCESS_NAME[] = "PROCESS_NAME";
41 constexpr char EVENT_STACK[] = "STACK";
42 }
43 std::weak_ptr<EventHandler> AppfreezeInner::appMainHandler_;
44 std::shared_ptr<AppfreezeInner> AppfreezeInner::instance_ = nullptr;
45 std::mutex AppfreezeInner::singletonMutex_;
46
AppfreezeInner()47 AppfreezeInner::AppfreezeInner()
48 {}
49
~AppfreezeInner()50 AppfreezeInner::~AppfreezeInner()
51 {}
52
SetMainHandler(const std::shared_ptr<EventHandler> & eventHandler)53 void AppfreezeInner::SetMainHandler(const std::shared_ptr<EventHandler>& eventHandler)
54 {
55 appMainHandler_ = eventHandler;
56 }
57
SetApplicationInfo(const std::shared_ptr<ApplicationInfo> & applicationInfo)58 void AppfreezeInner::SetApplicationInfo(const std::shared_ptr<ApplicationInfo>& applicationInfo)
59 {
60 applicationInfo_ = applicationInfo;
61 }
62
GetInstance()63 std::shared_ptr<AppfreezeInner> AppfreezeInner::GetInstance()
64 {
65 if (instance_ == nullptr) {
66 std::lock_guard<std::mutex> lock(singletonMutex_);
67 if (instance_ == nullptr) {
68 instance_ = std::make_shared<AppfreezeInner>();
69 }
70 }
71 return instance_;
72 }
73
DestroyInstance()74 void AppfreezeInner::DestroyInstance()
75 {
76 std::lock_guard<std::mutex> lock(singletonMutex_);
77 if (instance_ != nullptr) {
78 instance_.reset();
79 instance_ = nullptr;
80 }
81 }
82
IsHandleAppfreeze()83 bool AppfreezeInner::IsHandleAppfreeze()
84 {
85 return !isAppDebug_;
86 }
87
GetMainHandlerDump(std::string & msgContent)88 void AppfreezeInner::GetMainHandlerDump(std::string& msgContent)
89 {
90 auto mainHandler = appMainHandler_.lock();
91 if (mainHandler == nullptr) {
92 msgContent += "mainHandler is destructed!";
93 } else {
94 MainHandlerDumper handlerDumper;
95 msgContent += "mainHandler dump is:\n";
96 mainHandler->Dump(handlerDumper);
97 msgContent += handlerDumper.GetDumpInfo();
98 }
99 }
100
ChangeFaultDateInfo(FaultData & faultData,const std::string & msgContent)101 void AppfreezeInner::ChangeFaultDateInfo(FaultData& faultData, const std::string& msgContent)
102 {
103 faultData.errorObject.message += msgContent;
104 faultData.faultType = FaultDataType::APP_FREEZE;
105 faultData.notifyApp = false;
106 faultData.waitSaveState = false;
107 faultData.forceExit = false;
108 bool isExit = IsExitApp(faultData.errorObject.name);
109 if (isExit) {
110 faultData.forceExit = true;
111 faultData.waitSaveState = AppRecovery::GetInstance().IsEnabled();
112 AAFwk::ExitReason exitReason = {REASON_APP_FREEZE, "Kill Reason:" + faultData.errorObject.name};
113 AbilityManagerClient::GetInstance()->RecordAppExitReason(exitReason);
114 }
115 NotifyANR(faultData);
116 if (isExit) {
117 AppFreezeRecovery();
118 }
119 }
120
AppfreezeHandleOverReportCount(bool isSixSecondEvent)121 void AppfreezeInner::AppfreezeHandleOverReportCount(bool isSixSecondEvent)
122 {
123 FaultData faultData;
124 faultData.errorObject.message =
125 "\nFault time:" + AbilityRuntime::TimeUtil::FormatTime("%Y/%m/%d-%H:%M:%S") + "\n";
126 faultData.errorObject.message += "App main thread is not response!";
127 faultData.faultType = FaultDataType::APP_FREEZE;
128 faultData.timeoutMarkers = "";
129 if (isSixSecondEvent) {
130 faultData.errorObject.name = AppFreezeType::THREAD_BLOCK_6S;
131 } else {
132 faultData.errorObject.name = AppFreezeType::THREAD_BLOCK_3S;
133 }
134 if (!IsHandleAppfreeze()) {
135 NotifyANR(faultData);
136 return;
137 }
138 std::string msgContent;
139 GetMainHandlerDump(msgContent);
140 ChangeFaultDateInfo(faultData, msgContent);
141 return;
142 }
143
AppfreezeHandle(const FaultData & faultData,bool onlyMainThread)144 int AppfreezeInner::AppfreezeHandle(const FaultData& faultData, bool onlyMainThread)
145 {
146 if (!IsHandleAppfreeze()) {
147 NotifyANR(faultData);
148 return -1;
149 }
150 auto reportFreeze = [faultData, onlyMainThread]() {
151 if (faultData.errorObject.name == "") {
152 TAG_LOGE(AAFwkTag::APPDFR, "null name");
153 return;
154 }
155 AppExecFwk::AppfreezeInner::GetInstance()->AcquireStack(faultData, onlyMainThread);
156 };
157
158 {
159 std::lock_guard<std::mutex> lock(handlingMutex_);
160 handlinglist_.emplace_back(faultData);
161 constexpr int HANDLING_MIN_SIZE = 1;
162 if (handlinglist_.size() <= HANDLING_MIN_SIZE) {
163 ffrt::submit(reportFreeze, {}, {}, ffrt::task_attr().name("reportAppFreeze"));
164 }
165 }
166 return 0;
167 }
168
IsExitApp(const std::string & name)169 bool AppfreezeInner::IsExitApp(const std::string& name)
170 {
171 if (name == AppFreezeType::THREAD_BLOCK_6S || name == AppFreezeType::APP_INPUT_BLOCK ||
172 name == AppFreezeType::LIFECYCLE_TIMEOUT || name == AppFreezeType::BUSSINESS_THREAD_BLOCK_6S) {
173 return true;
174 }
175 return false;
176 }
177
AcquireStack(const FaultData & info,bool onlyMainThread)178 int AppfreezeInner::AcquireStack(const FaultData& info, bool onlyMainThread)
179 {
180 HITRACE_METER_FMT(HITRACE_TAG_APP, "AppfreezeInner::AcquireStack name:%s", info.errorObject.name.c_str());
181 std::string stack = "";
182 std::string msgContent;
183 GetMainHandlerDump(msgContent);
184
185 std::lock_guard<std::mutex> lock(handlingMutex_);
186 for (auto it = handlinglist_.begin(); it != handlinglist_.end(); it = handlinglist_.erase(it)) {
187 HITRACE_METER_FMT(HITRACE_TAG_APP, "send appfreeze name:%s", it->errorObject.name.c_str());
188 FaultData faultData;
189 faultData.errorObject.message = it->errorObject.message + "\n";
190 if (it->state != 0) {
191 FreezeUtil::LifecycleFlow flow = { it->token, static_cast<FreezeUtil::TimeoutState>(it->state) };
192 faultData.errorObject.message += "client:\n" +
193 FreezeUtil::GetInstance().GetLifecycleEvent(flow) + "\nclient app:\n" +
194 FreezeUtil::GetInstance().GetAppLifecycleEvent(0) + "\n";
195 }
196 faultData.errorObject.stack = stack;
197 faultData.errorObject.name = it->errorObject.name;
198 faultData.timeoutMarkers = it->timeoutMarkers;
199 faultData.eventId = it->eventId;
200 ChangeFaultDateInfo(faultData, msgContent);
201 }
202 return 0;
203 }
204
ThreadBlock(std::atomic_bool & isSixSecondEvent)205 void AppfreezeInner::ThreadBlock(std::atomic_bool& isSixSecondEvent)
206 {
207 FaultData faultData;
208 faultData.errorObject.message =
209 "\nFault time:" + AbilityRuntime::TimeUtil::FormatTime("%Y/%m/%d-%H:%M:%S") + "\n";
210 faultData.errorObject.message += "App main thread is not response!";
211 faultData.faultType = FaultDataType::APP_FREEZE;
212 bool onlyMainThread = false;
213
214 if (isSixSecondEvent) {
215 faultData.errorObject.name = AppFreezeType::THREAD_BLOCK_6S;
216 onlyMainThread = true;
217 #ifdef APP_NO_RESPONSE_DIALOG
218 isSixSecondEvent.store(false);
219 #endif
220 } else {
221 faultData.errorObject.name = AppFreezeType::THREAD_BLOCK_3S;
222 isSixSecondEvent.store(true);
223 }
224 faultData.timeoutMarkers = "";
225
226 if (!IsHandleAppfreeze()) {
227 return;
228 }
229
230 AppfreezeHandle(faultData, onlyMainThread);
231 }
232
NotifyANR(const FaultData & faultData)233 int AppfreezeInner::NotifyANR(const FaultData& faultData)
234 {
235 HITRACE_METER_FMT(HITRACE_TAG_APP, "AppfreezeInner::NotifyANR name:%s",
236 faultData.errorObject.name.c_str());
237 auto applicationInfo = applicationInfo_.lock();
238 if (applicationInfo == nullptr) {
239 TAG_LOGE(AAFwkTag::APPDFR, "null applicationInfo_");
240 return -1;
241 }
242
243 int32_t pid = static_cast<int32_t>(getpid());
244 TAG_LOGI(AAFwkTag::APPDFR, "NotifyAppFault:%{public}s, pid:%{public}d, bundleName:%{public}s",
245 faultData.errorObject.name.c_str(), pid, applicationInfo->bundleName.c_str());
246
247 int ret = DelayedSingleton<AppExecFwk::AppMgrClient>::GetInstance()->NotifyAppFault(faultData);
248 if (ret != 0) {
249 TAG_LOGW(AAFwkTag::APPDFR, "NotifyAppFault ret:%{public}d", ret);
250 }
251 return ret;
252 }
253
AppFreezeRecovery()254 void AppfreezeInner::AppFreezeRecovery()
255 {
256 AppRecovery::GetInstance().ScheduleSaveAppState(StateReason::APP_FREEZE);
257 AppRecovery::GetInstance().ScheduleRecoverApp(StateReason::APP_FREEZE);
258 }
259
SetAppDebug(bool isAppDebug)260 void AppfreezeInner::SetAppDebug(bool isAppDebug)
261 {
262 isAppDebug_ = isAppDebug;
263 }
264
Dump(const std::string & message)265 void MainHandlerDumper::Dump(const std::string &message)
266 {
267 dumpInfo += message;
268 }
269
GetTag()270 std::string MainHandlerDumper::GetTag()
271 {
272 return "";
273 }
274
GetDumpInfo()275 std::string MainHandlerDumper::GetDumpInfo()
276 {
277 return dumpInfo;
278 }
279 } // namespace AAFwk
280 } // namespace OHOS