No OneTemporary
Actions

Size

42 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/configure.ac b/configure.ac
	index 879ad15..ec9b35b 100644
	--- a/configure.ac
	+++ b/configure.ac
	@@ -1,890 +1,895 @@

	# Process this file with autoconf to produce a configure script.

	AC_PREREQ([2.69])

	dnl inject zero as a "patch" component of the version if missing in tag;
	dnl care to bump "X.Y.Z-yank" template below upon each release very desirable
	AC_INIT([libqb],
	m4_esyscmd([build-aux/git-version-gen $(echo '$Format:%h??%D$'\
	\| sed -ne 's/^[$]Format:[^$]*[$]$/.tarball-version/p;tend'\
	-e 's/.tag: v$[^, ][^, ]$.*/\1-yank/;tv'\
	-e 's/^$[[:xdigit:]][[:xdigit:]]$./1.9.0-yank\1/'\
	-e ':v' -e 'w .snapshot-version' -e 'i\
	.snapshot-version' -e ':end' -e 'q')\
	's/^$v[0-9][0-9]\.[0-9][0-9]$$[^.].*$\?$/\1.0\2/']),
	[developers@clusterlabs.org])
	AC_CONFIG_AUX_DIR([build-aux])
	AC_CONFIG_SRCDIR([lib/ringbuffer.c])
	AC_CONFIG_HEADERS([include/config.h include/qb/qbconfig.h])
	AC_USE_SYSTEM_EXTENSIONS

	AM_INIT_AUTOMAKE([-Wno-portability dist-xz subdir-objects])
	dnl automake >= 1.11 offers --enable-silent-rules for suppressing the output from
	dnl normal compilation. When a failure occurs, it will then display the full
	dnl command line
	dnl Wrap in m4_ifdef to avoid breaking on older platforms
	m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])])
	LT_PREREQ([2.2.6])
	# --enable-new-dtags: Use RUNPATH instead of RPATH.
	# It is necessary to have this done before libtool does linker detection.
	# See also: https://github.com/kronosnet/kronosnet/issues/107
	AX_CHECK_LINK_FLAG([-Wl,--enable-new-dtags],
	[AM_LDFLAGS=-Wl,--enable-new-dtags],
	[AC_MSG_ERROR(["Linker support for --enable-new-dtags is required"])])
	AC_SUBST([AM_LDFLAGS])
	saved_LDFLAGS="$LDFLAGS"
	LDFLAGS="$AM_LDFLAGS $LDFLAGS"
	LT_INIT
	LDFLAGS="$saved_LDFLAGS"

	AC_CONFIG_MACRO_DIR([m4])

	AC_CANONICAL_HOST
	LT_INIT
	AC_LANG([C])

	dnl Fix default variables - "prefix" variable if not specified
	if test "$prefix" = "NONE"; then
	prefix="/usr"
	if test "$localstatedir" = "\${prefix}/var"; then
	localstatedir="/var"
	fi
	if test "$sysconfdir" = "\${prefix}/etc"; then
	sysconfdir="/etc"
	fi
	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

	AC_PROG_CXX
	AM_CONDITIONAL(HAVE_GXX, [test "x$GXX" = xyes])
	AC_PROG_AWK
	AC_PROG_CC
	AC_PROG_CPP
	AM_PROG_CC_C_O
	m4_version_prereq([2.70], [:], [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_CHECK_PROGS([PKGCONFIG], [pkg-config])
	AC_CHECK_PROGS([DOXYGEN], [doxygen])
	AM_CONDITIONAL(HAVE_DOXYGEN, test -n "${DOXYGEN}")
	AC_CHECK_TOOLS([NM], [eu-nm nm], [:])
	AC_CHECK_TOOLS([READELF], [eu-readelf readelf], [:])
	AM_PATH_PYTHON([2.6],, [:])
	AM_CONDITIONAL([HAVE_PYTHON], [test "$PYTHON" != :])

	## local helper functions

	# this function checks if CC support options passed as
	# args. Global CFLAGS are ignored during this test.
	cc_supports_flag() {
	BACKUP="$CPPFLAGS"
	CPPFLAGS="$CPPFLAGS $@ -Werror"
	AC_MSG_CHECKING([whether $CC supports "$@"])
	AC_COMPILE_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
	NONE) exec_prefix=$prefix;;
	prefix) exec_prefix=$prefix;;
	esac

	# Checks for libraries.
	AX_PTHREAD(,[AC_MSG_ERROR([POSIX threads support is required])])
	AX_SAVE_FLAGS
	AC_SEARCH_LIBS([dlopen],[dl],,[AC_MSG_ERROR([cannot find dlopen() function])])
	AC_SUBST([dlopen_LIBS],[$LIBS])
	AX_RESTORE_FLAGS
	AX_SAVE_FLAGS
	AC_SEARCH_LIBS([socket], [socket],,[AC_MSG_ERROR([cannot find socket() function])])
	AC_SUBST([socket_LIBS],[$LIBS])
	AX_RESTORE_FLAGS
	AX_SAVE_FLAGS
	AC_SEARCH_LIBS([gethostbyname], [nsl],,[AC_MSG_ERROR([cannot find gethostbyname() function])])
	AC_SUBST([nsl_LIBS],[$LIBS])
	AX_RESTORE_FLAGS
	AX_SAVE_FLAGS
	AC_SEARCH_LIBS([clock_gettime], [rt],,[AC_MSG_ERROR([cannot find clock_gettime() function])])
	AC_SUBST([rt_LIBS],[$LIBS])
	AX_RESTORE_FLAGS

	USE_JOURNAL="no"
	PKG_CHECK_MODULES([SYSTEMD], [libsystemd], [have_systemd=yes],[have_systemd=no])
	if test "x$enable_systemd_journal" = "xyes" ; then
	if test "x$have_systemd" = "xyes" ; then
	AC_DEFINE_UNQUOTED(USE_JOURNAL, 1, [Use systemd journal logging])
	USE_JOURNAL="yes"
	else
	echo "systemd libraries not found, will just use syslog"
	fi
	fi

	# look for testing harness "check"
	PKG_CHECK_MODULES([CHECK], [check >= 0.9.4],[with_check=yes],[with_check=no])
	AM_CONDITIONAL(HAVE_CHECK, test "${with_check}" = "yes")

	# look for GLIB (used for testing integration)
	PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.0, have_glib=yes, have_glib=no)
	AM_CONDITIONAL(HAVE_GLIB, test x$have_glib = xyes)
	AC_SUBST(GLIB_CFLAGS)
	AC_SUBST(GLIB_LIBS)
	if test x"$have_glib" = xyes; then
	AC_DEFINE_UNQUOTED([HAVE_GLIB], [1], [We have glib])
	fi

	# For building doxygen2man and man pages
	PKG_CHECK_MODULES([libxml], [libxml-2.0])

	# if we are not cross-compiling, we can use the locally built
	# version of doxygen2man, otherwise we can look for
	# a locally installed version. If neither are usable, then
	# don´t build the man pages
	if test "x$cross_compiling" = "xno"; then
	AM_CONDITIONAL([BUILD_MAN], [true])
	DOXYGEN2MAN="\$(abs_builddir)/../doxygen2man/doxygen2man"
	else
	AC_CHECK_PROGS([DOXYGEN2MAN], [doxygen2man])
	if test "x$DOXYGEN2MAN" = "x"; then
	AM_CONDITIONAL([BUILD_MAN], [false])
	else
	AM_CONDITIONAL([BUILD_MAN], [true])
	fi
	fi
	AC_SUBST(DOXYGEN2MAN)

	# Checks for header files.
	AC_HEADER_SYS_WAIT

	AC_CHECK_HEADERS([arpa/inet.h link.h fcntl.h inttypes.h limits.h netinet/in.h \
	stdint.h stddef.h stdlib.h string.h strings.h \
	dlfcn.h time.h sys/time.h sys/types.h sys/stat.h \
	sys/param.h sys/socket.h sys/time.h sys/poll.h sys/epoll.h \
	sys/uio.h sys/event.h sys/sockio.h sys/un.h sys/resource.h \
	syslog.h errno.h unistd.h sys/mman.h \
	sys/sem.h sys/ipc.h sys/msg.h netdb.h])

	# Checks for typedefs, structures, and compiler characteristics.
	AC_TYPE_UID_T
	AC_C_INLINE
	AC_TYPE_INT32_T
	AC_TYPE_INT64_T
	AC_TYPE_INT8_T
	AC_TYPE_MODE_T
	AC_TYPE_PID_T
	AC_TYPE_SIZE_T
	AC_TYPE_SSIZE_T
	AC_TYPE_UINT64_T
	AC_TYPE_UINT32_T
	AC_TYPE_UINT16_T
	AC_TYPE_UINT8_T

	AC_CHECK_MEMBER([struct sockaddr_un.sun_len],
	[AC_DEFINE([HAVE_STRUCT_SOCKADDR_UN_SUN_LEN],
	1,
	[Define to 1 if struct sockaddr_un has a member sun_len])],
	[],
	[#include <sys/un.h>])

	AC_MSG_CHECKING(looking for union semun in sys/sem.h)
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/types.h>
	#include <sys/ipc.h>
	#include <sys/sem.h>]],
	[[union semun arg; semctl(0, 0, 0, arg);]])],
	[
	AC_MSG_RESULT([yes])
	AC_DEFINE_UNQUOTED([HAVE_SEMUN], 1, [Define to 1 if you have union semun.])
	],
	[
	AC_MSG_RESULT([no])
	]
	)

	# Checks for library functions
	AX_SAVE_FLAGS
	LIBS="$LIBS $rt_LIBS"
	AC_CHECK_FUNCS([clock_gettime])
	AX_RESTORE_FLAGS

	AC_FUNC_CHOWN
	AC_FUNC_FORK
	AC_FUNC_MMAP
	AC_FUNC_STRERROR_R
	AC_CHECK_FUNCS([alarm fsync fdatasync ftruncate posix_fallocate \
	gettimeofday localtime localtime_r \
	memset munmap socket \
	strchr strrchr strdup strstr strcasecmp \
	poll epoll_create epoll_create1 kqueue \
	random rand getrlimit sysconf \
	getpeerucred getpeereid \
	openat unlinkat])

	AX_SAVE_FLAGS
	CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
	LIBS="$LIBS $PTHREAD_LIBS"
	AC_CHECK_FUNCS([pthread_spin_lock pthread_setschedparam \
	pthread_mutexattr_setpshared \
	pthread_condattr_setpshared \
	sem_timedwait semtimedop])
	AX_RESTORE_FLAGS

	# Checks for defined macros
	AC_MSG_CHECKING(for MSG_NOSIGNAL)
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/socket.h>]],
	[[ int f = MSG_NOSIGNAL; ]])],
	[ AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_MSG_NOSIGNAL, 1,
	[Define this symbol if you have MSG_NOSIGNAL])],
	[ AC_MSG_RESULT(no)])

	AC_MSG_CHECKING(for SO_NOSIGPIPE )
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/socket.h>]],
	[[ int f = SO_NOSIGPIPE; ]])],
	[ AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_SO_NOSIGPIPE, 1,
	[Define this symbol if you have SO_NOSIGPIPE]) ],
	[ AC_MSG_RESULT(no)])
	AC_MSG_CHECKING([for RTLD_NEXT])
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#ifndef _GNU_SOURCE
	#define _GNU_SOURCE
	#endif
	#include <dlfcn.h>]],
	[[ void *h = RTLD_NEXT; ]])],
	[ AC_MSG_RESULT([yes])
	AC_DEFINE([HAVE_FAILURE_INJECTION], 1,
	[have failure injection])
	have_RTLD_NEXT=yes ],
	[ AC_MSG_RESULT([no])])


	AM_CONDITIONAL(HAVE_SEM_TIMEDWAIT,
	[test "x$ac_cv_func_sem_timedwait" = xyes])
	AM_CONDITIONAL(HAVE_EPOLL,
	[test "x$ac_cv_func_epoll_create" = xyes])
	AM_CONDITIONAL(HAVE_POLL,
	[test "x$ac_cv_func_poll" = xyes])
	AM_CONDITIONAL(HAVE_KQUEUE,
	[test "x$ac_cv_func_kqueue" = xyes])
	AM_CONDITIONAL(HAVE_FAILURE_INJECTION,
	[test "x$have_RTLD_NEXT" = xyes])

	AC_CONFIG_LIBOBJ_DIR(lib)
	AC_REPLACE_FUNCS(strlcpy strlcat strchrnul)

	## local defines
	PACKAGE_FEATURES=""

	if test x$ac_cv_func_epoll_create = xyes; then
	PACKAGE_FEATURES="$PACKAGE_FEATURES epoll"
	fi

	nongcc_memory_barrier_needed=no
	arch_force_shmlba=no
	file_sync=fdatasync
	AC_MSG_CHECKING([for architecture in ${host_cpu}])
	case $host_cpu in
	sparc*)
	AC_MSG_RESULT([sparc])
	AC_DEFINE_UNQUOTED([QB_ARCH_SPARC], [1], [sparc])
	nongcc_memory_barrier_needed=yes
	arch_force_shmlba=yes
	;;
	alpha*)
	AC_MSG_RESULT([alpha])
	AC_DEFINE_UNQUOTED([QB_ARCH_ALPHA], [1], [alpha])
	nongcc_memory_barrier_needed=yes
	;;
	powerpc*)
	AC_MSG_RESULT([powerpc])
	AC_DEFINE_UNQUOTED([QB_ARCH_POWERPC], [1], [powerpc])
	nongcc_memory_barrier_needed=yes
	arch_force_shmlba=yes
	;;
	ia64)
	AC_MSG_RESULT([ia64])
	AC_DEFINE_UNQUOTED([QB_ARCH_IA64], [1], [ia64])
	nongcc_memory_barrier_needed=yes
	;;
	arm*)
	AC_MSG_RESULT([arm])
	AC_DEFINE_UNQUOTED([QB_ARCH_ARM], [1], [arm])
	arch_force_shmlba=yes
	;;
	hppa*)
	AC_MSG_RESULT([hppa])
	AC_DEFINE_UNQUOTED([QB_ARCH_HPPA], [1], [hppa])
	;;
	mips*)
	AC_MSG_RESULT([ia64])
	AC_DEFINE_UNQUOTED([QB_ARCH_MIPS], [1], [mips])
	arch_force_shmlba=yes
	;;
	+ loongson*)
	+ AC_MSG_RESULT([loongson])
	+ AC_DEFINE_UNQUOTED([QB_ARCH_LOONGSON], [1], [loongson])
	+ arch_force_shmlba=yes
	+ ;;
	*)
	AC_MSG_RESULT([${host_cpu}])
	;;
	esac

	if test $arch_force_shmlba = yes; then
	AC_DEFINE_UNQUOTED([QB_FORCE_SHM_ALIGN], [1],
	[shared and fixed mmap must align on 16k])
	fi

	# OS detection
	# THIS SECTION MUST DIE!
	CP=cp
	AC_MSG_CHECKING([for os in ${host_os}])
	case "$host_os" in
	linux)
	AC_DEFINE_UNQUOTED([QB_LINUX], [1],
	[Compiling for Linux platform])
	AC_MSG_RESULT([Linux])
	;;
	cygwin)
	AC_DEFINE_UNQUOTED([QB_CYGWIN], [1],
	[Compiling for Cygwin platform])
	nongcc_memory_barrier_needed=yes
	gcc_has_builtin_sync_operations=no
	AC_MSG_RESULT([Cygwin])
	;;
	darwin*)
	AC_DEFINE_UNQUOTED([QB_DARWIN], [1],
	[Compiling for Darwin platform])
	CP=rsync
	dnl Attribute section appears to work here but fails later with:
	dnl cc1: error in backend: Global variable 'descriptor.4902'
	dnl has an invalid section specifier '__verbose': mach-o
	dnl section specifier requires a segment and section
	dnl separated by a comma
	AC_DEFINE_UNQUOTED([DISABLE_POSIX_THREAD_PROCESS_SHARED], [1],
	[Disable _POSIX_THREAD_PROCESS_SHARED])
	AC_MSG_RESULT([Darwin])
	;;
	bsd)
	AC_DEFINE_UNQUOTED([QB_BSD], [1],
	[Compiling for BSD platform])
	case "$host_os" in
	netbsd)
	AC_DEFINE_UNQUOTED([UNIX_PATH_MAX], [103],
	[Unix path length])
	;;
	openbsd)
	AC_DEFINE_UNQUOTED([UNIX_PATH_MAX], [104],
	[Unix path length])
	;;
	esac
	AC_MSG_RESULT([BSD])
	;;
	solaris)
	AC_DEFINE_UNQUOTED(DISABLE_IPC_SHM, 1,
	[Disable shared mem ipc])
	AC_DEFINE_UNQUOTED([QB_SOLARIS], [1],
	[Compiling for Solaris platform])
	CP=rsync
	AC_MSG_RESULT([Solaris])
	;;
	gnu)
	AC_DEFINE_UNQUOTED([QB_GNU], [1],
	[Compiling for GNU/Hurd platform])
	AC_MSG_RESULT([GNU])
	;;
	*)
	AC_MSG_ERROR([Unsupported OS? hmmmm])
	;;
	esac

	dnl break on first hit, fallthrough otherwise, until empty or unsupported
	dnl string reached; output QB_FILE_SYNC macro operates on a file descriptor
	while : ; do
	case ${file_sync} in
	fdatasync)
	test "x${ac_cv_func_fdatasync}" = "xno" \|\| break
	file_sync=fsync

	dnl Darwin provides the function but doesn't have it in headers
	case "$host_os" in
	darwin*)
	AH_BOTTOM([int fdatasync(int fildes);])
	;;
	esac
	;;
	fsync)
	test "x${ac_cv_func_fsync}" = "xno" \|\| break
	file_sync=;;
	"")
	break;;
	*)
	AC_MSG_ERROR([Cannot select file sync method]);;
	esac
	done
	if test "x${file_sync}" != x; then
	AC_DEFINE_UNQUOTED([QB_FILE_SYNC(fd)], [${file_sync}(fd)], [File sync method])
	else
	AC_MSG_WARN([No file sync method applicable!])
	AC_DEFINE([QB_FILE_SYNC(x)], [], [File sync method])
	fi

	AC_MSG_CHECKING([whether GCC supports builtin sync intrinsics])
	if test -z "$gcc_has_builtin_sync_operations"; then
	gcc_has_builtin_sync_operations=no
	if test x"$GCC" = xyes && test x$have_mingw != xyes; then
	AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],
	[[int i;
	__sync_synchronize ();
	__sync_bool_compare_and_swap (&i, 0, 1);
	__sync_fetch_and_add (&i, 1);
	]])],
	[gcc_has_builtin_sync_operations=yes],
	[gcc_has_builtin_sync_operations=no])
	fi
	fi
	AC_MSG_RESULT($gcc_has_builtin_sync_operations)
	AM_CONDITIONAL(HAVE_GCC_BUILTINS_FOR_SYNC_OPERATIONS,
	[test "x$gcc_has_builtin_sync_operations" = xyes])

	if test "x$gcc_has_builtin_sync_operations" = xyes; then
	AC_DEFINE_UNQUOTED(HAVE_GCC_BUILTINS_FOR_SYNC_OPERATIONS, 1,
	[have builtin sync operations])
	fi

	# __atomic_XXX
	AC_MSG_CHECKING([whether GCC supports builtin atomic intrinsics])
	if test -z "$gcc_has_builtin_atomic_operations"; then
	gcc_has_builtin_atomic_operations=no
	if test x"$GCC" = xyes && test x$have_mingw != xyes; then
	AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],
	[[int i;
	__atomic_load_n(&i, __ATOMIC_ACQUIRE);
	__atomic_exchange_n(&i, 0, __ATOMIC_RELEASE);
	]])],
	[gcc_has_builtin_atomic_operations=yes],
	[gcc_has_builtin_atomic_operations=no])
	fi
	fi
	AC_MSG_RESULT($gcc_has_builtin_atomic_operations)
	AM_CONDITIONAL(HAVE_GCC_BUILTINS_FOR_ATOMIC_OPERATIONS,
	[test "x$gcc_has_builtin_atomic_operations" = xyes])

	if test "x$gcc_has_builtin_atomic_operations" = xyes; then
	AC_DEFINE_UNQUOTED(HAVE_GCC_BUILTINS_FOR_ATOMIC_OPERATIONS, 1,
	[have builtin atomic operations])
	fi


	AC_MSG_CHECKING([whether atomics need memory barrier])
	if test -n "$ac_cv_atomic_need_memory_barrier"; then
	memory_barrier_needed=$ac_cv_atomic_need_memory_barrier
	else
	if test x$gcc_has_builtin_sync_operations = xyes; then
	memory_barrier_needed=yes
	PACKAGE_FEATURES="$PACKAGE_FEATURES gcc__sync"
	else
	memory_barrier_needed=$nongcc_memory_barrier_needed
	AC_MSG_WARN([-----------------------------])
	AC_MSG_WARN([You have gcc but not __sync_bool_compare_and_swap])
	AC_MSG_WARN([try CFLAGS="-march=<your arch> -mtune=native" ./configure])
	AC_MSG_WARN([-----------------------------])
	fi
	fi
	AC_MSG_RESULT($memory_barrier_needed)

	if test x"$memory_barrier_needed" != xno; then
	AC_DEFINE_UNQUOTED(QB_ATOMIC_OP_MEMORY_BARRIER_NEEDED, 1,
	[need atomic memory barrier])
	fi

	LINT_FLAGS="-weak -D__gnuc_va_list=va_list -D__attribute$x$= \
	-badflag -fcnuse -syntax -unrecog -sysunrecog -warnposix \
	+ignoresigns +matchanyintegral +posixlib \
	+showscan +showsummary"

	# local options
	AC_ARG_ENABLE([ansi],
	[AS_HELP_STRING([--enable-ansi],[force to build with ANSI standards])])

	AC_ARG_ENABLE([fatal-warnings],
	[AS_HELP_STRING([--enable-fatal-warnings],[enable fatal warnings])])

	AC_ARG_ENABLE([debug],
	[AS_HELP_STRING([--enable-debug],[enable debug build])])

	AC_ARG_WITH([sanitizers],
	[AS_HELP_STRING([--with-sanitizers=...,...],
	[enable SANitizer build, do NOT use for production. Only ASAN/UBSAN/TSAN are currently supported])],
	[ SANITIZERS="$withval" ],
	[ SANITIZERS="" ])

	AC_ARG_ENABLE([coverage],
	[AS_HELP_STRING([--enable-coverage],[coverage analysis of the codebase])])

	AC_ARG_ENABLE([interlib-deps],
	[AS_HELP_STRING([--disable-interlib-deps],
	[disable inter-library dependencies (might break builds)])])

	AC_ARG_ENABLE([slow-tests],
	[AS_HELP_STRING([--enable-slow-tests],[build and run slow tests])])

	AC_ARG_WITH([socket-dir],
	[AS_HELP_STRING([--with-socket-dir=DIR],[socket directory @<:@LOCALSTATEDIR/run@:>@])],
	[ SOCKETDIR="$withval" ],
	[ SOCKETDIR="$localstatedir/run" ])

	AC_ARG_ENABLE([systemd-journal],
	[AS_HELP_STRING([--enable-systemd-journal],[Allow use of systemd journal instead of syslog])])

	AC_ARG_WITH([force-sockets-config-file],
	[AS_HELP_STRING([--with-force-sockets-config-file=FILE],[config file to force IPC to use filesystem sockets (Linux & Cygwin only) @<:@SYSCONFDIR/libqb/force-filesystem-sockets@:>@])],
	[ FORCESOCKETSFILE="$withval" ],
	[ FORCESOCKETSFILE="$sysconfdir/libqb/force-filesystem-sockets" ])

	AC_ARG_ENABLE([tests],
	[AS_HELP_STRING([--disable-tests],[disable tests])],,
	[ enable_tests="yes" ])
	AM_CONDITIONAL([ENABLE_TESTS], [test x$enable_tests = xyes])

	AC_ARG_ENABLE([install-tests],
	[AS_HELP_STRING([--enable-install-tests],[install tests])],,
	[ enable_install_tests="no" ])
	AM_CONDITIONAL([INSTALL_TESTS], [test x$enable_install_tests = xyes])

	AC_ARG_WITH([testdir],
	[AS_HELP_STRING([--with-testdir=DIR],[path to /usr/lib../libqb/tests/ dir where to install the test suite])],
	[ TESTDIR="$withval" ],
	[ TESTDIR="$libdir/libqb/tests" ])
	AC_SUBST([TESTDIR])

	AC_SUBST(CP)
	# *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"
	if test "x${GCC}" = xyes; then
	GDB_FLAGS="-ggdb3"
	else
	GDB_FLAGS="-g"
	fi
	PACKAGE_FEATURES="$PACKAGE_FEATURES debug"
	fi

	# extra warnings
	EXTRA_WARNINGS=""

	WARNLIST="
	all
	extra
	unused
	shadow
	missing-prototypes
	missing-declarations
	suggest-attribute=noreturn
	suggest-attribute=format
	property-attribute-mismatch
	strict-prototypes
	pointer-arith
	write-strings
	cast-align
	bad-function-cast
	missing-format-attribute
	float-equal
	format=2
	format-signedness
	shift-overflow
	shift-overflow=2
	overlength-strings
	redundent-decls
	init-self
	uninitialized
	unknown-pragmas
	no-unused-parameter
	unused-const-variable
	no-format-nonliteral
	no-format-truncation
	no-sign-compare
	"
	# at least no-sign-compare assumed temporary!

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

	# warnings suppression
	gcc_format_complaints=no
	if test x"$GCC" = xyes && cc_supports_flag -Wmissing-format-attribute; then
	gcc_format_complaints=yes
	AC_DEFINE([HAVE_GCC_MISSING_FORMAT_ATTRIBUTE], [],
	[gcc supports -Wmissing-format-attribute])
	fi
	if test x"$GCC" = xyes && cc_supports_flag -Wsuggest-attribute=format; then
	gcc_format_complaints=yes
	AC_DEFINE([HAVE_GCC_SUGGEST_ATTRIBUTE_FORMAT], [],
	[gcc supports -Wsuggest-attribute=format])
	fi
	dnl pretend GCC (<4.6) is not capable of format complaints when it does not
	dnl support diagnostic push/pop pragmas (cannot track state reliably, then)
	if test x"$gcc_format_complaints" = xyes; then
	backup_CFLAGS="$CFLAGS"
	CFLAGS="$CFLAGS -Werror"
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	#pragma GCC diagnostic push
	#pragma GCC diagnostic pop
	]])], AC_DEFINE([HAVE_GCC_FORMAT_COMPLAINTS], [],
	[gcc can complain about missing format attribute]))
	CFLAGS="$backup_CFLAGS"
	fi

	# --- coverage ---
	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

	# --- inter-library dependencies ---
	# because of debian/ubuntu swimming against the stream
	# https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=702737,
	# override the libtool variable by force because the current
	# arrangement relies on transitive dependency propagation
	AC_MSG_NOTICE([Enabling inter-library dependencies: $enable_interlib_deps])
	if test "x${enable_interlib_deps}" = xno; then
	link_all_deplibs=no
	else
	link_all_deplibs=yes
	fi

	# --- slow tests ---
	if test "x${enable_slow_tests}" = xyes ; then
	AC_DEFINE([HAVE_SLOW_TESTS], 1,[have slow tests])
	AC_MSG_NOTICE([Enabling Slow tests])
	fi
	AM_CONDITIONAL(HAVE_SLOW_TESTS, [test "x${enable_slow_tests}" = xyes])
	AC_SUBST(HAVE_SLOW_TESTS)

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

	# --- fatal warnings ---
	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

	# --- ASAN/UBSAN/TSAN (see man gcc) ---
	# when using SANitizers, we need to pass the -fsanitize..
	# to both CFLAGS and LDFLAGS. The CFLAGS/LDFLAGS must be
	# specified as first in the list or there will be runtime
	# issues (for example user has to LD_PRELOAD asan for it to work
	# properly).

	if test -n "${SANITIZERS}"; then
	SANITIZERS=$(echo $SANITIZERS \| sed -e 's/,/ /g')
	for SANITIZER in $SANITIZERS; do
	case $SANITIZER in
	asan\|ASAN)
	SANITIZERS_CFLAGS="$SANITIZERS_CFLAGS -fsanitize=address"
	SANITIZERS_LDFLAGS="$SANITIZERS_LDFLAGS -fsanitize=address -lasan"
	AC_CHECK_LIB([asan],[main],,AC_MSG_ERROR([Unable to find libasan]))
	;;
	ubsan\|UBSAN)
	SANITIZERS_CFLAGS="$SANITIZERS_CFLAGS -fsanitize=undefined"
	SANITIZERS_LDFLAGS="$SANITIZERS_LDFLAGS -fsanitize=undefined -lubsan"
	AC_CHECK_LIB([ubsan],[main],,AC_MSG_ERROR([Unable to find libubsan]))
	;;
	tsan\|TSAN)
	SANITIZERS_CFLAGS="$SANITIZERS_CFLAGS -fsanitize=thread"
	SANITIZERS_LDFLAGS="$SANITIZERS_LDFLAGS -fsanitize=thread -ltsan"
	AC_CHECK_LIB([tsan],[main],,AC_MSG_ERROR([Unable to find libtsan]))
	;;
	esac
	done
	fi

	# final build of *FLAGS
	CFLAGS="$SANITIZERS_CFLAGS $ENV_CFLAGS $OPT_CFLAGS $GDB_FLAGS \
	$COVERAGE_CFLAGS $EXTRA_WARNINGS $WERROR_CFLAGS"
	CPPFLAGS="$ENV_CPPFLAGS $ANSI_CPPFLAGS"
	LDFLAGS="$SANITIZERS_LDFLAGS $ENV_LDFLAGS $COVERAGE_LDFLAGS"

	if test -f /usr/share/dict/words ; then
	HAVE_DICT_WORDS=yes
	AC_DEFINE([HAVE_DICT_WORDS], 1, "Have /usr/share/dict/words")
	fi
	AM_CONDITIONAL([HAVE_DICT_WORDS], [test "x$HAVE_DICT_WORDS" = xyes])

	# substitute what we need:
	AC_SUBST([SOCKETDIR])
	AC_SUBST([LINT_FLAGS])
	AC_SUBST([FORCESOCKETSFILE])

	AC_DEFINE_UNQUOTED([SOCKETDIR], "$(eval echo ${SOCKETDIR})", [Socket directory])
	AC_DEFINE_UNQUOTED([LOCALSTATEDIR], "$(eval echo ${localstatedir})", [localstate directory])
	AC_DEFINE_UNQUOTED([PACKAGE_FEATURES], "${PACKAGE_FEATURES}", [quarterback built-in features])
	AC_DEFINE_UNQUOTED([FORCESOCKETSFILE], "$(eval echo ${FORCESOCKETSFILE})", [for sockets config file])

	# version parsing (for qbconfig.h)
	AC_DEFINE_UNQUOTED([QB_VER_MAJOR],
	[$(echo "${VERSION}" \
	\| sed -e 's\|^$[[0-9]][[0-9]]$.\|\1\|' \
	-e t -e 's\|.*\|1\|')],
	[libqb major version])
	AC_DEFINE_UNQUOTED([QB_VER_MINOR],
	[$(echo "${VERSION}" \
	\| sed -e 's\|^[[0-9]][[0-9]]\.$[[0-9]][[0-9]]$.*\|\1\|' \
	-e t -e 's\|.*\|0\|')],
	[libqb minor version])
	AC_DEFINE_UNQUOTED([QB_VER_MICRO],
	[$(echo "${VERSION}" \
	\| sed -e 's\|^[[0-9]][[0-9]]\.[[0-9]][[0-9]]\.$[[0-9]][[0-9]]$.\|\1\|' \
	-e t -e 's\|.*\|0\|')],
	[libqb patch version])
	AC_DEFINE_UNQUOTED([QB_VER_REST],
	[$(echo "${VERSION}" \
	\| sed -e 's\|^[[0-9]][[0-9]]$\.[[0-9]][[0-9]]$\{0,2\}$.*$\|"\2"\|' \
	-e t -e 's\|.*\|""\|')],
	[libqb patch version])

	AX_PROG_DATE
	AS_IF([test "$ax_cv_prog_date_gnu_date:$ax_cv_prog_date_gnu_utc" = yes:yes],
	[UTC_DATE_AT="date -u -d@"],
	[AS_IF([test "x$ax_cv_prog_date_bsd_date" = xyes],
	[UTC_DATE_AT="date -u -r"],
	[AC_MSG_ERROR([date utility unable to convert epoch to UTC])])])
	AC_SUBST([UTC_DATE_AT])

	AC_ARG_VAR([SOURCE_EPOCH],[last modification date of the source])
	AC_MSG_NOTICE([trying to determine source epoch])
	AC_MSG_CHECKING([for source epoch in \$SOURCE_EPOCH])
	AS_IF([test -n "$SOURCE_EPOCH"],
	[AC_MSG_RESULT([yes])],
	[AC_MSG_RESULT([no])
	AC_MSG_CHECKING([for source epoch in source_epoch file])
	AS_IF([test -e "$srcdir/source_epoch"],
	[read SOURCE_EPOCH <"$srcdir/source_epoch"
	AC_MSG_RESULT([yes])],
	[AC_MSG_RESULT([no])
	AC_MSG_CHECKING([for source epoch baked in by gitattributes export-subst])
	SOURCE_EPOCH='$Format:%ct$' # template for rewriting by git-archive
	AS_CASE([$SOURCE_EPOCH],
	[?Format:*], # was not rewritten
	[AC_MSG_RESULT([no])
	AC_MSG_CHECKING([for source epoch in \$SOURCE_DATE_EPOCH])
	AS_IF([test "x$SOURCE_DATE_EPOCH" != x],
	[SOURCE_EPOCH="$SOURCE_DATE_EPOCH"
	AC_MSG_RESULT([yes])],
	[AC_MSG_RESULT([no])
	AC_MSG_CHECKING([whether git log can provide a source epoch])
	SOURCE_EPOCH=f${SOURCE_EPOCH#\$F} # convert into git log --pretty format
	SOURCE_EPOCH=$(cd "$srcdir" && git log -1 --pretty=${SOURCE_EPOCH%$} 2>/dev/null)
	AS_IF([test -n "$SOURCE_EPOCH"],
	[AC_MSG_RESULT([yes])],
	[AC_MSG_RESULT([no, using current time and breaking reproducibility])
	SOURCE_EPOCH=$(date +%s)])])],
	[AC_MSG_RESULT([yes])]
	)])
	])
	AC_MSG_NOTICE([using source epoch $($UTC_DATE_AT$SOURCE_EPOCH +'%F %T %Z')])

	AC_CONFIG_FILES([Makefile
	include/Makefile
	include/qb/Makefile
	lib/Makefile
	lib/libqb.pc
	tools/Makefile
	tests/Makefile
	tests/test.conf
	examples/Makefile
	doxygen2man/Makefile
	docs/Makefile
	docs/man.dox
	lib/qblog_script.la:lib/qblog_script.la.in])

	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([ SOCKETDIR = ${SOCKETDIR}])
	AC_MSG_RESULT([ Features = ${PACKAGE_FEATURES}])
	AC_MSG_RESULT([ Use systemd journal = ${USE_JOURNAL}])
	AC_MSG_RESULT([])
	AC_MSG_RESULT([$PACKAGE build info:])
	AC_MSG_RESULT([ Optimization = ${OPT_CFLAGS}])
	AC_MSG_RESULT([ 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/lib/unix.c b/lib/unix.c
	index 6bd3cc2..0dc7647 100644
	--- a/lib/unix.c
	+++ b/lib/unix.c
	@@ -1,617 +1,617 @@
	/*
	* Copyright (C) 2011 Red Hat, Inc.
	*
	* All rights reserved.
	*
	* Author: Angus Salkeld <asalkeld@redhat.com>
	*
	* libqb is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Lesser General Public License as published by
	* the Free Software Foundation, either version 2.1 of the License, or
	* (at your option) any later version.
	*
	* libqb is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public License
	* along with libqb. If not, see <http://www.gnu.org/licenses/>.
	*/
	#include "os_base.h"

	#ifdef HAVE_SYS_SHM_H
	#include <sys/shm.h>
	#endif
	#ifdef HAVE_SYS_MMAN_H
	#include <sys/mman.h>
	#endif
	#if defined(HAVE_FCNTL_H) && defined(HAVE_POSIX_FALLOCATE)
	#include <fcntl.h>
	#endif

	#include "util_int.h"
	#include <qb/qbdefs.h>
	#include <qb/qbutil.h>
	#include <qb/qbatomic.h>

	#if defined(MAP_ANON) && ! defined(MAP_ANONYMOUS)
	/*
	* BSD derivatives usually have MAP_ANON, not MAP_ANONYMOUS
	**/
	#define MAP_ANONYMOUS MAP_ANON
	#endif


	char *
	qb_strerror_r(int errnum, char *buf, size_t buflen)
	{
	#ifdef STRERROR_R_CHAR_P
	return strerror_r(errnum, buf, buflen);
	#else
	if (strerror_r(errnum, buf, buflen) != 0) {
	buf[0] = '\0';
	}
	return buf;
	#endif /* STRERROR_R_CHAR_P */
	}

	static int32_t
	open_mmap_file(char *path, uint32_t file_flags)
	{
	if (strstr(path, "XXXXXX") != NULL) {
	mode_t old_mode = umask(077);
	int32_t temp_fd = mkstemp(path);
	(void)umask(old_mode);
	return temp_fd;
	}

	return open(path, file_flags, 0600);
	}

	#if defined(QB_BSD) \|\| !defined(HAVE_POSIX_FALLOCATE)
	static int local_fallocate(int fd, size_t bytes)
	{
	long page_size = sysconf(_SC_PAGESIZE);
	long write_size = QB_MIN(page_size, bytes);
	char *buffer = NULL;
	int i;
	size_t written;

	if (page_size < 0) {
	goto error_exit;
	}
	buffer = calloc(1, write_size);
	if (buffer == NULL) {
	goto error_exit;
	}

	for (i = 0; i < (bytes / write_size); i++) {
	retry_write:
	written = write(fd, buffer, write_size);
	if (written == -1 && errno == EINTR) {
	goto retry_write;
	}
	if (written != write_size) {
	free(buffer);
	errno = ENOSPC;
	goto error_exit;
	}
	}
	free(buffer);

	return 0;

	error_exit:
	return -1;
	}
	#endif

	int32_t
	qb_sys_mmap_file_open(char path, const char file, size_t bytes,
	uint32_t file_flags)
	{
	int32_t fd;
	int32_t res = 0;
	#ifndef HAVE_POSIX_FALLOCATE
	ssize_t written;
	char *buffer = NULL;
	int32_t i;
	#endif
	char *is_absolute = strchr(file, '/');
	#ifdef HAVE_POSIX_FALLOCATE
	int32_t fallocate_retry = 5;
	#endif

	if (is_absolute) {
	(void)strlcpy(path, file, PATH_MAX);
	} else {
	#if defined(QB_LINUX) \|\| defined(QB_CYGWIN)
	/* This is only now called when talking to an old libqb
	where we need to add qb- to the name */
	snprintf(path, PATH_MAX, "/dev/shm/qb-%s", file);
	#else
	snprintf(path, PATH_MAX, "%s/%s", SOCKETDIR, file);
	is_absolute = path;
	#endif
	}
	fd = open_mmap_file(path, file_flags);
	if (fd < 0 && !is_absolute) {
	qb_util_perror(LOG_ERR, "couldn't open file %s", path);

	snprintf(path, PATH_MAX, "%s/%s", SOCKETDIR, file);
	fd = open_mmap_file(path, file_flags);
	if (fd < 0) {
	res = -errno;
	qb_util_perror(LOG_ERR, "couldn't open file %s", path);
	return res;
	}
	} else if (fd < 0 && is_absolute) {
	res = -errno;
	qb_util_perror(LOG_ERR, "couldn't open file %s", path);
	return res;
	}

	#ifndef _WIN32
	/* ftruncate not supported on WSL
	https://github.com/microsoft/WSL/issues/902 */
	if (ftruncate(fd, bytes) == -1) {
	res = -errno;
	qb_util_perror(LOG_ERR, "couldn't truncate file %s", path);
	goto unlink_exit;
	}
	#endif
	#ifdef HAVE_POSIX_FALLOCATE
	/* posix_fallocate(3) can be interrupted by a signal,
	so retry few times before giving up */
	do {
	fallocate_retry--;
	res = posix_fallocate(fd, 0, bytes);
	if (res == EINTR) {
	qb_util_log(LOG_DEBUG, "got EINTR trying to allocate file %s, retrying...", path);
	continue;
	#ifdef QB_BSD
	} else if (res == EINVAL) { /* posix_fallocate() fails on ZFS
	https://lists.freebsd.org/pipermail/freebsd-current/2018-February/068448.html */
	qb_util_log(LOG_DEBUG, "posix_fallocate returned EINVAL - running on ZFS?");
	if (file_flags & O_CREAT) {
	if (local_fallocate(fd, bytes)) {
	goto unlink_exit;
	}
	}
	#endif
	} else if (res != 0) {
	errno = res;
	res = -1 * res;
	qb_util_perror(LOG_ERR, "couldn't allocate file %s", path);
	goto unlink_exit;
	}
	break;
	} while (fallocate_retry > 0);
	#else
	if (file_flags & O_CREAT) {
	if (local_fallocate(fd, bytes)) {
	goto unlink_exit;
	}
	}
	#endif /* HAVE_POSIX_FALLOCATE */

	return fd;

	unlink_exit:
	unlink(path);
	if (fd >= 0) {
	close(fd);
	}
	return res;
	}


	int32_t
	qb_sys_circular_mmap(int32_t fd, void **buf, size_t bytes)
	{
	void *addr_orig = NULL;
	void *addr;
	void *addr_next;
	int32_t res;
	int flags = MAP_ANONYMOUS;

	#ifdef QB_FORCE_SHM_ALIGN
	/* On a number of arches any fixed and shared mmap() mapping address
	* must be aligned to 16k. If the first mmap() below is not shared then
	* the first mmap() will succeed because these restrictions do not apply to
	* private mappings. The second mmap() wants a shared memory mapping but
	* the address returned by the first one is only page-aligned and not
	* aligned to 16k.
	*/
	flags \|= MAP_SHARED;
	#else
	flags \|= MAP_PRIVATE;
	#endif /* QB_FORCE_SHM_ALIGN */

	-#if defined(QB_ARCH_HPPA)
	+#if defined(QB_ARCH_HPPA) \|\| defined(QB_ARCH_LOONGSON)
	/* map twice the size we want to make sure we have already mapped
	the second memory location behind it too. Otherwise the Linux
	kernel may map it in the upper memory so that we can't map
	the second part afterwards since it will conflict. */
	addr = mmap(NULL, 2*bytes, PROT_READ \| PROT_WRITE,
	MAP_SHARED, fd, 0);

	if (addr == MAP_FAILED)
	return -errno;

	addr_orig = addr;
	#else
	addr_orig = mmap(NULL, bytes << 1, PROT_NONE, flags, -1, 0);

	if (addr_orig == MAP_FAILED) {
	return -errno;
	}

	addr = mmap(addr_orig, bytes, PROT_READ \| PROT_WRITE,
	MAP_FIXED \| MAP_SHARED, fd, 0);
	#endif

	if (addr != addr_orig) {
	res = -errno;
	goto cleanup_fail;
	}
	#if defined(QB_BSD) && defined(MADV_NOSYNC)
	madvise(addr_orig, bytes, MADV_NOSYNC);
	#endif
	addr_next = ((char *)addr_orig) + bytes;
	addr = mmap(addr_next,
	bytes, PROT_READ \| PROT_WRITE,
	MAP_FIXED \| MAP_SHARED, fd, 0);
	if (addr != addr_next) {
	res = -errno;
	goto cleanup_fail;
	}
	#if defined(QB_BSD) && defined(MADV_NOSYNC)
	madvise(((char *)addr_orig) + bytes, bytes, MADV_NOSYNC);
	#endif

	res = close(fd);
	if (res) {
	goto cleanup_fail_noclose;
	}
	*buf = addr_orig;
	return 0;

	cleanup_fail:
	close(fd);

	cleanup_fail_noclose:
	if (addr_orig) {
	munmap(addr_orig, bytes << 1);
	}
	return res;
	}

	int32_t
	qb_sys_fd_nonblock_cloexec_set(int32_t fd)
	{
	int32_t res = 0;
	int32_t oldflags = fcntl(fd, F_GETFD, 0);

	if (oldflags < 0) {
	oldflags = 0;
	}
	oldflags \|= FD_CLOEXEC;
	res = fcntl(fd, F_SETFD, oldflags);
	if (res == -1) {
	res = -errno;
	qb_util_perror(LOG_ERR,
	"Could not set close-on-exit on fd:%d", fd);
	return res;
	}

	res = fcntl(fd, F_SETFL, O_NONBLOCK);
	if (res == -1) {
	res = -errno;
	qb_util_log(LOG_ERR, "Could not set non-blocking on fd:%d", fd);
	}

	return res;
	}

	int32_t
	qb_sys_unlink_or_truncate(const char *path, int32_t truncate_fallback)
	{
	int32_t res = 0;

	if (unlink(path) == -1) {
	res = errno;
	qb_util_perror(LOG_DEBUG,
	"Unlinking file: %s",
	path);
	if (res != ENOENT && truncate_fallback) {
	res = errno = 0;
	if (truncate(path, 0) == -1) {
	res = errno;
	qb_util_perror(LOG_DEBUG,
	"Truncating file: %s", path);
	}
	}
	}
	return -res;
	}

	#if defined(HAVE_OPENAT) && defined(HAVE_UNLINKAT)
	int32_t
	qb_sys_unlink_or_truncate_at(int32_t dirfd, const char *path,
	int32_t truncate_fallback)
	{
	int32_t fd, res = 0;

	if (unlinkat(dirfd, path, 0) == -1) {
	res = errno;
	qb_util_perror(LOG_DEBUG,
	"Unlinking file at dir: %s", path);
	if (res != ENOENT && truncate_fallback) {
	res = errno = 0;
	if ((fd = openat(dirfd, path, O_WRONLY\|O_TRUNC)) == -1) {
	res = errno;
	qb_util_perror(LOG_DEBUG,
	"Truncating file at dir: %s",
	path);
	} else {
	close(fd);
	}
	}
	}
	return -res;
	}
	#endif

	void
	qb_sigpipe_ctl(enum qb_sigpipe_ctl ctl)
	{
	#if !defined(HAVE_MSG_NOSIGNAL) && !defined(HAVE_SO_NOSIGPIPE)
	struct sigaction act;
	struct sigaction oact;

	act.sa_handler = SIG_IGN;

	if (ctl == QB_SIGPIPE_IGNORE) {
	sigaction(SIGPIPE, &act, &oact);
	} else {
	sigaction(SIGPIPE, &oact, NULL);
	}
	#endif /* !MSG_NOSIGNAL && !SO_NOSIGPIPE */
	}

	void
	qb_socket_nosigpipe(int32_t s)
	{
	#if !defined(HAVE_MSG_NOSIGNAL) && defined(HAVE_SO_NOSIGPIPE)
	int32_t on = 1;
	setsockopt(s, SOL_SOCKET, SO_NOSIGPIPE, (void *)&on, sizeof(on));
	#endif /* !MSG_NOSIGNAL && SO_NOSIGPIPE */
	}


	/*
	* atomic operations
	* --------------------------------------------------------------------------
	*/
	#ifndef HAVE_GCC_BUILTINS_FOR_SYNC_OPERATIONS
	/*
	* We have to use the slow, but safe locking method
	*/

	static qb_thread_lock_t *qb_atomic_mutex = NULL;

	void
	qb_atomic_init(void)
	{
	if (qb_atomic_mutex == NULL) {
	qb_atomic_mutex = qb_thread_lock_create(QB_THREAD_LOCK_SHORT);
	}
	assert(qb_atomic_mutex);
	}

	int32_t
	qb_atomic_int_exchange_and_add(volatile int32_t QB_GNUC_MAY_ALIAS * atomic,
	int32_t val)
	{
	int32_t result;

	qb_thread_lock(qb_atomic_mutex);
	result = *atomic;
	*atomic += val;
	qb_thread_unlock(qb_atomic_mutex);

	return result;
	}

	void
	qb_atomic_int_add(volatile int32_t QB_GNUC_MAY_ALIAS * atomic, int32_t val)
	{
	qb_thread_lock(qb_atomic_mutex);
	*atomic += val;
	qb_thread_unlock(qb_atomic_mutex);
	}

	int32_t
	qb_atomic_int_compare_and_exchange(volatile int32_t QB_GNUC_MAY_ALIAS * atomic,
	int32_t oldval, int32_t newval)
	{
	int32_t result;

	qb_thread_lock(qb_atomic_mutex);
	if (*atomic == oldval) {
	result = QB_TRUE;
	*atomic = newval;
	} else {
	result = QB_FALSE;
	}
	qb_thread_unlock(qb_atomic_mutex);

	return result;
	}

	int32_t
	qb_atomic_pointer_compare_and_exchange(volatile void QB_GNUC_MAY_ALIAS
	atomic, void oldval, void newval)
	{
	int32_t result;

	qb_thread_lock(qb_atomic_mutex);
	if (*atomic == oldval) {
	result = QB_TRUE;
	*atomic = newval;
	} else {
	result = QB_FALSE;
	}
	qb_thread_unlock(qb_atomic_mutex);

	return result;
	}

	#ifdef QB_ATOMIC_OP_MEMORY_BARRIER_NEEDED
	int32_t
	(qb_atomic_int_get) (volatile int32_t QB_GNUC_MAY_ALIAS * atomic)
	{
	int32_t result;

	qb_thread_lock(qb_atomic_mutex);
	result = *atomic;
	qb_thread_unlock(qb_atomic_mutex);

	return result;
	}

	void
	(qb_atomic_int_set) (volatile int32_t QB_GNUC_MAY_ALIAS * atomic,
	int32_t newval)
	{
	qb_thread_lock(qb_atomic_mutex);
	*atomic = newval;
	qb_thread_unlock(qb_atomic_mutex);
	}

	void *
	(qb_atomic_pointer_get) (volatile void QB_GNUC_MAY_ALIAS atomic)
	{
	void *result;

	qb_thread_lock(qb_atomic_mutex);
	result = (void)atomic;
	qb_thread_unlock(qb_atomic_mutex);

	return result;
	}

	void
	(qb_atomic_pointer_set) (volatile void QB_GNUC_MAY_ALIAS atomic,
	void *newval)
	{
	qb_thread_lock(qb_atomic_mutex);
	*atomic = newval;
	qb_thread_unlock(qb_atomic_mutex);
	}
	#endif /* QB_ATOMIC_OP_MEMORY_BARRIER_NEEDED */

	#else

	/*
	* gcc built-ins
	*/

	void
	qb_atomic_init(void)
	{
	}

	int32_t
	qb_atomic_int_exchange_and_add(volatile int32_t QB_GNUC_MAY_ALIAS * atomic,
	int32_t val)
	{
	return __sync_fetch_and_add(atomic, val);
	}

	void
	qb_atomic_int_add(volatile int32_t QB_GNUC_MAY_ALIAS * atomic, int32_t val)
	{
	__sync_fetch_and_add(atomic, val);
	}

	int32_t
	qb_atomic_int_compare_and_exchange(volatile int32_t QB_GNUC_MAY_ALIAS * atomic,
	int32_t oldval, int32_t newval)
	{
	return __sync_bool_compare_and_swap(atomic, oldval, newval);
	}

	int32_t
	qb_atomic_pointer_compare_and_exchange(volatile void QB_GNUC_MAY_ALIAS
	atomic, void oldval, void newval)
	{
	return __sync_bool_compare_and_swap(atomic, oldval, newval);
	}

	#ifdef QB_ATOMIC_OP_MEMORY_BARRIER_NEEDED
	#define QB_ATOMIC_MEMORY_BARRIER __sync_synchronize ()

	int32_t
	(qb_atomic_int_get) (volatile int32_t QB_GNUC_MAY_ALIAS * atomic)
	{
	QB_ATOMIC_MEMORY_BARRIER;
	return *atomic;
	}

	void
	(qb_atomic_int_set) (volatile int32_t QB_GNUC_MAY_ALIAS * atomic,
	int32_t newval)
	{
	*atomic = newval;
	QB_ATOMIC_MEMORY_BARRIER;
	}

	void *
	(qb_atomic_pointer_get) (volatile void QB_GNUC_MAY_ALIAS atomic)
	{
	QB_ATOMIC_MEMORY_BARRIER;
	return (void)atomic;
	}

	void
	(qb_atomic_pointer_set) (volatile void QB_GNUC_MAY_ALIAS atomic,
	void *newval)
	{
	*atomic = newval;
	QB_ATOMIC_MEMORY_BARRIER;
	}

	#endif /* QB_ATOMIC_OP_MEMORY_BARRIER_NEEDED */

	#endif /* HAVE_GCC_BUILTINS_FOR_SYNC_OPERATIONS */

	#ifndef QB_ATOMIC_OP_MEMORY_BARRIER_NEEDED
	int32_t
	(qb_atomic_int_get) (volatile int32_t QB_GNUC_MAY_ALIAS * atomic)
	{
	return qb_atomic_int_get(atomic);
	}

	void
	(qb_atomic_int_set) (volatile int32_t QB_GNUC_MAY_ALIAS * atomic,
	int32_t newval)
	{
	qb_atomic_int_set(atomic, newval);
	}

	void *
	(qb_atomic_pointer_get) (volatile void QB_GNUC_MAY_ALIAS atomic)
	{
	return qb_atomic_pointer_get(atomic);
	}

	void
	(qb_atomic_pointer_set) (volatile void QB_GNUC_MAY_ALIAS atomic,
	void *newval)
	{
	qb_atomic_pointer_set(atomic, newval);
	}
	#endif /* !QB_ATOMIC_OP_MEMORY_BARRIER_NEEDED */

File Metadata

Mime Type: text/x-diff
Expires: Sat, Nov 23, 6:18 AM (16 h, 22 s)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1018286
Default Alt Text: (42 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions