Merge "Revert "Revert "libbinder: Build and run binderRpcTest on Trusty""" am:... (412fb031) · Commits · e / os / android_frameworks_native

libs/binder/Android.bp

+2 −0

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

	cc_defaults {		cc_defaults {
	name: "trusty_mock_defaults",		name: "trusty_mock_defaults",
			vendor_available: true,
			host_supported: true,

	header_libs: [		header_libs: [
	"trusty_mock_headers",		"trusty_mock_headers",

libs/binder/tests/Android.bp

+26 −0

Original line number	Original line	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 {		cc_test {
	name: "binderRpcTest",		name: "binderRpcTest",
	defaults: [		defaults: [
	@@ -382,6 +407,7 @@ cc_test {
	required: [		required: [
	"libbinder_on_trusty_mock",		"libbinder_on_trusty_mock",
	"binderRpcTestService_on_trusty_mock",		"binderRpcTestService_on_trusty_mock",
			"binderRpcTest_on_trusty_mock",
	],		],
	}		}

libs/binder/tests/binderRpcTestTrusty.cpp

0 → 100644

+105 −0

Original line number	Original line	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	Original line	Diff line number	Diff line
	@@ -386,11 +386,11 @@ TEST_P(BinderRpc, SameBinderEqualityWeak) {
	EXPECT_EQ(b, weak.promote());		EXPECT_EQ(b, weak.promote());
	}		}

	#define expectSessions(expected, iface) \		#define EXPECT_SESSIONS(expected, iface) \
	do { \		do { \
	int session; \		int session; \
	EXPECT_OK((iface)->getNumOpenSessions(&session)); \		EXPECT_OK((iface)->getNumOpenSessions(&session)); \
	EXPECT_EQ(expected, session); \		EXPECT_EQ(static_cast<int>(expected), session); \
	} while (false)		} while (false)

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

	expectSessions(1, proc.rootIface);		EXPECT_SESSIONS(1, proc.rootIface);
	session = nullptr;		session = nullptr;
	expectSessions(0, proc.rootIface);		EXPECT_SESSIONS(0, proc.rootIface);
	}		}

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

	for (size_t i = 0; i < 15; i++) {		for (size_t i = 0; i < 15; i++) {
	expectSessions(i, proc.rootIface);		EXPECT_SESSIONS(i, proc.rootIface);
	sp<IBinderRpcSession> session;		sp<IBinderRpcSession> session;
	EXPECT_OK(proc.rootIface->openSession(std::to_string(i), &session));		EXPECT_OK(proc.rootIface->openSession(std::to_string(i), &session));
	sessions.push_back(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++) {		for (size_t i = 0; i < sessions.size(); i++) {
	std::string out;		std::string out;
	EXPECT_OK(sessions.at(i)->getName(&out));		EXPECT_OK(sessions.at(i)->getName(&out));
	EXPECT_EQ(std::to_string(i), out);		EXPECT_EQ(std::to_string(i), out);
	}		}
	expectSessions(sessions.size(), proc.rootIface);		EXPECT_SESSIONS(sessions.size(), proc.rootIface);

	while (!sessions.empty()) {		while (!sessions.empty()) {
	sessions.pop_back();		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) {		TEST_P(BinderRpc, OnewayCallDoesNotWait) {
	@@ -483,7 +483,7 @@ TEST_P(BinderRpc, Callbacks) {
	cb->mCv.wait_for(_l, 1s, [&] { return !cb->mValues.empty(); });		cb->mCv.wait_for(_l, 1s, [&] { return !cb->mValues.empty(); });
	}		}

	EXPECT_EQ(cb->mValues.size(), 1)		EXPECT_EQ(cb->mValues.size(), 1UL)
	<< "callIsOneway: " << callIsOneway		<< "callIsOneway: " << callIsOneway
	<< " callbackIsOneway: " << callbackIsOneway << " delayed: " << delayed;		<< " callbackIsOneway: " << callbackIsOneway << " delayed: " << delayed;
	if (cb->mValues.empty()) continue;		if (cb->mValues.empty()) continue;

libs/binder/trusty/binderRpcTest/manifest.json

0 → 100644

+6 −0

Original line number	Original line	Diff line number	Diff line
			{
			"uuid": "9dbe9fb8-60fd-4bdd-af86-03e95d7ad78b",
			"app_name": "binderRpcTest",
			"min_heap": 163840,
			"min_stack": 16384
			}