No OneTemporary
Actions

Size

73 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/configure.ac b/configure.ac
	index f3d81584..309114c4 100644
	--- a/configure.ac
	+++ b/configure.ac
	@@ -1,797 +1,799 @@
	# -- Autoconf --
	# Process this file with autoconf to produce a configure script.

	# bootstrap / init
	AC_PREREQ([2.61])

	AC_INIT([corosync],
	m4_esyscmd([build-aux/git-version-gen .tarball-version]),
	[users@clusterlabs.org])

	AC_USE_SYSTEM_EXTENSIONS

	AM_INIT_AUTOMAKE([foreign 1.11])

	LT_PREREQ([2.2.6])
	LT_INIT

	AM_SILENT_RULES([yes])

	AC_CONFIG_SRCDIR([lib/cpg.c])
	AC_CONFIG_HEADER([include/corosync/config.h])
	AC_CONFIG_MACRO_DIR([m4])

	AC_CANONICAL_HOST

	AC_LANG([C])

	AC_SUBST(WITH_LIST, [""])

	#Enable inter-library dependencies
	AC_ARG_ENABLE(interlib-deps,
	[AC_HELP_STRING([--disable-interlib-deps ],[disable inter-library dependencies (might break builds)])],
	[enable_interlib_deps="$enableval"],
	[enable_interlib_deps="yes"])

	AC_MSG_NOTICE([enable inter-library dependencies: $enable_interlib_deps])
	if test "${enable_interlib_deps}" == "yes"; then
	link_all_deplibs=yes
	link_all_deplibs_CXX=yes
	else
	link_all_deplibs=no
	link_all_deplibs_CXX=no
	fi

	dnl Fix default variables - "prefix" variable if not specified
	if test "$prefix" = "NONE"; then
	prefix="/usr"

	dnl Fix "localstatedir" variable if not specified
	if test "$localstatedir" = "\${prefix}/var"; then
	localstatedir="/var"
	fi
	dnl Fix "sysconfdir" variable if not specified
	if test "$sysconfdir" = "\${prefix}/etc"; then
	sysconfdir="/etc"
	fi
	dnl Fix "libdir" variable if not specified
	if test "$libdir" = "\${exec_prefix}/lib"; then
	if test -e /usr/lib64; then
	libdir="/usr/lib64"
	else
	libdir="/usr/lib"
	fi
	fi
	fi

	if test "$srcdir" = "."; then
	AC_MSG_NOTICE([building in place srcdir:$srcdir])
	AC_DEFINE([BUILDING_IN_PLACE], 1, [building in place])
	else
	AC_MSG_NOTICE([building out of tree srcdir:$srcdir])
	fi

	# Checks for programs.

	# check stolen from gnulib/m4/gnu-make.m4
	if ! ${MAKE-make} --version /cannot/make/this >/dev/null 2>&1; then
	AC_MSG_ERROR([you don't seem to have GNU make; it is required])
	fi

	sinclude(corosync-default.m4)

	AC_PROG_CC
	AC_PROG_CC_C99
	if test "x$ac_cv_prog_cc_c99" = "xno"; then
	AC_MSG_ERROR(["C99 support is required"])
	fi
	AC_PROG_INSTALL
	AC_PROG_LN_S
	AC_PROG_MAKE_SET
	AC_PROG_SED

	AC_CHECK_PROGS([GROFF], [groff])
	AC_CHECK_PROGS([PKGCONFIG], [pkg-config])
	AC_CHECK_PROGS([AUGTOOL], [augtool])
	AC_CHECK_PROGS([DOT], [dot])
	AC_CHECK_PROGS([DOXYGEN], [doxygen])
	AC_CHECK_PROGS([AWK], [awk])
	AC_CHECK_PROGS([SED], [sed])
	AC_PATH_PROG([BASHPATH], [bash])

	# Checks for compiler characteristics.
	AC_PROG_GCC_TRADITIONAL
	AC_C_CONST
	AC_C_INLINE
	AC_C_VOLATILE

	# Checks for header files.
	AC_HEADER_DIRENT
	AC_HEADER_STDC
	AC_HEADER_SYS_WAIT
	AC_CHECK_HEADERS([arpa/inet.h fcntl.h limits.h netdb.h netinet/in.h stdint.h \
	stdlib.h string.h sys/ioctl.h sys/param.h sys/socket.h \
	sys/time.h syslog.h unistd.h sys/types.h getopt.h malloc.h \
	utmpx.h ifaddrs.h stddef.h sys/file.h sys/uio.h])

	# Check entries in specific structs
	AC_CHECK_MEMBER([struct sockaddr_in.sin_len],
	[AC_DEFINE_UNQUOTED([HAVE_SOCK_SIN_LEN], [1], [sockaddr_in needs sin_len])],
	[], [[#include <netinet/in.h>]])
	AC_CHECK_MEMBER([struct sockaddr_in6.sin6_len],
	[AC_DEFINE_UNQUOTED([HAVE_SOCK_SIN6_LEN], [1], [sockaddr_in6 needs sin6_len])],
	[], [[#include <netinet/in.h>]])
	AC_CHECK_MEMBER([struct msghdr.msg_control],
	[AC_DEFINE_UNQUOTED([HAVE_MSGHDR_CONTROL], [1], [msghdr has msg_control])],
	[], [[#include <sys/socket.h>]])
	AC_CHECK_MEMBER([struct msghdr.msg_controllen],
	[AC_DEFINE_UNQUOTED([HAVE_MSGHDR_CONTROLLEN], [1], [msghdr has msg_controllen])],
	[], [[#include <sys/socket.h>]])
	AC_CHECK_MEMBER([struct msghdr.msg_flags],
	[AC_DEFINE_UNQUOTED([HAVE_MSGHDR_FLAGS], [1], [msghdr has msg_flags])],
	[], [[#include <sys/socket.h>]])
	AC_CHECK_MEMBER([struct msghdr.msg_accrights],
	[AC_DEFINE_UNQUOTED([HAVE_MSGHDR_ACCRIGHTS], [1], [msghdr has msg_accrights])],
	[], [[#include <sys/socket.h>]])
	AC_CHECK_MEMBER([struct msghdr.msg_accrightslen],
	[AC_DEFINE_UNQUOTED([HAVE_MSGHDR_ACCRIGHTSLEN], [1], [msghdr has msg_accrightslen])],
	[], [[#include <sys/socket.h>]])

	# Checks for typedefs.
	AC_TYPE_UID_T
	AC_TYPE_INT16_T
	AC_TYPE_INT32_T
	AC_TYPE_INT64_T
	AC_TYPE_INT8_T
	AC_TYPE_UINT16_T
	AC_TYPE_UINT32_T
	AC_TYPE_UINT64_T
	AC_TYPE_UINT8_T
	AC_TYPE_SIZE_T
	AC_TYPE_SSIZE_T

	# Checks for libraries.
	PKG_CHECK_MODULES([nss],[nss])
	SAVE_CPPFLAGS="$CPPFLAGS"
	SAVE_LIBS="$LIBS"
	PKG_CHECK_MODULES([LIBQB], [libqb])
	CPPFLAGS="$CPPFLAGS $LIBQB_CFLAGS"
	LIBS="$LIBS $LIBQB_LIBS"
	AC_CHECK_LIB([qb], [qb_log_thread_priority_set], \
	have_qb_log_thread_priority_set="yes", \
	have_qb_log_thread_priority_set="no")
	if test "x${have_qb_log_thread_priority_set}" = xyes; then
	AC_DEFINE_UNQUOTED([HAVE_QB_LOG_THREAD_PRIORITY_SET], 1, [have qb_log_thread_priority_set])
	fi
	CPPFLAGS="$SAVE_CPPFLAGS"
	LIBS="$SAVE_LIBS"
	AC_CHECK_LIB([pthread], [pthread_create])
	AC_CHECK_LIB([socket], [socket])
	PKG_CHECK_MODULES([KNET],[libknet])
	AC_CHECK_LIB([nsl], [t_open])
	AC_CHECK_LIB([rt], [sched_getscheduler])
	AC_CHECK_LIB([z], [crc32],
	AM_CONDITIONAL([BUILD_CPGHUM], true),
	AM_CONDITIONAL([BUILD_CPGHUM], false))

	# Checks for library functions.
	AC_FUNC_ALLOCA
	AC_FUNC_CLOSEDIR_VOID
	AC_FUNC_ERROR_AT_LINE
	AC_FUNC_FORK
	AC_FUNC_MALLOC
	AC_FUNC_MEMCMP
	AC_FUNC_MMAP
	AC_FUNC_REALLOC
	AC_FUNC_SELECT_ARGTYPES
	AC_FUNC_VPRINTF

	AC_CHECK_FUNCS([alarm alphasort atexit bzero dup2 endgrent endpwent fdatasync \
	fcntl getcwd getpeerucred getpeereid gettimeofday inet_ntoa \
	memmove memset mkdir scandir select socket strcasecmp strchr \
	strdup strerror strrchr strspn strstr pthread_setschedparam \
	sched_get_priority_max sched_setscheduler getifaddrs \
	clock_gettime ftruncate gethostname localtime_r munmap strtol])

	AC_CONFIG_FILES([Makefile
	exec/Makefile
	include/Makefile
	init/Makefile
	lib/Makefile
	common_lib/Makefile
	man/Makefile
	pkgconfig/Makefile
	test/Makefile
	cts/Makefile
	cts/agents/Makefile
	cts/CTSvars.py
	tools/Makefile
	conf/Makefile
	qdevices/Makefile
	vqsim/Makefile
	Doxyfile
	conf/logrotate/Makefile])

	### Local business

	dnl ===============================================
	dnl Functions / global M4 variables
	dnl ===============================================
	dnl Global list of LIB names
	m4_define([local_soname_list], [])dnl

	dnl Upcase parameter
	m4_define([local_upcase], [translit([$*], [a-z], [A-Z])])dnl

	dnl M4 macro for include lib/lib$1.soname and subst that
	m4_define([LIB_SONAME_IMPORT],[dnl
	m4_define([local_libname], local_upcase($1)[_SONAME])dnl
	m4_define([local_soname], translit(m4_sinclude(lib/lib$1.verso), [
	], []))dnl
	local_libname="local_soname"dnl
	m4_define([local_soname_list], m4_defn([local_soname_list])[,]local_libname[,]local_upcase($1))dnl
	AC_SUBST(local_libname)dnl
	])dnl

	dnl M4 macro for print padspaces (used in LIB_MSG_RESULT). It takes 2 arguments, length of string to pad and desired
	dnl (padded) length
	m4_define([m4_printpadspace],[ifelse(m4_eval([$2 - $1 < 1]),[1],,[ ][m4_printpadspace([$1],m4_eval([$2 - 1]))])])dnl

	dnl Show AC_MSG_RESULT for specific libraries
	m4_define([LIB_MSG_RESULT], [ifelse([$#], [1], ,[dnl
	AC_MSG_RESULT([ $2 Library SONAME m4_printpadspace(len($2),8) = ${$1}])
	LIB_MSG_RESULT(m4_shift(m4_shift($@)))dnl
	])])dnl

	# ===============================================
	# Helpers
	# ===============================================

	## check if the compiler supports -Werror -Wunknown-warning-option
	AC_MSG_CHECKING([whether $CC supports -Wunknown-warning-option -Werror])
	BACKUP="$CPPFLAGS"
	CPPFLAGS="$CPPFLAGS -Werror -Wunknown-warning-option"
	AC_PREPROC_IFELSE([AC_LANG_PROGRAM([])],
	[unknown_warnings_as_errors='-Wunknown-warning-option -Werror'; AC_MSG_RESULT([yes])],
	[unknown_warnings_as_errors=''; AC_MSG_RESULT([no])])
	CPPFLAGS="$BACKUP"

	## helper for CC stuff
	cc_supports_flag() {
	BACKUP="$CPPFLAGS"
	CPPFLAGS="$CPPFLAGS $@ $unknown_warnings_as_errors"
	AC_MSG_CHECKING([whether $CC supports "$@"])
	AC_PREPROC_IFELSE([AC_LANG_PROGRAM([])],
	[RC=0; AC_MSG_RESULT([yes])],
	[RC=1; AC_MSG_RESULT([no])])
	CPPFLAGS="$BACKUP"
	return $RC
	}

	## cleanup
	AC_MSG_NOTICE(Sanitizing prefix: ${prefix})
	case $prefix in
	NONE) prefix=/usr/local;;
	esac

	AC_MSG_NOTICE(Sanitizing exec_prefix: ${exec_prefix})
	case $exec_prefix in
	dnl For consistency with Corosync, map NONE->$prefix
	NONE) exec_prefix=$prefix;;
	prefix) exec_prefix=$prefix;;
	esac

	## local defines
	PACKAGE_FEATURES=""

	LINT_FLAGS="-weak -unrecog +posixlib +ignoresigns -fcnuse \
	-badflag -D__gnuc_va_list=va_list -D__attribute$x$="

	# default libraries SONAME
	SOMAJOR="5"
	SOMINOR="0"
	SOMICRO="0"
	SONAME="${SOMAJOR}.${SOMINOR}.${SOMICRO}"

	# specific libraries SONAME
	LIB_SONAME_IMPORT([cfg])
	LIB_SONAME_IMPORT([cpg])
	LIB_SONAME_IMPORT([quorum])
	LIB_SONAME_IMPORT([sam])
	LIB_SONAME_IMPORT([votequorum])
	LIB_SONAME_IMPORT([cmap])

	# local options
	AC_ARG_ENABLE([ansi],
	[ --enable-ansi : force to build with ANSI standards. ],
	[ default="no" ])

	AC_ARG_ENABLE([fatal-warnings],
	[ --enable-fatal-warnings : enable fatal warnings. ],
	[ default="no" ])

	AC_ARG_ENABLE([debug],
	[ --enable-debug : enable debug build. ],
	[ default="no" ])

	AC_ARG_ENABLE([secure-build],
	[ --enable-secure-build : enable PIE/RELRO build. ],
	[],
	[enable_secure_build="yes"])

	AC_ARG_ENABLE([user-flags],
	[ --enable-user-flags : rely on user environment. ],
	[ default="no" ])

	AC_ARG_ENABLE([coverage],
	[ --enable-coverage : coverage analysis of the codebase. ],
	[ default="no" ])

	AC_ARG_ENABLE([small-memory-footprint],
	[ --enable-small-memory-footprint : Use small message queues and small messages sizes. ],
	[ default="no" ])

	AC_ARG_ENABLE([dbus],
	[ --enable-dbus : dbus events. ],,
	[ enable_dbus="no" ])

	AC_ARG_ENABLE([testagents],
	[ --enable-testagents : Install Test Agents. ],,
	[ default="no" ])

	AC_ARG_ENABLE([monitoring],
	[ --enable-monitoring : resource monitoring ],,
	[ default="no" ])
	AM_CONDITIONAL(BUILD_MONITORING, test x$enable_monitoring = xyes)

	AC_ARG_ENABLE([watchdog],
	[ --enable-watchdog : Watchdog support ],,
	[ default="no" ])
	AM_CONDITIONAL(BUILD_WATCHDOG, test x$enable_watchdog = xyes)

	AC_ARG_ENABLE([augeas],
	[ --enable-augeas : Install the augeas lens for corosync.conf ],,
	[ enable_augeas="no" ])
	AM_CONDITIONAL(INSTALL_AUGEAS, test x$enable_augeas = xyes)

	AC_ARG_ENABLE([systemd],
	[ --enable-systemd : Install systemd service files],,
	[ enable_systemd="no" ])
	AM_CONDITIONAL(INSTALL_SYSTEMD, test x$enable_systemd = xyes)

	AC_ARG_ENABLE([upstart],
	[ --enable-upstart : Install upstart service files],,
	[ enable_upstart="no" ])
	AM_CONDITIONAL(INSTALL_UPSTART, test x$enable_upstart = xyes)

	AC_ARG_WITH([initconfigdir],
	[AS_HELP_STRING([--with-initconfigdir=DIR],
	[configuration directory @<:@SYSCONFDIR/sysconfig@:>@])],
	[INITCONFIGDIR="$withval"],
	[INITCONFIGDIR='${sysconfdir}/sysconfig'])
	AC_SUBST([INITCONFIGDIR])

	AC_ARG_WITH([initddir],
	[ --with-initddir=DIR : path to init script directory. ],
	[ INITDDIR="$withval" ],
	[ INITDDIR="$sysconfdir/init.d" ])

	AC_ARG_WITH([systemddir],
	[ --with-systemddir=DIR : path to systemd unit files directory. ],
	[ SYSTEMDDIR="$withval" ],
	[ SYSTEMDDIR="/lib/systemd/system" ])

	AC_ARG_WITH([upstartdir],
	[ --with-upstartdir=DIR : path to upstart config files directory. ],
	[ UPSTARTDIR="$withval" ],
	[ UPSTARTDIR="$sysconfdir/init" ])

	AC_ARG_WITH([initwrappersdir],
	[ --with-initwrappersdir=DIR : path to init wrappers files directory. ],
	[ INITWRAPPERSDIR="$withval" ],
	[ INITWRAPPERSDIR="$datarootdir/corosync" ])

	AC_ARG_WITH([logdir],
	[ --with-logdir=DIR : the base directory for corosync logging files. ],
	[ LOGDIR="$withval" ],
	[ LOGDIR="$localstatedir/log/cluster" ])

	AC_ARG_WITH([logrotatedir],
	[ --with-logrotatedir=DIR : the base directory for logrorate.d files. ],
	[ LOGROTATEDIR="$withval" ],
	[ LOGROTATEDIR="$sysconfdir/logrotate.d" ])

	AC_ARG_ENABLE([snmp],
	[ --enable-snmp : SNMP protocol support ],
	[ default="no" ])

	AC_ARG_ENABLE([xmlconf],
	[ --enable-xmlconf : XML configuration support ],,
	[ enable_xmlconf="no" ])
	AM_CONDITIONAL(INSTALL_XMLCONF, test x$enable_xmlconf = xyes)

	AC_ARG_ENABLE([qdevices],
	[ --enable-qdevices : Quorum devices support ],,
	[ enable_qdevices="no" ])
	AM_CONDITIONAL(BUILD_QDEVICES, test x$enable_qdevices = xyes)
	AC_ARG_ENABLE([qnetd],
	[ --enable-qnetd : Quorum Net Daemon support ],,
	[ enable_qnetd="no" ])
	AM_CONDITIONAL(BUILD_QNETD, test x$enable_qnetd = xyes)
	AC_ARG_ENABLE([libcgroup],
	[ --enable-libcgroup : Enable libcgroup support ],,
	[ enable_libcgroup="no" ])
	AM_CONDITIONAL(ENABLE_LIBCGROUP, test x$enable_libcgroup = xyes)

	AC_ARG_ENABLE([vqsim],
	[ --enable-vqsim : Quorum simulator support ],,
	[ enable_vqsim="no" ])
	AM_CONDITIONAL(BUILD_VQSIM, test x$enable_vqsim = xyes)

	# *FLAGS handling goes here

	ENV_CFLAGS="$CFLAGS"
	ENV_CPPFLAGS="$CPPFLAGS"
	ENV_LDFLAGS="$LDFLAGS"

	# debug build stuff
	if test "x${enable_debug}" = xyes; then
	AC_DEFINE_UNQUOTED([DEBUG], [1], [Compiling Debugging code])
	OPT_CFLAGS="-O0"
	PACKAGE_FEATURES="$PACKAGE_FEATURES debug"
	else
	OPT_CFLAGS="-O3"
	fi

	# gdb flags
	if test "x${GCC}" = xyes; then
	GDB_FLAGS="-ggdb3"
	else
	GDB_FLAGS="-g"
	fi

	# Look for dbus-1
	if test "x${enable_dbus}" = xyes; then
	PKG_CHECK_MODULES([DBUS],[dbus-1])
	AC_DEFINE_UNQUOTED([HAVE_DBUS], 1, [have dbus])
	PACKAGE_FEATURES="$PACKAGE_FEATURES dbus"
	WITH_LIST="$WITH_LIST --with dbus"
	fi

	if test "x${enable_testagents}" = xyes; then
	AC_DEFINE_UNQUOTED([HAVE_TESTAGENTS], 1, [have testagents])
	PACKAGE_FEATURES="$PACKAGE_FEATURES testagents"
	WITH_LIST="$WITH_LIST --with testagents"
	fi

	if test "x${enable_monitoring}" = xyes; then
	PKG_CHECK_MODULES([statgrab], [libstatgrab])
	PKG_CHECK_MODULES([statgrabge090], [libstatgrab >= 0.90],
	AC_DEFINE_UNQUOTED([HAVE_LIBSTATGRAB_GE_090], 1, [have libstatgrab >= 0.90]),
	TMP_VARIABLE=1)
	AC_DEFINE_UNQUOTED([HAVE_MONITORING], 1, [have resource monitoring])
	PACKAGE_FEATURES="$PACKAGE_FEATURES monitoring"
	WITH_LIST="$WITH_LIST --with monitoring"
	fi

	if test "x${enable_watchdog}" = xyes; then
	AC_CHECK_HEADER([linux/watchdog.h], [], [AC_MSG_ERROR([watchdog requires linux/watchdog.h])])
	AC_CHECK_HEADER([linux/reboot.h], [], [AC_MSG_ERROR([watchdog requires linux/reboot.h])])
	AC_DEFINE_UNQUOTED([HAVE_WATCHDOG], 1, [have watchdog])
	PACKAGE_FEATURES="$PACKAGE_FEATURES watchdog"
	WITH_LIST="$WITH_LIST --with watchdog"
	fi

	if test "x${enable_augeas}" = xyes; then
	PACKAGE_FEATURES="$PACKAGE_FEATURES augeas"
	fi
	if test "x${enable_systemd}" = xyes; then
	+ PKG_CHECK_MODULES([libsystemd], [libsystemd])
	+ AC_DEFINE([HAVE_LIBSYSTEMD], [1], [have systemd interface library])
	PACKAGE_FEATURES="$PACKAGE_FEATURES systemd"
	WITH_LIST="$WITH_LIST --with systemd"
	fi
	if test "x${enable_upstart}" = xyes; then
	PACKAGE_FEATURES="$PACKAGE_FEATURES upstart"
	WITH_LIST="$WITH_LIST --with upstart"
	fi
	if test "x${enable_xmlconf}" = xyes; then
	PACKAGE_FEATURES="$PACKAGE_FEATURES xmlconf"
	WITH_LIST="$WITH_LIST --with xmlconf"
	fi
	if test "x${enable_qdevices}" = xyes; then
	PACKAGE_FEATURES="$PACKAGE_FEATURES qdevices"
	fi

	if test "x${enable_vqsim}" = xyes; then
	vqsim_readline=no
	AC_CHECK_HEADERS([readline/readline.h readline/history.h],
	[],
	AC_MSG_WARN([vqsim will lack readline support]))
	PACKAGE_FEATURES="$PACKAGE_FEATURES vqsim"
	fi
	AM_CONDITIONAL(VQSIM_READLINE, [test "x${ac_cv_header_readline_readline_h}" = xyes])

	if test "x${enable_qnetd}" = xyes; then
	PACKAGE_FEATURES="$PACKAGE_FEATURES qnetd"
	fi

	do_snmp=0
	if test "x${enable_snmp}" = xyes; then
	AC_PATH_PROGS([SNMPCONFIG], [net-snmp-config])

	if test "x${SNMPCONFIG}" != "x"; then
	AC_MSG_CHECKING([for snmp includes])
	SNMP_PREFIX=`$SNMPCONFIG --prefix`
	SNMP_INCLUDES="-I$SNMP_PREFIX/include"
	AC_MSG_RESULT([$SNMP_INCLUDES])

	AC_MSG_CHECKING([for snmp libraries])
	SNMP_LIBS=`$SNMPCONFIG --libs`
	AC_MSG_RESULT([$SNMP_LIBS])
	AC_SUBST([SNMP_LIBS])

	saveCFLAGS="$CFLAGS"
	CFLAGS="$CFLAGS $SNMP_INCLUDES"
	AC_CHECK_HEADERS([net-snmp/net-snmp-config.h])
	CFLAGS="$saveCFLAGS"

	if test "x${ac_cv_header_net_snmp_net_snmp_config_h}" != "xyes"; then
	AC_MSG_ERROR([Unable to use net-snmp/net-snmp-config.h])
	fi

	savedLibs=$LIBS
	LIBS="$LIBS $SNMP_LIBS"
	AC_CHECK_FUNCS([netsnmp_transport_open_client])
	if test $ac_cv_func_netsnmp_transport_open_client != yes; then
	AC_CHECK_FUNCS([netsnmp_tdomain_transport])
	if test $ac_cv_func_netsnmp_tdomain_transport != yes; then
	AC_MSG_ERROR([No usable SNMP client transport implementation found])
	fi
	else
	AC_DEFINE_UNQUOTED([NETSNMPV54], $NETSNMP_NEW_SUPPORT, [have net-snmp5.4 over])
	fi
	LIBS=$savedLibs

	do_snmp=1
	PACKAGE_FEATURES="$PACKAGE_FEATURES snmp"
	WITH_LIST="$WITH_LIST --with snmp"
	AC_DEFINE_UNQUOTED([ENABLE_SNMP], $do_snmp, [Build in support for sending SNMP traps])
	else
	AC_MSG_ERROR([You need the net_snmp development package to continue.])
	fi
	fi
	AM_CONDITIONAL(BUILD_SNMP, test "${do_snmp}" = "1")

	if test "x${enable_libcgroup}" = xyes; then
	PKG_CHECK_MODULES([libcgroup], [libcgroup])
	AC_DEFINE_UNQUOTED([HAVE_LIBCGROUP], 1, [have libcgroup])
	PACKAGE_FEATURES="$PACKAGE_FEATURES libcgroup"
	WITH_LIST="$WITH_LIST --with libcgroup"
	fi

	# extra warnings
	EXTRA_WARNINGS=""

	WARNLIST="
	all
	shadow
	missing-prototypes
	missing-declarations
	strict-prototypes
	pointer-arith
	write-strings
	cast-align
	bad-function-cast
	missing-format-attribute
	format=2
	format-security
	format-nonliteral
	no-long-long
	unsigned-char
	no-strict-aliasing
	"

	for j in $WARNLIST; do
	if cc_supports_flag -W$j; then
	EXTRA_WARNINGS="$EXTRA_WARNINGS -W$j";
	fi
	done

	if test "x${enable_coverage}" = xyes && \
	cc_supports_flag -ftest-coverage && \
	cc_supports_flag -fprofile-arcs ; then
	AC_MSG_NOTICE([Enabling Coverage (enable -O0 by default)])
	OPT_CFLAGS="-O0"
	COVERAGE_CFLAGS="-ftest-coverage -fprofile-arcs"
	COVERAGE_LDFLAGS="-ftest-coverage -fprofile-arcs"
	PACKAGE_FEATURES="$PACKAGE_FEATURES coverage"
	else
	COVERAGE_CFLAGS=""
	COVERAGE_LDFLAGS=""
	fi

	if test "x${enable_small_memory_footprint}" = xyes ; then
	AC_DEFINE_UNQUOTED([HAVE_SMALL_MEMORY_FOOTPRINT], 1, [have small_memory_footprint])
	PACKAGE_FEATURES="$PACKAGE_FEATURES small-memory-footprint"
	fi

	if test "x${enable_ansi}" = xyes && \
	cc_supports_flag -std=iso9899:199409 ; then
	AC_MSG_NOTICE([Enabling ANSI Compatibility])
	ANSI_CPPFLAGS="-ansi -DANSI_ONLY"
	PACKAGE_FEATURES="$PACKAGE_FEATURES ansi"
	else
	ANSI_CPPFLAGS=""
	fi

	if test "x${enable_fatal_warnings}" = xyes && \
	cc_supports_flag -Werror ; then
	AC_MSG_NOTICE([Enabling Fatal Warnings (-Werror)])
	WERROR_CFLAGS="-Werror"
	PACKAGE_FEATURES="$PACKAGE_FEATURES fatal-warnings"
	else
	WERROR_CFLAGS=""
	fi

	# don't add addtional cflags
	if test "x${enable_user_flags}" = xyes; then
	OPT_CFLAGS=""
	GDB_FLAGS=""
	EXTRA_WARNINGS=""
	fi

	if test "x${enable_secure_build}" = xyes; then
	# stolen from apache configure snippet
	AC_CACHE_CHECK([whether $CC accepts PIE flags], [ap_cv_cc_pie], [
	save_CFLAGS=$CFLAGS
	save_LDFLAGS=$LDFLAGS
	CFLAGS="$CFLAGS -fPIE"
	LDFLAGS="$LDFLAGS -pie"
	AC_TRY_RUN([static int foo[30000]; int main () { return 0; }],
	[ap_cv_cc_pie=yes], [ap_cv_cc_pie=no], [ap_cv_cc_pie=yes])
	CFLAGS=$save_CFLAGS
	LDFLAGS=$save_LDFLAGS
	])
	if test "$ap_cv_cc_pie" = "yes"; then
	SEC_FLAGS="$SEC_FLAGS -fPIE"
	SEC_LDFLAGS="$SEC_LDFLAGS -pie"
	PACKAGE_FEATURES="$PACKAGE_FEATURES pie"
	fi

	# similar to above
	AC_CACHE_CHECK([whether $CC accepts RELRO flags], [ap_cv_cc_relro], [
	save_LDFLAGS=$LDFLAGS
	LDFLAGS="$LDFLAGS -Wl,-z,relro"
	AC_TRY_RUN([static int foo[30000]; int main () { return 0; }],
	[ap_cv_cc_relro=yes], [ap_cv_cc_relro=no], [ap_cv_cc_relro=yes])
	LDFLAGS=$save_LDFLAGS
	])
	if test "$ap_cv_cc_relro" = "yes"; then
	SEC_LDFLAGS="$SEC_LDFLAGS -Wl,-z,relro"
	PACKAGE_FEATURES="$PACKAGE_FEATURES relro"
	fi

	AC_CACHE_CHECK([whether $CC accepts BINDNOW flags], [ap_cv_cc_bindnow], [
	save_LDFLAGS=$LDFLAGS
	LDFLAGS="$LDFLAGS -Wl,-z,now"
	AC_TRY_RUN([static int foo[30000]; int main () { return 0; }],
	[ap_cv_cc_bindnow=yes], [ap_cv_cc_bindnow=no], [ap_cv_cc_bindnow=yes])
	LDFLAGS=$save_LDFLAGS
	])
	if test "$ap_cv_cc_bindnow" = "yes"; then
	SEC_LDFLAGS="$SEC_LDFLAGS -Wl,-z,now"
	PACKAGE_FEATURES="$PACKAGE_FEATURES bindnow"
	fi
	fi

	AC_CACHE_CHECK([whether $CC accepts "--as-needed"], [ap_cv_cc_as_needed], [
	save_LDFLAGS=$LDFLAGS
	LDFLAGS="$LDFLAGS -Wl,--as-needed"
	AC_TRY_RUN([static int foo[30000]; int main () { return 0; }],
	[ap_cv_cc_as_needed=yes], [ap_cv_cc_as_needed=no], [ap_cv_cc_as_needed=yes])
	LDFLAGS=$save_LDFLAGS
	])

	AC_CACHE_CHECK([whether $CC accepts "--version-script"], [ap_cv_cc_version_script], [
	save_LDFLAGS=$LDFLAGS
	LDFLAGS="$LDFLAGS -Wl,--version-script=conftest.versions"
	echo "CONFTEST { };" >conftest.versions
	AC_TRY_RUN([static int foo[30000]; int main () { return 0; }],
	[ap_cv_cc_version_script=yes], [ap_cv_cc_version_script=no], [ap_cv_cc_version_script=yes])
	rm -f conftest.versions
	LDFLAGS=$save_LDFLAGS
	])
	if test "$ap_cv_cc_version_script" = "yes"; then
	AC_SUBST(VERSCRIPT_LDFLAGS, ["-Wl,--version-script=\$(srcdir)/lib\$(call get_libname,\$<).versions"])
	else
	AC_SUBST(VERSCRIPT_LDFLAGS, [""])
	fi

	# define global include dirs
	INCLUDE_DIRS="$INCLUDE_DIRS -I\$(top_builddir)/include -I\$(top_srcdir)/include"
	INCLUDE_DIRS="$INCLUDE_DIRS -I\$(top_builddir)/include/corosync -I\$(top_srcdir)/include/corosync"

	# final build of *FLAGS
	CFLAGS="$ENV_CFLAGS $lt_prog_compiler_pic $SEC_FLAGS $OPT_CFLAGS $GDB_FLAGS \
	$COVERAGE_CFLAGS $EXTRA_WARNINGS \
	$WERROR_CFLAGS $NSS_CFLAGS $LIBQB_CFLAGS \
	$SNMP_INCLUDES"
	CPPFLAGS="$ENV_CPPFLAGS $ANSI_CPPFLAGS $INCLUDE_DIRS"
	LDFLAGS="$ENV_LDFLAGS $lt_prog_compiler_pic $SEC_LDFLAGS $COVERAGE_LDFLAGS"

	if test "$ap_cv_cc_as_needed" = "yes"; then
	LDFLAGS="$LDFLAGS -Wl,--as-needed"
	fi

	# substitute what we need:
	AC_SUBST([BASHPATH])
	AC_SUBST([INITDDIR])
	AC_SUBST([SYSTEMDDIR])
	AC_SUBST([UPSTARTDIR])
	INITWRAPPERSDIR=$(eval echo ${INITWRAPPERSDIR})
	AC_SUBST([INITWRAPPERSDIR])
	AC_SUBST([LOGDIR])
	AC_SUBST([LOGROTATEDIR])

	AC_SUBST([SOMAJOR])
	AC_SUBST([SOMINOR])
	AC_SUBST([SOMICRO])
	AC_SUBST([SONAME])

	AM_CONDITIONAL(INSTALL_TESTAGENTS, test "${enable_testagents}" = "yes")
	AM_CONDITIONAL(INSTALL_MIB, test "${do_snmp}" = "1")
	AM_CONDITIONAL(INSTALL_DBUSCONF, test "${enable_dbus}" = "yes")
	AM_CONDITIONAL(AUGTOOL, test -n "${AUGTOOL}")
	AC_SUBST([NSS_LDFLAGS])

	AM_CONDITIONAL(BUILD_HTML_DOCS, test -n "${GROFF}")

	AC_SUBST([LINT_FLAGS])

	AC_DEFINE_UNQUOTED([LOCALSTATEDIR], "$(eval echo ${localstatedir})", [localstate directory])

	COROSYSCONFDIR=${sysconfdir}/corosync
	AC_SUBST([COROSYSCONFDIR])
	AC_DEFINE_UNQUOTED([COROSYSCONFDIR], "$(eval echo ${COROSYSCONFDIR})", [corosync config directory])

	AC_DEFINE_UNQUOTED([PACKAGE_FEATURES], "${PACKAGE_FEATURES}", [corosync built-in features])

	AC_OUTPUT

	AC_MSG_RESULT([])
	AC_MSG_RESULT([$PACKAGE configuration:])
	AC_MSG_RESULT([ Version = ${VERSION}])
	AC_MSG_RESULT([ Prefix = ${prefix}])
	AC_MSG_RESULT([ Executables = ${sbindir}])
	AC_MSG_RESULT([ Man pages = ${mandir}])
	AC_MSG_RESULT([ Doc dir = ${docdir}])
	AC_MSG_RESULT([ Libraries = ${libdir}])
	AC_MSG_RESULT([ Header files = ${includedir}])
	AC_MSG_RESULT([ Arch-independent files = ${datadir}])
	AC_MSG_RESULT([ State information = ${localstatedir}])
	AC_MSG_RESULT([ System configuration = ${sysconfdir}])
	AC_MSG_RESULT([ System init.d directory = ${INITDDIR}])
	AC_MSG_RESULT([ System systemd directory = ${SYSTEMDDIR}])
	AC_MSG_RESULT([ System upstart directory = ${UPSTARTDIR}])
	AC_MSG_RESULT([ System init wraps dir = ${INITWRAPPERSDIR}])
	AC_MSG_RESULT([ Log directory = ${LOGDIR}])
	AC_MSG_RESULT([ Log rotate directory = ${LOGROTATEDIR}])
	AC_MSG_RESULT([ corosync config dir = ${COROSYSCONFDIR}])
	AC_MSG_RESULT([ init config directory = ${INITCONFIGDIR}])
	AC_MSG_RESULT([ Features =${PACKAGE_FEATURES}])
	AC_MSG_RESULT([])
	AC_MSG_RESULT([$PACKAGE build info:])
	AC_MSG_RESULT([ Library SONAME = ${SONAME}])
	LIB_MSG_RESULT(m4_shift(local_soname_list))dnl
	AC_MSG_RESULT([ Default optimization = ${OPT_CFLAGS}])
	AC_MSG_RESULT([ Default debug options = ${GDB_CFLAGS}])
	AC_MSG_RESULT([ Extra compiler warnings = ${EXTRA_WARNING}])
	AC_MSG_RESULT([ Env. defined CFLAG = ${ENV_CFLAGS}])
	AC_MSG_RESULT([ Env. defined CPPFLAGS = ${ENV_CPPFLAGS}])
	AC_MSG_RESULT([ Env. defined LDFLAGS = ${ENV_LDFLAGS}])
	AC_MSG_RESULT([ ANSI defined CPPFLAGS = ${ANSI_CPPFLAGS}])
	AC_MSG_RESULT([ Coverage CFLAGS = ${COVERAGE_CFLAGS}])
	AC_MSG_RESULT([ Coverage LDFLAGS = ${COVERAGE_LDFLAGS}])
	AC_MSG_RESULT([ Fatal War. CFLAGS = ${WERROR_CFLAGS}])
	AC_MSG_RESULT([ Final CFLAGS = ${CFLAGS}])
	AC_MSG_RESULT([ Final CPPFLAGS = ${CPPFLAGS}])
	AC_MSG_RESULT([ Final LDFLAGS = ${LDFLAGS}])
	diff --git a/exec/Makefile.am b/exec/Makefile.am
	index 8afbea97..96dce6ec 100644
	--- a/exec/Makefile.am
	+++ b/exec/Makefile.am
	@@ -1,84 +1,84 @@
	# Copyright (c) 2009 Red Hat, Inc.
	#
	# Authors: Andrew Beekhof
	# Steven Dake (sdake@redhat.com)
	#
	# This software licensed under BSD license, the text of which follows:
	#
	# Redistribution and use in source and binary forms, with or without
	# modification, are permitted provided that the following conditions are met:
	#
	# - Redistributions of source code must retain the above copyright notice,
	# this list of conditions and the following disclaimer.
	# - 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.
	# - Neither the name of the MontaVista Software, Inc. nor the names of its
	# contributors may be used to endorse or promote products derived from this
	# software without specific prior written permission.
	#
	# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.

	MAINTAINERCLEANFILES = Makefile.in

	noinst_HEADERS = apidef.h cs_queue.h logconfig.h main.h \
	quorum.h service.h timer.h totemconfig.h \
	totemnet.h totemudp.h \
	totemudpu.h totemsrp.h util.h vsf.h \
	schedwrk.h sync.h fsm.h votequorum.h vsf_ykd.h \
	totemknet.h stats.h

	TOTEM_SRC = totemip.c totemnet.c totemudp.c \
	totemudpu.c totemsrp.c \
	totempg.c totemknet.c


	lib_LTLIBRARIES = libtotem_pg.la
	libtotem_pg_la_SOURCES = $(TOTEM_SRC)
	libtotem_pg_la_CFLAGS = $(nss_CFLAGS) $(rdmacm_CFLAGS) $(ibverbs_CFLAGS)
	libtotem_pg_la_LDFLAGS = -version-number $(subst .,:,$(SONAME))
	libtotem_pg_la_LIBADD = -lpthread $(LIBQB_LIBS) $(nss_LIBS) \
	$(rdmacm_LIBS) $(ibverbs_LIBS) -lknet

	sbin_PROGRAMS = corosync

	corosync_SOURCES = vsf_ykd.c coroparse.c vsf_quorum.c sync.c \
	logsys.c cfg.c cmap.c cpg.c pload.c \
	votequorum.c util.c schedwrk.c main.c \
	apidef.c quorum.c icmap.c timer.c stats.c \
	ipc_glue.c service.c logconfig.c totemconfig.c

	if BUILD_MONITORING
	corosync_SOURCES += mon.c
	endif

	if BUILD_WATCHDOG
	corosync_SOURCES += wd.c
	endif

	corosync_CPPFLAGS = -DLOGCONFIG_USE_ICMAP=1

	-corosync_CFLAGS = $(statgrab_CFLAGS)
	+corosync_CFLAGS = $(statgrab_CFLAGS) $(libsystemd_CFLAGS)

	corosync_LDADD = libtotem_pg.la ../common_lib/libcorosync_common.la \
	- $(LIBQB_LIBS) $(statgrab_LIBS)
	+ $(LIBQB_LIBS) $(statgrab_LIBS) $(libsystemd_LIBS)

	corosync_DEPENDENCIES = libtotem_pg.la ../common_lib/libcorosync_common.la

	if ENABLE_LIBCGROUP
	corosync_CFLAGS += $(libcgroup_CFLAGS)
	corosync_LDADD += $(libcgroup_LIBS)
	endif

	lint:
	-splint $(LINT_FLAGS) $(CPPFLAGS) $(CFLAGS) *.c
	diff --git a/exec/main.c b/exec/main.c
	index c69ddd19..8915d9ef 100644
	--- a/exec/main.c
	+++ b/exec/main.c
	@@ -1,1541 +1,1549 @@
	/*
	* Copyright (c) 2002-2006 MontaVista Software, Inc.
	* Copyright (c) 2006-2017 Red Hat, Inc.
	*
	* All rights reserved.
	*
	* Author: Steven Dake (sdake@redhat.com)
	*
	* This software licensed under BSD license, the text of which follows:
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	*
	* - Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	* - 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.
	* - Neither the name of the MontaVista Software, Inc. nor the names of its
	* contributors may be used to endorse or promote products derived from this
	* software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
	*/

	/**
	* \mainpage Corosync
	*
	* This is the doxygen generated developer documentation for the Corosync
	* project. For more information about Corosync, please see the project
	* web site, <a href="http://www.corosync.org">corosync.org</a>.
	*
	* \section license License
	*
	* This software licensed under BSD license, the text of which follows:
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	*
	* - Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	* - 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.
	* - Neither the name of the MontaVista Software, Inc. nor the names of its
	* contributors may be used to endorse or promote products derived from this
	* software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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 <config.h>

	#include <pthread.h>
	#include <assert.h>
	#include <sys/types.h>
	#include <sys/file.h>
	#include <sys/poll.h>
	#include <sys/uio.h>
	#include <sys/mman.h>
	#include <sys/socket.h>
	#include <sys/un.h>
	#include <sys/time.h>
	#include <sys/resource.h>
	#include <sys/stat.h>
	#include <netinet/in.h>
	#include <arpa/inet.h>
	#include <unistd.h>
	#include <fcntl.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <errno.h>
	#include <signal.h>
	#include <sched.h>
	#include <time.h>
	#include <semaphore.h>
	#include <string.h>

	+#ifdef HAVE_LIBSYSTEMD
	+#include <systemd/sd-daemon.h>
	+#endif
	+
	#include <qb/qbdefs.h>
	#include <qb/qblog.h>
	#include <qb/qbloop.h>
	#include <qb/qbutil.h>
	#include <qb/qbipcs.h>

	#include <corosync/swab.h>
	#include <corosync/corotypes.h>
	#include <corosync/corodefs.h>
	#include <corosync/totem/totempg.h>
	#include <corosync/logsys.h>
	#include <corosync/icmap.h>

	#ifdef HAVE_LIBCGROUP
	#include <libcgroup.h>
	#endif

	#include "quorum.h"
	#include "totemsrp.h"
	#include "logconfig.h"
	#include "totemconfig.h"
	#include "main.h"
	#include "sync.h"
	#include "timer.h"
	#include "util.h"
	#include "apidef.h"
	#include "service.h"
	#include "schedwrk.h"
	#include "ipcs_stats.h"
	#include "stats.h"

	#ifdef HAVE_SMALL_MEMORY_FOOTPRINT
	#define IPC_LOGSYS_SIZE 1024*64
	#else
	#define IPC_LOGSYS_SIZE 8192*128
	#endif

	/*
	* LibQB adds default "*" syslog filter so we have to set syslog_priority as low
	* as possible so filters applied later in _logsys_config_apply_per_file takes
	* effect.
	*/
	LOGSYS_DECLARE_SYSTEM ("corosync",
	LOGSYS_MODE_OUTPUT_STDERR \| LOGSYS_MODE_OUTPUT_SYSLOG,
	LOG_DAEMON,
	LOG_EMERG);

	LOGSYS_DECLARE_SUBSYS ("MAIN");

	#define SERVER_BACKLOG 5

	static int sched_priority = 0;

	static unsigned int service_count = 32;

	static struct totem_logging_configuration totem_logging_configuration;

	static struct corosync_api_v1 *api = NULL;

	static int sync_in_process = 1;

	static qb_loop_t *corosync_poll_handle;

	struct sched_param global_sched_param;

	static corosync_timer_handle_t corosync_stats_timer_handle;

	static const char *corosync_lock_file = LOCALSTATEDIR"/run/corosync.pid";

	static int ip_version = AF_INET;

	qb_loop_t *cs_poll_handle_get (void)
	{
	return (corosync_poll_handle);
	}

	int cs_poll_dispatch_add (qb_loop_t * handle,
	int fd,
	int events,
	void *data,

	int (*dispatch_fn) (int fd,
	int revents,
	void *data))
	{
	return qb_loop_poll_add(handle, QB_LOOP_MED, fd, events, data,
	dispatch_fn);
	}

	int cs_poll_dispatch_delete(qb_loop_t * handle, int fd)
	{
	return qb_loop_poll_del(handle, fd);
	}

	void corosync_state_dump (void)
	{
	int i;

	for (i = 0; i < SERVICES_COUNT_MAX; i++) {
	if (corosync_service[i] && corosync_service[i]->exec_dump_fn) {
	corosync_service[i]->exec_dump_fn ();
	}
	}
	}

	static void corosync_blackbox_write_to_file (void)
	{
	char fname[PATH_MAX];
	char fdata_fname[PATH_MAX];
	char time_str[PATH_MAX];
	struct tm cur_time_tm;
	time_t cur_time_t;
	ssize_t res;

	cur_time_t = time(NULL);
	localtime_r(&cur_time_t, &cur_time_tm);

	strftime(time_str, PATH_MAX, "%Y-%m-%dT%H:%M:%S", &cur_time_tm);
	snprintf(fname, PATH_MAX, "%s/fdata-%s-%lld",
	get_run_dir(),
	time_str,
	(long long int)getpid());

	if ((res = qb_log_blackbox_write_to_file(fname)) < 0) {
	LOGSYS_PERROR(-res, LOGSYS_LEVEL_ERROR, "Can't store blackbox file");
	}
	snprintf(fdata_fname, sizeof(fdata_fname), "%s/fdata", get_run_dir());
	unlink(fdata_fname);
	if (symlink(fname, fdata_fname) == -1) {
	log_printf(LOGSYS_LEVEL_ERROR, "Can't create symlink to '%s' for corosync blackbox file '%s'",
	fname, fdata_fname);
	}
	}

	static void unlink_all_completed (void)
	{
	api->timer_delete (corosync_stats_timer_handle);
	qb_loop_stop (corosync_poll_handle);
	icmap_fini();
	}

	void corosync_shutdown_request (void)
	{
	corosync_service_unlink_all (api, unlink_all_completed);
	}

	static int32_t sig_diag_handler (int num, void *data)
	{
	corosync_state_dump ();
	return 0;
	}

	static int32_t sig_exit_handler (int num, void *data)
	{
	log_printf(LOGSYS_LEVEL_NOTICE, "Node was shut down by a signal");
	corosync_service_unlink_all (api, unlink_all_completed);
	return 0;
	}

	static void sigsegv_handler (int num)
	{
	(void)signal (num, SIG_DFL);
	corosync_blackbox_write_to_file ();
	qb_log_fini();
	raise (num);
	}

	#define LOCALHOST_IP inet_addr("127.0.0.1")

	static void *corosync_group_handle;

	static struct totempg_group corosync_group = {
	.group = "a",
	.group_len = 1
	};

	static void serialize_lock (void)
	{
	}

	static void serialize_unlock (void)
	{
	}

	static void corosync_sync_completed (void)
	{
	log_printf (LOGSYS_LEVEL_NOTICE,
	"Completed service synchronization, ready to provide service.");
	sync_in_process = 0;

	cs_ipcs_sync_state_changed(sync_in_process);
	cs_ipc_allow_connections(1);
	/*
	* Inform totem to start using new message queue again
	*/
	totempg_trans_ack();
	+
	+#ifdef HAVE_LIBSYSTEMD
	+ sd_notify (0, "READY=1");
	+#endif
	}

	static int corosync_sync_callbacks_retrieve (
	int service_id,
	struct sync_callbacks *callbacks)
	{
	if (corosync_service[service_id] == NULL) {
	return (-1);
	}

	if (callbacks == NULL) {
	return (0);
	}

	callbacks->name = corosync_service[service_id]->name;

	callbacks->sync_init = corosync_service[service_id]->sync_init;
	callbacks->sync_process = corosync_service[service_id]->sync_process;
	callbacks->sync_activate = corosync_service[service_id]->sync_activate;
	callbacks->sync_abort = corosync_service[service_id]->sync_abort;
	return (0);
	}

	static struct memb_ring_id corosync_ring_id;

	static void member_object_joined (unsigned int nodeid)
	{
	char member_ip[ICMAP_KEYNAME_MAXLEN];
	char member_join_count[ICMAP_KEYNAME_MAXLEN];
	char member_status[ICMAP_KEYNAME_MAXLEN];

	snprintf(member_ip, ICMAP_KEYNAME_MAXLEN,
	"runtime.members.%u.ip", nodeid);
	snprintf(member_join_count, ICMAP_KEYNAME_MAXLEN,
	"runtime.members.%u.join_count", nodeid);
	snprintf(member_status, ICMAP_KEYNAME_MAXLEN,
	"runtime.members.%u.status", nodeid);

	if (icmap_get(member_ip, NULL, NULL, NULL) == CS_OK) {
	icmap_inc(member_join_count);
	icmap_set_string(member_status, "joined");
	} else {
	icmap_set_string(member_ip, (char*)api->totem_ifaces_print (nodeid));
	icmap_set_uint32(member_join_count, 1);
	icmap_set_string(member_status, "joined");
	}

	log_printf (LOGSYS_LEVEL_DEBUG,
	"Member joined: %s", api->totem_ifaces_print (nodeid));
	}

	static void member_object_left (unsigned int nodeid)
	{
	char member_status[ICMAP_KEYNAME_MAXLEN];

	snprintf(member_status, ICMAP_KEYNAME_MAXLEN,
	"runtime.members.%u.status", nodeid);
	icmap_set_string(member_status, "left");

	log_printf (LOGSYS_LEVEL_DEBUG,
	"Member left: %s", api->totem_ifaces_print (nodeid));
	}

	static void confchg_fn (
	enum totem_configuration_type configuration_type,
	const unsigned int *member_list, size_t member_list_entries,
	const unsigned int *left_list, size_t left_list_entries,
	const unsigned int *joined_list, size_t joined_list_entries,
	const struct memb_ring_id *ring_id)
	{
	int i;
	int abort_activate = 0;

	if (sync_in_process == 1) {
	abort_activate = 1;
	}
	sync_in_process = 1;
	cs_ipcs_sync_state_changed(sync_in_process);
	memcpy (&corosync_ring_id, ring_id, sizeof (struct memb_ring_id));

	for (i = 0; i < left_list_entries; i++) {
	member_object_left (left_list[i]);
	}
	for (i = 0; i < joined_list_entries; i++) {
	member_object_joined (joined_list[i]);
	}
	/*
	* Call configuration change for all services
	*/
	for (i = 0; i < service_count; i++) {
	if (corosync_service[i] && corosync_service[i]->confchg_fn) {
	corosync_service[i]->confchg_fn (configuration_type,
	member_list, member_list_entries,
	left_list, left_list_entries,
	joined_list, joined_list_entries, ring_id);
	}
	}

	if (abort_activate) {
	sync_abort ();
	}
	if (configuration_type == TOTEM_CONFIGURATION_TRANSITIONAL) {
	sync_save_transitional (member_list, member_list_entries, ring_id);
	}
	if (configuration_type == TOTEM_CONFIGURATION_REGULAR) {
	sync_start (member_list, member_list_entries, ring_id);
	}
	}

	static void priv_drop (void)
	{
	return; /* TODO: we are still not dropping privs */
	}

	static void corosync_tty_detach (void)
	{
	int devnull;

	/*
	* Disconnect from TTY if this is not a debug run
	*/

	switch (fork ()) {
	case -1:
	corosync_exit_error (COROSYNC_DONE_FORK);
	break;
	case 0:
	/*
	* child which is disconnected, run this process
	*/
	break;
	default:
	exit (0);
	break;
	}

	/* Create new session */
	(void)setsid();

	/*
	* Map stdin/out/err to /dev/null.
	*/
	devnull = open("/dev/null", O_RDWR);
	if (devnull == -1) {
	corosync_exit_error (COROSYNC_DONE_STD_TO_NULL_REDIR);
	}

	if (dup2(devnull, 0) < 0 \|\| dup2(devnull, 1) < 0
	\|\| dup2(devnull, 2) < 0) {
	close(devnull);
	corosync_exit_error (COROSYNC_DONE_STD_TO_NULL_REDIR);
	}
	close(devnull);
	}

	static void corosync_mlockall (void)
	{
	int res;
	struct rlimit rlimit;

	rlimit.rlim_cur = RLIM_INFINITY;
	rlimit.rlim_max = RLIM_INFINITY;

	#ifndef RLIMIT_MEMLOCK
	#define RLIMIT_MEMLOCK RLIMIT_VMEM
	#endif

	setrlimit (RLIMIT_MEMLOCK, &rlimit);

	res = mlockall (MCL_CURRENT \| MCL_FUTURE);
	if (res == -1) {
	LOGSYS_PERROR (errno, LOGSYS_LEVEL_WARNING,
	"Could not lock memory of service to avoid page faults");
	};
	}


	static void corosync_totem_stats_updater (void *data)
	{
	totempg_stats_t * stats;
	uint32_t total_mtt_rx_token;
	uint32_t total_backlog_calc;
	uint32_t total_token_holdtime;
	int t, prev;
	int32_t token_count;
	const char *cstr;

	stats = api->totem_get_stats();


	stats->srp->firewall_enabled_or_nic_failure = stats->srp->continuous_gather > MAX_NO_CONT_GATHER ? 1 : 0;

	if (stats->srp->continuous_gather > MAX_NO_CONT_GATHER \|\|
	stats->srp->continuous_sendmsg_failures > MAX_NO_CONT_SENDMSG_FAILURES) {
	cstr = "";

	if (stats->srp->continuous_sendmsg_failures > MAX_NO_CONT_SENDMSG_FAILURES) {
	cstr = "number of multicast sendmsg failures is above threshold";
	}

	if (stats->srp->continuous_gather > MAX_NO_CONT_GATHER) {
	cstr = "totem is continuously in gather state";
	}

	log_printf (LOGSYS_LEVEL_WARNING,
	"Totem is unable to form a cluster because of an "
	"operating system or network fault (reason: %s). The most common "
	"cause of this message is that the local firewall is "
	"configured improperly.", cstr);
	stats->srp->firewall_enabled_or_nic_failure = 1;
	} else {
	stats->srp->firewall_enabled_or_nic_failure = 0;
	}

	total_mtt_rx_token = 0;
	total_token_holdtime = 0;
	total_backlog_calc = 0;
	token_count = 0;
	t = stats->srp->latest_token;
	while (1) {
	if (t == 0)
	prev = TOTEM_TOKEN_STATS_MAX - 1;
	else
	prev = t - 1;
	if (prev == stats->srp->earliest_token)
	break;
	/* if tx == 0, then dropped token (not ours) */
	if (stats->srp->token[t].tx != 0 \|\|
	(stats->srp->token[t].rx - stats->srp->token[prev].rx) > 0 ) {
	total_mtt_rx_token += (stats->srp->token[t].rx - stats->srp->token[prev].rx);
	total_token_holdtime += (stats->srp->token[t].tx - stats->srp->token[t].rx);
	total_backlog_calc += stats->srp->token[t].backlog_calc;
	token_count++;
	}
	t = prev;
	}
	if (token_count) {
	stats->srp->mtt_rx_token = (total_mtt_rx_token / token_count);
	stats->srp->avg_token_workload = (total_token_holdtime / token_count);
	stats->srp->avg_backlog_calc = (total_backlog_calc / token_count);
	}

	stats_trigger_trackers();

	api->timer_add_duration (1500 * MILLI_2_NANO_SECONDS, NULL,
	corosync_totem_stats_updater,
	&corosync_stats_timer_handle);
	}

	static void corosync_totem_stats_init (void)
	{
	/* start stats timer */
	api->timer_add_duration (1500 * MILLI_2_NANO_SECONDS, NULL,
	corosync_totem_stats_updater,
	&corosync_stats_timer_handle);
	}

	static void deliver_fn (
	unsigned int nodeid,
	const void *msg,
	unsigned int msg_len,
	int endian_conversion_required)
	{
	const struct qb_ipc_request_header *header;
	int32_t service;
	int32_t fn_id;
	uint32_t id;

	header = msg;
	if (endian_conversion_required) {
	id = swab32 (header->id);
	} else {
	id = header->id;
	}

	/*
	* Call the proper executive handler
	*/
	service = id >> 16;
	fn_id = id & 0xffff;

	if (!corosync_service[service]) {
	return;
	}
	if (fn_id >= corosync_service[service]->exec_engine_count) {
	log_printf(LOGSYS_LEVEL_WARNING, "discarded unknown message %d for service %d (max id %d)",
	fn_id, service, corosync_service[service]->exec_engine_count);
	return;
	}

	icmap_fast_inc(service_stats_rx[service][fn_id]);

	if (endian_conversion_required) {
	assert(corosync_service[service]->exec_engine[fn_id].exec_endian_convert_fn != NULL);
	corosync_service[service]->exec_engine[fn_id].exec_endian_convert_fn
	((void *)msg);
	}

	corosync_service[service]->exec_engine[fn_id].exec_handler_fn
	(msg, nodeid);
	}

	int main_mcast (
	const struct iovec *iovec,
	unsigned int iov_len,
	unsigned int guarantee)
	{
	const struct qb_ipc_request_header *req = iovec->iov_base;
	int32_t service;
	int32_t fn_id;

	service = req->id >> 16;
	fn_id = req->id & 0xffff;

	if (corosync_service[service]) {
	icmap_fast_inc(service_stats_tx[service][fn_id]);
	}

	return (totempg_groups_mcast_joined (corosync_group_handle, iovec, iov_len, guarantee));
	}

	static void corosync_ring_id_create_or_load (
	struct memb_ring_id *memb_ring_id,
	const struct totem_ip_address *addr)
	{
	int fd;
	int res = 0;
	char filename[PATH_MAX];

	snprintf (filename, sizeof(filename), "%s/ringid_%s",
	get_run_dir(), totemip_print (addr));
	fd = open (filename, O_RDONLY, 0700);
	/*
	* If file can be opened and read, read the ring id
	*/
	if (fd != -1) {
	res = read (fd, &memb_ring_id->seq, sizeof (uint64_t));
	close (fd);
	}
	/*
	* If file could not be opened or read, create a new ring id
	*/
	if ((fd == -1) \|\| (res != sizeof (uint64_t))) {
	memb_ring_id->seq = 0;
	umask(0);
	fd = open (filename, O_CREAT\|O_RDWR, 0700);
	if (fd != -1) {
	res = write (fd, &memb_ring_id->seq, sizeof (uint64_t));
	close (fd);
	if (res == -1) {
	LOGSYS_PERROR (errno, LOGSYS_LEVEL_ERROR,
	"Couldn't write ringid file '%s'", filename);

	corosync_exit_error (COROSYNC_DONE_STORE_RINGID);
	}
	} else {
	LOGSYS_PERROR (errno, LOGSYS_LEVEL_ERROR,
	"Couldn't create ringid file '%s'", filename);

	corosync_exit_error (COROSYNC_DONE_STORE_RINGID);
	}
	}

	totemip_copy(&memb_ring_id->rep, addr);
	assert (!totemip_zero_check(&memb_ring_id->rep));
	}

	static void corosync_ring_id_store (
	const struct memb_ring_id *memb_ring_id,
	const struct totem_ip_address *addr)
	{
	char filename[PATH_MAX];
	int fd;
	int res;

	snprintf (filename, sizeof(filename), "%s/ringid_%s",
	get_run_dir(), totemip_print (addr));

	fd = open (filename, O_WRONLY, 0700);
	if (fd == -1) {
	fd = open (filename, O_CREAT\|O_RDWR, 0700);
	}
	if (fd == -1) {
	LOGSYS_PERROR(errno, LOGSYS_LEVEL_ERROR,
	"Couldn't store new ring id %llx to stable storage",
	memb_ring_id->seq);

	corosync_exit_error (COROSYNC_DONE_STORE_RINGID);
	}
	log_printf (LOGSYS_LEVEL_DEBUG,
	"Storing new sequence id for ring %llx", memb_ring_id->seq);
	res = write (fd, &memb_ring_id->seq, sizeof(memb_ring_id->seq));
	close (fd);
	if (res != sizeof(memb_ring_id->seq)) {
	LOGSYS_PERROR(errno, LOGSYS_LEVEL_ERROR,
	"Couldn't store new ring id %llx to stable storage",
	memb_ring_id->seq);

	corosync_exit_error (COROSYNC_DONE_STORE_RINGID);
	}
	}

	static qb_loop_timer_handle recheck_the_q_level_timer;
	void corosync_recheck_the_q_level(void *data)
	{
	totempg_check_q_level(corosync_group_handle);
	if (cs_ipcs_q_level_get() == TOTEM_Q_LEVEL_CRITICAL) {
	qb_loop_timer_add(cs_poll_handle_get(), QB_LOOP_MED, 1*QB_TIME_NS_IN_MSEC,
	NULL, corosync_recheck_the_q_level, &recheck_the_q_level_timer);
	}
	}

	struct sending_allowed_private_data_struct {
	int reserved_msgs;
	};


	int corosync_sending_allowed (
	unsigned int service,
	unsigned int id,
	const void *msg,
	void *sending_allowed_private_data)
	{
	struct sending_allowed_private_data_struct *pd =
	(struct sending_allowed_private_data_struct *)sending_allowed_private_data;
	struct iovec reserve_iovec;
	struct qb_ipc_request_header header = (struct qb_ipc_request_header )msg;
	int sending_allowed;

	reserve_iovec.iov_base = (char *)header;
	reserve_iovec.iov_len = header->size;

	pd->reserved_msgs = totempg_groups_joined_reserve (
	corosync_group_handle,
	&reserve_iovec, 1);
	if (pd->reserved_msgs == -1) {
	return -EINVAL;
	}

	/* Message ID out of range */
	if (id >= corosync_service[service]->lib_engine_count) {
	return -EINVAL;
	}

	sending_allowed = QB_FALSE;
	if (corosync_quorum_is_quorate() == 1 \|\|
	corosync_service[service]->allow_inquorate == CS_LIB_ALLOW_INQUORATE) {
	// we are quorate
	// now check flow control
	if (corosync_service[service]->lib_engine[id].flow_control == CS_LIB_FLOW_CONTROL_NOT_REQUIRED) {
	sending_allowed = QB_TRUE;
	} else if (pd->reserved_msgs && sync_in_process == 0) {
	sending_allowed = QB_TRUE;
	} else if (pd->reserved_msgs == 0) {
	return -ENOBUFS;
	} else /* (sync_in_process) */ {
	return -EINPROGRESS;
	}
	} else {
	return -EHOSTUNREACH;
	}

	return (sending_allowed);
	}

	void corosync_sending_allowed_release (void *sending_allowed_private_data)
	{
	struct sending_allowed_private_data_struct *pd =
	(struct sending_allowed_private_data_struct *)sending_allowed_private_data;

	if (pd->reserved_msgs == -1) {
	return;
	}
	totempg_groups_joined_release (pd->reserved_msgs);
	}

	int message_source_is_local (const mar_message_source_t *source)
	{
	int ret = 0;

	assert (source != NULL);
	if (source->nodeid == totempg_my_nodeid_get ()) {
	ret = 1;
	}
	return ret;
	}

	void message_source_set (
	mar_message_source_t *source,
	void *conn)
	{
	assert ((source != NULL) && (conn != NULL));
	memset (source, 0, sizeof (mar_message_source_t));
	source->nodeid = totempg_my_nodeid_get ();
	source->conn = conn;
	}

	struct scheduler_pause_timeout_data {
	struct totem_config *totem_config;
	qb_loop_timer_handle handle;
	unsigned long long tv_prev;
	unsigned long long max_tv_diff;
	};

	static void timer_function_scheduler_timeout (void *data)
	{
	struct scheduler_pause_timeout_data timeout_data = (struct scheduler_pause_timeout_data )data;
	unsigned long long tv_current;
	unsigned long long tv_diff;

	tv_current = qb_util_nano_current_get ();

	if (timeout_data->tv_prev == 0) {
	/*
	* Initial call -> just pretent everything is ok
	*/
	timeout_data->tv_prev = tv_current;
	timeout_data->max_tv_diff = 0;
	}

	tv_diff = tv_current - timeout_data->tv_prev;
	timeout_data->tv_prev = tv_current;

	if (tv_diff > timeout_data->max_tv_diff) {
	log_printf (LOGSYS_LEVEL_WARNING, "Corosync main process was not scheduled for %0.4f ms "
	"(threshold is %0.4f ms). Consider token timeout increase.",
	(float)tv_diff / QB_TIME_NS_IN_MSEC, (float)timeout_data->max_tv_diff / QB_TIME_NS_IN_MSEC);
	}

	/*
	* Set next threshold, because token_timeout can change
	*/
	timeout_data->max_tv_diff = timeout_data->totem_config->token_timeout * QB_TIME_NS_IN_MSEC * 0.8;
	qb_loop_timer_add (corosync_poll_handle,
	QB_LOOP_MED,
	timeout_data->totem_config->token_timeout * QB_TIME_NS_IN_MSEC / 3,
	timeout_data,
	timer_function_scheduler_timeout,
	&timeout_data->handle);
	}


	static int corosync_set_rr_scheduler (void)
	{
	int ret_val = 0;

	#if defined(HAVE_PTHREAD_SETSCHEDPARAM) && defined(HAVE_SCHED_GET_PRIORITY_MAX) && defined(HAVE_SCHED_SETSCHEDULER)
	int res;

	sched_priority = sched_get_priority_max (SCHED_RR);
	if (sched_priority != -1) {
	global_sched_param.sched_priority = sched_priority;
	res = sched_setscheduler (0, SCHED_RR, &global_sched_param);
	if (res == -1) {
	LOGSYS_PERROR(errno, LOGSYS_LEVEL_WARNING,
	"Could not set SCHED_RR at priority %d",
	global_sched_param.sched_priority);

	global_sched_param.sched_priority = 0;
	#ifdef HAVE_QB_LOG_THREAD_PRIORITY_SET
	qb_log_thread_priority_set (SCHED_OTHER, 0);
	#endif
	ret_val = -1;
	} else {

	/*
	* Turn on SCHED_RR in logsys system
	*/
	#ifdef HAVE_QB_LOG_THREAD_PRIORITY_SET
	res = qb_log_thread_priority_set (SCHED_RR, sched_priority);
	#else
	res = -1;
	#endif
	if (res == -1) {
	log_printf (LOGSYS_LEVEL_ERROR,
	"Could not set logsys thread priority."
	" Can't continue because of priority inversions.");
	corosync_exit_error (COROSYNC_DONE_LOGSETUP);
	}
	}
	} else {
	LOGSYS_PERROR (errno, LOGSYS_LEVEL_WARNING,
	"Could not get maximum scheduler priority");
	sched_priority = 0;
	ret_val = -1;
	}
	#else
	log_printf(LOGSYS_LEVEL_WARNING,
	"The Platform is missing process priority setting features. Leaving at default.");
	ret_val = -1;
	#endif

	return (ret_val);
	}


	/* The basename man page contains scary warnings about
	thread-safety and portability, hence this */
	static const char corosync_basename(const char file_name)
	{
	char *base;
	base = strrchr (file_name, '/');
	if (base) {
	return base + 1;
	}

	return file_name;
	}

	static void
	_logsys_log_printf(int level, int subsys,
	const char *function_name,
	const char *file_name,
	int file_line,
	const char *format,
	...) __attribute__((format(printf, 6, 7)));

	static void
	_logsys_log_printf(int level, int subsys,
	const char *function_name,
	const char *file_name,
	int file_line,
	const char *format, ...)
	{
	va_list ap;

	va_start(ap, format);
	qb_log_from_external_source_va(function_name, corosync_basename(file_name),
	format, level, file_line,
	subsys, ap);
	va_end(ap);
	}

	static void fplay_key_change_notify_fn (
	int32_t event,
	const char *key_name,
	struct icmap_notify_value new_val,
	struct icmap_notify_value old_val,
	void *user_data)
	{
	if (strcmp(key_name, "runtime.blackbox.dump_flight_data") == 0) {
	fprintf(stderr,"Writetofile\n");
	corosync_blackbox_write_to_file ();
	}
	if (strcmp(key_name, "runtime.blackbox.dump_state") == 0) {
	fprintf(stderr,"statefump\n");
	corosync_state_dump ();
	}
	}

	static void corosync_fplay_control_init (void)
	{
	icmap_track_t track = NULL;

	icmap_set_string("runtime.blackbox.dump_flight_data", "no");
	icmap_set_string("runtime.blackbox.dump_state", "no");

	icmap_track_add("runtime.blackbox.dump_flight_data",
	ICMAP_TRACK_ADD \| ICMAP_TRACK_DELETE \| ICMAP_TRACK_MODIFY,
	fplay_key_change_notify_fn,
	NULL, &track);
	icmap_track_add("runtime.blackbox.dump_state",
	ICMAP_TRACK_ADD \| ICMAP_TRACK_DELETE \| ICMAP_TRACK_MODIFY,
	fplay_key_change_notify_fn,
	NULL, &track);
	}

	/*
	* Set RO flag for keys, which ether doesn't make sense to change by user (statistic)
	* or which when changed are not reflected by runtime (totem.crypto_cipher, ...).
	*
	* Also some RO keys cannot be determined in this stage, so they are set later in
	* other functions (like nodelist.local_node_pos, ...)
	*/
	static void set_icmap_ro_keys_flag (void)
	{
	/*
	* Set RO flag for all keys of internal configuration and runtime statistics
	*/
	icmap_set_ro_access("internal_configuration.", CS_TRUE, CS_TRUE);
	icmap_set_ro_access("runtime.services.", CS_TRUE, CS_TRUE);
	icmap_set_ro_access("runtime.config.", CS_TRUE, CS_TRUE);
	icmap_set_ro_access("runtime.totem.", CS_TRUE, CS_TRUE);
	icmap_set_ro_access("uidgid.config.", CS_TRUE, CS_TRUE);

	/*
	* Set RO flag for constrete keys of configuration which can't be changed
	* during runtime
	*/
	icmap_set_ro_access("totem.crypto_cipher", CS_FALSE, CS_TRUE);
	icmap_set_ro_access("totem.crypto_hash", CS_FALSE, CS_TRUE);
	icmap_set_ro_access("totem.secauth", CS_FALSE, CS_TRUE);
	icmap_set_ro_access("totem.ip_version", CS_FALSE, CS_TRUE);
	icmap_set_ro_access("totem.rrp_mode", CS_FALSE, CS_TRUE);
	icmap_set_ro_access("totem.transport", CS_FALSE, CS_TRUE);
	icmap_set_ro_access("totem.cluster_name", CS_FALSE, CS_TRUE);
	icmap_set_ro_access("totem.netmtu", CS_FALSE, CS_TRUE);
	icmap_set_ro_access("totem.threads", CS_FALSE, CS_TRUE);
	icmap_set_ro_access("totem.version", CS_FALSE, CS_TRUE);
	icmap_set_ro_access("totem.nodeid", CS_FALSE, CS_TRUE);
	icmap_set_ro_access("totem.clear_node_high_bit", CS_FALSE, CS_TRUE);
	icmap_set_ro_access("qb.ipc_type", CS_FALSE, CS_TRUE);
	icmap_set_ro_access("config.reload_in_progress", CS_FALSE, CS_TRUE);
	icmap_set_ro_access("config.totemconfig_reload_in_progress", CS_FALSE, CS_TRUE);
	}

	static void main_service_ready (void)
	{
	int res;

	/*
	* This must occur after totempg is initialized because "this_ip" must be set
	*/
	res = corosync_service_defaults_link_and_init (api);
	if (res == -1) {
	log_printf (LOGSYS_LEVEL_ERROR, "Could not initialize default services");
	corosync_exit_error (COROSYNC_DONE_INIT_SERVICES);
	}
	cs_ipcs_init();
	corosync_totem_stats_init ();
	corosync_fplay_control_init ();
	sync_init (
	corosync_sync_callbacks_retrieve,
	corosync_sync_completed);
	}

	static enum e_corosync_done corosync_flock (const char *lockfile, pid_t pid)
	{
	struct flock lock;
	enum e_corosync_done err;
	char pid_s[17];
	int fd_flag;
	int lf;

	err = COROSYNC_DONE_EXIT;

	lf = open (lockfile, O_WRONLY \| O_CREAT, 0640);
	if (lf == -1) {
	log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't create lock file.");
	return (COROSYNC_DONE_ACQUIRE_LOCK);
	}

	retry_fcntl:
	lock.l_type = F_WRLCK;
	lock.l_start = 0;
	lock.l_whence = SEEK_SET;
	lock.l_len = 0;
	if (fcntl (lf, F_SETLK, &lock) == -1) {
	switch (errno) {
	case EINTR:
	goto retry_fcntl;
	break;
	case EAGAIN:
	case EACCES:
	log_printf (LOGSYS_LEVEL_ERROR, "Another Corosync instance is already running.");
	err = COROSYNC_DONE_ALREADY_RUNNING;
	goto error_close;
	break;
	default:
	log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't acquire lock. Error was %s",
	strerror(errno));
	err = COROSYNC_DONE_ACQUIRE_LOCK;
	goto error_close;
	break;
	}
	}

	if (ftruncate (lf, 0) == -1) {
	log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't truncate lock file. Error was %s",
	strerror (errno));
	err = COROSYNC_DONE_ACQUIRE_LOCK;
	goto error_close_unlink;
	}

	memset (pid_s, 0, sizeof (pid_s));
	snprintf (pid_s, sizeof (pid_s) - 1, "%u\n", pid);

	retry_write:
	if (write (lf, pid_s, strlen (pid_s)) != strlen (pid_s)) {
	if (errno == EINTR) {
	goto retry_write;
	} else {
	log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't write pid to lock file. "
	"Error was %s", strerror (errno));
	err = COROSYNC_DONE_ACQUIRE_LOCK;
	goto error_close_unlink;
	}
	}

	if ((fd_flag = fcntl (lf, F_GETFD, 0)) == -1) {
	log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't get close-on-exec flag from lock file. "
	"Error was %s", strerror (errno));
	err = COROSYNC_DONE_ACQUIRE_LOCK;
	goto error_close_unlink;
	}
	fd_flag \|= FD_CLOEXEC;
	if (fcntl (lf, F_SETFD, fd_flag) == -1) {
	log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't set close-on-exec flag to lock file. "
	"Error was %s", strerror (errno));
	err = COROSYNC_DONE_ACQUIRE_LOCK;
	goto error_close_unlink;
	}

	return (err);

	error_close_unlink:
	unlink (lockfile);
	error_close:
	close (lf);

	return (err);
	}

	static int corosync_move_to_root_cgroup(void) {
	int res = -1;
	#ifdef HAVE_LIBCGROUP
	int cg_ret;
	struct cgroup *root_cgroup = NULL;
	struct cgroup_controller *root_cpu_cgroup_controller = NULL;
	char *current_cgroup_path = NULL;

	cg_ret = cgroup_init();
	if (cg_ret) {
	log_printf(LOGSYS_LEVEL_WARNING, "Unable to initialize libcgroup: %s ",
	cgroup_strerror(cg_ret));

	goto exit_res;
	}

	cg_ret = cgroup_get_current_controller_path(getpid(), "cpu", &current_cgroup_path);
	if (cg_ret) {
	log_printf(LOGSYS_LEVEL_WARNING, "Unable to get current cpu cgroup path: %s ",
	cgroup_strerror(cg_ret));

	goto exit_res;
	}

	if (strcmp(current_cgroup_path, "/") == 0) {
	log_printf(LOGSYS_LEVEL_DEBUG, "Corosync is already in root cgroup path");

	res = 0;
	goto exit_res;
	}

	root_cgroup = cgroup_new_cgroup("/");
	if (root_cgroup == NULL) {
	log_printf(LOGSYS_LEVEL_WARNING, "Can't create root cgroup");

	goto exit_res;
	}

	root_cpu_cgroup_controller = cgroup_add_controller(root_cgroup, "cpu");
	if (root_cpu_cgroup_controller == NULL) {
	log_printf(LOGSYS_LEVEL_WARNING, "Can't create root cgroup cpu controller");

	goto exit_res;
	}

	cg_ret = cgroup_attach_task(root_cgroup);
	if (cg_ret) {
	log_printf(LOGSYS_LEVEL_WARNING, "Can't attach task to root cgroup: %s ",
	cgroup_strerror(cg_ret));

	goto exit_res;
	}

	cg_ret = cgroup_get_current_controller_path(getpid(), "cpu", &current_cgroup_path);
	if (cg_ret) {
	log_printf(LOGSYS_LEVEL_WARNING, "Unable to get current cpu cgroup path: %s ",
	cgroup_strerror(cg_ret));

	goto exit_res;
	}

	if (strcmp(current_cgroup_path, "/") == 0) {
	log_printf(LOGSYS_LEVEL_NOTICE, "Corosync sucesfully moved to root cgroup");
	res = 0;
	} else {
	log_printf(LOGSYS_LEVEL_WARNING, "Can't move Corosync to root cgroup");
	}

	exit_res:
	if (root_cgroup != NULL) {
	cgroup_free(&root_cgroup);
	}

	/*
	* libcgroup doesn't define something like cgroup_fini so there is no way how to clean
	* it's cache. It has to be called when libcgroup authors decide to implement it.
	*/

	#endif
	return (res);
	}


	int main (int argc, char argv, char envp)
	{
	const char *error_string;
	struct totem_config totem_config;
	int res, ch;
	int background, sched_rr, prio, testonly, move_to_root_cgroup;
	struct stat stat_out;
	enum e_corosync_done flock_err;
	uint64_t totem_config_warnings;
	struct scheduler_pause_timeout_data scheduler_pause_timeout_data;
	long int tmpli;
	char *ep;

	/* default configuration
	*/
	background = 1;
	sched_rr = 1;
	prio = 0;
	testonly = 0;
	move_to_root_cgroup = 1;

	while ((ch = getopt (argc, argv, "fP:pRrtv")) != EOF) {

	switch (ch) {
	case 'f':
	background = 0;
	break;
	case 'p':
	sched_rr = 0;
	break;
	case 'P':
	if (strcmp(optarg, "max") == 0) {
	prio = INT_MIN;
	} else if (strcmp(optarg, "min") == 0) {
	prio = INT_MAX;
	} else {
	tmpli = strtol(optarg, &ep, 10);
	if (errno != 0 \|\| *ep != '\0' \|\| tmpli > INT_MAX \|\| tmpli < INT_MIN) {
	fprintf(stderr, "Priority value %s is invalid", optarg);
	logsys_system_fini();
	return EXIT_FAILURE;
	}

	prio = tmpli;
	}
	break;
	case 'R':
	move_to_root_cgroup = 0;
	break;
	case 'r':
	sched_rr = 1;
	break;
	case 't':
	testonly = 1;
	break;
	case 'v':
	printf ("Corosync Cluster Engine, version '%s'\n", VERSION);
	printf ("Copyright (c) 2006-2009 Red Hat, Inc.\n");
	logsys_system_fini();
	return EXIT_SUCCESS;

	break;
	default:
	fprintf(stderr, \
	"usage:\n"\
	" -f : Start application in foreground.\n"\
	" -p : Do not set realtime scheduling.\n"\
	" -r : Set round robin realtime scheduling (default).\n"\
	" -R : Do not try move corosync to root cpu cgroup (valid when built with libcgroup)\n" \
	" -P num : Set priority of process (no effect when -r is used)\n"\
	" -t : Test configuration and exit.\n"\
	" -v : Display version and SVN revision of Corosync and exit.\n");
	logsys_system_fini();
	return EXIT_FAILURE;
	}
	}


	/*
	* Other signals are registered later via qb_loop_signal_add
	*/
	(void)signal (SIGSEGV, sigsegv_handler);
	(void)signal (SIGABRT, sigsegv_handler);
	#if MSG_NOSIGNAL != 0
	(void)signal (SIGPIPE, SIG_IGN);
	#endif

	if (icmap_init() != CS_OK) {
	log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't initialize configuration component.");
	corosync_exit_error (COROSYNC_DONE_ICMAP);
	}
	set_icmap_ro_keys_flag();

	/*
	* Initialize the corosync_api_v1 definition
	*/
	api = apidef_get ();

	res = coroparse_configparse(icmap_get_global_map(), &error_string);
	if (res == -1) {
	/*
	* Logsys can't log properly at this early stage, and we need to get this message out
	*
	*/
	fprintf (stderr, "%s\n", error_string);
	syslog (LOGSYS_LEVEL_ERROR, "%s", error_string);
	corosync_exit_error (COROSYNC_DONE_MAINCONFIGREAD);
	}

	if (stats_map_init(api) != CS_OK) {
	fprintf (stderr, "Corosync Executive couldn't initialize statistics component.\n");
	syslog (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't initialize statistics component.");
	corosync_exit_error (COROSYNC_DONE_STATS);
	}

	res = corosync_log_config_read (&error_string);
	if (res == -1) {
	/*
	* if we are here, we _must_ flush the logsys queue
	* and try to inform that we couldn't read the config.
	* this is a desperate attempt before certain death
	* and there is no guarantee that we can print to stderr
	* nor that logsys is sending the messages where we expect.
	*/
	log_printf (LOGSYS_LEVEL_ERROR, "%s", error_string);
	fprintf(stderr, "%s", error_string);
	syslog (LOGSYS_LEVEL_ERROR, "%s", error_string);
	corosync_exit_error (COROSYNC_DONE_LOGCONFIGREAD);
	}

	if (!testonly) {
	log_printf (LOGSYS_LEVEL_NOTICE, "Corosync Cluster Engine ('%s'): started and ready to provide service.", VERSION);
	log_printf (LOGSYS_LEVEL_INFO, "Corosync built-in features:" PACKAGE_FEATURES "");
	}

	/*
	* Make sure required directory is present
	*/
	res = stat (get_run_dir(), &stat_out);
	if ((res == -1) \|\| (res == 0 && !S_ISDIR(stat_out.st_mode))) {
	log_printf (LOGSYS_LEVEL_ERROR, "Required directory not present %s. Please create it.", get_run_dir());
	corosync_exit_error (COROSYNC_DONE_DIR_NOT_PRESENT);
	}

	res = chdir(get_run_dir());
	if (res == -1) {
	log_printf (LOGSYS_LEVEL_ERROR, "Cannot chdir to run directory %s. "
	"Please make sure it has correct context and rights.", get_run_dir());
	corosync_exit_error (COROSYNC_DONE_DIR_NOT_PRESENT);
	}

	res = totem_config_read (&totem_config, &error_string, &totem_config_warnings);
	if (res == -1) {
	log_printf (LOGSYS_LEVEL_ERROR, "%s", error_string);
	corosync_exit_error (COROSYNC_DONE_MAINCONFIGREAD);
	}

	if (totem_config_warnings & TOTEM_CONFIG_WARNING_MEMBERS_IGNORED) {
	log_printf (LOGSYS_LEVEL_WARNING, "member section is used together with nodelist. Members ignored.");
	}

	if (totem_config_warnings & TOTEM_CONFIG_WARNING_MEMBERS_DEPRECATED) {
	log_printf (LOGSYS_LEVEL_WARNING, "member section is deprecated.");
	}

	if (totem_config_warnings & TOTEM_CONFIG_WARNING_TOTEM_NODEID_IGNORED) {
	log_printf (LOGSYS_LEVEL_WARNING, "nodeid appears both in totem section and nodelist. Nodelist one is used.");
	}

	if (totem_config_warnings & TOTEM_CONFIG_BINDNETADDR_NODELIST_SET) {
	log_printf (LOGSYS_LEVEL_WARNING, "interface section bindnetaddr is used together with nodelist. "
	"Nodelist one is going to be used.");
	}

	if (totem_config_warnings != 0) {
	log_printf (LOGSYS_LEVEL_WARNING, "Please migrate config file to nodelist.");
	}

	res = totem_config_keyread (&totem_config, &error_string);
	if (res == -1) {
	log_printf (LOGSYS_LEVEL_ERROR, "%s", error_string);
	corosync_exit_error (COROSYNC_DONE_MAINCONFIGREAD);
	}

	res = totem_config_validate (&totem_config, &error_string);
	if (res == -1) {
	log_printf (LOGSYS_LEVEL_ERROR, "%s", error_string);
	corosync_exit_error (COROSYNC_DONE_MAINCONFIGREAD);
	}

	if (testonly) {
	corosync_exit_error (COROSYNC_DONE_EXIT);
	}


	/*
	* Try to move corosync into root cpu cgroup. Failure is not fatal and
	* error is deliberately ignored.
	*/
	if (move_to_root_cgroup) {
	(void)corosync_move_to_root_cgroup();
	}

	/*
	* Set round robin realtime scheduling with priority 99
	*/
	if (sched_rr) {
	if (corosync_set_rr_scheduler () != 0) {
	prio = INT_MIN;
	} else {
	prio = 0;
	}
	}

	if (prio != 0) {
	if (setpriority(PRIO_PGRP, 0, prio) != 0) {
	LOGSYS_PERROR(errno, LOGSYS_LEVEL_WARNING,
	"Could not set priority %d", prio);
	}
	}

	ip_version = totem_config.ip_version;

	totem_config.totem_memb_ring_id_create_or_load = corosync_ring_id_create_or_load;
	totem_config.totem_memb_ring_id_store = corosync_ring_id_store;

	totem_config.totem_logging_configuration = totem_logging_configuration;
	totem_config.totem_logging_configuration.log_subsys_id = _logsys_subsys_create("TOTEM", "totem,"
	"totemip.c,totemconfig.c,totemcrypto.c,totemsrp.c,"
	"totempg.c,totemudp.c,totemudpu.c,totemnet.c,totemknet.c");

	totem_config.totem_logging_configuration.log_level_security = LOGSYS_LEVEL_WARNING;
	totem_config.totem_logging_configuration.log_level_error = LOGSYS_LEVEL_ERROR;
	totem_config.totem_logging_configuration.log_level_warning = LOGSYS_LEVEL_WARNING;
	totem_config.totem_logging_configuration.log_level_notice = LOGSYS_LEVEL_NOTICE;
	totem_config.totem_logging_configuration.log_level_debug = LOGSYS_LEVEL_DEBUG;
	totem_config.totem_logging_configuration.log_level_trace = LOGSYS_LEVEL_TRACE;
	totem_config.totem_logging_configuration.log_printf = _logsys_log_printf;

	logsys_config_apply();

	/*
	* Now we are fully initialized.
	*/
	if (background) {
	corosync_tty_detach ();
	}

	/*
	* Lock all memory to avoid page faults which may interrupt
	* application healthchecking
	*/
	corosync_mlockall ();

	corosync_poll_handle = qb_loop_create ();

	memset(&scheduler_pause_timeout_data, 0, sizeof(scheduler_pause_timeout_data));
	scheduler_pause_timeout_data.totem_config = &totem_config;
	timer_function_scheduler_timeout (&scheduler_pause_timeout_data);

	qb_loop_signal_add(corosync_poll_handle, QB_LOOP_LOW,
	SIGUSR2, NULL, sig_diag_handler, NULL);
	qb_loop_signal_add(corosync_poll_handle, QB_LOOP_HIGH,
	SIGINT, NULL, sig_exit_handler, NULL);
	qb_loop_signal_add(corosync_poll_handle, QB_LOOP_HIGH,
	SIGQUIT, NULL, sig_exit_handler, NULL);
	qb_loop_signal_add(corosync_poll_handle, QB_LOOP_HIGH,
	SIGTERM, NULL, sig_exit_handler, NULL);

	if (logsys_thread_start() != 0) {
	log_printf (LOGSYS_LEVEL_ERROR, "Can't initialize log thread");
	corosync_exit_error (COROSYNC_DONE_LOGCONFIGREAD);
	}

	if ((flock_err = corosync_flock (corosync_lock_file, getpid ())) != COROSYNC_DONE_EXIT) {
	corosync_exit_error (flock_err);
	}

	/*
	* if totempg_initialize doesn't have root priveleges, it cannot
	* bind to a specific interface. This only matters if
	* there is more then one interface in a system, so
	* in this case, only a warning is printed
	*/
	/*
	* Join multicast group and setup delivery
	* and configuration change functions
	*/
	if (totempg_initialize (
	corosync_poll_handle,
	&totem_config) != 0) {

	log_printf (LOGSYS_LEVEL_ERROR, "Can't initialize TOTEM layer");
	corosync_exit_error (COROSYNC_DONE_FATAL_ERR);
	}

	totempg_service_ready_register (
	main_service_ready);

	totempg_groups_initialize (
	&corosync_group_handle,
	deliver_fn,
	confchg_fn);

	totempg_groups_join (
	corosync_group_handle,
	&corosync_group,
	1);

	/*
	* Drop root privleges to user 'corosync'
	* TODO: Don't really need full root capabilities;
	* needed capabilities are:
	* CAP_NET_RAW (bindtodevice)
	* CAP_SYS_NICE (setscheduler)
	* CAP_IPC_LOCK (mlockall)
	*/
	priv_drop ();

	schedwrk_init (
	serialize_lock,
	serialize_unlock);

	/*
	* Start main processing loop
	*/
	qb_loop_run (corosync_poll_handle);

	/*
	* Exit was requested
	*/
	totempg_finalize ();

	/*
	* free the loop resources
	*/
	qb_loop_destroy (corosync_poll_handle);

	/*
	* free up the icmap
	*/

	/*
	* Remove pid lock file
	*/
	unlink (corosync_lock_file);

	corosync_exit_error (COROSYNC_DONE_EXIT);

	return EXIT_SUCCESS;
	}
	diff --git a/init/corosync.service.in b/init/corosync.service.in
	index 7733a98c..cc67284c 100644
	--- a/init/corosync.service.in
	+++ b/init/corosync.service.in
	@@ -1,26 +1,26 @@
	[Unit]
	Description=Corosync Cluster Engine
	Documentation=man:corosync man:corosync.conf man:corosync_overview
	ConditionKernelCommandLine=!nocluster
	Requires=network-online.target
	After=network-online.target

	[Service]
	-ExecStart=@INITWRAPPERSDIR@/corosync start
	-ExecStop=@INITWRAPPERSDIR@/corosync stop
	-Type=forking
	+EnvironmentFile=-@INITCONFIGDIR@/corosync
	+ExecStart=@SBINDIR@/corosync -f $OPTIONS
	+Type=notify

	# The following config is for corosync with enabled watchdog service.
	#
	# When corosync watchdog service is being enabled and using with
	# pacemaker.service, and if you want to exert the watchdog when a
	# corosync process is terminated abnormally,
	# uncomment the line of the following Restart= and RestartSec=.
	#Restart=on-failure
	# Specify a period longer than soft_margin as RestartSec.
	#RestartSec=70
	# rewrite according to environment.
	#ExecStartPre=/sbin/modprobe softdog

	[Install]
	WantedBy=multi-user.target

File Metadata

Mime Type: text/x-diff
Expires: Mon, Apr 21, 8:38 PM (4 h, 28 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1665730
Default Alt Text: (73 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions