• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021-2023 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 #ifndef SERVICES_SAMGR_NATIVE_INCLUDE_SYSTEM_ABILITY_MANAGER_H
17 #define SERVICES_SAMGR_NATIVE_INCLUDE_SYSTEM_ABILITY_MANAGER_H
18 
19 #include <map>
20 #include <mutex>
21 #include <set>
22 #include <shared_mutex>
23 #include <string>
24 #include <utility>
25 
26 #include "dbinder_service.h"
27 #include "dbinder_service_stub.h"
28 #include "device_status_collect_manager.h"
29 #include "dynamic_cache.h"
30 #include "ffrt_handler.h"
31 #include "rpc_callback_imp.h"
32 #include "thread_pool.h"
33 #include "timer.h"
34 #include "sa_profiles.h"
35 #include "system_ability_manager_stub.h"
36 #include "schedule/system_ability_state_scheduler.h"
37 
38 namespace OHOS {
39 struct SAInfo {
40     sptr<IRemoteObject> remoteObj;
41     bool isDistributed = false;
42     std::u16string capability;
43     std::string permission;
44 };
45 
46 enum {
47     UUID = 0,
48     NODE_ID,
49     UNKNOWN,
50 };
51 
52 enum ListenerState {
53     INIT = 0,
54     NOTIFIED,
55 };
56 
57 struct SAListener {
58     sptr<ISystemAbilityStatusChange> listener;
59     int32_t callingPid;
60     ListenerState state = ListenerState::INIT;
61     SAListener(sptr<ISystemAbilityStatusChange> lst, int32_t cpid, ListenerState sta = ListenerState::INIT)
listenerSAListener62         :listener(lst), callingPid(cpid), state(sta) {}
63 };
64 
65 class SystemAbilityManager : public DynamicCache, public SystemAbilityManagerStub {
66 public:
~SystemAbilityManager()67     virtual ~SystemAbilityManager()
68     {
69         if (reportEventTimer_ != nullptr) {
70             reportEventTimer_->Shutdown();
71         }
72     }
GetInstance()73     static sptr<SystemAbilityManager> GetInstance()
74     {
75         std::lock_guard<std::mutex> autoLock(instanceLock);
76         if (instance == nullptr) {
77             instance = new SystemAbilityManager;
78         }
79         return instance;
80     }
81 
82     int32_t RemoveSystemAbility(const sptr<IRemoteObject>& ability);
83     std::vector<std::u16string> ListSystemAbilities(uint32_t dumpFlags) override;
84 
SetDeviceName(const std::u16string & name)85     void SetDeviceName(const std::u16string &name)
86     {
87         deviceName_ = name;
88     }
89 
GetDeviceName()90     const std::u16string& GetDeviceName() const
91     {
92         return deviceName_;
93     }
94 
GetDBinder()95     const sptr<DBinderService> GetDBinder() const
96     {
97         return dBinderService_;
98     }
99 
100     sptr<IRemoteObject> GetSystemAbility(int32_t systemAbilityId) override;
101 
102     sptr<IRemoteObject> CheckSystemAbility(int32_t systemAbilityId) override;
103 
104     int32_t RemoveSystemAbility(int32_t systemAbilityId) override;
105 
106     int32_t SubscribeSystemAbility(int32_t systemAbilityId, const sptr<ISystemAbilityStatusChange>& listener) override;
107     int32_t UnSubscribeSystemAbility(int32_t systemAbilityId,
108         const sptr<ISystemAbilityStatusChange>& listener) override;
109     void UnSubscribeSystemAbility(const sptr<IRemoteObject>& remoteObject);
110 
111     sptr<IRemoteObject> GetSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override;
112 
113     sptr<IRemoteObject> CheckSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override;
114 
115     int32_t AddOnDemandSystemAbilityInfo(int32_t systemAbilityId, const std::u16string& procName) override;
116 
117     sptr<IRemoteObject> CheckSystemAbility(int32_t systemAbilityId, bool& isExist) override;
118     bool DoLoadOnDemandAbility(int32_t systemAbilityId, bool& isExist);
119 
120     int32_t RemoveDiedSystemAbility(int32_t systemAbilityId);
121 
122     void NotifyRemoteSaDied(const std::u16string& name);
123     void NotifyRemoteDeviceOffline(const std::string& deviceId);
124     int32_t AddSystemAbility(int32_t systemAbilityId, const sptr<IRemoteObject>& ability,
125         const SAExtraProp& extraProp) override;
GetLocalNodeId()126     std::string GetLocalNodeId()
127     {
128         return std::string();
129     }
130     void Init();
CleanFfrt()131     void CleanFfrt()
132     {
133         if (workHandler_ != nullptr) {
134             workHandler_->CleanFfrt();
135         }
136         if (collectManager_ != nullptr) {
137             collectManager_->CleanFfrt();
138         }
139         if (abilityStateScheduler_ != nullptr) {
140             abilityStateScheduler_->CleanFfrt();
141         }
142     }
143 
SetFfrt()144     void SetFfrt()
145     {
146         if (workHandler_ != nullptr) {
147             workHandler_->SetFfrt("workHandler");
148         }
149         if (collectManager_ != nullptr) {
150             collectManager_->SetFfrt();
151         }
152         if (abilityStateScheduler_ != nullptr) {
153             abilityStateScheduler_->SetFfrt();
154         }
155     }
156     int32_t Dump(int32_t fd, const std::vector<std::u16string>& args) override;
157     void AddSamgrToAbilityMap();
158 
159     int32_t AddSystemProcess(const std::u16string& procName, const sptr<IRemoteObject>& procObject) override;
160     int32_t RemoveSystemProcess(const sptr<IRemoteObject>& procObject);
161     int32_t GetSystemProcessInfo(int32_t systemAbilityId, SystemProcessInfo& systemProcessInfo) override;
162     int32_t GetRunningSystemProcess(std::list<SystemProcessInfo>& systemProcessInfos) override;
163     int32_t SubscribeSystemProcess(const sptr<ISystemProcessStatusChange>& listener) override;
164     int32_t UnSubscribeSystemProcess(const sptr<ISystemProcessStatusChange>& listener) override;
165     int32_t GetOnDemandReasonExtraData(int64_t extraDataId, MessageParcel& extraDataParcel) override;
166 
LoadSystemAbility(int32_t systemAbilityId,int32_t timeout)167     sptr<IRemoteObject> LoadSystemAbility(int32_t systemAbilityId, int32_t timeout) override
168     {
169         return nullptr;
170     }
171 
172     int32_t LoadSystemAbility(int32_t systemAbilityId, const sptr<ISystemAbilityLoadCallback>& callback) override;
173     int32_t DoLoadSystemAbility(int32_t systemAbilityId, const std::u16string& procName,
174         const sptr<ISystemAbilityLoadCallback>& callback, int32_t callingPid, const OnDemandEvent& event);
175     int32_t LoadSystemAbility(int32_t systemAbilityId, const std::string& deviceId,
176         const sptr<ISystemAbilityLoadCallback>& callback) override;
177     int32_t UnloadSystemAbility(int32_t systemAbilityId) override;
178     int32_t DoUnloadSystemAbility(int32_t systemAbilityId, const std::u16string& procName, const OnDemandEvent& event);
179     int32_t CancelUnloadSystemAbility(int32_t systemAbilityId) override;
180     int32_t DoUnloadSystemAbility(int32_t systemAbilityId, const std::u16string& procName);
181     int32_t UnloadAllIdleSystemAbility() override;
182     bool IdleSystemAbility(int32_t systemAbilityId, const std::u16string& procName,
183         const nlohmann::json& idleReason, int32_t& delayTime);
184     bool ActiveSystemAbility(int32_t systemAbilityId, const std::u16string& procName,
185         const nlohmann::json& activeReason);
186     void OnAbilityCallbackDied(const sptr<IRemoteObject>& remoteObject);
187     void OnRemoteCallbackDied(const sptr<IRemoteObject>& remoteObject);
188     sptr<IRemoteObject> GetSystemAbilityFromRemote(int32_t systemAbilityId);
189     bool LoadSystemAbilityFromRpc(const std::string& srcDeviceId, int32_t systemAbilityId,
190         const sptr<ISystemAbilityLoadCallback>& callback);
191     int32_t DoLoadSystemAbilityFromRpc(const std::string& srcDeviceId, int32_t systemAbilityId,
192         const std::u16string& procName, const sptr<ISystemAbilityLoadCallback>& callback, const OnDemandEvent& event);
193     void NotifyRpcLoadCompleted(const std::string& srcDeviceId, int32_t systemAbilityId,
194         const sptr<IRemoteObject>& remoteObject);
195     void StartDfxTimer();
196     void DoLoadForPerf();
197     void ProcessOnDemandEvent(const OnDemandEvent& event, const std::list<SaControlInfo>& saControlList);
198     int32_t GetOnDemandPolicy(int32_t systemAbilityId, OnDemandPolicyType type,
199         std::vector<SystemAbilityOnDemandEvent>& abilityOnDemandEvents) override;
200     int32_t UpdateOnDemandPolicy(int32_t systemAbilityId, OnDemandPolicyType type,
201         const std::vector<SystemAbilityOnDemandEvent>& abilityOnDemandEvents) override;
202     int32_t GetOnDemandSystemAbilityIds(std::vector<int32_t>& systemAbilityIds) override;
203     int32_t SendStrategy(int32_t type, std::vector<int32_t>& systemAbilityIds,
204         int32_t level, std::string& action) override;
CheckSaIsImmediatelyRecycle(int32_t systemAbilityId)205     bool CheckSaIsImmediatelyRecycle(int32_t systemAbilityId)
206     {
207         CommonSaProfile saProfile;
208         bool ret = GetSaProfile(systemAbilityId, saProfile);
209         if (!ret) {
210             HILOGE("UnloadSystemAbility SA:%{public}d not supported!", systemAbilityId);
211             return ERR_INVALID_VALUE;
212         }
213         return saProfile.recycleStrategy == IMMEDIATELY;
214     }
IsDistributedSystemAbility(int32_t systemAbilityId)215     bool IsDistributedSystemAbility(int32_t systemAbilityId)
216     {
217         CommonSaProfile saProfile;
218         bool ret = GetSaProfile(systemAbilityId, saProfile);
219         if (!ret) {
220             HILOGE("IsDistributedSa SA:%{public}d no Profile!", systemAbilityId);
221             return false;
222         }
223         return saProfile.distributed;
224     }
225     int32_t GetRunningSaExtensionInfoList(const std::string& extension,
226         std::vector<SaExtensionInfo>& infoList) override;
227     int32_t GetExtensionSaIds(const std::string& extension, std::vector<int32_t>& saIds) override;
228     int32_t GetExtensionRunningSaList(const std::string& extension, std::vector<sptr<IRemoteObject>>& saList) override;
229     int32_t GetCommonEventExtraDataIdlist(int32_t saId, std::vector<int64_t>& extraDataIdList,
230         const std::string& eventName = "") override;
231     sptr<IRemoteObject> GetSystemProcess(const std::u16string& procName);
IsModuleUpdate(int32_t systemAbilityId)232     bool IsModuleUpdate(int32_t systemAbilityId)
233     {
234         CommonSaProfile saProfile;
235         bool ret = GetSaProfile(systemAbilityId, saProfile);
236         if (!ret) {
237             HILOGE("IsModuleUpdate SA:%{public}d not exist!", systemAbilityId);
238             return false;
239         }
240         return saProfile.moduleUpdate;
241     }
RemoveWhiteCommonEvent()242     void RemoveWhiteCommonEvent()
243     {
244         if (collectManager_ != nullptr) {
245             collectManager_->RemoveWhiteCommonEvent();
246         }
247     }
248     void RemoveOnDemandSaInDiedProc(std::shared_ptr<SystemProcessContext>& processContext);
249 #ifdef SAMGR_ENABLE_DELAY_DBINDER
250     void InitDbinderService();
251 #endif
252 private:
253     enum class AbilityState {
254         INIT,
255         STARTING,
256         STARTED,
257     };
258 
259     using CallbackList = std::list<std::pair<sptr<ISystemAbilityLoadCallback>, int32_t>>;
260 
261     struct AbilityItem {
262         AbilityState state = AbilityState::INIT;
263         std::map<std::string, CallbackList> callbackMap; // key : networkid
264         OnDemandEvent event;
265     };
266 
SystemAbilityManager()267     SystemAbilityManager()
268     {
269 #ifndef SAMGR_ENABLE_DELAY_DBINDER
270         dBinderService_ = DBinderService::GetInstance();
271 #endif
272     }
273     std::string EventToJson(const OnDemandEvent& event);
274     void DoInsertSaData(const std::u16string& name, const sptr<IRemoteObject>& ability, const SAExtraProp& extraProp);
StartOnDemandAbility(int32_t systemAbilityId,bool & isExist)275     int32_t StartOnDemandAbility(int32_t systemAbilityId, bool& isExist)
276     {
277         lock_guard<mutex> onDemandAbilityLock(onDemandLock_);
278         return StartOnDemandAbilityLocked(systemAbilityId, isExist);
279     }
280     int32_t StartOnDemandAbilityLocked(int32_t systemAbilityId, bool& isExist);
281     void RefreshListenerState(int32_t systemAbilityId);
282     int32_t AddSystemAbility(const std::u16string& name, const sptr<IRemoteObject>& ability,
283         const SAExtraProp& extraProp);
284     int32_t FindSystemAbilityNotify(int32_t systemAbilityId, int32_t code);
285     int32_t FindSystemAbilityNotify(int32_t systemAbilityId, const std::string& deviceId, int32_t code);
286 
287     void InitSaProfile();
GetSaProfile(int32_t saId,CommonSaProfile & saProfile)288     bool GetSaProfile(int32_t saId, CommonSaProfile& saProfile)
289     {
290         lock_guard<mutex> autoLock(saProfileMapLock_);
291         auto iter = saProfileMap_.find(saId);
292         if (iter == saProfileMap_.end()) {
293             return false;
294         } else {
295             saProfile = iter->second;
296         }
297         return true;
298     }
299     void CheckListenerNotify(int32_t systemAbilityId, const sptr<ISystemAbilityStatusChange>& listener);
300     void NotifySystemAbilityChanged(int32_t systemAbilityId, const std::string& deviceId, int32_t code,
301         const sptr<ISystemAbilityStatusChange>& listener);
302     void NotifySystemAbilityAddedByAsync(int32_t systemAbilityId, const sptr<ISystemAbilityStatusChange>& listener);
303     void UnSubscribeSystemAbilityLocked(std::list<SAListener>& listenerList,
304         const sptr<IRemoteObject>& listener);
305 
306     void SendSystemAbilityAddedMsg(int32_t systemAbilityId, const sptr<IRemoteObject>& remoteObject);
307     void SendSystemAbilityRemovedMsg(int32_t systemAbilityId);
308 
309     void NotifySystemAbilityLoaded(int32_t systemAbilityId, const sptr<IRemoteObject>& remoteObject);
310     void NotifySystemAbilityLoaded(int32_t systemAbilityId, const sptr<IRemoteObject>& remoteObject,
311         const sptr<ISystemAbilityLoadCallback>& callback);
312     void NotifySystemAbilityLoadFail(int32_t systemAbilityId, const sptr<ISystemAbilityLoadCallback>& callback);
313     int32_t StartingSystemProcess(const std::u16string& name, int32_t systemAbilityId, const OnDemandEvent& event);
314     int32_t StartingSystemProcessLocked(const std::u16string& name, int32_t systemAbilityId,
315         const OnDemandEvent& event);
StartOnDemandAbility(const std::u16string & name,int32_t systemAbilityId)316     void StartOnDemandAbility(const std::u16string& name, int32_t systemAbilityId)
317     {
318         lock_guard<mutex> autoLock(onDemandLock_);
319         StartOnDemandAbilityLocked(name, systemAbilityId);
320     }
321     void StartOnDemandAbilityLocked(const std::u16string& name, int32_t systemAbilityId);
322     int32_t StartOnDemandAbilityInner(const std::u16string& name, int32_t systemAbilityId, AbilityItem& abilityItem);
323     bool IsInitBootFinished();
324     int32_t StartDynamicSystemProcess(const std::u16string& name, int32_t systemAbilityId, const OnDemandEvent& event);
StopOnDemandAbility(const std::u16string & name,int32_t systemAbilityId,const OnDemandEvent & event)325     bool StopOnDemandAbility(const std::u16string& name, int32_t systemAbilityId, const OnDemandEvent& event)
326     {
327         lock_guard<mutex> autoLock(onDemandLock_);
328         return StopOnDemandAbilityInner(name, systemAbilityId, event);
329     }
330     bool StopOnDemandAbilityInner(const std::u16string& name, int32_t systemAbilityId, const OnDemandEvent& event);
331     void RemoveStartingAbilityCallback(CallbackList& callbackList, const sptr<IRemoteObject>& remoteObject);
332     void RemoveStartingAbilityCallbackForDevice(AbilityItem& abilityItem, const sptr<IRemoteObject>& remoteObject);
333     void RemoveStartingAbilityCallbackLocked(std::pair<sptr<ISystemAbilityLoadCallback>, int32_t>& itemPair);
IsCacheCommonEvent(int32_t systemAbilityId)334     bool IsCacheCommonEvent(int32_t systemAbilityId)
335     {
336         CommonSaProfile saProfile;
337         if (!GetSaProfile(systemAbilityId, saProfile)) {
338             HILOGD("SA:%{public}d no profile!", systemAbilityId);
339             return false;
340         }
341         return saProfile.cacheCommonEvent;
342     }
343     void SendCheckLoadedMsg(int32_t systemAbilityId, const std::u16string& name, const std::string& srcDeviceId,
344         const sptr<ISystemAbilityLoadCallback>& callback);
345     void RemoveCheckLoadedMsg(int32_t systemAbilityId);
346     void SendLoadedSystemAbilityMsg(int32_t systemAbilityId, const sptr<IRemoteObject>& remoteObject,
347         const sptr<ISystemAbilityLoadCallback>& callback);
348     void DoLoadRemoteSystemAbility(int32_t systemAbilityId, int32_t callingPid,
349         int32_t callingUid, const std::string& deviceId, const sptr<ISystemAbilityLoadCallback>& callback);
350     sptr<DBinderServiceStub> DoMakeRemoteBinder(int32_t systemAbilityId, int32_t callingPid, int32_t callingUid,
351         const std::string& deviceId);
352     void RemoveRemoteCallbackLocked(std::list<sptr<ISystemAbilityLoadCallback>>& callbacks,
353         const sptr<IRemoteObject>& remoteObject);
354     void CleanCallbackForLoadFailed(int32_t systemAbilityId, const std::u16string& name,
355         const std::string& srcDeviceId, const sptr<ISystemAbilityLoadCallback>& callback);
356     int32_t UpdateSaFreMap(int32_t uid, int32_t saId);
357     void ReportGetSAPeriodically();
358     void OndemandLoad();
359     void OndemandLoadForPerf();
360     std::list<int32_t> GetAllOndemandSa();
361     void SystemAbilityInvalidateCache(int32_t systemAbilityId);
362 #ifdef SUPPORT_DEVICE_MANAGER
363     void DeviceIdToNetworkId(std::string& networkId);
364 #endif
365     bool IpcStatSamgrProc(int32_t fd, int32_t cmd);
366     void IpcDumpAllProcess(int32_t fd, int32_t cmd);
367     void IpcDumpSamgrProcess(int32_t fd, int32_t cmd);
368     void IpcDumpSingleProcess(int32_t fd, int32_t cmd, const std::string processName);
369     int32_t IpcDumpProc(int32_t fd, const std::vector<std::string>& args);
370     void RegisterDistribute(int32_t said, bool isDistributed);
371     void ConvertDumpListener(std::vector<std::pair<int32_t, std::list<int32_t>>>& dumpListeners);
372 
373     std::u16string deviceName_;
374     static sptr<SystemAbilityManager> instance;
375     static std::mutex instanceLock;
376     sptr<IRemoteObject::DeathRecipient> abilityDeath_;
377     sptr<IRemoteObject::DeathRecipient> systemProcessDeath_;
378     sptr<IRemoteObject::DeathRecipient> abilityStatusDeath_;
379     sptr<IRemoteObject::DeathRecipient> abilityCallbackDeath_;
380     sptr<IRemoteObject::DeathRecipient> remoteCallbackDeath_;
381     sptr<DBinderService> dBinderService_;
382     sptr<DeviceStatusCollectManager> collectManager_;
383     std::shared_ptr<RpcSystemAbilityCallback> rpcCallbackImp_;
384 
385 #ifdef SAMGR_ENABLE_DELAY_DBINDER
386     std::shared_mutex dBinderServiceLock_;
387     std::list<int32_t> distributedSaList_;
388     bool isDbinderServiceInit_ = false;
389 #endif
390 
391     // must hold abilityMapLock_ never access other locks
392     std::shared_mutex abilityMapLock_;
393     std::map<int32_t, SAInfo> abilityMap_;
394 
395     // maybe hold listenerMapLock_ and then access onDemandLock_
396     std::mutex listenerMapLock_;
397     std::map<int32_t, std::list<SAListener>> listenerMap_;
398     std::map<int32_t, int32_t> subscribeCountMap_;
399 
400     std::mutex onDemandLock_;
401     std::map<int32_t, std::u16string> onDemandAbilityMap_;
402     std::map<int32_t, AbilityItem> startingAbilityMap_;
403     std::mutex systemProcessMapLock_;
404     std::map<std::u16string, sptr<IRemoteObject>> systemProcessMap_;
405     std::mutex startingProcessMapLock_;
406     std::map<std::u16string, int64_t> startingProcessMap_;
407     std::map<int32_t, int32_t> callbackCountMap_;
408 
409     std::shared_ptr<FFRTHandler> workHandler_;
410 
411     std::map<int32_t, CommonSaProfile> saProfileMap_;
412     std::set<int32_t> onDemandSaIdsSet_;
413     std::mutex saProfileMapLock_;
414     std::mutex loadRemoteLock_;
415     std::map<std::string, std::list<sptr<ISystemAbilityLoadCallback>>> remoteCallbacks_; // key : said_deviceId
416 
417     std::mutex saFrequencyLock_;
418     std::map<uint64_t, int32_t> saFrequencyMap_; // {pid_said, count}
419 
420     std::unique_ptr<Utils::Timer> reportEventTimer_;
421     std::shared_ptr<SystemAbilityStateScheduler> abilityStateScheduler_;
422 };
423 } // namespace OHOS
424 
425 #endif // !defined(SERVICES_SAMGR_NATIVE_INCLUDE_SYSTEM_ABILITY_MANAGER_H)
426