diff --git a/README_zh.md b/README_zh.md index cacf33e..d7b3a71 100644 --- a/README_zh.md +++ b/README_zh.md @@ -1,18 +1,19 @@ # 内存管理部件 - [内存管理部件](#内存管理部件) - - [简介](#简介) - - [目录](#目录) - - [框架](#框架) - - [进程回收优先级列表](#进程回收优先级列表) - - [回收策略/查杀策略](#回收策略查杀策略) - - [使用说明](#使用说明) - - [参数配置说明](#参数配置说明) + - [简介](#简介) + - [目录](#目录) + - [框架](#框架) + - [进程回收优先级列表](#进程回收优先级列表) + - [补充](#补充) + - [回收策略/查杀策略](#回收策略查杀策略) + - [使用说明](#使用说明) + - [参数配置说明](#参数配置说明) - [availbufferSize](#availbuffersize) - [ZswapdParam](#zswapdparam) - [killConfig](#killconfig) - [nandlife](#nandlife) - - [相关仓](#相关仓) + - [相关仓](#相关仓) ## 简介 @@ -82,6 +83,9 @@ | 260 | 连接着分布式设备的后台应用 | | 400 | 普通后台应用及无被任何进程关联的extension进程 | +#### 补充 +1. extension进程的优先级根据其关联进程组进行更新，其值在关联进程组最小优先级基础上增加100 + ### 回收策略/查杀策略 diff --git a/services/memmgrservice/include/reclaim_priority_manager/process_priority_info.h b/services/memmgrservice/include/reclaim_priority_manager/process_priority_info.h index 6b146e4..b03066d 100644 --- a/services/memmgrservice/include/reclaim_priority_manager/process_priority_info.h +++ b/services/memmgrservice/include/reclaim_priority_manager/process_priority_info.h @@ -39,15 +39,24 @@ public: bool isSuspendDelay; bool isEventStart; bool isDistDeviceConnected; + bool isExtension; int extensionBindStatus; // 0: unkown, 1:fg bind, 2:bg bind, 3:no bind std::set extensionConnectors; // contains all pid of connectors + std::set extensionProcessUids_; + std::set extensionConnectorUids_; void SetPriority(int targetPriority); int32_t ExtensionConnectorsCount(); void AddExtensionConnector(int32_t pid); void RemoveExtensionConnector(int32_t pid); + void AddExtensionProcessUid(int32_t uid); + void RemoveExtensionProcessUid(int32_t uid); + void AddExtensionConnectorUid(int32_t uid); + void RemoveExtensionConnectorUid(int32_t uid); bool ContainsConnector(int32_t pid); std::string ConnectorsToString(); + std::string ExtensionProcessUidToString(); + std::string ExtensionConnectorsUidToString(); }; } // namespace Memory } // namespace OHOS diff --git a/services/memmgrservice/include/reclaim_priority_manager/reclaim_priority_constants.h b/services/memmgrservice/include/reclaim_priority_manager/reclaim_priority_constants.h index 50f5840..945ec07 100644 --- a/services/memmgrservice/include/reclaim_priority_manager/reclaim_priority_constants.h +++ b/services/memmgrservice/include/reclaim_priority_manager/reclaim_priority_constants.h @@ -75,6 +75,7 @@ enum class AppStateUpdateReason { DIST_DEVICE_DISCONNECTED, BIND_EXTENSION, UNBIND_EXTENSION, + UPDATE_EXTENSION_PROCESS, }; enum class BundleState { diff --git a/services/memmgrservice/include/reclaim_priority_manager/reclaim_priority_manager.h b/services/memmgrservice/include/reclaim_priority_manager/reclaim_priority_manager.h index c3c5fea..64cf67f 100644 --- a/services/memmgrservice/include/reclaim_priority_manager/reclaim_priority_manager.h +++ b/services/memmgrservice/include/reclaim_priority_manager/reclaim_priority_manager.h @@ -157,6 +157,17 @@ private: bool IsKillableSystemApp(std::shared_ptr bundle); void NotifyKillableSystemAppsAdded(std::set &newKillableApps); bool IsImportantApp(std::shared_ptr bundle, int &dstPriority); + bool UpdateProcessForExtension(int32_t callerPid, int32_t callerUid, + const std::string &callerBundleName, pid_t pid, int bundleUid, const std::string &bundleName, + AppStateUpdateReason priorityReason); + bool UpdateConnectorsForExtension(int32_t callerPid, int32_t callerUid, + const std::string &callerBundleName, pid_t pid, int bundleUid, const std::string &bundleName, + AppStateUpdateReason priorityReason); + void UpdatePriorityByProcForExtension(ProcessPriorityInfo &proc); + void UpdatePriorityByProcConnector(ProcessPriorityInfo &proc); + bool UpdateReclaimPriorityByUid(int bundleUid, AppStateUpdateReason reason); + bool UpdateReclaimPriorityByUidInner(int bundleUid, AppStateUpdateReason reason); + bool HandleUpdateExtensionBundle(int bundleUid); static inline int GetOsAccountLocalIdFromUid(int bundleUid) { diff --git a/services/memmgrservice/src/reclaim_priority_manager/account_bundle_info.cpp b/services/memmgrservice/src/reclaim_priority_manager/account_bundle_info.cpp index 862f1ee..6ab72f4 100644 --- a/services/memmgrservice/src/reclaim_priority_manager/account_bundle_info.cpp +++ b/services/memmgrservice/src/reclaim_priority_manager/account_bundle_info.cpp @@ -36,7 +36,12 @@ bool AccountBundleInfo::HasBundle(int bundleUid) std::shared_ptr AccountBundleInfo::FindBundleById(int bundleUid) { - return bundleIdInfoMapping_.at(bundleUid); + auto iter = bundleIdInfoMapping_.find(bundleUid); + if (iter != bundleIdInfoMapping_.end()) { + return iter->second; + } + HILOGD("not found the bundle info"); + return nullptr; } void AccountBundleInfo::AddBundleToOsAccount(std::shared_ptr bundle) diff --git a/services/memmgrservice/src/reclaim_priority_manager/process_priority_info.cpp b/services/memmgrservice/src/reclaim_priority_manager/process_priority_info.cpp index b2837ce..4f44c76 100644 --- a/services/memmgrservice/src/reclaim_priority_manager/process_priority_info.cpp +++ b/services/memmgrservice/src/reclaim_priority_manager/process_priority_info.cpp @@ -35,6 +35,7 @@ ProcessPriorityInfo::ProcessPriorityInfo(pid_t pid, int bundleUid, int priority) this->isSuspendDelay = false; this->isEventStart = false; this->isDistDeviceConnected = false; + this->isExtension = false; this->extensionBindStatus = EXTENSION_STATUS_BIND_UNKOWN; } @@ -44,6 +45,7 @@ ProcessPriorityInfo::ProcessPriorityInfo(const ProcessPriorityInfo ©Process) this->pid_ = copyProcess.pid_; this->priority_ = copyProcess.priority_; this->isFreground = copyProcess.isFreground; + this->isExtension = copyProcess.isExtension; this->isBackgroundRunning = copyProcess.isBackgroundRunning; this->isSuspendDelay = copyProcess.isSuspendDelay; this->isEventStart = copyProcess.isEventStart; @@ -52,11 +54,19 @@ ProcessPriorityInfo::ProcessPriorityInfo(const ProcessPriorityInfo ©Process) for (auto connectors : copyProcess.extensionConnectors) { this->AddExtensionConnector(connectors); } + for (auto callerUid : copyProcess.extensionProcessUids_) { + this->AddExtensionProcessUid(callerUid); + } + for (auto connectorUid : copyProcess.extensionConnectorUids_) { + this->AddExtensionConnectorUid(connectorUid); + } } ProcessPriorityInfo::~ProcessPriorityInfo() { extensionConnectors.clear(); + extensionProcessUids_.clear(); + extensionConnectorUids_.clear(); } void ProcessPriorityInfo::SetPriority(int targetPriority) @@ -80,6 +90,26 @@ void ProcessPriorityInfo::RemoveExtensionConnector(int32_t pid) extensionConnectors.erase(pid); } +void ProcessPriorityInfo::AddExtensionProcessUid(int32_t uid) +{ + extensionProcessUids_.insert(uid); +} + +void ProcessPriorityInfo::RemoveExtensionProcessUid(int32_t uid) +{ + extensionProcessUids_.erase(uid); +} + +void ProcessPriorityInfo::AddExtensionConnectorUid(int32_t uid) +{ + extensionConnectorUids_.insert(uid); +} + +void ProcessPriorityInfo::RemoveExtensionConnectorUid(int32_t uid) +{ + extensionConnectorUids_.erase(uid); +} + bool ProcessPriorityInfo::ContainsConnector(int32_t pid) { return extensionConnectors.count(pid) != 0; @@ -95,5 +125,27 @@ std::string ProcessPriorityInfo::ConnectorsToString() ss << "]"; return ss.str(); } + +std::string ProcessPriorityInfo::ExtensionProcessUidToString() +{ + std::stringstream ss; + ss << "["; + for (auto callerUid : extensionProcessUids_) { + ss << callerUid << " "; + } + ss << "]"; + return ss.str(); +} + +std::string ProcessPriorityInfo::ExtensionConnectorsUidToString() +{ + std::stringstream ss; + ss << "["; + for (auto connectorUid : extensionConnectorUids_) { + ss << connectorUid << " "; + } + ss << "]"; + return ss.str(); +} } // namespace Memory } // namespace OHOS diff --git a/services/memmgrservice/src/reclaim_priority_manager/reclaim_priority_manager.cpp b/services/memmgrservice/src/reclaim_priority_manager/reclaim_priority_manager.cpp index 27b54e6..260fbe7 100644 --- a/services/memmgrservice/src/reclaim_priority_manager/reclaim_priority_manager.cpp +++ b/services/memmgrservice/src/reclaim_priority_manager/reclaim_priority_manager.cpp @@ -105,16 +105,17 @@ void ReclaimPriorityManager::Dump(int fd) } dprintf(fd, "-----------------------------------------------------------------\n\n"); - dprintf(fd, "priority list of all managed processes, status:(fg,bgtask,trantask,evt,dist,ext)\n"); + dprintf(fd, "priority list of all managed processes, status:(fg,bgtask,trantask,evt,dist,extb,ext)\n"); dprintf(fd, " pid uid bundle priority status\ - connnectors\n"); + connnectorpids connnectoruids processuids\n"); for (auto bundlePtr : totalBundlePrioSet_) { dprintf(fd, "|-----------------------------------------\n"); for (auto procEntry : bundlePtr->procs_) { ProcessPriorityInfo &proc = procEntry.second; - dprintf(fd, "|%8d %8d %42s %5d %d%d%d%d%d%d %30s\n", proc.pid_, bundlePtr->uid_, bundlePtr->name_.c_str(), + dprintf(fd, "|%8d %8d %42s %5d %d%d%d%d%d%d%d %30s %30s %30s\n", proc.pid_, bundlePtr->uid_, bundlePtr->name_.c_str(), proc.priority_, proc.isFreground, proc.isBackgroundRunning, proc.isSuspendDelay, proc.isEventStart, - proc.isDistDeviceConnected, proc.extensionBindStatus, proc.ConnectorsToString().c_str()); + proc.isDistDeviceConnected, proc.extensionBindStatus, proc.isExtension, proc.ConnectorsToString().c_str(), + proc.ExtensionConnectorsUidToString().c_str(), proc.ExtensionProcessUidToString().c_str()); } } dprintf(fd, "-----------------------------------------------------------------\n"); @@ -423,6 +424,17 @@ bool ReclaimPriorityManager::UpdateReclaimPriorityWithCaller(int32_t callerPid, return handler_->PostImmediateTask(updateReclaimPriorityCallerInnerFunc); } +bool ReclaimPriorityManager::UpdateReclaimPriorityByUid(int bundleUid, AppStateUpdateReason reason) +{ + if (!initialized_) { + HILOGE("has not been initialized_, skiped!"); + return false; + } + std::function updateReclaimPriorityByUidInnerFunc = + std::bind(&ReclaimPriorityManager::UpdateReclaimPriorityByUidInner, this, bundleUid, reason); + return handler_->PostImmediateTask(updateReclaimPriorityByUidInnerFunc); +} + sptr GetBundleMgr() { sptr saMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); @@ -562,7 +574,7 @@ bool ReclaimPriorityManager::HandleApplicationSuspend(std::shared_ptrpriority_ <= RECLAIM_PRIORITY_KILLABLE_SYSTEM || IsKillableSystemApp(bundle)) { - HILOGI("%{public}s is system app, skip!", bundleName.c_str()); + HILOGD("%{public}s is system app, skip!", bundleName.c_str()); return true; } if (priorityReason == AppStateUpdateReason::BIND_EXTENSION) { proc.isFreground = false; // current process is a extension, it never be a fg app. + proc.isExtension = true; proc.AddExtensionConnector(callerPid); - HILOGI("add connector %{public}d to %{public}s(%{public}d,%{public}d), now connectors:%{public}s", callerPid, + proc.AddExtensionConnectorUid(callerUid); + HILOGD("add connector %{public}d to %{public}s(%{public}d,%{public}d), now connectors:%{public}s", callerPid, bundleName.c_str(), pid, bundleUid, proc.ConnectorsToString().c_str()); } else if (priorityReason == AppStateUpdateReason::UNBIND_EXTENSION) { proc.isFreground = false; // current process is a extension, it never be a fg app. + proc.isExtension = true; proc.RemoveExtensionConnector(callerPid); - HILOGI("del connector %{public}d from %{public}s(%{public}d,%{public}d), now connectors:%{public}s", callerPid, + proc.RemoveExtensionConnectorUid(callerUid); + HILOGD("del connector %{public}d from %{public}s(%{public}d,%{public}d), now connectors:%{public}s", callerPid, bundleName.c_str(), pid, bundleUid, proc.ConnectorsToString().c_str()); } AppAction action = AppAction::OTHERS; @@ -597,6 +613,66 @@ bool ReclaimPriorityManager::UpdateReclaimPriorityWithCallerInner(int32_t caller return ApplyReclaimPriority(bundle, pid, action); } +bool ReclaimPriorityManager::UpdateProcessForExtension(int32_t callerPid, int32_t callerUid, + const std::string &callerBundleName, pid_t pid, int bundleUid, const std::string &bundleName, + AppStateUpdateReason priorityReason) +{ + int callerAccountId = GetOsAccountLocalIdFromUid(callerUid); + if (!IsProcExist(callerPid, callerUid, callerAccountId)) { + HILOGE("caller process not exist and not to create it!!"); + return false; + } + std::shared_ptr callerAccount = FindOsAccountById(callerAccountId); + std::shared_ptr callerBundle = callerAccount->FindBundleById(callerUid); + ProcessPriorityInfo &callerProc = callerBundle->FindProcByPid(callerPid); + + if (priorityReason == AppStateUpdateReason::BIND_EXTENSION) { + callerProc.AddExtensionProcessUid(bundleUid); + HILOGD("add caller %{public}d to %{public}s(%{public}d,%{public}d), now calling:%{public}s", callerPid, + bundleName.c_str(), pid, bundleUid, callerProc.ExtensionProcessUidToString().c_str()); + } else if (priorityReason == AppStateUpdateReason::UNBIND_EXTENSION) { + callerProc.RemoveExtensionProcessUid(bundleUid); + HILOGD("del caller %{public}d from %{public}s(%{public}d,%{public}d), now calling:%{public}s ", callerPid, + bundleName.c_str(), pid, bundleUid, callerProc.ExtensionProcessUidToString().c_str()); + } + return true; +} + +bool ReclaimPriorityManager::UpdateReclaimPriorityByUidInner(int bundleUid, AppStateUpdateReason reason) +{ + bool ret = false; + if (reason == AppStateUpdateReason::UPDATE_EXTENSION_PROCESS) { + HILOGD("call HandleCreateProcess"); + ret = HandleUpdateExtensionBundle(bundleUid); + } + return ret; +} + +bool ReclaimPriorityManager::HandleUpdateExtensionBundle(int bundleUid) +{ + int accountId = GetOsAccountLocalIdFromUid(bundleUid); + std::shared_ptr accountPtr = FindOsAccountById(accountId); + if (accountPtr == nullptr || !accountPtr->HasBundle(bundleUid)) { + return false; + } + std::shared_ptr bundlePtr = accountPtr->FindBundleById(bundleUid); + for (auto i = bundlePtr->procs_.begin(); i != bundlePtr->procs_.end(); ++i) { + UpdatePriorityByProcConnector(i->second); + } + UpdateBundlePriority(bundlePtr); + return true; +} + +bool ReclaimPriorityManager::UpdateReclaimPriorityWithCallerInner(int32_t callerPid, int32_t callerUid, + const std::string &callerBundleName, pid_t pid, int bundleUid, const std::string &bundleName, + AppStateUpdateReason priorityReason) +{ + UpdateProcessForExtension(callerPid, callerUid, + callerBundleName, pid, bundleUid, bundleName, priorityReason); + return UpdateConnectorsForExtension(callerPid, callerUid, + callerBundleName, pid, bundleUid, bundleName, priorityReason); +} + bool ReclaimPriorityManager::UpdateReclaimPriorityInner(pid_t pid, int bundleUid, const std::string &bundleName, AppStateUpdateReason reason) { @@ -655,6 +731,35 @@ bool ReclaimPriorityManager::IsImportantApp(std::shared_ptr return false; } +void ReclaimPriorityManager::UpdatePriorityByProcForExtension(ProcessPriorityInfo &proc) +{ + for (auto callerUid : proc.extensionProcessUids_) { + UpdateReclaimPriorityByUid(callerUid, AppStateUpdateReason::UPDATE_EXTENSION_PROCESS); + } +} + +void ReclaimPriorityManager::UpdatePriorityByProcConnector(ProcessPriorityInfo &proc) +{ + if (proc.extensionConnectorUids_.size() == 0) { + return; + } + int minPriority = RECLAIM_PRIORITY_UNKNOWN; + for (auto connectorUid : proc.extensionConnectorUids_) { + int connectorAccountId = GetOsAccountLocalIdFromUid(connectorUid); + std::shared_ptr connectorAccount = FindOsAccountById(connectorAccountId); + if (connectorAccount == nullptr || !connectorAccount->HasBundle(connectorUid)) { + minPriority = 0; // native + continue; + } + std::shared_ptr connectorBundle = connectorAccount->FindBundleById(connectorUid); + for (auto procEntry : connectorBundle->procs_) { + ProcessPriorityInfo &connectorProc = procEntry.second; + minPriority = connectorProc.priority_ < minPriority ? connectorProc.priority_ : minPriority; + } + } + proc.SetPriority(minPriority + 100); +} + void ReclaimPriorityManager::UpdatePriorityByProcStatus(std::shared_ptr bundle, ProcessPriorityInfo &proc) { @@ -669,6 +774,7 @@ void ReclaimPriorityManager::UpdatePriorityByProcStatus(std::shared_ptr RECLAIM_PRIORITY_FOREGROUND) { proc.SetPriority(RECLAIM_PRIORITY_FOREGROUND); } + UpdatePriorityByProcForExtension(proc); } else { // is a background process int bgPriority = RECLAIM_PRIORITY_BACKGROUND; if(IsImportantApp(bundle, bgPriority)) { @@ -679,6 +785,7 @@ void ReclaimPriorityManager::UpdatePriorityByProcStatus(std::shared_ptr%{public}d",