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
30testing::Environment* binder_env;
31
32class 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 | O_CLOEXEC);
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
72class 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
136TEST_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
142TEST_F(BinderDriverInterfaceTest, WriteReadNull) {
143    binderTestIoctlErr1(BINDER_WRITE_READ, NULL, EFAULT);
144}
145
146TEST_F(BinderDriverInterfaceTest, SetIdleTimeoutNull) {
147    binderTestIoctlErr2(BINDER_SET_IDLE_TIMEOUT, NULL, EFAULT, EINVAL);
148}
149
150TEST_F(BinderDriverInterfaceTest, SetMaxThreadsNull) {
151    binderTestIoctlErr2(BINDER_SET_MAX_THREADS, NULL, EFAULT, EINVAL); /* TODO: don't accept EINVAL */
152}
153
154TEST_F(BinderDriverInterfaceTest, SetIdlePriorityNull) {
155    binderTestIoctlErr2(BINDER_SET_IDLE_PRIORITY, NULL, EFAULT, EINVAL);
156}
157
158TEST_F(BinderDriverInterfaceTest, VersionNull) {
159    binderTestIoctlErr2(BINDER_VERSION, NULL, EFAULT, EINVAL); /* TODO: don't accept EINVAL */
160}
161
162TEST_F(BinderDriverInterfaceTest, SetIdleTimeoutNoTest) {
163    int64_t idle_timeout = 100000;
164    binderTestIoctlUnimplemented(BINDER_SET_IDLE_TIMEOUT, &idle_timeout);
165}
166
167TEST_F(BinderDriverInterfaceTest, SetMaxThreads) {
168    uint32_t max_threads = 0;
169    binderTestIoctl(BINDER_SET_MAX_THREADS, &max_threads);
170}
171
172TEST_F(BinderDriverInterfaceTest, SetIdlePriorityNoTest) {
173    int idle_priority = 0;
174    binderTestIoctlUnimplemented(BINDER_SET_IDLE_PRIORITY, &idle_priority);
175}
176
177TEST_F(BinderDriverInterfaceTest, SetContextMgrBusy) {
178    int32_t dummy = 0;
179    binderTestIoctlErr1(BINDER_SET_CONTEXT_MGR, &dummy, EBUSY);
180}
181
182TEST_F(BinderDriverInterfaceTest, ThreadExit) {
183    int32_t dummy = 0;
184    binderTestIoctl(BINDER_THREAD_EXIT, &dummy);
185    static_cast<BinderDriverInterfaceTestEnv *>(binder_env)->EnterLooper();
186}
187
188TEST_F(BinderDriverInterfaceTest, WriteReadEmpty) {
189    struct binder_write_read bwr = binder_write_read();
190    binderTestIoctl(BINDER_WRITE_READ, &bwr);
191}
192
193TEST_F(BinderDriverInterfaceTest, Read) {
194    binderTestReadEmpty();
195}
196
197TEST_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
216TEST_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
297TEST_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
346int 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
354