parlib: have 2LS libraries #include parlib/stdio.h
[akaros.git] / user / parlib / signal.c
1 /* Copyright (c) 2013 The Regents of the University of California
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * Kevin Klues <klueska@cs.berkeley.edu>
4  * See LICENSE for details.
5  *
6  * POSIX signal handling glue.  All glibc programs link against parlib, so they
7  * will get this mixed in.  Mostly just registration of signal handlers.
8  *
9  * POSIX signal handling caveats:
10  * - We don't copy signal handling tables or anything across forks or execs
11  * - We don't send meaningful info in the siginfos, nor do we pass pid/uids on
12  * signals coming from a kill.  This is especially pertinent for sigqueue,
13  * which needs a payload (value) and sending PID
14  * - We run handlers in vcore context, so any blocking syscall will spin.
15  * Regular signals have restrictions on their syscalls too, though not this
16  * great.  We could spawn off a uthread to run the handler, given that we have
17  * a 2LS (which we don't for SCPs).
18  * - We don't do anything with signal blocking/masking.  When in a signal
19  * handler, you won't get interrupted with another signal handler (so long as
20  * you run it in vcore context!).  With uthreads, you could get interrupted.
21  * There is also no process wide signal blocking yet (sigprocmask()).  If this
22  * is desired, we can abort certain signals when we h_p_signal(), 
23  * - Likewise, we don't do waiting for particular signals yet.  Just about the
24  * only thing we do is allow the registration of signal handlers. 
25  * - Check each function for further notes.  */
26
27 // Needed for sigmask functions...
28 #define _GNU_SOURCE
29
30 #include <parlib/parlib.h>
31 #include <parlib/signal.h>
32 #include <parlib/uthread.h>
33 #include <parlib/event.h>
34 #include <parlib/ros_debug.h>
35 #include <errno.h>
36 #include <stdlib.h>
37 #include <parlib/assert.h>
38 #include <ros/procinfo.h>
39 #include <ros/syscall.h>
40 #include <sys/mman.h>
41 #include <parlib/stdio.h>
42
43 /* Forward declare our signal_ops functions. */
44 static int __sigaltstack(__const struct sigaltstack *__restrict __ss,
45                          struct sigaltstack *__restrict __oss);
46 static int __siginterrupt(int __sig, int __interrupt);
47 static int __sigpending(sigset_t *__set);
48 static int __sigprocmask(int __how, __const sigset_t *__restrict __set,
49                          sigset_t *__restrict __oset);
50 static int __sigqueue(__pid_t __pid, int __sig, __const union sigval __val);
51 static int __sigreturn(struct sigcontext *__scp);
52 static int __sigstack(struct sigstack *__ss, struct sigstack *__oss);
53 static int __sigsuspend(__const sigset_t *__set);
54 static int __sigtimedwait(__const sigset_t *__restrict __set,
55                           siginfo_t *__restrict __info,
56                           __const struct timespec *__restrict __timeout);
57 static int __sigwait(__const sigset_t *__restrict __set, int *__restrict __sig);
58 static int __sigwaitinfo(__const sigset_t *__restrict __set,
59                          siginfo_t *__restrict __info);
60 static int __sigself(int signo);
61
62 /* The default definition of signal_ops (similar to sched_ops in uthread.c) */
63 struct signal_ops default_signal_ops = {
64         .sigaltstack = __sigaltstack,
65         .siginterrupt = __siginterrupt,
66         .sigpending = __sigpending,
67         .sigprocmask = __sigprocmask,
68         .sigqueue = __sigqueue,
69         .sigreturn = __sigreturn,
70         .sigstack = __sigstack,
71         .sigsuspend = __sigsuspend,
72         .sigtimedwait = __sigtimedwait,
73         .sigwait = __sigwait,
74         .sigwaitinfo = __sigwaitinfo,
75         .sigself = __sigself
76 };
77
78 /* This is the catch all akaros event->posix signal handler.  All posix signals
79  * are received in a single akaros event type.  They are then dispatched from
80  * this function to their proper posix signal handler */
81 static void handle_event(struct event_msg *ev_msg, unsigned int ev_type,
82                          void *data)
83 {
84         int sig_nr;
85         struct siginfo info = {0};
86         info.si_code = SI_USER;
87         struct user_context fake_uctx;
88
89         assert(ev_msg);
90         sig_nr = ev_msg->ev_arg1;
91         /* We're handling a process-wide signal, but signal handlers will want a
92          * user context.  They operate on the model that some thread got the
93          * signal, but that didn't happen on Akaros.  If we happen to have a
94          * current uthread, we can use that - perhaps that's what the user
95          * wants.  If not, we'll build a fake one representing our current call
96          * stack. */
97         if (current_uthread) {
98                 trigger_posix_signal(sig_nr, &info, get_cur_uth_ctx());
99         } else {
100                 init_user_ctx(&fake_uctx, (uintptr_t)handle_event,
101                               get_stack_pointer());
102                 trigger_posix_signal(sig_nr, &info, &fake_uctx);
103         }
104 }
105
106 /* Called from uthread_slim_init() */
107 void init_posix_signals(void)
108 {
109         struct event_queue *posix_sig_ev_q;
110
111         signal_ops = &default_signal_ops;
112         register_ev_handler(EV_POSIX_SIGNAL, handle_event, 0);
113         posix_sig_ev_q = get_eventq(EV_MBOX_UCQ);
114         assert(posix_sig_ev_q);
115         posix_sig_ev_q->ev_flags = EVENT_IPI | EVENT_INDIR | EVENT_SPAM_INDIR |
116                                    EVENT_WAKEUP;
117         register_kevent_q(posix_sig_ev_q, EV_POSIX_SIGNAL);
118 }
119
120 /* Swap the contents of two user contexts (not just their pointers). */
121 static void swap_user_contexts(struct user_context *c1, struct user_context *c2)
122 {
123         struct user_context temp_ctx;
124
125         temp_ctx = *c1;
126         *c1 = *c2;
127         *c2 = temp_ctx;
128 }
129
130 /* Helper for checking a stack pointer.  It's possible the context we're
131  * injecting signals into is complete garbage, so using the SP is a little
132  * dangerous. */
133 static bool stack_ptr_is_sane(uintptr_t sp)
134 {
135         if ((sp < PGSIZE) || (sp > ULIM))
136                 return FALSE;
137         return TRUE;
138 }
139
140 static bool uth_is_handling_sigs(struct uthread *uth)
141 {
142         return uth->sigstate.data ? TRUE : FALSE;
143 }
144
145 /* Prep a uthread to run a signal handler.  The original context of the uthread
146  * is saved on its stack, and a new context is set up to run the signal handler
147  * the next time the uthread is run. */
148 static void __prep_sighandler(struct uthread *uthread,
149                               void (*entry)(void),
150                               struct siginfo *info)
151 {
152         uintptr_t stack;
153         struct user_context *ctx;
154
155         if (uthread->flags & UTHREAD_SAVED) {
156                 ctx = &uthread->u_ctx;
157         } else {
158                 assert(current_uthread == uthread);
159                 ctx = &vcpd_of(vcore_id())->uthread_ctx;
160         }
161         stack = get_user_ctx_sp(ctx) - sizeof(struct sigdata);
162         stack = ROUNDDOWN(stack, __alignof__(struct sigdata));
163         assert(stack_ptr_is_sane(stack));
164         uthread->sigstate.data = (struct sigdata*)stack;
165         /* Parlib aggressively saves the FP state for HW and VM ctxs.  SW ctxs
166          * should not have FP state saved. */
167         switch (ctx->type) {
168         case ROS_HW_CTX:
169         case ROS_VM_CTX:
170                 assert(uthread->flags & UTHREAD_FPSAVED);
171                 /* We need to save the already-saved FP state into the sigstate
172                  * space.  The sig handler is taking over the uthread and its GP
173                  * and FP spaces.
174                  *
175                  * If we ever go back to not aggressively saving the FP state,
176                  * then for HW and VM ctxs, the state is in hardware.
177                  * Regardless, we still need to save it in ->as, with something
178                  * like: save_fp_state(&uthread->sigstate.data->as);
179                  *
180                  * Either way, when we're done with this entire function, the
181                  * *uthread* will have ~UTHREAD_FPSAVED, since we will be
182                  * talking about the SW context that is running the signal
183                  * handler. */
184                 uthread->sigstate.data->as = uthread->as;
185                 uthread->flags &= ~UTHREAD_FPSAVED;
186                 break;
187         case ROS_SW_CTX:
188                 assert(!(uthread->flags & UTHREAD_FPSAVED));
189                 break;
190         };
191         if (info != NULL)
192                 uthread->sigstate.data->info = *info;
193
194         if (uthread->sigstate.sigalt_stacktop != 0)
195                 stack = uthread->sigstate.sigalt_stacktop;
196
197         init_user_ctx(&uthread->sigstate.data->u_ctx, (uintptr_t)entry, stack);
198         /* The uthread may or may not be UTHREAD_SAVED.  That depends on whether
199          * the uthread was in that state initially.  We're swapping into the
200          * location of 'ctx', which is either in VCPD or the uth itself. */
201         swap_user_contexts(ctx, &uthread->sigstate.data->u_ctx);
202 }
203
204 /* Restore the context saved as the result of running a signal handler on a
205  * uthread. This context will execute the next time the uthread is run. */
206 static void __restore_after_sighandler(struct uthread *uthread)
207 {
208         uthread->u_ctx = uthread->sigstate.data->u_ctx;
209         uthread->flags |= UTHREAD_SAVED;
210         switch (uthread->u_ctx.type) {
211         case ROS_HW_CTX:
212         case ROS_VM_CTX:
213                 uthread->as = uthread->sigstate.data->as;
214                 uthread->flags |= UTHREAD_FPSAVED;
215                 break;
216         }
217         uthread->sigstate.data = NULL;
218 }
219
220 /* Callback when yielding a pthread after upon completion of a sighandler.  We
221  * didn't save the current context on yeild, but that's ok because here we
222  * restore the original saved context of the pthread and then treat this like a
223  * normal voluntary yield. */
224 static void __exit_sighandler_cb(struct uthread *uthread, void *junk)
225 {
226         __restore_after_sighandler(uthread);
227         uthread_paused(uthread);
228 }
229
230 /* Run a specific sighandler from the top of the sigstate stack. The 'info'
231  * struct is prepopulated before the call is triggered as the result of a
232  * reflected fault. */
233 static void __run_sighandler(void)
234 {
235         struct uthread *uthread = current_uthread;
236         int signo = uthread->sigstate.data->info.si_signo;
237
238         __sigdelset(&uthread->sigstate.pending, signo);
239         trigger_posix_signal(signo, &uthread->sigstate.data->info,
240                              &uthread->sigstate.data->u_ctx);
241         uthread_yield(FALSE, __exit_sighandler_cb, 0);
242 }
243
244 /* Run through all pending sighandlers and trigger them with a NULL info
245  * field. These handlers are triggered as the result of thread directed
246  * signals (i.e. not interprocess signals), and thus don't require individual
247  * 'info' structs. */
248 static void __run_all_sighandlers(void)
249 {
250         struct uthread *uthread = current_uthread;
251         sigset_t andset = uthread->sigstate.pending & (~uthread->sigstate.mask);
252
253         for (int i = 1; i < _NSIG; i++) {
254                 if (__sigismember(&andset, i)) {
255                         __sigdelset(&uthread->sigstate.pending, i);
256                         trigger_posix_signal(i, NULL,
257                                              &uthread->sigstate.data->u_ctx);
258                 }
259         }
260         uthread_yield(FALSE, __exit_sighandler_cb, 0);
261 }
262
263 int uthread_signal(struct uthread *uthread, int signo)
264 {
265         // Slightly racy with clearing of mask when triggering the signal, but
266         // that's OK, as signals are inherently racy since they don't queue up.
267         return sigaddset(&uthread->sigstate.pending, signo);
268 }
269
270 /* If there are any pending signals, prep the uthread to run it's signal
271  * handler. The next time the uthread is run, it will pop into it's signal
272  * handler context instead of its original saved context. Once the signal
273  * handler is complete, the original context will be restored and restarted. */
274 void uthread_prep_pending_signals(struct uthread *uthread)
275 {
276         if (!uth_is_handling_sigs(uthread) && uthread->sigstate.pending) {
277                 sigset_t andset = uthread->sigstate.pending & (~uthread->sigstate.mask);
278
279                 if (!__sigisemptyset(&andset))
280                         __prep_sighandler(uthread, __run_all_sighandlers, NULL);
281         }
282 }
283
284 /* If the given signal is unmasked, prep the uthread to run it's signal
285  * handler, but don't run it yet. In either case, make the uthread runnable
286  * again. Once the signal handler is complete, the original context will be
287  * restored and restarted. */
288 void uthread_prep_signal_from_fault(struct uthread *uthread,
289                                     int signo, int code, void *addr)
290 {
291         if (!__sigismember(&uthread->sigstate.mask, signo)) {
292                 struct siginfo info = {0};
293
294                 if (uth_is_handling_sigs(uthread)) {
295                         printf("Uthread sighandler faulted, signal: %d\n",
296                                signo);
297                         /* uthread.c already copied out the faulting ctx into
298                          * the uth */
299                         print_user_context(&uthread->u_ctx);
300                         exit(-1);
301                 }
302                 info.si_signo = signo;
303                 info.si_code = code;
304                 info.si_addr = addr;
305                 __prep_sighandler(uthread, __run_sighandler, &info);
306         }
307 }
308
309 /* This is managed by vcore / 2LS code */
310 static int __sigaltstack(__const struct sigaltstack *__restrict __ss,
311                          struct sigaltstack *__restrict __oss)
312 {
313         if (__ss->ss_flags != 0) {
314                 errno = EINVAL;
315                 return -1;
316         }
317         if (__oss != NULL) {
318                 errno = EINVAL;
319                 return -1;
320         }
321         if (__ss->ss_size < MINSIGSTKSZ) {
322                 errno = ENOMEM;
323                 return -1;
324         }
325         uintptr_t stack_top = (uintptr_t) __ss->ss_sp + __ss->ss_size;
326
327         current_uthread->sigstate.sigalt_stacktop = stack_top;
328         return 0;
329 }
330
331 /* Akaros can't have signals interrupt syscalls to need a restart, though we can
332  * re-wake-up the process while it is waiting for its syscall. */
333 static int __siginterrupt(int __sig, int __interrupt)
334 {
335         return 0;
336 }
337
338 /* Not really possible or relevant - you'd need to walk/examine the event UCQ */
339 static int __sigpending(sigset_t *__set)
340 {
341         return 0;
342 }
343
344 static int __sigprocmask(int __how, __const sigset_t *__restrict __set,
345                          sigset_t *__restrict __oset)
346 {
347         sigset_t *sigmask;
348
349         /* Signal handlers might call sigprocmask, with the intent of affecting
350          * the uthread's sigmask.  Process-wide signal handlers run on behalf of
351          * the entire process and aren't bound to a uthread, which means
352          * sigprocmask won't work.  We can tell we're running one of these
353          * handlers since we are in vcore context.  Uthread signals (e.g.
354          * pthread_kill()) run from uthread context. */
355         if (in_vcore_context()) {
356                 errno = ENOENT;
357                 return -1;
358         }
359
360         sigmask = &current_uthread->sigstate.mask;
361
362         if (__set && (__how != SIG_BLOCK) &&
363                      (__how != SIG_SETMASK) &&
364                      (__how != SIG_UNBLOCK)) {
365                 errno = EINVAL;
366                 return -1;
367         }
368
369         if (__oset)
370                 *__oset = *sigmask;
371         if (__set) {
372                 switch (__how) {
373                         case SIG_BLOCK:
374                                 *sigmask = *sigmask | *__set;
375                                 break;
376                         case SIG_SETMASK:
377                                 *sigmask = *__set;
378                                 break;
379                         case SIG_UNBLOCK:
380                                 *sigmask = *sigmask & ~(*__set);
381                                 break;
382                 }
383         }
384         return 0;
385 }
386
387 /* Needs support with trigger_posix_signal to deal with passing values with
388  * POSIX signals. */
389 static int __sigqueue(__pid_t __pid, int __sig, __const union sigval __val)
390 {
391         return 0;
392 }
393
394 /* Linux specific, and not really needed for us */
395 static int __sigreturn(struct sigcontext *__scp)
396 {
397         return 0;
398 }
399
400 /* This is managed by vcore / 2LS code */
401 static int __sigstack(struct sigstack *__ss, struct sigstack *__oss)
402 {
403         return 0;
404 }
405
406 /* Could do this with a loop on delivery of the signal, sleeping and getting
407  * woken up by the kernel on any event, like we do with async syscalls. */
408 static int __sigsuspend(__const sigset_t *__set)
409 {
410         return 0;
411 }
412
413 /* Can be done similar to sigsuspend, with an extra alarm syscall */
414 static int __sigtimedwait(__const sigset_t *__restrict __set,
415                           siginfo_t *__restrict __info,
416                           __const struct timespec *__restrict __timeout)
417 {
418         return 0;
419 }
420
421 /* Can be done similar to sigsuspend */
422 static int __sigwait(__const sigset_t *__restrict __set, int *__restrict __sig)
423 {
424         return 0;
425 }
426
427 /* Can be done similar to sigsuspend */
428 static int __sigwaitinfo(__const sigset_t *__restrict __set,
429                          siginfo_t *__restrict __info)
430 {
431         return 0;
432 }
433
434 static int __sigself(int signo)
435 {
436         int ret;
437
438         if (in_vcore_context())
439                 return kill(getpid(), signo);
440
441         ret = uthread_signal(current_uthread, signo);
442
443         void cb(struct uthread *uthread, void *arg)
444         {
445                 uthread_paused(uthread);
446         }
447         if (ret == 0)
448                 uthread_yield(TRUE, cb, 0);
449         return ret;
450 }