poll.c 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234
  1. /* Copyright (C) 1994,1996,1997,1998,1999,2001,2002
  2. Free Software Foundation, Inc.
  3. This file is part of the GNU C Library.
  4. The GNU C Library is free software; you can redistribute it and/or
  5. modify it under the terms of the GNU Lesser General Public
  6. License as published by the Free Software Foundation; either
  7. version 2.1 of the License, or (at your option) any later version.
  8. The GNU C Library is distributed in the hope that it will be useful,
  9. but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  11. Lesser General Public License for more details.
  12. You should have received a copy of the GNU Lesser General Public
  13. License along with the GNU C Library; if not, write to the Free
  14. Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  15. 02111-1307 USA. */
  16. #include <sys/syscall.h>
  17. #include <sys/poll.h>
  18. extern __typeof(poll) __libc_poll;
  19. #ifdef __NR_poll
  20. # define __NR___libc_poll __NR_poll
  21. _syscall3(int, __libc_poll, struct pollfd *, fds,
  22. unsigned long int, nfds, int, timeout);
  23. #elif defined(__NR_ppoll)
  24. libc_hidden_proto(ppoll)
  25. int __libc_poll(struct pollfd *fds, nfds_t nfds, int timeout)
  26. {
  27. struct timespec *ts = NULL, tval;
  28. if (timeout > 0) {
  29. tval.tv_sec = timeout / 1000;
  30. tval.tv_nsec = (timeout % 1000) * 1000000;
  31. ts = &tval;
  32. } else if (timeout == 0) {
  33. tval.tv_sec = 0;
  34. tval.tv_nsec = 0;
  35. ts = &tval;
  36. }
  37. return ppoll(fds, nfds, ts, NULL);
  38. }
  39. #else
  40. /* ugh, this arch lacks poll, so we need to emulate this crap ... */
  41. #include <alloca.h>
  42. #include <sys/types.h>
  43. #include <errno.h>
  44. #include <string.h>
  45. #include <sys/time.h>
  46. #include <sys/param.h>
  47. #include <unistd.h>
  48. libc_hidden_proto(memcpy)
  49. libc_hidden_proto(memset)
  50. libc_hidden_proto(getdtablesize)
  51. libc_hidden_proto(select)
  52. /* uClinux 2.0 doesn't have poll, emulate it using select */
  53. /* Poll the file descriptors described by the NFDS structures starting at
  54. FDS. If TIMEOUT is nonzero and not -1, allow TIMEOUT milliseconds for
  55. an event to occur; if TIMEOUT is -1, block until an event occurs.
  56. Returns the number of file descriptors with events, zero if timed out,
  57. or -1 for errors. */
  58. int __libc_poll(struct pollfd *fds, nfds_t nfds, int timeout)
  59. {
  60. static int max_fd_size;
  61. struct timeval tv;
  62. fd_set *rset, *wset, *xset;
  63. struct pollfd *f;
  64. int ready;
  65. int maxfd = 0;
  66. int bytes;
  67. if (!max_fd_size)
  68. max_fd_size = getdtablesize ();
  69. bytes = howmany (max_fd_size, __NFDBITS);
  70. rset = alloca (bytes);
  71. wset = alloca (bytes);
  72. xset = alloca (bytes);
  73. /* We can't call FD_ZERO, since FD_ZERO only works with sets
  74. of exactly __FD_SETSIZE size. */
  75. memset (rset, 0, bytes);
  76. memset (wset, 0, bytes);
  77. memset (xset, 0, bytes);
  78. for (f = fds; f < &fds[nfds]; ++f)
  79. {
  80. f->revents = 0;
  81. if (f->fd >= 0)
  82. {
  83. if (f->fd >= max_fd_size)
  84. {
  85. /* The user provides a file descriptor number which is higher
  86. than the maximum we got from the `getdtablesize' call.
  87. Maybe this is ok so enlarge the arrays. */
  88. fd_set *nrset, *nwset, *nxset;
  89. int nbytes;
  90. max_fd_size = roundup (f->fd, __NFDBITS);
  91. nbytes = howmany (max_fd_size, __NFDBITS);
  92. nrset = alloca (nbytes);
  93. nwset = alloca (nbytes);
  94. nxset = alloca (nbytes);
  95. memset ((char *) nrset + bytes, 0, nbytes - bytes);
  96. memset ((char *) nwset + bytes, 0, nbytes - bytes);
  97. memset ((char *) nxset + bytes, 0, nbytes - bytes);
  98. rset = memcpy (nrset, rset, bytes);
  99. wset = memcpy (nwset, wset, bytes);
  100. xset = memcpy (nxset, xset, bytes);
  101. bytes = nbytes;
  102. }
  103. if (f->events & POLLIN)
  104. FD_SET (f->fd, rset);
  105. if (f->events & POLLOUT)
  106. FD_SET (f->fd, wset);
  107. if (f->events & POLLPRI)
  108. FD_SET (f->fd, xset);
  109. if (f->fd > maxfd && (f->events & (POLLIN|POLLOUT|POLLPRI)))
  110. maxfd = f->fd;
  111. }
  112. }
  113. tv.tv_sec = timeout / 1000;
  114. tv.tv_usec = (timeout % 1000) * 1000;
  115. while (1)
  116. {
  117. ready = select (maxfd + 1, rset, wset, xset,
  118. timeout == -1 ? NULL : &tv);
  119. /* It might be that one or more of the file descriptors is invalid.
  120. We now try to find and mark them and then try again. */
  121. if (ready == -1 && errno == EBADF)
  122. {
  123. fd_set *sngl_rset = alloca (bytes);
  124. fd_set *sngl_wset = alloca (bytes);
  125. fd_set *sngl_xset = alloca (bytes);
  126. struct timeval sngl_tv;
  127. /* Clear the original set. */
  128. memset (rset, 0, bytes);
  129. memset (wset, 0, bytes);
  130. memset (xset, 0, bytes);
  131. /* This means we don't wait for input. */
  132. sngl_tv.tv_sec = 0;
  133. sngl_tv.tv_usec = 0;
  134. maxfd = -1;
  135. /* Reset the return value. */
  136. ready = 0;
  137. for (f = fds; f < &fds[nfds]; ++f)
  138. if (f->fd != -1 && (f->events & (POLLIN|POLLOUT|POLLPRI))
  139. && (f->revents & POLLNVAL) == 0)
  140. {
  141. int n;
  142. memset (sngl_rset, 0, bytes);
  143. memset (sngl_wset, 0, bytes);
  144. memset (sngl_xset, 0, bytes);
  145. if (f->events & POLLIN)
  146. FD_SET (f->fd, sngl_rset);
  147. if (f->events & POLLOUT)
  148. FD_SET (f->fd, sngl_wset);
  149. if (f->events & POLLPRI)
  150. FD_SET (f->fd, sngl_xset);
  151. n = select (f->fd + 1, sngl_rset, sngl_wset, sngl_xset,
  152. &sngl_tv);
  153. if (n != -1)
  154. {
  155. /* This descriptor is ok. */
  156. if (f->events & POLLIN)
  157. FD_SET (f->fd, rset);
  158. if (f->events & POLLOUT)
  159. FD_SET (f->fd, wset);
  160. if (f->events & POLLPRI)
  161. FD_SET (f->fd, xset);
  162. if (f->fd > maxfd)
  163. maxfd = f->fd;
  164. if (n > 0)
  165. /* Count it as being available. */
  166. ++ready;
  167. }
  168. else if (errno == EBADF)
  169. f->revents |= POLLNVAL;
  170. }
  171. /* Try again. */
  172. continue;
  173. }
  174. break;
  175. }
  176. if (ready > 0)
  177. for (f = fds; f < &fds[nfds]; ++f)
  178. {
  179. if (f->fd >= 0)
  180. {
  181. if (FD_ISSET (f->fd, rset))
  182. f->revents |= POLLIN;
  183. if (FD_ISSET (f->fd, wset))
  184. f->revents |= POLLOUT;
  185. if (FD_ISSET (f->fd, xset))
  186. f->revents |= POLLPRI;
  187. }
  188. }
  189. return ready;
  190. }
  191. #endif
  192. libc_hidden_proto(poll)
  193. weak_alias(__libc_poll,poll)
  194. libc_hidden_weak(poll)