libbinder: Build and run binderRpcTest on Trusty (94675e7b) · Commits · e / os / android_frameworks_native

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

+25 −0

Original line number	Diff line number	Diff line
		@@ -370,6 +370,30 @@ cc_binary {
		],
		}

		cc_test {
		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",
		],
		}

		cc_test {
		name: "binderRpcTest",
		defaults: [
		@@ -382,6 +406,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
		}