27da5d6f9139bb4e89c1d4da51a9b7cce20df943
[sliver-openvswitch.git] / lib / signals.c
1 /*
2  * Copyright (c) 2008, 2009, 2011, 2012, 2013 Nicira, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <config.h>
18 #include "signals.h"
19 #include <errno.h>
20 #include <limits.h>
21 #include <signal.h>
22 #include <stdlib.h>
23 #include <unistd.h>
24 #include "poll-loop.h"
25 #include "socket-util.h"
26 #include "type-props.h"
27 #include "util.h"
28 #include "vlog.h"
29
30 VLOG_DEFINE_THIS_MODULE(signals);
31
32 #if defined(_NSIG)
33 #define N_SIGNALS _NSIG
34 #elif defined(NSIG)
35 #define N_SIGNALS NSIG
36 #else
37 /* We could try harder to get the maximum signal number, but in practice we
38  * only care about SIGHUP, which is normally signal 1 anyway. */
39 #define N_SIGNALS 32
40 #endif
41
42 struct signal {
43     int fds[2];
44 };
45
46 static struct signal signals[N_SIGNALS];
47
48 static void signal_handler(int signr);
49
50 /* Sets up a handler for 'signr' and returns a structure that represents it.
51  *
52  * Only one handler for a given signal may be registered. */
53 struct signal *
54 signal_register(int signr)
55 {
56     struct sigaction sa;
57     struct signal *s;
58
59     ovs_assert(signr >= 1 && signr < N_SIGNALS);
60
61     /* Create a pipe. */
62     s = &signals[signr];
63     ovs_assert(!s->fds[0] && !s->fds[1]);
64     xpipe_nonblocking(s->fds);
65
66     /* Install signal handler. */
67     memset(&sa, 0, sizeof sa);
68     sa.sa_handler = signal_handler;
69     sigemptyset(&sa.sa_mask);
70     sa.sa_flags = SA_RESTART;
71     xsigaction(signr, &sa, NULL);
72
73     return s;
74 }
75
76 /* Returns true if signal 's' has been received since the last call to this
77  * function with argument 's'. */
78 bool
79 signal_poll(struct signal *s)
80 {
81     char buf[_POSIX_PIPE_BUF];
82
83     return read(s->fds[0], buf, sizeof buf) > 0;
84 }
85
86 /* Causes the next call to poll_block() to wake up when signal_poll(s) would
87  * return true. */
88 void
89 signal_wait(struct signal *s)
90 {
91     poll_fd_wait(s->fds[0], POLLIN);
92 }
93 \f
94 static void
95 signal_handler(int signr)
96 {
97     if (signr >= 1 && signr < N_SIGNALS) {
98         ignore(write(signals[signr].fds[1], "", 1));
99     }
100 }
101
102 /* Returns the name of signal 'signum' as a string.  The return value is either
103  * a statically allocated constant string or the 'bufsize'-byte buffer
104  * 'namebuf'.  'bufsize' should be at least SIGNAL_NAME_BUFSIZE.
105  *
106  * The string is probably a (possibly multi-word) description of the signal
107  * (e.g. "Hangup") instead of just the stringified version of the macro
108  * (e.g. "SIGHUP"). */
109 const char *
110 signal_name(int signum, char *namebuf, size_t bufsize)
111 {
112 #if HAVE_DECL_SYS_SIGLIST
113     if (signum >= 0 && signum < N_SIGNALS) {
114         const char *name = sys_siglist[signum];
115         if (name) {
116             return name;
117         }
118     }
119 #endif
120
121     snprintf(namebuf, bufsize, "signal %d", signum);
122     return namebuf;
123 }
124
125 void
126 xsigaction(int signum, const struct sigaction *new, struct sigaction *old)
127 {
128     if (sigaction(signum, new, old)) {
129         char namebuf[SIGNAL_NAME_BUFSIZE];
130
131         VLOG_FATAL("sigaction(%s) failed (%s)",
132                    signal_name(signum, namebuf, sizeof namebuf),
133                    ovs_strerror(errno));
134     }
135 }
136
137 void
138 xpthread_sigmask(int how, const sigset_t *new, sigset_t *old)
139 {
140     int error = pthread_sigmask(how, new, old);
141     if (error) {
142         VLOG_FATAL("pthread_sigmask failed (%s)", ovs_strerror(error));
143     }
144 }