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)
62         :listener(lst), callingPid(cpid), state(sta) {}
63 };
64 
65 class SystemAbilityManager : public DynamicCache, public SystemAbilityManagerStub {
66 public:
67     virtual ~SystemAbilityManager();
68     static sptr<SystemAbilityManager> GetInstance();
69 
70     int32_t RemoveSystemAbility(const sptr<IRemoteObject>& ability);
71     std::vector<std::u16string> ListSystemAbilities(uint32_t dumpFlags) override;
72 
SetDeviceName(const std::u16string & name)73     void SetDeviceName(const std::u16string &name)
74     {
75         deviceName_ = name;
76     }
77 
GetDeviceName()78     const std::u16string& GetDeviceName() const
79     {
80         return deviceName_;
81     }
82 
GetDBinder()83     const sptr<DBinderService> GetDBinder() const
84     {
85         return dBinderService_;
86     }
87 
88     sptr<IRemoteObject> GetSystemAbility(int32_t systemAbilityId) override;
89 
90     sptr<IRemoteObject> CheckSystemAbility(int32_t systemAbilityId) override;
91 
92     int32_t RemoveSystemAbility(int32_t systemAbilityId) override;
93 
94     int32_t SubscribeSystemAbility(int32_t systemAbilityId, const sptr<ISystemAbilityStatusChange>& listener) override;
95     int32_t UnSubscribeSystemAbility(int32_t systemAbilityId,
96         const sptr<ISystemAbilityStatusChange>& listener) override;
97     void UnSubscribeSystemAbility(const sptr<IRemoteObject>& remoteObject);
98 
99     sptr<IRemoteObject> GetSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override;
100 
101     sptr<IRemoteObject> CheckSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override;
102 
103     int32_t AddOnDemandSystemAbilityInfo(int32_t systemAbilityId, const std::u16string& procName) override;
104 
105     sptr<IRemoteObject> CheckSystemAbility(int32_t systemAbilityId, bool& isExist) override;
106     bool DoLoadOnDemandAbility(int32_t systemAbilityId, bool& isExist);
107 
108     int32_t RemoveDiedSystemAbility(int32_t systemAbilityId);
109 
110     void NotifyRemoteSaDied(const std::u16string& name);
111     void NotifyRemoteDeviceOffline(const std::string& deviceId);
112     int32_t AddSystemAbility(int32_t systemAbilityId, const sptr<IRemoteObject>& ability,
113         const SAExtraProp& extraProp) override;
GetLocalNodeId()114     std::string GetLocalNodeId()
115     {
116         return std::string();
117     }
118     void Init();
119     void CleanFfrt();
120     void SetFfrt();
121     int32_t Dump(int32_t fd, const std::vector<std::u16string>& args) override;
122     void AddSamgrToAbilityMap();
123 
124     int32_t AddSystemProcess(const std::u16string& procName, const sptr<IRemoteObject>& procObject) override;
125     int32_t RemoveSystemProcess(const sptr<IRemoteObject>& procObject);
126     int32_t GetSystemProcessInfo(int32_t systemAbilityId, SystemProcessInfo& systemProcessInfo) override;
127     int32_t GetRunningSystemProcess(std::list<SystemProcessInfo>& systemProcessInfos) override;
128     int32_t SubscribeSystemProcess(const sptr<ISystemProcessStatusChange>& listener) override;
129     int32_t UnSubscribeSystemProcess(const sptr<ISystemProcessStatusChange>& listener) override;
130     int32_t GetOnDemandReasonExtraData(int64_t extraDataId, MessageParcel& extraDataParcel) override;
131 
LoadSystemAbility(int32_t systemAbilityId,int32_t timeout)132     sptr<IRemoteObject> LoadSystemAbility(int32_t systemAbilityId, int32_t timeout) override
133     {
134         return nullptr;
135     }
136 
137     int32_t LoadSystemAbility(int32_t systemAbilityId, const sptr<ISystemAbilityLoadCallback>& callback) override;
138     int32_t DoLoadSystemAbility(int32_t systemAbilityId, const std::u16string& procName,
139         const sptr<ISystemAbilityLoadCallback>& callback, int32_t callingPid, const OnDemandEvent& event);
140     int32_t LoadSystemAbility(int32_t systemAbilityId, const std::string& deviceId,
141         const sptr<ISystemAbilityLoadCallback>& callback) override;
142     int32_t UnloadSystemAbility(int32_t systemAbilityId) override;
143     int32_t DoUnloadSystemAbility(int32_t systemAbilityId, const std::u16string& procName, const OnDemandEvent& event);
144     int32_t CancelUnloadSystemAbility(int32_t systemAbilityId) override;
145     int32_t DoUnloadSystemAbility(int32_t systemAbilityId, const std::u16string& procName);
146     int32_t UnloadAllIdleSystemAbility() override;
147     bool IdleSystemAbility(int32_t systemAbilityId, const std::u16string& procName,
148         const nlohmann::json& idleReason, int32_t& delayTime);
149     bool ActiveSystemAbility(int32_t systemAbilityId, const std::u16string& procName,
150         const nlohmann::json& activeReason);
151     void OnAbilityCallbackDied(const sptr<IRemoteObject>& remoteObject);
152     void OnRemoteCallbackDied(const sptr<IRemoteObject>& remoteObject);
153     sptr<IRemoteObject> GetSystemAbilityFromRemote(int32_t systemAbilityId);
154     bool LoadSystemAbilityFromRpc(const std::string& srcDeviceId, int32_t systemAbilityId,
155         const sptr<ISystemAbilityLoadCallback>& callback);
156     int32_t DoLoadSystemAbilityFromRpc(const std::string& srcDeviceId, int32_t systemAbilityId,
157         const std::u16string& procName, const sptr<ISystemAbilityLoadCallback>& callback, const OnDemandEvent& event);
158     void NotifyRpcLoadCompleted(const std::string& srcDeviceId, int32_t systemAbilityId,
159         const sptr<IRemoteObject>& remoteObject);
160     void StartDfxTimer();
161     void DoLoadForPerf();
162     void ProcessOnDemandEvent(const OnDemandEvent& event, const std::list<SaControlInfo>& saControlList);
163     int32_t GetOnDemandPolicy(int32_t systemAbilityId, OnDemandPolicyType type,
164         std::vector<SystemAbilityOnDemandEvent>& abilityOnDemandEvents) override;
165     int32_t UpdateOnDemandPolicy(int32_t systemAbilityId, OnDemandPolicyType type,
166         const std::vector<SystemAbilityOnDemandEvent>& abilityOnDemandEvents) override;
167     int32_t GetOnDemandSystemAbilityIds(std::vector<int32_t>& systemAbilityIds) override;
168     int32_t SendStrategy(int32_t type, std::vector<int32_t>& systemAbilityIds,
169         int32_t level, std::string& action) override;
170     bool CheckSaIsImmediatelyRecycle(int32_t systemAbilityId);
171     bool IsDistributedSystemAbility(int32_t systemAbilityId);
172     int32_t GetRunningSaExtensionInfoList(const std::string& extension,
173         std::vector<SaExtensionInfo>& infoList) override;
174     int32_t GetExtensionSaIds(const std::string& extension, std::vector<int32_t>& saIds) override;
175     int32_t GetExtensionRunningSaList(const std::string& extension, std::vector<sptr<IRemoteObject>>& saList) override;
176     int32_t GetCommonEventExtraDataIdlist(int32_t saId, std::vector<int64_t>& extraDataIdList,
177         const std::string& eventName = "") override;
178     sptr<IRemoteObject> GetSystemProcess(const std::u16string& procName);
179     bool IsModuleUpdate(int32_t systemAbilityId);
180     void RemoveWhiteCommonEvent();
181     void InitDbinderService();
182 private:
183     enum class AbilityState {
184         INIT,
185         STARTING,
186         STARTED,
187     };
188 
189     using CallbackList = std::list<std::pair<sptr<ISystemAbilityLoadCallback>, int32_t>>;
190 
191     struct AbilityItem {
192         AbilityState state = AbilityState::INIT;
193         std::map<std::string, CallbackList> callbackMap; // key : networkid
194         OnDemandEvent event;
195     };
196 
197     SystemAbilityManager();
198     std::string EventToJson(const OnDemandEvent& event);
199     void DoInsertSaData(const std::u16string& name, const sptr<IRemoteObject>& ability, const SAExtraProp& extraProp);
200     int32_t StartOnDemandAbility(int32_t systemAbilityId, bool& isExist);
201     int32_t StartOnDemandAbilityLocked(int32_t systemAbilityId, bool& isExist);
202     void RefreshListenerState(int32_t systemAbilityId);
203     int32_t AddSystemAbility(const std::u16string& name, const sptr<IRemoteObject>& ability,
204         const SAExtraProp& extraProp);
205     int32_t FindSystemAbilityNotify(int32_t systemAbilityId, int32_t code);
206     int32_t FindSystemAbilityNotify(int32_t systemAbilityId, const std::string& deviceId, int32_t code);
207 
208     void InitSaProfile();
209     bool GetSaProfile(int32_t saId, SaProfile& saProfile);
210     void CheckListenerNotify(int32_t systemAbilityId, const sptr<ISystemAbilityStatusChange>& listener);
211     void NotifySystemAbilityChanged(int32_t systemAbilityId, const std::string& deviceId, int32_t code,
212         const sptr<ISystemAbilityStatusChange>& listener);
213     void NotifySystemAbilityAddedByAsync(int32_t systemAbilityId, const sptr<ISystemAbilityStatusChange>& listener);
214     void UnSubscribeSystemAbilityLocked(std::list<SAListener>& listenerList,
215         const sptr<IRemoteObject>& listener);
216 
217     void SendSystemAbilityAddedMsg(int32_t systemAbilityId, const sptr<IRemoteObject>& remoteObject);
218     void SendSystemAbilityRemovedMsg(int32_t systemAbilityId);
219 
220     void NotifySystemAbilityLoaded(int32_t systemAbilityId, const sptr<IRemoteObject>& remoteObject);
221     void NotifySystemAbilityLoaded(int32_t systemAbilityId, const sptr<IRemoteObject>& remoteObject,
222         const sptr<ISystemAbilityLoadCallback>& callback);
223     void NotifySystemAbilityLoadFail(int32_t systemAbilityId, const sptr<ISystemAbilityLoadCallback>& callback);
224     int32_t StartingSystemProcess(const std::u16string& name, int32_t systemAbilityId, const OnDemandEvent& event);
225     int32_t StartingSystemProcessLocked(const std::u16string& name, int32_t systemAbilityId,
226         const OnDemandEvent& event);
227     void StartOnDemandAbility(const std::u16string& name, int32_t systemAbilityId);
228     void StartOnDemandAbilityLocked(const std::u16string& name, int32_t systemAbilityId);
229     int32_t StartOnDemandAbilityInner(const std::u16string& name, int32_t systemAbilityId, AbilityItem& abilityItem);
230     bool IsInitBootFinished();
231     int32_t StartDynamicSystemProcess(const std::u16string& name, int32_t systemAbilityId, const OnDemandEvent& event);
232     bool StopOnDemandAbility(const std::u16string& name, int32_t systemAbilityId, const OnDemandEvent& event);
233     bool StopOnDemandAbilityInner(const std::u16string& name, int32_t systemAbilityId, const OnDemandEvent& event);
234     void RemoveStartingAbilityCallback(CallbackList& callbackList, const sptr<IRemoteObject>& remoteObject);
235     void RemoveStartingAbilityCallbackForDevice(AbilityItem& abilityItem, const sptr<IRemoteObject>& remoteObject);
236     void RemoveStartingAbilityCallbackLocked(std::pair<sptr<ISystemAbilityLoadCallback>, int32_t>& itemPair);
237     bool IsCacheCommonEvent(int32_t systemAbilityId);
238     void SendCheckLoadedMsg(int32_t systemAbilityId, const std::u16string& name, const std::string& srcDeviceId,
239         const sptr<ISystemAbilityLoadCallback>& callback);
240     void RemoveCheckLoadedMsg(int32_t systemAbilityId);
241     void SendLoadedSystemAbilityMsg(int32_t systemAbilityId, const sptr<IRemoteObject>& remoteObject,
242         const sptr<ISystemAbilityLoadCallback>& callback);
243     void DoLoadRemoteSystemAbility(int32_t systemAbilityId, int32_t callingPid,
244         int32_t callingUid, const std::string& deviceId, const sptr<ISystemAbilityLoadCallback>& callback);
245     sptr<DBinderServiceStub> DoMakeRemoteBinder(int32_t systemAbilityId, int32_t callingPid, int32_t callingUid,
246         const std::string& deviceId);
247     void RemoveRemoteCallbackLocked(std::list<sptr<ISystemAbilityLoadCallback>>& callbacks,
248         const sptr<IRemoteObject>& remoteObject);
249     void CleanCallbackForLoadFailed(int32_t systemAbilityId, const std::u16string& name,
250         const std::string& srcDeviceId, const sptr<ISystemAbilityLoadCallback>& callback);
251     int32_t UpdateSaFreMap(int32_t uid, int32_t saId);
252     void ReportGetSAPeriodically();
253     void OndemandLoad();
254     void OndemandLoadForPerf();
255     std::list<int32_t> GetAllOndemandSa();
256     void SystemAbilityInvalidateCache(int32_t systemAbilityId);
257 #ifdef SUPPORT_DEVICE_MANAGER
258     void DeviceIdToNetworkId(std::string& networkId);
259 #endif
260     bool IpcStatSamgrProc(int32_t fd, int32_t cmd);
261     void IpcDumpAllProcess(int32_t fd, int32_t cmd);
262     void IpcDumpSamgrProcess(int32_t fd, int32_t cmd);
263     void IpcDumpSingleProcess(int32_t fd, int32_t cmd, const std::string processName);
264     int32_t IpcDumpProc(int32_t fd, const std::vector<std::string>& args);
265     void RegisterDistribute(int32_t said, bool isDistributed);
266 
267     std::u16string deviceName_;
268     static sptr<SystemAbilityManager> instance;
269     static std::mutex instanceLock;
270     sptr<IRemoteObject::DeathRecipient> abilityDeath_;
271     sptr<IRemoteObject::DeathRecipient> systemProcessDeath_;
272     sptr<IRemoteObject::DeathRecipient> abilityStatusDeath_;
273     sptr<IRemoteObject::DeathRecipient> abilityCallbackDeath_;
274     sptr<IRemoteObject::DeathRecipient> remoteCallbackDeath_;
275     sptr<DBinderService> dBinderService_;
276     sptr<DeviceStatusCollectManager> collectManager_;
277     std::shared_ptr<RpcSystemAbilityCallback> rpcCallbackImp_;
278 
279     std::shared_mutex dBinderServiceLock_;
280     std::list<int32_t> distributedSaList_;
281     bool isDbinderServiceInit_ = false;
282 
283     // must hold abilityMapLock_ never access other locks
284     std::shared_mutex abilityMapLock_;
285     std::map<int32_t, SAInfo> abilityMap_;
286 
287     // maybe hold listenerMapLock_ and then access onDemandLock_
288     std::mutex listenerMapLock_;
289     std::map<int32_t, std::list<SAListener>> listenerMap_;
290     std::map<int32_t, int32_t> subscribeCountMap_;
291 
292     std::mutex onDemandLock_;
293     std::map<int32_t, std::u16string> onDemandAbilityMap_;
294     std::map<int32_t, AbilityItem> startingAbilityMap_;
295     std::mutex systemProcessMapLock_;
296     std::map<std::u16string, sptr<IRemoteObject>> systemProcessMap_;
297     std::mutex startingProcessMapLock_;
298     std::map<std::u16string, int64_t> startingProcessMap_;
299     std::map<int32_t, int32_t> callbackCountMap_;
300 
301     std::shared_ptr<FFRTHandler> workHandler_;
302 
303     std::map<int32_t, SaProfile> saProfileMap_;
304     std::set<int32_t> onDemandSaIdsSet_;
305     std::mutex saProfileMapLock_;
306     std::mutex loadRemoteLock_;
307     std::map<std::string, std::list<sptr<ISystemAbilityLoadCallback>>> remoteCallbacks_; // key : said_deviceId
308 
309     std::mutex saFrequencyLock_;
310     std::map<uint64_t, int32_t> saFrequencyMap_; // {pid_said, count}
311 
312     std::unique_ptr<Utils::Timer> reportEventTimer_;
313     std::shared_ptr<SystemAbilityStateScheduler> abilityStateScheduler_;
314 };
315 } // namespace OHOS
316 
317 #endif // !defined(SERVICES_SAMGR_NATIVE_INCLUDE_SYSTEM_ABILITY_MANAGER_H)
318