7fc22b5cd7063f923fed89ae1d21720092b30aed
[akaros.git] / user / iplib / select.c
1 /* Copyright (c) 2016 Google Inc.
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * See LICENSE for details.
4  *
5  * select()
6  *
7  * Our select() is super spurious and will only work with apps that use
8  * non-blocking I/O.
9  *
10  * Under the hood, our select() is implemented with epoll (and under that, FD
11  * taps).  Those can only detect edges (e.g. a socket becomes readable).
12  *
13  * The problem is that we want to detect a level status (e.g. socket is
14  * readable) with an edge event (e.g. socket *becomes* readable).  To do this,
15  * when someone initially selects, the FD gets tracked with epoll and we
16  * immediately return saying the FD is ready for whatever they asked for.  This
17  * is usually not true, and the application will need to poll all of its FDs
18  * once after the initial select() call.  Subsequent selects() will still be
19  * tracking the FD in the epoll set.  If any edge events that come after the
20  * poll (which eventually returns EAGAIN) will be caught by epoll, and a
21  * subsequent select will wake up (or never block in the first place) due to the
22  * reception of that edge event.
23  *
24  * We maintain one FD set per program.  It tracks *any* FD being tracked by
25  * *any* select call.  Regardless of whether the user asked for
26  * read/write/except, the FD gets watched for anything until it closes.  This
27  * will result in spurious wakeups.
28  *
29  * One issue with the global FD set is that one thread may consume the epoll
30  * events intended for another thread (or even for itself at another call
31  * site!).  To get around this, only one thread is the actual epoller, and the
32  * others block on a mutex.  An alternative is to use a per-thread FD set, using
33  * TLS, but not every 2LS uses TLS, and performance is not a concern for code
34  * using select().
35  *
36  * Notes:
37  * - pselect might be racy
38  * - if the user has no read/write/except sets, we won't wait.  some users of
39  *   select use it as a timer only.  if that comes up, we can expand this.
40  * - if you epoll or FD tap an FD, then try to use select on it, you'll get an
41  *   error (only one tap per FD).  select() only knows about the FDs in its set.
42  * - if you select() on a readfd that is a disk file, it'll always say it is
43  *   available for I/O.
44  */
45
46 #include <sys/select.h>
47 #include <sys/time.h>
48 #include <sys/types.h>
49 #include <unistd.h>
50 #include <sys/stat.h>
51
52 #include <ros/common.h>
53 #include <parlib/uthread.h>
54 #include <parlib/arch/arch.h>
55 #include <sys/close_cb.h>
56 #include <sys/fork_cb.h>
57 #include <sys/epoll.h>
58 #include <malloc.h>
59 #include <stdlib.h>
60 #include <errno.h>
61 #include <signal.h>
62
63 static int epoll_fd;
64 static fd_set all_fds;
65 static uth_mutex_t fdset_mtx;
66 static uintptr_t unique_caller;
67 static uth_mutex_t sleep_mtx;
68
69 static bool fd_is_set(unsigned int fd, fd_set *set)
70 {
71         if (fd > FD_SETSIZE)
72                 return FALSE;
73         if (!set)
74                 return FALSE;
75         return FD_ISSET(fd, set);
76 }
77
78 static void select_fd_closed(int fd)
79 {
80         /* Slightly racy, but anything concurrently added will be closed later, and
81          * after it is_set. */
82         if (!fd_is_set(fd, &all_fds))
83                 return;
84         /* We just need to stop tracking FD.  We do not need to remove it from the
85          * epoll set, since that will happen automatically on close(). */
86         uth_mutex_lock(fdset_mtx);
87         FD_CLR(fd, &all_fds);
88         uth_mutex_unlock(fdset_mtx);
89 }
90
91 static void select_forked(void)
92 {
93         struct epoll_event ep_ev;
94
95         uth_mutex_lock(fdset_mtx);
96         for (int i = 0; i < FD_SETSIZE; i++) {
97                 if (fd_is_set(i, &all_fds)) {
98                         ep_ev.events = EPOLLET | EPOLLIN | EPOLLOUT | EPOLLHUP |
99                                        EPOLLERR;
100                         ep_ev.data.fd = i;
101                         /* Discard error.  The underlying tap is gone, and the epoll ctlr
102                          * might also have been emptied.  We just want to make sure there is
103                          * no epoll/tap so that a future CTL_ADD doesn't fail. */
104                         epoll_ctl(epoll_fd, EPOLL_CTL_DEL, i, &ep_ev);
105                         FD_CLR(i, &all_fds);
106                 }
107         }
108         uth_mutex_unlock(fdset_mtx);
109 }
110
111 static void select_init(void)
112 {
113         static struct close_cb select_close_cb = {.func = select_fd_closed};
114         static struct fork_cb select_fork_cb = {.func = select_forked};
115
116         register_close_cb(&select_close_cb);
117         epoll_fd = epoll_create(FD_SETSIZE);
118         if (epoll_fd < 0) {
119                 perror("select failed epoll_create");
120                 exit(-1);
121         }
122         fdset_mtx = uth_mutex_alloc();
123         sleep_mtx = uth_mutex_alloc();
124         register_fork_cb(&select_fork_cb);
125 }
126
127 static int select_tv_to_ep_timeout(struct timeval *tv)
128 {
129         if (!tv)
130                 return -1;
131         return tv->tv_sec * 1000 + DIV_ROUND_UP(tv->tv_usec, 1000);
132 }
133
134 /* Check with the kernel if FD is readable or not.  Some apps will call select()
135  * on something even if it is already readable.
136  *
137  * TODO: this *won't* work for disk based files.  It only works on qids that are
138  * backed with qio queues or something similar, where size == readable. */
139 static bool fd_is_readable(int fd)
140 {
141         struct stat stat_buf;
142         int ret;
143
144         ret = fstat(fd, &stat_buf);
145         assert(!ret);
146         return stat_buf.st_size > 0;
147 }
148
149 int select(int nfds, fd_set *readfds, fd_set *writefds,
150            fd_set *exceptfds, struct timeval *timeout)
151 {
152         bool changed_set = FALSE;
153         struct epoll_event ep_ev;
154         struct epoll_event *ep_results;
155         uintptr_t my_call_id;
156         int ret;
157         int ep_timeout = select_tv_to_ep_timeout(timeout);
158
159         run_once(select_init());
160         /* good thing nfds is a signed int... */
161         if (nfds < 0) {
162                 errno = EINVAL;
163                 return -1;
164         }
165         /* It is legal to select even if you didn't consume all of the data in an
166          * FD.  Similar for writables, though it's harder for us to check those.
167          * Hopefully we don't need to. */
168         for (int i = 0; i < nfds; i++) {
169                 if (fd_is_set(i, readfds) && fd_is_readable(i))
170                         return nfds;
171         }
172         uth_mutex_lock(fdset_mtx);
173         for (int i = 0; i < nfds; i++) {
174                 if ((fd_is_set(i, readfds) || fd_is_set(i, writefds) ||
175                     fd_is_set(i, exceptfds)) && !fd_is_set(i, &all_fds)) {
176
177                         changed_set = TRUE;
178                         FD_SET(i, &all_fds);
179                         /* FDs that we track for *any* reason with select will be
180                          * tracked for *all* reasons with epoll. */
181                         ep_ev.events = EPOLLET | EPOLLIN | EPOLLOUT | EPOLLHUP |
182                                        EPOLLERR;
183                         ep_ev.data.fd = i;
184                         if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, i, &ep_ev)) {
185                                 /* We might have failed because we tried to set up too many
186                                  * FD tap types.  Listen FDs, for instance, can only be
187                                  * tapped for READABLE and HANGUP.  Let's try for one of
188                                  * those. */
189                                 if (errno == ENOSYS) {
190                                         ep_ev.events = EPOLLET | EPOLLIN | EPOLLHUP;
191                                         if (!epoll_ctl(epoll_fd, EPOLL_CTL_ADD, i, &ep_ev))
192                                                 continue;
193                                 }
194                                 /* Careful to unlock before calling perror.  perror calls
195                                  * close, which calls our CB, which grabs the lock. */
196                                 uth_mutex_unlock(fdset_mtx);
197                                 perror("select epoll_ctl failed");
198                                 return -1;
199                         }
200                 }
201         }
202         uth_mutex_unlock(fdset_mtx);
203         /* Since we just added some FD to our tracking set, we don't know if its
204          * readable or not.  We'll only catch edge-triggered changes in the future.
205          * We can spuriously tell the user all FDs are ready, and next time they
206          * can block until there is edge activity. */
207         if (changed_set)
208                 return nfds;
209         /* Since there is a global epoll set, we could have multiple threads
210          * epolling at a time and one thread could consume the events that should
211          * wake another thread.  We don't know when the 'other' thread last polled,
212          * so we'll need to assume its event was consumed and just return.
213          *
214          * To make matters more confusing, we could also have a single thread that
215          * selects multiple times on separate FD sets.  So we also need to
216          * distinguish between calls and threads.
217          *
218          * If the same {thread, callsite} selects again and no one else has since
219          * selected, then we know no one consumed the events.  We'll use the stack
220          * pointer to uniquely identify the {thread, callsite} combo that recently
221          * selected.  We use a mutex so that the extra threads sleep. */
222         uth_mutex_lock(sleep_mtx);
223         my_call_id = get_stack_pointer();
224         if (my_call_id != unique_caller) {
225                 /* Could thrash, if we fight with another uth for unique_caller */
226                 unique_caller = my_call_id;
227                 uth_mutex_unlock(sleep_mtx);
228                 return nfds;
229         }
230         /* Need to check for up to FD_SETSIZE - nfds isn't the size of all FDs
231          * tracked; it's the size of only our current select call */
232         ep_results = malloc(sizeof(struct epoll_event) * FD_SETSIZE);
233         if (!ep_results) {
234                 uth_mutex_unlock(sleep_mtx);
235                 errno = ENOMEM;
236                 return -1;
237         }
238         /* Don't care which ones were set; we'll just tell the user they all were
239          * set.  If they can't handle that, this whole plan won't work. */
240         ret = epoll_wait(epoll_fd, ep_results, FD_SETSIZE, ep_timeout);
241         uth_mutex_unlock(sleep_mtx);
242         free(ep_results);
243         /* TODO: consider updating timeval.  It's not mandatory (POSIX). */
244         if (ret == 0)   /* timeout */
245                 return 0;
246         return nfds;
247 }
248
249 int pselect(int nfds, fd_set *readfds, fd_set *writefds,
250             fd_set *exceptfds, const struct timespec *timeout,
251             const sigset_t *sigmask)
252 {
253         int ready;
254         sigset_t origmask;
255         struct timeval local_tv, *tv = &local_tv;
256
257         if (!timeout) {
258                 tv = 0;
259         } else {
260                 tv->tv_sec = timeout->tv_sec;
261                 tv->tv_usec = DIV_ROUND_UP(timeout->tv_nsec, 1000);
262         }
263         /* TODO: this is probably racy */
264         sigprocmask(SIG_SETMASK, sigmask, &origmask);
265         ready = select(nfds, readfds, writefds, exceptfds, tv);
266         sigprocmask(SIG_SETMASK, &origmask, NULL);
267         return ready;
268 }