1/* http://frotznet.googlecode.com/svn/trunk/utils/fdevent.c
2**
3** Copyright 2006, Brian Swetland <swetland@frotz.net>
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18#define TRACE_TAG FDEVENT
19
20#include "sysdeps.h"
21#include "fdevent.h"
22
23#include <fcntl.h>
24#include <stdlib.h>
25#include <string.h>
26#include <unistd.h>
27
28#include <atomic>
29#include <list>
30#include <unordered_map>
31#include <vector>
32
33#include <android-base/logging.h>
34#include <android-base/stringprintf.h>
35
36#include "adb_io.h"
37#include "adb_trace.h"
38#include "adb_utils.h"
39
40#if !ADB_HOST
41// This socket is used when a subproc shell service exists.
42// It wakes up the fdevent_loop() and cause the correct handling
43// of the shell's pseudo-tty master. I.e. force close it.
44int SHELL_EXIT_NOTIFY_FD = -1;
45#endif // !ADB_HOST
46
47#define FDE_EVENTMASK  0x00ff
48#define FDE_STATEMASK  0xff00
49
50#define FDE_ACTIVE     0x0100
51#define FDE_PENDING    0x0200
52#define FDE_CREATED    0x0400
53
54struct PollNode {
55  fdevent* fde;
56  adb_pollfd pollfd;
57
58  explicit PollNode(fdevent* fde) : fde(fde) {
59      memset(&pollfd, 0, sizeof(pollfd));
60      pollfd.fd = fde->fd;
61
62#if defined(__linux__)
63      // Always enable POLLRDHUP, so the host server can take action when some clients disconnect.
64      // Then we can avoid leaving many sockets in CLOSE_WAIT state. See http://b/23314034.
65      pollfd.events = POLLRDHUP;
66#endif
67  }
68};
69
70// All operations to fdevent should happen only in the main thread.
71// That's why we don't need a lock for fdevent.
72static auto& g_poll_node_map = *new std::unordered_map<int, PollNode>();
73static auto& g_pending_list = *new std::list<fdevent*>();
74static std::atomic<bool> terminate_loop(false);
75static bool main_thread_valid;
76static unsigned long main_thread_id;
77
78static void check_main_thread() {
79    if (main_thread_valid) {
80        CHECK_EQ(main_thread_id, adb_thread_id());
81    }
82}
83
84static void set_main_thread() {
85    main_thread_valid = true;
86    main_thread_id = adb_thread_id();
87}
88
89static std::string dump_fde(const fdevent* fde) {
90    std::string state;
91    if (fde->state & FDE_ACTIVE) {
92        state += "A";
93    }
94    if (fde->state & FDE_PENDING) {
95        state += "P";
96    }
97    if (fde->state & FDE_CREATED) {
98        state += "C";
99    }
100    if (fde->state & FDE_READ) {
101        state += "R";
102    }
103    if (fde->state & FDE_WRITE) {
104        state += "W";
105    }
106    if (fde->state & FDE_ERROR) {
107        state += "E";
108    }
109    if (fde->state & FDE_DONT_CLOSE) {
110        state += "D";
111    }
112    return android::base::StringPrintf("(fdevent %d %s)", fde->fd, state.c_str());
113}
114
115fdevent *fdevent_create(int fd, fd_func func, void *arg)
116{
117    check_main_thread();
118    fdevent *fde = (fdevent*) malloc(sizeof(fdevent));
119    if(fde == 0) return 0;
120    fdevent_install(fde, fd, func, arg);
121    fde->state |= FDE_CREATED;
122    return fde;
123}
124
125void fdevent_destroy(fdevent *fde)
126{
127    check_main_thread();
128    if(fde == 0) return;
129    if(!(fde->state & FDE_CREATED)) {
130        LOG(FATAL) << "destroying fde not created by fdevent_create(): " << dump_fde(fde);
131    }
132    fdevent_remove(fde);
133    free(fde);
134}
135
136void fdevent_install(fdevent* fde, int fd, fd_func func, void* arg) {
137    check_main_thread();
138    CHECK_GE(fd, 0);
139    memset(fde, 0, sizeof(fdevent));
140    fde->state = FDE_ACTIVE;
141    fde->fd = fd;
142    fde->func = func;
143    fde->arg = arg;
144    if (!set_file_block_mode(fd, false)) {
145        // Here is not proper to handle the error. If it fails here, some error is
146        // likely to be detected by poll(), then we can let the callback function
147        // to handle it.
148        LOG(ERROR) << "failed to set non-blocking mode for fd " << fd;
149    }
150    auto pair = g_poll_node_map.emplace(fde->fd, PollNode(fde));
151    CHECK(pair.second) << "install existing fd " << fd;
152    D("fdevent_install %s", dump_fde(fde).c_str());
153}
154
155void fdevent_remove(fdevent* fde) {
156    check_main_thread();
157    D("fdevent_remove %s", dump_fde(fde).c_str());
158    if (fde->state & FDE_ACTIVE) {
159        g_poll_node_map.erase(fde->fd);
160        if (fde->state & FDE_PENDING) {
161            g_pending_list.remove(fde);
162        }
163        if (!(fde->state & FDE_DONT_CLOSE)) {
164            adb_close(fde->fd);
165            fde->fd = -1;
166        }
167        fde->state = 0;
168        fde->events = 0;
169    }
170}
171
172static void fdevent_update(fdevent* fde, unsigned events) {
173    auto it = g_poll_node_map.find(fde->fd);
174    CHECK(it != g_poll_node_map.end());
175    PollNode& node = it->second;
176    if (events & FDE_READ) {
177        node.pollfd.events |= POLLIN;
178    } else {
179        node.pollfd.events &= ~POLLIN;
180    }
181
182    if (events & FDE_WRITE) {
183        node.pollfd.events |= POLLOUT;
184    } else {
185        node.pollfd.events &= ~POLLOUT;
186    }
187    fde->state = (fde->state & FDE_STATEMASK) | events;
188}
189
190void fdevent_set(fdevent* fde, unsigned events) {
191    check_main_thread();
192    events &= FDE_EVENTMASK;
193    if ((fde->state & FDE_EVENTMASK) == events) {
194        return;
195    }
196    CHECK(fde->state & FDE_ACTIVE);
197    fdevent_update(fde, events);
198    D("fdevent_set: %s, events = %u", dump_fde(fde).c_str(), events);
199
200    if (fde->state & FDE_PENDING) {
201        // If we are pending, make sure we don't signal an event that is no longer wanted.
202        fde->events &= events;
203        if (fde->events == 0) {
204            g_pending_list.remove(fde);
205            fde->state &= ~FDE_PENDING;
206        }
207    }
208}
209
210void fdevent_add(fdevent* fde, unsigned events) {
211    check_main_thread();
212    fdevent_set(fde, (fde->state & FDE_EVENTMASK) | events);
213}
214
215void fdevent_del(fdevent* fde, unsigned events) {
216    check_main_thread();
217    fdevent_set(fde, (fde->state & FDE_EVENTMASK) & ~events);
218}
219
220static std::string dump_pollfds(const std::vector<adb_pollfd>& pollfds) {
221    std::string result;
222    for (const auto& pollfd : pollfds) {
223        std::string op;
224        if (pollfd.events & POLLIN) {
225            op += "R";
226        }
227        if (pollfd.events & POLLOUT) {
228            op += "W";
229        }
230        android::base::StringAppendF(&result, " %d(%s)", pollfd.fd, op.c_str());
231    }
232    return result;
233}
234
235static void fdevent_process() {
236    std::vector<adb_pollfd> pollfds;
237    for (const auto& pair : g_poll_node_map) {
238        pollfds.push_back(pair.second.pollfd);
239    }
240    CHECK_GT(pollfds.size(), 0u);
241    D("poll(), pollfds = %s", dump_pollfds(pollfds).c_str());
242    int ret = adb_poll(&pollfds[0], pollfds.size(), -1);
243    if (ret == -1) {
244        PLOG(ERROR) << "poll(), ret = " << ret;
245        return;
246    }
247    for (const auto& pollfd : pollfds) {
248        if (pollfd.revents != 0) {
249            D("for fd %d, revents = %x", pollfd.fd, pollfd.revents);
250        }
251        unsigned events = 0;
252        if (pollfd.revents & POLLIN) {
253            events |= FDE_READ;
254        }
255        if (pollfd.revents & POLLOUT) {
256            events |= FDE_WRITE;
257        }
258        if (pollfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
259            // We fake a read, as the rest of the code assumes that errors will
260            // be detected at that point.
261            events |= FDE_READ | FDE_ERROR;
262        }
263#if defined(__linux__)
264        if (pollfd.revents & POLLRDHUP) {
265            events |= FDE_READ | FDE_ERROR;
266        }
267#endif
268        if (events != 0) {
269            auto it = g_poll_node_map.find(pollfd.fd);
270            CHECK(it != g_poll_node_map.end());
271            fdevent* fde = it->second.fde;
272            CHECK_EQ(fde->fd, pollfd.fd);
273            fde->events |= events;
274            D("%s got events %x", dump_fde(fde).c_str(), events);
275            fde->state |= FDE_PENDING;
276            g_pending_list.push_back(fde);
277        }
278    }
279}
280
281static void fdevent_call_fdfunc(fdevent* fde)
282{
283    unsigned events = fde->events;
284    fde->events = 0;
285    CHECK(fde->state & FDE_PENDING);
286    fde->state &= (~FDE_PENDING);
287    D("fdevent_call_fdfunc %s", dump_fde(fde).c_str());
288    fde->func(fde->fd, events, fde->arg);
289}
290
291#if !ADB_HOST
292
293#include <sys/ioctl.h>
294
295static void fdevent_subproc_event_func(int fd, unsigned ev,
296                                       void* /* userdata */)
297{
298
299    D("subproc handling on fd = %d, ev = %x", fd, ev);
300
301    CHECK_GE(fd, 0);
302
303    if (ev & FDE_READ) {
304        int subproc_fd;
305
306        if(!ReadFdExactly(fd, &subproc_fd, sizeof(subproc_fd))) {
307            LOG(FATAL) << "Failed to read the subproc's fd from " << fd;
308        }
309        auto it = g_poll_node_map.find(subproc_fd);
310        if (it == g_poll_node_map.end()) {
311            D("subproc_fd %d cleared from fd_table", subproc_fd);
312            adb_close(subproc_fd);
313            return;
314        }
315        fdevent* subproc_fde = it->second.fde;
316        if(subproc_fde->fd != subproc_fd) {
317            // Already reallocated?
318            LOG(FATAL) << "subproc_fd(" << subproc_fd << ") != subproc_fde->fd(" << subproc_fde->fd
319                       << ")";
320            return;
321        }
322
323        subproc_fde->force_eof = 1;
324
325        int rcount = 0;
326        ioctl(subproc_fd, FIONREAD, &rcount);
327        D("subproc with fd %d has rcount=%d, err=%d", subproc_fd, rcount, errno);
328        if (rcount != 0) {
329            // If there is data left, it will show up in the select().
330            // This works because there is no other thread reading that
331            // data when in this fd_func().
332            return;
333        }
334
335        D("subproc_fde %s", dump_fde(subproc_fde).c_str());
336        subproc_fde->events |= FDE_READ;
337        if(subproc_fde->state & FDE_PENDING) {
338            return;
339        }
340        subproc_fde->state |= FDE_PENDING;
341        fdevent_call_fdfunc(subproc_fde);
342    }
343}
344
345void fdevent_subproc_setup()
346{
347    int s[2];
348
349    if(adb_socketpair(s)) {
350        PLOG(FATAL) << "cannot create shell-exit socket-pair";
351    }
352    D("fdevent_subproc: socket pair (%d, %d)", s[0], s[1]);
353
354    SHELL_EXIT_NOTIFY_FD = s[0];
355    fdevent *fde = fdevent_create(s[1], fdevent_subproc_event_func, NULL);
356    CHECK(fde != nullptr) << "cannot create fdevent for shell-exit handler";
357    fdevent_add(fde, FDE_READ);
358}
359#endif // !ADB_HOST
360
361void fdevent_loop()
362{
363    set_main_thread();
364#if !ADB_HOST
365    fdevent_subproc_setup();
366#endif // !ADB_HOST
367
368    while (true) {
369        if (terminate_loop) {
370            return;
371        }
372
373        D("--- --- waiting for events");
374
375        fdevent_process();
376
377        while (!g_pending_list.empty()) {
378            fdevent* fde = g_pending_list.front();
379            g_pending_list.pop_front();
380            fdevent_call_fdfunc(fde);
381        }
382    }
383}
384
385void fdevent_terminate_loop() {
386    terminate_loop = true;
387}
388
389size_t fdevent_installed_count() {
390    return g_poll_node_map.size();
391}
392
393void fdevent_reset() {
394    g_poll_node_map.clear();
395    g_pending_list.clear();
396    main_thread_valid = false;
397    terminate_loop = false;
398}
399