1 /* 2 ** 3 ** Copyright 2015, The Android Open Source Project 4 ** 5 ** Licensed under the Apache License, Version 2.0 (the "License"); 6 ** you may not use this file except in compliance with the License. 7 ** You may obtain a copy of the License at 8 ** 9 ** http://www.apache.org/licenses/LICENSE-2.0 10 ** 11 ** Unless required by applicable law or agreed to in writing, software 12 ** distributed under the License is distributed on an "AS IS" BASIS, 13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 ** See the License for the specific language governing permissions and 15 ** limitations under the License. 16 */ 17 18 #ifndef ANDROID_MEDIA_RESOURCEMANAGERSERVICE_H 19 #define ANDROID_MEDIA_RESOURCEMANAGERSERVICE_H 20 21 #include <map> 22 #include <mutex> 23 24 #include <aidl/android/media/BnResourceManagerService.h> 25 #include <arpa/inet.h> 26 #include <media/MediaResource.h> 27 #include <utils/Errors.h> 28 #include <utils/KeyedVector.h> 29 #include <utils/String8.h> 30 #include <utils/threads.h> 31 #include <utils/Vector.h> 32 33 namespace android { 34 35 class DeathNotifier; 36 class ResourceManagerService; 37 class ResourceObserverService; 38 class ServiceLog; 39 struct ProcessInfoInterface; 40 41 using Status = ::ndk::ScopedAStatus; 42 using ::aidl::android::media::IResourceManagerClient; 43 using ::aidl::android::media::BnResourceManagerService; 44 using ::aidl::android::media::MediaResourceParcel; 45 using ::aidl::android::media::MediaResourcePolicyParcel; 46 47 typedef std::map<std::tuple< 48 MediaResource::Type, MediaResource::SubType, std::vector<uint8_t>>, 49 MediaResourceParcel> ResourceList; 50 51 struct ResourceInfo { 52 int64_t clientId; 53 uid_t uid; 54 std::shared_ptr<IResourceManagerClient> client; 55 uintptr_t cookie{0}; 56 ResourceList resources; 57 bool pendingRemoval{false}; 58 }; 59 60 // TODO: convert these to std::map 61 typedef KeyedVector<int64_t, ResourceInfo> ResourceInfos; 62 typedef KeyedVector<int, ResourceInfos> PidResourceInfosMap; 63 64 class ResourceManagerService : public BnResourceManagerService { 65 public: 66 struct SystemCallbackInterface : public RefBase { 67 virtual void noteStartVideo(int uid) = 0; 68 virtual void noteStopVideo(int uid) = 0; 69 virtual void noteResetVideo() = 0; 70 virtual bool requestCpusetBoost(bool enable) = 0; 71 }; 72 getServiceName()73 static char const *getServiceName() { return "media.resource_manager"; } 74 static void instantiate(); 75 76 virtual inline binder_status_t dump( 77 int /*fd*/, const char** /*args*/, uint32_t /*numArgs*/); 78 79 ResourceManagerService(); 80 explicit ResourceManagerService( 81 const sp<ProcessInfoInterface> &processInfo, 82 const sp<SystemCallbackInterface> &systemResource); 83 virtual ~ResourceManagerService(); 84 void setObserverService( 85 const std::shared_ptr<ResourceObserverService>& observerService); 86 87 // IResourceManagerService interface 88 Status config(const std::vector<MediaResourcePolicyParcel>& policies) override; 89 90 Status addResource( 91 int32_t pid, 92 int32_t uid, 93 int64_t clientId, 94 const std::shared_ptr<IResourceManagerClient>& client, 95 const std::vector<MediaResourceParcel>& resources) override; 96 97 Status removeResource( 98 int32_t pid, 99 int64_t clientId, 100 const std::vector<MediaResourceParcel>& resources) override; 101 102 Status removeClient(int32_t pid, int64_t clientId) override; 103 104 // Tries to reclaim resource from processes with lower priority than the calling process 105 // according to the requested resources. 106 // Returns true if any resource has been reclaimed, otherwise returns false. 107 Status reclaimResource( 108 int32_t callingPid, 109 const std::vector<MediaResourceParcel>& resources, 110 bool* _aidl_return) override; 111 112 Status overridePid( 113 int originalPid, 114 int newPid) override; 115 116 Status overrideProcessInfo( 117 const std::shared_ptr<IResourceManagerClient>& client, 118 int pid, 119 int procState, 120 int oomScore) override; 121 122 Status markClientForPendingRemoval(int32_t pid, int64_t clientId) override; 123 124 Status reclaimResourcesFromClientsPendingRemoval(int32_t pid) override; 125 126 Status removeResource(int pid, int64_t clientId, bool checkValid); 127 128 private: 129 friend class ResourceManagerServiceTest; 130 friend class DeathNotifier; 131 friend class OverrideProcessInfoDeathNotifier; 132 133 // Reclaims resources from |clients|. Returns true if reclaim succeeded 134 // for all clients. 135 bool reclaimInternal( 136 const Vector<std::shared_ptr<IResourceManagerClient>> &clients); 137 138 // Gets the list of all the clients who own the specified resource type. 139 // Returns false if any client belongs to a process with higher priority than the 140 // calling process. The clients will remain unchanged if returns false. 141 bool getAllClients_l(int callingPid, MediaResource::Type type, 142 Vector<std::shared_ptr<IResourceManagerClient>> *clients); 143 144 // Gets the client who owns specified resource type from lowest possible priority process. 145 // Returns false if the calling process priority is not higher than the lowest process 146 // priority. The client will remain unchanged if returns false. 147 bool getLowestPriorityBiggestClient_l(int callingPid, MediaResource::Type type, 148 std::shared_ptr<IResourceManagerClient> *client); 149 150 // Gets lowest priority process that has the specified resource type. 151 // Returns false if failed. The output parameters will remain unchanged if failed. 152 bool getLowestPriorityPid_l(MediaResource::Type type, int *pid, int *priority); 153 154 // Gets the client who owns biggest piece of specified resource type from pid. 155 // Returns false if failed. The client will remain unchanged if failed. 156 bool getBiggestClient_l(int pid, MediaResource::Type type, 157 std::shared_ptr<IResourceManagerClient> *client, 158 bool pendingRemovalOnly = false); 159 160 bool isCallingPriorityHigher_l(int callingPid, int pid); 161 162 // A helper function basically calls getLowestPriorityBiggestClient_l and add 163 // the result client to the given Vector. 164 void getClientForResource_l(int callingPid, const MediaResourceParcel *res, 165 Vector<std::shared_ptr<IResourceManagerClient>> *clients); 166 167 void onFirstAdded(const MediaResourceParcel& res, const ResourceInfo& clientInfo); 168 void onLastRemoved(const MediaResourceParcel& res, const ResourceInfo& clientInfo); 169 170 // Merge r2 into r1 171 void mergeResources(MediaResourceParcel& r1, const MediaResourceParcel& r2); 172 173 // Get priority from process's pid 174 bool getPriority_l(int pid, int* priority); 175 176 void removeProcessInfoOverride(int pid); 177 178 void removeProcessInfoOverride_l(int pid); 179 uintptr_t addCookieAndLink_l(::ndk::SpAIBinder binder, const sp<DeathNotifier>& notifier); 180 void removeCookieAndUnlink_l(::ndk::SpAIBinder binder, uintptr_t cookie); 181 182 mutable Mutex mLock; 183 sp<ProcessInfoInterface> mProcessInfo; 184 sp<SystemCallbackInterface> mSystemCB; 185 sp<ServiceLog> mServiceLog; 186 PidResourceInfosMap mMap; 187 bool mSupportsMultipleSecureCodecs; 188 bool mSupportsSecureWithNonSecureCodec; 189 int32_t mCpuBoostCount; 190 ::ndk::ScopedAIBinder_DeathRecipient mDeathRecipient; 191 struct ProcessInfoOverride { 192 uintptr_t cookie; 193 std::shared_ptr<IResourceManagerClient> client; 194 }; 195 std::map<int, int> mOverridePidMap; 196 std::map<pid_t, ProcessInfoOverride> mProcessInfoOverrideMap; 197 static std::mutex sCookieLock; 198 static uintptr_t sCookieCounter GUARDED_BY(sCookieLock); 199 static std::map<uintptr_t, sp<DeathNotifier> > sCookieToDeathNotifierMap 200 GUARDED_BY(sCookieLock); 201 std::shared_ptr<ResourceObserverService> mObserverService; 202 }; 203 204 // ---------------------------------------------------------------------------- 205 } // namespace android 206 207 #endif // ANDROID_MEDIA_RESOURCEMANAGERSERVICE_H 208