blob: 6d26414c823caba074cfdf8d00919e769b85c47c [file] [log] [blame]
/*
* Copyright (C) 2005 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 <hwbinder/Binder.h>
#include <android-base/macros.h>
#include <cutils/android_filesystem_config.h>
#include <cutils/multiuser.h>
#include <hwbinder/BpHwBinder.h>
#include <hwbinder/IInterface.h>
#include <hwbinder/IPCThreadState.h>
#include <hwbinder/Parcel.h>
#include <utils/Log.h>
#include <utils/misc.h>
#include <linux/sched.h>
#include <stdio.h>
#include <atomic>
namespace android {
namespace hardware {
// ---------------------------------------------------------------------------
IBinder::IBinder()
: RefBase()
{
}
IBinder::~IBinder()
{
}
// ---------------------------------------------------------------------------
BHwBinder* IBinder::localBinder()
{
return nullptr;
}
BpHwBinder* IBinder::remoteBinder()
{
return nullptr;
}
bool IBinder::checkSubclass(const void* /*subclassID*/) const
{
return false;
}
// ---------------------------------------------------------------------------
class BHwBinder::Extras
{
public:
// unlocked objects
bool mRequestingSid = false;
// for below objects
Mutex mLock;
BpHwBinder::ObjectManager mObjects;
};
// ---------------------------------------------------------------------------
BHwBinder::BHwBinder() : mSchedPolicy(SCHED_NORMAL), mSchedPriority(0), mExtras(nullptr)
{
}
int BHwBinder::getMinSchedulingPolicy() {
return mSchedPolicy;
}
int BHwBinder::getMinSchedulingPriority() {
return mSchedPriority;
}
bool BHwBinder::isRequestingSid() {
Extras* e = mExtras.load(std::memory_order_acquire);
return e && e->mRequestingSid;
}
void BHwBinder::setRequestingSid(bool requestingSid) {
Extras* e = mExtras.load(std::memory_order_acquire);
if (!e) {
// default is false. Most things don't need sids, so avoiding allocations when possible.
if (!requestingSid) {
return;
}
e = getOrCreateExtras();
if (!e) return; // out of memory
}
e->mRequestingSid = requestingSid;
}
status_t BHwBinder::transact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags, TransactCallback callback)
{
data.setDataPosition(0);
if (reply != nullptr && (flags & FLAG_CLEAR_BUF)) {
reply->markSensitive();
}
// extra comment to try to force running all tests
if (UNLIKELY(code == HIDL_DEBUG_TRANSACTION)) {
uid_t uid = IPCThreadState::self()->getCallingUid();
if (multiuser_get_app_id(uid) >= AID_APP_START) {
ALOGE("Can not call IBase::debug from apps");
return PERMISSION_DENIED;
}
}
return onTransact(code, data, reply, flags, [&](auto& replyParcel) {
replyParcel.setDataPosition(0);
if (callback != nullptr) {
callback(replyParcel);
}
});
}
status_t BHwBinder::linkToDeath(
const sp<DeathRecipient>& /*recipient*/, void* /*cookie*/,
uint32_t /*flags*/)
{
return INVALID_OPERATION;
}
status_t BHwBinder::unlinkToDeath(
const wp<DeathRecipient>& /*recipient*/, void* /*cookie*/,
uint32_t /*flags*/, wp<DeathRecipient>* /*outRecipient*/)
{
return INVALID_OPERATION;
}
void BHwBinder::attachObject(
const void* objectID, void* object, void* cleanupCookie,
object_cleanup_func func)
{
Extras* e = getOrCreateExtras();
if (!e) return; // out of memory
AutoMutex _l(e->mLock);
e->mObjects.attach(objectID, object, cleanupCookie, func);
}
void* BHwBinder::findObject(const void* objectID) const
{
Extras* e = mExtras.load(std::memory_order_acquire);
if (!e) return nullptr;
AutoMutex _l(e->mLock);
return e->mObjects.find(objectID);
}
void BHwBinder::detachObject(const void* objectID)
{
Extras* e = mExtras.load(std::memory_order_acquire);
if (!e) return;
AutoMutex _l(e->mLock);
e->mObjects.detach(objectID);
}
BHwBinder* BHwBinder::localBinder()
{
return this;
}
BHwBinder::~BHwBinder()
{
Extras* e = mExtras.load(std::memory_order_relaxed);
if (e) delete e;
}
status_t BHwBinder::onTransact(
uint32_t /*code*/, const Parcel& /*data*/, Parcel* /*reply*/, uint32_t /*flags*/,
TransactCallback /*callback*/)
{
return UNKNOWN_TRANSACTION;
}
BHwBinder::Extras* BHwBinder::getOrCreateExtras()
{
Extras* e = mExtras.load(std::memory_order_acquire);
if (!e) {
e = new Extras;
Extras* expected = nullptr;
if (!mExtras.compare_exchange_strong(expected, e,
std::memory_order_release,
std::memory_order_acquire)) {
delete e;
e = expected; // Filled in by CAS
}
if (e == nullptr) return nullptr; // out of memory
}
return e;
}
// ---------------------------------------------------------------------------
enum {
// This is used to transfer ownership of the remote binder from
// the BpHwRefBase object holding it (when it is constructed), to the
// owner of the BpHwRefBase object when it first acquires that BpHwRefBase.
kRemoteAcquired = 0x00000001
};
BpHwRefBase::BpHwRefBase(const sp<IBinder>& o)
: mRemote(o.get()), mRefs(nullptr), mState(0)
{
if (mRemote) {
mRemote->incStrong(this); // Removed on first IncStrong().
}
}
BpHwRefBase::~BpHwRefBase()
{
if (mRemote) {
if (!(mState.load(std::memory_order_relaxed)&kRemoteAcquired)) {
mRemote->decStrong(this);
}
}
}
void BpHwRefBase::onFirstRef()
{
mState.fetch_or(kRemoteAcquired, std::memory_order_relaxed);
}
void BpHwRefBase::onLastStrongRef(const void* /*id*/)
{
if (mRemote) {
mRemote->decStrong(this);
}
}
bool BpHwRefBase::onIncStrongAttempted(uint32_t /*flags*/, const void* /*id*/)
{
return false;
}
// ---------------------------------------------------------------------------
} // namespace hardware
} // namespace android