From f211c63925ea6d03cc1036b5e11061ec82d92ef8 Mon Sep 17 00:00:00 2001 From: Christian Muck Date: Wed, 30 May 2012 15:50:56 +0200 Subject: [GDLT-90] Implemented systemd watchdog concept Signed-off-by: Christian Muck --- CMakeLists.txt | 58 +++-- cmake/CMakeLists.txt | 4 + cmake/config.h.cmake | 2 + src/daemon/CMakeLists.txt | 7 +- src/daemon/dlt-daemon.c | 135 +++++++++- src/daemon/dlt-daemon.h | 3 + systemd/3rdparty/sd-daemon.c | 530 +++++++++++++++++++++++++++++++++++++++ systemd/3rdparty/sd-daemon.h | 282 +++++++++++++++++++++ systemd/CMakeLists.txt | 30 ++- systemd/dlt-syslog.service.cmake | 19 +- systemd/dlt.service.cmake | 27 +- 11 files changed, 1047 insertions(+), 50 deletions(-) create mode 100644 systemd/3rdparty/sd-daemon.c create mode 100644 systemd/3rdparty/sd-daemon.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 7bebbaa..eba6689 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -50,14 +50,15 @@ endif(NOT CMAKE_BUILD_TYPE) # Set of indiviual options option(BUILD_SHARED_LIBS "Set to OFF to build static libraries" ON ) -option(WITH_DLT_SHM_ENABLE "Set to OFF to use FIFO as IPC from user to daemon" OFF ) +option(WITH_DLT_SHM_ENABLE "Set to ON to use shared memory as IPC - experimental" OFF ) option(WITH_DOC "Set to ON to build documentation target" OFF ) -option(WITH_MAN "Set to OFF to skip building of man pages" ON ) +option(WITH_MAN "Set to ON to build man pages" OFF ) option(WITH_CHECK_CONFIG_FILE "Set to ON to create a configure file of CheckIncludeFiles and CheckFunctionExists " OFF ) option(WITH_TESTSCRIPTS "Set to ON to run CMakeLists.txt in testscripts" OFF ) -option(WITH_SYSTEMD "Set to ON to run CMakeLists.txt in systemd" OFF ) +option(WITH_SYSTEMD "Set to ON to create unit files and systemd check on dlt-daemon startup" OFF ) +option(WITH_SYSTEMD_WATCHDOG "Set to ON to use the systemd watchdog in dlt-daemon" ON) option(WITH_GPROF "Set -pg to compile flags" OFF ) -option(WITH_DLTTEST "Set to ON to build with modifications to test Uuser-Daemon communication with corrupt messages" OFF) +option(WITH_DLTTEST "Set to ON to build with modifications to test User-Daemon communication with corrupt messages" OFF) # RPM settings set( GENIVI_RPM_RELEASE "1")#${DLT_REVISION}") @@ -72,8 +73,11 @@ include_directories( ${CMAKE_SOURCE_DIR}/src/shared/ ${CMAKE_SOURCE_DIR}/src/lib/ ${CMAKE_SOURCE_DIR}/src/daemon/ + ${CMAKE_SOURCE_DIR}/systemd/3rdparty/ ) +add_definitions( -D_GNU_SOURCE ) + if(WITH_DLTTEST) add_definitions( -DDLT_TEST_ENABLE) endif(WITH_DLTTEST) @@ -81,27 +85,49 @@ endif(WITH_DLTTEST) if(WITH_DLT_SHM_ENABLE) add_definitions( -DDLT_SHM_ENABLE) endif(WITH_DLT_SHM_ENABLE) - -add_definitions( -D_GNU_SOURCE ) - + if(WITH_GPROF) SET(CMAKE_C_FLAGS "-pg") -endif(WITH_GPROF) +endif(WITH_GPROF) add_definitions( "-Wall" ) +configure_file(${CMAKE_SOURCE_DIR}/${PROJECT_NAME}.spec.in ${PROJECT_BINARY_DIR}/${PROJECT_NAME}.spec) +configure_file(${CMAKE_SOURCE_DIR}/${PROJECT_NAME}.pc.in ${PROJECT_BINARY_DIR}/${PROJECT_NAME}.pc @ONLY) +install(FILES ${PROJECT_BINARY_DIR}/${PROJECT_NAME}.pc DESTINATION lib/pkgconfig COMPONENT devel) + add_subdirectory( cmake ) +if(WITH_SYSTEMD OR WITH_SYSTEMD_WATCHDOG) + if(WITH_SYSTEMD) + add_definitions( -DDLT_SYSTEMD_ENABLE) + endif(WITH_SYSTEMD) + + if(WITH_SYSTEMD_WATCHDOG) + add_definitions( -DDLT_SYSTEMD_WATCHDOG_ENABLE) + endif(WITH_SYSTEMD_WATCHDOG) + + set( systemd_SRCS ${CMAKE_SOURCE_DIR}/systemd/3rdparty/sd-daemon.c) + + add_subdirectory( systemd ) +endif(WITH_SYSTEMD OR WITH_SYSTEMD_WATCHDOG) + +add_subdirectory( doc ) +add_subdirectory( src ) +add_subdirectory( include ) +add_subdirectory( testscripts ) + message( STATUS ) message( STATUS "-------------------------------------------------------------------------------" ) message( STATUS "Build for Version ${DLT_VERSION} build ${DLT_REVISION} version state ${DLT_VERSION_STATE}") +message( STATUS "WITH_SYSTEMD = ${WITH_SYSTEMD}" ) +message( STATUS "WITH_SYSTEMD_WATCHDOG = ${WITH_SYSTEMD_WATCHDOG}" ) +message( STATUS "WITH_DOC = ${WITH_DOC}" ) +message( STATUS "WITH_MAN = ${WITH_MAN}" ) message( STATUS "WITH_DLT_SHM_ENABLE = ${WITH_DLT_SHM_ENABLE}" ) message( STATUS "WITH_CHECK_CONFIG_FILE = ${WITH_CHECK_CONFIG_FILE}" ) -message( STATUS "WITH_DOC = ${WITH_DOC}" ) message( STATUS "WITH_TESTSCRIPTS = ${WITH_TESTSCRIPTS}" ) -message( STATUS "WITH_SYSTEMD = ${WITH_SYSTEMD}" ) message( STATUS "WITH_GPROF = ${WITH_GPROF}" ) -message( STATUS "WITH_MAN = ${WITH_MAN}" ) message( STATUS "WITH_DLTTEST = ${WITH_DLTTEST}" ) message( STATUS "BUILD_SHARED_LIBS = ${BUILD_SHARED_LIBS}" ) message( STATUS "CMAKE_INSTALL_PREFIX = ${CMAKE_INSTALL_PREFIX}" ) @@ -109,13 +135,3 @@ message( STATUS "CMAKE_BUILD_TYPE = ${CMAKE_BUILD_TYPE}" ) message( STATUS "Change a value with: cmake -D=" ) message( STATUS "-------------------------------------------------------------------------------" ) message( STATUS ) - -configure_file(${CMAKE_SOURCE_DIR}/${PROJECT_NAME}.spec.in ${PROJECT_BINARY_DIR}/${PROJECT_NAME}.spec) -configure_file(${CMAKE_SOURCE_DIR}/${PROJECT_NAME}.pc.in ${PROJECT_BINARY_DIR}/${PROJECT_NAME}.pc @ONLY) -install(FILES ${PROJECT_BINARY_DIR}/${PROJECT_NAME}.pc DESTINATION lib/pkgconfig COMPONENT devel) - -add_subdirectory( doc ) -add_subdirectory( src ) -add_subdirectory( include ) -add_subdirectory( testscripts ) -add_subdirectory( systemd ) diff --git a/cmake/CMakeLists.txt b/cmake/CMakeLists.txt index 78f6d65..0dad9f5 100644 --- a/cmake/CMakeLists.txt +++ b/cmake/CMakeLists.txt @@ -23,6 +23,10 @@ CHECK_INCLUDE_FILES( strings.h HAVE_STRINGS_H) CHECK_INCLUDE_FILES( sys/ioctl.h HAVE_SYSIOCTL_H) CHECK_INCLUDE_FILES( sys/socket.h HAVE_SYSSOCKET_H) CHECK_INCLUDE_FILES( sys/time.h HAVE_SYSTIME_H) +if( WITH_SYSTEMD_WATCHDOG OR WITH_SYSTEMD ) + set(CMAKE_REQUIRED_INCLUDES "${CMAKE_SOURCE_DIR}/systemd/3rdparty/") + CHECK_INCLUDE_FILES( sd-daemon.h HAVE_SYSTEMD_H) +endif ( WITH_SYSTEMD_WATCHDOG OR WITH_SYSTEMD ) CHECK_INCLUDE_FILES( unistd.h HAVE_UNISTD_H) CHECK_INCLUDE_FILES( sys/ipc.h HAVE_SYSIPC_H) CHECK_INCLUDE_FILES( netdb.h HAVE_NETDB_H) diff --git a/cmake/config.h.cmake b/cmake/config.h.cmake index 31f1144..f9e701b 100755 --- a/cmake/config.h.cmake +++ b/cmake/config.h.cmake @@ -2,6 +2,7 @@ // cmakedefine01 sets #define [0|1] if variable is defined in cmake // variable is set by CHECK_INCLUDE_FILES and CHECK_FUNCTION_EXISTS +#cmakedefine01 HAVE_SYSTEMD_H #cmakedefine01 HAVE_ARPAINET_H #cmakedefine01 HAVE_FCNTL_H #cmakedefine01 HAVE_FLOAT_H @@ -16,6 +17,7 @@ #cmakedefine01 HAVE_SYSIOCTL_H #cmakedefine01 HAVE_SYSSOCKET_H #cmakedefine01 HAVE_SYSTIME_H +#cmakedefine01 HAVE_SYSTEMD_H #cmakedefine01 HAVE_UNISTD_H #cmakedefine01 HAVE_SYSIPC_H #cmakedefine01 HAVE_NETDB_H diff --git a/src/daemon/CMakeLists.txt b/src/daemon/CMakeLists.txt index b868a0f..08c5767 100755 --- a/src/daemon/CMakeLists.txt +++ b/src/daemon/CMakeLists.txt @@ -14,8 +14,13 @@ # @licence end@ ######## + +if(WITH_SYSTEMD_WATCHDOG OR WITH_SYSTEMD) + message( STATUS "Added ${systemd_SRCS} to dlt-daemon") +endif(WITH_SYSTEMD_WATCHDOG OR WITH_SYSTEMD) + set(dlt_daemon_SRCS dlt-daemon dlt_daemon_common ${CMAKE_SOURCE_DIR}/src/shared/dlt_user_shared.c ${CMAKE_SOURCE_DIR}/src/shared/dlt_common.c ${CMAKE_SOURCE_DIR}/src/shared/dlt_shm.c ${CMAKE_SOURCE_DIR}/src/shared/dlt_offline_trace.c) -add_executable(dlt-daemon ${dlt_daemon_SRCS}) +add_executable(dlt-daemon ${dlt_daemon_SRCS} ${systemd_SRCS}) target_link_libraries(dlt-daemon rt ${CMAKE_THREAD_LIBS_INIT}) install(TARGETS dlt-daemon diff --git a/src/daemon/dlt-daemon.c b/src/daemon/dlt-daemon.c index 6aa4a07..5a44f60 100644 --- a/src/daemon/dlt-daemon.c +++ b/src/daemon/dlt-daemon.c @@ -86,15 +86,14 @@ #include "dlt-daemon.h" #include "dlt-daemon_cfg.h" -/** \page Contents - * The package automotive-dlt includes the following items: - * - dlt daemon (dlt-daemon) - * - adptors to to interface the daemon (dlt-adaptor-stdin, dlt-adaptor-udp) - * - dlt client gui (dlt-viewer) - * - dlt console tools (dlt-receive, dlt-convert) - * - examples (dlt-example-user, dlt-example-user-func, dlt-example-ringbuffer) - * - a library including user-application, client and common functions - */ +#if defined(DLT_SYSTEMD_ENABLE) + #if defined(DLT_SYSTEMD_WATCHDOG_ENABLE) + #include + #include + #endif + +#include "sd-daemon.h" +#endif /** \defgroup daemon DLT Daemon @@ -110,6 +109,11 @@ static DltDaemonTimingPacketThreadData dlt_daemon_timingpacket_thread_data; static pthread_t dlt_daemon_timingpacket_thread_handle; static pthread_attr_t dlt_daemon_timingpacket_thread_attr; +#if defined(DLT_SYSTEMD_WATCHDOG_ENABLE) +static DltDaemonTimingPacketThreadData dlt_daemon_systemd_watchdog_thread_data; +static pthread_t dlt_daemon_systemd_watchdog_thread_handle; +#endif + /** * Print usage information of tool. */ @@ -505,6 +509,11 @@ int main(int argc, char* argv[]) int dlt_daemon_local_init_p1(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose) { +#if defined(DLT_SYSTEMD_WATCHDOG_ENABLE) || defined(DLT_SYSTEMD_ENABLE) + int ret; +#endif + + PRINT_FUNCTION_VERBOSE(verbose); if ((daemon==0) || (daemon_local==0)) @@ -513,6 +522,26 @@ int dlt_daemon_local_init_p1(DltDaemon *daemon, DltDaemonLocal *daemon_local, in return -1; } +#if defined(DLT_SYSTEMD_WATCHDOG_ENABLE) || defined(DLT_SYSTEMD_ENABLE) + ret = sd_booted(); + + if(ret == 0){ + dlt_log(LOG_CRIT, "system not booted with systemd!\n"); + return -1; + } + else if(ret < 0) + { + dlt_log(LOG_CRIT, "sd_booted failed!\n"); + return -1; + } + else + { + dlt_log(LOG_INFO, "system booted with systemd\n"); + } +#endif + + + /* Check for daemon mode */ if (daemon_local->flags.dflag) { @@ -655,6 +684,24 @@ int dlt_daemon_local_init_p2(DltDaemon *daemon, DltDaemonLocal *daemon_local, in pthread_attr_destroy(&dlt_daemon_timingpacket_thread_attr); + + +#if defined(DLT_SYSTEMD_WATCHDOG_ENABLE) + + dlt_daemon_systemd_watchdog_thread_data.daemon = daemon; + dlt_daemon_systemd_watchdog_thread_data.daemon_local = daemon_local; + + if (pthread_create(&(dlt_daemon_systemd_watchdog_thread_handle), + NULL, + (void *) &dlt_daemon_systemd_watchdog_thread, + (void *) &dlt_daemon_systemd_watchdog_thread_data)!=0) + { + dlt_log(LOG_ERR,"Could not initialize systemd watchdog thread\n"); + return -1; + } +#endif + + return 0; } @@ -2303,6 +2350,76 @@ void dlt_daemon_timingpacket_thread(void *ptr) dlt_daemon_wait_period (&info, daemon_local->flags.vflag); } } +#if defined(DLT_SYSTEMD_WATCHDOG_ENABLE) +void dlt_daemon_systemd_watchdog_thread(void *ptr) +{ + char *watchdogUSec; + int watchdogTimeoutSeconds; + int notifiyPeriodNSec; + DltDaemonPeriodicData info; + DltDaemonTimingPacketThreadData *data; + DltDaemon *daemon; + DltDaemonLocal *daemon_local; + + if (ptr==0) + { + dlt_log(LOG_ERR, "No data pointer passed to systemd watchdog thread\n"); + return; + } + + data = (DltDaemonTimingPacketThreadData*)ptr; + daemon = data->daemon; + daemon_local = data->daemon_local; + + if ((daemon==0) || (daemon_local==0)) + { + dlt_log(LOG_ERR, "Invalid function parameters used for function dlt_daemon_timingpacket_thread()"); + return; + } + + watchdogUSec = getenv("WATCHDOG_USEC"); + + if(watchdogUSec) + { + watchdogTimeoutSeconds = atoi(watchdogUSec); + + if( watchdogTimeoutSeconds > 0 ){ + + // Calculate half of WATCHDOG_USEC in ns for timer tick + notifiyPeriodNSec = watchdogTimeoutSeconds / 2 ; + + sprintf(str,"systemd watchdog timeout: %i nsec - timer will be initialized: %i nsec\n", watchdogTimeoutSeconds, notifiyPeriodNSec ); + dlt_log(LOG_INFO, str); + + if (dlt_daemon_make_periodic (notifiyPeriodNSec, &info, daemon_local->flags.vflag)<0) + { + dlt_log(LOG_CRIT, "Could not initialize systemd watchdog timer"); + return; + } + + while (1) + { + if(sd_notify(0, "WATCHDOG=1") < 0) + { + dlt_log(LOG_CRIT, "Could not reset systemd watchdog\n"); + } + //dlt_log(LOG_INFO, "systemd watchdog waited periodic\n"); + /* Wait for next period */ + dlt_daemon_wait_period (&info, daemon_local->flags.vflag); + } + } + else + { + sprintf(str,"systemd watchdog timeout incorrect: %i\n", watchdogTimeoutSeconds); + dlt_log(LOG_CRIT, str); + } + } + else + { + dlt_log(LOG_CRIT, "systemd watchdog timeout (WATCHDOG_USEC) is null!\n"); + } +} +#endif int dlt_daemon_make_periodic (unsigned int period, DltDaemonPeriodicData *info, int verbose) { diff --git a/src/daemon/dlt-daemon.h b/src/daemon/dlt-daemon.h index 36ad2ba..40159f4 100755 --- a/src/daemon/dlt-daemon.h +++ b/src/daemon/dlt-daemon.h @@ -166,6 +166,9 @@ int dlt_daemon_process_user_message_log_mode(DltDaemon *daemon, DltDaemonLocal * int dlt_daemon_send_ringbuffer_to_client(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose); void dlt_daemon_timingpacket_thread(void *ptr); +#if defined(DLT_SYSTEMD_WATCHDOG_ENABLE) + void dlt_daemon_systemd_watchdog_thread(void *ptr); +#endif int dlt_daemon_make_periodic (unsigned int period, DltDaemonPeriodicData *info, int verbose); void dlt_daemon_wait_period(DltDaemonPeriodicData *info, int verbose); diff --git a/systemd/3rdparty/sd-daemon.c b/systemd/3rdparty/sd-daemon.c new file mode 100644 index 0000000..763e079 --- /dev/null +++ b/systemd/3rdparty/sd-daemon.c @@ -0,0 +1,530 @@ +/*-*- 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 +#ifdef __BIONIC__ +#include +#else +#include +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(__linux__) +#include +#endif + +#include "sd-daemon.h" + +#if (__GNUC__ >= 4) +#ifdef SD_EXPORT_SYMBOLS +/* Export symbols */ +#define _sd_export_ __attribute__ ((visibility("default"))) +#else +/* Don't export the symbols */ +#define _sd_export_ __attribute__ ((visibility("hidden"))) +#endif +#else +#define _sd_export_ +#endif + +_sd_export_ 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 +} + +_sd_export_ 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; +} + +_sd_export_ int sd_is_special(int fd, const char *path) { + struct stat st_fd; + + if (fd < 0) + return -EINVAL; + + if (fstat(fd, &st_fd) < 0) + return -errno; + + if (!S_ISREG(st_fd.st_mode) && !S_ISCHR(st_fd.st_mode)) + return 0; + + if (path) { + struct stat st_path; + + if (stat(path, &st_path) < 0) { + + if (errno == ENOENT || errno == ENOTDIR) + return 0; + + return -errno; + } + + if (S_ISREG(st_fd.st_mode) && S_ISREG(st_path.st_mode)) + return + st_path.st_dev == st_fd.st_dev && + st_path.st_ino == st_fd.st_ino; + else if (S_ISCHR(st_fd.st_mode) && S_ISCHR(st_path.st_mode)) + return st_path.st_rdev == st_fd.st_rdev; + else + return 0; + } + + 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; +}; + +_sd_export_ 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; +} + +_sd_export_ 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; +} + +_sd_export_ 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; +} + +_sd_export_ int sd_is_mq(int fd, const char *path) { +#if !defined(__linux__) + return 0; +#else + struct mq_attr attr; + + if (fd < 0) + return -EINVAL; + + if (mq_getattr(fd, &attr) < 0) + return -errno; + + if (path) { + char fpath[PATH_MAX]; + struct stat a, b; + + if (path[0] != '/') + return -EINVAL; + + if (fstat(fd, &a) < 0) + return -errno; + + strncpy(stpcpy(fpath, "/dev/mqueue"), path, sizeof(fpath) - 12); + fpath[sizeof(fpath)-1] = 0; + + if (stat(fpath, &b) < 0) + return -errno; + + if (a.st_dev != b.st_dev || + a.st_ino != b.st_ino) + return 0; + } + + return 1; +#endif +} + +_sd_export_ 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 +} + +_sd_export_ 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 +} + +_sd_export_ 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/systemd/3rdparty/sd-daemon.h b/systemd/3rdparty/sd-daemon.h new file mode 100644 index 0000000..fe51159 --- /dev/null +++ b/systemd/3rdparty/sd-daemon.h @@ -0,0 +1,282 @@ +/*-*- 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/systemd/plain/src/systemd/sd-daemon.h + http://cgit.freedesktop.org/systemd/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 + +/* + 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); + +/* + 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); + +/* + Helper call for identifying a passed file descriptor. Returns 1 if + the file descriptor is a special character device on 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 special character. + Returns a negative errno style error code on failure. + + See sd_is_special(3) for more information. +*/ +int sd_is_special(int fd, const char *path); + +/* + 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); + +/* + 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); + +/* + 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); + +/* + Helper call for identifying a passed file descriptor. Returns 1 if + the file descriptor is a POSIX Message Queue of the specified name, + 0 otherwise. If path is NULL a message queue name check is not + done. Returns a negative errno style error code on failure. +*/ +int sd_is_mq(int fd, const char *path); + +/* + 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" + + WATCHDOG=1 Tells systemd to update the watchdog timestamp. + Services using this feature should do this in + regular intervals. A watchdog framework can use the + timestamps to detect failed services. + + 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); + +/* + 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); + +/* + 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); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/systemd/CMakeLists.txt b/systemd/CMakeLists.txt index e51250d..7411364 100644 --- a/systemd/CMakeLists.txt +++ b/systemd/CMakeLists.txt @@ -15,10 +15,26 @@ ######## if(WITH_SYSTEMD) - SET( DLT_SYSLOG_APPID "SYS" ) - SET( DLT_SYSLOG_CTID "LOG" ) - SET( DLT_SYSLOG_PORT 4712 ) - - CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/systemd/dlt.service.cmake ${PROJECT_BINARY_DIR}/systemd/dlt.service @ONLY) - CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/systemd/dlt-syslog.service.cmake ${PROJECT_BINARY_DIR}/systemd/dlt-syslog.service @ONLY) -endif(WITH_SYSTEMD) + set(SYSTEMD_CONFIGURATIONS_FILES_DIR "/lib/systemd/system" ) + + if(WITH_SYSTEMD_WATCHDOG) + set( DLT_WatchdogSec 2 ) + message( STATUS "The systemd watchdog is enabled for DLT daemon - timeout is set to ${DLT_WatchdogSec} seconds") + else(WITH_SYSTEMD_WATCHDOG) + set( DLT_WatchdogSec 0 ) + message( STATUS "The systemd watchdog is disabled for DLT daemon") + endif(WITH_SYSTEMD_WATCHDOG) + + configure_file(${CMAKE_SOURCE_DIR}/systemd/dlt.service.cmake ${PROJECT_BINARY_DIR}/systemd/dlt.service) + install(FILES ${PROJECT_BINARY_DIR}/systemd/dlt.service DESTINATION ${SYSTEMD_CONFIGURATIONS_FILES_DIR} ) + message( STATUS "Configured systemd unit file:dlt.service" ) + + set( DLT_SYSLOG_APPID "SYS" ) + set( DLT_SYSLOG_CTID "LOG" ) + set( DLT_SYSLOG_PORT 4712 ) + message(STATUS "DLT-syslog configuration: APPID:${DLT_SYSLOG_APPID} CTID:${DLT_SYSLOG_CTID} PORT:${DLT_SYSLOG_PORT}" ) + configure_file(${CMAKE_SOURCE_DIR}/systemd/dlt-syslog.service.cmake ${PROJECT_BINARY_DIR}/systemd/dlt-syslog.service) + install(FILES ${PROJECT_BINARY_DIR}/systemd/dlt-syslog.service DESTINATION ${SYSTEMD_CONFIGURATIONS_FILES_DIR} ) + message( STATUS "Configured systemd unit file:dlt-syslog.service" ) + +endif(WITH_SYSTEMD) \ No newline at end of file diff --git a/systemd/dlt-syslog.service.cmake b/systemd/dlt-syslog.service.cmake index aacba97..a962841 100755 --- a/systemd/dlt-syslog.service.cmake +++ b/systemd/dlt-syslog.service.cmake @@ -1,11 +1,18 @@ -# This file is for starting dlt-adaptor-udp +####### +# Dlt - Diagnostic Log and Trace +# @licence make begin@ # -# For more informations about starting options of dlt-daemon use the command "dlt-adaptor-udp -h". +# Copyright (C) 2011-2012, BMW AG - Alexander Wenzel +# +# Contributions are licensed to the GENIVI Alliance under one or more +# Contribution License Agreements. +# +# This Source Code Form is subject to the terms of the +# Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with +# this file, You can obtain one at http://mozilla.org/MPL/2.0/. # -# basic.target A special target unit covering early boot-up. -# Usually this should pull-in all sockets, mount points, swap devices and -# other basic initialization necessary for the general purpose daemons. -# Most normal daemons should have dependencies of type After and Requires on this unit +# @licence end@ +######## [Unit] Description=DLT Syslog Adapter diff --git a/systemd/dlt.service.cmake b/systemd/dlt.service.cmake index baa8532..43cb319 100755 --- a/systemd/dlt.service.cmake +++ b/systemd/dlt.service.cmake @@ -1,16 +1,31 @@ -# This file is for starting the dlt-daemon as a service with systemd at the multi-user.target +####### +# Dlt - Diagnostic Log and Trace +# @licence make begin@ # -# For more informations about starting options of dlt-daemon use the command -# "dlt-daemon -h". +# Copyright (C) 2011-2012, BMW AG - Alexander Wenzel +# +# Contributions are licensed to the GENIVI Alliance under one or more +# Contribution License Agreements. +# +# This Source Code Form is subject to the terms of the +# Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with +# this file, You can obtain one at http://mozilla.org/MPL/2.0/. # -# Multi-user.target is a special target unit for setting up a multi-user system (non-graphical). -# For more details about the multi-user.target see systemd.special(7). +# @licence end@ +######## [Unit] -Description=DLT Daemon for logging and tracing +Description=GENIVI DLT +Documentation=dlt-daemon(1) dlt.conf(5) [Service] +Type=Simple +User=genivi +#ExecStartPre=rm /tmp/dlt ExecStart=@CMAKE_INSTALL_PREFIX@/bin/dlt-daemon +WatchdogSec=@DLT_WatchdogSec@ +NotifyAccess=main +#RestartSec=2 #Restart=always [Install] -- cgit v1.2.1