VMM: Sync halting GPCs and interrupt injection
[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 #include <ros/fs.h>
63
64 static int epoll_fd;
65 static fd_set all_fds;
66 static uth_mutex_t fdset_mtx;
67 static uintptr_t unique_caller;
68 static uth_mutex_t sleep_mtx;
69
70 static bool fd_is_set(unsigned int fd, fd_set *set)
71 {
72         if (fd > FD_SETSIZE)
73                 return FALSE;
74         if (!set)
75                 return FALSE;
76         return FD_ISSET(fd, set);
77 }
78
79 static void select_fd_closed(int fd)
80 {
81         /* Slightly racy, but anything concurrently added will be closed later, and
82          * after it is_set. */
83         if (!fd_is_set(fd, &all_fds))
84                 return;
85         /* We just need to stop tracking FD.  We do not need to remove it from the
86          * epoll set, since that will happen automatically on close(). */
87         uth_mutex_lock(fdset_mtx);
88         FD_CLR(fd, &all_fds);
89         uth_mutex_unlock(fdset_mtx);
90 }
91
92 static void select_forked(void)
93 {
94         struct epoll_event ep_ev;
95
96         uth_mutex_lock(fdset_mtx);
97         for (int i = 0; i < FD_SETSIZE; i++) {
98                 if (fd_is_set(i, &all_fds)) {
99                         ep_ev.events = EPOLLET | EPOLLIN | EPOLLOUT | EPOLLHUP |
100                                        EPOLLERR;
101                         ep_ev.data.fd = i;
102                         /* Discard error.  The underlying tap is gone, and the epoll ctlr
103                          * might also have been emptied.  We just want to make sure there is
104                          * no epoll/tap so that a future CTL_ADD doesn't fail. */
105                         epoll_ctl(epoll_fd, EPOLL_CTL_DEL, i, &ep_ev);
106                         FD_CLR(i, &all_fds);
107                 }
108         }
109         uth_mutex_unlock(fdset_mtx);
110 }
111
112 static void select_init(void)
113 {
114         static struct close_cb select_close_cb = {.func = select_fd_closed};
115         static struct fork_cb select_fork_cb = {.func = select_forked};
116
117         register_close_cb(&select_close_cb);
118         epoll_fd = epoll_create(FD_SETSIZE);
119         if (epoll_fd < 0) {
120                 perror("select failed epoll_create");
121                 exit(-1);
122         }
123         fdset_mtx = uth_mutex_alloc();
124         sleep_mtx = uth_mutex_alloc();
125         register_fork_cb(&select_fork_cb);
126 }
127
128 static int select_tv_to_ep_timeout(struct timeval *tv)
129 {
130         if (!tv)
131                 return -1;
132         return tv->tv_sec * 1000 + DIV_ROUND_UP(tv->tv_usec, 1000);
133 }
134
135 /* Check with the kernel if FD is readable/writable or not.  Some apps will call
136  * select() on something even if it is already actionable, and not wait until
137  * they get the EAGAIN.
138  *
139  * TODO: this *won't* work for disk based files.  It only works on qids that are
140  * backed with qio queues or something similar, where the device has support for
141  * setting DMREADABLE/DMWRITABLE. */
142 static bool fd_is_actionable(int fd, fd_set *readfds, fd_set *writefds)
143 {
144         struct stat stat_buf;
145         int ret;
146
147         /* Avoid the stat call on FDs we're not tracking (which should trigger an
148          * error, or give us the stat for FD 0). */
149         if (!(fd_is_set(fd, readfds) || fd_is_set(fd, writefds)))
150                 return FALSE;
151         ret = fstat(fd, &stat_buf);
152         assert(!ret);
153         return (fd_is_set(fd, readfds)  && S_READABLE(stat_buf.st_mode)) ||
154                (fd_is_set(fd, writefds) && S_WRITABLE(stat_buf.st_mode));
155 }
156
157 int select(int nfds, fd_set *readfds, fd_set *writefds,
158            fd_set *exceptfds, struct timeval *timeout)
159 {
160         bool changed_set = FALSE;
161         struct epoll_event ep_ev;
162         struct epoll_event *ep_results;
163         uintptr_t my_call_id;
164         int ret;
165         int ep_timeout = select_tv_to_ep_timeout(timeout);
166
167         run_once(select_init());
168         /* good thing nfds is a signed int... */
169         if (nfds < 0) {
170                 errno = EINVAL;
171                 return -1;
172         }
173         /* It is legal to select on read even if you didn't consume all of the data
174          * in an FD; similarly for writers on non-full FDs. */
175         for (int i = 0; i < nfds; i++) {
176                 if (fd_is_actionable(i, readfds, writefds))
177                         return nfds;
178         }
179         uth_mutex_lock(fdset_mtx);
180         for (int i = 0; i < nfds; i++) {
181                 if ((fd_is_set(i, readfds) || fd_is_set(i, writefds) ||
182                     fd_is_set(i, exceptfds)) && !fd_is_set(i, &all_fds)) {
183
184                         changed_set = TRUE;
185                         FD_SET(i, &all_fds);
186                         /* FDs that we track for *any* reason with select will be
187                          * tracked for *all* reasons with epoll. */
188                         ep_ev.events = EPOLLET | EPOLLIN | EPOLLOUT | EPOLLHUP |
189                                        EPOLLERR;
190                         ep_ev.data.fd = i;
191                         if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, i, &ep_ev)) {
192                                 /* We might have failed because we tried to set up too many
193                                  * FD tap types.  Listen FDs, for instance, can only be
194                                  * tapped for READABLE and HANGUP.  Let's try for one of
195                                  * those. */
196                                 if (errno == ENOSYS) {
197                                         ep_ev.events = EPOLLET | EPOLLIN | EPOLLHUP;
198                                         if (!epoll_ctl(epoll_fd, EPOLL_CTL_ADD, i, &ep_ev))
199                                                 continue;
200                                 }
201                                 /* Careful to unlock before calling perror.  perror calls
202                                  * close, which calls our CB, which grabs the lock. */
203                                 uth_mutex_unlock(fdset_mtx);
204                                 perror("select epoll_ctl failed");
205                                 return -1;
206                         }
207                 }
208         }
209         uth_mutex_unlock(fdset_mtx);
210         /* Since we just added some FD to our tracking set, we don't know if its
211          * readable or not.  We'll only catch edge-triggered changes in the future.
212          * We can spuriously tell the user all FDs are ready, and next time they
213          * can block until there is edge activity. */
214         if (changed_set)
215                 return nfds;
216         /* Since there is a global epoll set, we could have multiple threads
217          * epolling at a time and one thread could consume the events that should
218          * wake another thread.  We don't know when the 'other' thread last polled,
219          * so we'll need to assume its event was consumed and just return.
220          *
221          * To make matters more confusing, we could also have a single thread that
222          * selects multiple times on separate FD sets.  So we also need to
223          * distinguish between calls and threads.
224          *
225          * If the same {thread, callsite} selects again and no one else has since
226          * selected, then we know no one consumed the events.  We'll use the stack
227          * pointer to uniquely identify the {thread, callsite} combo that recently
228          * selected.  We use a mutex so that the extra threads sleep. */
229         uth_mutex_lock(sleep_mtx);
230         my_call_id = get_stack_pointer();
231         if (my_call_id != unique_caller) {
232                 /* Could thrash, if we fight with another uth for unique_caller */
233                 unique_caller = my_call_id;
234                 uth_mutex_unlock(sleep_mtx);
235                 return nfds;
236         }
237         /* Need to check for up to FD_SETSIZE - nfds isn't the size of all FDs
238          * tracked; it's the size of only our current select call */
239         ep_results = malloc(sizeof(struct epoll_event) * FD_SETSIZE);
240         if (!ep_results) {
241                 uth_mutex_unlock(sleep_mtx);
242                 errno = ENOMEM;
243                 return -1;
244         }
245         /* Don't care which ones were set; we'll just tell the user they all were
246          * set.  If they can't handle that, this whole plan won't work. */
247         ret = epoll_wait(epoll_fd, ep_results, FD_SETSIZE, ep_timeout);
248         uth_mutex_unlock(sleep_mtx);
249         free(ep_results);
250         /* TODO: consider updating timeval.  It's not mandatory (POSIX). */
251         if (ret == 0)   /* timeout */
252                 return 0;
253         return nfds;
254 }
255
256 int pselect(int nfds, fd_set *readfds, fd_set *writefds,
257             fd_set *exceptfds, const struct timespec *timeout,
258             const sigset_t *sigmask)
259 {
260         int ready;
261         sigset_t origmask;
262         struct timeval local_tv, *tv = &local_tv;
263
264         if (!timeout) {
265                 tv = 0;
266         } else {
267                 tv->tv_sec = timeout->tv_sec;
268                 tv->tv_usec = DIV_ROUND_UP(timeout->tv_nsec, 1000);
269         }
270         /* TODO: this is probably racy */
271         sigprocmask(SIG_SETMASK, sigmask, &origmask);
272         ready = select(nfds, readfds, writefds, exceptfds, tv);
273         sigprocmask(SIG_SETMASK, &origmask, NULL);
274         return ready;
275 }