The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 1 | /* http://frotznet.googlecode.com/svn/trunk/utils/fdevent.c |
| 2 | ** |
| 3 | ** Copyright 2006, Brian Swetland <swetland@frotz.net> |
| 4 | ** |
Elliott Hughes | aa24549 | 2015-08-03 10:38:08 -0700 | [diff] [blame] | 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 |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 8 | ** |
Elliott Hughes | aa24549 | 2015-08-03 10:38:08 -0700 | [diff] [blame] | 9 | ** http://www.apache.org/licenses/LICENSE-2.0 |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 10 | ** |
Elliott Hughes | aa24549 | 2015-08-03 10:38:08 -0700 | [diff] [blame] | 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 |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 15 | ** limitations under the License. |
| 16 | */ |
| 17 | |
Yabin Cui | aed3c61 | 2015-09-22 15:52:57 -0700 | [diff] [blame] | 18 | #define TRACE_TAG FDEVENT |
JP Abgrall | 408fa57 | 2011-03-16 15:57:42 -0700 | [diff] [blame] | 19 | |
Dan Albert | 3313426 | 2015-03-19 15:21:08 -0700 | [diff] [blame] | 20 | #include "sysdeps.h" |
| 21 | #include "fdevent.h" |
| 22 | |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 23 | #include <fcntl.h> |
Dan Albert | 3313426 | 2015-03-19 15:21:08 -0700 | [diff] [blame] | 24 | #include <stdlib.h> |
| 25 | #include <string.h> |
Dan Albert | 3313426 | 2015-03-19 15:21:08 -0700 | [diff] [blame] | 26 | #include <unistd.h> |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 27 | |
Josh Gao | 022d447 | 2016-02-10 14:49:00 -0800 | [diff] [blame] | 28 | #include <atomic> |
Josh Gao | e39ccd3 | 2018-02-23 14:37:07 -0800 | [diff] [blame] | 29 | #include <deque> |
Josh Gao | 4c93639 | 2017-05-03 14:10:39 -0700 | [diff] [blame] | 30 | #include <functional> |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 31 | #include <list> |
Josh Gao | 4c93639 | 2017-05-03 14:10:39 -0700 | [diff] [blame] | 32 | #include <mutex> |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 33 | #include <unordered_map> |
| 34 | #include <vector> |
| 35 | |
Elliott Hughes | 4f71319 | 2015-12-04 22:00:26 -0800 | [diff] [blame] | 36 | #include <android-base/logging.h> |
| 37 | #include <android-base/stringprintf.h> |
Josh Gao | 4c93639 | 2017-05-03 14:10:39 -0700 | [diff] [blame] | 38 | #include <android-base/thread_annotations.h> |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 39 | |
Dan Albert | cc731cc | 2015-02-24 21:26:58 -0800 | [diff] [blame] | 40 | #include "adb_io.h" |
leozwang | d3fc15f | 2014-07-29 12:50:02 -0700 | [diff] [blame] | 41 | #include "adb_trace.h" |
Josh Gao | 4c93639 | 2017-05-03 14:10:39 -0700 | [diff] [blame] | 42 | #include "adb_unique_fd.h" |
Yabin Cui | 6dfef25 | 2015-10-06 15:10:05 -0700 | [diff] [blame] | 43 | #include "adb_utils.h" |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 44 | |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 45 | #if !ADB_HOST |
JP Abgrall | 408fa57 | 2011-03-16 15:57:42 -0700 | [diff] [blame] | 46 | // This socket is used when a subproc shell service exists. |
| 47 | // It wakes up the fdevent_loop() and cause the correct handling |
| 48 | // of the shell's pseudo-tty master. I.e. force close it. |
| 49 | int SHELL_EXIT_NOTIFY_FD = -1; |
Alex Vallée | 947cb3e | 2015-07-17 15:30:59 -0400 | [diff] [blame] | 50 | #endif // !ADB_HOST |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 51 | |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 52 | #define FDE_EVENTMASK 0x00ff |
| 53 | #define FDE_STATEMASK 0xff00 |
| 54 | |
| 55 | #define FDE_ACTIVE 0x0100 |
| 56 | #define FDE_PENDING 0x0200 |
| 57 | #define FDE_CREATED 0x0400 |
| 58 | |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 59 | struct PollNode { |
| 60 | fdevent* fde; |
Josh Gao | 3777d2e | 2016-02-16 17:34:53 -0800 | [diff] [blame] | 61 | adb_pollfd pollfd; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 62 | |
Chih-Hung Hsieh | 1c563d9 | 2016-04-29 15:44:04 -0700 | [diff] [blame] | 63 | explicit PollNode(fdevent* fde) : fde(fde) { |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 64 | memset(&pollfd, 0, sizeof(pollfd)); |
| 65 | pollfd.fd = fde->fd; |
Yabin Cui | aa77e22 | 2015-09-29 12:25:33 -0700 | [diff] [blame] | 66 | |
| 67 | #if defined(__linux__) |
| 68 | // Always enable POLLRDHUP, so the host server can take action when some clients disconnect. |
| 69 | // Then we can avoid leaving many sockets in CLOSE_WAIT state. See http://b/23314034. |
| 70 | pollfd.events = POLLRDHUP; |
| 71 | #endif |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 72 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 73 | }; |
| 74 | |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 75 | // All operations to fdevent should happen only in the main thread. |
| 76 | // That's why we don't need a lock for fdevent. |
Josh Gao | b7b1edf | 2015-11-11 17:56:12 -0800 | [diff] [blame] | 77 | static auto& g_poll_node_map = *new std::unordered_map<int, PollNode>(); |
| 78 | static auto& g_pending_list = *new std::list<fdevent*>(); |
Josh Gao | 022d447 | 2016-02-10 14:49:00 -0800 | [diff] [blame] | 79 | static std::atomic<bool> terminate_loop(false); |
Yabin Cui | fbfa840 | 2015-10-30 18:37:26 -0700 | [diff] [blame] | 80 | static bool main_thread_valid; |
Josh Gao | 3777d2e | 2016-02-16 17:34:53 -0800 | [diff] [blame] | 81 | static unsigned long main_thread_id; |
Yabin Cui | fbfa840 | 2015-10-30 18:37:26 -0700 | [diff] [blame] | 82 | |
Josh Gao | 4c93639 | 2017-05-03 14:10:39 -0700 | [diff] [blame] | 83 | static auto& run_queue_notify_fd = *new unique_fd(); |
| 84 | static auto& run_queue_mutex = *new std::mutex(); |
Josh Gao | e39ccd3 | 2018-02-23 14:37:07 -0800 | [diff] [blame] | 85 | static auto& run_queue GUARDED_BY(run_queue_mutex) = *new std::deque<std::function<void()>>(); |
Josh Gao | 4c93639 | 2017-05-03 14:10:39 -0700 | [diff] [blame] | 86 | |
Yabin Cui | b5e1141 | 2017-03-10 16:01:01 -0800 | [diff] [blame] | 87 | void check_main_thread() { |
Yabin Cui | fbfa840 | 2015-10-30 18:37:26 -0700 | [diff] [blame] | 88 | if (main_thread_valid) { |
Josh Gao | 3777d2e | 2016-02-16 17:34:53 -0800 | [diff] [blame] | 89 | CHECK_EQ(main_thread_id, adb_thread_id()); |
Yabin Cui | fbfa840 | 2015-10-30 18:37:26 -0700 | [diff] [blame] | 90 | } |
| 91 | } |
| 92 | |
Yabin Cui | b5e1141 | 2017-03-10 16:01:01 -0800 | [diff] [blame] | 93 | void set_main_thread() { |
Yabin Cui | fbfa840 | 2015-10-30 18:37:26 -0700 | [diff] [blame] | 94 | main_thread_valid = true; |
Josh Gao | 3777d2e | 2016-02-16 17:34:53 -0800 | [diff] [blame] | 95 | main_thread_id = adb_thread_id(); |
Yabin Cui | fbfa840 | 2015-10-30 18:37:26 -0700 | [diff] [blame] | 96 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 97 | |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 98 | static std::string dump_fde(const fdevent* fde) { |
| 99 | std::string state; |
| 100 | if (fde->state & FDE_ACTIVE) { |
| 101 | state += "A"; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 102 | } |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 103 | if (fde->state & FDE_PENDING) { |
| 104 | state += "P"; |
| 105 | } |
| 106 | if (fde->state & FDE_CREATED) { |
| 107 | state += "C"; |
| 108 | } |
| 109 | if (fde->state & FDE_READ) { |
| 110 | state += "R"; |
| 111 | } |
| 112 | if (fde->state & FDE_WRITE) { |
| 113 | state += "W"; |
| 114 | } |
| 115 | if (fde->state & FDE_ERROR) { |
| 116 | state += "E"; |
| 117 | } |
| 118 | if (fde->state & FDE_DONT_CLOSE) { |
| 119 | state += "D"; |
| 120 | } |
| 121 | return android::base::StringPrintf("(fdevent %d %s)", fde->fd, state.c_str()); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 122 | } |
| 123 | |
Josh Gao | 4c93639 | 2017-05-03 14:10:39 -0700 | [diff] [blame] | 124 | fdevent* fdevent_create(int fd, fd_func func, void* arg) { |
Yabin Cui | fbfa840 | 2015-10-30 18:37:26 -0700 | [diff] [blame] | 125 | check_main_thread(); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 126 | fdevent *fde = (fdevent*) malloc(sizeof(fdevent)); |
| 127 | if(fde == 0) return 0; |
| 128 | fdevent_install(fde, fd, func, arg); |
| 129 | fde->state |= FDE_CREATED; |
| 130 | return fde; |
| 131 | } |
| 132 | |
Josh Gao | 4c93639 | 2017-05-03 14:10:39 -0700 | [diff] [blame] | 133 | void fdevent_destroy(fdevent* fde) { |
Yabin Cui | fbfa840 | 2015-10-30 18:37:26 -0700 | [diff] [blame] | 134 | check_main_thread(); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 135 | if(fde == 0) return; |
| 136 | if(!(fde->state & FDE_CREATED)) { |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 137 | LOG(FATAL) << "destroying fde not created by fdevent_create(): " << dump_fde(fde); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 138 | } |
| 139 | fdevent_remove(fde); |
SungHyun Kwon | abb80e0 | 2015-03-03 13:56:42 +0900 | [diff] [blame] | 140 | free(fde); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 141 | } |
| 142 | |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 143 | void fdevent_install(fdevent* fde, int fd, fd_func func, void* arg) { |
Yabin Cui | fbfa840 | 2015-10-30 18:37:26 -0700 | [diff] [blame] | 144 | check_main_thread(); |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 145 | CHECK_GE(fd, 0); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 146 | memset(fde, 0, sizeof(fdevent)); |
| 147 | fde->state = FDE_ACTIVE; |
| 148 | fde->fd = fd; |
| 149 | fde->func = func; |
| 150 | fde->arg = arg; |
Yabin Cui | 6dfef25 | 2015-10-06 15:10:05 -0700 | [diff] [blame] | 151 | if (!set_file_block_mode(fd, false)) { |
Yabin Cui | c1b1f6f | 2015-09-15 16:27:09 -0700 | [diff] [blame] | 152 | // Here is not proper to handle the error. If it fails here, some error is |
| 153 | // likely to be detected by poll(), then we can let the callback function |
| 154 | // to handle it. |
Yabin Cui | 6dfef25 | 2015-10-06 15:10:05 -0700 | [diff] [blame] | 155 | LOG(ERROR) << "failed to set non-blocking mode for fd " << fd; |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 156 | } |
| 157 | auto pair = g_poll_node_map.emplace(fde->fd, PollNode(fde)); |
| 158 | CHECK(pair.second) << "install existing fd " << fd; |
| 159 | D("fdevent_install %s", dump_fde(fde).c_str()); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 160 | } |
| 161 | |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 162 | void fdevent_remove(fdevent* fde) { |
Yabin Cui | fbfa840 | 2015-10-30 18:37:26 -0700 | [diff] [blame] | 163 | check_main_thread(); |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 164 | D("fdevent_remove %s", dump_fde(fde).c_str()); |
| 165 | if (fde->state & FDE_ACTIVE) { |
| 166 | g_poll_node_map.erase(fde->fd); |
| 167 | if (fde->state & FDE_PENDING) { |
| 168 | g_pending_list.remove(fde); |
| 169 | } |
| 170 | if (!(fde->state & FDE_DONT_CLOSE)) { |
| 171 | adb_close(fde->fd); |
| 172 | fde->fd = -1; |
| 173 | } |
| 174 | fde->state = 0; |
| 175 | fde->events = 0; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 176 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 177 | } |
| 178 | |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 179 | static void fdevent_update(fdevent* fde, unsigned events) { |
| 180 | auto it = g_poll_node_map.find(fde->fd); |
| 181 | CHECK(it != g_poll_node_map.end()); |
| 182 | PollNode& node = it->second; |
| 183 | if (events & FDE_READ) { |
| 184 | node.pollfd.events |= POLLIN; |
| 185 | } else { |
| 186 | node.pollfd.events &= ~POLLIN; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 187 | } |
| 188 | |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 189 | if (events & FDE_WRITE) { |
| 190 | node.pollfd.events |= POLLOUT; |
| 191 | } else { |
| 192 | node.pollfd.events &= ~POLLOUT; |
| 193 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 194 | fde->state = (fde->state & FDE_STATEMASK) | events; |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 195 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 196 | |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 197 | void fdevent_set(fdevent* fde, unsigned events) { |
Yabin Cui | fbfa840 | 2015-10-30 18:37:26 -0700 | [diff] [blame] | 198 | check_main_thread(); |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 199 | events &= FDE_EVENTMASK; |
| 200 | if ((fde->state & FDE_EVENTMASK) == events) { |
| 201 | return; |
| 202 | } |
Spencer Low | 888a748 | 2015-09-29 18:33:38 -0700 | [diff] [blame] | 203 | CHECK(fde->state & FDE_ACTIVE); |
| 204 | fdevent_update(fde, events); |
| 205 | D("fdevent_set: %s, events = %u", dump_fde(fde).c_str(), events); |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 206 | |
Spencer Low | 888a748 | 2015-09-29 18:33:38 -0700 | [diff] [blame] | 207 | if (fde->state & FDE_PENDING) { |
| 208 | // If we are pending, make sure we don't signal an event that is no longer wanted. |
| 209 | fde->events &= events; |
| 210 | if (fde->events == 0) { |
| 211 | g_pending_list.remove(fde); |
| 212 | fde->state &= ~FDE_PENDING; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 213 | } |
| 214 | } |
| 215 | } |
| 216 | |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 217 | void fdevent_add(fdevent* fde, unsigned events) { |
Yabin Cui | fbfa840 | 2015-10-30 18:37:26 -0700 | [diff] [blame] | 218 | check_main_thread(); |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 219 | fdevent_set(fde, (fde->state & FDE_EVENTMASK) | events); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 220 | } |
| 221 | |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 222 | void fdevent_del(fdevent* fde, unsigned events) { |
Yabin Cui | fbfa840 | 2015-10-30 18:37:26 -0700 | [diff] [blame] | 223 | check_main_thread(); |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 224 | fdevent_set(fde, (fde->state & FDE_EVENTMASK) & ~events); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 225 | } |
| 226 | |
Josh Gao | 3777d2e | 2016-02-16 17:34:53 -0800 | [diff] [blame] | 227 | static std::string dump_pollfds(const std::vector<adb_pollfd>& pollfds) { |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 228 | std::string result; |
Elliott Hughes | 65fe251 | 2015-10-07 15:59:35 -0700 | [diff] [blame] | 229 | for (const auto& pollfd : pollfds) { |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 230 | std::string op; |
| 231 | if (pollfd.events & POLLIN) { |
| 232 | op += "R"; |
| 233 | } |
| 234 | if (pollfd.events & POLLOUT) { |
| 235 | op += "W"; |
| 236 | } |
| 237 | android::base::StringAppendF(&result, " %d(%s)", pollfd.fd, op.c_str()); |
| 238 | } |
| 239 | return result; |
| 240 | } |
| 241 | |
| 242 | static void fdevent_process() { |
Josh Gao | 3777d2e | 2016-02-16 17:34:53 -0800 | [diff] [blame] | 243 | std::vector<adb_pollfd> pollfds; |
Elliott Hughes | 65fe251 | 2015-10-07 15:59:35 -0700 | [diff] [blame] | 244 | for (const auto& pair : g_poll_node_map) { |
| 245 | pollfds.push_back(pair.second.pollfd); |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 246 | } |
| 247 | CHECK_GT(pollfds.size(), 0u); |
| 248 | D("poll(), pollfds = %s", dump_pollfds(pollfds).c_str()); |
Josh Gao | 3777d2e | 2016-02-16 17:34:53 -0800 | [diff] [blame] | 249 | int ret = adb_poll(&pollfds[0], pollfds.size(), -1); |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 250 | if (ret == -1) { |
Yabin Cui | c1b1f6f | 2015-09-15 16:27:09 -0700 | [diff] [blame] | 251 | PLOG(ERROR) << "poll(), ret = " << ret; |
| 252 | return; |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 253 | } |
Elliott Hughes | 65fe251 | 2015-10-07 15:59:35 -0700 | [diff] [blame] | 254 | for (const auto& pollfd : pollfds) { |
Yabin Cui | c1b1f6f | 2015-09-15 16:27:09 -0700 | [diff] [blame] | 255 | if (pollfd.revents != 0) { |
| 256 | D("for fd %d, revents = %x", pollfd.fd, pollfd.revents); |
| 257 | } |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 258 | unsigned events = 0; |
| 259 | if (pollfd.revents & POLLIN) { |
| 260 | events |= FDE_READ; |
| 261 | } |
| 262 | if (pollfd.revents & POLLOUT) { |
| 263 | events |= FDE_WRITE; |
| 264 | } |
| 265 | if (pollfd.revents & (POLLERR | POLLHUP | POLLNVAL)) { |
| 266 | // We fake a read, as the rest of the code assumes that errors will |
| 267 | // be detected at that point. |
| 268 | events |= FDE_READ | FDE_ERROR; |
| 269 | } |
Yabin Cui | aa77e22 | 2015-09-29 12:25:33 -0700 | [diff] [blame] | 270 | #if defined(__linux__) |
| 271 | if (pollfd.revents & POLLRDHUP) { |
| 272 | events |= FDE_READ | FDE_ERROR; |
| 273 | } |
| 274 | #endif |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 275 | if (events != 0) { |
| 276 | auto it = g_poll_node_map.find(pollfd.fd); |
| 277 | CHECK(it != g_poll_node_map.end()); |
| 278 | fdevent* fde = it->second.fde; |
| 279 | CHECK_EQ(fde->fd, pollfd.fd); |
| 280 | fde->events |= events; |
| 281 | D("%s got events %x", dump_fde(fde).c_str(), events); |
| 282 | fde->state |= FDE_PENDING; |
| 283 | g_pending_list.push_back(fde); |
| 284 | } |
| 285 | } |
| 286 | } |
| 287 | |
Josh Gao | 4c93639 | 2017-05-03 14:10:39 -0700 | [diff] [blame] | 288 | static void fdevent_call_fdfunc(fdevent* fde) { |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 289 | unsigned events = fde->events; |
| 290 | fde->events = 0; |
Spencer Low | 888a748 | 2015-09-29 18:33:38 -0700 | [diff] [blame] | 291 | CHECK(fde->state & FDE_PENDING); |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 292 | fde->state &= (~FDE_PENDING); |
| 293 | D("fdevent_call_fdfunc %s", dump_fde(fde).c_str()); |
| 294 | fde->func(fde->fd, events, fde->arg); |
| 295 | } |
| 296 | |
| 297 | #if !ADB_HOST |
Josh Gao | 3777d2e | 2016-02-16 17:34:53 -0800 | [diff] [blame] | 298 | |
| 299 | #include <sys/ioctl.h> |
| 300 | |
Josh Gao | 4c93639 | 2017-05-03 14:10:39 -0700 | [diff] [blame] | 301 | static void fdevent_subproc_event_func(int fd, unsigned ev, void* /* userdata */) { |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 302 | D("subproc handling on fd = %d, ev = %x", fd, ev); |
| 303 | |
| 304 | CHECK_GE(fd, 0); |
| 305 | |
| 306 | if (ev & FDE_READ) { |
| 307 | int subproc_fd; |
| 308 | |
| 309 | if(!ReadFdExactly(fd, &subproc_fd, sizeof(subproc_fd))) { |
| 310 | LOG(FATAL) << "Failed to read the subproc's fd from " << fd; |
| 311 | } |
| 312 | auto it = g_poll_node_map.find(subproc_fd); |
| 313 | if (it == g_poll_node_map.end()) { |
| 314 | D("subproc_fd %d cleared from fd_table", subproc_fd); |
Josh Gao | c65fae9 | 2016-01-19 16:21:17 -0800 | [diff] [blame] | 315 | adb_close(subproc_fd); |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 316 | return; |
| 317 | } |
| 318 | fdevent* subproc_fde = it->second.fde; |
| 319 | if(subproc_fde->fd != subproc_fd) { |
| 320 | // Already reallocated? |
Josh Gao | c65fae9 | 2016-01-19 16:21:17 -0800 | [diff] [blame] | 321 | LOG(FATAL) << "subproc_fd(" << subproc_fd << ") != subproc_fde->fd(" << subproc_fde->fd |
| 322 | << ")"; |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 323 | return; |
| 324 | } |
| 325 | |
| 326 | subproc_fde->force_eof = 1; |
| 327 | |
| 328 | int rcount = 0; |
| 329 | ioctl(subproc_fd, FIONREAD, &rcount); |
| 330 | D("subproc with fd %d has rcount=%d, err=%d", subproc_fd, rcount, errno); |
| 331 | if (rcount != 0) { |
| 332 | // If there is data left, it will show up in the select(). |
| 333 | // This works because there is no other thread reading that |
| 334 | // data when in this fd_func(). |
| 335 | return; |
| 336 | } |
| 337 | |
| 338 | D("subproc_fde %s", dump_fde(subproc_fde).c_str()); |
| 339 | subproc_fde->events |= FDE_READ; |
| 340 | if(subproc_fde->state & FDE_PENDING) { |
| 341 | return; |
| 342 | } |
| 343 | subproc_fde->state |= FDE_PENDING; |
| 344 | fdevent_call_fdfunc(subproc_fde); |
| 345 | } |
| 346 | } |
| 347 | |
Josh Gao | 4c93639 | 2017-05-03 14:10:39 -0700 | [diff] [blame] | 348 | static void fdevent_subproc_setup() { |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 349 | int s[2]; |
| 350 | |
| 351 | if(adb_socketpair(s)) { |
| 352 | PLOG(FATAL) << "cannot create shell-exit socket-pair"; |
| 353 | } |
| 354 | D("fdevent_subproc: socket pair (%d, %d)", s[0], s[1]); |
| 355 | |
| 356 | SHELL_EXIT_NOTIFY_FD = s[0]; |
| 357 | fdevent *fde = fdevent_create(s[1], fdevent_subproc_event_func, NULL); |
| 358 | CHECK(fde != nullptr) << "cannot create fdevent for shell-exit handler"; |
| 359 | fdevent_add(fde, FDE_READ); |
| 360 | } |
| 361 | #endif // !ADB_HOST |
| 362 | |
Josh Gao | e39ccd3 | 2018-02-23 14:37:07 -0800 | [diff] [blame] | 363 | static void fdevent_run_flush() EXCLUDES(run_queue_mutex) { |
| 364 | // We need to be careful around reentrancy here, since a function we call can queue up another |
| 365 | // function. |
| 366 | while (true) { |
| 367 | std::function<void()> fn; |
| 368 | { |
| 369 | std::lock_guard<std::mutex> lock(run_queue_mutex); |
| 370 | if (run_queue.empty()) { |
| 371 | break; |
| 372 | } |
| 373 | fn = run_queue.front(); |
| 374 | run_queue.pop_front(); |
| 375 | } |
| 376 | fn(); |
Josh Gao | 4c93639 | 2017-05-03 14:10:39 -0700 | [diff] [blame] | 377 | } |
Josh Gao | 4c93639 | 2017-05-03 14:10:39 -0700 | [diff] [blame] | 378 | } |
| 379 | |
| 380 | static void fdevent_run_func(int fd, unsigned ev, void* /* userdata */) { |
| 381 | CHECK_GE(fd, 0); |
| 382 | CHECK(ev & FDE_READ); |
| 383 | |
| 384 | char buf[1024]; |
| 385 | |
| 386 | // Empty the fd. |
| 387 | if (adb_read(fd, buf, sizeof(buf)) == -1) { |
| 388 | PLOG(FATAL) << "failed to empty run queue notify fd"; |
| 389 | } |
| 390 | |
Josh Gao | 4c93639 | 2017-05-03 14:10:39 -0700 | [diff] [blame] | 391 | fdevent_run_flush(); |
| 392 | } |
| 393 | |
| 394 | static void fdevent_run_setup() { |
Josh Gao | e39ccd3 | 2018-02-23 14:37:07 -0800 | [diff] [blame] | 395 | { |
| 396 | std::lock_guard<std::mutex> lock(run_queue_mutex); |
| 397 | CHECK(run_queue_notify_fd.get() == -1); |
| 398 | int s[2]; |
| 399 | if (adb_socketpair(s) != 0) { |
| 400 | PLOG(FATAL) << "failed to create run queue notify socketpair"; |
| 401 | } |
Josh Gao | 4c93639 | 2017-05-03 14:10:39 -0700 | [diff] [blame] | 402 | |
Josh Gao | e39ccd3 | 2018-02-23 14:37:07 -0800 | [diff] [blame] | 403 | run_queue_notify_fd.reset(s[0]); |
| 404 | fdevent* fde = fdevent_create(s[1], fdevent_run_func, nullptr); |
| 405 | CHECK(fde != nullptr); |
| 406 | fdevent_add(fde, FDE_READ); |
| 407 | } |
Josh Gao | 4c93639 | 2017-05-03 14:10:39 -0700 | [diff] [blame] | 408 | |
| 409 | fdevent_run_flush(); |
| 410 | } |
| 411 | |
| 412 | void fdevent_run_on_main_thread(std::function<void()> fn) { |
| 413 | std::lock_guard<std::mutex> lock(run_queue_mutex); |
| 414 | run_queue.push_back(std::move(fn)); |
| 415 | |
| 416 | // run_queue_notify_fd could still be -1 if we're called before fdevent has finished setting up. |
| 417 | // In that case, rely on the setup code to flush the queue without a notification being needed. |
| 418 | if (run_queue_notify_fd != -1) { |
| 419 | if (adb_write(run_queue_notify_fd.get(), "", 1) != 1) { |
| 420 | PLOG(FATAL) << "failed to write to run queue notify fd"; |
| 421 | } |
| 422 | } |
| 423 | } |
| 424 | |
| 425 | void fdevent_loop() { |
Yabin Cui | fbfa840 | 2015-10-30 18:37:26 -0700 | [diff] [blame] | 426 | set_main_thread(); |
Alex Vallée | 947cb3e | 2015-07-17 15:30:59 -0400 | [diff] [blame] | 427 | #if !ADB_HOST |
JP Abgrall | 408fa57 | 2011-03-16 15:57:42 -0700 | [diff] [blame] | 428 | fdevent_subproc_setup(); |
Alex Vallée | 947cb3e | 2015-07-17 15:30:59 -0400 | [diff] [blame] | 429 | #endif // !ADB_HOST |
Josh Gao | 4c93639 | 2017-05-03 14:10:39 -0700 | [diff] [blame] | 430 | fdevent_run_setup(); |
David 'Digit' Turner | f6330a2 | 2009-05-18 17:36:28 +0200 | [diff] [blame] | 431 | |
Elliott Hughes | aa24549 | 2015-08-03 10:38:08 -0700 | [diff] [blame] | 432 | while (true) { |
Josh Gao | 022d447 | 2016-02-10 14:49:00 -0800 | [diff] [blame] | 433 | if (terminate_loop) { |
| 434 | return; |
| 435 | } |
| 436 | |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 437 | D("--- --- waiting for events"); |
JP Abgrall | 408fa57 | 2011-03-16 15:57:42 -0700 | [diff] [blame] | 438 | |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 439 | fdevent_process(); |
David 'Digit' Turner | f6330a2 | 2009-05-18 17:36:28 +0200 | [diff] [blame] | 440 | |
Yabin Cui | a108016 | 2015-09-04 16:19:56 -0700 | [diff] [blame] | 441 | while (!g_pending_list.empty()) { |
| 442 | fdevent* fde = g_pending_list.front(); |
| 443 | g_pending_list.pop_front(); |
JP Abgrall | 408fa57 | 2011-03-16 15:57:42 -0700 | [diff] [blame] | 444 | fdevent_call_fdfunc(fde); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 445 | } |
| 446 | } |
| 447 | } |
Yabin Cui | c1b1f6f | 2015-09-15 16:27:09 -0700 | [diff] [blame] | 448 | |
Josh Gao | 022d447 | 2016-02-10 14:49:00 -0800 | [diff] [blame] | 449 | void fdevent_terminate_loop() { |
| 450 | terminate_loop = true; |
| 451 | } |
| 452 | |
Yabin Cui | c1b1f6f | 2015-09-15 16:27:09 -0700 | [diff] [blame] | 453 | size_t fdevent_installed_count() { |
| 454 | return g_poll_node_map.size(); |
| 455 | } |
| 456 | |
| 457 | void fdevent_reset() { |
| 458 | g_poll_node_map.clear(); |
| 459 | g_pending_list.clear(); |
Josh Gao | 4c93639 | 2017-05-03 14:10:39 -0700 | [diff] [blame] | 460 | |
| 461 | std::lock_guard<std::mutex> lock(run_queue_mutex); |
| 462 | run_queue_notify_fd.reset(); |
| 463 | run_queue.clear(); |
| 464 | |
Yabin Cui | fbfa840 | 2015-10-30 18:37:26 -0700 | [diff] [blame] | 465 | main_thread_valid = false; |
Josh Gao | 022d447 | 2016-02-10 14:49:00 -0800 | [diff] [blame] | 466 | terminate_loop = false; |
Yabin Cui | c1b1f6f | 2015-09-15 16:27:09 -0700 | [diff] [blame] | 467 | } |