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

Commit 985ccbe4 authored by Steven Moreland's avatar Steven Moreland Committed by Automerger Merge Worker
Browse files

Merge changes I069e633f,I8cac77d6 into main am: ded9bda9 am: 9d656f46 am:... 

Merge changes I069e633f,I8cac77d6 into main am: ded9bda9 am: 9d656f46 am: c6d6027c am: 4b5fe403

Original change: https://android-review.googlesource.com/c/platform/frameworks/native/+/2681019



Change-Id: I42aec60fb65f0aa856fae1b1260ca2033f7873d8
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 0c78ea65 4b5fe403

libs/binder/tests/binderRpcTest.cpp

+68 −19
Original line number Diff line number Diff line
@@ -249,12 +249,12 @@ std::unique_ptr<ProcessSession> BinderRpc::createRpcTestSocketServerProcessEtc( 
        CHECK_EQ(options.numIncomingConnectionsBySession.size(), options.numSessions);

    }



    SocketType socketType = std::get<0>(GetParam());

    RpcSecurity rpcSecurity = std::get<1>(GetParam());

    uint32_t clientVersion = std::get<2>(GetParam());

    uint32_t serverVersion = std::get<3>(GetParam());

    bool singleThreaded = std::get<4>(GetParam());

    bool noKernel = std::get<5>(GetParam());

    SocketType socketType = GetParam().type;

    RpcSecurity rpcSecurity = GetParam().security;

    uint32_t clientVersion = GetParam().clientVersion;

    uint32_t serverVersion = GetParam().serverVersion;

    bool singleThreaded = GetParam().singleThreaded;

    bool noKernel = GetParam().noKernel;



    std::string path = android::base::GetExecutableDirectory();

    auto servicePath = android::base::StringPrintf("%s/binder_rpc_test_service%s%s", path.c_str(),
@@ -1121,12 +1121,27 @@ TEST_P(BinderRpc, Fds) { 
}



#ifdef BINDER_RPC_TO_TRUSTY_TEST

INSTANTIATE_TEST_CASE_P(Trusty, BinderRpc,

                        ::testing::Combine(::testing::Values(SocketType::TIPC),

                                           ::testing::Values(RpcSecurity::RAW),

                                           ::testing::ValuesIn(testVersions()),

                                           ::testing::ValuesIn(testVersions()),

                                           ::testing::Values(true), ::testing::Values(true)),



static std::vector<BinderRpc::ParamType> getTrustyBinderRpcParams() {

    std::vector<BinderRpc::ParamType> ret;



    for (const auto& clientVersion : testVersions()) {

        for (const auto& serverVersion : testVersions()) {

            ret.push_back(BinderRpc::ParamType{

                    .type = SocketType::TIPC,

                    .security = RpcSecurity::RAW,

                    .clientVersion = clientVersion,

                    .serverVersion = serverVersion,

                    .singleThreaded = true,

                    .noKernel = true,

            });

        }

    }



    return ret;

}



INSTANTIATE_TEST_CASE_P(Trusty, BinderRpc, ::testing::ValuesIn(getTrustyBinderRpcParams()),

                        BinderRpc::PrintParamInfo);

#else // BINDER_RPC_TO_TRUSTY_TEST

bool testSupportVsockLoopback() {
@@ -1246,13 +1261,47 @@ static std::vector<SocketType> testSocketTypes(bool hasPreconnected = true) { 
    return ret;

}



INSTANTIATE_TEST_CASE_P(PerSocket, BinderRpc,

                        ::testing::Combine(::testing::ValuesIn(testSocketTypes()),

                                           ::testing::ValuesIn(RpcSecurityValues()),

                                           ::testing::ValuesIn(testVersions()),

                                           ::testing::ValuesIn(testVersions()),

                                           ::testing::Values(false, true),

                                           ::testing::Values(false, true)),

static std::vector<BinderRpc::ParamType> getBinderRpcParams() {

    std::vector<BinderRpc::ParamType> ret;



    constexpr bool full = false;



    for (const auto& type : testSocketTypes()) {

        if (full || type == SocketType::UNIX) {

            for (const auto& security : RpcSecurityValues()) {

                for (const auto& clientVersion : testVersions()) {

                    for (const auto& serverVersion : testVersions()) {

                        for (bool singleThreaded : {false, true}) {

                            for (bool noKernel : {false, true}) {

                                ret.push_back(BinderRpc::ParamType{

                                        .type = type,

                                        .security = security,

                                        .clientVersion = clientVersion,

                                        .serverVersion = serverVersion,

                                        .singleThreaded = singleThreaded,

                                        .noKernel = noKernel,

                                });

                            }

                        }

                    }

                }

            }

        } else {

            ret.push_back(BinderRpc::ParamType{

                    .type = type,

                    .security = RpcSecurity::RAW,

                    .clientVersion = RPC_WIRE_PROTOCOL_VERSION,

                    .serverVersion = RPC_WIRE_PROTOCOL_VERSION,

                    .singleThreaded = false,

                    .noKernel = false,

            });

        }

    }



    return ret;

}



INSTANTIATE_TEST_CASE_P(PerSocket, BinderRpc, ::testing::ValuesIn(getBinderRpcParams()),

                        BinderRpc::PrintParamInfo);



class BinderRpcServerRootObject

libs/binder/tests/binderRpcTestFixture.h

+22 −13
Original line number Diff line number Diff line
@@ -106,15 +106,23 @@ struct BinderRpcTestProcessSession { 
    }

};



class BinderRpc : public ::testing::TestWithParam<

                          std::tuple<SocketType, RpcSecurity, uint32_t, uint32_t, bool, bool>> {

struct BinderRpcParam {

    SocketType type;

    RpcSecurity security;

    uint32_t clientVersion;

    uint32_t serverVersion;

    bool singleThreaded;

    bool noKernel;

};

class BinderRpc : public ::testing::TestWithParam<BinderRpcParam> {

public:

    SocketType socketType() const { return std::get<0>(GetParam()); }

    RpcSecurity rpcSecurity() const { return std::get<1>(GetParam()); }

    uint32_t clientVersion() const { return std::get<2>(GetParam()); }

    uint32_t serverVersion() const { return std::get<3>(GetParam()); }

    bool serverSingleThreaded() const { return std::get<4>(GetParam()); }

    bool noKernel() const { return std::get<5>(GetParam()); }

    // TODO: avoid unnecessary layer of indirection

    SocketType socketType() const { return GetParam().type; }

    RpcSecurity rpcSecurity() const { return GetParam().security; }

    uint32_t clientVersion() const { return GetParam().clientVersion; }

    uint32_t serverVersion() const { return GetParam().serverVersion; }

    bool serverSingleThreaded() const { return GetParam().singleThreaded; }

    bool noKernel() const { return GetParam().noKernel; }



    bool clientOrServerSingleThreaded() const {

        return !kEnableRpcThreads || serverSingleThreaded();
@@ -148,15 +156,16 @@ public: 
    }



    static std::string PrintParamInfo(const testing::TestParamInfo<ParamType>& info) {

        auto [type, security, clientVersion, serverVersion, singleThreaded, noKernel] = info.param;

        auto ret = PrintToString(type) + "_" + newFactory(security)->toCString() + "_clientV" +

                std::to_string(clientVersion) + "_serverV" + std::to_string(serverVersion);

        if (singleThreaded) {

        auto ret = PrintToString(info.param.type) + "_" +

                newFactory(info.param.security)->toCString() + "_clientV" +

                std::to_string(info.param.clientVersion) + "_serverV" +

                std::to_string(info.param.serverVersion);

        if (info.param.singleThreaded) {

            ret += "_single_threaded";

        } else {

            ret += "_multi_threaded";

        }

        if (noKernel) {

        if (info.param.noKernel) {

            ret += "_no_kernel";

        } else {

            ret += "_with_kernel";

libs/binder/tests/binderRpcTestTrusty.cpp

+24 −9
Original line number Diff line number Diff line
@@ -57,9 +57,9 @@ std::unique_ptr<ProcessSession> BinderRpc::createRpcTestSocketServerProcessEtc( 
                                    [](size_t n) { return n != 0; }),

                        "Non-zero incoming connections on Trusty");



    RpcSecurity rpcSecurity = std::get<1>(GetParam());

    uint32_t clientVersion = std::get<2>(GetParam());

    uint32_t serverVersion = std::get<3>(GetParam());

    RpcSecurity rpcSecurity = GetParam().security;

    uint32_t clientVersion = GetParam().clientVersion;

    uint32_t serverVersion = GetParam().serverVersion;



    auto ret = std::make_unique<TrustyProcessSession>();
@@ -89,12 +89,27 @@ std::unique_ptr<ProcessSession> BinderRpc::createRpcTestSocketServerProcessEtc( 
    return ret;

}



INSTANTIATE_TEST_CASE_P(Trusty, BinderRpc,

                        ::testing::Combine(::testing::Values(SocketType::TIPC),

                                           ::testing::Values(RpcSecurity::RAW),

                                           ::testing::ValuesIn(testVersions()),

                                           ::testing::ValuesIn(testVersions()),

                                           ::testing::Values(false), ::testing::Values(true)),

static std::vector<BinderRpc::ParamType> getTrustyBinderRpcParams() {

    std::vector<BinderRpc::ParamType> ret;



    for (const auto& clientVersion : testVersions()) {

        for (const auto& serverVersion : testVersions()) {

            ret.push_back(BinderRpc::ParamType{

                    .type = SocketType::TIPC,

                    .security = RpcSecurity::RAW,

                    .clientVersion = clientVersion,

                    .serverVersion = serverVersion,

                    // TODO: should we test both versions here?

                    .singleThreaded = false,

                    .noKernel = true,

            });

        }

    }



    return ret;

}



INSTANTIATE_TEST_CASE_P(Trusty, BinderRpc, ::testing::ValuesIn(getTrustyBinderRpcParams()),

                        BinderRpc::PrintParamInfo);



} // namespace android

libs/binder/tests/binderRpcUniversalTests.cpp

+1 −1
Original line number Diff line number Diff line
@@ -84,7 +84,7 @@ TEST_P(BinderRpc, SeparateRootObject) { 
        GTEST_SKIP() << "This test requires a multi-threaded service";

    }



    SocketType type = std::get<0>(GetParam());

    SocketType type = GetParam().type;

    if (type == SocketType::PRECONNECTED || type == SocketType::UNIX ||

        type == SocketType::UNIX_BOOTSTRAP || type == SocketType::UNIX_RAW) {

        // we can't get port numbers for unix sockets