Check for ctx in default_core_handler()
[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 #include <signal.h>
28 #include <stdio.h>
29
30 #include <parlib/parlib.h>
31 #include <parlib/event.h>
32 #include <errno.h>
33 #include <assert.h>
34 #include <ros/procinfo.h>
35 #include <ros/syscall.h>
36 #include <sys/mman.h>
37 #include <parlib/vcore.h> /* for print_user_context() */
38 #include <parlib/waitfreelist.h>
39
40 /* This is list of sigactions associated with each posix signal. */
41 static struct sigaction sigactions[_NSIG];
42
43 /* Forward declare some functions. */
44 static int __sigprocmask(int __how, __const sigset_t *__restrict __set,
45                          sigset_t *__restrict __oset);
46
47 /* The default definition of signal_ops (similar to sched_ops in uthread.c) */
48 struct signal_ops default_signal_ops = {
49         .sigprocmask = __sigprocmask,
50 };
51 struct signal_ops *signal_ops = &default_signal_ops;
52
53 /* This is a wait-free-list used to hold the data necessary to execute signal
54  * handlers inside a 2LS. We are able to store them in a wfl because all
55  * sigdata structs are created equal, and reuse is encouraged as uthreads
56  * ask for them on demand. */
57 static struct wfl sigdata_list;
58 #define SIGNAL_STACK_SIZE (2*PGSIZE + sizeof(struct sigdata))
59
60 /* These are the default handlers for each posix signal.  They are listed in
61  * SIGNAL(7) of the Linux Programmer's Manual.  We run them as default
62  * sigactions, instead of the older handlers, so that we have access to the
63  * faulting context.
64  *
65  * Exit codes are set as suggested in the following link.  I wish I could find
66  * the definitive source, but this will have to do for now.
67  * http://unix.stackexchange.com/questions/99112/default-exit-code-when-process-is-terminated
68  * */
69 static void default_term_handler(int signr, siginfo_t *info, void *ctx)
70 {
71         ros_syscall(SYS_proc_destroy, __procinfo.pid, signr, 0, 0, 0, 0);
72 }
73
74 static void default_core_handler(int signr, siginfo_t *info, void *ctx)
75 {
76         fprintf(stderr, "Segmentation Fault (sorry, no core dump yet)\n");
77         if (ctx)
78                 print_user_context((struct user_context*)ctx);
79         else
80                 fprintf(stderr, "No ctx for %s\n", __FUNCTION__);
81         if (info) {
82                 /* ghetto, we don't have access to the PF err, since we only have a few
83                  * fields available in siginfo (e.g. there's no si_trapno). */
84                 fprintf(stderr, "Fault type %d at addr %p\n", info->si_errno,
85                         info->si_addr);
86         } else {
87                 fprintf(stderr, "No fault info\n");
88         }
89         default_term_handler((1 << 7) + signr, info, ctx);
90 }
91
92 static void default_stop_handler(int signr, siginfo_t *info, void *ctx)
93 {
94         fprintf(stderr, "Stop signal received!  No support to stop yet though!\n");
95 }
96
97 static void default_cont_handler(int signr, siginfo_t *info, void *ctx)
98 {
99         fprintf(stderr, "Cont signal received!  No support to cont yet though!\n");
100 }
101
102 typedef void (*__sigacthandler_t)(int, siginfo_t *, void *);
103 #define SIGACT_ERR      ((__sigacthandler_t) -1)        /* Error return.  */
104 #define SIGACT_DFL      ((__sigacthandler_t) 0)         /* Default action.  */
105 #define SIGACT_IGN      ((__sigacthandler_t) 1)         /* Ignore signal.  */
106
107 static __sigacthandler_t default_handlers[] = {
108         [SIGHUP]    = default_term_handler, 
109         [SIGINT]    = default_term_handler, 
110         [SIGQUIT]   = default_core_handler, 
111         [SIGILL]    = default_core_handler, 
112         [SIGTRAP]   = default_core_handler, 
113         [SIGABRT]   = default_core_handler, 
114         [SIGIOT]    = default_core_handler, 
115         [SIGBUS]    = default_core_handler, 
116         [SIGFPE]    = default_core_handler, 
117         [SIGKILL]   = default_term_handler, 
118         [SIGUSR1]   = default_term_handler, 
119         [SIGSEGV]   = default_core_handler, 
120         [SIGUSR2]   = default_term_handler, 
121         [SIGPIPE]   = default_term_handler, 
122         [SIGALRM]   = default_term_handler, 
123         [SIGTERM]   = default_term_handler, 
124         [SIGSTKFLT] = default_term_handler, 
125         [SIGCHLD]   = SIGACT_IGN,
126         [SIGCONT]   = default_cont_handler, 
127         [SIGSTOP]   = default_stop_handler, 
128         [SIGTSTP]   = default_stop_handler, 
129         [SIGTTIN]   = default_stop_handler, 
130         [SIGTTOU]   = default_stop_handler, 
131         [SIGURG]    = default_term_handler, 
132         [SIGXCPU]   = SIGACT_IGN,
133         [SIGXFSZ]   = default_core_handler, 
134         [SIGVTALRM] = default_term_handler, 
135         [SIGPROF]   = default_term_handler, 
136         [SIGWINCH]  = SIGACT_IGN,
137         [SIGIO]     = default_term_handler, 
138         [SIGPWR]    = SIGACT_IGN,
139         [SIGSYS]    = default_core_handler,
140         [SIGSYS+1 ... _NSIG-1] = SIGACT_IGN
141 };
142
143 /* This function allocates a sigdata struct for use when running signal
144  * handlers inside a 2LS. The sigdata struct returned is pre-initialized with
145  * the 'stack' field pointing to a valid stack.  Space is allocated for both
146  * the sigdata struct and the stack in a single mmap call.  The sigdata struct
147  * just sits at the bottom of the stack, and its 'stack' field points just
148  * above it.  */
149 struct sigdata *alloc_sigdata()
150 {
151         struct sigdata *data = wfl_remove(&sigdata_list);
152         if (data == NULL) {
153                 void *stack = mmap(0, SIGNAL_STACK_SIZE,
154                                    PROT_READ|PROT_WRITE|PROT_EXEC,
155                                    MAP_POPULATE|MAP_ANONYMOUS, -1, 0);
156                 assert(stack != MAP_FAILED);
157                 data = stack + SIGNAL_STACK_SIZE - sizeof(struct sigdata);
158                 data->stack = data;
159         }
160         return data;
161 }
162
163 /* This function frees a previously allocated sigdata struct. */
164 void free_sigdata(struct sigdata *sigdata)
165 {
166         wfl_insert(&sigdata_list, sigdata);
167 }
168
169 /* This is the akaros posix signal trigger.  Signals are dispatched from
170  * this function to their proper posix signal handler */
171 void trigger_posix_signal(int sig_nr, struct siginfo *info, void *aux)
172 {
173         struct sigaction *action;
174         if (sig_nr >= _NSIG || sig_nr < 0)
175                 return;
176         action = &sigactions[sig_nr];
177         /* Would like a switch/case here, but they are pointers.  We can also get
178          * away with this check early since sa_handler and sa_sigaction are macros
179          * referencing the same union.  The man page isn't specific about whether or
180          * not you need to care about SA_SIGINFO when sending DFL/ERR/IGN. */
181         if (action->sa_handler == SIG_ERR)
182                 return;
183         if (action->sa_handler == SIG_IGN)
184                 return;
185         if (action->sa_handler == SIG_DFL) {
186                 if (default_handlers[sig_nr] != SIGACT_IGN)
187                         default_handlers[sig_nr](sig_nr, info, aux);
188                 return;
189         }
190
191         if (action->sa_flags & SA_SIGINFO) {
192                 /* If NULL info struct passed in, construct our own */
193                 struct siginfo s = {0};
194                 if (info == NULL)
195                         info = &s;
196                 /* Make sure the caller either already set singo in the info struct, or
197                  * if they didn't, make sure it has been zeroed out (i.e. not just some
198                  * garbage on the stack. */
199                 assert(info->si_signo == sig_nr || info->si_signo == 0);
200                 info->si_signo = sig_nr;
201                 /* TODO: consider info->pid and whatnot */
202                 /* We assume that this function follows the proper calling convention
203                  * (i.e. it wasn't written in some crazy assembly function that
204                  * trashes all its registers, i.e GO's default runtime handler) */
205                 action->sa_sigaction(sig_nr, info, aux);
206         } else {
207                 action->sa_handler(sig_nr);
208         }
209 }
210
211 /* This is the catch all akaros event->posix signal handler.  All posix signals
212  * are received in a single akaros event type.  They are then dispatched from
213  * this function to their proper posix signal handler */
214 static void handle_event(struct event_msg *ev_msg, unsigned int ev_type,
215                          void *data)
216 {
217         int sig_nr;
218         struct siginfo info = {0};
219         info.si_code = SI_USER;
220
221         assert(ev_msg);
222         sig_nr = ev_msg->ev_arg1;
223         trigger_posix_signal(sig_nr, &info, 0);
224 }
225
226 /* Called from uthread_slim_init() */
227 void init_posix_signals(void)
228 {
229         struct event_queue *posix_sig_ev_q;
230         register_ev_handler(EV_POSIX_SIGNAL, handle_event, 0);
231         posix_sig_ev_q = get_eventq(EV_MBOX_UCQ);
232         assert(posix_sig_ev_q);
233         posix_sig_ev_q->ev_flags = EVENT_IPI | EVENT_INDIR | EVENT_SPAM_INDIR |
234                                    EVENT_WAKEUP;
235         register_kevent_q(posix_sig_ev_q, EV_POSIX_SIGNAL);
236         wfl_init(&sigdata_list);
237 }
238
239 int sigaddset(sigset_t *__set, int __signo)
240 {
241         if (__signo == 0 || __signo >= _NSIG) {
242                 errno = EINVAL;
243                 return -1;
244         }
245         __sigaddset(__set, __signo);
246         return 0;
247 }
248
249 int sigdelset(sigset_t *__set, int __signo)
250 {
251         if (__signo == 0 || __signo >= _NSIG) {
252                 errno = EINVAL;
253                 return -1;
254         }
255         __sigdelset(__set, __signo);
256         return 0;
257 }
258
259 int sigismember(__const sigset_t *__set, int __signo)
260 {
261         if (__signo == 0 || __signo >= _NSIG) {
262                 errno = EINVAL;
263                 return -1;
264         }
265         __sigismember(__set, __signo);
266         return 0;
267 }
268
269 static int __sigprocmask(int __how, __const sigset_t *__restrict __set,
270                          sigset_t *__restrict __oset)
271 {
272         printf("Function not supported generically! "
273            "Use 2LS specific function e.g. pthread_sigmask\n");
274         return 0;
275 }
276
277 int sigprocmask(int __how, __const sigset_t *__restrict __set,
278                 sigset_t *__restrict __oset)
279 {
280         return signal_ops->sigprocmask(__how, __set, __oset);
281 }
282
283 /* Could do this with a loop on delivery of the signal, sleeping and getting
284  * woken up by the kernel on any event, like we do with async syscalls. */
285 int sigsuspend(__const sigset_t *__set)
286 {
287         return 0;
288 }
289
290 int sigaction(int __sig, __const struct sigaction *__restrict __act,
291               struct sigaction *__restrict __oact)
292 {
293         if (__sig >= _NSIG || __sig < 0)
294                 return -1;
295         if (__oact) {
296                 *__oact = sigactions[__sig];
297         }
298         if (!__act)
299                 return 0;
300         sigactions[__sig] = *__act;
301         return 0;
302 }
303
304 /* Not really possible or relevant - you'd need to walk/examine the event UCQ */
305 int sigpending(sigset_t *__set)
306 {
307         return 0;
308 }
309
310 /* Can be done similar to sigsuspend */
311 int sigwait(__const sigset_t *__restrict __set, int *__restrict __sig)
312 {
313         return 0;
314 }
315
316 /* Can be done similar to sigsuspend */
317 int sigwaitinfo(__const sigset_t *__restrict __set,
318                 siginfo_t *__restrict __info)
319 {
320         return 0;
321 }
322
323 /* Can be done similar to sigsuspend, with an extra alarm syscall */
324 int sigtimedwait(__const sigset_t *__restrict __set,
325                  siginfo_t *__restrict __info,
326                  __const struct timespec *__restrict __timeout)
327 {
328         return 0;
329 }
330
331 /* Needs support with trigger_posix_signal to deal with passing values with POSIX
332  * signals. */
333 int sigqueue(__pid_t __pid, int __sig, __const union sigval __val)
334 {
335         return 0;
336 }
337
338 /* Old BSD interface, deprecated */
339 int sigvec(int __sig, __const struct sigvec *__vec, struct sigvec *__ovec)
340 {
341         return 0;
342 }
343
344 /* Linux specific, and not really needed for us */
345 int sigreturn(struct sigcontext *__scp)
346 {
347         return 0;
348 }
349
350 /* Akaros can't have signals interrupt syscalls to need a restart, though we can
351  * re-wake-up the process while it is waiting for its syscall. */
352 int siginterrupt(int __sig, int __interrupt)
353 {
354         return 0;
355 }
356
357 /* This is managed by vcore / 2LS code */
358 int sigstack(struct sigstack *__ss, struct sigstack *__oss)
359 {
360         return 0;
361 }
362
363 /* This is managed by vcore / 2LS code */
364 int sigaltstack(__const struct sigaltstack *__restrict __ss,
365                 struct sigaltstack *__restrict __oss)
366 {
367         return 0;
368 }
369
370 __sighandler_t signal(int sig, __sighandler_t handler)
371 {
372         int ret;
373         struct sigaction newsa = {0};
374         struct sigaction oldsa = {0};
375         newsa.sa_handler = handler;
376         ret = sigaction(sig, &newsa, &oldsa);
377         if (ret < 0) {
378                 errno = EINVAL;
379                 return SIG_ERR;
380         }
381         return oldsa.sa_handler;
382 }