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

Commit a7e6c7c5 authored by Nikita Ioffe's avatar Nikita Ioffe Committed by Automerger Merge Worker
Browse files

Merge changes from topic "revert-1658450-HONDOEPHGR" am: 98880475 am: 7273b293 am: 67247a2d

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

Change-Id: I034c24565e3a9d869adfac4733c54980943d6054
parents 1592f2b1 67247a2d
Loading
Loading
Loading
Loading
+54 −104
Original line number Diff line number Diff line
@@ -20,7 +20,6 @@

#include <binder/Parcel.h>
#include <binder/Stability.h>
#include <utils/String8.h>

#include "RpcState.h"
#include "RpcWireFormat.h"
@@ -30,20 +29,14 @@
#include <sys/un.h>
#include <unistd.h>

#ifdef __GLIBC__
#if defined(__GLIBC__)
extern "C" pid_t gettid();
#endif

#ifdef __BIONIC__
#include <linux/vm_sockets.h>
#endif

namespace android {

using base::unique_fd;

RpcConnection::SocketAddress::~SocketAddress() {}

RpcConnection::RpcConnection() {
    LOG_RPC_DETAIL("RpcConnection created %p", this);

@@ -57,67 +50,64 @@ sp<RpcConnection> RpcConnection::make() {
    return new RpcConnection;
}

class UnixSocketAddress : public RpcConnection::SocketAddress {
public:
    explicit UnixSocketAddress(const char* path) : mAddr({.sun_family = AF_UNIX}) {
        unsigned int pathLen = strlen(path) + 1;
        LOG_ALWAYS_FATAL_IF(pathLen > sizeof(mAddr.sun_path), "%u %s", pathLen, path);
        memcpy(mAddr.sun_path, path, pathLen);
    }
    virtual ~UnixSocketAddress() {}
    std::string toString() const override {
        return String8::format("path '%.*s'", static_cast<int>(sizeof(mAddr.sun_path)),
                               mAddr.sun_path)
                .c_str();
bool RpcConnection::setupUnixDomainServer(const char* path) {
    LOG_ALWAYS_FATAL_IF(mServer.get() != -1, "Only supports one server now");

    unique_fd serverFd(TEMP_FAILURE_RETRY(socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0)));
    if (serverFd == -1) {
        ALOGE("Could not create socket at %s: %s", path, strerror(errno));
        return false;
    }
    const sockaddr* addr() const override { return reinterpret_cast<const sockaddr*>(&mAddr); }
    size_t addrSize() const override { return sizeof(mAddr); }

private:
    sockaddr_un mAddr;
    struct sockaddr_un addr = {
            .sun_family = AF_UNIX,
    };

bool RpcConnection::setupUnixDomainServer(const char* path) {
    return addServer(UnixSocketAddress(path));
    unsigned int pathLen = strlen(path) + 1;
    LOG_ALWAYS_FATAL_IF(pathLen > sizeof(addr.sun_path), "%u", pathLen);
    memcpy(addr.sun_path, path, pathLen);

    if (0 != TEMP_FAILURE_RETRY(bind(serverFd.get(), (struct sockaddr*)&addr, sizeof(addr)))) {
        ALOGE("Could not bind socket at %s: %s", path, strerror(errno));
        return false;
    }

bool RpcConnection::addUnixDomainClient(const char* path) {
    return addClient(UnixSocketAddress(path));
    if (0 != TEMP_FAILURE_RETRY(listen(serverFd.get(), 1 /*backlog*/))) {
        ALOGE("Could not listen socket at %s: %s", path, strerror(errno));
        return false;
    }

#ifdef __BIONIC__
    mServer = std::move(serverFd);
    return true;
}

bool RpcConnection::addUnixDomainClient(const char* path) {
    LOG_RPC_DETAIL("Connecting on path: %s", path);

class VsockSocketAddress : public RpcConnection::SocketAddress {
public:
    VsockSocketAddress(unsigned int cid, unsigned int port)
          : mAddr({
                    .svm_family = AF_VSOCK,
                    .svm_port = port,
                    .svm_cid = cid,
            }) {}
    virtual ~VsockSocketAddress() {}
    std::string toString() const override {
        return String8::format("cid %du port %du", mAddr.svm_cid, mAddr.svm_port).c_str();
    unique_fd serverFd(TEMP_FAILURE_RETRY(socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0)));
    if (serverFd == -1) {
        ALOGE("Could not create socket at %s: %s", path, strerror(errno));
        return false;
    }
    const sockaddr* addr() const override { return reinterpret_cast<const sockaddr*>(&mAddr); }
    size_t addrSize() const override { return sizeof(mAddr); }

private:
    sockaddr_vm mAddr;
    struct sockaddr_un addr = {
            .sun_family = AF_UNIX,
    };

bool RpcConnection::setupVsockServer(unsigned int port) {
    // realizing value w/ this type at compile time to avoid ubsan abort
    constexpr unsigned int kAnyCid = VMADDR_CID_ANY;
    unsigned int pathLen = strlen(path) + 1;
    LOG_ALWAYS_FATAL_IF(pathLen > sizeof(addr.sun_path), "%u", pathLen);
    memcpy(addr.sun_path, path, pathLen);

    return addServer(VsockSocketAddress(kAnyCid, port));
    if (0 != TEMP_FAILURE_RETRY(connect(serverFd.get(), (struct sockaddr*)&addr, sizeof(addr)))) {
        ALOGE("Could not connect socket at %s: %s", path, strerror(errno));
        return false;
    }

bool RpcConnection::addVsockClient(unsigned int cid, unsigned int port) {
    return addClient(VsockSocketAddress(cid, port));
}
    LOG_RPC_DETAIL("Unix domain client with fd %d", serverFd.get());

#endif // __BIONIC__
    addClient(std::move(serverFd));
    return true;
}

sp<IBinder> RpcConnection::getRootObject() {
    ExclusiveSocket socket(this, SocketUse::CLIENT);
@@ -140,8 +130,11 @@ status_t RpcConnection::sendDecStrong(const RpcAddress& address) {
void RpcConnection::join() {
    // establish a connection
    {
        unique_fd clientFd(
                TEMP_FAILURE_RETRY(accept4(mServer.get(), nullptr, 0 /*length*/, SOCK_CLOEXEC)));
        struct sockaddr_un clientSa;
        socklen_t clientSaLen = sizeof(clientSa);

        unique_fd clientFd(TEMP_FAILURE_RETRY(
                accept4(mServer.get(), (struct sockaddr*)&clientSa, &clientSaLen, SOCK_CLOEXEC)));
        if (clientFd < 0) {
            // If this log becomes confusing, should save more state from setupUnixDomainServer
            // in order to output here.
@@ -151,7 +144,7 @@ void RpcConnection::join() {

        LOG_RPC_DETAIL("accept4 on fd %d yields fd %d", mServer.get(), clientFd.get());

        assignServerToThisThread(std::move(clientFd));
        addServer(std::move(clientFd));
    }

    // We may not use the connection we just established (two threads might
@@ -177,57 +170,14 @@ wp<RpcServer> RpcConnection::server() {
    return mForServer;
}

bool RpcConnection::addServer(const SocketAddress& addr) {
    LOG_ALWAYS_FATAL_IF(mServer.get() != -1, "Each RpcConnection can only have one server.");

    unique_fd serverFd(
            TEMP_FAILURE_RETRY(socket(addr.addr()->sa_family, SOCK_STREAM | SOCK_CLOEXEC, 0)));
    if (serverFd == -1) {
        ALOGE("Could not create socket: %s", strerror(errno));
        return false;
    }

    if (0 != TEMP_FAILURE_RETRY(bind(serverFd.get(), addr.addr(), addr.addrSize()))) {
        int savedErrno = errno;
        ALOGE("Could not bind socket at %s: %s", addr.toString().c_str(), strerror(savedErrno));
        return false;
    }

    if (0 != TEMP_FAILURE_RETRY(listen(serverFd.get(), 1 /*backlog*/))) {
        int savedErrno = errno;
        ALOGE("Could not listen socket at %s: %s", addr.toString().c_str(), strerror(savedErrno));
        return false;
    }

    mServer = std::move(serverFd);
    return true;
}

bool RpcConnection::addClient(const SocketAddress& addr) {
    unique_fd serverFd(
            TEMP_FAILURE_RETRY(socket(addr.addr()->sa_family, SOCK_STREAM | SOCK_CLOEXEC, 0)));
    if (serverFd == -1) {
        int savedErrno = errno;
        ALOGE("Could not create socket at %s: %s", addr.toString().c_str(), strerror(savedErrno));
        return false;
    }

    if (0 != TEMP_FAILURE_RETRY(connect(serverFd.get(), addr.addr(), addr.addrSize()))) {
        int savedErrno = errno;
        ALOGE("Could not connect socket at %s: %s", addr.toString().c_str(), strerror(savedErrno));
        return false;
    }

    LOG_RPC_DETAIL("Socket at %s client with fd %d", addr.toString().c_str(), serverFd.get());

void RpcConnection::addClient(base::unique_fd&& fd) {
    std::lock_guard<std::mutex> _l(mSocketMutex);
    sp<ConnectionSocket> connection = new ConnectionSocket();
    connection->fd = std::move(serverFd);
    connection->fd = std::move(fd);
    mClients.push_back(connection);
    return true;
}

void RpcConnection::assignServerToThisThread(base::unique_fd&& fd) {
void RpcConnection::addServer(base::unique_fd&& fd) {
    std::lock_guard<std::mutex> _l(mSocketMutex);
    sp<ConnectionSocket> connection = new ConnectionSocket();
    connection->fd = std::move(fd);
+2 −23
Original line number Diff line number Diff line
@@ -61,18 +61,6 @@ public:
     */
    [[nodiscard]] bool addUnixDomainClient(const char* path);

#ifdef __BIONIC__
    /**
     * Creates an RPC server at the current port.
     */
    [[nodiscard]] bool setupVsockServer(unsigned int port);

    /**
     * Connects to an RPC server at the CVD & port.
     */
    [[nodiscard]] bool addVsockClient(unsigned int cvd, unsigned int port);
#endif // __BIONIC__

    /**
     * Query the other side of the connection for the root object hosted by that
     * process's RpcServer (if one exists)
@@ -97,20 +85,11 @@ public:
    // internal only
    const std::unique_ptr<RpcState>& state() { return mState; }

    class SocketAddress {
    public:
        virtual ~SocketAddress();
        virtual std::string toString() const = 0;
        virtual const sockaddr* addr() const = 0;
        virtual size_t addrSize() const = 0;
    };

private:
    RpcConnection();

    bool addServer(const SocketAddress& address);
    bool addClient(const SocketAddress& address);
    void assignServerToThisThread(base::unique_fd&& fd);
    void addServer(base::unique_fd&& fd);
    void addClient(base::unique_fd&& fd);

    struct ConnectionSocket : public RefBase {
        base::unique_fd fd;
+0 −1
Original line number Diff line number Diff line
@@ -122,7 +122,6 @@ cc_test {
    ],
    test_suites: ["general-tests"],
    require_root: true,
    host_supported: true,
}

cc_test {
+109 −171
Original line number Diff line number Diff line
@@ -14,6 +14,14 @@
 * limitations under the License.
 */

#include <sys/prctl.h>
#include <unistd.h>

#include <chrono>
#include <cstdlib>
#include <iostream>
#include <thread>

#include <BnBinderRpcSession.h>
#include <BnBinderRpcTest.h>
#include <android-base/logging.h>
@@ -25,18 +33,6 @@
#include <binder/RpcServer.h>
#include <gtest/gtest.h>

#include <chrono>
#include <cstdlib>
#include <iostream>
#include <thread>

#ifdef __BIONIC__
#include <linux/vm_sockets.h>
#endif //__BIONIC__

#include <sys/prctl.h>
#include <unistd.h>

#include "../RpcState.h" // for debugging

namespace android {
@@ -189,13 +185,8 @@ private:

static std::string allocateSocketAddress() {
    static size_t id = 0;
    static bool gUseTmp = access("/tmp/", F_OK) != -1;

    if (gUseTmp) {
        return "/tmp/binderRpcTest_" + std::to_string(id++);
    } else {
    return "/dev/binderRpcTest_" + std::to_string(id++);
    }
};

struct ProcessConnection {
@@ -223,51 +214,6 @@ struct ProcessConnection {
    }
};

// Process connection where the process hosts IBinderRpcTest, the server used
// for most testing here
struct BinderRpcTestProcessConnection {
    ProcessConnection proc;

    // pre-fetched root object
    sp<IBinder> rootBinder;

    // pre-casted root object
    sp<IBinderRpcTest> rootIface;

    ~BinderRpcTestProcessConnection() {
        if (!proc.expectInvalid) {
            int32_t remoteBinders = 0;
            EXPECT_OK(rootIface->countBinders(&remoteBinders));
            // should only be the root binder object, iface
            EXPECT_EQ(remoteBinders, 1);
        }

        rootIface = nullptr;
        rootBinder = nullptr;
    }
};

enum class SocketType {
    UNIX,
#ifdef __BIONIC__
    VSOCK,
#endif // __BIONIC__
};
static inline std::string PrintSocketType(const testing::TestParamInfo<SocketType>& info) {
    switch (info.param) {
        case SocketType::UNIX:
            return "unix_domain_socket";
#ifdef __BIONIC__
        case SocketType::VSOCK:
            return "vm_socket";
#endif // __BIONIC__
        default:
            LOG_ALWAYS_FATAL("Unknown socket type");
            return "";
    }
}
class BinderRpc : public ::testing::TestWithParam<SocketType> {
public:
// This creates a new process serving an interface on a certain number of
// threads.
ProcessConnection createRpcTestSocketServerProcess(
@@ -275,12 +221,8 @@ public:
        const std::function<void(const sp<RpcServer>&, const sp<RpcConnection>&)>& configure) {
    CHECK_GT(numThreads, 0);

        SocketType socketType = GetParam();

    std::string addr = allocateSocketAddress();
    unlink(addr.c_str());
        static unsigned int port = 3456;
        port++;

    auto ret = ProcessConnection{
            .host = Process([&] {
@@ -290,19 +232,7 @@ public:

                // server supporting one client on one socket
                sp<RpcConnection> connection = server->addClientConnection();

                    switch (socketType) {
                        case SocketType::UNIX:
                CHECK(connection->setupUnixDomainServer(addr.c_str())) << addr;
                            break;
#ifdef __BIONIC__
                        case SocketType::VSOCK:
                            CHECK(connection->setupVsockServer(port));
                            break;
#endif // __BIONIC__
                        default:
                            LOG_ALWAYS_FATAL("Unknown socket type");
                    }

                configure(server, connection);

@@ -317,31 +247,49 @@ public:
            .connection = RpcConnection::make(),
    };

    // wait up to 1s for sockets to be created
    constexpr useconds_t kMaxWaitUs = 1000000;
    constexpr useconds_t kWaitDivision = 100;
    for (size_t i = 0; i < kWaitDivision && 0 != access(addr.c_str(), F_OK); i++) {
        usleep(kMaxWaitUs / kWaitDivision);
    }

    // create remainder of connections
    for (size_t i = 0; i < numThreads; i++) {
            for (size_t tries = 0; tries < 5; tries++) {
                usleep(10000);
                switch (socketType) {
                    case SocketType::UNIX:
                        if (ret.connection->addUnixDomainClient(addr.c_str())) goto success;
                        break;
#ifdef __BIONIC__
                    case SocketType::VSOCK:
                        if (ret.connection->addVsockClient(VMADDR_CID_LOCAL, port)) goto success;
                        break;
#endif // __BIONIC__
                    default:
                        LOG_ALWAYS_FATAL("Unknown socket type");
                }
            }
            LOG_ALWAYS_FATAL("Could not connect");
        success:;
        // Connection refused sometimes after file created but before listening.
        CHECK(ret.connection->addUnixDomainClient(addr.c_str()) ||
              (usleep(10000), ret.connection->addUnixDomainClient(addr.c_str())))
                << i;
    }

    ret.rootBinder = ret.connection->getRootObject();
    return ret;
}

// Process connection where the process hosts IBinderRpcTest, the server used
// for most testing here
struct BinderRpcTestProcessConnection {
    ProcessConnection proc;

    // pre-fetched root object
    sp<IBinder> rootBinder;

    // pre-casted root object
    sp<IBinderRpcTest> rootIface;

    ~BinderRpcTestProcessConnection() {
        if (!proc.expectInvalid) {
            int32_t remoteBinders = 0;
            EXPECT_OK(rootIface->countBinders(&remoteBinders));
            // should only be the root binder object, iface
            EXPECT_EQ(remoteBinders, 1);
        }

        rootIface = nullptr;
        rootBinder = nullptr;
    }
};

BinderRpcTestProcessConnection createRpcTestSocketServerProcess(size_t numThreads) {
    BinderRpcTestProcessConnection ret{
            .proc = createRpcTestSocketServerProcess(numThreads,
@@ -360,9 +308,8 @@ public:

    return ret;
}
};

TEST_P(BinderRpc, RootObjectIsNull) {
TEST(BinderRpc, RootObjectIsNull) {
    auto proc = createRpcTestSocketServerProcess(1,
                                                 [](const sp<RpcServer>& server,
                                                    const sp<RpcConnection>&) {
@@ -377,20 +324,20 @@ TEST_P(BinderRpc, RootObjectIsNull) {
    EXPECT_EQ(nullptr, proc.connection->getRootObject());
}

TEST_P(BinderRpc, Ping) {
TEST(BinderRpc, Ping) {
    auto proc = createRpcTestSocketServerProcess(1);
    ASSERT_NE(proc.rootBinder, nullptr);
    EXPECT_EQ(OK, proc.rootBinder->pingBinder());
}

TEST_P(BinderRpc, TransactionsMustBeMarkedRpc) {
TEST(BinderRpc, TransactionsMustBeMarkedRpc) {
    auto proc = createRpcTestSocketServerProcess(1);
    Parcel data;
    Parcel reply;
    EXPECT_EQ(BAD_TYPE, proc.rootBinder->transact(IBinder::PING_TRANSACTION, data, &reply, 0));
}

TEST_P(BinderRpc, UnknownTransaction) {
TEST(BinderRpc, UnknownTransaction) {
    auto proc = createRpcTestSocketServerProcess(1);
    Parcel data;
    data.markForBinder(proc.rootBinder);
@@ -398,19 +345,19 @@ TEST_P(BinderRpc, UnknownTransaction) {
    EXPECT_EQ(UNKNOWN_TRANSACTION, proc.rootBinder->transact(1337, data, &reply, 0));
}

TEST_P(BinderRpc, SendSomethingOneway) {
TEST(BinderRpc, SendSomethingOneway) {
    auto proc = createRpcTestSocketServerProcess(1);
    EXPECT_OK(proc.rootIface->sendString("asdf"));
}

TEST_P(BinderRpc, SendAndGetResultBack) {
TEST(BinderRpc, SendAndGetResultBack) {
    auto proc = createRpcTestSocketServerProcess(1);
    std::string doubled;
    EXPECT_OK(proc.rootIface->doubleString("cool ", &doubled));
    EXPECT_EQ("cool cool ", doubled);
}

TEST_P(BinderRpc, SendAndGetResultBackBig) {
TEST(BinderRpc, SendAndGetResultBackBig) {
    auto proc = createRpcTestSocketServerProcess(1);
    std::string single = std::string(1024, 'a');
    std::string doubled;
@@ -418,7 +365,7 @@ TEST_P(BinderRpc, SendAndGetResultBackBig) {
    EXPECT_EQ(single + single, doubled);
}

TEST_P(BinderRpc, CallMeBack) {
TEST(BinderRpc, CallMeBack) {
    auto proc = createRpcTestSocketServerProcess(1);

    int32_t pingResult;
@@ -428,7 +375,7 @@ TEST_P(BinderRpc, CallMeBack) {
    EXPECT_EQ(0, MyBinderRpcSession::gNum);
}

TEST_P(BinderRpc, RepeatBinder) {
TEST(BinderRpc, RepeatBinder) {
    auto proc = createRpcTestSocketServerProcess(1);

    sp<IBinder> inBinder = new MyBinderRpcSession("foo");
@@ -450,7 +397,7 @@ TEST_P(BinderRpc, RepeatBinder) {
    EXPECT_EQ(0, MyBinderRpcSession::gNum);
}

TEST_P(BinderRpc, RepeatTheirBinder) {
TEST(BinderRpc, RepeatTheirBinder) {
    auto proc = createRpcTestSocketServerProcess(1);

    sp<IBinderRpcSession> session;
@@ -474,7 +421,7 @@ TEST_P(BinderRpc, RepeatTheirBinder) {
    EXPECT_EQ(nullptr, weak.promote());
}

TEST_P(BinderRpc, RepeatBinderNull) {
TEST(BinderRpc, RepeatBinderNull) {
    auto proc = createRpcTestSocketServerProcess(1);

    sp<IBinder> outBinder;
@@ -482,7 +429,7 @@ TEST_P(BinderRpc, RepeatBinderNull) {
    EXPECT_EQ(nullptr, outBinder);
}

TEST_P(BinderRpc, HoldBinder) {
TEST(BinderRpc, HoldBinder) {
    auto proc = createRpcTestSocketServerProcess(1);

    IBinder* ptr = nullptr;
@@ -508,7 +455,7 @@ TEST_P(BinderRpc, HoldBinder) {
// These are behavioral differences form regular binder, where certain usecases
// aren't supported.

TEST_P(BinderRpc, CannotMixBindersBetweenUnrelatedSocketConnections) {
TEST(BinderRpc, CannotMixBindersBetweenUnrelatedSocketConnections) {
    auto proc1 = createRpcTestSocketServerProcess(1);
    auto proc2 = createRpcTestSocketServerProcess(1);

@@ -517,7 +464,7 @@ TEST_P(BinderRpc, CannotMixBindersBetweenUnrelatedSocketConnections) {
              proc1.rootIface->repeatBinder(proc2.rootBinder, &outBinder).transactionError());
}

TEST_P(BinderRpc, CannotSendRegularBinderOverSocketBinder) {
TEST(BinderRpc, CannotSendRegularBinderOverSocketBinder) {
    auto proc = createRpcTestSocketServerProcess(1);

    sp<IBinder> someRealBinder = IInterface::asBinder(defaultServiceManager());
@@ -526,7 +473,7 @@ TEST_P(BinderRpc, CannotSendRegularBinderOverSocketBinder) {
              proc.rootIface->repeatBinder(someRealBinder, &outBinder).transactionError());
}

TEST_P(BinderRpc, CannotSendSocketBinderOverRegularBinder) {
TEST(BinderRpc, CannotSendSocketBinderOverRegularBinder) {
    auto proc = createRpcTestSocketServerProcess(1);

    // for historical reasons, IServiceManager interface only returns the
@@ -537,7 +484,7 @@ TEST_P(BinderRpc, CannotSendSocketBinderOverRegularBinder) {

// END TESTS FOR LIMITATIONS OF SOCKET BINDER

TEST_P(BinderRpc, RepeatRootObject) {
TEST(BinderRpc, RepeatRootObject) {
    auto proc = createRpcTestSocketServerProcess(1);

    sp<IBinder> outBinder;
@@ -545,7 +492,7 @@ TEST_P(BinderRpc, RepeatRootObject) {
    EXPECT_EQ(proc.rootBinder, outBinder);
}

TEST_P(BinderRpc, NestedTransactions) {
TEST(BinderRpc, NestedTransactions) {
    auto proc = createRpcTestSocketServerProcess(1);

    auto nastyNester = sp<MyBinderRpcTest>::make();
@@ -556,7 +503,7 @@ TEST_P(BinderRpc, NestedTransactions) {
    EXPECT_EQ(nullptr, weak.promote());
}

TEST_P(BinderRpc, SameBinderEquality) {
TEST(BinderRpc, SameBinderEquality) {
    auto proc = createRpcTestSocketServerProcess(1);

    sp<IBinder> a;
@@ -568,7 +515,7 @@ TEST_P(BinderRpc, SameBinderEquality) {
    EXPECT_EQ(a, b);
}

TEST_P(BinderRpc, SameBinderEqualityWeak) {
TEST(BinderRpc, SameBinderEqualityWeak) {
    auto proc = createRpcTestSocketServerProcess(1);

    sp<IBinder> a;
@@ -600,7 +547,7 @@ TEST_P(BinderRpc, SameBinderEqualityWeak) {
        EXPECT_EQ(expected, session);                     \
    } while (false)

TEST_P(BinderRpc, SingleSession) {
TEST(BinderRpc, SingleSession) {
    auto proc = createRpcTestSocketServerProcess(1);

    sp<IBinderRpcSession> session;
@@ -614,7 +561,7 @@ TEST_P(BinderRpc, SingleSession) {
    expectSessions(0, proc.rootIface);
}

TEST_P(BinderRpc, ManySessions) {
TEST(BinderRpc, ManySessions) {
    auto proc = createRpcTestSocketServerProcess(1);

    std::vector<sp<IBinderRpcSession>> sessions;
@@ -648,7 +595,7 @@ size_t epochMillis() {
    return duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
}

TEST_P(BinderRpc, ThreadPoolGreaterThanEqualRequested) {
TEST(BinderRpc, ThreadPoolGreaterThanEqualRequested) {
    constexpr size_t kNumThreads = 10;

    auto proc = createRpcTestSocketServerProcess(kNumThreads);
@@ -680,7 +627,7 @@ TEST_P(BinderRpc, ThreadPoolGreaterThanEqualRequested) {
    for (auto& t : ts) t.join();
}

TEST_P(BinderRpc, ThreadPoolOverSaturated) {
TEST(BinderRpc, ThreadPoolOverSaturated) {
    constexpr size_t kNumThreads = 10;
    constexpr size_t kNumCalls = kNumThreads + 3;
    constexpr size_t kSleepMs = 500;
@@ -704,7 +651,7 @@ TEST_P(BinderRpc, ThreadPoolOverSaturated) {
    EXPECT_LE(epochMsAfter, epochMsBefore + 3 * kSleepMs);
}

TEST_P(BinderRpc, ThreadingStressTest) {
TEST(BinderRpc, ThreadingStressTest) {
    constexpr size_t kNumClientThreads = 10;
    constexpr size_t kNumServerThreads = 10;
    constexpr size_t kNumCalls = 100;
@@ -725,7 +672,7 @@ TEST_P(BinderRpc, ThreadingStressTest) {
    for (auto& t : threads) t.join();
}

TEST_P(BinderRpc, OnewayCallDoesNotWait) {
TEST(BinderRpc, OnewayCallDoesNotWait) {
    constexpr size_t kReallyLongTimeMs = 100;
    constexpr size_t kSleepMs = kReallyLongTimeMs * 5;

@@ -740,7 +687,7 @@ TEST_P(BinderRpc, OnewayCallDoesNotWait) {
    EXPECT_LT(epochMsAfter, epochMsBefore + kReallyLongTimeMs);
}

TEST_P(BinderRpc, OnewayCallQueueing) {
TEST(BinderRpc, OnewayCallQueueing) {
    constexpr size_t kNumSleeps = 10;
    constexpr size_t kNumExtraServerThreads = 4;
    constexpr size_t kSleepMs = 50;
@@ -764,7 +711,7 @@ TEST_P(BinderRpc, OnewayCallQueueing) {
    EXPECT_GT(epochMsAfter, epochMsBefore + kSleepMs * kNumSleeps);
}

TEST_P(BinderRpc, Die) {
TEST(BinderRpc, Die) {
    // TODO(b/183141167): handle this in library
    signal(SIGPIPE, SIG_IGN);

@@ -796,7 +743,7 @@ ssize_t countFds() {
    return ret;
}

TEST_P(BinderRpc, Fds) {
TEST(BinderRpc, Fds) {
    ssize_t beforeFds = countFds();
    ASSERT_GE(beforeFds, 0);
    {
@@ -806,19 +753,10 @@ TEST_P(BinderRpc, Fds) {
    ASSERT_EQ(beforeFds, countFds()) << (system("ls -l /proc/self/fd/"), "fd leak?");
}

INSTANTIATE_TEST_CASE_P(PerSocket, BinderRpc,
                        ::testing::Values(SocketType::UNIX
#ifdef __BIONIC__
                                          ,
                                          SocketType::VSOCK
#endif // __BIONIC__
                                          ),
                        PrintSocketType);

} // namespace android

int main(int argc, char** argv) {
extern "C" int main(int argc, char** argv) {
    ::testing::InitGoogleTest(&argc, argv);
    android::base::InitLogging(argv, android::base::StderrLogger, android::base::DefaultAborter);
    return RUN_ALL_TESTS();
}

} // namespace android