No OneTemporary
Actions

Size

45 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/configure.ac b/configure.ac
	index b8742e0..50e1549 100644
	--- a/configure.ac
	+++ b/configure.ac
	@@ -1,618 +1,624 @@

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

	AC_PREREQ([2.61])

	AC_INIT([libqb],
	m4_esyscmd([build-aux/git-version-gen .tarball-version]),
	[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])
	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])
	LT_INIT

	AC_CONFIG_MACRO_DIR([m4])

	AC_CANONICAL_HOST
	AC_PROG_LIBTOOL
	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
	AC_PROG_AWK
	AC_PROG_CC
	AC_PROG_CPP
	AM_PROG_CC_C_O
	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_PROGS([SPLINT], [splint])
	AM_CONDITIONAL(HAVE_SPLINT, test -n "${SPLINT}")

	## 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_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
	NONE) exec_prefix=$prefix;;
	prefix) exec_prefix=$prefix;;
	esac

	# Checks for libraries.
	dnl librt from glibc NEEDs libpthread
	dnl so. if test for libpthread after librt
	dnl it will always be "none needed", but it is not true
	dnl when linking libraries. Looks like a bug.
	AC_SEARCH_LIBS([pthread_create], [pthread])
	AC_SEARCH_LIBS([mq_open], [rt])
	AC_SEARCH_LIBS([dlopen], [dl])
	AC_SEARCH_LIBS([socket], [socket])
	AC_SEARCH_LIBS([gethostbyname], [nsl])

	# 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

	# Checks for header files.
	AC_HEADER_STDC
	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])
	]
	)


	AC_MSG_CHECKING(for MSG_NOSIGNAL)
	AC_TRY_COMPILE([#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_TRY_COMPILE([#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)])

	# Checks for library functions.
	AC_FUNC_CHOWN
	AC_FUNC_FORK
	AC_FUNC_MMAP
	AC_FUNC_STRERROR_R
	AC_CHECK_FUNCS([alarm clock_gettime ftruncate gettimeofday \
	localtime localtime_r memset munmap socket \
	strchr strrchr strdup strstr strcasecmp \
	poll epoll_create epoll_create1 kqueue \
	random rand getrlimit sysconf \
	pthread_spin_lock pthread_setschedparam \
	pthread_mutexattr_setpshared \
	pthread_condattr_setpshared \
	sem_timedwait semtimedop \
	sched_get_priority_max sched_setscheduler \
	getpeerucred getpeereid])

	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])

	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
	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])
	ac_cv_link_attribute_section=no
	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
	;;
	*)
	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])
	ac_cv_link_attribute_section=no
	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
	ac_cv_link_attribute_section=no
	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)
	# this is because dlopen within a dl_iterate_phdr
	# callback locks up.
	ac_cv_link_attribute_section=no
	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_cv_link_attribute_section=no
	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])
	;;
	*)
	AC_MSG_ERROR([Unsupported OS? hmmmm])
	;;
	esac

	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_TRY_LINK([],
	[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_TRY_LINK([],
	[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="-syntax -weak -unrecog +posixlib +ignoresigns -fcnuse \
	-badflag -D__gnuc_va_list=va_list -D__attribute$x$= \
	-warnposix +matchanyintegral -sysunrecog"

	# 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([coverage],
	[ --enable-coverage : coverage analysis of the codebase. ],
	[ default="no" ])

	AC_ARG_ENABLE([slow-tests],
	[ --enable-slow-tests : build and run slow tests. ],
	[ default="no" ])

	AC_ARG_WITH([socket-dir],
	[ --with-socket-dir=DIR : socket dir. ],
	[ SOCKETDIR="$withval" ],
	[ SOCKETDIR="$localstatedir/run" ])

	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
	shadow
	missing-prototypes
	missing-declarations
	strict-prototypes
	declaration-after-statement
	pointer-arith
	write-strings
	cast-align
	bad-function-cast
	missing-format-attribute
	format=2
	format-security
	no-format-nonliteral
	no-long-long
	unsigned-char
	gnu89-inline
	no-strict-aliasing
	"

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

	+# warnings suppression
	+if test x"$GCC" = xyes && cc_supports_flag -Wsuggest-attribute=format; then
	+ AC_DEFINE([HAVE_GCC_SUGGEST_ATTRIBUTE_FORMAT], [],
	+ [gcc supports -Wsuggest-attribute=format])
	+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

	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)

	# --- callsite sections ---
	if test "x${GCC}" = xyes; then
	AC_MSG_CHECKING([whether GCC supports __attribute__((section())])
	if test "x${ac_cv_link_attribute_section}" = x ; then
	AC_TRY_LINK([],
	[static int my_var __attribute__((section("__verbose"))) = 5;
	if (my_var == 5) return 0;
	else return -1;
	],
	[gcc_has_attribute_section=yes],
	[gcc_has_attribute_section=no])
	else
	gcc_has_attribute_section=${ac_cv_link_attribute_section}
	fi

	AC_MSG_RESULT($gcc_has_attribute_section)
	if test $gcc_has_attribute_section = yes; then
	AC_DEFINE([QB_HAVE_ATTRIBUTE_SECTION], 1,
	[Enabling code using __attribute__((section))])
	PACKAGE_FEATURES="$PACKAGE_FEATURES attribute-section"
	fi
	fi

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

	# final build of *FLAGS
	CFLAGS="$ENV_CFLAGS $OPT_CFLAGS $GDB_FLAGS \
	$COVERAGE_CFLAGS $EXTRA_WARNINGS $WERROR_CFLAGS"
	CPPFLAGS="$ENV_CPPFLAGS $ANSI_CPPFLAGS"
	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_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_CONFIG_FILES([Makefile
	include/Makefile
	include/qb/Makefile
	lib/Makefile
	lib/libqb.pc
	tools/Makefile
	tests/Makefile
	tests/test.conf
	examples/Makefile
	docs/Makefile
	docs/man.dox
	docs/html.dox])

	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([])
	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/log.c b/lib/log.c
	index 3336af9..b6eb3ce 100644
	--- a/lib/log.c
	+++ b/lib/log.c
	@@ -1,1116 +1,1125 @@
	/*
	* 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"
	#include <ctype.h>
	#ifdef HAVE_LINK_H
	#include <link.h>
	#endif /* HAVE_LINK_H */
	#include <stdarg.h>
	#include <pthread.h>
	#ifdef HAVE_DLFCN_H
	#include <dlfcn.h>
	#endif /* HAVE_DLFCN_H */
	#include <stdarg.h>
	#include <string.h>

	#include <qb/qbdefs.h>
	#include <qb/qblist.h>
	#include <qb/qblog.h>
	#include <qb/qbutil.h>
	#include <qb/qbarray.h>
	#include "log_int.h"
	#include "util_int.h"
	#include <regex.h>

	static struct qb_log_target conf[QB_LOG_TARGET_MAX];
	static uint32_t conf_active_max = 0;
	static int32_t in_logger = QB_FALSE;
	static int32_t logger_inited = QB_FALSE;
	static pthread_rwlock_t _listlock;
	static qb_log_filter_fn _custom_filter_fn = NULL;

	static QB_LIST_DECLARE(dlnames);
	static QB_LIST_DECLARE(tags_head);
	static QB_LIST_DECLARE(callsite_sections);

	struct dlname {
	char *dln_name;
	struct qb_list_head list;
	};

	struct callsite_section {
	struct qb_log_callsite *start;
	struct qb_log_callsite *stop;
	struct qb_list_head list;
	};

	static int32_t _log_target_enable(struct qb_log_target *t);
	static void _log_target_disable(struct qb_log_target *t);
	static void _log_filter_apply(struct callsite_section *sect,
	uint32_t t, enum qb_log_filter_conf c,
	enum qb_log_filter_type type,
	const char *text,
	regex_t *regex,
	uint8_t high_priority, uint8_t low_priority);
	static void _log_filter_apply_to_cs(struct qb_log_callsite *cs,
	uint32_t t, enum qb_log_filter_conf c,
	enum qb_log_filter_type type,
	const char *text,
	regex_t *regex,
	uint8_t high_priority, uint8_t low_priority);

	/* deprecated method of getting internal log messages */
	static qb_util_log_fn_t old_internal_log_fn = NULL;
	void
	qb_util_set_log_function(qb_util_log_fn_t fn)
	{
	old_internal_log_fn = fn;
	}

	static void
	_log_free_filter(struct qb_log_filter *flt)
	{
	if (flt->regex) {
	regfree(flt->regex);
	}
	free(flt->regex);
	free(flt->text);
	free(flt);
	}

	static int32_t
	_cs_matches_filter_(struct qb_log_callsite *cs,
	enum qb_log_filter_type type,
	const char *text,
	regex_t *regex,
	uint8_t high_priority,
	uint8_t low_priority)
	{
	int32_t match = QB_FALSE;
	const char *offset = NULL;
	const char *next = NULL;

	if (cs->priority > low_priority \|\|
	cs->priority < high_priority) {
	return QB_FALSE;
	}
	if (strcmp(text, "*") == 0) {
	return QB_TRUE;
	}

	switch (type) {
	case QB_LOG_FILTER_FILE:
	case QB_LOG_FILTER_FUNCTION:
	next = text;
	do {
	char token[500];
	offset = next;
	next = strchrnul(offset, ',');
	snprintf(token, 499, "%.*s", (int)(next - offset), offset);

	if (type == QB_LOG_FILTER_FILE) {
	match = (strcmp(cs->filename, token) == 0) ? 1 : 0;
	} else {
	match = (strcmp(cs->function, token) == 0) ? 1 : 0;
	}
	if (!match && next[0] != 0) {
	next++;
	}

	} while (match == QB_FALSE && next != NULL && next[0] != 0);
	break;
	case QB_LOG_FILTER_FILE_REGEX:
	next = next ? next : cs->filename;
	case QB_LOG_FILTER_FUNCTION_REGEX:
	next = next ? next : cs->function;
	case QB_LOG_FILTER_FORMAT_REGEX:
	next = next ? next : cs->format;

	if (regex == NULL) {
	return QB_FALSE;
	}
	match = regexec(regex, next, 0, NULL, 0);
	if (match == 0) {
	match = QB_TRUE;
	} else {
	match = QB_FALSE;
	}
	break;
	case QB_LOG_FILTER_FORMAT:
	if (strstr(cs->format, text)) {
	match = QB_TRUE;
	}
	break;
	}

	return match;
	}

	/**
	* @internal
	* @brief Format a log message into a string buffer
	*
	* @param[out] str Destination buffer to contain formatted string
	* @param[in] cs Callsite containing format to use
	* @param[in] ap Variable arguments for format
	*/
	+#ifdef HAVE_GCC_SUGGEST_ATTRIBUTE_FORMAT
	+/* suppress suggestion that we currently can do nothing better about
	+ as the format specification is hidden in cs argument */
	+#pragma GCC diagnostic push
	+#pragma GCC diagnostic ignored "-Wsuggest-attribute=format"
	+#endif
	static inline void
	cs_format(char str, struct qb_log_callsite cs, va_list ap)
	{
	va_list ap_copy;
	int len;

	va_copy(ap_copy, ap);
	len = vsnprintf(str, QB_LOG_MAX_LEN, cs->format, ap_copy);
	va_end(ap_copy);
	if (len > QB_LOG_MAX_LEN) {
	len = QB_LOG_MAX_LEN;
	}
	if (str[len - 1] == '\n') {
	str[len - 1] = '\0';
	}
	}
	+#ifdef HAVE_GCC_SUGGEST_ATTRIBUTE_FORMAT
	+#pragma GCC diagnostic pop
	+#endif

	void
	qb_log_real_va_(struct qb_log_callsite *cs, va_list ap)
	{
	int32_t found_threaded = QB_FALSE;
	struct qb_log_target *t;
	struct timespec tv;
	int32_t pos;
	int32_t formatted = QB_FALSE;
	char buf[QB_LOG_MAX_LEN];
	char *str = buf;
	va_list ap_copy;

	if (in_logger \|\| cs == NULL) {
	return;
	}
	in_logger = QB_TRUE;

	if (old_internal_log_fn &&
	qb_bit_is_set(cs->tags, QB_LOG_TAG_LIBQB_MSG_BIT)) {
	if (formatted == QB_FALSE) {
	cs_format(str, cs, ap);
	formatted = QB_TRUE;
	}
	qb_do_extended(str, QB_TRUE,
	old_internal_log_fn(cs->filename, cs->lineno,
	cs->priority, str));
	}

	qb_util_timespec_from_epoch_get(&tv);

	/*
	* 1 if we can find a threaded target that needs this log then post it
	* 2 foreach non-threaded target call it's logger function
	*/
	for (pos = 0; pos <= conf_active_max; pos++) {
	t = &conf[pos];
	if ((t->state == QB_LOG_STATE_ENABLED)
	&& qb_bit_is_set(cs->targets, pos)) {
	if (t->threaded) {
	if (!found_threaded) {
	found_threaded = QB_TRUE;
	if (formatted == QB_FALSE) {
	cs_format(str, cs, ap);
	formatted = QB_TRUE;
	}
	}

	} else if (t->vlogger) {
	va_copy(ap_copy, ap);
	t->vlogger(t->pos, cs, tv.tv_sec, ap_copy);
	va_end(ap_copy);

	} else if (t->logger) {
	if (formatted == QB_FALSE) {
	cs_format(str, cs, ap);
	formatted = QB_TRUE;
	}
	qb_do_extended(str, t->extended,
	t->logger(t->pos, cs, tv.tv_sec, str));
	}
	}
	}

	if (found_threaded) {
	qb_log_thread_log_post(cs, tv.tv_sec, str);
	}
	in_logger = QB_FALSE;
	}

	void
	qb_log_real_(struct qb_log_callsite *cs, ...)
	{
	va_list ap;

	va_start(ap, cs);
	qb_log_real_va_(cs, ap);
	va_end(ap);
	}

	void
	qb_log_thread_log_write(struct qb_log_callsite *cs,
	time_t timestamp, const char *buffer)
	{
	struct qb_log_target *t;
	int32_t pos;

	for (pos = 0; pos <= conf_active_max; pos++) {
	t = &conf[pos];
	if ((t->state == QB_LOG_STATE_ENABLED) && t->threaded
	&& qb_bit_is_set(cs->targets, t->pos)) {
	qb_do_extended(buffer, t->extended,
	t->logger(t->pos, cs, timestamp, buffer));
	}
	}
	}

	struct qb_log_callsite*
	qb_log_callsite_get(const char *function,
	const char *filename,
	const char *format,
	uint8_t priority,
	uint32_t lineno,
	uint32_t tags)
	{
	struct qb_log_target *t;
	struct qb_log_filter *flt;
	struct qb_log_callsite *cs;
	int32_t new_dcs = QB_FALSE;
	struct qb_list_head *f_item;
	int32_t pos;

	if (!logger_inited) {
	return NULL;
	}

	cs = qb_log_dcs_get(&new_dcs, function, filename,
	format, priority, lineno, tags);
	if (cs == NULL) {
	return NULL;
	}

	if (new_dcs) {
	pthread_rwlock_rdlock(&_listlock);
	for (pos = 0; pos <= conf_active_max; pos++) {
	t = &conf[pos];
	if (t->state != QB_LOG_STATE_ENABLED) {
	continue;
	}
	qb_list_for_each(f_item, &t->filter_head) {
	flt = qb_list_entry(f_item, struct qb_log_filter, list);
	_log_filter_apply_to_cs(cs, t->pos, flt->conf, flt->type,
	flt->text, flt->regex, flt->high_priority,
	flt->low_priority);
	}
	}
	if (tags == 0) {
	qb_list_for_each(f_item, &tags_head) {
	flt = qb_list_entry(f_item, struct qb_log_filter, list);
	_log_filter_apply_to_cs(cs, flt->new_value, flt->conf, flt->type,
	flt->text, flt->regex, flt->high_priority,
	flt->low_priority);
	}
	} else {
	cs->tags = tags;
	}
	if (_custom_filter_fn) {
	_custom_filter_fn(cs);
	}
	pthread_rwlock_unlock(&_listlock);
	} else if (cs->tags != tags) {
	cs->tags = tags;
	if (_custom_filter_fn) {
	_custom_filter_fn(cs);
	}
	}
	return cs;
	}

	void
	qb_log_from_external_source_va(const char *function,
	const char *filename,
	const char *format,
	uint8_t priority,
	uint32_t lineno, uint32_t tags, va_list ap)
	{
	struct qb_log_callsite *cs;

	if (!logger_inited) {
	return;
	}

	cs = qb_log_callsite_get(function, filename,
	format, priority, lineno, tags);
	qb_log_real_va_(cs, ap);
	}

	void
	qb_log_from_external_source(const char *function,
	const char *filename,
	const char *format,
	uint8_t priority,
	uint32_t lineno, uint32_t tags, ...)
	{
	struct qb_log_callsite *cs;
	va_list ap;

	if (!logger_inited) {
	return;
	}

	cs = qb_log_callsite_get(function, filename,
	format, priority, lineno, tags);
	va_start(ap, tags);
	qb_log_real_va_(cs, ap);
	va_end(ap);
	}

	int32_t
	qb_log_callsites_register(struct qb_log_callsite *_start,
	struct qb_log_callsite *_stop)
	{
	struct callsite_section *sect;
	struct qb_log_callsite *cs;
	struct qb_log_target *t;
	struct qb_log_filter *flt;
	int32_t pos;

	if (_start == NULL \|\| _stop == NULL) {
	return -EINVAL;
	}

	pthread_rwlock_rdlock(&_listlock);
	qb_list_for_each_entry(sect, &callsite_sections, list) {
	if (sect->start == _start \|\| sect->stop == _stop) {
	pthread_rwlock_unlock(&_listlock);
	return -EEXIST;
	}
	}
	pthread_rwlock_unlock(&_listlock);

	sect = calloc(1, sizeof(struct callsite_section));
	if (sect == NULL) {
	return -ENOMEM;
	}
	sect->start = _start;
	sect->stop = _stop;
	qb_list_init(&sect->list);

	pthread_rwlock_wrlock(&_listlock);
	qb_list_add(&sect->list, &callsite_sections);

	/*
	* Now apply the filters on these new callsites
	*/
	for (pos = 0; pos <= conf_active_max; pos++) {
	t = &conf[pos];
	if (t->state != QB_LOG_STATE_ENABLED) {
	continue;
	}
	qb_list_for_each_entry(flt, &t->filter_head, list) {
	_log_filter_apply(sect, t->pos, flt->conf,
	flt->type, flt->text, flt->regex,
	flt->high_priority, flt->low_priority);
	}
	}
	qb_list_for_each_entry(flt, &tags_head, list) {
	_log_filter_apply(sect, flt->new_value, flt->conf,
	flt->type, flt->text, flt->regex,
	flt->high_priority, flt->low_priority);
	}
	pthread_rwlock_unlock(&_listlock);
	if (_custom_filter_fn) {
	for (cs = sect->start; cs < sect->stop; cs++) {
	if (cs->lineno > 0) {
	_custom_filter_fn(cs);
	}
	}
	}
	/* qb_log_callsites_dump_sect(sect); */

	return 0;
	}

	static void
	qb_log_callsites_dump_sect(struct callsite_section *sect)
	{
	struct qb_log_callsite *cs;

	printf(" start %p - stop %p\n", sect->start, sect->stop);
	printf("filename lineno targets tags\n");
	for (cs = sect->start; cs < sect->stop; cs++) {
	if (cs->lineno > 0) {
	printf("%12s %6d %16d %16d\n", cs->filename, cs->lineno,
	cs->targets, cs->tags);
	}
	}
	}

	void
	qb_log_callsites_dump(void)
	{
	struct callsite_section *sect;
	int32_t l;

	pthread_rwlock_rdlock(&_listlock);
	l = qb_list_length(&callsite_sections);
	printf("Callsite Database [%d]\n", l);
	printf("---------------------\n");
	qb_list_for_each_entry(sect, &callsite_sections, list) {
	qb_log_callsites_dump_sect(sect);
	}
	pthread_rwlock_unlock(&_listlock);
	}

	static int32_t
	_log_filter_exists(struct qb_list_head *list_head,
	enum qb_log_filter_type type,
	const char *text,
	uint8_t high_priority,
	uint8_t low_priority,
	uint32_t new_value)
	{
	struct qb_log_filter *flt;

	qb_list_for_each_entry(flt, list_head, list) {
	if (flt->type == type &&
	flt->high_priority == high_priority &&
	flt->low_priority == low_priority &&
	flt->new_value == new_value &&
	strcmp(flt->text, text) == 0) {
	return QB_TRUE;
	}
	}
	return QB_FALSE;
	}

	static int32_t
	_log_filter_store(uint32_t t, enum qb_log_filter_conf c,
	enum qb_log_filter_type type,
	const char *text,
	uint8_t high_priority,
	uint8_t low_priority,
	struct qb_log_filter **new)
	{
	struct qb_log_filter *flt;
	struct qb_list_head *iter;
	struct qb_list_head *next;
	struct qb_list_head *list_head;

	switch (c) {
	case QB_LOG_FILTER_ADD:
	case QB_LOG_FILTER_REMOVE:
	case QB_LOG_FILTER_CLEAR_ALL:
	list_head = &conf[t].filter_head;
	break;

	case QB_LOG_TAG_SET:
	case QB_LOG_TAG_CLEAR:
	case QB_LOG_TAG_CLEAR_ALL:
	list_head = &tags_head;
	break;
	default:
	return -ENOSYS;
	}

	if (c == QB_LOG_FILTER_ADD \|\| c == QB_LOG_TAG_SET) {
	if (text == NULL) {
	return -EINVAL;
	}
	if (_log_filter_exists(list_head, type, text,
	high_priority, low_priority, t)) {
	return -EEXIST;
	}
	flt = calloc(1, sizeof(struct qb_log_filter));
	if (flt == NULL) {
	return -ENOMEM;
	}
	qb_list_init(&flt->list);
	flt->conf = c;
	flt->type = type;
	flt->text = strdup(text);
	if (flt->text == NULL) {
	_log_free_filter(flt);
	return -ENOMEM;
	}

	if (type == QB_LOG_FILTER_FUNCTION_REGEX \|\|
	type == QB_LOG_FILTER_FILE_REGEX \|\|
	type == QB_LOG_FILTER_FORMAT_REGEX) {
	int res;

	flt->regex = calloc(1, sizeof(regex_t));
	if (flt->regex == NULL) {
	_log_free_filter(flt);
	return -ENOMEM;
	}
	res = regcomp(flt->regex, flt->text, 0);
	if (res) {
	_log_free_filter(flt);
	return -EINVAL;
	}
	}
	flt->high_priority = high_priority;
	flt->low_priority = low_priority;
	flt->new_value = t;
	qb_list_add_tail(&flt->list, list_head);
	if (new) {
	*new = flt;
	}
	} else if (c == QB_LOG_FILTER_REMOVE \|\| c == QB_LOG_TAG_CLEAR) {
	qb_list_for_each_safe(iter, next, list_head) {
	flt = qb_list_entry(iter, struct qb_log_filter, list);
	if (flt->type == type &&
	flt->low_priority <= low_priority &&
	flt->high_priority >= high_priority &&
	(strcmp(flt->text, text) == 0 \|\|
	strcmp("*", text) == 0)) {
	qb_list_del(iter);
	_log_free_filter(flt);
	return 0;
	}
	}

	} else if (c == QB_LOG_FILTER_CLEAR_ALL \|\| c == QB_LOG_TAG_CLEAR_ALL) {
	qb_list_for_each_safe(iter, next, list_head) {
	flt = qb_list_entry(iter, struct qb_log_filter, list);
	qb_list_del(iter);
	_log_free_filter(flt);
	}
	}
	return 0;
	}

	static void
	_log_filter_apply(struct callsite_section *sect,
	uint32_t t, enum qb_log_filter_conf c,
	enum qb_log_filter_type type,
	const char *text,
	regex_t *regex,
	uint8_t high_priority, uint8_t low_priority)
	{
	struct qb_log_callsite *cs;

	for (cs = sect->start; cs < sect->stop; cs++) {
	if (cs->lineno > 0) {
	_log_filter_apply_to_cs(cs, t, c, type, text, regex,
	high_priority, low_priority);
	}
	}
	}

	/* #define _QB_FILTER_DEBUGGING_ 1 */
	static void
	_log_filter_apply_to_cs(struct qb_log_callsite *cs,
	uint32_t t, enum qb_log_filter_conf c,
	enum qb_log_filter_type type,
	const char *text,
	regex_t *regex,
	uint8_t high_priority, uint8_t low_priority)
	{

	if (c == QB_LOG_FILTER_CLEAR_ALL) {
	qb_bit_clear(cs->targets, t);
	return;
	} else if (c == QB_LOG_TAG_CLEAR_ALL) {
	cs->tags = 0;
	return;
	}

	if (_cs_matches_filter_(cs, type, text, regex, high_priority, low_priority)) {
	#ifdef _QB_FILTER_DEBUGGING_
	uint32_t old_targets = cs->targets;
	uint32_t old_tags = cs->tags;
	#endif /* _QB_FILTER_DEBUGGING_ */
	if (c == QB_LOG_FILTER_ADD) {
	qb_bit_set(cs->targets, t);
	} else if (c == QB_LOG_FILTER_REMOVE) {
	qb_bit_clear(cs->targets, t);
	} else if (c == QB_LOG_TAG_SET) {
	cs->tags = t;
	} else if (c == QB_LOG_TAG_CLEAR) {
	cs->tags = 0;
	}
	#ifdef _QB_FILTER_DEBUGGING_
	if (old_targets != cs->targets) {
	printf("targets: %s:%u value(%d) %d -> %d\n",
	cs->filename, cs->lineno, t,
	old_targets, cs->targets);
	}
	if (old_tags != cs->tags) {
	printf("tags: %s:%u value(%d) %d -> %d\n",
	cs->filename, cs->lineno, t, old_tags, cs->tags);
	}
	#endif /* _QB_FILTER_DEBUGGING_ */
	}
	}

	int32_t
	qb_log_filter_ctl2(int32_t t, enum qb_log_filter_conf c,
	enum qb_log_filter_type type, const char * text,
	uint8_t high_priority, uint8_t low_priority)
	{
	struct qb_log_filter *new_flt = NULL;
	regex_t *regex = NULL;
	struct callsite_section *sect;
	int32_t rc;

	if (!logger_inited) {
	return -EINVAL;
	}

	if (c == QB_LOG_FILTER_ADD \|\|
	c == QB_LOG_FILTER_CLEAR_ALL \|\|
	c == QB_LOG_FILTER_REMOVE) {
	if (t < 0 \|\| t >= QB_LOG_TARGET_MAX \|\|
	conf[t].state == QB_LOG_STATE_UNUSED) {
	return -EBADF;
	}
	}

	if (text == NULL \|\|
	low_priority < high_priority \|\|
	type > QB_LOG_FILTER_FORMAT_REGEX \|\|
	c > QB_LOG_TAG_CLEAR_ALL) {
	return -EINVAL;
	}
	pthread_rwlock_rdlock(&_listlock);
	rc = _log_filter_store(t, c, type, text, high_priority, low_priority, &new_flt);
	if (rc < 0) {
	pthread_rwlock_unlock(&_listlock);
	return rc;
	}

	if (new_flt && new_flt->regex) {
	regex = new_flt->regex;
	}
	qb_list_for_each_entry(sect, &callsite_sections, list) {
	_log_filter_apply(sect, t, c, type, text, regex, high_priority, low_priority);
	}
	pthread_rwlock_unlock(&_listlock);
	return 0;
	}

	int32_t
	qb_log_filter_fn_set(qb_log_filter_fn fn)
	{
	struct callsite_section *sect;
	struct qb_log_callsite *cs;

	if (!logger_inited) {
	return -EINVAL;
	}
	_custom_filter_fn = fn;
	if (_custom_filter_fn == NULL) {
	return 0;
	}

	qb_list_for_each_entry(sect, &callsite_sections, list) {
	for (cs = sect->start; cs < sect->stop; cs++) {
	if (cs->lineno > 0) {
	_custom_filter_fn(cs);
	}
	}
	}
	return 0;
	}

	int32_t
	qb_log_filter_ctl(int32_t t, enum qb_log_filter_conf c,
	enum qb_log_filter_type type,
	const char *text, uint8_t priority)
	{
	return qb_log_filter_ctl2(t, c, type, text, LOG_EMERG, priority);
	}

	#ifdef QB_HAVE_ATTRIBUTE_SECTION
	/* Some platforms (eg. FreeBSD 10+) don't support calling dlopen() from
	* within a dl_iterate_phdr() callback; so save all of the dlpi_names to
	* a list and iterate over them afterwards. */
	static int32_t
	_log_so_walk_callback(struct dl_phdr_info info, size_t size, void data)
	{
	struct dlname *dlname;

	if (strlen(info->dlpi_name) > 0) {
	dlname = calloc(1, sizeof(struct dlname));
	if (!dlname)
	return 0;
	dlname->dln_name = strdup(info->dlpi_name);
	qb_list_add_tail(&dlname->list, &dlnames);
	}

	return 0;
	}

	static void
	_log_so_walk_dlnames(void)
	{
	struct dlname *dlname;
	struct qb_list_head *iter;
	struct qb_list_head *next;

	void *handle;
	void *start;
	void *stop;
	const char *error;

	qb_list_for_each_safe(iter, next, &dlnames) {
	dlname = qb_list_entry(iter, struct dlname, list);

	handle = dlopen(dlname->dln_name, RTLD_LAZY);
	error = dlerror();
	if (!handle \|\| error) {
	qb_log(LOG_ERR, "%s", error);
	goto done;
	}

	start = dlsym(handle, "__start___verbose");
	error = dlerror();
	if (error) {
	goto done;
	}

	stop = dlsym(handle, "__stop___verbose");
	error = dlerror();
	if (error) {
	goto done;

	} else {
	qb_log_callsites_register(start, stop);
	}
	done:
	if (handle)
	dlclose(handle);
	qb_list_del(iter);
	if (dlname->dln_name)
	free(dlname->dln_name);
	free(dlname);
	}
	}
	#endif /* QB_HAVE_ATTRIBUTE_SECTION */

	static void
	_log_target_state_set(struct qb_log_target *t, enum qb_log_target_state s)
	{
	int32_t i;
	int32_t a_set = QB_FALSE;
	int32_t u_set = QB_FALSE;

	t->state = s;

	for (i = 31; i >= 0; i--) {
	if (!a_set && conf[i].state == QB_LOG_STATE_ENABLED) {
	a_set = QB_TRUE;
	conf_active_max = i;
	}
	if (!u_set && conf[i].state != QB_LOG_STATE_UNUSED) {
	u_set = QB_TRUE;
	}
	}
	}

	void
	qb_log_init(const char *name, int32_t facility, uint8_t priority)
	{
	int32_t i;

	i = pthread_rwlock_init(&_listlock, NULL);
	assert(i == 0);
	qb_log_format_init();

	for (i = 0; i < QB_LOG_TARGET_MAX; i++) {
	conf[i].pos = i;
	conf[i].debug = QB_FALSE;
	conf[i].file_sync = QB_FALSE;
	conf[i].extended = QB_TRUE;
	conf[i].state = QB_LOG_STATE_UNUSED;
	(void)strlcpy(conf[i].name, name, PATH_MAX);
	conf[i].facility = facility;
	qb_list_init(&conf[i].filter_head);
	}

	qb_log_dcs_init();
	#ifdef QB_HAVE_ATTRIBUTE_SECTION
	qb_log_callsites_register(__start___verbose, __stop___verbose);
	dl_iterate_phdr(_log_so_walk_callback, NULL);
	_log_so_walk_dlnames();
	#endif /* QB_HAVE_ATTRIBUTE_SECTION */

	conf[QB_LOG_STDERR].state = QB_LOG_STATE_DISABLED;
	conf[QB_LOG_BLACKBOX].state = QB_LOG_STATE_DISABLED;
	conf[QB_LOG_STDOUT].state = QB_LOG_STATE_DISABLED;

	logger_inited = QB_TRUE;
	(void)qb_log_syslog_open(&conf[QB_LOG_SYSLOG]);
	_log_target_state_set(&conf[QB_LOG_SYSLOG], QB_LOG_STATE_ENABLED);
	(void)qb_log_filter_ctl(QB_LOG_SYSLOG, QB_LOG_FILTER_ADD,
	QB_LOG_FILTER_FILE, "*", priority);
	}

	void
	qb_log_fini(void)
	{
	struct qb_log_target *t;
	struct qb_log_filter *flt;
	struct callsite_section *s;
	struct qb_list_head *iter;
	struct qb_list_head *iter2;
	struct qb_list_head *next;
	struct qb_list_head *next2;
	int32_t pos;

	if (!logger_inited) {
	return;
	}
	logger_inited = QB_FALSE;
	qb_log_thread_stop();
	pthread_rwlock_destroy(&_listlock);

	for (pos = 0; pos <= conf_active_max; pos++) {
	t = &conf[pos];
	_log_target_disable(t);
	qb_list_for_each_safe(iter2, next2, &t->filter_head) {
	flt = qb_list_entry(iter2, struct qb_log_filter, list);
	qb_list_del(iter2);
	_log_free_filter(flt);
	}
	}
	qb_log_format_fini();
	qb_log_dcs_fini();
	qb_list_for_each_safe(iter, next, &callsite_sections) {
	s = qb_list_entry(iter, struct callsite_section, list);
	qb_list_del(iter);
	free(s);
	}
	qb_list_for_each_safe(iter, next, &tags_head) {
	flt = qb_list_entry(iter, struct qb_log_filter, list);
	qb_list_del(iter);
	_log_free_filter(flt);
	}
	}

	struct qb_log_target *
	qb_log_target_alloc(void)
	{
	int32_t i;
	for (i = 0; i < QB_LOG_TARGET_MAX; i++) {
	if (conf[i].state == QB_LOG_STATE_UNUSED) {
	_log_target_state_set(&conf[i], QB_LOG_STATE_DISABLED);
	return &conf[i];
	}
	}
	return NULL;
	}

	void
	qb_log_target_free(struct qb_log_target *t)
	{
	(void)qb_log_filter_ctl(t->pos, QB_LOG_FILTER_CLEAR_ALL,
	QB_LOG_FILTER_FILE, NULL, 0);
	t->debug = QB_FALSE;
	t->filename[0] = '\0';
	qb_log_format_set(t->pos, NULL);
	_log_target_state_set(t, QB_LOG_STATE_UNUSED);
	}

	struct qb_log_target *
	qb_log_target_get(int32_t pos)
	{
	return &conf[pos];
	}

	void *
	qb_log_target_user_data_get(int32_t t)
	{
	if (t < 0 \|\| t >= QB_LOG_TARGET_MAX \|\|
	conf[t].state == QB_LOG_STATE_UNUSED) {
	errno = -EBADF;
	return NULL;
	}

	return conf[t].instance;
	}

	int32_t
	qb_log_target_user_data_set(int32_t t, void *user_data)
	{
	if (!logger_inited) {
	return -EINVAL;
	}
	if (t < 0 \|\| t >= QB_LOG_TARGET_MAX \|\|
	conf[t].state == QB_LOG_STATE_UNUSED) {
	return -EBADF;
	}

	conf[t].instance = user_data;
	return 0;
	}

	int32_t
	qb_log_custom_open(qb_log_logger_fn log_fn,
	qb_log_close_fn close_fn,
	qb_log_reload_fn reload_fn, void *user_data)
	{
	struct qb_log_target *t;

	t = qb_log_target_alloc();
	if (t == NULL) {
	return -errno;
	}

	t->instance = user_data;
	snprintf(t->filename, PATH_MAX, "custom-%d", t->pos);

	t->logger = log_fn;
	t->vlogger = NULL;
	t->reload = reload_fn;
	t->close = close_fn;

	return t->pos;
	}

	void
	qb_log_custom_close(int32_t t)
	{
	struct qb_log_target *target;

	if (!logger_inited) {
	return;
	}
	if (t < 0 \|\| t >= QB_LOG_TARGET_MAX \|\|
	conf[t].state == QB_LOG_STATE_UNUSED) {
	return;
	}

	target = qb_log_target_get(t);

	if (target->close) {
	in_logger = QB_TRUE;
	target->close(t);
	in_logger = QB_FALSE;
	}
	qb_log_target_free(target);
	}

	static int32_t
	_log_target_enable(struct qb_log_target *t)
	{
	int32_t rc = 0;

	if (t->state == QB_LOG_STATE_ENABLED) {
	return 0;
	}
	if (t->pos == QB_LOG_STDERR \|\|
	t->pos == QB_LOG_STDOUT) {
	rc = qb_log_stderr_open(t);
	} else if (t->pos == QB_LOG_SYSLOG) {
	rc = qb_log_syslog_open(t);
	} else if (t->pos == QB_LOG_BLACKBOX) {
	rc = qb_log_blackbox_open(t);
	}
	if (rc == 0) {
	_log_target_state_set(t, QB_LOG_STATE_ENABLED);
	}
	return rc;
	}

	static void
	_log_target_disable(struct qb_log_target *t)
	{
	if (t->state != QB_LOG_STATE_ENABLED) {
	return;
	}
	_log_target_state_set(t, QB_LOG_STATE_DISABLED);
	if (t->close) {
	in_logger = QB_TRUE;
	t->close(t->pos);
	in_logger = QB_FALSE;
	}
	}

	int32_t
	qb_log_ctl(int32_t t, enum qb_log_conf c, int32_t arg)
	{
	int32_t rc = 0;
	int32_t need_reload = QB_FALSE;

	if (!logger_inited) {
	return -EINVAL;
	}
	if (t < 0 \|\| t >= QB_LOG_TARGET_MAX \|\|
	conf[t].state == QB_LOG_STATE_UNUSED) {
	return -EBADF;
	}
	switch (c) {
	case QB_LOG_CONF_ENABLED:
	if (arg) {
	rc = _log_target_enable(&conf[t]);
	} else {
	_log_target_disable(&conf[t]);
	}
	break;
	case QB_LOG_CONF_STATE_GET:
	rc = conf[t].state;
	break;
	case QB_LOG_CONF_FACILITY:
	conf[t].facility = arg;
	if (t == QB_LOG_SYSLOG) {
	need_reload = QB_TRUE;
	}
	break;
	case QB_LOG_CONF_FILE_SYNC:
	conf[t].file_sync = arg;
	break;
	case QB_LOG_CONF_PRIORITY_BUMP:
	conf[t].priority_bump = arg;
	break;
	case QB_LOG_CONF_SIZE:
	if (t == QB_LOG_BLACKBOX) {
	if (arg <= 0) {
	return -EINVAL;
	}
	conf[t].size = arg;
	need_reload = QB_TRUE;
	} else {
	return -ENOSYS;
	}
	break;
	case QB_LOG_CONF_THREADED:
	conf[t].threaded = arg;
	break;
	case QB_LOG_CONF_EXTENDED:
	conf[t].extended = arg;
	break;

	default:
	rc = -EINVAL;
	}
	if (rc == 0 && need_reload && conf[t].reload) {
	in_logger = QB_TRUE;
	conf[t].reload(t);
	in_logger = QB_FALSE;
	}
	return rc;
	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Feb 24, 7:14 PM (4 h, 35 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1464414
Default Alt Text: (45 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions