add extension priority degradation mechanism

category:bugfix

Signed-off-by: wonghiu45 <huangxiao35@huawei.com>
Change-Id: I62577eea7216bd76013cceb2e818444e6d422257

README_zh.md

@@ -1,18 +1,19 @@
 # 内存管理部件
 
 - [内存管理部件](#内存管理部件)
-	- [简介<a name="section_introduction"></a>](#简介)
-	- [目录<a name="section_catalogue"></a>](#目录)
-	- [框架<a name="section_framework"></a>](#框架)
-		- [进程回收优先级列表<a name="section_prio"></a>](#进程回收优先级列表)
-		- [回收策略/查杀策略<a name="section_reclaim"></a>](#回收策略查杀策略)
-	- [使用说明<a name="section_usage"></a>](#使用说明)
-	- [参数配置说明<a name="section_usage"></a>](#参数配置说明)
+	- [简介](#简介)
+	- [目录](#目录)
+	- [框架](#框架)
+		- [进程回收优先级列表](#进程回收优先级列表)
+			- [补充](#补充)
+		- [回收策略/查杀策略](#回收策略查杀策略)
+	- [使用说明](#使用说明)
+	- [参数配置说明](#参数配置说明)
 		- [availbufferSize](#availbuffersize)
 		- [ZswapdParam](#zswapdparam)
 		- [killConfig](#killconfig)
 		- [nandlife](#nandlife)
-	- [相关仓<a name="section_projects"></a>](#相关仓)
+	- [相关仓](#相关仓)
 
 ## 简介<a name="section_introduction"></a>
 
@@ -82,6 +83,9 @@
 | 260 | 连接着分布式设备的后台应用 |
 | 400 | 普通后台应用及无被任何进程关联的extension进程 |
 
+#### 补充
+1. extension进程的优先级根据其关联进程组进行更新，其值在关联进程组最小优先级基础上增加100
+
 
 ### 回收策略/查杀策略<a name="section_reclaim"></a>
 

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<int32_t> extensionConnectors; // contains all pid of connectors
+    std::set<int32_t> extensionProcessUids_;
+    std::set<int32_t> 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

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 {

services/memmgrservice/include/reclaim_priority_manager/reclaim_priority_manager.h

@@ -157,6 +157,17 @@ private:
     bool IsKillableSystemApp(std::shared_ptr<BundlePriorityInfo> bundle);
     void NotifyKillableSystemAppsAdded(std::set<std::string> &newKillableApps);
     bool IsImportantApp(std::shared_ptr<BundlePriorityInfo> 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)
     {

services/memmgrservice/src/reclaim_priority_manager/account_bundle_info.cpp

@@ -36,7 +36,12 @@ bool AccountBundleInfo::HasBundle(int bundleUid)
 
 std::shared_ptr<BundlePriorityInfo> 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<BundlePriorityInfo> bundle)

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 &copyProcess)
     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 &copyProcess)
     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

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<bool()> updateReclaimPriorityByUidInnerFunc =
+        std::bind(&ReclaimPriorityManager::UpdateReclaimPriorityByUidInner, this, bundleUid, reason);
+    return handler_->PostImmediateTask(updateReclaimPriorityByUidInnerFunc);
+}
+
 sptr<AppExecFwk::IBundleMgr> GetBundleMgr()
 {
     sptr<ISystemAbilityManager> saMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
@@ -562,7 +574,7 @@ bool ReclaimPriorityManager::HandleApplicationSuspend(std::shared_ptr<BundlePrio
     return ret;
 }
 
-bool ReclaimPriorityManager::UpdateReclaimPriorityWithCallerInner(int32_t callerPid, int32_t callerUid,
+bool ReclaimPriorityManager::UpdateConnectorsForExtension(int32_t callerPid, int32_t callerUid,
     const std::string &callerBundleName, pid_t pid, int bundleUid, const std::string &bundleName,
     AppStateUpdateReason priorityReason)
 {
@@ -577,19 +589,23 @@ bool ReclaimPriorityManager::UpdateReclaimPriorityWithCallerInner(int32_t caller
 
     if (proc.priority_ <= RECLAIM_PRIORITY_KILLABLE_SYSTEM || bundle->priority_ <= 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<AccountBundleInfo> callerAccount = FindOsAccountById(callerAccountId);
+    std::shared_ptr<BundlePriorityInfo> 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<AccountBundleInfo> accountPtr = FindOsAccountById(accountId);
+    if (accountPtr == nullptr || !accountPtr->HasBundle(bundleUid)) {
+        return false;
+    }   
+    std::shared_ptr<BundlePriorityInfo> 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<BundlePriorityInfo>
     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<AccountBundleInfo> connectorAccount = FindOsAccountById(connectorAccountId);
+        if (connectorAccount == nullptr || !connectorAccount->HasBundle(connectorUid)) {
+            minPriority = 0; // native
+            continue;
+        }   
+        std::shared_ptr<BundlePriorityInfo> 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<BundlePriorityInfo> bundle,
                                                         ProcessPriorityInfo &proc)
 {
@@ -669,6 +774,7 @@ void ReclaimPriorityManager::UpdatePriorityByProcStatus(std::shared_ptr<BundlePr
         if (proc.priority_ > 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<BundlePr
                     proc.pid_, bgPriority);        
         }
         proc.SetPriority(bgPriority);
+        UpdatePriorityByProcForExtension(proc);
     }
     if (proc.isSuspendDelay) { // is a background process with transient task
         HILOGD("%{public}d is a background process with transient task", proc.pid_);
@@ -714,6 +821,9 @@ void ReclaimPriorityManager::UpdatePriorityByProcStatus(std::shared_ptr<BundlePr
     } else {
         // is a plain background process
     }
+    if (proc.isExtension) {
+        UpdatePriorityByProcConnector(proc);
+    }
     HILOGI(": bundle[uid_=%{public}d,name=%{public}s,priority=%{public}d], proc[pid_=%{public}d, uid=%{public}d, "
         "isFreground=%{public}d, isBackgroundRunning=%{public}d, isSuspendDelay=%{public}d, isEventStart=%{public}d, "
         "isDistDeviceConnected=%{public}d, extensionBindStatus=%{public}d], priority:%{public}d-->%{public}d",