blob: c8a8acc0a0ee8411ecef23d685f5e3013a9c3c9e [file] [log] [blame] [edit]
/*
* 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.
*/
#pragma once
#include <gtest/gtest.h>
#include "binderRpcTestCommon.h"
#define EXPECT_OK(status) \
do { \
android::binder::Status stat = (status); \
EXPECT_TRUE(stat.isOk()) << stat; \
} while (false)
namespace android {
// Abstract base class with a virtual destructor that handles the
// ownership of a process session for BinderRpcTestSession below
class ProcessSession {
public:
struct SessionInfo {
sp<RpcSession> session;
sp<IBinder> root;
// Trusty defines its own socket APIs in trusty_ipc.h but doesn't include
// sockaddr types.
#ifndef __TRUSTY__
sockaddr_storage addr;
socklen_t addrLen;
#endif
};
// client session objects associated with other process
// each one represents a separate session
std::vector<SessionInfo> sessions;
virtual ~ProcessSession() = 0;
// If the process exits with a status, run the given callback on that value.
virtual void setCustomExitStatusCheck(std::function<void(int wstatus)> f) = 0;
// Kill the process. Avoid if possible. Shutdown gracefully via an RPC instead.
virtual void terminate() = 0;
};
// Process session where the process hosts IBinderRpcTest, the server used
// for most testing here
struct BinderRpcTestProcessSession {
std::unique_ptr<ProcessSession> proc;
// pre-fetched root object (for first session)
sp<IBinder> rootBinder;
// pre-casted root object (for first session)
sp<IBinderRpcTest> rootIface;
// whether session should be invalidated by end of run
bool expectAlreadyShutdown = false;
// TODO(b/271830568): fix this in binderRpcTest, we always use the first session to cause the
// remote process to shutdown. Normally, when we shutdown, the default in the destructor is to
// check that there are no leaks and shutdown. However, when there are incoming threadpools,
// there will be a few extra binder threads there, so we can't shutdown the server. We should
// consider an alternative way of doing the test so that we don't need this, some ideas, such as
// program in understanding of incoming threadpool into the destructor so that (e.g.
// intelligently wait for sessions to shutdown now that they will do this)
void forceShutdown() {
if (auto status = rootIface->scheduleShutdown(); !status.isOk()) {
EXPECT_EQ(DEAD_OBJECT, status.transactionError()) << status;
}
EXPECT_TRUE(proc->sessions.at(0).session->shutdownAndWait(true));
expectAlreadyShutdown = true;
}
BinderRpcTestProcessSession(std::unique_ptr<ProcessSession> proc) : proc(std::move(proc)){};
BinderRpcTestProcessSession(BinderRpcTestProcessSession&&) = default;
~BinderRpcTestProcessSession() {
if (!expectAlreadyShutdown) {
EXPECT_NE(nullptr, rootIface);
if (rootIface == nullptr) return;
std::vector<int32_t> remoteCounts;
// calling over any sessions counts across all sessions
EXPECT_OK(rootIface->countBinders(&remoteCounts));
EXPECT_EQ(remoteCounts.size(), proc->sessions.size());
for (auto remoteCount : remoteCounts) {
EXPECT_EQ(remoteCount, 1);
}
// even though it is on another thread, shutdown races with
// the transaction reply being written
if (auto status = rootIface->scheduleShutdown(); !status.isOk()) {
EXPECT_EQ(DEAD_OBJECT, status.transactionError()) << status;
}
}
rootIface = nullptr;
rootBinder = nullptr;
}
};
struct BinderRpcParam {
SocketType type;
RpcSecurity security;
uint32_t clientVersion;
uint32_t serverVersion;
bool singleThreaded;
bool noKernel;
};
class BinderRpc : public ::testing::TestWithParam<BinderRpcParam> {
public:
// 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();
}
// Whether the test params support sending FDs in parcels.
bool supportsFdTransport() const {
if (socketType() == SocketType::TIPC) {
// Trusty does not support file descriptors yet
return false;
}
return clientVersion() >= 1 && serverVersion() >= 1 && rpcSecurity() != RpcSecurity::TLS &&
(socketType() == SocketType::PRECONNECTED || socketType() == SocketType::UNIX ||
socketType() == SocketType::UNIX_BOOTSTRAP ||
socketType() == SocketType::UNIX_RAW);
}
void SetUp() override {
if (socketType() == SocketType::UNIX_BOOTSTRAP && rpcSecurity() == RpcSecurity::TLS) {
GTEST_SKIP() << "Unix bootstrap not supported over a TLS transport";
}
}
BinderRpcTestProcessSession createRpcTestSocketServerProcess(const BinderRpcOptions& options) {
BinderRpcTestProcessSession ret(createRpcTestSocketServerProcessEtc(options));
ret.rootBinder = ret.proc->sessions.empty() ? nullptr : ret.proc->sessions.at(0).root;
ret.rootIface = interface_cast<IBinderRpcTest>(ret.rootBinder);
return ret;
}
static std::string PrintParamInfo(const testing::TestParamInfo<ParamType>& info) {
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 (info.param.noKernel) {
ret += "_no_kernel";
} else {
ret += "_with_kernel";
}
return ret;
}
protected:
static std::unique_ptr<RpcTransportCtxFactory> newFactory(RpcSecurity rpcSecurity);
std::unique_ptr<ProcessSession> createRpcTestSocketServerProcessEtc(
const BinderRpcOptions& options);
};
} // namespace android