libs/binder/tests/binderDriverInterfaceTest.cpp

   1 /*
   2  * Copyright (C) 2014 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <errno.h>
  18 #include <fcntl.h>
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21
  22 #include <gtest/gtest.h>
  23 #include <linux/binder.h>
  24 #include <binder/IBinder.h>
  25 #include <sys/mman.h>
  26 #include <poll.h>
  27
  28 #define BINDER_DEV_NAME "/dev/binder"
  29
  30 testing::Environment* binder_env;
  31
  32 class BinderDriverInterfaceTestEnv : public ::testing::Environment {
  33         virtual void SetUp() {
  34             int ret;
  35             uint32_t max_threads = 0;
  36
  37             m_binderFd = open(BINDER_DEV_NAME, O_RDWR | O_NONBLOCK);
  38             ASSERT_GE(m_binderFd, 0);
  39             m_buffer = mmap(NULL, 64*1024, PROT_READ, MAP_SHARED, m_binderFd, 0);
  40             ASSERT_NE(m_buffer, (void *)NULL);
  41             ret = ioctl(m_binderFd, BINDER_SET_MAX_THREADS, &max_threads);
  42             EXPECT_EQ(0, ret);
  43             EnterLooper();
  44         }
  45         virtual void TearDown() {
  46             close(m_binderFd);
  47         }
  48     private:
  49         int m_binderFd;
  50         void *m_buffer;
  51     public:
  52         int getBinderFd(void) {
  53             return m_binderFd;
  54         }
  55         void EnterLooper(void) {
  56             int ret;
  57             const uint32_t bc[] = {
  58                 BC_ENTER_LOOPER,
  59             };
  60             struct binder_write_read bwr = binder_write_read();
  61             bwr.write_buffer = (uintptr_t)bc;
  62             bwr.write_size = sizeof(bc);
  63             ret = ioctl(m_binderFd, BINDER_WRITE_READ, &bwr);
  64             EXPECT_EQ(0, ret);
  65             if (ret < 0) {
  66                     EXPECT_EQ(0, errno);
  67             }
  68             EXPECT_EQ(sizeof(bc), bwr.write_consumed);
  69         }
  70 };
  71
  72 class BinderDriverInterfaceTest : public ::testing::Test {
  73     public:
  74         virtual void SetUp() {
  75             m_binderFd = static_cast<BinderDriverInterfaceTestEnv *>(binder_env)->getBinderFd();
  76         }
  77         virtual void TearDown() {
  78         }
  79     protected:
  80         void binderTestIoctlRetErr2(int cmd, void *arg, int expect_ret, int expect_errno, int accept_errno) {
  81             int ret;
  82
  83             ret = ioctl(m_binderFd, cmd, arg);
  84             EXPECT_EQ(expect_ret, ret);
  85             if (ret < 0) {
  86                 if (errno != accept_errno)
  87                     EXPECT_EQ(expect_errno, errno);
  88             }
  89         }
  90         void binderTestIoctlErr2(int cmd, void *arg, int expect_errno, int accept_errno) {
  91             binderTestIoctlRetErr2(cmd, arg, -1, expect_errno, accept_errno);
  92         }
  93         void binderTestIoctlErr1(int cmd, void *arg, int expect_errno) {
  94             binderTestIoctlErr2(cmd, arg, expect_errno, expect_errno);
  95         }
  96         void binderTestIoctl(int cmd, void *arg) {
  97             binderTestIoctlRetErr2(cmd, arg, 0, 0, 0);
  98         }
  99         void binderTestIoctlUnimplemented(int cmd, void *arg) {
 100             int ret;
 101
 102             ret = ioctl(m_binderFd, cmd, arg);
 103             if (ret < 0) {
 104                 /* Not currently implmented. Allow ret == -1, errno == EINVAL */
 105                 EXPECT_EQ(-1, ret);
 106                 EXPECT_EQ(EINVAL, errno);
 107             }
 108         }
 109         void binderTestReadEmpty(void) {
 110             size_t i;
 111             uint32_t br[32];
 112             struct binder_write_read bwr = binder_write_read();
 113             SCOPED_TRACE("TestReadEmpty");
 114             bwr.read_buffer = (uintptr_t)br;
 115             bwr.read_size = sizeof(br);
 116             binderTestIoctlErr1(BINDER_WRITE_READ, &bwr, EAGAIN);
 117             EXPECT_EQ(0u, bwr.read_consumed);
 118             for (i = 0; i * sizeof(uint32_t) < bwr.read_consumed; i++) {
 119                 SCOPED_TRACE(testing::Message() << "i = " << i);
 120                 EXPECT_EQ(BR_NOOP, br[i]);
 121             }
 122         }
 123         void binderWaitForReadData(int timeout_ms) {
 124             int ret;
 125             pollfd pfd = pollfd();
 126
 127             pfd.fd = m_binderFd;
 128             pfd.events = POLLIN;
 129             ret = poll(&pfd, 1, timeout_ms);
 130             EXPECT_EQ(1, ret);
 131         }
 132     private:
 133         int m_binderFd;
 134 };
 135
 136 TEST_F(BinderDriverInterfaceTest, Version) {
 137     struct binder_version version;
 138     binderTestIoctl(BINDER_VERSION, &version);
 139     ASSERT_EQ(BINDER_CURRENT_PROTOCOL_VERSION, version.protocol_version);
 140 }
 141
 142 TEST_F(BinderDriverInterfaceTest, WriteReadNull) {
 143     binderTestIoctlErr1(BINDER_WRITE_READ, NULL, EFAULT);
 144 }
 145
 146 TEST_F(BinderDriverInterfaceTest, SetIdleTimeoutNull) {
 147     binderTestIoctlErr2(BINDER_SET_IDLE_TIMEOUT, NULL, EFAULT, EINVAL);
 148 }
 149
 150 TEST_F(BinderDriverInterfaceTest, SetMaxThreadsNull) {
 151     binderTestIoctlErr2(BINDER_SET_MAX_THREADS, NULL, EFAULT, EINVAL); /* TODO: don't accept EINVAL */
 152 }
 153
 154 TEST_F(BinderDriverInterfaceTest, SetIdlePriorityNull) {
 155     binderTestIoctlErr2(BINDER_SET_IDLE_PRIORITY, NULL, EFAULT, EINVAL);
 156 }
 157
 158 TEST_F(BinderDriverInterfaceTest, VersionNull) {
 159     binderTestIoctlErr2(BINDER_VERSION, NULL, EFAULT, EINVAL); /* TODO: don't accept EINVAL */
 160 }
 161
 162 TEST_F(BinderDriverInterfaceTest, SetIdleTimeoutNoTest) {
 163     int64_t idle_timeout = 100000;
 164     binderTestIoctlUnimplemented(BINDER_SET_IDLE_TIMEOUT, &idle_timeout);
 165 }
 166
 167 TEST_F(BinderDriverInterfaceTest, SetMaxThreads) {
 168     uint32_t max_threads = 0;
 169     binderTestIoctl(BINDER_SET_MAX_THREADS, &max_threads);
 170 }
 171
 172 TEST_F(BinderDriverInterfaceTest, SetIdlePriorityNoTest) {
 173     int idle_priority = 0;
 174     binderTestIoctlUnimplemented(BINDER_SET_IDLE_PRIORITY, &idle_priority);
 175 }
 176
 177 TEST_F(BinderDriverInterfaceTest, SetContextMgrBusy) {
 178     int32_t dummy = 0;
 179     binderTestIoctlErr1(BINDER_SET_CONTEXT_MGR, &dummy, EBUSY);
 180 }
 181
 182 TEST_F(BinderDriverInterfaceTest, ThreadExit) {
 183     int32_t dummy = 0;
 184     binderTestIoctl(BINDER_THREAD_EXIT, &dummy);
 185     static_cast<BinderDriverInterfaceTestEnv *>(binder_env)->EnterLooper();
 186 }
 187
 188 TEST_F(BinderDriverInterfaceTest, WriteReadEmpty) {
 189     struct binder_write_read bwr = binder_write_read();
 190     binderTestIoctl(BINDER_WRITE_READ, &bwr);
 191 }
 192
 193 TEST_F(BinderDriverInterfaceTest, Read) {
 194     binderTestReadEmpty();
 195 }
 196
 197 TEST_F(BinderDriverInterfaceTest, IncRefsAcquireReleaseDecRefs) {
 198     const uint32_t bc[] = {
 199         BC_INCREFS,
 200         0,
 201         BC_ACQUIRE,
 202         0,
 203         BC_RELEASE,
 204         0,
 205         BC_DECREFS,
 206         0,
 207     };
 208     struct binder_write_read bwr = binder_write_read();
 209     bwr.write_buffer = (uintptr_t)bc;
 210     bwr.write_size = sizeof(bc);
 211     binderTestIoctl(BINDER_WRITE_READ, &bwr);
 212     EXPECT_EQ(sizeof(bc), bwr.write_consumed);
 213     binderTestReadEmpty();
 214 }
 215
 216 TEST_F(BinderDriverInterfaceTest, Transaction) {
 217     binder_uintptr_t cookie = 1234;
 218     struct {
 219         uint32_t cmd1;
 220         struct binder_transaction_data arg1;
 221     } __attribute__((packed)) bc1 = {
 222         .cmd1 = BC_TRANSACTION,
 223         .arg1 = {
 224             .target = { 0 },
 225             .cookie = 0,
 226             .code = android::IBinder::PING_TRANSACTION,
 227             .flags = 0,
 228             .sender_pid = 0,
 229             .sender_euid = 0,
 230             .data_size = 0,
 231             .offsets_size = 0,
 232             .data = {0, 0},
 233         },
 234     };
 235     struct {
 236         uint32_t cmd0;
 237         uint32_t cmd1;
 238         uint32_t cmd2;
 239         binder_transaction_data arg2;
 240         uint32_t pad[16];
 241     } __attribute__((packed)) br;
 242     struct binder_write_read bwr = binder_write_read();
 243
 244     bwr.write_buffer = (uintptr_t)&bc1;
 245     bwr.write_size = sizeof(bc1);
 246     bwr.read_buffer = (uintptr_t)&br;
 247     bwr.read_size = sizeof(br);
 248
 249     {
 250         SCOPED_TRACE("1st WriteRead");
 251         binderTestIoctl(BINDER_WRITE_READ, &bwr);
 252     }
 253     EXPECT_EQ(sizeof(bc1), bwr.write_consumed);
 254     if (bwr.read_consumed < offsetof(typeof(br), pad)) {
 255         SCOPED_TRACE("2nd WriteRead");
 256         binderWaitForReadData(10000);
 257         binderTestIoctl(BINDER_WRITE_READ, &bwr);
 258     }
 259     EXPECT_EQ(offsetof(typeof(br), pad), bwr.read_consumed);
 260     if (bwr.read_consumed > offsetof(typeof(br), cmd0))
 261         EXPECT_EQ(BR_NOOP, br.cmd0);
 262     if (bwr.read_consumed > offsetof(typeof(br), cmd1))
 263         EXPECT_EQ(BR_TRANSACTION_COMPLETE, br.cmd1);
 264     if (bwr.read_consumed > offsetof(typeof(br), cmd2))
 265         EXPECT_EQ(BR_REPLY, br.cmd2);
 266     if (bwr.read_consumed >= offsetof(typeof(br), pad)) {
 267         EXPECT_EQ(0u, br.arg2.target.ptr);
 268         EXPECT_EQ(0u, br.arg2.cookie);
 269         EXPECT_EQ(0u, br.arg2.code);
 270         EXPECT_EQ(0u, br.arg2.flags);
 271         EXPECT_EQ(0u, br.arg2.data_size);
 272         EXPECT_EQ(0u, br.arg2.offsets_size);
 273
 274         SCOPED_TRACE("3rd WriteRead");
 275
 276         binderTestReadEmpty();
 277
 278         struct {
 279             uint32_t cmd1;
 280             binder_uintptr_t arg1;
 281         } __attribute__((packed)) bc2 = {
 282             .cmd1 = BC_FREE_BUFFER,
 283             .arg1 = br.arg2.data.ptr.buffer,
 284         };
 285
 286         bwr.write_buffer = (uintptr_t)&bc2;
 287         bwr.write_size = sizeof(bc2);
 288         bwr.write_consumed = 0;
 289         bwr.read_size = 0;
 290
 291         binderTestIoctl(BINDER_WRITE_READ, &bwr);
 292         EXPECT_EQ(sizeof(bc2), bwr.write_consumed);
 293     }
 294     binderTestReadEmpty();
 295 }
 296
 297 TEST_F(BinderDriverInterfaceTest, RequestDeathNotification) {
 298     binder_uintptr_t cookie = 1234;
 299     struct {
 300         uint32_t cmd0;
 301         uint32_t arg0;
 302         uint32_t cmd1;
 303         struct binder_handle_cookie arg1;
 304         uint32_t cmd2;
 305         struct binder_handle_cookie arg2;
 306         uint32_t cmd3;
 307         uint32_t arg3;
 308     } __attribute__((packed)) bc = {
 309         .cmd0 = BC_INCREFS,
 310         .arg0 = 0,
 311         .cmd1 = BC_REQUEST_DEATH_NOTIFICATION,
 312         .arg1 = {
 313             .handle = 0,
 314             .cookie = cookie,
 315         },
 316         .cmd2 = BC_CLEAR_DEATH_NOTIFICATION,
 317         .arg2 = {
 318             .handle = 0,
 319             .cookie = cookie,
 320         },
 321         .cmd3 = BC_DECREFS,
 322         .arg3 = 0,
 323     };
 324     struct {
 325         uint32_t cmd0;
 326         uint32_t cmd1;
 327         binder_uintptr_t arg1;
 328         uint32_t pad[16];
 329     } __attribute__((packed)) br;
 330     struct binder_write_read bwr = binder_write_read();
 331
 332     bwr.write_buffer = (uintptr_t)&bc;
 333     bwr.write_size = sizeof(bc);
 334     bwr.read_buffer = (uintptr_t)&br;
 335     bwr.read_size = sizeof(br);
 336
 337     binderTestIoctl(BINDER_WRITE_READ, &bwr);
 338     EXPECT_EQ(sizeof(bc), bwr.write_consumed);
 339     EXPECT_EQ(sizeof(br) - sizeof(br.pad), bwr.read_consumed);
 340     EXPECT_EQ(BR_NOOP, br.cmd0);
 341     EXPECT_EQ(BR_CLEAR_DEATH_NOTIFICATION_DONE, br.cmd1);
 342     EXPECT_EQ(cookie, br.arg1);
 343     binderTestReadEmpty();
 344 }
 345
 346 int main(int argc, char **argv) {
 347     ::testing::InitGoogleTest(&argc, argv);
 348
 349     binder_env = AddGlobalTestEnvironment(new BinderDriverInterfaceTestEnv());
 350
 351     return RUN_ALL_TESTS();
 352 }
 353