VMM: SMP guest (XCC)
[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/stat.h>
48 #include <sys/time.h>
49 #include <sys/types.h>
50 #include <unistd.h>
51
52 #include <errno.h>
53 #include <malloc.h>
54 #include <parlib/arch/arch.h>
55 #include <parlib/uthread.h>
56 #include <ros/common.h>
57 #include <ros/fs.h>
58 #include <signal.h>
59 #include <stdlib.h>
60 #include <sys/close_cb.h>
61 #include <sys/epoll.h>
62 #include <sys/fork_cb.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 | 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/writable or not.  Some apps will call
135  * select() on something even if it is already actionable, and not wait until
136  * they get the EAGAIN.
137  *
138  * TODO: this *won't* work for disk based files.  It only works on qids that are
139  * backed with qio queues or something similar, where the device has support for
140  * setting DMREADABLE/DMWRITABLE. */
141 static bool fd_is_actionable(int fd, fd_set *readfds, fd_set *writefds)
142 {
143         struct stat stat_buf;
144         int ret;
145
146         /* Avoid the stat call on FDs we're not tracking (which should trigger an
147          * error, or give us the stat for FD 0). */
148         if (!(fd_is_set(fd, readfds) || fd_is_set(fd, writefds)))
149                 return FALSE;
150         ret = fstat(fd, &stat_buf);
151         assert(!ret);
152         return (fd_is_set(fd, readfds) && S_READABLE(stat_buf.st_mode)) ||
153                (fd_is_set(fd, writefds) && S_WRITABLE(stat_buf.st_mode));
154 }
155
156 int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
157            struct timeval *timeout)
158 {
159         bool changed_set = FALSE;
160         struct epoll_event ep_ev;
161         struct epoll_event *ep_results;
162         uintptr_t my_call_id;
163         int ret;
164         int ep_timeout = select_tv_to_ep_timeout(timeout);
165
166         run_once(select_init());
167         /* good thing nfds is a signed int... */
168         if (nfds < 0) {
169                 errno = EINVAL;
170                 return -1;
171         }
172         /* It is legal to select on read even if you didn't consume all of the data
173          * in an FD; similarly for writers on non-full FDs. */
174         for (int i = 0; i < nfds; i++) {
175                 if (fd_is_actionable(i, readfds, writefds))
176                         return nfds;
177         }
178         uth_mutex_lock(fdset_mtx);
179         for (int i = 0; i < nfds; i++) {
180                 if ((fd_is_set(i, readfds) || fd_is_set(i, writefds) ||
181                      fd_is_set(i, exceptfds)) &&
182                     !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 | EPOLLERR;
189                         ep_ev.data.fd = i;
190                         if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, i, &ep_ev)) {
191                                 /* We might have failed because we tried to set up too many
192                                  * FD tap types.  Listen FDs, for instance, can only be
193                                  * tapped for READABLE and HANGUP.  Let's try for one of
194                                  * those. */
195                                 if (errno == ENOSYS) {
196                                         ep_ev.events = EPOLLET | EPOLLIN | EPOLLHUP;
197                                         if (!epoll_ctl(epoll_fd, EPOLL_CTL_ADD, i, &ep_ev))
198                                                 continue;
199                                 }
200                                 /* Careful to unlock before calling perror.  perror calls
201                                  * close, which calls our CB, which grabs the lock. */
202                                 uth_mutex_unlock(fdset_mtx);
203                                 perror("select epoll_ctl failed");
204                                 return -1;
205                         }
206                 }
207         }
208         uth_mutex_unlock(fdset_mtx);
209         /* Since we just added some FD to our tracking set, we don't know if its
210          * readable or not.  We'll only catch edge-triggered changes in the future.
211          * We can spuriously tell the user all FDs are ready, and next time they
212          * can block until there is edge activity. */
213         if (changed_set)
214                 return nfds;
215         /* Since there is a global epoll set, we could have multiple threads
216          * epolling at a time and one thread could consume the events that should
217          * wake another thread.  We don't know when the 'other' thread last polled,
218          * so we'll need to assume its event was consumed and just return.
219          *
220          * To make matters more confusing, we could also have a single thread that
221          * selects multiple times on separate FD sets.  So we also need to
222          * distinguish between calls and threads.
223          *
224          * If the same {thread, callsite} selects again and no one else has since
225          * selected, then we know no one consumed the events.  We'll use the stack
226          * pointer to uniquely identify the {thread, callsite} combo that recently
227          * selected.  We use a mutex so that the extra threads sleep. */
228         uth_mutex_lock(sleep_mtx);
229         my_call_id = get_stack_pointer();
230         if (my_call_id != unique_caller) {
231                 /* Could thrash, if we fight with another uth for unique_caller */
232                 unique_caller = my_call_id;
233                 uth_mutex_unlock(sleep_mtx);
234                 return nfds;
235         }
236         /* Need to check for up to FD_SETSIZE - nfds isn't the size of all FDs
237          * tracked; it's the size of only our current select call */
238         ep_results = malloc(sizeof(struct epoll_event) * FD_SETSIZE);
239         if (!ep_results) {
240                 uth_mutex_unlock(sleep_mtx);
241                 errno = ENOMEM;
242                 return -1;
243         }
244         /* Don't care which ones were set; we'll just tell the user they all were
245          * set.  If they can't handle that, this whole plan won't work. */
246         ret = epoll_wait(epoll_fd, ep_results, FD_SETSIZE, ep_timeout);
247         uth_mutex_unlock(sleep_mtx);
248         free(ep_results);
249         /* TODO: consider updating timeval.  It's not mandatory (POSIX). */
250         if (ret == 0)   /* timeout */
251                 return 0;
252         return nfds;
253 }
254
255 int pselect(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
256             const struct timespec *timeout, const sigset_t *sigmask)
257 {
258         int ready;
259         sigset_t origmask;
260         struct timeval local_tv, *tv = &local_tv;
261
262         if (!timeout) {
263                 tv = 0;
264         } else {
265                 tv->tv_sec = timeout->tv_sec;
266                 tv->tv_usec = DIV_ROUND_UP(timeout->tv_nsec, 1000);
267         }
268         /* TODO: this is probably racy */
269         sigprocmask(SIG_SETMASK, sigmask, &origmask);
270         ready = select(nfds, readfds, writefds, exceptfds, tv);
271         sigprocmask(SIG_SETMASK, &origmask, NULL);
272         return ready;
273 }