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

Commit b29dea66 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Revert "Revert "libbinder: Build and run binderRpcTest on Trusty""" am: 1eb3edea 

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



Change-Id: I150c195733027d1e96cf20861b57d5ffa9d791c0
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 7b4342a8 1eb3edea

libs/binder/Android.bp

+2 −0
Original line number Diff line number Diff line
@@ -215,6 +215,8 @@ cc_library_headers { 


cc_defaults {

    name: "trusty_mock_defaults",

    vendor_available: true,

    host_supported: true,



    header_libs: [

        "trusty_mock_headers",

libs/binder/tests/Android.bp

+26 −0
Original line number Diff line number Diff line
@@ -370,6 +370,31 @@ cc_binary { 
    ],

}



cc_binary {

    name: "binderRpcTest_on_trusty_mock",

    defaults: [

        "trusty_mock_defaults",

    ],



    srcs: [

        "binderRpcUniversalTests.cpp",

        "binderRpcTestCommon.cpp",

        "binderRpcTestTrusty.cpp",

    ],



    shared_libs: [

        "libbinder_on_trusty_mock",

        "libbase",

        "libutils",

        "libcutils",

    ],



    static_libs: [

        "binderRpcTestIface-cpp",

        "libgtest",

    ],

}



cc_test {

    name: "binderRpcTest",

    defaults: [
@@ -382,6 +407,7 @@ cc_test { 
    required: [

        "libbinder_on_trusty_mock",

        "binderRpcTestService_on_trusty_mock",

        "binderRpcTest_on_trusty_mock",

    ],

}

libs/binder/tests/binderRpcTestTrusty.cpp

0 → 100644
+105 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2022 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_TAG "binderRpcTest"



#include <android-base/stringprintf.h>

#include <binder/RpcTransportTipcTrusty.h>

#include <trusty-gtest.h>

#include <trusty_ipc.h>



#include "binderRpcTestFixture.h"



namespace android {



// Destructors need to be defined, even if pure virtual

ProcessSession::~ProcessSession() {}



class TrustyProcessSession : public ProcessSession {

public:

    ~TrustyProcessSession() override {}



    void setCustomExitStatusCheck(std::function<void(int wstatus)> /*f*/) override {

        LOG_ALWAYS_FATAL("setCustomExitStatusCheck() not supported");

    }



    void terminate() override { LOG_ALWAYS_FATAL("terminate() not supported"); }

};



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

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

    auto ret = PrintToString(type) + "_clientV" + std::to_string(clientVersion) + "_serverV" +

            std::to_string(serverVersion);

    if (singleThreaded) {

        ret += "_single_threaded";

    }

    if (noKernel) {

        ret += "_no_kernel";

    }

    return ret;

}



// This creates a new process serving an interface on a certain number of

// threads.

std::unique_ptr<ProcessSession> BinderRpc::createRpcTestSocketServerProcessEtc(

        const BinderRpcOptions& options) {

    LOG_ALWAYS_FATAL_IF(options.numIncomingConnections != 0,

                        "Non-zero incoming connections %zu on Trusty",

                        options.numIncomingConnections);



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

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



    auto ret = std::make_unique<TrustyProcessSession>();



    status_t status;

    for (size_t i = 0; i < options.numSessions; i++) {

        auto factory = android::RpcTransportCtxFactoryTipcTrusty::make();

        auto session = android::RpcSession::make(std::move(factory));



        EXPECT_TRUE(session->setProtocolVersion(clientVersion));

        session->setMaxOutgoingThreads(options.numOutgoingConnections);

        session->setFileDescriptorTransportMode(options.clientFileDescriptorTransportMode);



        status = session->setupPreconnectedClient({}, [&]() {

            auto port = trustyIpcPort(serverVersion);

            int rc = connect(port.c_str(), IPC_CONNECT_WAIT_FOR_PORT);

            LOG_ALWAYS_FATAL_IF(rc < 0, "Failed to connect to service: %d", rc);

            return base::unique_fd(rc);

        });

        if (options.allowConnectFailure && status != OK) {

            ret->sessions.clear();

            break;

        }

        LOG_ALWAYS_FATAL_IF(status != OK, "Failed to connect to service: %s",

                            statusToString(status).c_str());

        ret->sessions.push_back({session, session->getRootObject()});

    }



    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)),

                        BinderRpc::PrintParamInfo);



} // namespace android



PORT_GTEST(BinderRpcTest, "com.android.trusty.binderRpcTest");

libs/binder/tests/binderRpcUniversalTests.cpp

+10 −10
Original line number Diff line number Diff line
@@ -386,11 +386,11 @@ TEST_P(BinderRpc, SameBinderEqualityWeak) { 
    EXPECT_EQ(b, weak.promote());

}



#define expectSessions(expected, iface)                   \

#define EXPECT_SESSIONS(expected, iface)                  \

    do {                                                  \

        int session;                                      \

        EXPECT_OK((iface)->getNumOpenSessions(&session)); \

        EXPECT_EQ(expected, session);                     \

        EXPECT_EQ(static_cast<int>(expected), session);   \

    } while (false)



TEST_P(BinderRpc, SingleSession) {
@@ -402,9 +402,9 @@ TEST_P(BinderRpc, SingleSession) { 
    EXPECT_OK(session->getName(&out));

    EXPECT_EQ("aoeu", out);



    expectSessions(1, proc.rootIface);

    EXPECT_SESSIONS(1, proc.rootIface);

    session = nullptr;

    expectSessions(0, proc.rootIface);

    EXPECT_SESSIONS(0, proc.rootIface);

}



TEST_P(BinderRpc, ManySessions) {
@@ -413,24 +413,24 @@ TEST_P(BinderRpc, ManySessions) { 
    std::vector<sp<IBinderRpcSession>> sessions;



    for (size_t i = 0; i < 15; i++) {

        expectSessions(i, proc.rootIface);

        EXPECT_SESSIONS(i, proc.rootIface);

        sp<IBinderRpcSession> session;

        EXPECT_OK(proc.rootIface->openSession(std::to_string(i), &session));

        sessions.push_back(session);

    }

    expectSessions(sessions.size(), proc.rootIface);

    EXPECT_SESSIONS(sessions.size(), proc.rootIface);

    for (size_t i = 0; i < sessions.size(); i++) {

        std::string out;

        EXPECT_OK(sessions.at(i)->getName(&out));

        EXPECT_EQ(std::to_string(i), out);

    }

    expectSessions(sessions.size(), proc.rootIface);

    EXPECT_SESSIONS(sessions.size(), proc.rootIface);



    while (!sessions.empty()) {

        sessions.pop_back();

        expectSessions(sessions.size(), proc.rootIface);

        EXPECT_SESSIONS(sessions.size(), proc.rootIface);

    }

    expectSessions(0, proc.rootIface);

    EXPECT_SESSIONS(0, proc.rootIface);

}



TEST_P(BinderRpc, OnewayCallDoesNotWait) {
@@ -483,7 +483,7 @@ TEST_P(BinderRpc, Callbacks) { 
                    cb->mCv.wait_for(_l, 1s, [&] { return !cb->mValues.empty(); });

                }



                EXPECT_EQ(cb->mValues.size(), 1)

                EXPECT_EQ(cb->mValues.size(), 1UL)

                        << "callIsOneway: " << callIsOneway

                        << " callbackIsOneway: " << callbackIsOneway << " delayed: " << delayed;

                if (cb->mValues.empty()) continue;

libs/binder/trusty/binderRpcTest/manifest.json

0 → 100644
+6 −0
Original line number Diff line number Diff line 
{

    "uuid": "9dbe9fb8-60fd-4bdd-af86-03e95d7ad78b",

    "app_name": "binderRpcTest",

    "min_heap": 163840,

    "min_stack": 16384

}