fdevent.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695
  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. #include <sys/ioctl.h>
  18. #include <stdlib.h>
  19. #include <stdio.h>
  20. #include <string.h>
  21. #include <unistd.h>
  22. #include <errno.h>
  23. #include <fcntl.h>
  24. #include <stdarg.h>
  25. #include <stddef.h>
  26. #include "fdevent.h"
  27. #include "transport.h"
  28. #include "sysdeps.h"
  29. /* !!! Do not enable DEBUG for the adb that will run as the server:
  30. ** both stdout and stderr are used to communicate between the client
  31. ** and server. Any extra output will cause failures.
  32. */
  33. #define DEBUG 0 /* non-0 will break adb server */
  34. // This socket is used when a subproc shell service exists.
  35. // It wakes up the fdevent_loop() and cause the correct handling
  36. // of the shell's pseudo-tty master. I.e. force close it.
  37. int SHELL_EXIT_NOTIFY_FD = -1;
  38. static void fatal(const char *fn, const char *fmt, ...)
  39. {
  40. va_list ap;
  41. va_start(ap, fmt);
  42. fprintf(stderr, "%s:", fn);
  43. vfprintf(stderr, fmt, ap);
  44. va_end(ap);
  45. abort();
  46. }
  47. #define FATAL(x...) fatal(__FUNCTION__, x)
  48. #if DEBUG
  49. #define D(...) \
  50. do { \
  51. adb_mutex_lock(&D_lock); \
  52. int save_errno = errno; \
  53. fprintf(stderr, "%s::%s():", __FILE__, __FUNCTION__); \
  54. errno = save_errno; \
  55. fprintf(stderr, __VA_ARGS__); \
  56. adb_mutex_unlock(&D_lock); \
  57. errno = save_errno; \
  58. } while(0)
  59. static void dump_fde(fdevent *fde, const char *info)
  60. {
  61. adb_mutex_lock(&D_lock);
  62. fprintf(stderr,"FDE #%03d %c%c%c %s\n", fde->fd,
  63. fde->state & FDE_READ ? 'R' : ' ',
  64. fde->state & FDE_WRITE ? 'W' : ' ',
  65. fde->state & FDE_ERROR ? 'E' : ' ',
  66. info);
  67. adb_mutex_unlock(&D_lock);
  68. }
  69. #else
  70. #define D(...) ((void)0)
  71. #define dump_fde(fde, info) do { } while(0)
  72. #endif
  73. #define FDE_EVENTMASK 0x00ff
  74. #define FDE_STATEMASK 0xff00
  75. #define FDE_ACTIVE 0x0100
  76. #define FDE_PENDING 0x0200
  77. #define FDE_CREATED 0x0400
  78. static void fdevent_plist_enqueue(fdevent *node);
  79. static void fdevent_plist_remove(fdevent *node);
  80. static fdevent *fdevent_plist_dequeue(void);
  81. static void fdevent_subproc_event_func(int fd, unsigned events, void *userdata);
  82. static fdevent list_pending = {
  83. .next = &list_pending,
  84. .prev = &list_pending,
  85. };
  86. static fdevent **fd_table = 0;
  87. static int fd_table_max = 0;
  88. #ifdef CRAPTASTIC
  89. //HAVE_EPOLL
  90. #include <sys/epoll.h>
  91. static int epoll_fd = -1;
  92. static void fdevent_init()
  93. {
  94. /* XXX: what's a good size for the passed in hint? */
  95. epoll_fd = epoll_create(256);
  96. if(epoll_fd < 0) {
  97. perror("epoll_create() failed");
  98. exit(1);
  99. }
  100. /* mark for close-on-exec */
  101. fcntl(epoll_fd, F_SETFD, FD_CLOEXEC);
  102. }
  103. static void fdevent_connect(fdevent *fde)
  104. {
  105. struct epoll_event ev;
  106. memset(&ev, 0, sizeof(ev));
  107. ev.events = 0;
  108. ev.data.ptr = fde;
  109. #if 0
  110. if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fde->fd, &ev)) {
  111. perror("epoll_ctl() failed\n");
  112. exit(1);
  113. }
  114. #endif
  115. }
  116. static void fdevent_disconnect(fdevent *fde)
  117. {
  118. struct epoll_event ev;
  119. memset(&ev, 0, sizeof(ev));
  120. ev.events = 0;
  121. ev.data.ptr = fde;
  122. /* technically we only need to delete if we
  123. ** were actively monitoring events, but let's
  124. ** be aggressive and do it anyway, just in case
  125. ** something's out of sync
  126. */
  127. epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fde->fd, &ev);
  128. }
  129. static void fdevent_update(fdevent *fde, unsigned events)
  130. {
  131. struct epoll_event ev;
  132. int active;
  133. active = (fde->state & FDE_EVENTMASK) != 0;
  134. memset(&ev, 0, sizeof(ev));
  135. ev.events = 0;
  136. ev.data.ptr = fde;
  137. if(events & FDE_READ) ev.events |= EPOLLIN;
  138. if(events & FDE_WRITE) ev.events |= EPOLLOUT;
  139. if(events & FDE_ERROR) ev.events |= (EPOLLERR | EPOLLHUP);
  140. fde->state = (fde->state & FDE_STATEMASK) | events;
  141. if(active) {
  142. /* we're already active. if we're changing to *no*
  143. ** events being monitored, we need to delete, otherwise
  144. ** we need to just modify
  145. */
  146. if(ev.events) {
  147. if(epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fde->fd, &ev)) {
  148. perror("epoll_ctl() failed\n");
  149. exit(1);
  150. }
  151. } else {
  152. if(epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fde->fd, &ev)) {
  153. perror("epoll_ctl() failed\n");
  154. exit(1);
  155. }
  156. }
  157. } else {
  158. /* we're not active. if we're watching events, we need
  159. ** to add, otherwise we can just do nothing
  160. */
  161. if(ev.events) {
  162. if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fde->fd, &ev)) {
  163. perror("epoll_ctl() failed\n");
  164. exit(1);
  165. }
  166. }
  167. }
  168. }
  169. static void fdevent_process()
  170. {
  171. struct epoll_event events[256];
  172. fdevent *fde;
  173. int i, n;
  174. n = epoll_wait(epoll_fd, events, 256, -1);
  175. if(n < 0) {
  176. if(errno == EINTR) return;
  177. perror("epoll_wait");
  178. exit(1);
  179. }
  180. for(i = 0; i < n; i++) {
  181. struct epoll_event *ev = events + i;
  182. fde = ev->data.ptr;
  183. if(ev->events & EPOLLIN) {
  184. fde->events |= FDE_READ;
  185. }
  186. if(ev->events & EPOLLOUT) {
  187. fde->events |= FDE_WRITE;
  188. }
  189. if(ev->events & (EPOLLERR | EPOLLHUP)) {
  190. fde->events |= FDE_ERROR;
  191. }
  192. if(fde->events) {
  193. if(fde->state & FDE_PENDING) continue;
  194. fde->state |= FDE_PENDING;
  195. fdevent_plist_enqueue(fde);
  196. }
  197. }
  198. }
  199. #else /* USE_SELECT */
  200. #ifdef HAVE_WINSOCK
  201. #include <winsock2.h>
  202. #else
  203. #include <sys/select.h>
  204. #endif
  205. static fd_set read_fds;
  206. static fd_set write_fds;
  207. static fd_set error_fds;
  208. static int select_n = 0;
  209. static void fdevent_init(void)
  210. {
  211. FD_ZERO(&read_fds);
  212. FD_ZERO(&write_fds);
  213. FD_ZERO(&error_fds);
  214. }
  215. static void fdevent_connect(fdevent *fde)
  216. {
  217. if(fde->fd >= select_n) {
  218. select_n = fde->fd + 1;
  219. }
  220. }
  221. static void fdevent_disconnect(fdevent *fde)
  222. {
  223. int i, n;
  224. FD_CLR(fde->fd, &read_fds);
  225. FD_CLR(fde->fd, &write_fds);
  226. FD_CLR(fde->fd, &error_fds);
  227. for(n = 0, i = 0; i < select_n; i++) {
  228. if(fd_table[i] != 0) n = i;
  229. }
  230. select_n = n + 1;
  231. }
  232. static void fdevent_update(fdevent *fde, unsigned events)
  233. {
  234. if(events & FDE_READ) {
  235. FD_SET(fde->fd, &read_fds);
  236. } else {
  237. FD_CLR(fde->fd, &read_fds);
  238. }
  239. if(events & FDE_WRITE) {
  240. FD_SET(fde->fd, &write_fds);
  241. } else {
  242. FD_CLR(fde->fd, &write_fds);
  243. }
  244. if(events & FDE_ERROR) {
  245. FD_SET(fde->fd, &error_fds);
  246. } else {
  247. FD_CLR(fde->fd, &error_fds);
  248. }
  249. fde->state = (fde->state & FDE_STATEMASK) | events;
  250. }
  251. /* Looks at fd_table[] for bad FDs and sets bit in fds.
  252. ** Returns the number of bad FDs.
  253. */
  254. static int fdevent_fd_check(fd_set *fds)
  255. {
  256. int i, n = 0;
  257. fdevent *fde;
  258. for(i = 0; i < select_n; i++) {
  259. fde = fd_table[i];
  260. if(fde == 0) continue;
  261. if(fcntl(i, F_GETFL, NULL) < 0) {
  262. FD_SET(i, fds);
  263. n++;
  264. // fde->state |= FDE_DONT_CLOSE;
  265. }
  266. }
  267. return n;
  268. }
  269. #if !DEBUG
  270. static inline void dump_all_fds(const char *extra_msg) {}
  271. #else
  272. static void dump_all_fds(const char *extra_msg)
  273. {
  274. int i;
  275. fdevent *fde;
  276. // per fd: 4 digits (but really: log10(FD_SETSIZE)), 1 staus, 1 blank
  277. char msg_buff[FD_SETSIZE*6 + 1], *pb=msg_buff;
  278. size_t max_chars = FD_SETSIZE * 6 + 1;
  279. int printed_out;
  280. #define SAFE_SPRINTF(...) \
  281. do { \
  282. printed_out = snprintf(pb, max_chars, __VA_ARGS__); \
  283. if (printed_out <= 0) { \
  284. D("... snprintf failed.\n"); \
  285. return; \
  286. } \
  287. if (max_chars < (unsigned int)printed_out) { \
  288. D("... snprintf out of space.\n"); \
  289. return; \
  290. } \
  291. pb += printed_out; \
  292. max_chars -= printed_out; \
  293. } while(0)
  294. for(i = 0; i < select_n; i++) {
  295. fde = fd_table[i];
  296. SAFE_SPRINTF("%d", i);
  297. if(fde == 0) {
  298. SAFE_SPRINTF("? ");
  299. continue;
  300. }
  301. if(fcntl(i, F_GETFL, NULL) < 0) {
  302. SAFE_SPRINTF("b");
  303. }
  304. SAFE_SPRINTF(" ");
  305. }
  306. D("%s fd_table[]->fd = {%s}\n", extra_msg, msg_buff);
  307. }
  308. #endif
  309. static void fdevent_process()
  310. {
  311. int i, n;
  312. fdevent *fde;
  313. unsigned events;
  314. fd_set rfd, wfd, efd;
  315. memcpy(&rfd, &read_fds, sizeof(fd_set));
  316. memcpy(&wfd, &write_fds, sizeof(fd_set));
  317. memcpy(&efd, &error_fds, sizeof(fd_set));
  318. dump_all_fds("pre select()");
  319. n = select(select_n, &rfd, &wfd, &efd, NULL);
  320. int saved_errno = errno;
  321. D("select() returned n=%d, errno=%d\n", n, n<0?saved_errno:0);
  322. dump_all_fds("post select()");
  323. if(n < 0) {
  324. switch(saved_errno) {
  325. case EINTR: return;
  326. case EBADF:
  327. // Can't trust the FD sets after an error.
  328. FD_ZERO(&wfd);
  329. FD_ZERO(&efd);
  330. FD_ZERO(&rfd);
  331. break;
  332. default:
  333. D("Unexpected select() error=%d\n", saved_errno);
  334. return;
  335. }
  336. }
  337. if(n <= 0) {
  338. // We fake a read, as the rest of the code assumes
  339. // that errors will be detected at that point.
  340. n = fdevent_fd_check(&rfd);
  341. }
  342. for(i = 0; (i < select_n) && (n > 0); i++) {
  343. events = 0;
  344. if(FD_ISSET(i, &rfd)) { events |= FDE_READ; n--; }
  345. if(FD_ISSET(i, &wfd)) { events |= FDE_WRITE; n--; }
  346. if(FD_ISSET(i, &efd)) { events |= FDE_ERROR; n--; }
  347. if(events) {
  348. fde = fd_table[i];
  349. if(fde == 0)
  350. FATAL("missing fde for fd %d\n", i);
  351. fde->events |= events;
  352. D("got events fde->fd=%d events=%04x, state=%04x\n",
  353. fde->fd, fde->events, fde->state);
  354. if(fde->state & FDE_PENDING) continue;
  355. fde->state |= FDE_PENDING;
  356. fdevent_plist_enqueue(fde);
  357. }
  358. }
  359. }
  360. #endif
  361. static void fdevent_register(fdevent *fde)
  362. {
  363. if(fde->fd < 0) {
  364. FATAL("bogus negative fd (%d)\n", fde->fd);
  365. }
  366. if(fde->fd >= fd_table_max) {
  367. int oldmax = fd_table_max;
  368. if(fde->fd > 32000) {
  369. FATAL("bogus huuuuge fd (%d)\n", fde->fd);
  370. }
  371. if(fd_table_max == 0) {
  372. fdevent_init();
  373. fd_table_max = 256;
  374. }
  375. while(fd_table_max <= fde->fd) {
  376. fd_table_max *= 2;
  377. }
  378. fd_table = realloc(fd_table, sizeof(fdevent*) * fd_table_max);
  379. if(fd_table == 0) {
  380. FATAL("could not expand fd_table to %d entries\n", fd_table_max);
  381. }
  382. memset(fd_table + oldmax, 0, sizeof(int) * (fd_table_max - oldmax));
  383. }
  384. fd_table[fde->fd] = fde;
  385. }
  386. static void fdevent_unregister(fdevent *fde)
  387. {
  388. if((fde->fd < 0) || (fde->fd >= fd_table_max)) {
  389. FATAL("fd out of range (%d)\n", fde->fd);
  390. }
  391. if(fd_table[fde->fd] != fde) {
  392. FATAL("fd_table out of sync [%d]\n", fde->fd);
  393. }
  394. fd_table[fde->fd] = 0;
  395. if(!(fde->state & FDE_DONT_CLOSE)) {
  396. dump_fde(fde, "close");
  397. adb_close(fde->fd);
  398. }
  399. }
  400. static void fdevent_plist_enqueue(fdevent *node)
  401. {
  402. fdevent *list = &list_pending;
  403. node->next = list;
  404. node->prev = list->prev;
  405. node->prev->next = node;
  406. list->prev = node;
  407. }
  408. static void fdevent_plist_remove(fdevent *node)
  409. {
  410. node->prev->next = node->next;
  411. node->next->prev = node->prev;
  412. node->next = 0;
  413. node->prev = 0;
  414. }
  415. static fdevent *fdevent_plist_dequeue(void)
  416. {
  417. fdevent *list = &list_pending;
  418. fdevent *node = list->next;
  419. if(node == list) return 0;
  420. list->next = node->next;
  421. list->next->prev = list;
  422. node->next = 0;
  423. node->prev = 0;
  424. return node;
  425. }
  426. static void fdevent_call_fdfunc(fdevent* fde)
  427. {
  428. unsigned events = fde->events;
  429. fde->events = 0;
  430. if(!(fde->state & FDE_PENDING)) return;
  431. fde->state &= (~FDE_PENDING);
  432. dump_fde(fde, "callback");
  433. fde->func(fde->fd, events, fde->arg);
  434. }
  435. static void fdevent_subproc_event_func(int fd, unsigned ev, void *userdata)
  436. {
  437. D("subproc handling on fd=%d ev=%04x\n", fd, ev);
  438. // Hook oneself back into the fde's suitable for select() on read.
  439. if((fd < 0) || (fd >= fd_table_max)) {
  440. FATAL("fd %d out of range for fd_table \n", fd);
  441. }
  442. fdevent *fde = fd_table[fd];
  443. fdevent_add(fde, FDE_READ);
  444. if(ev & FDE_READ){
  445. int subproc_fd;
  446. if(readx(fd, &subproc_fd, sizeof(subproc_fd))) {
  447. FATAL("Failed to read the subproc's fd from fd=%d\n", fd);
  448. }
  449. if((subproc_fd < 0) || (subproc_fd >= fd_table_max)) {
  450. D("subproc_fd %d out of range 0, fd_table_max=%d\n",
  451. subproc_fd, fd_table_max);
  452. return;
  453. }
  454. fdevent *subproc_fde = fd_table[subproc_fd];
  455. if(!subproc_fde) {
  456. D("subproc_fd %d cleared from fd_table\n", subproc_fd);
  457. return;
  458. }
  459. if(subproc_fde->fd != subproc_fd) {
  460. // Already reallocated?
  461. D("subproc_fd %d != fd_table[].fd %d\n", subproc_fd, subproc_fde->fd);
  462. return;
  463. }
  464. subproc_fde->force_eof = 1;
  465. int rcount = 0;
  466. ioctl(subproc_fd, FIONREAD, &rcount);
  467. D("subproc with fd=%d has rcount=%d err=%d\n",
  468. subproc_fd, rcount, errno);
  469. if(rcount) {
  470. // If there is data left, it will show up in the select().
  471. // This works because there is no other thread reading that
  472. // data when in this fd_func().
  473. return;
  474. }
  475. D("subproc_fde.state=%04x\n", subproc_fde->state);
  476. subproc_fde->events |= FDE_READ;
  477. if(subproc_fde->state & FDE_PENDING) {
  478. return;
  479. }
  480. subproc_fde->state |= FDE_PENDING;
  481. fdevent_call_fdfunc(subproc_fde);
  482. }
  483. }
  484. fdevent *fdevent_create(int fd, fd_func func, void *arg)
  485. {
  486. fdevent *fde = (fdevent*) malloc(sizeof(fdevent));
  487. if(fde == 0) return 0;
  488. fdevent_install(fde, fd, func, arg);
  489. fde->state |= FDE_CREATED;
  490. return fde;
  491. }
  492. void fdevent_destroy(fdevent *fde)
  493. {
  494. if(fde == 0) return;
  495. if(!(fde->state & FDE_CREATED)) {
  496. FATAL("fde %p not created by fdevent_create()\n", fde);
  497. }
  498. fdevent_remove(fde);
  499. }
  500. void fdevent_install(fdevent *fde, int fd, fd_func func, void *arg)
  501. {
  502. memset(fde, 0, sizeof(fdevent));
  503. fde->state = FDE_ACTIVE;
  504. fde->fd = fd;
  505. fde->force_eof = 0;
  506. fde->func = func;
  507. fde->arg = arg;
  508. #ifndef HAVE_WINSOCK
  509. fcntl(fd, F_SETFL, O_NONBLOCK);
  510. #endif
  511. fdevent_register(fde);
  512. dump_fde(fde, "connect");
  513. fdevent_connect(fde);
  514. fde->state |= FDE_ACTIVE;
  515. }
  516. void fdevent_remove(fdevent *fde)
  517. {
  518. if(fde->state & FDE_PENDING) {
  519. fdevent_plist_remove(fde);
  520. }
  521. if(fde->state & FDE_ACTIVE) {
  522. fdevent_disconnect(fde);
  523. dump_fde(fde, "disconnect");
  524. fdevent_unregister(fde);
  525. }
  526. fde->state = 0;
  527. fde->events = 0;
  528. }
  529. void fdevent_set(fdevent *fde, unsigned events)
  530. {
  531. events &= FDE_EVENTMASK;
  532. if((fde->state & FDE_EVENTMASK) == events) return;
  533. if(fde->state & FDE_ACTIVE) {
  534. fdevent_update(fde, events);
  535. dump_fde(fde, "update");
  536. }
  537. fde->state = (fde->state & FDE_STATEMASK) | events;
  538. if(fde->state & FDE_PENDING) {
  539. /* if we're pending, make sure
  540. ** we don't signal an event that
  541. ** is no longer wanted.
  542. */
  543. fde->events &= (~events);
  544. if(fde->events == 0) {
  545. fdevent_plist_remove(fde);
  546. fde->state &= (~FDE_PENDING);
  547. }
  548. }
  549. }
  550. void fdevent_add(fdevent *fde, unsigned events)
  551. {
  552. fdevent_set(
  553. fde, (fde->state & FDE_EVENTMASK) | (events & FDE_EVENTMASK));
  554. }
  555. void fdevent_del(fdevent *fde, unsigned events)
  556. {
  557. fdevent_set(
  558. fde, (fde->state & FDE_EVENTMASK) & (~(events & FDE_EVENTMASK)));
  559. }
  560. void fdevent_subproc_setup()
  561. {
  562. int s[2];
  563. if(adb_socketpair(s)) {
  564. FATAL("cannot create shell-exit socket-pair\n");
  565. }
  566. SHELL_EXIT_NOTIFY_FD = s[0];
  567. fdevent *fde;
  568. fde = fdevent_create(s[1], fdevent_subproc_event_func, NULL);
  569. if(!fde)
  570. FATAL("cannot create fdevent for shell-exit handler\n");
  571. fdevent_add(fde, FDE_READ);
  572. }
  573. void fdevent_loop()
  574. {
  575. fdevent *fde;
  576. fdevent_subproc_setup();
  577. for(;;) {
  578. D("--- ---- waiting for events\n");
  579. fdevent_process();
  580. while((fde = fdevent_plist_dequeue())) {
  581. fdevent_call_fdfunc(fde);
  582. }
  583. }
  584. }