You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
702 lines
24 KiB
702 lines
24 KiB
/*
|
|
* Copyright (C) 2019 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.
|
|
*/
|
|
|
|
#include "ServiceManager.h"
|
|
|
|
#include <android-base/logging.h>
|
|
#include <android-base/properties.h>
|
|
#include <binder/BpBinder.h>
|
|
#include <binder/IPCThreadState.h>
|
|
#include <binder/ProcessState.h>
|
|
#include <binder/Stability.h>
|
|
#include <cutils/android_filesystem_config.h>
|
|
#include <cutils/multiuser.h>
|
|
#include <thread>
|
|
|
|
#ifndef VENDORSERVICEMANAGER
|
|
#include <vintf/VintfObject.h>
|
|
#include <vintf/constants.h>
|
|
#endif // !VENDORSERVICEMANAGER
|
|
|
|
using ::android::binder::Status;
|
|
using ::android::internal::Stability;
|
|
|
|
namespace android {
|
|
|
|
#ifndef VENDORSERVICEMANAGER
|
|
struct ManifestWithDescription {
|
|
std::shared_ptr<const vintf::HalManifest> manifest;
|
|
const char* description;
|
|
};
|
|
// func true -> stop search and forEachManifest will return true
|
|
static bool forEachManifest(const std::function<bool(const ManifestWithDescription&)>& func) {
|
|
for (const ManifestWithDescription& mwd : {
|
|
ManifestWithDescription{ vintf::VintfObject::GetDeviceHalManifest(), "device" },
|
|
ManifestWithDescription{ vintf::VintfObject::GetFrameworkHalManifest(), "framework" },
|
|
}) {
|
|
if (mwd.manifest == nullptr) {
|
|
LOG(ERROR) << "NULL VINTF MANIFEST!: " << mwd.description;
|
|
// note, we explicitly do not retry here, so that we can detect VINTF
|
|
// or other bugs (b/151696835)
|
|
continue;
|
|
}
|
|
if (func(mwd)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
struct AidlName {
|
|
std::string package;
|
|
std::string iface;
|
|
std::string instance;
|
|
|
|
static bool fill(const std::string& name, AidlName* aname) {
|
|
size_t firstSlash = name.find('/');
|
|
size_t lastDot = name.rfind('.', firstSlash);
|
|
if (firstSlash == std::string::npos || lastDot == std::string::npos) {
|
|
LOG(ERROR) << "VINTF HALs require names in the format type/instance (e.g. "
|
|
<< "some.package.foo.IFoo/default) but got: " << name;
|
|
return false;
|
|
}
|
|
aname->package = name.substr(0, lastDot);
|
|
aname->iface = name.substr(lastDot + 1, firstSlash - lastDot - 1);
|
|
aname->instance = name.substr(firstSlash + 1);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
static bool isVintfDeclared(const std::string& name) {
|
|
AidlName aname;
|
|
if (!AidlName::fill(name, &aname)) return false;
|
|
|
|
bool found = forEachManifest([&](const ManifestWithDescription& mwd) {
|
|
if (mwd.manifest->hasAidlInstance(aname.package, aname.iface, aname.instance)) {
|
|
LOG(INFO) << "Found " << name << " in " << mwd.description << " VINTF manifest.";
|
|
return true; // break
|
|
}
|
|
return false; // continue
|
|
});
|
|
|
|
if (!found) {
|
|
// Although it is tested, explicitly rebuilding qualified name, in case it
|
|
// becomes something unexpected.
|
|
LOG(ERROR) << "Could not find " << aname.package << "." << aname.iface << "/"
|
|
<< aname.instance << " in the VINTF manifest.";
|
|
}
|
|
|
|
return found;
|
|
}
|
|
|
|
static std::optional<std::string> getVintfUpdatableApex(const std::string& name) {
|
|
AidlName aname;
|
|
if (!AidlName::fill(name, &aname)) return std::nullopt;
|
|
|
|
std::optional<std::string> updatableViaApex;
|
|
|
|
forEachManifest([&](const ManifestWithDescription& mwd) {
|
|
mwd.manifest->forEachInstance([&](const auto& manifestInstance) {
|
|
if (manifestInstance.format() != vintf::HalFormat::AIDL) return true;
|
|
if (manifestInstance.package() != aname.package) return true;
|
|
if (manifestInstance.interface() != aname.iface) return true;
|
|
if (manifestInstance.instance() != aname.instance) return true;
|
|
updatableViaApex = manifestInstance.updatableViaApex();
|
|
return false; // break (libvintf uses opposite convention)
|
|
});
|
|
return false; // continue
|
|
});
|
|
|
|
return updatableViaApex;
|
|
}
|
|
|
|
static std::vector<std::string> getVintfInstances(const std::string& interface) {
|
|
size_t lastDot = interface.rfind('.');
|
|
if (lastDot == std::string::npos) {
|
|
LOG(ERROR) << "VINTF interfaces require names in Java package format (e.g. some.package.foo.IFoo) but got: " << interface;
|
|
return {};
|
|
}
|
|
const std::string package = interface.substr(0, lastDot);
|
|
const std::string iface = interface.substr(lastDot+1);
|
|
|
|
std::vector<std::string> ret;
|
|
(void)forEachManifest([&](const ManifestWithDescription& mwd) {
|
|
auto instances = mwd.manifest->getAidlInstances(package, iface);
|
|
ret.insert(ret.end(), instances.begin(), instances.end());
|
|
return false; // continue
|
|
});
|
|
|
|
return ret;
|
|
}
|
|
|
|
static bool meetsDeclarationRequirements(const sp<IBinder>& binder, const std::string& name) {
|
|
if (!Stability::requiresVintfDeclaration(binder)) {
|
|
return true;
|
|
}
|
|
|
|
return isVintfDeclared(name);
|
|
}
|
|
#endif // !VENDORSERVICEMANAGER
|
|
|
|
ServiceManager::ServiceManager(std::unique_ptr<Access>&& access) : mAccess(std::move(access)) {
|
|
// TODO(b/151696835): reenable performance hack when we solve bug, since with
|
|
// this hack and other fixes, it is unlikely we will see even an ephemeral
|
|
// failure when the manifest parse fails. The goal is that the manifest will
|
|
// be read incorrectly and cause the process trying to register a HAL to
|
|
// fail. If this is in fact an early boot kernel contention issue, then we
|
|
// will get no failure, and by its absence, be signalled to invest more
|
|
// effort in re-adding this performance hack.
|
|
// #ifndef VENDORSERVICEMANAGER
|
|
// // can process these at any times, don't want to delay first VINTF client
|
|
// std::thread([] {
|
|
// vintf::VintfObject::GetDeviceHalManifest();
|
|
// vintf::VintfObject::GetFrameworkHalManifest();
|
|
// }).detach();
|
|
// #endif // !VENDORSERVICEMANAGER
|
|
}
|
|
ServiceManager::~ServiceManager() {
|
|
// this should only happen in tests
|
|
|
|
for (const auto& [name, callbacks] : mNameToRegistrationCallback) {
|
|
CHECK(!callbacks.empty()) << name;
|
|
for (const auto& callback : callbacks) {
|
|
CHECK(callback != nullptr) << name;
|
|
}
|
|
}
|
|
|
|
for (const auto& [name, service] : mNameToService) {
|
|
CHECK(service.binder != nullptr) << name;
|
|
}
|
|
}
|
|
|
|
Status ServiceManager::getService(const std::string& name, sp<IBinder>* outBinder) {
|
|
*outBinder = tryGetService(name, true);
|
|
// returns ok regardless of result for legacy reasons
|
|
return Status::ok();
|
|
}
|
|
|
|
Status ServiceManager::checkService(const std::string& name, sp<IBinder>* outBinder) {
|
|
*outBinder = tryGetService(name, false);
|
|
// returns ok regardless of result for legacy reasons
|
|
return Status::ok();
|
|
}
|
|
|
|
sp<IBinder> ServiceManager::tryGetService(const std::string& name, bool startIfNotFound) {
|
|
auto ctx = mAccess->getCallingContext();
|
|
|
|
sp<IBinder> out;
|
|
Service* service = nullptr;
|
|
if (auto it = mNameToService.find(name); it != mNameToService.end()) {
|
|
service = &(it->second);
|
|
|
|
if (!service->allowIsolated) {
|
|
uid_t appid = multiuser_get_app_id(ctx.uid);
|
|
bool isIsolated = appid >= AID_ISOLATED_START && appid <= AID_ISOLATED_END;
|
|
|
|
if (isIsolated) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
out = service->binder;
|
|
}
|
|
|
|
if (!mAccess->canFind(ctx, name)) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (!out && startIfNotFound) {
|
|
tryStartService(name);
|
|
}
|
|
|
|
if (out) {
|
|
// Setting this guarantee each time we hand out a binder ensures that the client-checking
|
|
// loop knows about the event even if the client immediately drops the service
|
|
service->guaranteeClient = true;
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
bool isValidServiceName(const std::string& name) {
|
|
if (name.size() == 0) return false;
|
|
if (name.size() > 127) return false;
|
|
|
|
for (char c : name) {
|
|
if (c == '_' || c == '-' || c == '.' || c == '/') continue;
|
|
if (c >= 'a' && c <= 'z') continue;
|
|
if (c >= 'A' && c <= 'Z') continue;
|
|
if (c >= '0' && c <= '9') continue;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
Status ServiceManager::addService(const std::string& name, const sp<IBinder>& binder, bool allowIsolated, int32_t dumpPriority) {
|
|
auto ctx = mAccess->getCallingContext();
|
|
|
|
// apps cannot add services
|
|
if (multiuser_get_app_id(ctx.uid) >= AID_APP) {
|
|
return Status::fromExceptionCode(Status::EX_SECURITY);
|
|
}
|
|
|
|
if (!mAccess->canAdd(ctx, name)) {
|
|
return Status::fromExceptionCode(Status::EX_SECURITY);
|
|
}
|
|
|
|
if (binder == nullptr) {
|
|
return Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT);
|
|
}
|
|
|
|
if (!isValidServiceName(name)) {
|
|
LOG(ERROR) << "Invalid service name: " << name;
|
|
return Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT);
|
|
}
|
|
|
|
#ifndef VENDORSERVICEMANAGER
|
|
if (!meetsDeclarationRequirements(binder, name)) {
|
|
// already logged
|
|
return Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT);
|
|
}
|
|
#endif // !VENDORSERVICEMANAGER
|
|
|
|
// implicitly unlinked when the binder is removed
|
|
if (binder->remoteBinder() != nullptr &&
|
|
binder->linkToDeath(sp<ServiceManager>::fromExisting(this)) != OK) {
|
|
LOG(ERROR) << "Could not linkToDeath when adding " << name;
|
|
return Status::fromExceptionCode(Status::EX_ILLEGAL_STATE);
|
|
}
|
|
|
|
// Overwrite the old service if it exists
|
|
mNameToService[name] = Service {
|
|
.binder = binder,
|
|
.allowIsolated = allowIsolated,
|
|
.dumpPriority = dumpPriority,
|
|
.debugPid = ctx.debugPid,
|
|
};
|
|
|
|
auto it = mNameToRegistrationCallback.find(name);
|
|
if (it != mNameToRegistrationCallback.end()) {
|
|
for (const sp<IServiceCallback>& cb : it->second) {
|
|
mNameToService[name].guaranteeClient = true;
|
|
// permission checked in registerForNotifications
|
|
cb->onRegistration(name, binder);
|
|
}
|
|
}
|
|
|
|
return Status::ok();
|
|
}
|
|
|
|
Status ServiceManager::listServices(int32_t dumpPriority, std::vector<std::string>* outList) {
|
|
if (!mAccess->canList(mAccess->getCallingContext())) {
|
|
return Status::fromExceptionCode(Status::EX_SECURITY);
|
|
}
|
|
|
|
size_t toReserve = 0;
|
|
for (auto const& [name, service] : mNameToService) {
|
|
(void) name;
|
|
|
|
if (service.dumpPriority & dumpPriority) ++toReserve;
|
|
}
|
|
|
|
CHECK(outList->empty());
|
|
|
|
outList->reserve(toReserve);
|
|
for (auto const& [name, service] : mNameToService) {
|
|
(void) service;
|
|
|
|
if (service.dumpPriority & dumpPriority) {
|
|
outList->push_back(name);
|
|
}
|
|
}
|
|
|
|
return Status::ok();
|
|
}
|
|
|
|
Status ServiceManager::registerForNotifications(
|
|
const std::string& name, const sp<IServiceCallback>& callback) {
|
|
auto ctx = mAccess->getCallingContext();
|
|
|
|
if (!mAccess->canFind(ctx, name)) {
|
|
return Status::fromExceptionCode(Status::EX_SECURITY);
|
|
}
|
|
|
|
if (!isValidServiceName(name)) {
|
|
LOG(ERROR) << "Invalid service name: " << name;
|
|
return Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT);
|
|
}
|
|
|
|
if (callback == nullptr) {
|
|
return Status::fromExceptionCode(Status::EX_NULL_POINTER);
|
|
}
|
|
|
|
if (OK !=
|
|
IInterface::asBinder(callback)->linkToDeath(
|
|
sp<ServiceManager>::fromExisting(this))) {
|
|
LOG(ERROR) << "Could not linkToDeath when adding " << name;
|
|
return Status::fromExceptionCode(Status::EX_ILLEGAL_STATE);
|
|
}
|
|
|
|
mNameToRegistrationCallback[name].push_back(callback);
|
|
|
|
if (auto it = mNameToService.find(name); it != mNameToService.end()) {
|
|
const sp<IBinder>& binder = it->second.binder;
|
|
|
|
// never null if an entry exists
|
|
CHECK(binder != nullptr) << name;
|
|
callback->onRegistration(name, binder);
|
|
}
|
|
|
|
return Status::ok();
|
|
}
|
|
Status ServiceManager::unregisterForNotifications(
|
|
const std::string& name, const sp<IServiceCallback>& callback) {
|
|
auto ctx = mAccess->getCallingContext();
|
|
|
|
if (!mAccess->canFind(ctx, name)) {
|
|
return Status::fromExceptionCode(Status::EX_SECURITY);
|
|
}
|
|
|
|
bool found = false;
|
|
|
|
auto it = mNameToRegistrationCallback.find(name);
|
|
if (it != mNameToRegistrationCallback.end()) {
|
|
removeRegistrationCallback(IInterface::asBinder(callback), &it, &found);
|
|
}
|
|
|
|
if (!found) {
|
|
LOG(ERROR) << "Trying to unregister callback, but none exists " << name;
|
|
return Status::fromExceptionCode(Status::EX_ILLEGAL_STATE);
|
|
}
|
|
|
|
return Status::ok();
|
|
}
|
|
|
|
Status ServiceManager::isDeclared(const std::string& name, bool* outReturn) {
|
|
auto ctx = mAccess->getCallingContext();
|
|
|
|
if (!mAccess->canFind(ctx, name)) {
|
|
return Status::fromExceptionCode(Status::EX_SECURITY);
|
|
}
|
|
|
|
*outReturn = false;
|
|
|
|
#ifndef VENDORSERVICEMANAGER
|
|
*outReturn = isVintfDeclared(name);
|
|
#endif
|
|
return Status::ok();
|
|
}
|
|
|
|
binder::Status ServiceManager::getDeclaredInstances(const std::string& interface, std::vector<std::string>* outReturn) {
|
|
auto ctx = mAccess->getCallingContext();
|
|
|
|
std::vector<std::string> allInstances;
|
|
#ifndef VENDORSERVICEMANAGER
|
|
allInstances = getVintfInstances(interface);
|
|
#endif
|
|
|
|
outReturn->clear();
|
|
|
|
for (const std::string& instance : allInstances) {
|
|
if (mAccess->canFind(ctx, interface + "/" + instance)) {
|
|
outReturn->push_back(instance);
|
|
}
|
|
}
|
|
|
|
if (outReturn->size() == 0 && allInstances.size() != 0) {
|
|
return Status::fromExceptionCode(Status::EX_SECURITY);
|
|
}
|
|
|
|
return Status::ok();
|
|
}
|
|
|
|
Status ServiceManager::updatableViaApex(const std::string& name,
|
|
std::optional<std::string>* outReturn) {
|
|
auto ctx = mAccess->getCallingContext();
|
|
|
|
if (!mAccess->canFind(ctx, name)) {
|
|
return Status::fromExceptionCode(Status::EX_SECURITY);
|
|
}
|
|
|
|
*outReturn = std::nullopt;
|
|
|
|
#ifndef VENDORSERVICEMANAGER
|
|
*outReturn = getVintfUpdatableApex(name);
|
|
#endif
|
|
return Status::ok();
|
|
}
|
|
|
|
void ServiceManager::removeRegistrationCallback(const wp<IBinder>& who,
|
|
ServiceCallbackMap::iterator* it,
|
|
bool* found) {
|
|
std::vector<sp<IServiceCallback>>& listeners = (*it)->second;
|
|
|
|
for (auto lit = listeners.begin(); lit != listeners.end();) {
|
|
if (IInterface::asBinder(*lit) == who) {
|
|
if(found) *found = true;
|
|
lit = listeners.erase(lit);
|
|
} else {
|
|
++lit;
|
|
}
|
|
}
|
|
|
|
if (listeners.empty()) {
|
|
*it = mNameToRegistrationCallback.erase(*it);
|
|
} else {
|
|
(*it)++;
|
|
}
|
|
}
|
|
|
|
void ServiceManager::binderDied(const wp<IBinder>& who) {
|
|
for (auto it = mNameToService.begin(); it != mNameToService.end();) {
|
|
if (who == it->second.binder) {
|
|
it = mNameToService.erase(it);
|
|
} else {
|
|
++it;
|
|
}
|
|
}
|
|
|
|
for (auto it = mNameToRegistrationCallback.begin(); it != mNameToRegistrationCallback.end();) {
|
|
removeRegistrationCallback(who, &it, nullptr /*found*/);
|
|
}
|
|
|
|
for (auto it = mNameToClientCallback.begin(); it != mNameToClientCallback.end();) {
|
|
removeClientCallback(who, &it);
|
|
}
|
|
}
|
|
|
|
void ServiceManager::tryStartService(const std::string& name) {
|
|
ALOGI("Since '%s' could not be found, trying to start it as a lazy AIDL service",
|
|
name.c_str());
|
|
|
|
std::thread([=] {
|
|
if (!base::SetProperty("ctl.interface_start", "aidl/" + name)) {
|
|
LOG(INFO) << "Tried to start aidl service " << name
|
|
<< " as a lazy service, but was unable to. Usually this happens when a "
|
|
"service is not installed, but if the service is intended to be used as a "
|
|
"lazy service, then it may be configured incorrectly.";
|
|
}
|
|
}).detach();
|
|
}
|
|
|
|
Status ServiceManager::registerClientCallback(const std::string& name, const sp<IBinder>& service,
|
|
const sp<IClientCallback>& cb) {
|
|
if (cb == nullptr) {
|
|
return Status::fromExceptionCode(Status::EX_NULL_POINTER);
|
|
}
|
|
|
|
auto ctx = mAccess->getCallingContext();
|
|
if (!mAccess->canAdd(ctx, name)) {
|
|
return Status::fromExceptionCode(Status::EX_SECURITY);
|
|
}
|
|
|
|
auto serviceIt = mNameToService.find(name);
|
|
if (serviceIt == mNameToService.end()) {
|
|
LOG(ERROR) << "Could not add callback for nonexistent service: " << name;
|
|
return Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT);
|
|
}
|
|
|
|
if (serviceIt->second.debugPid != IPCThreadState::self()->getCallingPid()) {
|
|
LOG(WARNING) << "Only a server can register for client callbacks (for " << name << ")";
|
|
return Status::fromExceptionCode(Status::EX_UNSUPPORTED_OPERATION);
|
|
}
|
|
|
|
if (serviceIt->second.binder != service) {
|
|
LOG(WARNING) << "Tried to register client callback for " << name
|
|
<< " but a different service is registered under this name.";
|
|
return Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT);
|
|
}
|
|
|
|
if (OK !=
|
|
IInterface::asBinder(cb)->linkToDeath(sp<ServiceManager>::fromExisting(this))) {
|
|
LOG(ERROR) << "Could not linkToDeath when adding client callback for " << name;
|
|
return Status::fromExceptionCode(Status::EX_ILLEGAL_STATE);
|
|
}
|
|
|
|
mNameToClientCallback[name].push_back(cb);
|
|
|
|
return Status::ok();
|
|
}
|
|
|
|
void ServiceManager::removeClientCallback(const wp<IBinder>& who,
|
|
ClientCallbackMap::iterator* it) {
|
|
std::vector<sp<IClientCallback>>& listeners = (*it)->second;
|
|
|
|
for (auto lit = listeners.begin(); lit != listeners.end();) {
|
|
if (IInterface::asBinder(*lit) == who) {
|
|
lit = listeners.erase(lit);
|
|
} else {
|
|
++lit;
|
|
}
|
|
}
|
|
|
|
if (listeners.empty()) {
|
|
*it = mNameToClientCallback.erase(*it);
|
|
} else {
|
|
(*it)++;
|
|
}
|
|
}
|
|
|
|
ssize_t ServiceManager::Service::getNodeStrongRefCount() {
|
|
sp<BpBinder> bpBinder = sp<BpBinder>::fromExisting(binder->remoteBinder());
|
|
if (bpBinder == nullptr) return -1;
|
|
|
|
return ProcessState::self()->getStrongRefCountForNode(bpBinder);
|
|
}
|
|
|
|
void ServiceManager::handleClientCallbacks() {
|
|
for (const auto& [name, service] : mNameToService) {
|
|
handleServiceClientCallback(name, true);
|
|
}
|
|
}
|
|
|
|
ssize_t ServiceManager::handleServiceClientCallback(const std::string& serviceName,
|
|
bool isCalledOnInterval) {
|
|
auto serviceIt = mNameToService.find(serviceName);
|
|
if (serviceIt == mNameToService.end() || mNameToClientCallback.count(serviceName) < 1) {
|
|
return -1;
|
|
}
|
|
|
|
Service& service = serviceIt->second;
|
|
ssize_t count = service.getNodeStrongRefCount();
|
|
|
|
// binder driver doesn't support this feature
|
|
if (count == -1) return count;
|
|
|
|
bool hasClients = count > 1; // this process holds a strong count
|
|
|
|
if (service.guaranteeClient) {
|
|
// we have no record of this client
|
|
if (!service.hasClients && !hasClients) {
|
|
sendClientCallbackNotifications(serviceName, true);
|
|
}
|
|
|
|
// guarantee is temporary
|
|
service.guaranteeClient = false;
|
|
}
|
|
|
|
// only send notifications if this was called via the interval checking workflow
|
|
if (isCalledOnInterval) {
|
|
if (hasClients && !service.hasClients) {
|
|
// client was retrieved in some other way
|
|
sendClientCallbackNotifications(serviceName, true);
|
|
}
|
|
|
|
// there are no more clients, but the callback has not been called yet
|
|
if (!hasClients && service.hasClients) {
|
|
sendClientCallbackNotifications(serviceName, false);
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
void ServiceManager::sendClientCallbackNotifications(const std::string& serviceName, bool hasClients) {
|
|
auto serviceIt = mNameToService.find(serviceName);
|
|
if (serviceIt == mNameToService.end()) {
|
|
LOG(WARNING) << "sendClientCallbackNotifications could not find service " << serviceName;
|
|
return;
|
|
}
|
|
Service& service = serviceIt->second;
|
|
|
|
CHECK(hasClients != service.hasClients) << "Record shows: " << service.hasClients
|
|
<< " so we can't tell clients again that we have client: " << hasClients;
|
|
|
|
LOG(INFO) << "Notifying " << serviceName << " they have clients: " << hasClients;
|
|
|
|
auto ccIt = mNameToClientCallback.find(serviceName);
|
|
CHECK(ccIt != mNameToClientCallback.end())
|
|
<< "sendClientCallbackNotifications could not find callbacks for service ";
|
|
|
|
for (const auto& callback : ccIt->second) {
|
|
callback->onClients(service.binder, hasClients);
|
|
}
|
|
|
|
service.hasClients = hasClients;
|
|
}
|
|
|
|
Status ServiceManager::tryUnregisterService(const std::string& name, const sp<IBinder>& binder) {
|
|
if (binder == nullptr) {
|
|
return Status::fromExceptionCode(Status::EX_NULL_POINTER);
|
|
}
|
|
|
|
auto ctx = mAccess->getCallingContext();
|
|
if (!mAccess->canAdd(ctx, name)) {
|
|
return Status::fromExceptionCode(Status::EX_SECURITY);
|
|
}
|
|
|
|
auto serviceIt = mNameToService.find(name);
|
|
if (serviceIt == mNameToService.end()) {
|
|
LOG(WARNING) << "Tried to unregister " << name
|
|
<< ", but that service wasn't registered to begin with.";
|
|
return Status::fromExceptionCode(Status::EX_ILLEGAL_STATE);
|
|
}
|
|
|
|
if (serviceIt->second.debugPid != IPCThreadState::self()->getCallingPid()) {
|
|
LOG(WARNING) << "Only a server can unregister itself (for " << name << ")";
|
|
return Status::fromExceptionCode(Status::EX_UNSUPPORTED_OPERATION);
|
|
}
|
|
|
|
sp<IBinder> storedBinder = serviceIt->second.binder;
|
|
|
|
if (binder != storedBinder) {
|
|
LOG(WARNING) << "Tried to unregister " << name
|
|
<< ", but a different service is registered under this name.";
|
|
return Status::fromExceptionCode(Status::EX_ILLEGAL_STATE);
|
|
}
|
|
|
|
if (serviceIt->second.guaranteeClient) {
|
|
LOG(INFO) << "Tried to unregister " << name << ", but there is about to be a client.";
|
|
return Status::fromExceptionCode(Status::EX_ILLEGAL_STATE);
|
|
}
|
|
|
|
int clients = handleServiceClientCallback(name, false);
|
|
|
|
// clients < 0: feature not implemented or other error. Assume clients.
|
|
// Otherwise:
|
|
// - kernel driver will hold onto one refcount (during this transaction)
|
|
// - servicemanager has a refcount (guaranteed by this transaction)
|
|
// So, if clients > 2, then at least one other service on the system must hold a refcount.
|
|
if (clients < 0 || clients > 2) {
|
|
// client callbacks are either disabled or there are other clients
|
|
LOG(INFO) << "Tried to unregister " << name << ", but there are clients: " << clients;
|
|
// Set this flag to ensure the clients are acknowledged in the next callback
|
|
serviceIt->second.guaranteeClient = true;
|
|
return Status::fromExceptionCode(Status::EX_ILLEGAL_STATE);
|
|
}
|
|
|
|
mNameToService.erase(name);
|
|
|
|
return Status::ok();
|
|
}
|
|
|
|
Status ServiceManager::getServiceDebugInfo(std::vector<ServiceDebugInfo>* outReturn) {
|
|
if (!mAccess->canList(mAccess->getCallingContext())) {
|
|
return Status::fromExceptionCode(Status::EX_SECURITY);
|
|
}
|
|
|
|
outReturn->reserve(mNameToService.size());
|
|
for (auto const& [name, service] : mNameToService) {
|
|
ServiceDebugInfo info;
|
|
info.name = name;
|
|
info.debugPid = service.debugPid;
|
|
|
|
outReturn->push_back(std::move(info));
|
|
}
|
|
|
|
return Status::ok();
|
|
}
|
|
|
|
} // namespace android
|