1 /*
2 * Copyright (c) 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 "cgroup_event_handler.h"
17 #include <cinttypes>
18 #include "app_mgr_constants.h"
19 #include "cgroup_adjuster.h"
20 #include "cgroup_sched_common.h"
21 #include "cgroup_sched_log.h"
22 #include "ressched_utils.h"
23 #include "res_type.h"
24 #include "sched_controller.h"
25 #include "sched_policy.h"
26 #include "system_ability_definition.h"
27
28 namespace OHOS {
29 namespace ResourceSchedule {
30 namespace {
31 constexpr HiviewDFX::HiLogLabel LOG_LABEL = {LOG_CORE, LOG_TAG_DOMAIN_ID_RMS, "CgroupEventHandler"};
32 constexpr uint32_t EVENT_ID_REG_APP_STATE_OBSERVER = 1;
33 constexpr uint32_t EVENT_ID_REG_BGTASK_OBSERVER = 2;
34 constexpr uint32_t DELAYED_RETRY_REGISTER_DURATION = 100;
35 constexpr uint32_t MAX_RETRY_TIMES = 100;
36
37 const std::string MMI_SERVICE_NAME = "mmi_service";
38 }
39
40 using OHOS::AppExecFwk::ApplicationState;
41 using OHOS::AppExecFwk::AbilityState;
42 using OHOS::AppExecFwk::ExtensionState;
43
CgroupEventHandler(const std::shared_ptr<EventRunner> & runner)44 CgroupEventHandler::CgroupEventHandler(const std::shared_ptr<EventRunner> &runner)
45 : EventHandler(runner)
46 {}
47
~CgroupEventHandler()48 CgroupEventHandler::~CgroupEventHandler()
49 {
50 supervisor_ = nullptr;
51 }
52
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)53 void CgroupEventHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer& event)
54 {
55 CGS_LOGD("%{public}s : eventId:%{public}d param:%{public}" PRIu64,
56 __func__, event->GetInnerEventId(), event->GetParam());
57 switch (event->GetInnerEventId()) {
58 case EVENT_ID_REG_APP_STATE_OBSERVER: {
59 int64_t retry = event->GetParam();
60 if (!SchedController::GetInstance().SubscribeAppState() &&
61 retry < MAX_RETRY_TIMES) {
62 auto event = AppExecFwk::InnerEvent::Get(EVENT_ID_REG_APP_STATE_OBSERVER, retry + 1);
63 this->SendEvent(event, DELAYED_RETRY_REGISTER_DURATION);
64 }
65 break;
66 }
67 case EVENT_ID_REG_BGTASK_OBSERVER: {
68 int64_t retry = event->GetParam();
69 if (!SchedController::GetInstance().SubscribeBackgroundTask() &&
70 retry < MAX_RETRY_TIMES) {
71 auto event = AppExecFwk::InnerEvent::Get(EVENT_ID_REG_BGTASK_OBSERVER, retry + 1);
72 this->SendEvent(event, DELAYED_RETRY_REGISTER_DURATION);
73 }
74 break;
75 }
76 default:
77 break;
78 }
79 }
80
SetSupervisor(std::shared_ptr<Supervisor> supervisor)81 void CgroupEventHandler::SetSupervisor(std::shared_ptr<Supervisor> supervisor)
82 {
83 supervisor_ = supervisor;
84 }
85
HandleAbilityAdded(int32_t saId,const std::string & deviceId)86 void CgroupEventHandler::HandleAbilityAdded(int32_t saId, const std::string& deviceId)
87 {
88 switch (saId) {
89 case APP_MGR_SERVICE_ID:
90 this->RemoveEvent(EVENT_ID_REG_APP_STATE_OBSERVER);
91 if (!SchedController::GetInstance().SubscribeAppState()) {
92 auto event = AppExecFwk::InnerEvent::Get(EVENT_ID_REG_APP_STATE_OBSERVER, 0);
93 this->SendEvent(event, DELAYED_RETRY_REGISTER_DURATION);
94 }
95 break;
96 case WINDOW_MANAGER_SERVICE_ID:
97 SchedController::GetInstance().SubscribeWindowState();
98 break;
99 case BACKGROUND_TASK_MANAGER_SERVICE_ID:
100 this->RemoveEvent(EVENT_ID_REG_BGTASK_OBSERVER);
101 if (!SchedController::GetInstance().SubscribeBackgroundTask()) {
102 auto event = AppExecFwk::InnerEvent::Get(EVENT_ID_REG_BGTASK_OBSERVER, 0);
103 this->SendEvent(event, DELAYED_RETRY_REGISTER_DURATION);
104 }
105 break;
106 default:
107 break;
108 }
109 }
110
HandleAbilityRemoved(int32_t saId,const std::string & deviceId)111 void CgroupEventHandler::HandleAbilityRemoved(int32_t saId, const std::string& deviceId)
112 {
113 switch (saId) {
114 case APP_MGR_SERVICE_ID:
115 this->RemoveEvent(EVENT_ID_REG_APP_STATE_OBSERVER);
116 SchedController::GetInstance().UnsubscribeAppState();
117 break;
118 case WINDOW_MANAGER_SERVICE_ID:
119 SchedController::GetInstance().UnsubscribeWindowState();
120 break;
121 case BACKGROUND_TASK_MANAGER_SERVICE_ID:
122 this->RemoveEvent(EVENT_ID_REG_BGTASK_OBSERVER);
123 SchedController::GetInstance().UnsubscribeBackgroundTask();
124 break;
125 default:
126 break;
127 }
128 }
129
HandleForegroundApplicationChanged(uid_t uid,std::string bundleName,int32_t state)130 void CgroupEventHandler::HandleForegroundApplicationChanged(uid_t uid, std::string bundleName, int32_t state)
131 {
132 if (!supervisor_) {
133 CGS_LOGE("%{public}s : supervisor nullptr!", __func__);
134 return;
135 }
136 CGS_LOGD("%{public}s : %{public}d, %{public}s, %{public}d", __func__, uid, bundleName.c_str(), state);
137 ChronoScope cs("HandleForegroundApplicationChanged");
138 std::shared_ptr<Application> app = supervisor_->GetAppRecordNonNull(uid);
139 app->name_ = bundleName;
140 app->state_ = state;
141 CgroupAdjuster::GetInstance().AdjustAllProcessGroup(*(app.get()), AdjustSource::ADJS_FG_APP_CHANGE);
142 }
143
HandleApplicationStateChanged(uid_t uid,std::string bundleName,int32_t state)144 void CgroupEventHandler::HandleApplicationStateChanged(uid_t uid, std::string bundleName, int32_t state)
145 {
146 if (!supervisor_) {
147 CGS_LOGE("%{public}s : supervisor nullptr!", __func__);
148 return;
149 }
150 CGS_LOGD("%{public}s : %{public}d, %{public}s, %{public}d", __func__, uid, bundleName.c_str(), state);
151 ChronoScope cs("HandleApplicationStateChanged");
152 // remove terminated application
153 if (state == (int32_t)(ApplicationState::APP_STATE_TERMINATED)) {
154 supervisor_->RemoveApplication(uid);
155 return;
156 }
157 std::shared_ptr<Application> app = supervisor_->GetAppRecordNonNull(uid);
158 app->name_ = bundleName;
159 app->state_ = state;
160 }
161
HandleAbilityStateChanged(uid_t uid,pid_t pid,std::string bundleName,std::string abilityName,uintptr_t token,int32_t abilityState,int32_t abilityType)162 void CgroupEventHandler::HandleAbilityStateChanged(uid_t uid, pid_t pid, std::string bundleName,
163 std::string abilityName, uintptr_t token, int32_t abilityState, int32_t abilityType)
164 {
165 if (!supervisor_) {
166 CGS_LOGE("%{public}s : supervisor nullptr!", __func__);
167 return;
168 }
169 CGS_LOGD("%{public}s : %{public}d, %{public}d, %{public}s, %{public}s, %{public}d, %{public}d",
170 __func__, uid, pid, bundleName.c_str(), abilityName.c_str(), abilityState, abilityType);
171 ChronoScope cs("HandleAbilityStateChanged");
172 if (abilityState == (int32_t)(AbilityState::ABILITY_STATE_TERMINATED)) {
173 auto app = supervisor_->GetAppRecord(uid);
174 if (app) {
175 auto procRecord = app->GetProcessRecord(pid);
176 if (procRecord) {
177 procRecord->RemoveAbilityByToken(token);
178 CgroupAdjuster::GetInstance().AdjustProcessGroup(*(app.get()), *(procRecord.get()),
179 AdjustSource::ADJS_ABILITY_STATE);
180 }
181 }
182 return;
183 }
184 auto app = supervisor_->GetAppRecordNonNull(uid);
185 app->name_ = bundleName;
186 auto procRecord = app->GetProcessRecordNonNull(pid);
187 auto abiInfo = procRecord->GetAbilityInfoNonNull(token);
188 abiInfo->name_ = abilityName;
189 abiInfo->state_ = abilityState;
190 abiInfo->type_ = abilityType;
191 CgroupAdjuster::GetInstance().AdjustProcessGroup(*(app.get()), *(procRecord.get()),
192 AdjustSource::ADJS_ABILITY_STATE);
193 }
194
HandleExtensionStateChanged(uid_t uid,pid_t pid,std::string bundleName,std::string abilityName,uintptr_t token,int32_t extensionState,int32_t abilityType)195 void CgroupEventHandler::HandleExtensionStateChanged(uid_t uid, pid_t pid, std::string bundleName,
196 std::string abilityName, uintptr_t token, int32_t extensionState, int32_t abilityType)
197 {
198 if (!supervisor_) {
199 CGS_LOGE("%{public}s : supervisor nullptr!", __func__);
200 return;
201 }
202 CGS_LOGD("%{public}s : %{public}d, %{public}d, %{public}s, %{public}s, %{public}d, %{public}d",
203 __func__, uid, pid, bundleName.c_str(), abilityName.c_str(), extensionState, abilityType);
204 ChronoScope cs("HandleExtensionStateChanged");
205 if (extensionState == (int32_t)(ExtensionState::EXTENSION_STATE_TERMINATED)) {
206 auto app = supervisor_->GetAppRecord(uid);
207 if (app) {
208 auto procRecord = app->GetProcessRecord(pid);
209 if (procRecord) {
210 procRecord->RemoveAbilityByToken(token);
211 CgroupAdjuster::GetInstance().AdjustProcessGroup(*(app.get()), *(procRecord.get()),
212 AdjustSource::ADJS_EXTENSION_STATE);
213 }
214 }
215 return;
216 }
217 auto app = supervisor_->GetAppRecordNonNull(uid);
218 app->name_ = bundleName;
219 auto procRecord = app->GetProcessRecordNonNull(pid);
220 auto abiInfo = procRecord->GetAbilityInfoNonNull(token);
221 abiInfo->name_ = abilityName;
222 abiInfo->estate_ = extensionState;
223 abiInfo->type_ = abilityType;
224 CgroupAdjuster::GetInstance().AdjustProcessGroup(*(app.get()), *(procRecord.get()),
225 AdjustSource::ADJS_EXTENSION_STATE);
226 }
227
HandleProcessCreated(uid_t uid,pid_t pid,std::string bundleName)228 void CgroupEventHandler::HandleProcessCreated(uid_t uid, pid_t pid, std::string bundleName)
229 {
230 if (!supervisor_) {
231 CGS_LOGE("%{public}s : supervisor nullptr!", __func__);
232 return;
233 }
234 CGS_LOGD("%{public}s : %{public}d, %{public}d, %{public}s", __func__, uid, pid, bundleName.c_str());
235 ChronoScope cs("HandleProcessCreated");
236 std::shared_ptr<Application> app = supervisor_->GetAppRecordNonNull(uid);
237 app->name_ = bundleName;
238 std::shared_ptr<ProcessRecord> procRecord = std::make_shared<ProcessRecord>(uid, pid);
239 app->AddProcessRecord(procRecord);
240 CgroupAdjuster::GetInstance().AdjustProcessGroup(*(app.get()), *(procRecord.get()),
241 AdjustSource::ADJS_PROCESS_CREATE);
242 }
243
HandleProcessDied(uid_t uid,pid_t pid,std::string bundleName)244 void CgroupEventHandler::HandleProcessDied(uid_t uid, pid_t pid, std::string bundleName)
245 {
246 if (!supervisor_) {
247 CGS_LOGE("%{public}s : supervisor nullptr!", __func__);
248 return;
249 }
250 CGS_LOGD("%{public}s : %{public}d, %{public}d, %{public}s", __func__, uid, pid, bundleName.c_str());
251 std::shared_ptr<Application> app = supervisor_->GetAppRecord(uid);
252 if (!app) {
253 CGS_LOGE("%{public}s : application %{public}s not exist!", __func__, bundleName.c_str());
254 return;
255 }
256 app->RemoveProcessRecord(pid);
257 // if all processes died, remove current app
258 if (app->GetPidsMap().size() == 0) {
259 supervisor_->RemoveApplication(uid);
260 }
261 }
262
HandleTransientTaskStart(uid_t uid,pid_t pid,std::string packageName)263 void CgroupEventHandler::HandleTransientTaskStart(uid_t uid, pid_t pid, std::string packageName)
264 {
265 if (!supervisor_) {
266 CGS_LOGE("%{public}s : supervisor nullptr!", __func__);
267 return;
268 }
269 CGS_LOGD("%{public}s : %{public}d, %{public}d, %{public}s", __func__, uid, pid, packageName.c_str());
270 auto app = supervisor_->GetAppRecordNonNull(uid);
271 app->name_ = packageName;
272 auto procRecord = app->GetProcessRecord(pid);
273 if (!procRecord) {
274 return;
275 }
276 procRecord->runningTransientTask_ = true;
277 }
278
HandleTransientTaskEnd(uid_t uid,pid_t pid,std::string packageName)279 void CgroupEventHandler::HandleTransientTaskEnd(uid_t uid, pid_t pid, std::string packageName)
280 {
281 if (!supervisor_) {
282 CGS_LOGE("%{public}s : supervisor nullptr!", __func__);
283 return;
284 }
285 CGS_LOGD("%{public}s : %{public}d, %{public}d, %{public}s", __func__, uid, pid, packageName.c_str());
286 auto app = supervisor_->GetAppRecordNonNull(uid);
287 app->name_ = packageName;
288 auto procRecord = app->GetProcessRecord(pid);
289 if (!procRecord) {
290 return;
291 }
292 procRecord->runningTransientTask_ = false;
293 }
294
HandleContinuousTaskStart(uid_t uid,pid_t pid,int32_t typeId,std::string abilityName)295 void CgroupEventHandler::HandleContinuousTaskStart(uid_t uid, pid_t pid, int32_t typeId, std::string abilityName)
296 {
297 if (!supervisor_) {
298 CGS_LOGE("%{public}s : supervisor nullptr!", __func__);
299 return;
300 }
301 CGS_LOGD("%{public}s : %{public}d, %{public}d, %{public}d, %{public}s",
302 __func__, uid, pid, typeId, abilityName.c_str());
303 ChronoScope cs("HandleContinuousTaskStart");
304 auto app = supervisor_->GetAppRecordNonNull(uid);
305 auto procRecord = app->GetProcessRecordNonNull(pid);
306 procRecord->continuousTaskFlag_ |= (1U << typeId);
307 CgroupAdjuster::GetInstance().AdjustProcessGroup(*(app.get()), *(procRecord.get()),
308 AdjustSource::ADJS_CONTINUOUS_BEGIN);
309 }
310
HandleContinuousTaskCancel(uid_t uid,pid_t pid,int32_t typeId,std::string abilityName)311 void CgroupEventHandler::HandleContinuousTaskCancel(uid_t uid, pid_t pid, int32_t typeId, std::string abilityName)
312 {
313 if (!supervisor_) {
314 CGS_LOGE("%{public}s : supervisor nullptr!", __func__);
315 return;
316 }
317 CGS_LOGD("%{public}s : %{public}d, %{public}d, %{public}d, %{public}s",
318 __func__, uid, pid, typeId, abilityName.c_str());
319 ChronoScope cs("HandleContinuousTaskCancel");
320 auto app = supervisor_->GetAppRecordNonNull(uid);
321 auto procRecord = app->GetProcessRecord(pid);
322 if (!procRecord) {
323 return;
324 }
325 procRecord->continuousTaskFlag_ &= ~(1U << typeId);
326 CgroupAdjuster::GetInstance().AdjustProcessGroup(*(app.get()), *(procRecord.get()),
327 AdjustSource::ADJS_CONTINUOUS_END);
328 }
329
HandleFocusedWindow(uint32_t windowId,uintptr_t abilityToken,WindowType windowType,uint64_t displayId,int32_t pid,int32_t uid)330 void CgroupEventHandler::HandleFocusedWindow(uint32_t windowId, uintptr_t abilityToken,
331 WindowType windowType, uint64_t displayId, int32_t pid, int32_t uid)
332 {
333 nlohmann::json payload;
334 payload["pid"] = std::to_string(pid);
335 payload["uid"] = std::to_string(uid);
336 payload["windowId"] = std::to_string(windowId);
337 payload["windowType"] = std::to_string((int32_t)(windowType));
338 payload["displayId"] = std::to_string(displayId);
339
340 if (!supervisor_) {
341 CGS_LOGE("%{public}s : supervisor nullptr!", __func__);
342 payload["bundleName"] = SchedController::GetInstance().GetBundleNameByUid(uid);
343 ResSchedUtils::GetInstance().ReportDataInProcess(
344 ResType::RES_TYPE_WINDOW_FOCUS, ResType::WindowFocusStatus::WINDOW_FOCUS, payload);
345 return;
346 }
347 CGS_LOGD("%{public}s : %{public}d, %{public}d, %{public}" PRIu64 ", %{public}d, %{public}d",
348 __func__, windowId, windowType, displayId, pid, uid);
349 if (!abilityToken) {
350 CGS_LOGW("%{public}s : abilityToken nullptr!", __func__);
351 }
352 std::shared_ptr<Application> app = nullptr;
353 std::shared_ptr<ProcessRecord> procRecord = nullptr;
354 {
355 ChronoScope cs("HandleFocusedWindow");
356 app = supervisor_->GetAppRecordNonNull(uid);
357 procRecord = app->GetProcessRecordNonNull(pid);
358 auto win = procRecord->GetWindowInfoNonNull(windowId);
359 auto abi = procRecord->GetAbilityInfo(abilityToken);
360 win->windowType_ = (int32_t)(windowType);
361 win->isFocused_ = true;
362 win->displayId_ = displayId;
363 win->ability_ = abi;
364
365 app->focusedProcess_ = procRecord;
366 auto lastFocusApp = supervisor_->focusedApp_;
367 if (lastFocusApp && lastFocusApp != app) {
368 lastFocusApp->focusedProcess_ = nullptr;
369 CgroupAdjuster::GetInstance().AdjustAllProcessGroup(*(lastFocusApp.get()),
370 AdjustSource::ADJS_FOCUSED_WINDOW);
371 }
372 supervisor_->focusedApp_ = app;
373 CgroupAdjuster::GetInstance().AdjustAllProcessGroup(*(app.get()), AdjustSource::ADJS_FOCUSED_WINDOW);
374 }
375 if (app->name_.empty()) {
376 app->name_ = SchedController::GetInstance().GetBundleNameByUid(uid);
377 }
378 payload["bundleName"] = app->name_;
379 ResSchedUtils::GetInstance().ReportDataInProcess(
380 ResType::RES_TYPE_WINDOW_FOCUS, ResType::WindowFocusStatus::WINDOW_FOCUS, payload);
381 }
382
HandleUnfocusedWindow(uint32_t windowId,uintptr_t abilityToken,WindowType windowType,uint64_t displayId,int32_t pid,int32_t uid)383 void CgroupEventHandler::HandleUnfocusedWindow(uint32_t windowId, uintptr_t abilityToken,
384 WindowType windowType, uint64_t displayId, int32_t pid, int32_t uid)
385 {
386 nlohmann::json payload;
387 payload["pid"] = std::to_string(pid);
388 payload["uid"] = std::to_string(uid);
389 payload["windowId"] = std::to_string(windowId);
390 payload["windowType"] = std::to_string((int32_t)(windowType));
391 payload["displayId"] = std::to_string(displayId);
392
393 if (!supervisor_) {
394 CGS_LOGE("%{public}s : supervisor nullptr!", __func__);
395 payload["bundleName"] = SchedController::GetInstance().GetBundleNameByUid(uid);
396 ResSchedUtils::GetInstance().ReportDataInProcess(
397 ResType::RES_TYPE_WINDOW_FOCUS, ResType::WindowFocusStatus::WINDOW_UNFOCUS, payload);
398 return;
399 }
400 CGS_LOGD("%{public}s : %{public}d, %{public}d, %{public}" PRIu64 ", %{public}d, %{public}d",
401 __func__, windowId, windowType, displayId, pid, uid);
402 if (!abilityToken) {
403 CGS_LOGW("%{public}s : abilityToken nullptr!", __func__);
404 }
405 std::shared_ptr<Application> app = nullptr;
406 std::shared_ptr<ProcessRecord> procRecord = nullptr;
407 {
408 ChronoScope cs("HandleUnfocusedWindow");
409 app = supervisor_->GetAppRecord(uid);
410 procRecord = app ? app->GetProcessRecord(pid) : nullptr;
411 if (!app || !procRecord) {
412 payload["bundleName"] = SchedController::GetInstance().GetBundleNameByUid(uid);
413 ResSchedUtils::GetInstance().ReportDataInProcess(
414 ResType::RES_TYPE_WINDOW_FOCUS, ResType::WindowFocusStatus::WINDOW_UNFOCUS, payload);
415 return;
416 }
417 auto win = procRecord->GetWindowInfoNonNull(windowId);
418 auto abi = procRecord->GetAbilityInfo(abilityToken);
419 win->windowType_ = (int32_t)(windowType);
420 win->isFocused_ = false;
421 win->displayId_ = displayId;
422 win->ability_ = abi;
423
424 if (app->focusedProcess_ == procRecord) {
425 app->focusedProcess_ = nullptr;
426 }
427 CgroupAdjuster::GetInstance().AdjustAllProcessGroup(*(app.get()), AdjustSource::ADJS_UNFOCUSED_WINDOW);
428 }
429 if (app->name_.empty()) {
430 app->name_ = SchedController::GetInstance().GetBundleNameByUid(uid);
431 }
432 payload["bundleName"] = app->name_;
433 ResSchedUtils::GetInstance().ReportDataInProcess(
434 ResType::RES_TYPE_WINDOW_FOCUS, ResType::WindowFocusStatus::WINDOW_UNFOCUS, payload);
435 }
436
HandleWindowVisibilityChanged(uint32_t windowId,bool isVisible,WindowType windowType,int32_t pid,int32_t uid)437 void CgroupEventHandler::HandleWindowVisibilityChanged(
438 uint32_t windowId, bool isVisible, WindowType windowType, int32_t pid, int32_t uid)
439 {
440 if (!supervisor_) {
441 CGS_LOGE("%{public}s : supervisor nullptr!", __func__);
442 return;
443 }
444 CGS_LOGD("%{public}s : %{public}d, %{public}d, %{public}d, %{public}d, %{public}d", __func__, windowId,
445 isVisible, (int32_t)windowType, pid, uid);
446
447 std::shared_ptr<Application> app = nullptr;
448 std::shared_ptr<ProcessRecord> procRecord = nullptr;
449 if (isVisible) {
450 app = supervisor_->GetAppRecordNonNull(uid);
451 procRecord = app->GetProcessRecordNonNull(pid);
452 } else {
453 app = supervisor_->GetAppRecord(uid);
454 if (app) {
455 procRecord = app->GetProcessRecord(pid);
456 }
457 }
458 if (!procRecord) {
459 return;
460 }
461 auto windowInfo = procRecord->GetWindowInfoNonNull(windowId);
462 windowInfo->isVisible_ = isVisible;
463 windowInfo->windowType_ = (int32_t)windowType;
464
465 CgroupAdjuster::GetInstance().AdjustProcessGroup(*(app.get()), *(procRecord.get()),
466 AdjustSource::ADJS_WINDOW_VISIBILITY_CHANGED);
467 }
468
HandleReportMMIProcess(uint32_t resType,int64_t value,const nlohmann::json & payload)469 void CgroupEventHandler::HandleReportMMIProcess(uint32_t resType, int64_t value, const nlohmann::json& payload)
470 {
471 int32_t uid = 0;
472 int32_t pid = 0;
473 int32_t mmi_service;
474
475 if (!supervisor_) {
476 CGS_LOGE("%{public}s : supervisor nullptr!", __func__);
477 return;
478 }
479
480 if (!ParsePayload(uid, pid, mmi_service, value, payload)) {
481 return;
482 }
483
484 CGS_LOGD("%{public}s : %{public}u, %{public}d, %{public}d, %{public}d",
485 __func__, resType, uid, pid, mmi_service);
486 if (uid <= 0 || pid <= 0 || mmi_service <= 0) {
487 return;
488 }
489
490 auto app = supervisor_->GetAppRecordNonNull(uid);
491 app->name_ = MMI_SERVICE_NAME;
492 auto procRecord = app->GetProcessRecordNonNull(mmi_service);
493 CgroupAdjuster::GetInstance().AdjustProcessGroup(*(app.get()), *(procRecord.get()),
494 AdjustSource::ADJS_REPORT_MMI_SERVICE_THREAD);
495 }
496
HandleReportRenderThread(uint32_t resType,int64_t value,const nlohmann::json & payload)497 void CgroupEventHandler::HandleReportRenderThread(uint32_t resType, int64_t value, const nlohmann::json& payload)
498 {
499 int32_t uid = 0;
500 int32_t pid = 0;
501 int32_t render = 0;
502
503 if (!supervisor_) {
504 CGS_LOGE("%{public}s : supervisor nullptr!", __func__);
505 return;
506 }
507
508 if (!ParsePayload(uid, pid, render, value, payload)) {
509 return;
510 }
511
512 CGS_LOGD("%{public}s : %{public}u, %{public}d, %{public}d, %{public}d",
513 __func__, resType, uid, pid, render);
514 if (uid <= 0 || pid <= 0 || render <= 0) {
515 return;
516 }
517
518 auto app = supervisor_->GetAppRecordNonNull(uid);
519 auto procRecord = app->GetProcessRecordNonNull(pid);
520 procRecord->renderTid_ = render;
521 CgroupAdjuster::GetInstance().AdjustProcessGroup(*(app.get()), *(procRecord.get()),
522 AdjustSource::ADJS_REPORT_RENDER_THREAD);
523 }
524
ParsePayload(int32_t & uid,int32_t & pid,int32_t & tid,int64_t value,const nlohmann::json & payload)525 bool CgroupEventHandler::ParsePayload(int32_t& uid, int32_t& pid, int32_t& tid,
526 int64_t value, const nlohmann::json& payload)
527 {
528 if (payload.contains("uid") && payload.at("uid").is_string()) {
529 uid = atoi(payload["uid"].get<std::string>().c_str());
530 }
531
532 if (payload.contains("pid") && payload.at("pid").is_string()) {
533 pid = atoi(payload["pid"].get<std::string>().c_str());
534 }
535 tid = static_cast<int32_t>(value);
536 return true;
537 }
538 } // namespace ResourceSchedule
539 } // namespace OHOS
540