services/mediaresourcemanager/ResourceManagerServiceNew.cpp

/*
**
** Copyright 2023, The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
**     http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/

//#define LOG_NDEBUG 0
#define LOG_TAG "ResourceManagerServiceNew"
#include <utils/Log.h>
#include <binder/IPCThreadState.h>
#include <mediautils/ProcessInfo.h>

#include "DefaultResourceModel.h"
#include "ClientImportanceReclaimPolicy.h"
#include "ProcessPriorityReclaimPolicy.h"
#include "ResourceManagerServiceNew.h"
#include "ResourceTracker.h"
#include "ServiceLog.h"

namespace android {

ResourceManagerServiceNew::ResourceManagerServiceNew(
        const sp<ProcessInfoInterface>& processInfo,
        const sp<SystemCallbackInterface>& systemResource) :
  ResourceManagerService(processInfo, systemResource) {}

ResourceManagerServiceNew::~ResourceManagerServiceNew() {}

void ResourceManagerServiceNew::init() {
    // Create the Resource Tracker
    mResourceTracker = std::make_shared<ResourceTracker>(ref<ResourceManagerServiceNew>(),
                                                         mProcessInfo);
    setUpResourceModels();
    setUpReclaimPolicies();
}

void ResourceManagerServiceNew::setUpResourceModels() {
    std::scoped_lock lock{mLock};
    // Create/Configure the default resource model.
    if (mDefaultResourceModel == nullptr) {
        mDefaultResourceModel = std::make_unique<DefaultResourceModel>(
                mResourceTracker,
                mSupportsMultipleSecureCodecs,
                mSupportsSecureWithNonSecureCodec);
    } else {
        DefaultResourceModel* resourceModel =
            static_cast<DefaultResourceModel*>(mDefaultResourceModel.get());
        resourceModel->config(mSupportsMultipleSecureCodecs, mSupportsSecureWithNonSecureCodec);
    }
}

void ResourceManagerServiceNew::setUpReclaimPolicies() {
    mReclaimPolicies.clear();
    // Add Reclaim policies based on:
    // - the Process priority (oom score)
    // - the client/codec importance.
    setReclaimPolicy(true /* processPriority */, true /* clientImportance */);
}

Status ResourceManagerServiceNew::config(const std::vector<MediaResourcePolicyParcel>& policies) {
    Status status = ResourceManagerService::config(policies);
    // Change in the config dictates update to the resource model.
    setUpResourceModels();
    return status;
}

void ResourceManagerServiceNew::setObserverService(
        const std::shared_ptr<ResourceObserverService>& observerService) {
    ResourceManagerService::setObserverService(observerService);
    mResourceTracker->setResourceObserverService(observerService);
}

Status ResourceManagerServiceNew::addResource(
        const ClientInfoParcel& clientInfo,
        const std::shared_ptr<IResourceManagerClient>& client,
        const std::vector<MediaResourceParcel>& resources) {
    int32_t pid = clientInfo.pid;
    int32_t uid = clientInfo.uid;
    int64_t clientId = clientInfo.id;
    String8 log = String8::format("addResource(pid %d, uid %d clientId %lld, resources %s)",
            pid, uid, (long long) clientId, getString(resources).c_str());
    mServiceLog->add(log);

    std::scoped_lock lock{mLock};
    mResourceTracker->addResource(clientInfo, client, resources);
    notifyResourceGranted(pid, resources);

    return Status::ok();
}

Status ResourceManagerServiceNew::removeResource(
        const ClientInfoParcel& clientInfo,
        const std::vector<MediaResourceParcel>& resources) {
    int32_t pid = clientInfo.pid;
    int32_t uid = clientInfo.uid;
    int64_t clientId = clientInfo.id;
    String8 log = String8::format("removeResource(pid %d, uid %d clientId %lld, resources %s)",
            pid, uid, (long long) clientId, getString(resources).c_str());
    mServiceLog->add(log);

    std::scoped_lock lock{mLock};
    mResourceTracker->removeResource(clientInfo, resources);
    return Status::ok();
}

Status ResourceManagerServiceNew::removeClient(const ClientInfoParcel& clientInfo) {
    removeResource(clientInfo, true /*checkValid*/);
    return Status::ok();
}

Status ResourceManagerServiceNew::removeResource(const ClientInfoParcel& clientInfo,
                                                 bool checkValid) {
    int32_t pid = clientInfo.pid;
    int32_t uid = clientInfo.uid;
    int64_t clientId = clientInfo.id;
    String8 log = String8::format("removeResource(pid %d, uid %d clientId %lld)",
            pid, uid, (long long) clientId);
    mServiceLog->add(log);

    std::scoped_lock lock{mLock};
    if (mResourceTracker->removeResource(clientInfo, checkValid)) {
        notifyClientReleased(clientInfo);
    }
    return Status::ok();
}

Status ResourceManagerServiceNew::reclaimResource(
        const ClientInfoParcel& clientInfo,
        const std::vector<MediaResourceParcel>& resources,
        bool* _aidl_return) {
    return ResourceManagerService::reclaimResource(clientInfo, resources, _aidl_return);
}

bool ResourceManagerServiceNew::overridePid_l(int32_t originalPid, int32_t newPid) {
    return mResourceTracker->overridePid(originalPid, newPid);
}

Status ResourceManagerServiceNew::overridePid(int originalPid, int newPid) {
    return ResourceManagerService::overridePid(originalPid, newPid);
}

bool ResourceManagerServiceNew::overrideProcessInfo_l(
        const std::shared_ptr<IResourceManagerClient>& client,
        int pid,
        int procState,
        int oomScore) {
    return mResourceTracker->overrideProcessInfo(client, pid, procState, oomScore);
}

Status ResourceManagerServiceNew::overrideProcessInfo(
        const std::shared_ptr<IResourceManagerClient>& client,
        int pid,
        int procState,
        int oomScore) {
    return ResourceManagerService::overrideProcessInfo(client, pid, procState, oomScore);
}

void ResourceManagerServiceNew::removeProcessInfoOverride(int pid) {
    std::scoped_lock lock{mLock};

    mResourceTracker->removeProcessInfoOverride(pid);
}

Status ResourceManagerServiceNew::markClientForPendingRemoval(const ClientInfoParcel& clientInfo) {
    int32_t pid = clientInfo.pid;
    int64_t clientId = clientInfo.id;
    String8 log = String8::format(
            "markClientForPendingRemoval(pid %d, clientId %lld)",
            pid, (long long) clientId);
    mServiceLog->add(log);

    std::scoped_lock lock{mLock};
    mResourceTracker->markClientForPendingRemoval(clientInfo);
    return Status::ok();
}

Status ResourceManagerServiceNew::reclaimResourcesFromClientsPendingRemoval(int32_t pid) {
    String8 log = String8::format("reclaimResourcesFromClientsPendingRemoval(pid %d)", pid);
    mServiceLog->add(log);

    std::vector<ClientInfo> targetClients;
    {
        std::scoped_lock lock{mLock};
        mResourceTracker->getClientsMarkedPendingRemoval(pid, targetClients);
    }

    if (!targetClients.empty()) {
        reclaimUnconditionallyFrom(targetClients);
    }
    return Status::ok();
}

Status ResourceManagerServiceNew::notifyClientCreated(const ClientInfoParcel& clientInfo) {
    return ResourceManagerService::notifyClientCreated(clientInfo);
}

Status ResourceManagerServiceNew::notifyClientStarted(const ClientConfigParcel& clientConfig) {
    return ResourceManagerService::notifyClientStarted(clientConfig);
}

Status ResourceManagerServiceNew::notifyClientStopped(const ClientConfigParcel& clientConfig) {
    return ResourceManagerService::notifyClientStopped(clientConfig);
}

Status ResourceManagerServiceNew::notifyClientConfigChanged(
        const ClientConfigParcel& clientConfig) {
    {
        // Update the ResourceTracker about the change in the configuration.
        std::scoped_lock lock{mLock};
        mResourceTracker->updateResource(clientConfig.clientInfo);
    }
    return ResourceManagerService::notifyClientConfigChanged(clientConfig);
}

void ResourceManagerServiceNew::getResourceDump(std::string& resourceLog) const {
    std::scoped_lock lock{mLock};
    mResourceTracker->dump(resourceLog);
}

binder_status_t ResourceManagerServiceNew::dump(int fd, const char** args, uint32_t numArgs) {
    return ResourceManagerService::dump(fd, args, numArgs);
}

bool ResourceManagerServiceNew::getTargetClients(
        const ClientInfoParcel& clientInfo,
        const std::vector<MediaResourceParcel>& resources,
        std::vector<ClientInfo>& targetClients) {
    int32_t callingPid = clientInfo.pid;
    std::scoped_lock lock{mLock};
    if (!mProcessInfo->isPidTrusted(callingPid)) {
        pid_t actualCallingPid = IPCThreadState::self()->getCallingPid();
        ALOGW("%s called with untrusted pid %d, using actual calling pid %d", __FUNCTION__,
                callingPid, actualCallingPid);
        callingPid = actualCallingPid;
    }

    // Use the Resource Model to get a list of all the clients that hold the
    // needed/requested resources.
    uint32_t callingImportance = std::max(0, clientInfo.importance);
    ReclaimRequestInfo reclaimRequestInfo{callingPid, clientInfo.id, callingImportance, resources};
    std::vector<ClientInfo> clients;
    if (!mDefaultResourceModel->getAllClients(reclaimRequestInfo, clients)) {
        if (clients.empty()) {
            ALOGI("%s: There aren't any clients with given resources. Nothing to reclaim",
                  __func__);
            return false;
        }
        // Since there was a conflict, we need to reclaim all clients.
        targetClients = std::move(clients);
    } else {
        // Select a client among those have the needed resources.
        getClientForResource_l(reclaimRequestInfo, clients, targetClients);
    }
    return !targetClients.empty();
}

void ResourceManagerServiceNew::getClientForResource_l(
        const ReclaimRequestInfo& reclaimRequestInfo,
        const std::vector<ClientInfo>& clients,
        std::vector<ClientInfo>& targetClients) {
    int callingPid = reclaimRequestInfo.mCallingPid;

    // Before looking into other processes, check if we have clients marked for
    // pending removal in the same process.
    ClientInfo targetClient;
    for (const MediaResourceParcel& resource : reclaimRequestInfo.mResources) {
        if (mResourceTracker->getBiggestClientPendingRemoval(callingPid, resource.type,
                                                             resource.subType, targetClient)) {
            targetClients.emplace_back(targetClient);
            return;
        }
    }

    // Run through all the reclaim policies until a client to reclaim from is identified.
    for (std::unique_ptr<IReclaimPolicy>& reclaimPolicy : mReclaimPolicies) {
        if (reclaimPolicy->getClients(reclaimRequestInfo, clients, targetClients)) {
            return;
        }
    }
}

bool ResourceManagerServiceNew::getLowestPriorityBiggestClient_l(
        const ResourceRequestInfo& resourceRequestInfo,
        ClientInfo& clientInfo) {
    //NOTE: This function is used only by the test: ResourceManagerServiceTest
    if (resourceRequestInfo.mResource == nullptr) {
        return false;
    }

    // Use the DefaultResourceModel to get all the clients with the resources requested.
    std::vector<MediaResourceParcel> resources{*resourceRequestInfo.mResource};
    ReclaimRequestInfo reclaimRequestInfo{resourceRequestInfo.mCallingPid,
                                          resourceRequestInfo.mClientId,
                                          0, // default importance
                                          resources};
    std::vector<ClientInfo> clients;
    mDefaultResourceModel->getAllClients(reclaimRequestInfo, clients);

    // Use the ProcessPriorityReclaimPolicy to select a client to reclaim from.
    std::unique_ptr<IReclaimPolicy> reclaimPolicy
        = std::make_unique<ProcessPriorityReclaimPolicy>(mResourceTracker);
    std::vector<ClientInfo> targetClients;
    if (reclaimPolicy->getClients(reclaimRequestInfo, clients, targetClients)) {
        if (!targetClients.empty()) {
            clientInfo = targetClients[0];
            return true;
        }
    }

    return false;
}

bool ResourceManagerServiceNew::getPriority_l(int pid, int* priority) const {
    return mResourceTracker->getPriority(pid, priority);
}

bool ResourceManagerServiceNew::getLowestPriorityPid_l(
        MediaResource::Type type, MediaResource::SubType subType,
        int* lowestPriorityPid, int* lowestPriority) {
    //NOTE: This function is used only by the test: ResourceManagerServiceTest
    return mResourceTracker->getLowestPriorityPid(type, subType,
                                                  *lowestPriorityPid,
                                                  *lowestPriority);
}

bool ResourceManagerServiceNew::getAllClients_l(
        const ResourceRequestInfo& resourceRequestInfo,
        std::vector<ClientInfo>& clientsInfo) {
    //NOTE: This function is used only by the test: ResourceManagerServiceTest
    MediaResource::Type type = resourceRequestInfo.mResource->type;
    // Get the list of all clients that has requested resources.
    std::vector<ClientInfo> clients;
    mResourceTracker->getAllClients(resourceRequestInfo, clients);

    // Check is there any high priority process holding up the resources already.
    for (const ClientInfo& info : clients) {
        if (!isCallingPriorityHigher_l(resourceRequestInfo.mCallingPid, info.mPid)) {
            // some higher/equal priority process owns the resource,
            // this request can't be fulfilled.
            ALOGE("%s: can't reclaim resource %s from pid %d", __func__, asString(type), info.mPid);
            return false;
        }
        clientsInfo.emplace_back(info);
    }
    if (clientsInfo.size() == 0) {
        ALOGV("%s: didn't find any resource %s", __func__, asString(type));
    }
    return true;
}

std::shared_ptr<IResourceManagerClient> ResourceManagerServiceNew::getClient_l(
        int pid, const int64_t& clientId) const {
    return mResourceTracker->getClient(pid, clientId);
}

bool ResourceManagerServiceNew::removeClient_l(int pid, const int64_t& clientId) {
    return mResourceTracker->removeClient(pid, clientId);
}

const std::map<int, ResourceInfos>& ResourceManagerServiceNew::getResourceMap() const {
    return mResourceTracker->getResourceMap();
}

void ResourceManagerServiceNew::setReclaimPolicy(bool processPriority, bool clientImportance) {
    mReclaimPolicies.clear();
    if (processPriority) {
        // Process priority (oom score) as the Default reclaim policy.
        mReclaimPolicies.push_back(std::make_unique<ProcessPriorityReclaimPolicy>(
            mResourceTracker));
    }
    if (clientImportance) {
        mReclaimPolicies.push_back(std::make_unique<ClientImportanceReclaimPolicy>(
            mResourceTracker));
    }
}

} // namespace android