Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e9495af1 authored by Steven Moreland's avatar Steven Moreland
Browse files

Revert "Binder: support storing interface stability" 

This reverts commit 5981dcbe.

Reason for revert: breaking hawk (seems to be because 32-bit
    Parcel changed size 60 -> 64). Will revert and reland w/o
    changing the size.

Bug: 137348710

Change-Id: I24f5c443118703c5ef3dbb479288332e7bc5a08c
parent 5981dcbe

libs/binder/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -70,7 +70,6 @@ cc_library_shared { 
        "ProcessInfoService.cpp",

        "ProcessState.cpp",

        "Static.cpp",

        "Stability.cpp",

        "Status.cpp",

        "TextOutput.cpp",

        "IpPrefix.cpp",

libs/binder/Binder.cpp

+0 −3
Original line number Diff line number Diff line
@@ -124,7 +124,6 @@ status_t BBinder::transact( 
    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)

{

    data.setDataPosition(0);

    data.setTransactingBinder(this);



    status_t err = NO_ERROR;

    switch (code) {
@@ -136,10 +135,8 @@ status_t BBinder::transact( 
            break;

    }



    // In case this is being transacted on in the same process.

    if (reply != nullptr) {

        reply->setDataPosition(0);

        reply->setTransactingBinder(this);

    }



    return err;

libs/binder/BpBinder.cpp

+0 −5
Original line number Diff line number Diff line
@@ -216,11 +216,6 @@ status_t BpBinder::transact( 
        status_t status = IPCThreadState::self()->transact(

            mHandle, code, data, reply, flags);

        if (status == DEAD_OBJECT) mAlive = 0;



        if (reply != nullptr) {

            reply->setTransactingBinder(this);

        }



        return status;

    }

libs/binder/Parcel.cpp

+26 −45
Original line number Diff line number Diff line
@@ -164,34 +164,14 @@ static void release_object(const sp<ProcessState>& proc, 
    ALOGE("Invalid object type 0x%08x", obj.hdr.type);

}



status_t Parcel::finishFlattenBinder(

    const sp<IBinder>& binder, const flat_binder_object& flat)

inline static status_t finish_flatten_binder(

    const sp<IBinder>& /*binder*/, const flat_binder_object& flat, Parcel* out)

{

    status_t status = writeObject(flat, false);

    if (status != OK) return status;



    return writeInt32(internal::Stability::get(binder.get()));

    return out->writeObject(flat, false);

}



status_t Parcel::finishUnflattenBinder(

    const sp<IBinder>& binder, sp<IBinder>* out) const

{

    int32_t stability;

    status_t status = readInt32(&stability);

    if (status != OK) return status;



    if (!internal::Stability::check(stability, mRequiredStability)) {

        return BAD_TYPE;

    }



    status = internal::Stability::set(binder.get(), stability);

    if (status != OK) return status;



    *out = binder;

    return OK;

}



status_t Parcel::flattenBinder(const sp<IBinder>& binder)

static status_t flatten_binder(const sp<ProcessState>& /*proc*/,

    const sp<IBinder>& binder, Parcel* out)

{

    flat_binder_object obj;
@@ -229,24 +209,30 @@ status_t Parcel::flattenBinder(const sp<IBinder>& binder) 
        obj.cookie = 0;

    }



    return finishFlattenBinder(binder, obj);

    return finish_flatten_binder(binder, obj, out);

}



inline static status_t finish_unflatten_binder(

    BpBinder* /*proxy*/, const flat_binder_object& /*flat*/,

    const Parcel& /*in*/)

{

    return NO_ERROR;

}



status_t Parcel::unflattenBinder(sp<IBinder>* out) const

static status_t unflatten_binder(const sp<ProcessState>& proc,

    const Parcel& in, sp<IBinder>* out)

{

    const flat_binder_object* flat = readObject(false);

    const flat_binder_object* flat = in.readObject(false);



    if (flat) {

        switch (flat->hdr.type) {

            case BINDER_TYPE_BINDER: {

                sp<IBinder> binder = reinterpret_cast<IBinder*>(flat->cookie);

                return finishUnflattenBinder(binder, out);

            }

            case BINDER_TYPE_HANDLE: {

                sp<IBinder> binder =

                    ProcessState::self()->getStrongProxyForHandle(flat->handle);

                return finishUnflattenBinder(binder, out);

            }

            case BINDER_TYPE_BINDER:

                *out = reinterpret_cast<IBinder*>(flat->cookie);

                return finish_unflatten_binder(nullptr, *flat, in);

            case BINDER_TYPE_HANDLE:

                *out = proc->getStrongProxyForHandle(flat->handle);

                return finish_unflatten_binder(

                    static_cast<BpBinder*>(out->get()), *flat, in);

        }

    }

    return BAD_TYPE;
@@ -351,10 +337,6 @@ status_t Parcel::setDataCapacity(size_t size) 
    return NO_ERROR;

}



void Parcel::setTransactingBinder(const sp<IBinder>& binder) const {

    mRequiredStability = internal::Stability::get(binder.get());

}



status_t Parcel::setData(const uint8_t* buffer, size_t len)

{

    if (len > INT32_MAX) {
@@ -1050,7 +1032,7 @@ status_t Parcel::writeString16(const char16_t* str, size_t len) 


status_t Parcel::writeStrongBinder(const sp<IBinder>& val)

{

    return flattenBinder(val);

    return flatten_binder(ProcessState::self(), val, this);

}



status_t Parcel::writeStrongBinderVector(const std::vector<sp<IBinder>>& val)
@@ -1996,7 +1978,7 @@ status_t Parcel::readStrongBinder(sp<IBinder>* val) const 


status_t Parcel::readNullableStrongBinder(sp<IBinder>* val) const

{

    return unflattenBinder(val);

    return unflatten_binder(ProcessState::self(), *this, val);

}



sp<IBinder> Parcel::readStrongBinder() const
@@ -2700,10 +2682,9 @@ void Parcel::initState() 
    mObjectsCapacity = 0;

    mNextObjectHint = 0;

    mObjectsSorted = false;

    mAllowFds = true;

    mHasFds = false;

    mFdsKnown = true;

    mRequiredStability = internal::Stability::UNDECLARED;

    mAllowFds = true;

    mOwner = nullptr;

    mOpenAshmemSize = 0;

    mWorkSourceRequestHeaderPosition = 0;

libs/binder/Stability.cpp

deleted100644 → 0
+0 −117
Original line number Diff line number Diff line 
/*

 * 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 <binder/Stability.h>



namespace android {

namespace internal {



void Stability::markCompilationUnit(IBinder* binder) {

#ifdef __ANDROID_VNDK__

constexpr Stability::Level kLocalStability = Stability::Level::VENDOR;

#else

constexpr Stability::Level kLocalStability = Stability::Level::SYSTEM;

#endif



    status_t result = set(binder, kLocalStability);

    LOG_ALWAYS_FATAL_IF(result != OK, "Should only mark known object.");

}



void Stability::markVintf(IBinder* binder) {

    status_t result = set(binder, Level::VINTF);

    LOG_ALWAYS_FATAL_IF(result != OK, "Should only mark known object.");

}



status_t Stability::set(IBinder* binder, int32_t stability) {

    Level currentStability = get(binder);



    // null binder is always written w/ 'UNDECLARED' stability

    if (binder == nullptr) {

        if (stability == UNDECLARED) {

            return OK;

        } else {

            ALOGE("Null binder written with stability %s.", stabilityString(stability).c_str());

            return BAD_TYPE;

        }

    }



    if (!isDeclaredStability(stability)) {

        // There are UNDECLARED sets because some binder interfaces don't set their stability, and

        // then UNDECLARED stability is sent on the other side.

        if (stability != UNDECLARED) {

            ALOGE("Can only set known stability, not %d.", stability);

            return BAD_TYPE;

        }

    }



    if (currentStability != Level::UNDECLARED && currentStability != stability) {

        ALOGE("Interface being set with %s but it is already marked as %s.",

            stabilityString(stability).c_str(), stabilityString(stability).c_str());

        return BAD_TYPE;

    }



    if (currentStability == stability) return OK;



    binder->attachObject(

        reinterpret_cast<void*>(&Stability::get),

        reinterpret_cast<void*>(stability),

        nullptr /*cleanupCookie*/,

        nullptr /*cleanup function*/);



    return OK;

}



Stability::Level Stability::get(IBinder* binder) {

    if (binder == nullptr) return UNDECLARED;



    return static_cast<Level>(reinterpret_cast<intptr_t>(

        binder->findObject(reinterpret_cast<void*>(&Stability::get))));

}



bool Stability::check(int32_t provided, Level required) {

    bool stable = (provided & required) == required;



    if (!isDeclaredStability(provided) && provided != UNDECLARED) {

        ALOGE("Unknown stability when checking interface stability %d.", provided);



        stable = false;

    }



    if (!stable) {

        ALOGE("Interface with %s cannot accept interface with %s.",

            stabilityString(required).c_str(),

            stabilityString(provided).c_str());

    }



    return stable;

}



bool Stability::isDeclaredStability(int32_t stability) {

    return stability == VENDOR || stability == SYSTEM || stability == VINTF;

}



std::string Stability::stabilityString(int32_t stability) {

    switch (stability) {

        case Level::UNDECLARED: return "undeclared stability";

        case Level::VENDOR: return "vendor stability";

        case Level::SYSTEM: return "system stability";

        case Level::VINTF: return "vintf stability";

    }

    return "unknown stability " + std::to_string(stability);

}



}  // namespace internal

}  // namespace stability
 
 No newline at end of file