diff options
author | Dmitry Antipov <dantipov@cloudlinux.com> | 2022-10-25 11:30:34 +0300 |
---|---|---|
committer | Azat Khuzhin <azat@libevent.org> | 2022-11-12 21:14:48 +0100 |
commit | 1af745d033678333752afcd8724f5d6351561b4e (patch) | |
tree | b67297abda6067ca1609c338f74bbcc07332730a /signalfd.c | |
parent | 9e346936d47a3a461f8ebaedabb2975bef3babf5 (diff) | |
download | libevent-1af745d033678333752afcd8724f5d6351561b4e.tar.gz |
signal: new signal handling backend based on signalfd
Linux-specific signal handling backend based on signalfd(2)
system call, and public function event_base_get_signal_method()
to obtain an underlying kernel signal handling mechanism.
Signed-off-by: Dmitry Antipov <dantipov@cloudlinux.com>
Diffstat (limited to 'signalfd.c')
-rw-r--r-- | signalfd.c | 213 |
1 files changed, 213 insertions, 0 deletions
diff --git a/signalfd.c b/signalfd.c new file mode 100644 index 00000000..376a04d5 --- /dev/null +++ b/signalfd.c @@ -0,0 +1,213 @@ +/* + * Signal handling backend based on signalfd(2) system call + * Written by Dmitry Antipov <dantipov@cloudlinux.com> 2022 + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "event2/event-config.h" + +#include <unistd.h> +#include <sys/signalfd.h> + +#include "event2/event.h" +#include "event-internal.h" +#include "evmap-internal.h" +#include "evsignal-internal.h" +#include "evthread-internal.h" + +static int sigfd_add(struct event_base *, evutil_socket_t, short, short, void *); +static int sigfd_del(struct event_base *, evutil_socket_t, short, short, void *); + +static const struct eventop sigfdops = { + "signalfd_signal", + NULL, + sigfd_add, + sigfd_del, + NULL, + NULL, + 0, 0, 0 +}; + +static void +sigfd_cb(evutil_socket_t fd, short what, void *arg) +{ + struct signalfd_siginfo fdsi; + struct event_base *base = arg; + ssize_t ret = read(fd, &fdsi, sizeof(fdsi)); + + EVUTIL_ASSERT(ret == sizeof(fdsi)); + EVUTIL_ASSERT(fdsi.ssi_signo > 0 && fdsi.ssi_signo < NSIG); + EVUTIL_ASSERT(base->sig.ev_sigevent[fdsi.ssi_signo] != NULL); + + EVBASE_ACQUIRE_LOCK(base, th_base_lock); + evmap_signal_active_(base, fdsi.ssi_signo, 1); + EVBASE_RELEASE_LOCK(base, th_base_lock); +} + +static void +sigfd_free_sigevent(struct event_base *base, int signo) +{ + int ret; + struct event* sigev = base->sig.ev_sigevent[signo]; + + EVUTIL_ASSERT(sigev != NULL); + event_del_nolock_(sigev, EVENT_DEL_AUTOBLOCK); + ret = close(sigev->ev_fd); + EVUTIL_ASSERT(ret == 0); + mm_free(sigev); + base->sig.ev_sigevent[signo] = NULL; +} + +static int +sigfd_add(struct event_base *base, int signo, short old, short events, void *p) +{ + int sigfd; + sigset_t mask; + struct event* sigev; + struct evsig_info *sig = &base->sig; + + /* EV_SIGNAL event passed from evmap_signal_add_() when setting + up and from evmap_signal_reinit_iter_fn() during reinit. */ + EVUTIL_ASSERT(p != NULL); + + EVUTIL_ASSERT(signo > 0 && signo < NSIG); + sigev = base->sig.ev_sigevent[signo]; + + if (sigev != NULL) { + if (old) { + /* We're performing reinit after fork(). This is + required at least for epoll(2)-based backend + because if the process uses fork(2) to create + a child process, then the child will be able + to read(2) signals that are sent to it using the + signalfd(2) file descriptor, but epoll_wait(2) + will not indicate that the signalfd file + descriptor is ready. */ + sigfd_free_sigevent(base, signo); + } else { + /* We have an active signal fd + for this signal already. */ + return 0; + } + } + + /* Save previous handler just like evsig_set_handler_() does. */ + if (evsig_ensure_saved_(sig, signo) < 0) + return -1; + + sig->sh_old[signo] = mm_malloc(sizeof *sig->sh_old[signo]); + if (sig->sh_old[signo] == NULL) { + event_warn("malloc() failed"); + return -1; + } + + if (sigaction(signo, NULL, sig->sh_old[signo]) == -1) { + event_warn("sigaction() failed"); + mm_free(sig->sh_old[signo]); + sig->sh_old[signo] = NULL; + return -1; + } + + /* Block the signal from being handled according to its default + disposition so it may be received via the descriptor. */ + sigemptyset(&mask); + sigaddset(&mask, signo); + if (sigprocmask(SIG_BLOCK, &mask, NULL)) { + event_warn("sigprocmask() failed"); + return -1; + } + + sigfd = signalfd(-1, &mask, SFD_NONBLOCK | SFD_CLOEXEC); + if (sigfd < 0) { + event_warn("signalfd() failed"); + goto unblock; + } + + /* EV_READ event used to wakeup corresponding EV_SIGNAL ones. */ + sigev = event_new(base, sigfd, EV_READ | EV_PERSIST, sigfd_cb, base); + if (!sigev) + goto close_fd; + + /* This was blindly copied from evsig_init_(). */ + sigev->ev_flags |= EVLIST_INTERNAL; + event_priority_set(sigev, 0); + + if (event_add_nolock_(sigev, NULL, 0) < 0) + goto free_ev; + + base->sig.ev_sigevent[signo] = sigev; + return 0; +free_ev: + mm_free(sigev); +close_fd: + close(sigfd); +unblock: + sigprocmask(SIG_UNBLOCK, &mask, NULL); + return -1; +} + +static int +sigfd_del(struct event_base *base, int signo, short old, short events, void *p) +{ + sigset_t mask; + struct event *sigev; + struct evsig_info *sig = &base->sig; + + EVUTIL_ASSERT(signo > 0 && signo < NSIG); + sigev = base->sig.ev_sigevent[signo]; + EVUTIL_ASSERT(sigev != NULL); + + sigemptyset(&mask); + sigaddset(&mask, signo); + if (sigprocmask(SIG_UNBLOCK, &mask, NULL)) { + event_warn("sigprocmask() failed"); + return -1; + } + + /* Restore previous handler, if any. */ + if (signo < sig->sh_old_max) { + struct sigaction *sa = sig->sh_old[signo]; + if (sa) { + if (sigaction(signo, sa, NULL) == -1) { + event_warn("sigaction() failed"); + return -1; + } + mm_free(sa); + sig->sh_old[signo] = NULL; + } + } + + sigfd_free_sigevent(base, signo); + return 0; +} + +int sigfd_init_(struct event_base *base) +{ + EVUTIL_ASSERT(base != NULL); + if ((base->flags & EVENT_BASE_FLAG_DISALLOW_SIGNALFD) || + getenv("EVENT_DISALLOW_SIGNALFD")) + return -1; + base->evsigsel = &sigfdops; + return 0; +} |