From bbd8b03be3cf2e10caf21ecc26326bb0a693cc9b Mon Sep 17 00:00:00 2001 From: Michael Stapelberg Date: Sat, 30 Apr 2011 20:50:37 +0200 Subject: [PATCH] Implement systemd socket activation support for filed MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This commit implements socket activation support. Instead of starting the filed and having it waiting for connections, you can let systemd listen on port 9102 and start bacula-fd when it’s actually necessary (as soon as the first client connects). This further speeds up system boot and lowers resource consumption for sessions in which bacula-fd is not actually used. --- bacula/src/lib/Makefile.in | 6 +- bacula/src/lib/bnet_server.c | 251 ++++++++++++++---------- bacula/src/lib/sd-daemon.c | 436 ++++++++++++++++++++++++++++++++++++++++++ bacula/src/lib/sd-daemon.h | 265 +++++++++++++++++++++++++ 4 files changed, 849 insertions(+), 109 deletions(-) create mode 100644 bacula/src/lib/sd-daemon.c create mode 100644 bacula/src/lib/sd-daemon.h diff --git a/bacula/src/lib/Makefile.in b/bacula/src/lib/Makefile.in index 206ac7a..2936765 100644 --- a/bacula/src/lib/Makefile.in +++ b/bacula/src/lib/Makefile.in @@ -43,7 +43,8 @@ INCLUDE_FILES = ../baconfig.h ../bacula.h ../bc_types.h \ smartall.h status.h tls.h tree.h var.h \ waitq.h watchdog.h workq.h \ parse_conf.h \ - pythonlib.h lockmgr.h devlock.h + pythonlib.h lockmgr.h devlock.h \ + sd-daemon.h # # libbac @@ -58,7 +59,8 @@ LIBBAC_SRCS = attr.c base64.c berrno.c bsys.c bget_msg.c \ rwlock.c scan.c serial.c sha1.c \ signal.c smartall.c rblist.c tls.c tree.c \ util.c var.c watchdog.c workq.c btimers.c \ - address_conf.c breg.c htable.c lockmgr.c devlock.c + address_conf.c breg.c htable.c lockmgr.c devlock.c \ + sd-daemon.c LIBBAC_OBJS = $(LIBBAC_SRCS:.c=.o) LIBBAC_LOBJS = $(LIBBAC_SRCS:.c=.lo) diff --git a/bacula/src/lib/bnet_server.c b/bacula/src/lib/bnet_server.c index 3207ae4..f4cff1a 100644 --- a/bacula/src/lib/bnet_server.c +++ b/bacula/src/lib/bnet_server.c @@ -45,6 +45,7 @@ //#include #endif +#include "sd-daemon.h" static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; @@ -64,6 +65,68 @@ void bnet_stop_thread_server(pthread_t tid) } } +static void accept_client(int fd, workq_t *client_wq) { + socklen_t clilen; + struct sockaddr cli_addr; /* client's address */ + int newsockfd, stat; + int turnon = 1; + char buf[128]; + + /* Got a connection, now accept it. */ + do { + clilen = sizeof(cli_addr); + newsockfd = accept(fd, &cli_addr, &clilen); + } while (newsockfd < 0 && errno == EINTR); + if (newsockfd < 0) { + return; + } +#ifdef HAVE_LIBWRAP + P(mutex); /* hosts_access is not thread safe */ + request_init(&request, RQ_DAEMON, my_name, RQ_FILE, newsockfd, 0); + fromhost(&request); + if (!hosts_access(&request)) { + V(mutex); + Jmsg2(NULL, M_SECURITY, 0, + _("Connection from %s:%d refused by hosts.access\n"), + sockaddr_to_ascii(&cli_addr, buf, sizeof(buf)), + sockaddr_get_port(&cli_addr)); + close(newsockfd); + return; + } + V(mutex); +#endif + + /* + * Receive notification when connection dies. + */ + if (setsockopt(newsockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, + sizeof(turnon)) < 0) { + berrno be; + Emsg1(M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"), + be.bstrerror()); + } + + /* see who client is. i.e. who connected to us. */ + P(mutex); + sockaddr_to_ascii(&cli_addr, buf, sizeof(buf)); + V(mutex); + BSOCK *bs; + /* XXX: Why do we need to set the port here? at least for the filed, it seems unused */ + bs = init_bsock(NULL, newsockfd, "client", buf, 9102, &cli_addr); + //bs = init_bsock(NULL, newsockfd, "client", buf, fd_ptr->port, &cli_addr); + if (bs == NULL) { + Jmsg0(NULL, M_ABORT, 0, _("Could not create client BSOCK.\n")); + } + + /* Queue client to be served */ + if ((stat = workq_add(client_wq, (void *)bs, NULL, 0)) != 0) { + berrno be; + be.set_errno(stat); + Jmsg1(NULL, M_ABORT, 0, _("Could not add job to client queue: ERR=%s\n"), + be.bstrerror()); + } +} + /* Become Threaded Network Server This function is able to handle multiple server ips in @@ -75,9 +138,7 @@ void bnet_thread_server(dlist *addrs, int max_clients, workq_t *client_wq, void *handle_client_request(void *bsock)) { - int newsockfd, stat; - socklen_t clilen; - struct sockaddr cli_addr; /* client's address */ + int stat; int tlog; int turnon = 1; #ifdef HAVE_LIBWRAP @@ -89,56 +150,63 @@ bnet_thread_server(dlist *addrs, int max_clients, workq_t *client_wq, int fd; int port; } *fd_ptr = NULL; - char buf[128]; dlist sockfds; char allbuf[256 * 10]; Dmsg1(100, "Addresses %s\n", build_addresses_str(addrs, allbuf, sizeof(allbuf))); - foreach_dlist(p, addrs) { - /* Allocate on stack from -- no need to free */ - fd_ptr = (s_sockfd *)alloca(sizeof(s_sockfd)); - fd_ptr->port = p->get_port_net_order(); - /* - * Open a TCP socket - */ - for (tlog= 60; (fd_ptr->fd=socket(p->get_family(), SOCK_STREAM, 0)) < 0; tlog -= 10) { - if (tlog <= 0) { - berrno be; - char curbuf[256]; - Emsg3(M_ABORT, 0, _("Cannot open stream socket. ERR=%s. Current %s All %s\n"), - be.bstrerror(), - p->build_address_str(curbuf, sizeof(curbuf)), - build_addresses_str(addrs, allbuf, sizeof(allbuf))); - } - bmicrosleep(10, 0); - } - /* - * Reuse old sockets - */ - if (setsockopt(fd_ptr->fd, SOL_SOCKET, SO_REUSEADDR, (sockopt_val_t)&turnon, - sizeof(turnon)) < 0) { - berrno be; - Emsg1(M_WARNING, 0, _("Cannot set SO_REUSEADDR on socket: %s\n"), - be.bstrerror()); - } + int fds = sd_listen_fds(0); + if (fds < 0) { + Emsg0(M_ABORT, 0, "Error in sd_listen_fds\n"); + } + if (fds > 0) { + Dmsg1(100, "Taking %d FDs from systemd\n", fds); + } else { + foreach_dlist(p, addrs) { + /* Allocate on stack from -- no need to free */ + fd_ptr = (s_sockfd *)alloca(sizeof(s_sockfd)); + fd_ptr->port = p->get_port_net_order(); + /* + * Open a TCP socket + */ + for (tlog= 60; (fd_ptr->fd=socket(p->get_family(), SOCK_STREAM, 0)) < 0; tlog -= 10) { + if (tlog <= 0) { + berrno be; + char curbuf[256]; + Emsg3(M_ABORT, 0, _("Cannot open stream socket. ERR=%s. Current %s All %s\n"), + be.bstrerror(), + p->build_address_str(curbuf, sizeof(curbuf)), + build_addresses_str(addrs, allbuf, sizeof(allbuf))); + } + bmicrosleep(10, 0); + } + /* + * Reuse old sockets + */ + if (setsockopt(fd_ptr->fd, SOL_SOCKET, SO_REUSEADDR, (sockopt_val_t)&turnon, + sizeof(turnon)) < 0) { + berrno be; + Emsg1(M_WARNING, 0, _("Cannot set SO_REUSEADDR on socket: %s\n"), + be.bstrerror()); + } - int tmax = 30 * (60 / 5); /* wait 30 minutes max */ - for (tlog = 0; bind(fd_ptr->fd, p->get_sockaddr(), p->get_sockaddr_len()) < 0; tlog -= 5) { - berrno be; - if (tlog <= 0) { - tlog = 2 * 60; /* Complain every 2 minutes */ - Emsg2(M_WARNING, 0, _("Cannot bind port %d: ERR=%s: Retrying ...\n"), - ntohs(fd_ptr->port), be.bstrerror()); - } - bmicrosleep(5, 0); - if (--tmax <= 0) { - Emsg2(M_ABORT, 0, _("Cannot bind port %d: ERR=%s.\n"), ntohs(fd_ptr->port), - be.bstrerror()); - } + int tmax = 30 * (60 / 5); /* wait 30 minutes max */ + for (tlog = 0; bind(fd_ptr->fd, p->get_sockaddr(), p->get_sockaddr_len()) < 0; tlog -= 5) { + berrno be; + if (tlog <= 0) { + tlog = 2 * 60; /* Complain every 2 minutes */ + Emsg2(M_WARNING, 0, _("Cannot bind port %d: ERR=%s: Retrying ...\n"), + ntohs(fd_ptr->port), be.bstrerror()); + } + bmicrosleep(5, 0); + if (--tmax <= 0) { + Emsg2(M_ABORT, 0, _("Cannot bind port %d: ERR=%s.\n"), ntohs(fd_ptr->port), + be.bstrerror()); + } + } + listen(fd_ptr->fd, 50); /* tell system we are ready */ + sockfds.append(fd_ptr); } - listen(fd_ptr->fd, 50); /* tell system we are ready */ - sockfds.append(fd_ptr); } /* Start work queue thread */ if ((stat = workq_init(client_wq, max_clients, handle_client_request)) != 0) { @@ -153,9 +221,17 @@ bnet_thread_server(dlist *addrs, int max_clients, workq_t *client_wq, unsigned int maxfd = 0; fd_set sockset; FD_ZERO(&sockset); - foreach_dlist(fd_ptr, &sockfds) { - FD_SET((unsigned)fd_ptr->fd, &sockset); - maxfd = maxfd > (unsigned)fd_ptr->fd ? maxfd : fd_ptr->fd; + if (fds > 0) { + int fd; + for (fd = SD_LISTEN_FDS_START; fd < (SD_LISTEN_FDS_START + fds); fd++) { + FD_SET(fd, &sockset); + } + maxfd = SD_LISTEN_FDS_START + fds; + } else { + foreach_dlist(fd_ptr, &sockfds) { + FD_SET((unsigned)fd_ptr->fd, &sockset); + maxfd = maxfd > (unsigned)fd_ptr->fd ? maxfd : fd_ptr->fd; + } } errno = 0; if ((stat = select(maxfd + 1, &sockset, NULL, NULL, NULL)) < 0) { @@ -167,67 +243,28 @@ bnet_thread_server(dlist *addrs, int max_clients, workq_t *client_wq, break; } - foreach_dlist(fd_ptr, &sockfds) { - if (FD_ISSET(fd_ptr->fd, &sockset)) { - /* Got a connection, now accept it. */ - do { - clilen = sizeof(cli_addr); - newsockfd = accept(fd_ptr->fd, &cli_addr, &clilen); - } while (newsockfd < 0 && errno == EINTR); - if (newsockfd < 0) { - continue; - } -#ifdef HAVE_LIBWRAP - P(mutex); /* hosts_access is not thread safe */ - request_init(&request, RQ_DAEMON, my_name, RQ_FILE, newsockfd, 0); - fromhost(&request); - if (!hosts_access(&request)) { - V(mutex); - Jmsg2(NULL, M_SECURITY, 0, - _("Connection from %s:%d refused by hosts.access\n"), - sockaddr_to_ascii(&cli_addr, buf, sizeof(buf)), - sockaddr_get_port(&cli_addr)); - close(newsockfd); - continue; - } - V(mutex); -#endif - - /* - * Receive notification when connection dies. - */ - if (setsockopt(newsockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, - sizeof(turnon)) < 0) { - berrno be; - Emsg1(M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"), - be.bstrerror()); - } - - /* see who client is. i.e. who connected to us. */ - P(mutex); - sockaddr_to_ascii(&cli_addr, buf, sizeof(buf)); - V(mutex); - BSOCK *bs; - bs = init_bsock(NULL, newsockfd, "client", buf, fd_ptr->port, &cli_addr); - if (bs == NULL) { - Jmsg0(NULL, M_ABORT, 0, _("Could not create client BSOCK.\n")); - } - - /* Queue client to be served */ - if ((stat = workq_add(client_wq, (void *)bs, NULL, 0)) != 0) { - berrno be; - be.set_errno(stat); - Jmsg1(NULL, M_ABORT, 0, _("Could not add job to client queue: ERR=%s\n"), - be.bstrerror()); - } - } + if (fds > 0) { + int fd; + for (fd = SD_LISTEN_FDS_START; fd < (SD_LISTEN_FDS_START + fds); fd++) { + if (FD_ISSET(fd, &sockset)) { + accept_client(fd, client_wq); + } + } + } else { + foreach_dlist(fd_ptr, &sockfds) { + if (FD_ISSET(fd_ptr->fd, &sockset)) { + accept_client(fd_ptr->fd, client_wq); + } + } } } - /* Cleanup open files and pointers to them */ - while ((fd_ptr = (s_sockfd *)sockfds.first())) { - close(fd_ptr->fd); - sockfds.remove(fd_ptr); /* don't free() item it is on stack */ + if (fds == 0) { + /* Cleanup open files and pointers to them */ + while ((fd_ptr = (s_sockfd *)sockfds.first())) { + close(fd_ptr->fd); + sockfds.remove(fd_ptr); /* don't free() item it is on stack */ + } } /* Stop work queue thread */ diff --git a/bacula/src/lib/sd-daemon.c b/bacula/src/lib/sd-daemon.c new file mode 100644 index 0000000..6d1eebf --- /dev/null +++ b/bacula/src/lib/sd-daemon.c @@ -0,0 +1,436 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/*** + Copyright 2010 Lennart Poettering + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +***/ + +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "sd-daemon.h" + +int sd_listen_fds(int unset_environment) { + +#if defined(DISABLE_SYSTEMD) || !defined(__linux__) + return 0; +#else + int r, fd; + const char *e; + char *p = NULL; + unsigned long l; + + if (!(e = getenv("LISTEN_PID"))) { + r = 0; + goto finish; + } + + errno = 0; + l = strtoul(e, &p, 10); + + if (errno != 0) { + r = -errno; + goto finish; + } + + if (!p || *p || l <= 0) { + r = -EINVAL; + goto finish; + } + + /* Is this for us? */ + if (getpid() != (pid_t) l) { + r = 0; + goto finish; + } + + if (!(e = getenv("LISTEN_FDS"))) { + r = 0; + goto finish; + } + + errno = 0; + l = strtoul(e, &p, 10); + + if (errno != 0) { + r = -errno; + goto finish; + } + + if (!p || *p) { + r = -EINVAL; + goto finish; + } + + for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + (int) l; fd ++) { + int flags; + + if ((flags = fcntl(fd, F_GETFD)) < 0) { + r = -errno; + goto finish; + } + + if (flags & FD_CLOEXEC) + continue; + + if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) < 0) { + r = -errno; + goto finish; + } + } + + r = (int) l; + +finish: + if (unset_environment) { + unsetenv("LISTEN_PID"); + unsetenv("LISTEN_FDS"); + } + + return r; +#endif +} + +int sd_is_fifo(int fd, const char *path) { + struct stat st_fd; + + if (fd < 0) + return -EINVAL; + + memset(&st_fd, 0, sizeof(st_fd)); + if (fstat(fd, &st_fd) < 0) + return -errno; + + if (!S_ISFIFO(st_fd.st_mode)) + return 0; + + if (path) { + struct stat st_path; + + memset(&st_path, 0, sizeof(st_path)); + if (stat(path, &st_path) < 0) { + + if (errno == ENOENT || errno == ENOTDIR) + return 0; + + return -errno; + } + + return + st_path.st_dev == st_fd.st_dev && + st_path.st_ino == st_fd.st_ino; + } + + return 1; +} + +static int sd_is_socket_internal(int fd, int type, int listening) { + struct stat st_fd; + + if (fd < 0 || type < 0) + return -EINVAL; + + if (fstat(fd, &st_fd) < 0) + return -errno; + + if (!S_ISSOCK(st_fd.st_mode)) + return 0; + + if (type != 0) { + int other_type = 0; + socklen_t l = sizeof(other_type); + + if (getsockopt(fd, SOL_SOCKET, SO_TYPE, &other_type, &l) < 0) + return -errno; + + if (l != sizeof(other_type)) + return -EINVAL; + + if (other_type != type) + return 0; + } + + if (listening >= 0) { + int accepting = 0; + socklen_t l = sizeof(accepting); + + if (getsockopt(fd, SOL_SOCKET, SO_ACCEPTCONN, &accepting, &l) < 0) + return -errno; + + if (l != sizeof(accepting)) + return -EINVAL; + + if (!accepting != !listening) + return 0; + } + + return 1; +} + +union sockaddr_union { + struct sockaddr sa; + struct sockaddr_in in4; + struct sockaddr_in6 in6; + struct sockaddr_un un; + struct sockaddr_storage storage; +}; + +int sd_is_socket(int fd, int family, int type, int listening) { + int r; + + if (family < 0) + return -EINVAL; + + if ((r = sd_is_socket_internal(fd, type, listening)) <= 0) + return r; + + if (family > 0) { + union sockaddr_union sockaddr; + socklen_t l; + + memset(&sockaddr, 0, sizeof(sockaddr)); + l = sizeof(sockaddr); + + if (getsockname(fd, &sockaddr.sa, &l) < 0) + return -errno; + + if (l < sizeof(sa_family_t)) + return -EINVAL; + + return sockaddr.sa.sa_family == family; + } + + return 1; +} + +int sd_is_socket_inet(int fd, int family, int type, int listening, uint16_t port) { + union sockaddr_union sockaddr; + socklen_t l; + int r; + + if (family != 0 && family != AF_INET && family != AF_INET6) + return -EINVAL; + + if ((r = sd_is_socket_internal(fd, type, listening)) <= 0) + return r; + + memset(&sockaddr, 0, sizeof(sockaddr)); + l = sizeof(sockaddr); + + if (getsockname(fd, &sockaddr.sa, &l) < 0) + return -errno; + + if (l < sizeof(sa_family_t)) + return -EINVAL; + + if (sockaddr.sa.sa_family != AF_INET && + sockaddr.sa.sa_family != AF_INET6) + return 0; + + if (family > 0) + if (sockaddr.sa.sa_family != family) + return 0; + + if (port > 0) { + if (sockaddr.sa.sa_family == AF_INET) { + if (l < sizeof(struct sockaddr_in)) + return -EINVAL; + + return htons(port) == sockaddr.in4.sin_port; + } else { + if (l < sizeof(struct sockaddr_in6)) + return -EINVAL; + + return htons(port) == sockaddr.in6.sin6_port; + } + } + + return 1; +} + +int sd_is_socket_unix(int fd, int type, int listening, const char *path, size_t length) { + union sockaddr_union sockaddr; + socklen_t l; + int r; + + if ((r = sd_is_socket_internal(fd, type, listening)) <= 0) + return r; + + memset(&sockaddr, 0, sizeof(sockaddr)); + l = sizeof(sockaddr); + + if (getsockname(fd, &sockaddr.sa, &l) < 0) + return -errno; + + if (l < sizeof(sa_family_t)) + return -EINVAL; + + if (sockaddr.sa.sa_family != AF_UNIX) + return 0; + + if (path) { + if (length <= 0) + length = strlen(path); + + if (length <= 0) + /* Unnamed socket */ + return l == offsetof(struct sockaddr_un, sun_path); + + if (path[0]) + /* Normal path socket */ + return + (l >= offsetof(struct sockaddr_un, sun_path) + length + 1) && + memcmp(path, sockaddr.un.sun_path, length+1) == 0; + else + /* Abstract namespace socket */ + return + (l == offsetof(struct sockaddr_un, sun_path) + length) && + memcmp(path, sockaddr.un.sun_path, length) == 0; + } + + return 1; +} + +int sd_notify(int unset_environment, const char *state) { +#if defined(DISABLE_SYSTEMD) || !defined(__linux__) || !defined(SOCK_CLOEXEC) + return 0; +#else + int fd = -1, r; + struct msghdr msghdr; + struct iovec iovec; + union sockaddr_union sockaddr; + const char *e; + + if (!state) { + r = -EINVAL; + goto finish; + } + + if (!(e = getenv("NOTIFY_SOCKET"))) + return 0; + + /* Must be an abstract socket, or an absolute path */ + if ((e[0] != '@' && e[0] != '/') || e[1] == 0) { + r = -EINVAL; + goto finish; + } + + if ((fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0)) < 0) { + r = -errno; + goto finish; + } + + memset(&sockaddr, 0, sizeof(sockaddr)); + sockaddr.sa.sa_family = AF_UNIX; + strncpy(sockaddr.un.sun_path, e, sizeof(sockaddr.un.sun_path)); + + if (sockaddr.un.sun_path[0] == '@') + sockaddr.un.sun_path[0] = 0; + + memset(&iovec, 0, sizeof(iovec)); + iovec.iov_base = (char*) state; + iovec.iov_len = strlen(state); + + memset(&msghdr, 0, sizeof(msghdr)); + msghdr.msg_name = &sockaddr; + msghdr.msg_namelen = offsetof(struct sockaddr_un, sun_path) + strlen(e); + + if (msghdr.msg_namelen > sizeof(struct sockaddr_un)) + msghdr.msg_namelen = sizeof(struct sockaddr_un); + + msghdr.msg_iov = &iovec; + msghdr.msg_iovlen = 1; + + if (sendmsg(fd, &msghdr, MSG_NOSIGNAL) < 0) { + r = -errno; + goto finish; + } + + r = 1; + +finish: + if (unset_environment) + unsetenv("NOTIFY_SOCKET"); + + if (fd >= 0) + close(fd); + + return r; +#endif +} + +int sd_notifyf(int unset_environment, const char *format, ...) { +#if defined(DISABLE_SYSTEMD) || !defined(__linux__) + return 0; +#else + va_list ap; + char *p = NULL; + int r; + + va_start(ap, format); + r = vasprintf(&p, format, ap); + va_end(ap); + + if (r < 0 || !p) + return -ENOMEM; + + r = sd_notify(unset_environment, p); + free(p); + + return r; +#endif +} + +int sd_booted(void) { +#if defined(DISABLE_SYSTEMD) || !defined(__linux__) + return 0; +#else + + struct stat a, b; + + /* We simply test whether the systemd cgroup hierarchy is + * mounted */ + + if (lstat("/sys/fs/cgroup", &a) < 0) + return 0; + + if (lstat("/sys/fs/cgroup/systemd", &b) < 0) + return 0; + + return a.st_dev != b.st_dev; +#endif +} diff --git a/bacula/src/lib/sd-daemon.h b/bacula/src/lib/sd-daemon.h new file mode 100644 index 0000000..4b853a1 --- /dev/null +++ b/bacula/src/lib/sd-daemon.h @@ -0,0 +1,265 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +#ifndef foosddaemonhfoo +#define foosddaemonhfoo + +/*** + Copyright 2010 Lennart Poettering + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +***/ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + Reference implementation of a few systemd related interfaces for + writing daemons. These interfaces are trivial to implement. To + simplify porting we provide this reference implementation. + Applications are welcome to reimplement the algorithms described + here if they do not want to include these two source files. + + The following functionality is provided: + + - Support for logging with log levels on stderr + - File descriptor passing for socket-based activation + - Daemon startup and status notification + - Detection of systemd boots + + You may compile this with -DDISABLE_SYSTEMD to disable systemd + support. This makes all those calls NOPs that are directly related to + systemd (i.e. only sd_is_xxx() will stay useful). + + Since this is drop-in code we don't want any of our symbols to be + exported in any case. Hence we declare hidden visibility for all of + them. + + You may find an up-to-date version of these source files online: + + http://cgit.freedesktop.org/systemd/plain/src/sd-daemon.h + http://cgit.freedesktop.org/systemd/plain/src/sd-daemon.c + + This should compile on non-Linux systems, too, but with the + exception of the sd_is_xxx() calls all functions will become NOPs. + + See sd-daemon(7) for more information. +*/ + +#ifndef _sd_printf_attr_ +#if __GNUC__ >= 4 +#define _sd_printf_attr_(a,b) __attribute__ ((format (printf, a, b))) +#else +#define _sd_printf_attr_(a,b) +#endif +#endif + +#ifndef _sd_hidden_ +#if (__GNUC__ >= 4) && !defined(SD_EXPORT_SYMBOLS) +#define _sd_hidden_ __attribute__ ((visibility("hidden"))) +#else +#define _sd_hidden_ +#endif +#endif + +/* + Log levels for usage on stderr: + + fprintf(stderr, SD_NOTICE "Hello World!\n"); + + This is similar to printk() usage in the kernel. +*/ +#define SD_EMERG "<0>" /* system is unusable */ +#define SD_ALERT "<1>" /* action must be taken immediately */ +#define SD_CRIT "<2>" /* critical conditions */ +#define SD_ERR "<3>" /* error conditions */ +#define SD_WARNING "<4>" /* warning conditions */ +#define SD_NOTICE "<5>" /* normal but significant condition */ +#define SD_INFO "<6>" /* informational */ +#define SD_DEBUG "<7>" /* debug-level messages */ + +/* The first passed file descriptor is fd 3 */ +#define SD_LISTEN_FDS_START 3 + +/* + Returns how many file descriptors have been passed, or a negative + errno code on failure. Optionally, removes the $LISTEN_FDS and + $LISTEN_PID file descriptors from the environment (recommended, but + problematic in threaded environments). If r is the return value of + this function you'll find the file descriptors passed as fds + SD_LISTEN_FDS_START to SD_LISTEN_FDS_START+r-1. Returns a negative + errno style error code on failure. This function call ensures that + the FD_CLOEXEC flag is set for the passed file descriptors, to make + sure they are not passed on to child processes. If FD_CLOEXEC shall + not be set, the caller needs to unset it after this call for all file + descriptors that are used. + + See sd_listen_fds(3) for more information. +*/ +int sd_listen_fds(int unset_environment) _sd_hidden_; + +/* + Helper call for identifying a passed file descriptor. Returns 1 if + the file descriptor is a FIFO in the file system stored under the + specified path, 0 otherwise. If path is NULL a path name check will + not be done and the call only verifies if the file descriptor + refers to a FIFO. Returns a negative errno style error code on + failure. + + See sd_is_fifo(3) for more information. +*/ +int sd_is_fifo(int fd, const char *path) _sd_hidden_; + +/* + Helper call for identifying a passed file descriptor. Returns 1 if + the file descriptor is a socket of the specified family (AF_INET, + ...) and type (SOCK_DGRAM, SOCK_STREAM, ...), 0 otherwise. If + family is 0 a socket family check will not be done. If type is 0 a + socket type check will not be done and the call only verifies if + the file descriptor refers to a socket. If listening is > 0 it is + verified that the socket is in listening mode. (i.e. listen() has + been called) If listening is == 0 it is verified that the socket is + not in listening mode. If listening is < 0 no listening mode check + is done. Returns a negative errno style error code on failure. + + See sd_is_socket(3) for more information. +*/ +int sd_is_socket(int fd, int family, int type, int listening) _sd_hidden_; + +/* + Helper call for identifying a passed file descriptor. Returns 1 if + the file descriptor is an Internet socket, of the specified family + (either AF_INET or AF_INET6) and the specified type (SOCK_DGRAM, + SOCK_STREAM, ...), 0 otherwise. If version is 0 a protocol version + check is not done. If type is 0 a socket type check will not be + done. If port is 0 a socket port check will not be done. The + listening flag is used the same way as in sd_is_socket(). Returns a + negative errno style error code on failure. + + See sd_is_socket_inet(3) for more information. +*/ +int sd_is_socket_inet(int fd, int family, int type, int listening, uint16_t port) _sd_hidden_; + +/* + Helper call for identifying a passed file descriptor. Returns 1 if + the file descriptor is an AF_UNIX socket of the specified type + (SOCK_DGRAM, SOCK_STREAM, ...) and path, 0 otherwise. If type is 0 + a socket type check will not be done. If path is NULL a socket path + check will not be done. For normal AF_UNIX sockets set length to + 0. For abstract namespace sockets set length to the length of the + socket name (including the initial 0 byte), and pass the full + socket path in path (including the initial 0 byte). The listening + flag is used the same way as in sd_is_socket(). Returns a negative + errno style error code on failure. + + See sd_is_socket_unix(3) for more information. +*/ +int sd_is_socket_unix(int fd, int type, int listening, const char *path, size_t length) _sd_hidden_; + +/* + Informs systemd about changed daemon state. This takes a number of + newline separated environment-style variable assignments in a + string. The following variables are known: + + READY=1 Tells systemd that daemon startup is finished (only + relevant for services of Type=notify). The passed + argument is a boolean "1" or "0". Since there is + little value in signaling non-readiness the only + value daemons should send is "READY=1". + + STATUS=... Passes a single-line status string back to systemd + that describes the daemon state. This is free-from + and can be used for various purposes: general state + feedback, fsck-like programs could pass completion + percentages and failing programs could pass a human + readable error message. Example: "STATUS=Completed + 66% of file system check..." + + ERRNO=... If a daemon fails, the errno-style error code, + formatted as string. Example: "ERRNO=2" for ENOENT. + + BUSERROR=... If a daemon fails, the D-Bus error-style error + code. Example: "BUSERROR=org.freedesktop.DBus.Error.TimedOut" + + MAINPID=... The main pid of a daemon, in case systemd did not + fork off the process itself. Example: "MAINPID=4711" + + Daemons can choose to send additional variables. However, it is + recommended to prefix variable names not listed above with X_. + + Returns a negative errno-style error code on failure. Returns > 0 + if systemd could be notified, 0 if it couldn't possibly because + systemd is not running. + + Example: When a daemon finished starting up, it could issue this + call to notify systemd about it: + + sd_notify(0, "READY=1"); + + See sd_notifyf() for more complete examples. + + See sd_notify(3) for more information. +*/ +int sd_notify(int unset_environment, const char *state) _sd_hidden_; + +/* + Similar to sd_notify() but takes a format string. + + Example 1: A daemon could send the following after initialization: + + sd_notifyf(0, "READY=1\n" + "STATUS=Processing requests...\n" + "MAINPID=%lu", + (unsigned long) getpid()); + + Example 2: A daemon could send the following shortly before + exiting, on failure: + + sd_notifyf(0, "STATUS=Failed to start up: %s\n" + "ERRNO=%i", + strerror(errno), + errno); + + See sd_notifyf(3) for more information. +*/ +int sd_notifyf(int unset_environment, const char *format, ...) _sd_printf_attr_(2,3) _sd_hidden_; + +/* + Returns > 0 if the system was booted with systemd. Returns < 0 on + error. Returns 0 if the system was not booted with systemd. Note + that all of the functions above handle non-systemd boots just + fine. You should NOT protect them with a call to this function. Also + note that this function checks whether the system, not the user + session is controlled by systemd. However the functions above work + for both user and system services. + + See sd_booted(3) for more information. +*/ +int sd_booted(void) _sd_hidden_; + +#ifdef __cplusplus +} +#endif + +#endif -- 1.7.4.1